Add support for types groupping and arrays shortcut, closes #6

Author: pinepain

src/Extractors/ExtractorDefinitionBuilder.php

@@ -27,7 +27,49 @@ class ExtractorDefinitionBuilder implements ExtractorDefinitionBuilderInterface
     /**
      * @var string
      */
-    protected $type_regexp = '/^((?<name>[-_\w]+)(?:\s*\(\s*(?<param>(?-3)*|[\w\\\\]+)\s*\))?(?:\s*\|\s*(?<alt>(?-4)))?)$/';
+    protected $type_regexp = '/
+    ^
+    (
+        (?<name>
+            [-_\w]*
+        )
+        (?:
+            \s*
+            (?<group>
+                \(
+                \s*
+                (?<param>
+                    (?-4)*
+                    |
+                    [\w\\\\]+
+                )
+                \s*
+                \)
+            )
+        )?
+        (?:
+            \s*
+            (?<arr>(?:\s*\[\s*\]\s*)+)
+        )?
+        (?:
+            \s*
+            \|
+            \s*
+            (?<alt>(?-6))
+        )?
+    )
+    $
+    /xi';
+
+    protected $type_regexp2 = '/
+    ^
+        (?:((\w+\b(?:\(.*\))?(?:\s*\[\s*\])?)(?:\s*\|\s*(?-1))*))
+        |
+        (?:\(\s*(?-2)\s*\)(?:\s*\[\s*\])?)
+        |
+        (\[\s*\])
+    $
+    /xi';
 
     /**
      * {@inheritdoc}
@@ -40,32 +82,53 @@ public function build(string $definition): ExtractorDefinitionInterface
             throw new ExtractorDefinitionBuilderException('Definition must be non-empty string');
         }
 
-        if (preg_match($this->type_regexp, $definition, $matches)) {
-            return $this->buildExtractor($matches['name'], $matches['param'] ?? null, $matches['alt'] ?? null);
+        try {
+            if (preg_match($this->type_regexp, $definition, $matches)) {
+                $extractor = $this->buildExtractor($matches['name'], $matches['param'] ?? '', $matches['alt'] ?? '', $this->getDepth($matches), $this->hasGroups($matches));
+
+                return $extractor;
+            }
+        } catch (ExtractorDefinitionBuilderException $e) {
+            // We don't care about what specific issue we hit inside,
+            // for API user it means that the definition is invalid
         }
 
         throw new ExtractorDefinitionBuilderException("Unable to parse definition: '{$definition}'");
     }
 
     /**
-     * @param string      $name
+     * @param string $name
      * @param null|string $param
      * @param null|string $alt_definitions
+     * @param int $depth
+     * @param bool $groups
      *
      * @return ExtractorDefinitionInterface
      * @throws ExtractorDefinitionBuilderException
      */
-    protected function buildExtractor(string $name, ?string $param, ?string $alt_definitions): ExtractorDefinitionInterface
+    protected function buildExtractor(string $name, string $param, string $alt_definitions, int $depth, bool $groups): ExtractorDefinitionInterface
     {
         $next = null;
 
-        if ($param && preg_match($this->type_regexp, $param, $matches)) {
-            $next = $this->buildExtractor($matches['name'], $matches['param'] ?? null, $matches['alt'] ?? null);
+        if ('' !== $param && preg_match($this->type_regexp, $param, $matches)) {
+            $next = $this->buildExtractor($matches['name'], $matches['param'] ?? '', $matches['alt'] ?? '', $this->getDepth($matches), $this->hasGroups($matches));
+        }
+
+        if ($name) {
+            $definition = new PlainExtractorDefinition($name, $next);
+        } else {
+            $definition = $next;
+        }
+
+        if ($depth > 0) {
+            $definition = $this->buildArrayDefinition($definition, $depth, $groups);
         }
 
-        $definition = new PlainExtractorDefinition($name, $next);
+        if (!$definition) {
+            throw new ExtractorDefinitionBuilderException('Empty group is not allowed');
+        }
 
-        if ($alt_definitions) {
+        if ('' !== $alt_definitions) {
             $definition = $this->buildVariableDefinition($definition, $alt_definitions);
         }
 
@@ -74,7 +137,7 @@ protected function buildExtractor(string $name, ?string $param, ?string $alt_def
 
     /**
      * @param PlainExtractorDefinitionInterface $definition
-     * @param string                            $alt_definitions
+     * @param string $alt_definitions
      *
      * @return VariableExtractorDefinition
      * @throws ExtractorDefinitionBuilderException
@@ -83,19 +146,61 @@ protected function buildVariableDefinition(PlainExtractorDefinitionInterface $de
     {
         $alt = [$definition];
 
-        while ($alt_definitions && preg_match($this->type_regexp, $alt_definitions, $matches)) {
+        while ('' !== $alt_definitions && preg_match($this->type_regexp, $alt_definitions, $matches)) {
             // build alt
-            $alt[] = $this->buildExtractor($matches['name'], $matches['param'] ?? null, null);
+            $alt[] = $this->buildExtractor($matches['name'], $matches['param'] ?? '', '', $this->getDepth($matches), $this->hasGroups($matches));
 
-            $alt_definitions = $matches['alt'] ?? null;
+            $alt_definitions = trim($matches['alt'] ?? '');
         }
 
-        if ($alt_definitions) {
+        if ('' !== $alt_definitions) {
+            // UNEXPECTED
             // this should not be possible, but just in case we will ever get here
             throw new ExtractorDefinitionBuilderException('Invalid varying definition');
         }
 
         return new VariableExtractorDefinition(...$alt);
     }
 
+    /**
+     * @param null|ExtractorDefinitionInterface $definition
+     * @param int $depth
+     * @param bool $groups
+     *
+     * @return ExtractorDefinitionInterface
+     * @throws ExtractorDefinitionBuilderException
+     */
+    protected function buildArrayDefinition(?ExtractorDefinitionInterface $definition, int $depth, bool $groups): ExtractorDefinitionInterface
+    {
+        if (!$definition && $groups) {
+            throw new ExtractorDefinitionBuilderException('Empty group is not allowed');
+        }
+
+        while ($depth) {
+            $depth--;
+            // arrayed definition
+            $definition = new PlainExtractorDefinition('[]', $definition);
+        }
+
+        return $definition;
+    }
+
+    /**
+     * @param array $matches
+     *
+     * @return int
+     */
+    private function getDepth(array $matches): int
+    {
+        if (!isset($matches['arr']) || '' === $matches['arr']) {
+            return 0;
+        }
+
+        return substr_count($matches['arr'], '[');
+    }
+
+    private function hasGroups(array $matches): bool
+    {
+        return isset($matches['group']) && '' !== $matches['group'];
+    }
 }

src/Specs/Builder/ParameterSpecBuilder.php

@@ -56,7 +56,7 @@ class ParameterSpecBuilder implements ParameterSpecBuilderInterface
             \s*
             \:
             \s*
-            (?<type>(\w+\b(?:\(.*\))?)(?:\s*\|\s*(?-1))*)
+            (?<type>(\w*(?:\(.*\))?(?:\[\s*\])?)(?:\s*\|\s*(?-1))*)
             \s*
         )?
         $