Add possibility to create filter without constructor

Author: Louis Pinsard

src/Bridge/Symfony/Bundle/DependencyInjection/Compiler/AnnotationFilterPass.php

@@ -64,9 +64,10 @@ private function createFilterDefinitions(\ReflectionClass $reflectionClass, Cont
                 continue;
             }
 
+            $reflectionClass = $container->getReflectionClass($filterClass, false);
             if ($container->has($filterClass) && ($definition = $container->findDefinition($filterClass))->isAbstract()) {
                 $definition = new ChildDefinition($definition->getClass());
-            } elseif ($reflectionClass = $container->getReflectionClass($filterClass, false)) {
+            } elseif ($reflectionClass) {
                 $definition = new Definition($reflectionClass->getName());
                 $definition->setAutoconfigured(true);
             } else {
@@ -76,8 +77,10 @@ private function createFilterDefinitions(\ReflectionClass $reflectionClass, Cont
             $definition->addTag(self::TAG_FILTER_NAME);
             $definition->setAutowired(true);
 
-            foreach ($arguments as $key => $value) {
-                $definition->setArgument("$$key", $value);
+            if (null !== $reflectionClass && null !== $reflectionConstructor = $reflectionClass->getConstructor()) {
+                foreach ($arguments as $key => $value) {
+                    $definition->setArgument("$$key", $value);
+                }
             }
 
             $container->setDefinition($id, $definition);

tests/Bridge/Symfony/Bundle/DependencyInjection/Compiler/AnnotationFilterPassTest.php

@@ -21,6 +21,7 @@
 use ApiPlatform\Core\Bridge\Symfony\Bundle\DependencyInjection\Compiler\AnnotationFilterPass;
 use ApiPlatform\Core\Exception\InvalidArgumentException;
 use ApiPlatform\Core\Serializer\Filter\GroupFilter;
+use ApiPlatform\Core\Tests\Fixtures\DummyFilterWithoutConstructor;
 use ApiPlatform\Core\Tests\Fixtures\TestBundle\Doctrine\Orm\Filter\AnotherDummyFilter;
 use ApiPlatform\Core\Tests\Fixtures\TestBundle\Entity\Dummy;
 use Doctrine\Common\Annotations\Reader;
@@ -53,15 +54,20 @@ public function testProcess()
 
         $reader->getPropertyAnnotations(Argument::type(\ReflectionProperty::class))->will(function ($args) {
             if (Dummy::class === $args[0]->class && 'dummyDate' === $args[0]->name) {
-                return [new ApiFilter(['value' => DateFilter::class]), new ApiProperty()];
+                return [
+                    new ApiFilter(['value' => DateFilter::class]),
+                    new ApiProperty(),
+                ];
             }
 
             return [];
         });
 
         $reader->getClassAnnotations(Argument::type(\ReflectionClass::class))->will(function ($args) {
             if (Dummy::class === $args[0]->name) {
-                return [new ApiFilter(['value' => SearchFilter::class, 'strategy' => 'exact', 'properties' => ['description', 'relatedDummy.name', 'name']]), new ApiResource([]), new ApiFilter(['value' => GroupFilter::class, 'arguments' => ['parameterName' => 'foobar']])];
+                return [new ApiFilter(['value' => SearchFilter::class, 'strategy' => 'exact', 'properties' => ['description', 'relatedDummy.name', 'name']]), new ApiResource([]),
+                    new ApiFilter(['value' => GroupFilter::class, 'arguments' => ['parameterName' => 'foobar']]),
+                ];
             }
 
             return [];
@@ -81,6 +87,7 @@ public function testProcess()
 
         $containerBuilderProphecy->getReflectionClass(SearchFilter::class, false)->willReturn(new \ReflectionClass(SearchFilter::class))->shouldBeCalled();
         $containerBuilderProphecy->getReflectionClass(GroupFilter::class, false)->willReturn(new \ReflectionClass(GroupFilter::class))->shouldBeCalled();
+        $containerBuilderProphecy->getReflectionClass(DateFilter::class, false)->willReturn(new \ReflectionClass(GroupFilter::class))->shouldBeCalled();
 
         $containerBuilderProphecy->setDefinition('annotated_api_platform_core_tests_fixtures_test_bundle_entity_dummy_api_platform_core_bridge_doctrine_orm_filter_search_filter', Argument::that(function ($def) {
             $this->assertInstanceOf(Definition::class, $def);
@@ -207,4 +214,54 @@ public function testProcessInvalidFilterClass()
 
         $annotationFilterPass->process($containerBuilderProphecy->reveal());
     }
+
+    public function testProcessFilterWithoutConstructor()
+    {
+        $annotationFilterPass = new AnnotationFilterPass();
+
+        $this->assertInstanceOf(CompilerPassInterface::class, $annotationFilterPass);
+
+        $containerBuilderProphecy = $this->prophesize(ContainerBuilder::class);
+
+        $containerBuilderProphecy->getParameter('api_platform.resource_class_directories')->shouldBeCalled()->willReturn([
+            __DIR__.'/../../../../../Fixtures/TestBundle/Entity/',
+        ]);
+
+        $reader = $this->prophesize(Reader::class);
+
+        $reader->getPropertyAnnotations(Argument::type(\ReflectionProperty::class))->will(function ($args) {
+            if (Dummy::class === $args[0]->class && 'dummyDate' === $args[0]->name) {
+                return [new ApiProperty(), new ApiFilter(['value' => DummyFilterWithoutConstructor::class])];
+            }
+
+            return [];
+        });
+
+        $reader->getClassAnnotations(Argument::type(\ReflectionClass::class))->will(function ($args) {
+            if (Dummy::class === $args[0]->name) {
+                return [new ApiResource([])];
+            }
+
+            return [];
+        });
+
+        $containerBuilderProphecy->get('annotation_reader')->shouldBeCalled()->willReturn($reader->reveal());
+
+        $containerBuilderProphecy->has('annotated_api_platform_core_tests_fixtures_test_bundle_entity_dummy_api_platform_core_tests_fixtures_dummy_filter_without_constructor')->shouldBeCalled()->willReturn(false);
+
+        $containerBuilderProphecy->has(DummyFilterWithoutConstructor::class)->willReturn(true)->shouldBeCalled();
+
+        $containerBuilderProphecy->getReflectionClass(DummyFilterWithoutConstructor::class, false)->willReturn(new \ReflectionClass(DummyFilterWithoutConstructor::class))->shouldBeCalled();
+        $containerBuilderProphecy->findDefinition(DummyFilterWithoutConstructor::class)->willReturn((new Definition(DummyFilterWithoutConstructor::class))->setAbstract(false))->shouldBeCalled();
+
+        $containerBuilderProphecy->setDefinition('annotated_api_platform_core_tests_fixtures_test_bundle_entity_dummy_api_platform_core_tests_fixtures_dummy_filter_without_constructor', Argument::that(function ($def) {
+            $this->assertInstanceOf(Definition::class, $def);
+            $this->assertEquals(DummyFilterWithoutConstructor::class, $def->getClass());
+            $this->assertEquals([], $def->getArguments());
+
+            return true;
+        }))->shouldBeCalled();
+
+        $annotationFilterPass->process($containerBuilderProphecy->reveal());
+    }
 }

tests/Fixtures/DummyFilterWithoutConstructor.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the API Platform project.
+ *
+ * (c) Kévin Dunglas <dunglas@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace ApiPlatform\Core\Tests\Fixtures;
+
+use ApiPlatform\Core\Api\FilterInterface;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class DummyFilterWithoutConstructor implements FilterInterface
+{
+    /**
+     * @inheritdoc
+     */
+    public function getDescription(string $resourceClass): array
+    {
+        return [
+            'property' => 'foo',
+            'type' => '',
+            'required' => false,
+            'strategy' => '',
+        ];
+    }
+}