Support enums without type - Close #6

Author: sandrokeil

src/Type/Type.php

@@ -10,6 +10,7 @@
 
 namespace OpenCodeModeling\JsonSchemaToPhp\Type;
 
+use OpenCodeModeling\JsonSchemaToPhp\Exception\RuntimeException;
 use OpenCodeModeling\JsonSchemaToPhp\Shorthand\Shorthand;
 
 final class Type
@@ -57,10 +58,38 @@ public static function fromDefinition(array $definition, ?string $name = null, a
                     || isset($definition['required']):
                     $definition['type'] = ObjectType::type();
                     break;
+                case isset($definition['enum']):
+                    $enumType = '';
+
+                    foreach ($definition['enum'] as $enumvalue) {
+                        $previousType = \gettype($enumvalue);
+
+                        if ($enumType !== '' && $previousType !== $enumType) {
+                            throw new RuntimeException('Mixed enum types not supported');
+                        }
+                        $enumType = $previousType;
+                    }
+                    switch ($enumType) {
+                        case 'array':
+                        case 'string':
+                        case 'integer':
+                        case 'boolean':
+                            break;
+                        case 'float':
+                        case 'double':
+                            $enumType = 'number';
+                            break;
+                        default:
+                            throw new RuntimeException(
+                                \sprintf('The type "%s" is not supported in schema definition for "%s"', $enumType, $name)
+                            );
+                    }
+                    $definition['type'] = $enumType;
+                    break;
                 case \count($definition) === 0:
                     return new TypeSet(MixedType::fromDefinition($definition, $name));
                 default:
-                    throw new \RuntimeException(\sprintf('The "type" is missing in schema definition for "%s"', $name));
+                    throw new RuntimeException(\sprintf('The "type" is missing in schema definition for "%s"', $name));
             }
         }
 
@@ -113,14 +142,14 @@ public static function fromDefinition(array $definition, ?string $name = null, a
                     $isNullable = true;
                     break;
                 default:
-                    throw new \RuntimeException(
+                    throw new RuntimeException(
                         \sprintf('JSON schema type "%s" is not implemented', $definition['type'])
                     );
             }
         }
 
         if (\count($types) === 0) {
-            throw new \RuntimeException('Could not determine type of JSON schema');
+            throw new RuntimeException('Could not determine type of JSON schema');
         }
 
         $typeSet = new TypeSet(...$types);

tests/Type/TypeTest.php

@@ -1,9 +1,19 @@
 <?php
+
+/**
+ * @see       https://github.com/open-code-modeling/json-schema-to-php for the canonical source repository
+ * @copyright https://github.com/open-code-modeling/json-schema-to-php/blob/master/COPYRIGHT.md
+ * @license   https://github.com/open-code-modeling/json-schema-to-php/blob/master/LICENSE.md MIT License
+ */
+
 declare(strict_types=1);
 
 namespace OpenCodeModelingTest\JsonSchemaToPhp\Type;
 
+use OpenCodeModeling\JsonSchemaToPhp\Type\IntegerType;
+use OpenCodeModeling\JsonSchemaToPhp\Type\NumberType;
 use OpenCodeModeling\JsonSchemaToPhp\Type\ObjectType;
+use OpenCodeModeling\JsonSchemaToPhp\Type\StringType;
 use OpenCodeModeling\JsonSchemaToPhp\Type\Type;
 use PHPUnit\Framework\TestCase;
 
@@ -27,4 +37,58 @@ public function it_supports_shorthand_definition(): void
         $this->assertEquals('Person', $type->name());
         $this->assertEquals('Person', $type->title());
     }
+
+    /**
+     * @test
+     */
+    public function it_supports_string_enums_without_type(): void
+    {
+        $typeSet = Type::fromShorthand(['contentLanguage' => 'enum|de-DE|en-US'], 'Content');
+
+        $this->assertCount(1, $typeSet);
+
+        /** @var ObjectType $type */
+        $type = $typeSet->first();
+
+        $this->assertInstanceOf(ObjectType::class, $type);
+        $this->assertArrayHasKey('contentLanguage', $type->properties());
+
+        $contentLanguage = $type->properties()['contentLanguage'];
+        /** @var StringType $contentLanguageType */
+        $contentLanguageType = $contentLanguage->first();
+        $this->assertInstanceOf(StringType::class, $contentLanguageType);
+        $this->assertSame(['de-DE', 'en-US'], $contentLanguageType->enum());
+    }
+
+    /**
+     * @test
+     */
+    public function it_supports_int_enums_without_type(): void
+    {
+        $typeSet = Type::fromDefinition(['enum' => [10, 20]], 'Content');
+
+        $this->assertCount(1, $typeSet);
+
+        /** @var IntegerType $type */
+        $type = $typeSet->first();
+
+        $this->assertInstanceOf(IntegerType::class, $type);
+        $this->assertSame([10, 20], $type->enum());
+    }
+
+    /**
+     * @test
+     */
+    public function it_supports_float_enums_without_type(): void
+    {
+        $typeSet = Type::fromDefinition(['enum' => [10.10, 20.20]], 'Content');
+
+        $this->assertCount(1, $typeSet);
+
+        /** @var NumberType $type */
+        $type = $typeSet->first();
+
+        $this->assertInstanceOf(NumberType::class, $type);
+        $this->assertSame([10.10, 20.20], $type->enum());
+    }
 }