add enum support, remove mabe enum

Author: prolic

.gitignore

@@ -8,4 +8,3 @@
 .php_cs.cache
 nbproject
 composer.lock
-

README.md

@@ -33,6 +33,27 @@ echo \Model\Foo\Person\age($p2); // 36
 var_dump($p === $p2); // false
 ```
 
+### Enums?
+
+No problem
+
+```console
+namespace MyEnum;
+
+enum Color = Red | Blue | Green | Yellow
+```
+
+```php
+$blue = Blue();
+var_dump($blue->sameAs(Blue())); // true
+var_dump($blue->sameAs(Red())); // false
+
+function (Color $color): string
+{
+    return $color->value();
+}
+```
+
 ### Derivings
 
 There are 4 deriving types for now:
@@ -60,17 +81,23 @@ $p->sameAs($p) // true
 
 ### Usage
 
-`php bin/fpp.php <source dir> <target file>`
+`php bin/fpp.php <source dir or file> <target file>`
 
 ### Demo
 
-```
+```console
 git clone https://github.com/prolic/fpp
 cd fpp
 composer install
 php bin/fpp.php demo demo/generated.php
 ```
 
+or for a single file:
+
+```console
+php bin/enum.php demo demo/generated.php
+```
+
 ### Features
 
 - [x] Create immutable data types with ease
@@ -80,7 +107,8 @@ php bin/fpp.php demo demo/generated.php
 - [x] Generate prooph events
 - [x] Generate prooph queries
 - [x] Generate prooph aggregate changed events
-- [ ] Allow creating of or-types (f.e. data Color = Red | Blue | Green)
+- [x] Generate enums
+- [ ] Allow creating of custom constructors
 - [ ] Show deriving feature
 - [ ] Make parser more robust
 - [ ] More to come

composer.json

@@ -8,9 +8,7 @@
     }
   ],
   "require": {
-    "php": "^7.1",
-    "marc-mabe/php-enum": "^3.0",
-    "nikic/php-parser": "^3.1.4"
+    "php": "^7.1"
   },
   "require-dev": {
     "phpunit/phpunit": "^7.0",

demo/enum.fpp

@@ -0,0 +1,3 @@
+namespace Enum;
+
+enum Color = Red | Blue | Green

src/AggregateChanged.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fpp;
+
+final class AggregateChanged extends Type
+{
+    protected $value = 'AggregateChanged';
+}

src/ArrayConverter.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fpp;
+
+final class ArrayConverter extends Deriving
+{
+    protected $value = 'ArrayConverter';
+}

src/Command.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fpp;
+
+final class Command extends Type
+{
+    protected $value = 'Command';
+}

src/Data.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fpp;
+
+final class Data extends Type
+{
+    protected $value = 'Data';
+}

src/Definition.php

@@ -41,24 +41,31 @@ public function __construct(
         string $namespace,
         string $name,
         array $arguments = [],
-        DerivingSet $derivings = null,
+        array $derivings = [],
         string $messageName = null
     ) {
         if (empty($name)) {
             throw new \InvalidArgumentException('Name cannot be empty string');
         }
 
-        if ($type->is(Type::DATA()) && null !== $messageName) {
+        if ($type->sameAs(new Data())
+            && null !== $messageName
+        ) {
             throw new \InvalidArgumentException('Message name cannot be passed to data type');
-        } elseif (! $type->is(Type::DATA()) && empty($messageName)) {
+        } elseif (! $type->sameAs(new Data())
+            && ! $type->sameAs(new Enum())
+            && empty($messageName)
+        ) {
             throw new \InvalidArgumentException('Message name cannot be empty string');
         }
 
-        if (null === $derivings) {
-            $derivings = new DerivingSet();
+        if ($type->sameAs(new Enum()) && empty($arguments)) {
+            throw new \InvalidArgumentException('Enums need at least one implementation');
         }
 
-        if (count($arguments) > 1 && $derivings->contains(Deriving::STRING_CONVERTER())) {
+        if (count($arguments) > 1
+            && in_array((new StringConverter)->value(), $derivings)
+        ) {
             throw new \InvalidArgumentException(sprintf(
                 'Cannot derive from StringConverter using more than one argument for %s\\%s',
                 $namespace,
@@ -77,10 +84,15 @@ public function __construct(
             if ($argument->name() === $name) {
                 throw new \InvalidArgumentException('Argument name is not allowed to be same as object name');
             }
+            if ($argument->typehint() !== null
+                && $type->sameAs(new Enum())
+            ) {
+                throw new \InvalidArgumentException('Argument typehint is not allowed for enums');
+            }
             $this->arguments[] = $argument;
         }
 
-        $this->derivings = $derivings;
+        $this->derivings = array_unique($derivings);
         $this->messageName = $messageName;
     }
 
@@ -116,7 +128,7 @@ public function arguments(): array
         return $this->arguments;
     }
 
-    public function derivings(): DerivingSet
+    public function derivings(): array
     {
         return $this->derivings;
     }

src/Deriving.php

@@ -4,18 +4,53 @@
 
 namespace Fpp;
 
-use MabeEnum\Enum;
-
-/**
- * @method static Deriving SHOW()
- * @method static Deriving STRING_CONVERTER()
- * @method static Deriving ARRAY_CONVERTER()
- * @method static Deriving VALUE_OBJECT()
- */
-final class Deriving extends Enum
+abstract class Deriving
 {
-    const SHOW = 'Show';
-    const STRING_CONVERTER = 'StringConverter';
-    const ARRAY_CONVERTER = 'ArrayConverter';
-    const VALUE_OBJECT = 'ValueObject';
+    const OPTIONS = [
+        Show::class,
+        StringConverter::class,
+        ArrayConverter::class,
+        ValueObject::class,
+    ];
+
+    const OPTION_VALUES = [
+        'Show',
+        'StringConverter',
+        'ArrayConverter',
+        'ValueObject',
+    ];
+
+    protected $value;
+
+    final public function __construct()
+    {
+        $valid = false;
+
+        foreach(self::OPTIONS as $value) {
+            if ($this instanceof $value) {
+                $valid = true;
+                break;
+            }
+        }
+
+        if (! $valid) {
+            $self = get_class($this);
+            throw new \LogicException("Invalid Deriving '$self' given");
+        }
+    }
+
+    public function value(): string
+    {
+        return $this->value;
+    }
+
+    public function sameAs(Deriving $other): bool
+    {
+        return get_class($this) === get_class($other);
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
 }