lu dbo auto (de)serialization

src/Utils/Business/LuPropertyDocParser.php

@@ -0,0 +1,105 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 5/29/16
+ * Time: 7:42 PM
+ */
+
+namespace Luticate\Utils\Business;
+
+use Luticate\Utils\Dbo\LuParameterConstraintDbo;
+use Luticate\Utils\Dbo\LuParameterDbo;
+
+class LuPropertyDocParser
+{
+    /**
+     * LuDocParser constructor.
+     * @param $doc string
+     */
+    public function __construct($doc)
+    {
+        $this->_doc = $doc;
+    }
+
+    /**
+     * @return LuParameterDbo
+     */
+    public function parse()
+    {
+        if (!is_string($this->_doc)) {
+            return null;
+        }
+        $lines = preg_split("/(\r?\n)/", $this->_doc);
+        $count = count($lines);
+        if ($count > 2) {
+            array_splice($lines, 0, 1);
+            array_splice($lines, $count - 2, 1);
+        }
+
+        $currentParam = new LuParameterDbo();
+        
+        foreach ($lines as $line) {
+            $lineMatches = [];
+            if (preg_match("/ *\\** *(.*) */", $line, $lineMatches) === 1) {
+                $line = $lineMatches[1];
+                $commandMatches = [];
+                if (preg_match("/@([^ ]+) *(.*)/", $line, $commandMatches)) {
+                    $command = strtolower($commandMatches[1]);
+                    $line = $commandMatches[2];
+                    if ($command == "var") {
+                        $paramMatches = [];
+                        if (preg_match("/([^ ]+) *([^ ]+) *(.*)/", $line, $paramMatches) === 1) {
+                            if ($paramMatches[1][0] == "$") {
+                                $currentParam->setName(substr($paramMatches[1], 1, strlen($paramMatches[1]) - 1));
+                                $currentParam->setType($paramMatches[2]);
+                            }
+                            else {
+                                $currentParam->setName(substr($paramMatches[2], 1, strlen($paramMatches[2]) - 1));
+                                $currentParam->setType($paramMatches[1]);
+                            }
+                            $currentParam->setSummary($paramMatches[3] . "\n");
+                        }
+                    }
+                    else {
+                        $methodName = $command;
+                        $constraint = new LuParameterConstraintDbo();
+                        $constraint->setMethod($methodName);
+                        $args = [];
+                        $argMatches = [];
+                        if (preg_match_all('/ *(-?(?:\d*\.\d+|\d+|true|false|null|"[^"]*"|\'[^\']*\'))/', $line, $argMatches) !== false) {
+                            $args = $argMatches[1];
+                            foreach ($args as $key => $arg) {
+                                $argLower = strtolower($arg);
+                                if ($arg[0] == '"' || $arg[0] == "'") {
+                                    $args[$key] = substr($arg, 1, count($arg) - 2);
+                                }
+                                else if ($argLower == "true") {
+                                    $args[$key] = true;
+                                }
+                                else if ($argLower == "false") {
+                                    $args[$key] = false;
+                                }
+                                else if ($argLower == "null") {
+                                    $args[$key] = null;
+                                }
+                                else if (strpos($arg, ".") !== false) {
+                                    $args[$key] = floatval($arg);
+                                }
+                                else {
+                                    $args[$key] = intval($arg);
+                                }
+                            }
+                        }
+                        $constraint->setArguments($args);
+                        $currentParam->addConstraint($constraint);
+                    }
+                }
+                else {
+                    $currentParam->setSummary($currentParam->getSummary() . $line . "\n");
+                }
+            }
+        }
+        return $currentParam;
+    }
+}

src/Utils/Dbo/LuDbo.php

@@ -2,6 +2,9 @@
 
 namespace Luticate\Utils\Dbo;
 
+use Luticate\Utils\Business\LuPropertyDocParser;
+use Luticate\Utils\Business\LuStringUtils;
+
 abstract class LuDbo implements \JsonSerializable {
     /**
      * @return string
@@ -10,6 +13,40 @@ abstract class LuDbo implements \JsonSerializable {
     {
         return json_encode($this);
     }
+    
+    public function jsonSerialize()
+    {
+        $json = [];
+        $reflect = new \ReflectionClass(static::class);
+        $properties = $reflect->getProperties();
+        foreach ($properties as $property) {
+            $name = LuStringUtils::stringSnakeToCamelCase($property->getName(), true);
+            $property->setAccessible(true);
+            $value = $property->getValue($this);
+            if (is_array($value)) {
+                $array = [];
+                foreach ($value as $key => $v) {
+                    if ($v instanceof LuDbo) {
+                        $array[$key] = $v->jsonSerialize();
+                    }
+                    else {
+                        $array[$key] = $v;
+                    }
+                }
+                $json[$name] = $array;
+            }
+            else {
+                $value = $property->getValue($this);
+                if ($value instanceof LuDbo) {
+                    $json[$name] = $value->jsonSerialize();
+                }
+                else {
+                    $json[$name] = $value;
+                }
+            }
+        }
+        return $json;
+    }
 
     /**
      * @param $newClass LuDbo
@@ -23,6 +60,58 @@ abstract class LuDbo implements \JsonSerializable {
         return $obj;
     }
 
+    public static function endsWith($haystack, $needle) {
+        return $needle === "" || (($temp = strlen($haystack) - strlen($needle)) >= 0
+            && strpos($haystack, $needle, $temp) !== false);
+    }
+
+    public static function deserializeValue($value, $type) {
+        if (is_null($value)) {
+            return null;
+        }
+        
+        if (is_null($type) || $type == "") {
+            $type = "mixed";
+        }
+        else if ($type == "array") {
+            $type = "mixed[]";
+        }
+
+        if ($type == "string") {
+            $dbo = LuStringDbo::jsonDeserialize($value);
+            return $dbo->getString();
+        }
+        else if ($type == "int") {
+            $dbo = LuIntDbo::jsonDeserialize($value);
+            return $dbo->getInt();
+        }
+        else if ($type == "float") {
+            $dbo = LuFloatDbo::jsonDeserialize($value);
+            return $dbo->getFloat();
+        }
+        else if ($type == "bool") {
+            $dbo = LuBoolDbo::jsonDeserialize($value);
+            return $dbo->getBool();
+        }
+        else if ($type == "mixed") {
+            return $value;
+        }
+        else if (self::endsWith($type, "[]")) {
+            if (!is_array($value)) {
+                throw new LuDboDeserializeException("Invalid array value");
+            }
+            $type = substr($type, 0, strlen($type) - 2);
+            $data = [];
+            foreach ($value as $v) {
+                $data[] = self::deserializeValue($v, $type);
+            }
+            return $data;
+        }
+        else {
+            return call_user_func_array(array($type, "jsonDeserialize"), array($value));
+        }
+    }
+
     /**
      * Deserialize from a JSON object
      * @param $json mixed The JSON data to deserialize
@@ -30,7 +119,22 @@ abstract class LuDbo implements \JsonSerializable {
      */
     public static function jsonDeserialize($json)
     {
-        return null;
+        $dbo = new static();
+        $reflect = new \ReflectionClass(static::class);
+        $properties = $reflect->getProperties();
+        foreach ($properties as $property) {
+            $parser = new LuPropertyDocParser($property->getDocComment());
+            $name = LuStringUtils::stringSnakeToCamelCase($property->getName(), true);
+            $doc = $parser->parse();
+            $type = is_null($doc) ? null : $doc->getType();
+
+            if (isset($json[$name])) {
+                $value = static::deserializeValue($json[$name], $type);
+                $property->setAccessible(true);
+                $property->setValue($dbo, $value);
+            }
+        }
+        return $dbo;
     }
 
     /**

src/Utils/Dbo/LuMiddlewareDbo.php

@@ -22,7 +22,39 @@ class LuMiddlewareDbo extends LuDbo
     private $_middleware;
 
     /**
-     * @var $_parameters mixed[]
+     * @return string
+     */
+    public function getMiddleware()
+    {
+        return $this->_middleware;
+    }
+
+    /**
+     * @param string $middleware
+     */
+    public function setMiddleware($middleware)
+    {
+        $this->_middleware = $middleware;
+    }
+
+    /**
+     * @return array
+     */
+    public function getParameters()
+    {
+        return $this->_parameters;
+    }
+
+    /**
+     * @param array $parameters
+     */
+    public function setParameters($parameters)
+    {
+        $this->_parameters = $parameters;
+    }
+
+    /**
+     * @var $_parameters array
      */
     private $_parameters;
 }

tests/LuDboDeserializeTest.php

@@ -0,0 +1,125 @@
+<?php
+use Luticate\Utils\Dbo\LuDbo;
+
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 6/5/16
+ * Time: 7:02 PM
+ */
+
+class TestDbo extends LuDbo {
+
+    /**
+     * @var $_test string
+     */
+    private $_test;
+
+    /**
+     * @return string
+     */
+    public function getTest()
+    {
+        return $this->_test;
+    }
+
+    /**
+     * @param string $test
+     */
+    public function setTest($test)
+    {
+        $this->_test = $test;
+    }
+
+}
+
+class TestDbo2 extends LuDbo {
+
+    /**
+     * @var $_test2 TestDbo[]
+     */
+    private $_test2;
+
+    /**
+     * @var $_test3 TestDbo
+     */
+    private $_test3;
+
+    /**
+     * @return TestDbo[]
+     */
+    public function getTest2()
+    {
+        return $this->_test2;
+    }
+
+    /**
+     * @param TestDbo[] $test2
+     */
+    public function setTest2($test2)
+    {
+        $this->_test2 = $test2;
+    }
+
+    /**
+     * @return TestDbo
+     */
+    public function getTest3()
+    {
+        return $this->_test3;
+    }
+
+    /**
+     * @param TestDbo $test3
+     */
+    public function setTest3($test3)
+    {
+        $this->_test3 = $test3;
+    }
+
+}
+
+class LuDboDeserializeTest extends \PHPUnit_Framework_TestCase{
+    
+    public function test()
+    {
+        $json = ["Test" => "Test."];
+        $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo')->jsonSerialize());
+    }
+    
+    public function test2()
+    {
+        $json = [
+            "Test2" => [
+                ["Test" => "Test."],
+                ["Test" => "Test.2"]
+            ],
+            "Test3" => ["Test" => "Test.3"]
+        ];
+        $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo2')->jsonSerialize());
+    }
+
+    public function test3()
+    {
+        $json = [
+            "Test2" => [
+                ["Test" => "Test."],
+                ["Test" => "Test.2"]
+            ],
+            "Test3" => null
+        ];
+        $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo2')->jsonSerialize());
+    }
+
+    public function test4()
+    {
+        $json = [
+            "Test2" => [
+                ["Test" => "Test."],
+                null
+            ],
+            "Test3" => null
+        ];
+        $this->assertSame($json, LuDbo::deserializeValue($json, 'TestDbo2')->jsonSerialize());
+    }
+}