callable generators

README.md

@@ -72,8 +72,8 @@ A config file can be passed in `--config` option:
 PhpInvariant allows writing custom generators to generate data for you needs
 
 To write a generator you need to create two classes and add they in config file:
-1. `Type` class. This class uses as attribute and store settings for generator It must implements `TypeInterface`.  
-1. `Generator` class. It generates data based on settings from `Type` class. Must implements `GeneratorInterface`
+1. `Type` class. This class uses as attribute and store settings for generator  
+1. `Generator` class. It generates data based on settings from `Type` class. Must implements `__invoke` method
 1. Add classes in `generators` configuration file section
 ```yml
 parameters:

custom/CustomGenerator.php

@@ -6,18 +6,16 @@
 use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class CustomGenerator implements GeneratorInterface
+class CustomGenerator
 {
     public function __construct(
         private Random $random
     ) {
     }
 
 
-    /**
-     * @param CustomType $type
-     */
-    public function generate(TypeInterface $type): string
+
+    public function __invoke(CustomType $type): string
     {
         return $type->prefix.' '.$this->random->getInt(1, 100);
 

custom/CustomType.php

@@ -6,7 +6,7 @@
 use PhpInvariant\Generator\TypeInterface;
 
 #[Attribute]
-class CustomType implements TypeInterface
+class CustomType
 {
     public function __construct(public string $prefix)
     {

src/CheckMethodRunner/CheckMethodCaller.php

@@ -2,7 +2,6 @@
 
 namespace PhpInvariant\CheckMethodRunner;
 
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\CheckMethodRunner\Dto\MethodRunResult;
 use ReflectionClass;
 use ReflectionException;
@@ -16,7 +15,7 @@ public function __construct(
     }
 
     /**
-     * @param array<TypeInterface> $types
+     * @param array<mixed> $types
      * @throws ReflectionException
      */
     public function callMethod(ReflectionClass $checkClass, ReflectionMethod $checkMethod, array $types, MethodRunResult $result): void

src/CheckMethodRunner/CheckMethodGeneratorsCaller.php

@@ -4,7 +4,6 @@
 
 use PhpInvariant\BaseInvariant\Exception\PhpInvariantAssertException;
 use PhpInvariant\Generator\GeneratorFactory;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\CheckMethodRunner\Dto\ErrorRunResult;
 use PhpInvariant\CheckMethodRunner\Dto\CheckMethodCallResult;
 use PHPUnit\Framework\ExpectationFailedException;
@@ -20,7 +19,7 @@ public function __construct(
     }
 
     /**
-     * @param array<TypeInterface> $types
+     * @param array<mixed> $types
      * @throws ReflectionException
      * @throws ExpectationFailedException
      */
@@ -29,7 +28,7 @@ public function callMethod(ReflectionClass $checkClass, ReflectionMethod $checkM
         $parameters = [];
         foreach ($types as $type) {
             $generator = $this->generatorFactory->getGenerator($type);
-            $parameters[] = $generator->generate($type);
+            $parameters[] = $generator($type);
         }
         $result = new CheckMethodCallResult();
 

src/CheckMethodRunner/Condition/CountCondition.php

@@ -3,7 +3,6 @@
 namespace PhpInvariant\CheckMethodRunner\Condition;
 
 use PhpInvariant\Finish\FinishCount;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\CheckMethodRunner\Dto\MethodRunResult;
 use PhpInvariant\CheckMethodRunner\CheckMethodCaller;
 use ReflectionClass;
@@ -18,7 +17,7 @@ public function __construct(
     }
 
     /**
-     * @param array<TypeInterface> $types
+     * @param array<mixed> $types
      * @throws ReflectionException
      */
     public function run(ReflectionClass $checkClass, ReflectionMethod $checkMethod, array $types, FinishCount $finishCondition): MethodRunResult

src/CheckMethodRunner/Condition/TimeCondition.php

@@ -3,7 +3,6 @@
 namespace PhpInvariant\CheckMethodRunner\Condition;
 
 use PhpInvariant\Finish\FinishTime;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\CheckMethodRunner\Dto\MethodRunResult;
 use PhpInvariant\CheckMethodRunner\CheckMethodCaller;
 use ReflectionClass;
@@ -19,7 +18,7 @@ public function __construct(
 
 
     /**
-     * @param array<TypeInterface> $types
+     * @param array<mixed> $types
      * @throws ReflectionException
      */
     public function run(ReflectionClass $checkClass, ReflectionMethod $checkMethod, array $types, FinishTime $finishCondition): MethodRunResult

src/Generator/Exception/GeneratorNotFoundException.php

@@ -11,9 +11,5 @@ public static function notFoundForType(string $typeName): self
         return new self(sprintf('can not find generator for type %s', $typeName));
     }
 
-    public static function notImplementInterface(string $generatorName): self
-    {
-        return new self(sprintf('generator %s must implement GeneratorInterface', $generatorName));
-    }
 
 }

src/Generator/Generator/Arrays/ArrayGenerator.php

@@ -2,31 +2,29 @@
 
 namespace PhpInvariant\Generator\Generator\Arrays;
 
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\GeneratorFactory;
 use PhpInvariant\Generator\Type\Arrays\ArrayType;
-use PhpInvariant\Generator\TypeInterface;
 
-class ArrayGenerator implements GeneratorInterface
+class ArrayGenerator
 {
     public function __construct(
         private GeneratorFactory $generatorFactory
     ) {
     }
 
     /**
-     * @param ArrayType $type
      * @return array<mixed>
      */
-    public function generate(TypeInterface $type): array
+    public function __invoke(ArrayType $type): array
     {
         $generator = $this->generatorFactory->getGenerator($type->elementType);
         $data = [];
         for ($i = 0; $i < $type->count; $i++) {
-            $data[] = $generator->generate($type->elementType);
+            $data[] = $generator($type->elementType);
         }
         return $data;
     }
 
 
+
 }

src/Generator/Generator/Arrays/FromArrayGenerator.php

@@ -2,23 +2,20 @@
 
 namespace PhpInvariant\Generator\Generator\Arrays;
 
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\Type\Arrays\FromArrayType;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class FromArrayGenerator implements GeneratorInterface
+class FromArrayGenerator
 {
     public function __construct(
         private Random $random
     ) {
     }
 
     /**
-     * @param FromArrayType $type
      * @return array<mixed>
      */
-    public function generate(TypeInterface $type): array
+    public function __invoke(FromArrayType $type): array
     {
         $result = [];
         for ($i = 0; $i < $type->count; $i++) {

src/Generator/Generator/Combine/OneOfGenerator.php

@@ -2,29 +2,25 @@
 
 namespace PhpInvariant\Generator\Generator\Combine;
 
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\GeneratorFactory;
 use PhpInvariant\Generator\Type\Combine\OneOfType;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class OneOfGenerator implements GeneratorInterface
+class OneOfGenerator
 {
     public function __construct(
         private GeneratorFactory $generatorFactory,
         private Random $random
     ) {
     }
 
-    /**
-     * @param OneOfType $type
-     */
-    public function generate(TypeInterface $type): mixed
+
+    public function __invoke(OneOfType $type): mixed
     {
         $data = $type->types;
         $type = $data[$this->random->getInt(0, count($data) - 1)];
         $generator = $this->generatorFactory->getGenerator($type);
-        return $generator->generate($type);
+        return $generator($type);
 
     }
 }

src/Generator/Generator/DateTime/DateTimeGenerator.php

@@ -3,22 +3,18 @@
 namespace PhpInvariant\Generator\Generator\DateTime;
 
 use DateTime;
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\Type\DateTime\DateTimeType;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class DateTimeGenerator implements GeneratorInterface
+class DateTimeGenerator
 {
     public function __construct(
         private Random $random
     ) {
     }
 
-    /**
-     * @param DateTimeType $type
-     */
-    public function generate(TypeInterface $type): DateTime
+
+    public function __invoke(DateTimeType $type): DateTime
     {
         $from = !is_null($type->from) ? $type->from->getTimestamp() : 0;
         $before = !is_null($type->before) ? $type->before->getTimestamp() : 0xffffffff;

src/Generator/Generator/Scalar/Boolean/BooleanGenerator.php

@@ -2,22 +2,18 @@
 
 namespace PhpInvariant\Generator\Generator\Scalar\Boolean;
 
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\Type\Scalar\Boolean\BooleanType;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class BooleanGenerator implements GeneratorInterface
+class BooleanGenerator
 {
     public function __construct(
         private Random $random
     ) {
     }
 
-    /**
-     * @param BooleanType $type
-     */
-    public function generate(TypeInterface $type): bool
+
+    public function __invoke(BooleanType $type): bool
     {
         return (bool)($this->random->getInt(0, 1));
     }

src/Generator/Generator/Scalar/Float/FloatGenerator.php

@@ -2,22 +2,18 @@
 
 namespace PhpInvariant\Generator\Generator\Scalar\Float;
 
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\Type\Scalar\Float\FloatType;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class FloatGenerator implements GeneratorInterface
+class FloatGenerator
 {
     public function __construct(
         private Random $random
     ) {
     }
 
-    /**
-     * @param FloatType $type
-     */
-    public function generate(TypeInterface $type): float
+
+    public function __invoke(FloatType $type): float
     {
         $maxIntegerPart = (int)floor($type->max);
         $minIntegerPart = (int)floor($type->min);

src/Generator/Generator/Scalar/Integer/IntegerGenerator.php

@@ -2,22 +2,17 @@
 
 namespace PhpInvariant\Generator\Generator\Scalar\Integer;
 
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\Type\Scalar\Integer\IntegerType;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class IntegerGenerator implements GeneratorInterface
+class IntegerGenerator
 {
     public function __construct(
         private Random $random
     ) {
     }
 
-    /**
-     * @param IntegerType $type
-     */
-    public function generate(TypeInterface $type): int
+    public function __invoke(IntegerType $type): int
     {
         return $this->random->getInt($type->min, $type->max);
     }

src/Generator/Generator/Scalar/String/StringGenerator.php

@@ -2,22 +2,18 @@
 
 namespace PhpInvariant\Generator\Generator\Scalar\String;
 
-use PhpInvariant\Generator\Generator\GeneratorInterface;
 use PhpInvariant\Generator\Type\Scalar\String\StringType;
-use PhpInvariant\Generator\TypeInterface;
 use PhpInvariant\Random\Random;
 
-class StringGenerator implements GeneratorInterface
+class StringGenerator
 {
     public function __construct(
         private Random $random
     ) {
     }
 
-    /**
-     * @param StringType $type
-     */
-    public function generate(TypeInterface $type): string
+
+    public function __invoke(StringType $type): string
     {
         $alphabet = [];
         for ($char = 32; $char <= 127; $char++) {