Add array not empty filter

Add array filter documentation
Add array filter test cases
Deny transforming filters on arrays

Author: wol-soft

README.md

@@ -2,7 +2,7 @@
 [![Minimum PHP Version](https://img.shields.io/badge/php-%3E%3D%207.2-8892BF.svg)](https://php.net/)
 [![Maintainability](https://api.codeclimate.com/v1/badges/9e3c565c528edb3d58d5/maintainability)](https://codeclimate.com/github/wol-soft/php-json-schema-model-generator/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/7eb29e7366dc3d6a5f44/test_coverage)](https://codeclimate.com/github/wol-soft/php-json-schema-model-generator/test_coverage)
-[![Build Status](https://travis-ci.org/wol-soft/php-json-schema-model-generator.svg?branch=master)](https://travis-ci.org/wol-soft/php-json-schema-model-generator)
+[![Build Status](https://travis-ci.com/wol-soft/php-json-schema-model-generator.svg?branch=master)](https://travis-ci.com/wol-soft/php-json-schema-model-generator)
 [![Coverage Status](https://coveralls.io/repos/github/wol-soft/php-json-schema-model-generator/badge.svg?branch=master)](https://coveralls.io/github/wol-soft/php-json-schema-model-generator?branch=master)
 [![MIT License](https://img.shields.io/packagist/l/wol-soft/php-json-schema-model-generator.svg)](https://github.com/wol-soft/php-json-schema-model-generator/blob/master/LICENSE)
 [![Documentation Status](https://readthedocs.org/projects/php-json-schema-model-generator/badge/?version=latest)](https://php-json-schema-model-generator.readthedocs.io/en/latest/?badge=latest)

composer.json

@@ -12,7 +12,7 @@
     ],
     "require": {
         "symplify/easy-coding-standard": "^7.2.3",
-        "wol-soft/php-json-schema-model-generator-production": "0.8.0",
+        "wol-soft/php-json-schema-model-generator-production": "0.9.0",
         "wol-soft/php-micro-template": "^1.3.1",
 
         "php": ">=7.2",

docs/source/nonStandardExtensions/filter.rst

@@ -46,6 +46,31 @@ If a list is used filters may include additional option parameters. In this case
         }
     }
 
+Array filter
+------------
+
+Filters may be applied to arrays. In this case the filter operates on the whole array.
+
+.. code-block:: json
+
+    {
+        "type": "object",
+        "properties": {
+            "names": {
+                "type": "array",
+                "filter": "notEmpty",
+                "items": {
+                    "type": "string",
+                    "filter": "trim"
+                }
+            }
+        }
+    }
+
+The array filter is executed before the items are processed. Consequently strings which aren't empty at the beginning but are empty after the trim filter is applied to each element won't be filtered out in the example given above.
+
+It is not possible to use transforming filters on arrays.
+
 Transforming filter
 -------------------
 
@@ -112,6 +137,40 @@ If the filter trim is used for a property which doesn't require a string value a
 
 * Filter trim is not compatible with property type __TYPE__ for property __PROPERTY_NAME__
 
+notEmpty
+^^^^^^^^
+
+The dateTime filter is only valid for array properties.
+
+.. code-block:: json
+
+    {
+        "$id": "family",
+        "type": "object",
+        "properties": {
+            "members": {
+                "type": "array",
+                "filter": "notEmpty"
+            }
+        }
+    }
+
+Let's have a look how the generated model behaves:
+
+.. code-block:: php
+
+    // valid, the name will be NULL as the name is not required
+    $family = new Person([]);
+
+    // A valid example
+    $family = new Family(['members' => [null, null]]]);
+    $family->getMembers(); // returns an empty array
+    // the raw model data input is not affected by the filter
+    $family->getRawModelDataInput(); // returns ['members' => [null, null]]
+
+    $family->setMembers(['Hannes', null]);
+    $family->getMembers(); // returns ['Hannes']
+
 dateTime
 ^^^^^^^^
 
@@ -228,6 +287,9 @@ The callable filter method must be a static method. Internally it will be called
 
 If the custom filter is added to the generator configuration you can now use the filter in your schema and the generator will resolve the function:
 
+.. 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.
 
 .. code-block:: json
 

src/Model/GeneratorConfiguration.php

@@ -7,6 +7,7 @@
 use PHPModelGenerator\Exception\InvalidFilterException;
 use PHPModelGenerator\PropertyProcessor\Filter\DateTimeFilter;
 use PHPModelGenerator\PropertyProcessor\Filter\FilterInterface;
+use PHPModelGenerator\PropertyProcessor\Filter\NotEmptyFilter;
 use PHPModelGenerator\PropertyProcessor\Filter\TransformingFilterInterface;
 use PHPModelGenerator\PropertyProcessor\Filter\TrimFilter;
 use PHPModelGenerator\Utils\ClassNameGenerator;
@@ -51,6 +52,7 @@ public function __construct()
 
         $this
             ->addFilter(new DateTimeFilter())
+            ->addFilter(new NotEmptyFilter())
             ->addFilter(new TrimFilter());
     }
 
@@ -65,7 +67,6 @@ public function __construct()
      */
     public function addFilter(FilterInterface $filter): self
     {
-        // TODO: check accepted types
         if (!(count($filter->getFilter()) === 2) ||
             !is_string($filter->getFilter()[0]) ||
             !is_string($filter->getFilter()[1]) ||

src/Model/Validator/FilterValidator.php

@@ -129,7 +129,9 @@ private function mapDataTypes(array $acceptedTypes): array
                 case 'boolean': return 'bool';
                 case 'array': return 'array';
 
+                // @codeCoverageIgnoreStart this must not occur as invalid types are filtered out before
                 default: throw new SchemaException("Invalid accepted type $jsonSchemaType");
+                // @codeCoverageIgnoreEnd
             }
         }, $acceptedTypes);
     }

src/PropertyProcessor/Filter/FilterProcessor.php

@@ -65,6 +65,11 @@ public function process(
             );
 
             if ($filter instanceof TransformingFilterInterface) {
+                if ($property->getType() === 'array') {
+                    throw new SchemaException(
+                        "Applying a transforming filter to the array property {$property->getName()} is not supported"
+                    );
+                }
                 if ($hasTransformingFilter) {
                     throw new SchemaException(
                         "Applying multiple transforming filters for property {$property->getName()} is not supported"

src/PropertyProcessor/Filter/NotEmptyFilter.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace PHPModelGenerator\PropertyProcessor\Filter;
+
+use PHPModelGenerator\Filter\NotEmpty;
+
+/**
+ * Class NotEmptyFilter
+ *
+ * Removes empty elements from an array
+ *
+ * @package PHPModelGenerator\PropertyProcessor\Filter
+ */
+class NotEmptyFilter implements FilterInterface
+{
+    /**
+     * @inheritDoc
+     */
+    public function getAcceptedTypes(): array
+    {
+        return ['array'];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getToken(): string
+    {
+        return 'notEmpty';
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getFilter(): array
+    {
+        return [NotEmpty::class, 'filter'];
+    }
+}

src/PropertyProcessor/Filter/TrimFilter.php

@@ -16,31 +16,23 @@
 class TrimFilter implements FilterInterface
 {
     /**
-     * Return a list of accepted data types for the filter (eg. ['string', 'int']). If the filter is applied to a
-     * value which doesn't match an accepted type an exception will be thrown
-     *
-     * @return array
+     * @inheritDoc
      */
     public function getAcceptedTypes(): array
     {
         return ['string'];
     }
 
     /**
-     * Return the token for the filter
-     *
-     * @return string
+     * @inheritDoc
      */
     public function getToken(): string
     {
         return 'trim';
     }
 
     /**
-     * Return the filter to apply. Make sure the returned array is a callable which is also callable after the
-     * render process
-     *
-     * @return array
+     * @inheritDoc
      */
     public function getFilter(): array
     {

tests/Basic/FilterTest.php

@@ -477,6 +477,26 @@ public function testAdditionalFilterOptions(): void
         $this->assertSame(json_encode($expectedSerialization), $object->toJSON());
     }
 
+    public function testTransformingFilterAppliedToAnArrayPropertyThrowsAnException(): void
+    {
+        $this->expectException(SchemaException::class);
+        $this->expectExceptionMessage(
+            'Applying a transforming filter to the array property list is not supported'
+        );
+
+        $this->generateClassFromFile(
+            'ArrayTransformingFilter.json',
+            (new GeneratorConfiguration())->addFilter(
+                $this->getCustomTransformingFilter(
+                    [self::class, 'serializeBinaryToInt'],
+                    [self::class, 'filterIntToBinary'],
+                    'customArrayTransformer',
+                    ['array']
+                )
+            )
+        );
+    }
+
     public function testMultipleTransformingFiltersAppliedToOnePropertyThrowsAnException(): void
     {
         $this->expectException(SchemaException::class);
@@ -572,4 +592,29 @@ public static function serializeBinaryToInt(string $binary): int
     {
         return bindec($binary);
     }
+
+    /**
+     * @dataProvider arrayFilterDataProvider
+     *
+     * @param array|null $input
+     * @param array|null $output
+     */
+    public function testArrayFilter(?array $input, ?array $output): void
+    {
+        $className = $this->generateClassFromFile('ArrayFilter.json');
+
+        $object = new $className(['list' => $input]);
+        $this->assertSame($output, $object->getList());
+    }
+
+    public function arrayFilterDataProvider(): array
+    {
+        return [
+            'null' => [null, null],
+            'empty array' => [[], []],
+            'string array' => [['', 'Hello', null, '123'], ['Hello', '123']],
+            'numeric array' => [[12, 0, 43], [12, 43]],
+            'nested array' => [[['Hello'], [], [12], ['']], [['Hello'], [12], ['']]],
+        ];
+    }
 }

tests/Schema/FilterTest/ArrayFilter.json

@@ -0,0 +1,9 @@
+{
+  "type": "object",
+  "properties": {
+    "list": {
+      "type": "array",
+      "filter": "notEmpty"
+    }
+  }
+}

tests/Schema/FilterTest/ArrayTransformingFilter.json

@@ -0,0 +1,9 @@
+{
+  "type": "object",
+  "properties": {
+    "list": {
+      "type": "array",
+      "filter": "customArrayTransformer"
+    }
+  }
+}