[symfony] Add ServicesExcludedDirectoryMustExistRule (#202)

Author: TomasVotruba

README.md

@@ -39,6 +39,9 @@ includes:
     - vendor/symplify/phpstan-rules/config/rector-rules.neon
     - vendor/symplify/phpstan-rules/config/doctrine-rules.neon
     - vendor/symplify/phpstan-rules/config/symfony-rules.neon
+
+    # special set for PHP configs
+    - vendor/symplify/phpstan-rules/config/symfony-config-rules.neon
 ```
 
 <br>
@@ -1484,6 +1487,45 @@ abstract class AbstractController extends Controller
 
 <br>
 
+### ServicesExcludedDirectoryMustExistRule
+
+Services excluded path must exist. If not, remove it
+
+```yaml
+rules:
+    - Symplify\PHPStanRules\Rules\Symfony\ConfigClosure\ServicesExcludedDirectoryMustExistRule
+```
+
+```php
+use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+return static function (ContainerConfigurator $configurator): void {
+    $services = $configurator->serivces();
+
+    $services->load('App\\', __DIR__ . '/../src')
+        ->exclude([__DIR__ . '/this-path-does-not-exist']);
+};
+```
+
+:x:
+
+<br>
+
+```php
+use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+return static function (ContainerConfigurator $configurator): void {
+    $services = $configurator->services();
+
+    $services->load('App\\', __DIR__ . '/../src')
+        ->exclude([__DIR__ . '/../src/ValueObject']);
+};
+```
+
+:+1:
+
+<br>
+
 ### NoRoutingPrefixRule
 
 Avoid global route prefixing. Use single place for paths in @Route/#[Route] and improve static analysis instead.

config/symfony-config-rules.neon

@@ -0,0 +1,2 @@
+rules:
+    - Symplify\PHPStanRules\Rules\Symfony\ConfigClosure\ServicesExcludedDirectoryMustExistRule

src/Enum/SymfonyClass.php

@@ -40,4 +40,6 @@ final class SymfonyClass
     public const COMMAND = 'Symfony\Component\Console\Command\Command';
 
     public const VALIDATOR_TEST_CASE = 'Symfony\Component\Validator\Test\ConstraintValidatorTestCase';
+
+    public const CONTAINER_CONFIGURATOR = 'Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator';
 }

src/Enum/SymfonyRuleIdentifier.php

@@ -41,4 +41,6 @@ final class SymfonyRuleIdentifier
     public const NO_FIND_TAGGED_SERVICE_IDS_CALL = 'symfony.noFindTaggedServiceIdsCall';
 
     public const REQUIRE_ROUTE_NAME_TO_GENERATE_CONTROLLER_ROUTE = 'symfony.requireRouteNameToGenerateControllerRoute';
+
+    public const SERVICES_EXCLUDED_DIRECTORY_MUST_EXIST = 'symfony.servicesExcludedDirectoryMustExist';
 }

src/Rules/Symfony/ConfigClosure/ServicesExcludedDirectoryMustExistRule.php

@@ -0,0 +1,151 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Rules\Symfony\ConfigClosure;
+
+use PhpParser\Node;
+use PhpParser\Node\ArrayItem;
+use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Expr\BinaryOp;
+use PhpParser\Node\Expr\BinaryOp\Concat;
+use PhpParser\Node\Expr\Closure;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Scalar\MagicConst\Dir;
+use PhpParser\Node\Scalar\String_;
+use PhpParser\NodeFinder;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use Symplify\PHPStanRules\Enum\SymfonyRuleIdentifier;
+use Symplify\PHPStanRules\Symfony\NodeAnalyzer\SymfonyClosureDetector;
+
+/**
+ * @implements Rule<Closure>
+ */
+final class ServicesExcludedDirectoryMustExistRule implements Rule
+{
+    /**
+     * @var string
+     */
+    public const ERROR_MESSAGE = 'Services excluded path "%s" does not exists. You can remove it';
+
+    public function getNodeType(): string
+    {
+        return Closure::class;
+    }
+
+    /**
+     * @param Closure $node
+     * @return IdentifierRuleError[]
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (! SymfonyClosureDetector::detect($node)) {
+            return [];
+        }
+
+        $excludeMethodCalls = $this->resolveExcludeMethodCalls($node);
+        if ($excludeMethodCalls === []) {
+            return [];
+        }
+
+        $ruleErrors = [];
+
+        foreach ($excludeMethodCalls as $excludeMethodCall) {
+            // check all array args
+            $firstArgValue = $excludeMethodCall->getArgs()[0]->value;
+            if (! $firstArgValue instanceof Array_) {
+                continue;
+            }
+
+            foreach ($firstArgValue->items as $arrayItem) {
+                $directoryPath = $this->resolveDirectoryPath($arrayItem, $scope);
+                if (! is_string($directoryPath)) {
+                    continue;
+                }
+
+                // path exists, all good
+                if (file_exists($directoryPath)) {
+                    continue;
+                }
+
+                /** @var BinaryOp $binarOp */
+                $binarOp = $arrayItem->value;
+
+                /** @var String_ $pathValue */
+                $pathValue = $binarOp->right;
+
+                $errorMessage = sprintf(self::ERROR_MESSAGE, $pathValue->value);
+
+                $ruleErrors[] = RuleErrorBuilder::message($errorMessage)
+                    ->line($arrayItem->getStartLine())
+                    ->identifier(SymfonyRuleIdentifier::SERVICES_EXCLUDED_DIRECTORY_MUST_EXIST)
+                    ->build();
+            }
+        }
+
+        return $ruleErrors;
+    }
+
+    private function resolveDirectoryPath(ArrayItem $arrayItem, Scope $scope): ?string
+    {
+        if (! $arrayItem->value instanceof Concat) {
+            return null;
+        }
+
+        $concat = $arrayItem->value;
+        if (! $concat->left instanceof Dir) {
+            return null;
+        }
+
+        if (! $concat->right instanceof String_) {
+            return null;
+        }
+
+        $stringPart = $concat->right->value;
+
+        // uses magic mask, nothing to validate
+        if (str_contains($stringPart, '*') || str_contains($stringPart, '{')) {
+            return null;
+        }
+
+        // check full path
+        $directory = dirname($scope->getFile());
+        return $directory . '/' . $stringPart;
+    }
+
+    /**
+     * @return array<MethodCall>
+     */
+    private function resolveExcludeMethodCalls(Closure $closure): array
+    {
+        $nodeFinder = new NodeFinder();
+
+        $methodCalls = $nodeFinder->find($closure, function (Node $node): bool {
+            if (! $node instanceof MethodCall) {
+                return false;
+            }
+
+            if ($node->isFirstClassCallable()) {
+                return false;
+            }
+
+            // must have exactly 1 arg
+            if (count($node->getArgs()) !== 1) {
+                return false;
+            }
+
+            if (! $node->name instanceof Identifier) {
+                return false;
+            }
+
+            return $node->name->toString() === 'exclude';
+        });
+
+        /** @var MethodCall[] $methodCalls */
+        return $methodCalls;
+    }
+}

src/Rules/Symfony/FormTypeClassNameRule.php

@@ -22,6 +22,11 @@
  */
 final class FormTypeClassNameRule implements Rule
 {
+    /**
+     * @var string
+     */
+    public const ERROR_MESSAGE = 'Class extends "%s" must have "FormType" suffix to make form explicit, "%s" given';
+
     public function getNodeType(): string
     {
         return Class_::class;
@@ -50,11 +55,7 @@ public function processNode(Node $node, Scope $scope): array
             return [];
         }
 
-        $errorMessage = sprintf(
-            'Class extends "%s" must have "FormType" suffix to make form explicit, "%s" given',
-            SymfonyClass::FORM_TYPE,
-            $className
-        );
+        $errorMessage = sprintf(self::ERROR_MESSAGE, SymfonyClass::FORM_TYPE, $className);
 
         $identifierRuleError = RuleErrorBuilder::message($errorMessage)
             ->identifier(SymfonyRuleIdentifier::FORM_TYPE_CLASS_NAME)

src/Symfony/NodeAnalyzer/SymfonyClosureDetector.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Symfony\NodeAnalyzer;
+
+use PhpParser\Node\Expr\Closure;
+use PhpParser\Node\Name;
+use Symplify\PHPStanRules\Enum\SymfonyClass;
+
+final class SymfonyClosureDetector
+{
+    public static function detect(Closure $closure): bool
+    {
+        if (count($closure->getParams()) !== 1) {
+            return false;
+        }
+
+        $onlyParam = $closure->getParams()[0];
+        if (! $onlyParam->type instanceof Name) {
+            return false;
+        }
+
+        $parameterName = $onlyParam->type->toString();
+        return $parameterName === SymfonyClass::CONTAINER_CONFIGURATOR;
+    }
+}

tests/Rules/Symfony/ConfigClosure/ServicesExcludedDirectoryMustExistRule/Fixture/SkipInvalidPath.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\ConfigClosure\ServicesExcludedDirectoryMustExistRule\Fixture;
+
+use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+return function (ContainerConfigurator $container) {
+    $services = $container->services();
+    $services->load('App\\', __DIR__ . '/../src')
+        ->exclude([
+            __DIR__ . '/../*/missing'
+        ]);
+};

tests/Rules/Symfony/ConfigClosure/ServicesExcludedDirectoryMustExistRule/Fixture/SkipMaskPath.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\ConfigClosure\ServicesExcludedDirectoryMustExistRule\Fixture;
+
+use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+return function (ContainerConfigurator $container) {
+    $services = $container->services();
+    $services->load('App\\', __DIR__ . '/../src')
+        ->exclude([
+            __DIR__ . '/../{missing,here}'
+        ]);
+};

tests/Rules/Symfony/ConfigClosure/ServicesExcludedDirectoryMustExistRule/Fixture/SomeConfigWithInvalidExclude.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\Symfony\ConfigClosure\ServicesExcludedDirectoryMustExistRule\Fixture;
+
+use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+return function (ContainerConfigurator $container) {
+    $services = $container->services();
+    $services->load('App\\', __DIR__ . '/../src')
+        ->exclude([
+            __DIR__ . '/../missing'
+        ]);
+};