[symfony] Add NoRoutingPrefixRule (#172)

Author: TomasVotruba

README.md

@@ -1290,6 +1290,41 @@ abstract class AbstractController extends Controller
 
 <br>
 
+### NoRoutingPrefixRule
+
+Avoid global route prefixing. Use single place for paths in @Route/#[Route] and improve static analysis instead.
+
+```yaml
+rules:
+    - Symplify\PHPStanRules\Rules\Symfony\NoRoutingPrefixRule
+```
+
+
+```php
+use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
+
+return static function (RoutingConfigurator $routingConfigurator): void {
+    $routingConfigurator->import(__DIR__ . '/some-path')
+        ->prefix('/some-prefix');
+};
+```
+
+:x:
+
+<br>
+
+```php
+use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
+
+return static function (RoutingConfigurator $routingConfigurator): void {
+    $routingConfigurator->import(__DIR__ . '/some-path');
+};
+```
+
+:+1:
+
+<br>
+
 ### NoRequiredOutsideClassRule
 
 Symfony #[Require]/@required should be used only in classes to avoid misuse

config/symfony-rules.neon

@@ -7,6 +7,9 @@ rules:
     - Symplify\PHPStanRules\Rules\Symfony\RequireInvokableControllerRule
     - Symplify\PHPStanRules\Rules\Symfony\FormTypeClassNameRule
 
+    # routing
+    - Symplify\PHPStanRules\Rules\Symfony\NoRoutingPrefixRule
+
     # dependency injection
     - Symplify\PHPStanRules\Rules\Symfony\NoGetDoctrineInControllerRule
     - Symplify\PHPStanRules\Rules\Symfony\NoGetInControllerRule

src/Enum/ClassName.php

@@ -90,4 +90,9 @@ final class ClassName
      * @var string
      */
     public const REQUIRED_ATTRIBUTE = 'Symfony\Contracts\Service\Attribute\Required';
+
+    /**
+     * @var string
+     */
+    public const SYMFONY_ROUTE_IMPORT_CONFIGURATOR = 'Symfony\Component\Routing\Loader\Configurator\ImportConfigurator';
 }

src/Enum/SymfonyRuleIdentifier.php

@@ -29,4 +29,6 @@ final class SymfonyRuleIdentifier
     public const NO_CONSTRUCT_AND_REQUIRED = 'symfony.noConstructAndRequired';
 
     public const FORM_TYPE_CLASS_NAME = 'symfony.formTypeClassName';
+
+    public const NO_ROUTING_PREFIX = 'symfony.noRoutingPrefix';
 }

src/Rules/Symfony/NoRoutingPrefixRule.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Rules\Symfony;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\ObjectType;
+use Symplify\PHPStanRules\Enum\ClassName;
+use Symplify\PHPStanRules\Enum\SymfonyRuleIdentifier;
+
+/**
+ * @implements Rule<MethodCall>
+ *
+ * @see \Symplify\PHPStanRules\Tests\Rules\Symfony\NoRoutingPrefixRule\NoRoutingPrefixRuleTest
+ */
+final class NoRoutingPrefixRule implements Rule
+{
+    /**
+     * @var string
+     */
+    public const ERROR_MESSAGE = 'Avoid global route prefixing, to use single place for paths and improve static analysis';
+
+    public function getNodeType(): string
+    {
+        return MethodCall::class;
+    }
+
+    /**
+     * @param MethodCall $node
+     * @return RuleError[]
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (! $node->name instanceof Identifier) {
+            return [];
+        }
+
+        $methodName = $node->name->toString();
+        if ($methodName !== 'prefix') {
+            return [];
+        }
+
+        $callerType = $scope->getType($node->var);
+        if (! $callerType instanceof ObjectType) {
+            return [];
+        }
+
+        if (! $callerType->isInstanceOf(ClassName::SYMFONY_ROUTE_IMPORT_CONFIGURATOR)->yes()) {
+            return [];
+        }
+
+        $ruleError = RuleErrorBuilder::message(self::ERROR_MESSAGE)
+            ->line($node->getStartLine())
+            ->identifier(SymfonyRuleIdentifier::NO_ROUTING_PREFIX)
+            ->build();
+
+        return [$ruleError];
+    }
+}

tests/Rules/Symfony/NoRoutingPrefixRule/Fixture/routing_imports.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
+
+return static function (RoutingConfigurator $routingConfigurator): void {
+    $routingConfigurator->import(__DIR__ . '/some-path')
+        ->prefix('/some-prefix');
+};

tests/Rules/Symfony/NoRoutingPrefixRule/Fixture/skip_no_route_prefix.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
+
+return static function (RoutingConfigurator $routingConfigurator): void {
+    $routingConfigurator->import(__DIR__ . '/some-path');
+};

tests/Rules/Symfony/NoRoutingPrefixRule/NoRoutingPrefixRuleTest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\NoRoutingPrefixRule;
+
+use Iterator;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Symplify\PHPStanRules\Rules\Symfony\NoRoutingPrefixRule;
+
+final class NoRoutingPrefixRuleTest extends RuleTestCase
+{
+    /**
+     * @param string[] $filePaths
+     */
+    #[DataProvider('provideData')]
+    public function testRule(array $filePaths, array $expectedErrorsWithLines): void
+    {
+        $this->analyse($filePaths, $expectedErrorsWithLines);
+    }
+
+    public static function provideData(): Iterator
+    {
+        yield [[
+            __DIR__ . '/Fixture/skip_no_route_prefix.php',
+        ], []];
+
+        yield [[
+            __DIR__ . '/Fixture/routing_imports.php',
+        ], [[NoRoutingPrefixRule::ERROR_MESSAGE, 8]]];
+    }
+
+    protected function getRule(): Rule
+    {
+        return new NoRoutingPrefixRule();
+    }
+}