├── composer.json
├── src
    ├── functions.php
    └── Neko.php
├── LICENSE.md
└── README.md


/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "yuloh/neko",
 3 |     "description": "Simple helpers for case transformations.",
 4 |     "require": {
 5 |         "php": ">=5.6.4"
 6 |     },
 7 |     "require-dev": {
 8 |         "phpunit/phpunit": "^5.2"
 9 |     },
10 |     "license": "MIT",
11 |     "authors": [
12 |         {
13 |             "name": "Matt Allan",
14 |             "email": "matthew.james.allan@gmail.com"
15 |         }
16 |     ],
17 |     "autoload": {
18 |         "psr-4": {
19 |             "Yuloh\\Neko\\": "src"
20 |         },
21 |         "files": [
22 |             "src/functions.php"
23 |         ]
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Yuloh\Neko;
 4 | 
 5 | use Yuloh\Neko\Neko;
 6 | 
 7 | /**
 8 |  * Convert a value to snake_case.
 9 |  *
10 |  * @param  string $value
11 |  * @return string
12 |  */
13 | function snake_case($value)
14 | {
15 |     return Neko::snakeCase($value);
16 | }
17 | 
18 | /**
19 |  * Convert a value to kebab-case.
20 |  *
21 |  * @param  string $value
22 |  * @return string
23 |  */
24 | function kebab_case($value)
25 | {
26 |     return Neko::kebabCase($value);
27 | }
28 | 
29 | /**
30 |  * Convert a value to PascalCase.
31 |  *
32 |  * @param  string $value
33 |  * @return string
34 |  */
35 | function pascal_case($value)
36 | {
37 |     return Neko::pascalCase($value);
38 | }
39 | 
40 | /**
41 |  * Convert a value to camelCase.
42 |  *
43 |  * @param  string $value
44 |  * @return string
45 |  */
46 | function camel_case($value)
47 | {
48 |     return Neko::camelCase($value);
49 | }
50 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | # The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Matthew Allan matthew.james.allan@gmail.com
 4 | 
 5 | > Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | > of this software and associated documentation files (the "Software"), to deal
 7 | > in the Software without restriction, including without limitation the rights
 8 | > to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | > copies of the Software, and to permit persons to whom the Software is
10 | > furnished to do so, subject to the following conditions:
11 | >
12 | > The above copyright notice and this permission notice shall be included in
13 | > all copies or substantial portions of the Software.
14 | >
15 | > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | > IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | > FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | > AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | > THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Neko - Case tranformation functions for PHP
 2 | 
 3 | Neko is a small collection of case tranformation functions for PHP.  They are as simple as possible with no external dependencies.
 4 | 
 5 | I wrote this library because I was tired of the other libraries out there not working like I expected.  Neko can handle input in Title case, lower case, PascalCase, camelCase, kebab-case, SCREAMING-KEBAB-CASE, snake_case, and SCREAMING_SNAKE_CASE.
 6 | 
 7 | You can see how Neko stacks up against other case transformation libraries in the throwdown [over here](https://github.com/yuloh/case-transform-tests).
 8 | 
 9 | ## Install
10 | 
11 | Neko can be installed using [composer](getcomposer.org).
12 | 
13 | ``` bash
14 | $ composer require yuloh/neko
15 | ```
16 | 
17 | ## Usage
18 | 
19 | ### Snake Case
20 | 
21 | ```php
22 | use function Yuloh\Neko\snake_case;
23 | 
24 | echo snake_case('Hello World'); // hello_world
25 | ```
26 | 
27 | ### Kebab Case
28 | 
29 | ```php
30 | use function Yuloh\Neko\kebab_case;
31 | 
32 | echo kebab_case('Hello World'); // hello-world
33 | ```
34 | 
35 | ### Pascal Case
36 | 
37 | ```php
38 | use function Yuloh\Neko\pascal_case;
39 | 
40 | echo pascal_case('Hello World'); // HelloWorld
41 | ```
42 | 
43 | ### Camel Case
44 | 
45 | ```php
46 | use function Yuloh\Neko\camel_case;
47 | 
48 | echo camel_case('Hello World'); //helloWorld
49 | ```
50 | 


--------------------------------------------------------------------------------
/src/Neko.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Yuloh\Neko;
  4 | 
  5 | /**
  6 |  * The snakeCase regex is based on the regex from doctrine/inflector,
  7 |  * Copyright (c) 2006-2015 Doctrine Project.
  8 |  * @link https://github.com/doctrine/inflector/blob/master/LICENSE
  9 |  */
 10 | class Neko
 11 | {
 12 |     /**
 13 |      * The cache of snake-cased words.
 14 |      *
 15 |      * @var array
 16 |      */
 17 |     private static $snakeCache = [];
 18 | 
 19 |     /**
 20 |      * The cache of kebab-cased words.
 21 |      *
 22 |      * @var array
 23 |      */
 24 |     private static $kebabCache = [];
 25 | 
 26 |     /**
 27 |      * The cache of pascal-cased words.
 28 |      *
 29 |      * @var array
 30 |      */
 31 |     private static $pascalCache = [];
 32 | 
 33 |     /**
 34 |      * The cache of camel-cased words.
 35 |      *
 36 |      * @var array
 37 |      */
 38 |     private static $camelCache = [];
 39 | 
 40 |     /**
 41 |      * Convert a value to snake_case.
 42 |      *
 43 |      * @param  string $value
 44 |      * @return string
 45 |      */
 46 |     public static function snakeCase($value)
 47 |     {
 48 |         $key = $value;
 49 |         if (isset(static::$snakeCache[$key])) {
 50 |             return static::$snakeCache[$key];
 51 |         }
 52 | 
 53 |         $value = preg_replace('/\s+/', '', ucwords($value));
 54 |         $value = str_replace('-', '_', $value);
 55 |         $value = static::normalizeScreamingCase($value);
 56 |         return static::$snakeCache[$key] = strtolower(preg_replace('~(?<=\\w)([A-Z])~', '_$1', $value));
 57 |     }
 58 | 
 59 |     /**
 60 |      * Convert a value to kebab-case.
 61 |      *
 62 |      * @param  string $value
 63 |      * @return string
 64 |      */
 65 |     public static function kebabCase($value)
 66 |     {
 67 |         $key = $value;
 68 |         if (isset(static::$kebabCache[$key])) {
 69 |             return static::$kebabCache[$key];
 70 |         }
 71 | 
 72 |         $value = preg_replace('/\s+/', '', ucwords($value));
 73 |         $value = str_replace('_', '-', $value);
 74 |         $value = static::normalizeScreamingCase($value);
 75 |         return static::$kebabCache[$key] =  strtolower(preg_replace('~(?<=\\w)([A-Z])~', '-$1', $value));
 76 |     }
 77 | 
 78 |     /**
 79 |      * Convert a value to PascalCase.
 80 |      *
 81 |      * @param  string $value
 82 |      * @return string
 83 |      */
 84 |     public static function pascalCase($value)
 85 |     {
 86 |         if (isset(static::$pascalCache[$value])) {
 87 |             return static::$pascalCache[$value];
 88 |         }
 89 | 
 90 |         $value = static::normalizeScreamingCase($value);
 91 |         return static::$pascalCache[$value] = str_replace(' ', '', ucwords(str_replace(['-', '_'], ' ', $value)));
 92 |     }
 93 | 
 94 |     /**
 95 |      * Convert a value to camelCase.
 96 |      *
 97 |      * @param  string $value
 98 |      * @return string
 99 |      */
100 |     public static function camelCase($value)
101 |     {
102 |         if (isset(static::$camelCache[$value])) {
103 |             return static::$camelCache[$value];
104 |         }
105 | 
106 |         return static::$camelCache[$value] = lcfirst(static::pascalCase($value));
107 |     }
108 | 
109 |     /**
110 |      * Normalize screaming snake/kebab case value to regular snake/kebab case.
111 |      *
112 |      * @param  string $value
113 |      * @return string
114 |      */
115 |     private static function normalizeScreamingCase($value)
116 |     {
117 |         if (ctype_upper(str_replace(['_', '-'], '', $value))) {
118 |             return strtolower($value);
119 |         }
120 | 
121 |         return $value;
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------