Fix filter combined with multi type properties

Author: wol-soft

README.md

@@ -38,7 +38,8 @@ The recommended way to install php-json-schema-model-generator is through [Compo
 $ composer require --dev wol-soft/php-json-schema-model-generator
 $ composer require wol-soft/php-json-schema-model-generator-production
 ```
-To avoid adding all dependencies of the php-json-schema-model-generator to your production dependencies it's recommended to add the library as a dev-dependency and include the [wol-soft/php-json-schema-model-generator-production](https://github.com/wol-soft/php-json-schema-model-generator-production) library. The production library provides all classes to run the generated code. Generating the classes should either be a step done in the development environment (if you decide to commit the models) or as a build step of your application.
+
+To avoid adding all dependencies of the php-json-schema-model-generator to your production dependencies it's recommended to add the library as a dev-dependency and include the [wol-soft/php-json-schema-model-generator-production](https://github.com/wol-soft/php-json-schema-model-generator-production) library. The production library provides all classes to run the generated code. Generating the classes should either be a step done in the development environment or as a build step of your application (for example you could generate the models in a [composer post-update-cmd script](https://getcomposer.org/doc/articles/scripts.md#command-events), which is the recommended workflow).
 
 ## Basic usage ##
 
@@ -83,6 +84,7 @@ Method | Configuration | Default
 --- | --- | ---
 ``` setNamespacePrefix(string $prefix) ``` <br><br>Example:<br> ``` setNamespacePrefix('\MyApp\Model') ``` | Configures a namespace prefix for all generated classes. The namespaces will be extended with the directory structure of the source directory. | Empty string so no namespace prefix will be used
 ``` setImmutable(bool $immutable) ``` <br><br>Example:<br> ``` setImmutable(false) ``` | If set to true the generated model classes will be delivered without setter methods for the object properties. | true
+``` setImplicitNull(bool $allowImplicitNull) ``` <br><br>Example:<br> ``` setImplicitNull(true) ``` | By setting the implicit null option to true all of your object properties which aren't required will implicitly accept null. | false
 ``` setCollectErrors(bool $collectErrors) ``` <br><br>Example:<br> ``` setCollectErrors(false) ``` | By default the complete input is validated and in case of failing validations all error messages will be thrown in a single exception. If set to false the first failing validation will throw an exception. | true
 ``` setPrettyPrint(bool $prettyPrint) ``` <br><br>Example:<br> ``` setPrettyPrint(true) ``` | If set to false, the generated model classes won't follow coding guidelines (but the generation is faster). If enabled the package [Symplify/EasyCodingStandard](https://github.com/Symplify/EasyCodingStandard) will be used to clean up the generated code. By default pretty printing is disabled. | false
 ``` setSerialization(bool $serialization) ``` <br><br>Example:<br> ``` setSerialization(true) ``` | If set to true the serialization methods `toArray` and `toJSON` will be added to the public interface of the generated classes. | false

docs/source/gettingStarted.rst

@@ -11,7 +11,7 @@ The recommended way to install php-json-model-generator is through `Composer <ht
     composer require --dev wol-soft/php-json-schema-model-generator
     composer require wol-soft/php-json-schema-model-generator-production
 
-To avoid adding all dependencies of the php-json-model-generator to your production dependencies it's recommended to add the library as a dev-dependency and include the php-json-model-generator-exception library. The exception library provides all classes to run the generated code. Generating the classes should either be a step done in the development environment (if you decide to commit the models) or as a build step of your application.
+To avoid adding all dependencies of the php-json-model-generator to your production dependencies it's recommended to add the library as a dev-dependency and include the php-json-model-generator-exception library. The exception library provides all classes to run the generated code. Generating the classes should either be a step done in the development environment or as a build step of your application (for example you could generate the models in a `composer post-update-cmd script<https://getcomposer.org/doc/articles/scripts.md#command-events>`__, which is the recommended workflow).
 
 Generating classes
 ------------------
@@ -154,6 +154,22 @@ If set to true the generated model classes will be delivered without setter meth
     (new GeneratorConfiguration())
         ->setImmutable(false);
 
+Implicit null
+^^^^^^^^^^^^^
+
+By default the properties are strictly checked against their defined types. Consequently if you want a property to accept null you have to extend the type of your property explicitly (eg. ['string', 'null']).
+
+By setting the implicit null option to true all of your object properties which aren't required will implicitly accept null. All properties which are required and don't explicitly allow null in the type definition will still reject null.
+
+.. code-block:: php
+
+    setImplicitNull(bool $allowImplicitNull);
+
+.. code-block:: php
+
+    (new GeneratorConfiguration())
+        ->setImplicitNull(true);
+
 Collect errors vs. early return
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

docs/source/nonStandardExtensions/filter.rst

@@ -274,9 +274,9 @@ The callable filter method must be a static method. Internally it will be called
         public function getAcceptedTypes(): array
         {
             // return an array of types which can be handled by the filter.
-            // valid types are: [integer, number, boolean, string, array] or available classes (FQCN required, eg.
-            // DateTime::class)
-            return ['string'];
+            // valid types are: [integer, number, boolean, string, array, null]
+            // or available classes (FQCN required, eg. DateTime::class)
+            return ['string', 'null'];
         }
 
         public function getToken(): string
@@ -290,6 +290,10 @@ The callable filter method must be a static method. Internally it will be called
         }
     }
 
+.. hint::
+
+    If your filter accepts null values add 'null' to your *getAcceptedTypes* to make sure your filter is compatible with explicit null type
+
 .. hint::
 
     If a filter with the token of your custom filter already exists the existing filter will be overwritten when adding the filter to the generator configuration. By overwriting filters you may change the behaviour of builtin filters by replacing them with your custom implementation.
@@ -387,12 +391,12 @@ The custom serializer method will be called if the model utilizing the custom fi
 
         public function getAcceptedTypes(): array
         {
-            return ['object'];
+            return ['string', 'null'];
         }
 
         public function getToken(): string
         {
-            return 'uppercase';
+            return 'customer';
         }
 
         public function getFilter(): array

docs/source/types/null.rst

@@ -25,3 +25,5 @@ Generated interface (as null is no explicit type no typehints are generated):
 Possible exceptions:
 
 * Invalid type for property. Requires null, got __TYPE__
+
+The main use case for the **null** type is a property with `multiple types <complexTypes/multiType.html>`__ accepting for example a string and null values when using explicit null types.

src/Model/GeneratorConfiguration.php

@@ -27,7 +27,7 @@ class GeneratorConfiguration
     /** @var bool */
     protected $immutable = false;
     /** @var bool */
-    protected $allowImplicitNull = true;
+    protected $allowImplicitNull = false;
     /** @var bool */
     protected $prettyPrint = false;
     /** @var bool */
@@ -88,7 +88,7 @@ public function addFilter(FilterInterface $filter): self
         }
 
         foreach ($filter->getAcceptedTypes() as $acceptedType) {
-            if (!in_array($acceptedType, ['integer', 'number', 'boolean', 'string', 'array']) &&
+            if (!in_array($acceptedType, ['integer', 'number', 'boolean', 'string', 'array', 'null']) &&
                 !class_exists($acceptedType)
             ) {
                 throw new InvalidFilterException('Filter accepts invalid types');

src/Model/Validator/FilterValidator.php

@@ -56,11 +56,7 @@ public function __construct(
                 'typeCheck' => !empty($filter->getAcceptedTypes())
                     ? '($value !== null && (' .
                         implode(' && ', array_map(function (string $type) use ($property): string {
-                            return (new ReflectionTypeCheckValidator(
-                                in_array($type, ['int', 'float', 'string', 'bool', 'array', 'object']),
-                                $type,
-                                $property
-                            ))->getCheck();
+                            return ReflectionTypeCheckValidator::fromType($type, $property)->getCheck();
                         }, $this->mapDataTypes($filter->getAcceptedTypes()))) .
                         '))'
                     : '',
@@ -179,9 +175,7 @@ private function mapDataTypes(array $acceptedTypes): array
             switch ($jsonSchemaType) {
                 case 'integer': return 'int';
                 case 'number': return 'float';
-                case 'string': return 'string';
                 case 'boolean': return 'bool';
-                case 'array': return 'array';
 
                 default: return $jsonSchemaType;
             }

src/Model/Validator/MultiTypeCheckValidator.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace PHPModelGenerator\Model\Validator;
+
+use PHPModelGenerator\Model\Property\PropertyInterface;
+
+/**
+ * Class MultiTypeCheckValidator
+ *
+ * @package PHPModelGenerator\Model\Validator
+ */
+class MultiTypeCheckValidator extends PropertyValidator implements TypeCheckInterface
+{
+    /** @var string[] */
+    protected $types;
+
+    /**
+     * MultiTypeCheckValidator constructor.
+     *
+     * @param string[]          $types
+     * @param PropertyInterface $property
+     * @param bool              $allowImplicitNull
+     */
+    public function __construct(array $types, PropertyInterface $property, bool $allowImplicitNull)
+    {
+        $this->types = $types;
+
+        // if null is explicitly allowed we don't need an implicit null pass through
+        if (in_array('null', $types)) {
+            $allowImplicitNull = false;
+        }
+
+        parent::__construct(
+            join(
+                ' && ',
+                array_map(
+                    function (string $allowedType) use ($property) : string {
+                        return ReflectionTypeCheckValidator::fromType($allowedType, $property)->getCheck();
+                    },
+                    $types
+                )
+            ) . ($allowImplicitNull ? ' && $value !== null' : ''),
+            sprintf(
+                'Invalid type for %s. Requires [%s], got " . gettype($value) . "',
+                $property->getName(),
+                implode(', ', $types)
+            )
+
+        );
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTypes(): array
+    {
+        return $this->types;
+    }
+}

src/Model/Validator/PassThroughTypeCheckValidator.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace PHPModelGenerator\Model\Validator;
+
+use PHPModelGenerator\Model\Property\PropertyInterface;
+use ReflectionType;
+
+/**
+ * Class PassThroughTypeCheckValidator
+ *
+ * @package PHPModelGenerator\Model\Validator
+ */
+class PassThroughTypeCheckValidator extends PropertyValidator implements TypeCheckInterface
+{
+    /** @var string[] */
+    protected $types;
+
+    /**
+     * PassThroughTypeCheckValidator constructor.
+     *
+     * @param ReflectionType $passThroughType
+     * @param PropertyInterface $property
+     * @param TypeCheckValidator $typeCheckValidator
+     */
+    public function __construct(
+        ReflectionType $passThroughType,
+        PropertyInterface $property,
+        TypeCheckValidator $typeCheckValidator
+    ) {
+        $this->types = array_merge($typeCheckValidator->getTypes(), [$passThroughType->getName()]);
+
+        parent::__construct(
+            sprintf(
+                '%s && %s',
+                ReflectionTypeCheckValidator::fromReflectionType($passThroughType, $property)->getCheck(),
+                $typeCheckValidator->getCheck()
+            ),
+            sprintf(
+                'Invalid type for %s. Requires [%s, %s], got " . gettype($value) . "',
+                $property->getName(),
+                $passThroughType->getName(),
+                $property->getType()
+            )
+        );
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getTypes(): array
+    {
+        return $this->types;
+    }
+}

src/Model/Validator/ReflectionTypeCheckValidator.php

@@ -31,6 +31,23 @@ public static function fromReflectionType(
         );
     }
 
+    /**
+     * @param string $type
+     * @param PropertyInterface $property
+     *
+     * @return static
+     */
+    public static function fromType(
+        string $type,
+        PropertyInterface $property
+    ): self {
+        return new self(
+            in_array($type, ['int', 'float', 'string', 'bool', 'array', 'object', 'null']),
+            $type,
+            $property
+        );
+    }
+
     /**
      * ReflectionTypeCheckValidator constructor.
      *

src/Model/Validator/TypeCheckInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace PHPModelGenerator\Model\Validator;
+
+/**
+ * Interface TypeCheckInterface
+ *
+ * @package PHPModelGenerator\Model\Validator
+ */
+interface TypeCheckInterface
+{
+    /**
+     * Get all types accepted by the type check validator
+     *
+     * @return string[]
+     */
+    public function getTypes(): array;
+}