16610059202

Committed 29 Jul 2025 11:59PM UTC coverage: 99.583% (-0.4%) from 100.0%

Build # 16610059202

Build Type

Pull #31

github

Committed by

web-flow

Commit Message

Merge 380389517 into 20b3f6015

Pull Request Pull Request #31: Add NoPublicStaticMethods rule

Run Details

30 of 31 new or added lines in 1 file covered. (96.77%)

239 of 240 relevant lines covered (99.58%)

33.4 hits per line

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

96.77

/src/Rules/NoStaticMethodsRule.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 NoStaticMethodsRule 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.noStaticMethods';

    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 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 NoStaticMethodsRule 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.noStaticMethods';
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 classes with private constructors using reflection
68	if ($this->hasPrivateConstructor($node)) {	24✔
69	return [];	12✔
70	}
71
72	return $this->processPublicStaticMethods($node);	24✔
73	}
74
75	private function isTestFile(Scope $scope): bool
76	{
77	// Check if file ends with "Test.php" or "TestCase.php"
78	return str_ends_with($scope->getFile(), 'Test.php')	48✔
79	\|\| str_ends_with($scope->getFile(), 'TestCase.php');	48✔
80	}
81
82	private function getReflection(Class_ $node): ?ClassReflection
83	{
84	if (null === $node->namespacedName) {	24✔
85	return null;	12✔
86	}
87
88	$name = $node->namespacedName->toString();	24✔
89
90	if (!$this->reflectionProvider->hasClass($name)) {	24✔
NEW 91	return null;	×
92	}
93
94	return $this->reflectionProvider->getClass($name);	24✔
95	}
96
97	/**
98	* Check if class has a private constructor
99	*/
100	private function hasPrivateConstructor(Class_ $node): bool
101	{
102	$classReflection = $this->getReflection($node);	24✔
103	return $classReflection?->hasConstructor() && $classReflection->getConstructor()->isPrivate();	24✔
104	}
105
106	/**
107	* Process public static methods and return errors for violations
108	* @return list<IdentifierRuleError>
109	*/
110	private function processPublicStaticMethods(Class_ $node): array
111	{
112	$publicStaticMethods = $this->getPublicStaticMethods($node);	24✔
113	$additionalMethods = array_slice($publicStaticMethods, 1);	24✔
114
115	// Create error for each additional public static method (beyond the first one)
116	$errors = [];	24✔
117	foreach ($additionalMethods as $method) {	24✔
118	$errors[] = RuleErrorBuilder::message(self::ERROR_MESSAGE)	24✔
119	->line($method->getLine())	24✔
120	->identifier(self::IDENTIFIER)	24✔
121	->build();	24✔
122	}
123
124	return $errors;	24✔
125	}
126
127
128	/**
129	* @return ClassMethod[]
130	*/
131	private function getPublicStaticMethods(Class_ $class): array
132	{
133	$methods = [];	24✔
134
135	foreach ($class->stmts as $stmt) {	24✔
136	if ($stmt instanceof ClassMethod && $stmt->isStatic() && $stmt->isPublic()) {	24✔
137	$methods[] = $stmt;	24✔
138	}
139	}
140
141	return $methods;	24✔
142	}
143	}

sanmai / phpstan-rules / 16610059202

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