Doc parser

src/Utils/Business/LuDocParser.php

@@ -0,0 +1,159 @@
+<?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 LuDocParser
+{
+    /**
+     * @var string
+     */
+    private $_doc;
+
+    /**
+     * @return string
+     */
+    public function getSummary()
+    {
+        return $this->_summary;
+    }
+
+    /**
+     * @var string
+     */
+    private $_summary = "";
+
+    /**
+     * @var LuParameterDbo[]
+     */
+    private $_params = [];
+
+    /**
+     * @var string
+     */
+    private $_returnType = "";
+
+    /**
+     * @return string
+     */
+    public function getDoc()
+    {
+        return $this->_doc;
+    }
+
+    /**
+     * @return \Luticate\Utils\Dbo\LuParameterDbo[]
+     */
+    public function getParams()
+    {
+        return $this->_params;
+    }
+
+    /**
+     * @return string
+     */
+    public function getReturnType()
+    {
+        return $this->_returnType;
+    }
+
+    /**
+     * LuDocParser constructor.
+     * @param $doc string
+     */
+    public function __construct($doc)
+    {
+        $this->_doc = $doc;
+    }
+    
+    public function parse()
+    {
+        if (!is_string($this->_doc)) {
+            return;
+        }
+        $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 = null;
+        
+        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 == "param") {
+                        $currentParam = new LuParameterDbo();
+                        $paramMatches = [];
+                        if (preg_match("/([^ ]+) *([^ ]+) *(.*)/", $line, $paramMatches) === 1) {
+                            if ($paramMatches[1][0] == "$") {
+                                $currentParam->setName($paramMatches[1]);
+                                $currentParam->setType($paramMatches[2]);
+                            }
+                            else {
+                                $currentParam->setName($paramMatches[2]);
+                                $currentParam->setType($paramMatches[1]);
+                            }
+                            $currentParam->setSummary($paramMatches[3] . "\n");
+                        }
+                        $this->_params[$currentParam->getName()] = $currentParam;
+                    }
+                    else if ($command == "deprecated") {
+                    }
+                    else if ($command == "inheritdoc") {
+                    }
+                    else if ($command == "internal") {
+                    }
+                    else if ($command == "link") {
+                    }
+                    else if ($command == "return") {
+                        $this->_returnType = $line;
+                    }
+                    else if ($command == "see") {
+                    }
+                    else if ($command == "throws") {
+                    }
+                    else if (!is_null($currentParam)) {
+                        $methodName = $command;
+                        $constraint = new LuParameterConstraintDbo();
+                        $constraint->setMethod($methodName);
+                        $args = [];
+                        $argMatches = [];
+                        if (preg_match_all('/ *(-?(?:\d*\.\d+|\d+|true|false|"[^"]*"))/', $line, $argMatches) !== false) {
+                            $args = $argMatches[1];
+                            foreach ($args as $key => $arg) {
+                                if ($arg[0] == '"') {
+                                    $args[$key] = substr($arg, 1, count($arg) - 2);
+                                }
+                            }
+                        }
+                        $constraint->setArguments($args);
+                        $currentParam->addConstraint($constraint);
+                    }
+                }
+                else {
+                    if (is_null($currentParam)) {
+                        $this->_summary .= $line . "\n";
+                    }
+                    else {
+                        $currentParam->setSummary($currentParam->getSummary() . $line . "\n");
+                    }
+                }
+            }
+        }
+    }
+}

src/Utils/Dbo/LuDboConstraintException.php

@@ -0,0 +1,15 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 5/29/16
+ * Time: 7:18 PM
+ */
+
+namespace Luticate\Utils\Dbo;
+
+
+class LuDboConstraintException extends \Exception
+{
+
+}

src/Utils/Dbo/LuFloatDbo.php

@@ -54,4 +54,25 @@ class LuFloatDbo extends LuDbo
     {
         return 42.42;
     }
+
+    public function between($min, $max)
+    {
+        if ($this->_value < $min || $this->_value > $max) {
+            throw new LuDboConstraintException("Float must be between ${min} and ${max} inclusive");
+        }
+    }
+
+    public function min($min)
+    {
+        if ($this->_value < $min) {
+            throw new LuDboConstraintException("Float must be greater or equal than ${min}");
+        }
+    }
+
+    public function max($max)
+    {
+        if ($this->_value > $max) {
+            throw new LuDboConstraintException("Float must be smaller or equal than ${max}");
+        }
+    }
 }

src/Utils/Dbo/LuIntDbo.php

@@ -54,4 +54,26 @@ class LuIntDbo extends LuDbo
     {
         return 42;
     }
+
+    public function between($min, $max)
+    {
+        if ($this->_value < $min || $this->_value > $max) {
+            throw new LuDboConstraintException("Integer must be between ${min} and ${max} inclusive");
+        }
+    }
+    
+    public function min($min)
+    {
+        if ($this->_value < $min) {
+            throw new LuDboConstraintException("Integer must be greater or equal than ${min}");
+        }
+    }
+
+    public function max($max)
+    {
+        if ($this->_value > $max) {
+            throw new LuDboConstraintException("Integer must be smaller or equal than ${max}");
+        }
+    }
+    
 }

src/Utils/Dbo/LuParameterConstraintDbo.php

@@ -0,0 +1,65 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 5/29/16
+ * Time: 8:52 PM
+ */
+
+namespace Luticate\Utils\Dbo;
+
+
+use Luticate\Utils\LuDbo;
+
+class LuParameterConstraintDbo extends LuDbo
+{
+    /**
+     * @var $_method string
+     */
+    private $_method;
+
+    /**
+     * @var $_arguments string[]
+     */
+    private $_arguments = [];
+
+    function jsonSerialize()
+    {
+        return [
+            "Method" => $this->_method,
+            "Arguments" => $this->_arguments
+        ];
+    }
+
+    /**
+     * @return string
+     */
+    public function getMethod()
+    {
+        return $this->_method;
+    }
+
+    /**
+     * @param string $method
+     */
+    public function setMethod($method)
+    {
+        $this->_method = $method;
+    }
+
+    /**
+     * @return \string[]
+     */
+    public function getArguments()
+    {
+        return $this->_arguments;
+    }
+
+    /**
+     * @param \string[] $arguments
+     */
+    public function setArguments($arguments)
+    {
+        $this->_arguments = $arguments;
+    }
+}

src/Utils/Dbo/LuParameterDbo.php

@@ -0,0 +1,117 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 5/29/16
+ * Time: 7:48 PM
+ */
+
+namespace Luticate\Utils\Dbo;
+
+use Luticate\Utils\LuDbo;
+
+class LuParameterDbo extends LuDbo
+{
+    /**
+     * @var $_summary string
+     */
+    private $_summary = "";
+
+    /**
+     * @return string
+     */
+    public function getSummary()
+    {
+        return $this->_summary;
+    }
+
+    /**
+     * @param string $summary
+     */
+    public function setSummary($summary)
+    {
+        $this->_summary = $summary;
+    }
+
+    /**
+     * @var $_type string
+     */
+    private $_type = "";
+
+    /**
+     * @var $_name string
+     */
+    private $_name = "";
+
+    /**
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+    /**
+     * @param string $type
+     */
+    public function setType($type)
+    {
+        $this->_type = $type;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->_name;
+    }
+
+    /**
+     * @param string $name
+     */
+    public function setName($name)
+    {
+        $this->_name = $name;
+    }
+
+    /**
+     * @return LuParameterConstraintDbo[]
+     */
+    public function getConstraints()
+    {
+        return $this->_constraints;
+    }
+
+    /**
+     * @param LuParameterConstraintDbo[] $constraints
+     */
+    public function setConstraints($constraints)
+    {
+        $this->_constraints = $constraints;
+    }
+    
+    public function addConstraint($constraint)
+    {
+        $this->_constraints[] = $constraint;
+    }
+
+    /**
+     * @var $_constraints LuParameterConstraintDbo[]
+     */
+    private $_constraints = [];
+    
+    function jsonSerialize()
+    {
+        $constraints = [];
+        foreach ($this->_constraints as $constraint) {
+            $constraints[] = $constraint->jsonSerialize();
+        }
+        return [
+            "Name" => $this->_name,
+            "Type" => $this->_type,
+            "Summary" => $this->_summary,
+            "Constraints" => $constraints
+        ];
+    }
+}

tests/LuDocParserTest.php

@@ -0,0 +1,122 @@
+<?php
+use Luticate\Utils\Business\LuDocParser;
+
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 5/29/16
+ * Time: 7:52 PM
+ */
+class LuDocParserTest extends \PHPUnit_Framework_TestCase
+{
+    public function testSimpleSummary()
+    {
+        $doc = new LuDocParser("/**
+     * Get all data
+     */");
+        $doc->parse();
+        $this->assertSame("Get all data\n", $doc->getSummary());
+    }
+    
+    public function testSimpleSummaryMultiLine()
+    {
+        $doc = new LuDocParser("/**
+     * Get all data
+     * Using the database
+     */");
+        $doc->parse();
+        $this->assertSame("Get all data\nUsing the database\n", $doc->getSummary());
+    }
+
+    public function testSimpleParam()
+    {
+        $doc = new LuDocParser('/**
+     * Get all data
+     * @param $myvar MyType some doc
+     * @param MyType $myvar2 some other doc
+     */');
+        $doc->parse();
+        $this->assertSame("Get all data\n", $doc->getSummary());
+        
+        $params = [];
+        foreach ($doc->getParams() as $param) {
+            $params[] = $param->jsonSerialize();
+        }
+        
+        $expectedParams = [
+            ["Name" => '$myvar', "Type" => "MyType", "Summary" => "some doc\n",
+                "Constraints" => []],
+            ["Name" => '$myvar2', "Type" => "MyType", "Summary" => "some other doc\n",
+                "Constraints" => []]
+        ];
+        
+        $this->assertSame($expectedParams, $params);
+    }
+
+    public function testSimpleParamMultiLine()
+    {
+        $doc = new LuDocParser('/**
+     * Get all data
+     * @param $myvar MyType some doc
+     * @param MyType $myvar2 some other doc
+     * on another line
+     */');
+        $doc->parse();
+        $this->assertSame("Get all data\n", $doc->getSummary());
+
+        $params = [];
+        foreach ($doc->getParams() as $name => $param) {
+            $params[$name] = $param->jsonSerialize();
+        }
+
+        $expectedParams = [
+            '$myvar' => ["Name" => '$myvar', "Type" => "MyType", "Summary" => "some doc\n",
+                "Constraints" => []],
+            '$myvar2' => ["Name" => '$myvar2', "Type" => "MyType", "Summary" => "some other doc\non another line\n",
+                "Constraints" => []]
+        ];
+
+        $this->assertSame($expectedParams, $params);
+    }
+
+    public function testAll()
+    {
+        $doc = new LuDocParser('/**
+     * Get all data
+     * On another line
+     * @param $myvar MyType some doc
+     * Too much doc
+     * @param MyType $myvar2 some other doc
+     * on another line
+     * @min 42
+     * @max 42
+     * @between 0 42
+     * @another 1 2 42.42 true false "a string"
+     * and another
+     * @return AnotherType
+     */');
+        $doc->parse();
+        $this->assertSame("Get all data\nOn another line\n", $doc->getSummary());
+        $this->assertSame("AnotherType", $doc->getReturnType());
+
+        $params = [];
+        foreach ($doc->getParams() as $name => $param) {
+            $params[$name] = $param->jsonSerialize();
+        }
+
+        $expectedParams = [
+            '$myvar' => ["Name" => '$myvar', "Type" => "MyType", "Summary" => "some doc\nToo much doc\n",
+                "Constraints" => []],
+            '$myvar2' => ["Name" => '$myvar2', "Type" => "MyType", "Summary" => "some other doc\non another line\nand another\n",
+                "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"]]
+                ]
+            ]
+        ];
+
+        $this->assertSame($expectedParams, $params);
+    }
+}