16611207729

Committed 30 Jul 2025 01:26AM UTC coverage: 99.587% (-0.4%) from 100.0%

Build # 16611207729

Build Type

Pull #31

github

Committed by

web-flow

Commit Message

Merge f7d082ff6 into ead5abd39

Pull Request Pull Request #31: Add NoPublicStaticMethods rule

Run Details

32 of 33 new or added lines in 1 file covered. (96.97%)

241 of 242 relevant lines covered (99.59%)

32.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.97

/src/Rules/NoPublicStaticMethodsRule.php

<?php

/**
 * Copyright 2025 Alexey Kopytko <alexey@kopytko.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

declare(strict_types=1);

namespace Sanmai\PHPStanRules\Rules;

use Override;
use PhpParser\Node;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassMethod;
use PHPStan\Analyser\Scope;
use PHPStan\Reflection\ReflectionProvider;
use PHPStan\Rules\IdentifierRuleError;
use PHPStan\Rules\Rule;
use PHPStan\Rules\RuleErrorBuilder;
use PHPStan\Reflection\ClassReflection;

use function array_slice;
use function str_ends_with;

/**
 * @implements Rule<Class_>
 */
final class NoPublicStaticMethodsRule implements Rule
{
    public const ERROR_MESSAGE = 'Only one public static method is allowed per class. Static methods are impossible to mock in tests.';
    public const IDENTIFIER = 'sanmai.noPublicStaticMethods';

    public function __construct(
        private ReflectionProvider $reflectionProvider
    ) {}

    #[Override]
    public function getNodeType(): string
    {
        return Class_::class;
    }

    /**
     * @return list<IdentifierRuleError>
     * @param Class_ $node
     */
    #[Override]
    public function processNode(Node $node, Scope $scope): array
    {
        // Skip test files - they commonly need multiple static methods for data providers
        if ($this->isTestFile($scope)) {
            return [];
        }

        // Skip abstract classes - they often have multiple static utility methods
        if ($node->isAbstract()) {
            return [];
        }

        // Skip classes with private constructors using reflection
        if ($this->hasPrivateConstructor($node)) {
            return [];
        }

        return $this->processPublicStaticMethods($node);
    }

    private function isTestFile(Scope $scope): bool
    {
        // Check if file ends with "Test.php" or "TestCase.php"
        return str_ends_with($scope->getFile(), 'Test.php')
            || str_ends_with($scope->getFile(), 'TestCase.php');
    }

    private function getReflection(Class_ $node): ?ClassReflection
    {
        if (null === $node->namespacedName) {
            return null;
        }

        $name = $node->namespacedName->toString();

        if (!$this->reflectionProvider->hasClass($name)) {
            return null;
        }

        return $this->reflectionProvider->getClass($name);
    }

    /**
     * Check if class has a private constructor
     */
    private function hasPrivateConstructor(Class_ $node): bool
    {
        $classReflection = $this->getReflection($node);
        return $classReflection?->hasConstructor() && $classReflection->getConstructor()->isPrivate();
    }

    /**
     * Process public static methods and return errors for violations
     * @return list<IdentifierRuleError>
     */
    private function processPublicStaticMethods(Class_ $node): array
    {
        $publicStaticMethods = $this->getPublicStaticMethods($node);
        $additionalMethods = array_slice($publicStaticMethods, 1);

        // Create error for each additional public static method (beyond the first one)
        $errors = [];
        foreach ($additionalMethods as $method) {
            $errors[] = RuleErrorBuilder::message(self::ERROR_MESSAGE)
                ->line($method->getLine())
                ->identifier(self::IDENTIFIER)
                ->build();
        }

        return $errors;
    }


    /**
     * @return ClassMethod[]
     */
    private function getPublicStaticMethods(Class_ $class): array
    {
        $methods = [];

        foreach ($class->stmts as $stmt) {
            if ($stmt instanceof ClassMethod && $stmt->isStatic() && $stmt->isPublic()) {
                $methods[] = $stmt;
            }
        }

        return $methods;
    }
}

1	<?php
2
3	/**
4	* Copyright 2025 Alexey Kopytko <alexey@kopytko.com>
5	*
6	* Licensed under the Apache License, Version 2.0 (the "License");
7	* you may not use this file except in compliance with the License.
8	* You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing, software
13	* distributed under the License is distributed on an "AS IS" BASIS,
14	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15	* See the License for the specific language governing permissions and
16	* limitations under the License.
17	*/
18
19	declare(strict_types=1);
20
21	namespace Sanmai\PHPStanRules\Rules;
22
23	use Override;
24	use PhpParser\Node;
25	use PhpParser\Node\Stmt\Class_;
26	use PhpParser\Node\Stmt\ClassMethod;
27	use PHPStan\Analyser\Scope;
28	use PHPStan\Reflection\ReflectionProvider;
29	use PHPStan\Rules\IdentifierRuleError;
30	use PHPStan\Rules\Rule;
31	use PHPStan\Rules\RuleErrorBuilder;
32	use PHPStan\Reflection\ClassReflection;
33
34	use function array_slice;
35	use function str_ends_with;
36
37	/**
38	* @implements Rule<Class_>
39	*/
40	final class NoPublicStaticMethodsRule implements Rule
41	{
42	public const ERROR_MESSAGE = 'Only one public static method is allowed per class. Static methods are impossible to mock in tests.';
43	public const IDENTIFIER = 'sanmai.noPublicStaticMethods';
44
45	public function __construct(
46	private ReflectionProvider $reflectionProvider
47	) {}	48✔
48
49	#[Override]
50	public function getNodeType(): string
51	{
52	return Class_::class;	48✔
53	}
54
55	/**
56	* @return list<IdentifierRuleError>
57	* @param Class_ $node
58	*/
59	#[Override]
60	public function processNode(Node $node, Scope $scope): array
61	{
62	// Skip test files - they commonly need multiple static methods for data providers
63	if ($this->isTestFile($scope)) {	48✔
64	return [];	24✔
65	}
66
67	// Skip abstract classes - they often have multiple static utility methods
68	if ($node->isAbstract()) {	24✔
69	return [];	12✔
70	}
71
72	// Skip classes with private constructors using reflection
73	if ($this->hasPrivateConstructor($node)) {	24✔
74	return [];	12✔
75	}
76
77	return $this->processPublicStaticMethods($node);	24✔
78	}
79
80	private function isTestFile(Scope $scope): bool
81	{
82	// Check if file ends with "Test.php" or "TestCase.php"
83	return str_ends_with($scope->getFile(), 'Test.php')	48✔
84	\|\| str_ends_with($scope->getFile(), 'TestCase.php');	48✔
85	}
86
87	private function getReflection(Class_ $node): ?ClassReflection
88	{
89	if (null === $node->namespacedName) {	24✔
90	return null;	12✔
91	}
92
93	$name = $node->namespacedName->toString();	24✔
94
95	if (!$this->reflectionProvider->hasClass($name)) {	24✔
NEW 96	return null;	×
97	}
98
99	return $this->reflectionProvider->getClass($name);	24✔
100	}
101
102	/**
103	* Check if class has a private constructor
104	*/
105	private function hasPrivateConstructor(Class_ $node): bool
106	{
107	$classReflection = $this->getReflection($node);	24✔
108	return $classReflection?->hasConstructor() && $classReflection->getConstructor()->isPrivate();	24✔
109	}
110
111	/**
112	* Process public static methods and return errors for violations
113	* @return list<IdentifierRuleError>
114	*/
115	private function processPublicStaticMethods(Class_ $node): array
116	{
117	$publicStaticMethods = $this->getPublicStaticMethods($node);	24✔
118	$additionalMethods = array_slice($publicStaticMethods, 1);	24✔
119
120	// Create error for each additional public static method (beyond the first one)
121	$errors = [];	24✔
122	foreach ($additionalMethods as $method) {	24✔
123	$errors[] = RuleErrorBuilder::message(self::ERROR_MESSAGE)	24✔
124	->line($method->getLine())	24✔
125	->identifier(self::IDENTIFIER)	24✔
126	->build();	24✔
127	}
128
129	return $errors;	24✔
130	}
131
132
133	/**
134	* @return ClassMethod[]
135	*/
136	private function getPublicStaticMethods(Class_ $class): array
137	{
138	$methods = [];	24✔
139
140	foreach ($class->stmts as $stmt) {	24✔
141	if ($stmt instanceof ClassMethod && $stmt->isStatic() && $stmt->isPublic()) {	24✔
142	$methods[] = $stmt;	24✔
143	}
144	}
145
146	return $methods;	24✔
147	}
148	}

sanmai / phpstan-rules / 16611207729

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous