switched json serialization to lower camel case

src/Utils/Business/LuArrayUtils.php

 
 class LuArrayUtils
 {
-    public static function snakeToCamelCase($array)
+    public static function snakeToCamelCase($array, $capitalizeFirstCharacter = false)
     {
         if (!is_array($array))
         {
         $camelCase = [];
         foreach ($array as $key => $value)
         {
-            $camelCase[LuStringUtils::snakeToCamelCase($key, true)] = self::snakeToCamelCase($value);
+            $camelCase[LuStringUtils::snakeToCamelCase($key, $capitalizeFirstCharacter)] =
+                self::snakeToCamelCase($value, $capitalizeFirstCharacter);
         }
         return $camelCase;
     }
         return $camelCase;
     }
 
-    public static function convertJsonString($json)
+    public static function convertJsonString($json, $capitalizeFirstCharacter = false)
     {
-        return LuStringUtils::convertJsonString($json);
+        return LuStringUtils::convertJsonString($json, $capitalizeFirstCharacter);
     }
 
-    public static function objectToArray($d)
+    public static function objectToArray($d, $capitalizeFirstCharacter = false)
     {
         if (is_object($d)) {
             $d = get_object_vars($d);
         if (is_array($d)) {
             $data = [];
             foreach ($d as $key => $value) {
-                $data[$key] = self::objectToArray($value);
+                $data[$key] = self::objectToArray($value, $capitalizeFirstCharacter);
             }
-            return self::snakeToCamelCase($data);
+            return self::snakeToCamelCase($data, $capitalizeFirstCharacter);
         }
         else {
             return $d;

src/Utils/Business/LuStringUtils.php

 
 class LuStringUtils
 {
-    public static function snakeToCamelCase($string, $capitalizeFirstCharacter)
+    public static function snakeToCamelCase($string, $capitalizeFirstCharacter = false)
     {
         $str = preg_replace_callback("/_[a-zA-Z0-9]/", function($matches)
         {
         if ($capitalizeFirstCharacter && !empty($str)) {
             $str[0] = strtoupper($str[0]);
         }
+        else {
+            $str[0] = strtolower($str[0]);
+        }
         return $str;
     }
     
         return $str;
     }
 
-    public static function convertJsonString($json)
+    public static function convertJsonString($json, $capitalizeFirstCharacter = false)
     {
         $array = json_decode($json, true);
-        return LuArrayUtils::snakeToCamelCase($array);
+        return LuArrayUtils::snakeToCamelCase($array, $capitalizeFirstCharacter);
     }
 
     /**

src/Utils/Dbo/LuDbo.php

         $reflect = new \ReflectionClass(static::class);
         $properties = $reflect->getProperties();
         foreach ($properties as $property) {
-            $name = LuStringUtils::snakeToCamelCase($property->getName(), true);
+            $name = LuStringUtils::snakeToCamelCase($property->getName(), false);
             $property->setAccessible(true);
             $value = $property->getValue($this);
             $json[$name] = static::serializeValue($value);
         $properties = $reflect->getProperties();
         foreach ($properties as $property) {
             $parser = new LuPropertyDocParser($property->getDocComment());
-            $name = LuStringUtils::snakeToCamelCase($property->getName(), true);
+            $name = LuStringUtils::snakeToCamelCase($property->getName(), false);
             $doc = $parser->parse();
             $type = is_null($doc) ? null : $doc->getType();
 

src/Utils/Dbo/LuPaginatedDbo.php

     function jsonSerialize()
     {
         return array(
-            "Count" => $this->_count,
-            "Data" => LuDbo::serializeValue($this->_data)
+            "count" => $this->_count,
+            "data" => LuDbo::serializeValue($this->_data)
         );
     }
 
     
     public static function jsonDeserialize($json)
     {
-        return new static($json["Count"], $json["Data"]);
+        return new static($json["count"], $json["data"]);
     }
 
     public static function generateSample()
     {
         return [
-            "Count" => 42,
-            "Data" => []
+            "count" => 42,
+            "data" => []
         ];
     }
 }

src/Utils/Dbo/LuParameterConstraintDbo.php

      */
     private $_arguments = [];
 
-    function jsonSerialize()
-    {
-        return [
-            "Method" => $this->_method,
-            "Arguments" => $this->_arguments
-        ];
-    }
-
     /**
      * @return string
      */

tests/DatabaseTest.php

 
     public function testSpGetMultiplePaginated1()
     {
-        $this->assertSame(["Count" => 16, "Data" => range(0, 1)], SpTest2::executePaginated(42, 0, 2)->jsonSerialize());
+        $this->assertSame(["count" => 16, "data" => range(0, 1)], SpTest2::executePaginated(42, 0, 2)->jsonSerialize());
     }
 
     public function testSpGetMultiplePaginated2()
     {
-        $this->assertSame(["Count" => 16, "Data" => range(2, 3)], SpTest2::executePaginated(42, 1, 2)->jsonSerialize());
+        $this->assertSame(["count" => 16, "data" => range(2, 3)], SpTest2::executePaginated(42, 1, 2)->jsonSerialize());
     }
 
     public function testDaGetMultiple()
     {
-        $this->assertSame([["Id" => 1, "SomeText" => "lol2", "SomeIntegerArray" => [], "CreatedAt" => "2016-06-15 13:45:23"]],
+        $this->assertSame([["id" => 1, "someText" => "lol2", "someIntegerArray" => [], "createdAt" => "2016-06-15 13:45:23"]],
             LuDbo::serializeValue(TestTableDataAccess::getMultiple(function(Builder $q)
             {
                 return $q->where("id", "=", 1);
 
     public function testDaGetMultipleOffset()
     {
-        $this->assertSame([["Id" => 11, "SomeText" => "lol2", "SomeIntegerArray" => [], "CreatedAt" => "2016-06-15 13:45:23"]],
+        $this->assertSame([["id" => 11, "someText" => "lol2", "someIntegerArray" => [], "createdAt" => "2016-06-15 13:45:23"]],
             LuDbo::serializeValue(TestTableDataAccess::getMultiple(function(Builder $q)
             {
                 return $q->take(1)->offset(2);
 
     public function testDaGetPaginated()
     {
-        $this->assertSame(["Count" => 3, "Data" =>
-            [["Id" => 11, "SomeText" => "lol2", "SomeIntegerArray" => [], "CreatedAt" => "2016-06-15 13:45:23"]]],
+        $this->assertSame(["count" => 3, "data" =>
+            [["id" => 11, "someText" => "lol2", "someIntegerArray" => [], "createdAt" => "2016-06-15 13:45:23"]]],
             LuDbo::serializeValue(TestTableDataAccess::getMultiplePaginated(function(Builder $q)
             {
                 return $q->orderBy("id", "ASC");
 
     public function testDaGetSingleById()
     {
-        $this->assertSame(["Id" => 1, "SomeText" => "lol2", "SomeIntegerArray" => [], "CreatedAt" => "2016-06-15 13:45:23"],
+        $this->assertSame(["id" => 1, "someText" => "lol2", "someIntegerArray" => [], "createdAt" => "2016-06-15 13:45:23"],
             LuDbo::serializeValue(TestTableDataAccess::getSingleById(1)));
     }
     

tests/LuDboDeserializeTest.php

     
     public function test()
     {
-        $json = ["Test" => "Test."];
+        $json = ["test" => "Test."];
         $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo')->jsonSerialize());
     }
     
     public function test2()
     {
         $json = [
-            "Test2" => [
-                ["Test" => "Test."],
-                ["Test" => "Test.2"]
+            "test2" => [
+                ["test" => "Test."],
+                ["test" => "Test.2"]
             ],
-            "Test3" => ["Test" => "Test.3"]
+            "test3" => ["test" => "Test.3"]
         ];
         $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo2')->jsonSerialize());
     }
     public function test3()
     {
         $json = [
-            "Test2" => [
-                ["Test" => "Test."],
-                ["Test" => "Test.2"]
+            "test2" => [
+                ["test" => "Test."],
+                ["test" => "Test.2"]
             ],
-            "Test3" => null
+            "test3" => null
         ];
         $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo2')->jsonSerialize());
     }
     public function test4()
     {
         $json = [
-            "Test2" => [
-                ["Test" => "Test."],
+            "test2" => [
+                ["test" => "Test."],
                 null
             ],
-            "Test3" => null
+            "test3" => null
         ];
         $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo2')->jsonSerialize());
     }

tests/LuMethodDocParserTest.php

         }
         
         $expectedParams = [
-            ["NotNull" => true, "Summary" => "some doc\n", "Type" => "MyType", "Name" => 'myvar',
-                "Constraints" => []],
-            ["NotNull" => true, "Summary" => "some other doc\n", "Type" => "MyType", "Name" => 'myvar2',
-                "Constraints" => []]
+            ["notNull" => true, "summary" => "some doc\n", "type" => "MyType", "name" => 'myvar',
+                "constraints" => []],
+            ["notNull" => true, "summary" => "some other doc\n", "type" => "MyType", "name" => 'myvar2',
+                "constraints" => []]
         ];
         
         $this->assertSame($expectedParams, $params);
         }
 
         $expectedParams = [
-            'myvar' => ["NotNull" => true, "Summary" => "some doc\n", "Type" => "MyType", "Name" => 'myvar',
-                "Constraints" => []],
-            'myvar2' => ["NotNull" => true, "Summary" => "some other doc\non another line\n", "Type" => "MyType",
-                "Name" => 'myvar2', "Constraints" => []]
+            'myvar' => ["notNull" => true, "summary" => "some doc\n", "type" => "MyType", "name" => 'myvar',
+                "constraints" => []],
+            'myvar2' => ["notNull" => true, "summary" => "some other doc\non another line\n", "type" => "MyType",
+                "name" => 'myvar2', "constraints" => []]
         ];
 
         $this->assertSame($expectedParams, $params);
         }
 
         $expectedParams = [
-            'myvar' => ["NotNull" => true, "Summary" => "some doc\nToo much doc\n", "Type" => "MyType",
-                "Name" => 'myvar', "Constraints" => []],
-            'myvar2' => ["NotNull" => false, "Summary" => "some other doc\non another line\nand another\n",
-                "Type" => "MyType", "Name" => 'myvar2',
-                "Constraints" => [
-                    ["Method" => "min", "Arguments" => [42]],
-                    ["Method" => "max", "Arguments" => [42]],
-                    ["Method" => "between", "Arguments" => [0, 42]],
-                    ["Method" => "another", "Arguments" => [1, 2, 42.42, true, false, "a string", "string", null]]
+            'myvar' => ["notNull" => true, "summary" => "some doc\nToo much doc\n", "type" => "MyType",
+                "name" => 'myvar', "constraints" => []],
+            'myvar2' => ["notNull" => false, "summary" => "some other doc\non another line\nand another\n",
+                "type" => "MyType", "name" => 'myvar2',
+                "constraints" => [
+                    ["method" => "min", "arguments" => [42]],
+                    ["method" => "max", "arguments" => [42]],
+                    ["method" => "between", "arguments" => [0, 42]],
+                    ["method" => "another", "arguments" => [1, 2, 42.42, true, false, "a string", "string", null]]
                 ]
             ]
         ];

tests/LuRouteTest.php

         $router = new LuRoute();
         $router->addRoute("GET", "/test", '\BasicTestController', "testTypedParameter");
         $router->setup();
-        $res = $router->dispatch("GET", "/test", ["test" => '{"Test": "Some value"}']);
+        $res = $router->dispatch("GET", "/test", ["test" => '{"test": "Some value"}']);
         $this->assertSame("Some value", $res);
     }
 
         $router = new LuRoute();
         $router->addRoute("GET", "/test", '\BasicTestController', "testTypedParameterDoc");
         $router->setup();
-        $res = $router->dispatch("GET", "/test", ["test" => '{"Test": "42"}']);
+        $res = $router->dispatch("GET", "/test", ["test" => '{"test": "42"}']);
         $this->assertSame("42", $res);
     }