Add parameter type guessing by default value

Author: pinepain

src/Extractors/ExtractorDefinitionBuilder.php

@@ -181,11 +181,6 @@ protected function buildArrayDefinition(?ExtractorDefinitionInterface $definitio
         return $definition;
     }
 
-    /**
-     * @param array $matches
-     *
-     * @return int
-     */
     private function getDepth(array $matches): int
     {
         if (!isset($matches['arr']) || '' === $matches['arr']) {

src/Specs/Builder/ParameterSpecBuilder.php

@@ -24,7 +24,6 @@
 use Pinepain\JsSandbox\Specs\Parameters\OptionalParameterSpec;
 use Pinepain\JsSandbox\Specs\Parameters\ParameterSpecInterface;
 use Pinepain\JsSandbox\Specs\Parameters\VariadicParameterSpec;
-use function strlen;
 
 
 class ParameterSpecBuilder implements ParameterSpecBuilderInterface
@@ -138,6 +137,10 @@ protected function buildOptionalParameterSpec(array $matches, ?string $default):
             } catch (ArgumentValueBuilderException $e) {
                 throw new ParameterSpecBuilderException("Unknown or unsupported default value format '{$default_definition}'");
             }
+
+            if (!$this->hasType($matches)) {
+                $matches['type'] = $this->guessTypeFromDefault($default);
+            }
         }
 
         return new OptionalParameterSpec($matches['name'], $this->extractor->build($matches['type']), $default);
@@ -162,8 +165,9 @@ protected function prepareDefinition(array $matches): array
             throw new ParameterSpecBuilderException('Variadic parameter could have no default value');
         }
 
-        if (!$this->hasType($matches)) {
-            $matches['type'] = 'any'; // special case
+        if (!$this->hasDefault($matches) && !$this->hasType($matches)) {
+            // special case when no default value set and no type provided
+            $matches['type'] = 'any';
         }
 
         return $matches;
@@ -188,4 +192,27 @@ private function hasDefault(array $matches): bool
     {
         return isset($matches['default']) && '' !== $matches['default'];
     }
+
+    private function guessTypeFromDefault($default): string
+    {
+        if (is_array($default)) {
+            return '[]';
+        }
+
+        if (is_numeric($default)) {
+            return 'number';
+        }
+
+        if (is_bool($default)) {
+            return 'bool';
+        }
+
+        if (is_string($default)) {
+            return 'string';
+        }
+
+        // it looks like we have nullable parameter which could be anything
+
+        return 'any';
+    }
 }

tests/Specs/Builder/ParameterSpecBuilderTest.php

@@ -210,6 +210,118 @@ public function testBuildingNullableParameter()
         $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
     }
 
+    public function testBuildingParameterWithArrayTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('[]');
+        $this->extractorDefinitionShouldBuildOn('[]');
+
+        $spec = $this->builder->build('param = []');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertSame([], $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
+    public function testBuildingParameterWithBoolTrueTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('true');
+        $this->extractorDefinitionShouldBuildOn('bool');
+
+        $spec = $this->builder->build('param = true');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertSame(true, $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
+    public function testBuildingParameterWithBoolFalseTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('false');
+        $this->extractorDefinitionShouldBuildOn('bool');
+
+        $spec = $this->builder->build('param = false');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertSame(false, $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
+    public function testBuildingParameterWithNullableTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('null');
+        $this->extractorDefinitionShouldBuildOn('any');
+
+        $spec = $this->builder->build('param?');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertSame(null, $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
+    public function testBuildingParameterWithDefaultNullTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('null');
+        $this->extractorDefinitionShouldBuildOn('any');
+
+        $spec = $this->builder->build('param = null');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertSame(null, $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
+    public function testBuildingParameterWithDefaultIntNumberTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('123');
+        $this->extractorDefinitionShouldBuildOn('number');
+
+        $spec = $this->builder->build('param = 123');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertEquals(123, $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
+    public function testBuildingParameterWithDefaultFloatNumberTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('123.42');
+        $this->extractorDefinitionShouldBuildOn('number');
+
+        $spec = $this->builder->build('param = 123.42');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertSame(123.42, $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
+    public function testBuildingParameterWithDefaultStringTypeGuessing()
+    {
+        $this->argumentDefinitionShouldBuildOn('"test"');
+        $this->extractorDefinitionShouldBuildOn('string');
+
+        $spec = $this->builder->build('param = "test"');
+
+        $this->assertInstanceOf(OptionalParameterSpec::class, $spec);
+
+        $this->assertSame('param', $spec->getName());
+        $this->assertSame('"test"', $spec->getDefaultValue());
+        $this->assertInstanceOf(ExtractorDefinitionInterface::class, $spec->getExtractorDefinition());
+    }
+
     /**
      * @expectedException \Pinepain\JsSandbox\Specs\Builder\Exceptions\ParameterSpecBuilderException
      * @expectedExceptionMessage Unable to parse definition because of extractor failure: ExtractorDefinitionBuilder exception for testing
@@ -223,9 +335,31 @@ public function testBuildingWhenExtractorFailsShouldAlsoFail()
 
     protected function argumentDefinitionShouldBuildOn($name)
     {
+        $retval = $name;
+
+        if ('[]' == $name) {
+            $retval = [];
+        }
+
+        if ('true' === $name) {
+            $retval = true;
+        }
+
+        if ('false' === $name) {
+            $retval = false;
+        }
+
+        if (is_numeric($name)) {
+            $retval = is_int($name) ? (int)$name : (float) $name;
+        }
+
+        if ('null' === $name) {
+            $retval = null;
+        }
+
         $this->argument_builder->method('build')
                                ->with($name, false)
-                               ->willReturn($name);
+                               ->willReturn($retval);
     }
 
     protected function argumentDefinitionShouldThrowOn($name)