PHPCS & PHPStan fixes

Author: Florian Krämer

phpcs.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<ruleset name="Phauthentic">
+    <arg name="tab-width" value="4"/>
+    <rule ref="PSR12">
+        <exclude name="Squiz.WhiteSpace.OperatorSpacing.SpacingAfter"/>
+        <exclude name="Generic.Files.LineLength.TooLong"/>
+    </rule>
+    <file>./src</file>
+    <file>./tests</file>
+</ruleset>

phpstan.neon

@@ -1,7 +1,7 @@
 parameters:
     level: 8
     paths:
-        - data
+        - src
     parallel:
         maximumNumberOfProcesses: 8
 

src/ControlStructureNestingRule.php

@@ -18,6 +18,8 @@
 
 /**
  * A rule to check the nesting level of control structures (if, else, elseif, try, catch).
+ *
+ * @implements Rule<Node>
  */
 class ControlStructureNestingRule implements Rule
 {

src/DependencyConstraintsRule.php

@@ -8,6 +8,7 @@
 use PhpParser\Node\Stmt\Use_;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
 
 /**
@@ -56,20 +57,33 @@ public function processNode(Node $node, Scope $scope): array
                 continue;
             }
 
-            foreach ($node->uses as $use) {
-                $usedClassName = $use->name->toString();
-                foreach ($disallowedDependencyPatterns as $disallowedPattern) {
-                    if (preg_match($disallowedPattern, $usedClassName)) {
-                        $errors[] = RuleErrorBuilder::message(sprintf(
-                            self::ERROR_MESSAGE,
-                            $currentNamespace,
-                            $usedClassName
-                        ))
-                        ->line($use->getStartLine())
-                        ->nonIgnorable()
-                        ->build();
+            $errors = $this->validateUseStatements($node, $disallowedDependencyPatterns, $currentNamespace, $errors);
+        }
+
+        return $errors;
+    }
 
-                    }
+    /**
+     * @param Node $node
+     * @param array<string> $disallowedDependencyPatterns
+     * @param string $currentNamespace
+     * @param array<RuleError> $errors
+     * @return array<RuleError>
+     * @throws \PHPStan\ShouldNotHappenException
+     */
+    public function validateUseStatements(Node $node, array $disallowedDependencyPatterns, string $currentNamespace, array $errors): array
+    {
+        foreach ($node->uses as $use) {
+            $usedClassName = $use->name->toString();
+            foreach ($disallowedDependencyPatterns as $disallowedPattern) {
+                if (preg_match($disallowedPattern, $usedClassName)) {
+                    $errors[] = RuleErrorBuilder::message(sprintf(
+                        self::ERROR_MESSAGE,
+                        $currentNamespace,
+                        $usedClassName
+                    ))
+                    ->line($use->getStartLine())
+                    ->build();
                 }
             }
         }

src/FinalClassRule.php

@@ -10,12 +10,23 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements Rule<Class_>
+ */
 class FinalClassRule implements Rule
 {
     private const ERROR_MESSAGE = 'Class %s must be final.';
 
+    /**
+     * @var array<string> An array of regex patterns to match against class names.
+     * e.g., ['#^App\\Domain\\.*#', '#^App\\Service\\.*#']
+     */
     protected array $patterns;
 
+    /**
+     * @param array<string> $patterns An array of regex patterns to match against class names.
+     * Each pattern should be a valid PCRE regex.
+     */
     public function __construct(array $patterns)
     {
         $this->patterns = $patterns;

src/NamespaceClassPatternRule.php

@@ -14,6 +14,8 @@
 /**
  * PHPStan rule to ensure that classes inside namespaces matching a given regex
  * must have names matching at least one of the provided patterns.
+ *
+ * @implements Rule<Namespace_>
  */
 class NamespaceClassPatternRule implements Rule
 {

src/ReadonlyClassRule.php

@@ -10,12 +10,21 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 
+/**
+ * @implements Rule<Class_>
+ */
 class ReadonlyClassRule implements Rule
 {
     private const ERROR_MESSAGE = 'Class %s must be readonly.';
 
+    /**
+     * @var string[]
+     */
     protected array $patterns;
 
+    /**
+     * @param string[] $patterns
+     */
     public function __construct(array $patterns)
     {
         $this->patterns = $patterns;

src/TooManyArgumentsRule.php

@@ -7,19 +7,31 @@
 use PhpParser\Node;
 use PhpParser\Node\Stmt\ClassMethod;
 use PHPStan\Analyser\Scope;
+use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\ShouldNotHappenException;
 
 /**
  * A configurable rule to check the number of arguments in a method.
+ *
+ * @implements Rule<ClassMethod>
  */
 class TooManyArgumentsRule implements Rule
 {
     private const ERROR_MESSAGE = 'Method %s::%s has too many arguments (%d). Maximum allowed is %d.';
 
     private int $maxArguments;
+
+    /**
+     * @var string[]
+     */
     private array $patterns;
 
+    /**
+     * @param string[] $patterns
+     */
     public function __construct(int $maxArguments, array $patterns = [])
     {
         $this->maxArguments = $maxArguments;
@@ -36,9 +48,18 @@ private function isClassMethod(Node $node): bool
         return $node instanceof ClassMethod;
     }
 
+    /**
+     * Processes the node and checks if it exceeds the maximum number of arguments.
+     *
+     * @param Node $node The node to process.
+     * @param Scope $scope The scope of the node.
+     * @return RuleError[] An array of rule errors if any.
+     * @throws ShouldNotHappenException
+     */
     public function processNode(Node $node, Scope $scope): array
     {
-        if (!$this->isClassMethod($node)
+        if (
+            !$this->isClassMethod($node)
             || !$this->matchesPattern($scope)
             || !$this->argumentCountIsExceeded($node)
         ) {
@@ -54,7 +75,8 @@ public function processNode(Node $node, Scope $scope): array
                     count($node->params),
                     $this->maxArguments
                 )
-            )->build()
+            )
+            ->build()
         ];
     }
 

tests/ControlStructureNestingRuleTest.php

@@ -1,4 +1,6 @@
-<?php declare(strict_types = 1);
+<?php
+
+declare(strict_types=1);
 
 namespace App;
 

tests/FinalClassRuleTest.php

@@ -1,4 +1,6 @@
-<?php declare(strict_types = 1);
+<?php
+
+declare(strict_types=1);
 
 namespace App;