AddNamedArgumentsRector::addNamesToArgs() - Code Metrics - Inspection of "fix cs" - savinmikhail/AddNamedArgumentsRector - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 6ae173...96ec27 )

by mikhail

created 2025-02-16 05:18 UTC

AddNamedArgumentsRector::addNamesToArgs() B

↳ Parent: AddNamedArgumentsRector

Complexity

Conditions	8
Paths	8

Size

Total Lines	32
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	8.1515

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	8
eloc	14
c	2
b	0
f	0
nc	8
nop	2
dl	0
loc	32
ccs	13
cts	15
cp	0.8667
crap	8.1515
rs	8.4444

<?php

declare(strict_types=1);

namespace SavinMikhail\AddNamedArgumentsRector;

use InvalidArgumentException;
use PhpParser\Node;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\New_;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name;
use PHPStan\Reflection\ClassMemberAccessAnswerer;
filter:
    dependency_paths: ["lib/*"]
use PHPStan\Reflection\ExtendedParameterReflection;
filter:
    dependency_paths: ["lib/*"]
use PHPStan\Reflection\ReflectionProvider;
filter:
    dependency_paths: ["lib/*"]
use Rector\Contract\Rector\ConfigurableRectorInterface;
use Rector\NodeTypeResolver\Node\AttributeKey;
use Rector\Rector\AbstractRector;
use Rector\ValueObject\PhpVersion;
use Rector\VersionBonding\Contract\MinPhpVersionInterface;
use SavinMikhail\AddNamedArgumentsRector\Config\ConfigStrategy;
use SavinMikhail\AddNamedArgumentsRector\Config\DefaultStrategy;
filter:
    dependency_paths: ["lib/*"]
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
use Webmozart\Assert\Assert;

use function count;

/**
 * @see AddNamedArgumentsRectorTest
 */
final class AddNamedArgumentsRector extends AbstractRector implements MinPhpVersionInterface, ConfigurableRectorInterface
{
    private string $configStrategy = DefaultStrategy::class;

    public function __construct(
        private readonly ReflectionProvider $reflectionProvider,
    ) {}

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition('Convert all arguments to named arguments', codeSamples: [
            new CodeSample(
                badCode: '$user->setPassword("123456");',
                goodCode: '$user->changePassword(password: "123456");',
            ),
        ]);
    }

    public function getNodeTypes(): array
    {
        return [FuncCall::class, StaticCall::class, MethodCall::class, New_::class];
    }

    public function refactor(Node $node): ?Node
    {
        $parameters = $this->getParameters($node);

        if (!$this->configStrategy::shouldApply($node, $parameters)) {
            return null;
        }

        /** @var FuncCall|StaticCall|MethodCall|New_ $node */
        $hasChanged = $this->addNamesToArgs($node, $parameters);

        return $hasChanged ? $node : null;
    }

    /**
     * @return ExtendedParameterReflection[]
     */
    private function getParameters(Node $node): array
    {
        $parameters = [];

        if ($node instanceof New_) {
            $parameters = $this->getConstructorArgs($node);
        } elseif ($node instanceof MethodCall) {
            $parameters = $this->getMethodArgs($node);
        } elseif ($node instanceof StaticCall) {
            $parameters = $this->getStaticMethodArgs($node);
        } elseif ($node instanceof FuncCall) {
            $parameters = $this->getFuncArgs($node);
        }

        return $parameters;
    }

    /**
     * @return ExtendedParameterReflection[]
     */
    private function getStaticMethodArgs(StaticCall $node): array
    {
        if (! $node->class instanceof Name) {
            return [];
        }

        $className = $this->getName($node->class);
        if (! $this->reflectionProvider->hasClass($className)) {
            return [];
        }

        $classReflection = $this->reflectionProvider->getClass($className);

        if ($node->name instanceof Identifier) {
            $methodName = $node->name->name;
        } elseif ($node->name instanceof Name) {

            $methodName = (string) $node->name;
        } else {
            return [];
        }

        if (! $classReflection->hasMethod($methodName)) {
            return [];
        }

        /** @var ClassMemberAccessAnswerer $scope */
        $scope = $node->getAttribute(AttributeKey::SCOPE);
        $methodReflection = $classReflection->getMethod($methodName, $scope);

        return $methodReflection->getOnlyVariant()
            ->getParameters();
    }

    /**
     * @return ExtendedParameterReflection[]
     */
    private function getMethodArgs(MethodCall $node): array
    {
        $callerType = $this->nodeTypeResolver->getType($node->var);
        $name = $node->name;
        if ($name instanceof Node\Expr) {
            return [];
        }
        $methodName = $name->name;

        if (! $callerType->hasMethod($methodName)->yes()) {
            return [];
        }

        /** @var ClassMemberAccessAnswerer $scope */
        $scope = $node->getAttribute(AttributeKey::SCOPE);
        $methodReflection = $callerType->getMethod($methodName, $scope);

        return $methodReflection->getOnlyVariant()
            ->getParameters();
    }

    private function resolveCalledName(Node $node): ?string
    {
        if ($node instanceof FuncCall && $node->name instanceof Name) {
            return (string) $node->name;
        }

        if ($node instanceof MethodCall && $node->name instanceof Identifier) {
            return (string) $node->name;
        }

        if ($node instanceof StaticCall && $node->name instanceof Identifier) {
            return (string) $node->name;
        }

        if ($node instanceof New_ && $node->class instanceof Name) {
            return (string) $node->class;
        }

        return null;
    }

    /**
     * @return ExtendedParameterReflection[]
     */
    private function getConstructorArgs(New_ $node): array
    {
        $calledName = $this->resolveCalledName($node);
        if ($calledName === null) {
            return [];
        }

        if (! $this->reflectionProvider->hasClass($calledName)) {
            return [];
        }
        $classReflection = $this->reflectionProvider->getClass($calledName);

        if (! $classReflection->hasConstructor()) {
            return [];
        }

        $constructorReflection = $classReflection->getConstructor();

        return $constructorReflection->getOnlyVariant()
            ->getParameters();
    }

    /**
     * @return ExtendedParameterReflection[]
     */
    private function getFuncArgs(FuncCall $node): array
    {
        $calledName = $this->resolveCalledName($node);
        if ($calledName === null) {
            return [];
        }

        $scope = $node->getAttribute(AttributeKey::SCOPE);

        if (! $this->reflectionProvider->hasFunction(new Name($calledName), $scope)) {
            return [];
        }
        $reflection = $this->reflectionProvider->getFunction(new Name($calledName), $scope);

        return $reflection
            ->getOnlyVariant()
            ->getParameters();
    }

    /**
     * @param ExtendedParameterReflection[] $parameters
     */
    private function addNamesToArgs(
        FuncCall|StaticCall|MethodCall|New_ $node,
        array $parameters,
    ): bool {
        $argNames = [];
        foreach ($node->args as $index => $arg) {
            if (! isset($parameters[$index])) {
                return false;
            }

            // Skip variadic parameters (...$param)
            if ($parameters[$index]->isVariadic()) {
                return false;
            }

            // Skip unpacking arguments (...$var)
            if ($arg instanceof Node\Arg && $arg->unpack) {
                return false;
            }

            if ($arg instanceof Node\VariadicPlaceholder) {
                return false;
            }

            $argNames[$index] = new Identifier($parameters[$index]->getName());
        }

        foreach ($node->args as $index => $arg) {
            $arg->name = $argNames[$index];

        }

        return true;
    }

    public function provideMinPhpVersion(): int
    {
        return PhpVersion::PHP_80;
    }

    public function configure(array $configuration): void
    {
        Assert::lessThan(count($configuration), 2, 'You can pass only 1 strategy');
        if ($configuration === []) {
            return;
        }
        $strategyClass = $configuration[0];

        if (!class_exists($strategyClass)) {
            throw new InvalidArgumentException("Class {$strategyClass} does not exist.");
        }

        $strategy = new $strategyClass();

        Assert::isInstanceOf($strategy, ConfigStrategy::class, 'Your strategy must implement ConfigStrategy interface');

        $this->configStrategy = $strategyClass;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace SavinMikhail\AddNamedArgumentsRector;
6
7		use InvalidArgumentException;
8		use PhpParser\Node;
9		use PhpParser\Node\Expr\FuncCall;
10		use PhpParser\Node\Expr\MethodCall;
11		use PhpParser\Node\Expr\New_;
12		use PhpParser\Node\Expr\StaticCall;
13		use PhpParser\Node\Identifier;
14		use PhpParser\Node\Name;
15		use PHPStan\Reflection\ClassMemberAccessAnswerer;
		0 ignored issues – show Bug introduced 2025-01-21 03:50 UTC by Report Bug Copy Issue Report The type `PHPStan\Reflection\ClassMemberAccessAnswerer` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
16		use PHPStan\Reflection\ExtendedParameterReflection;
		0 ignored issues – show Bug introduced 2025-01-21 03:50 UTC by Report Bug Copy Issue Report The type `PHPStan\Reflection\ExtendedParameterReflection` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
17		use PHPStan\Reflection\ReflectionProvider;
		0 ignored issues – show Bug introduced 2025-01-21 03:50 UTC by Report Bug Copy Issue Report The type `PHPStan\Reflection\ReflectionProvider` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
18		use Rector\Contract\Rector\ConfigurableRectorInterface;
19		use Rector\NodeTypeResolver\Node\AttributeKey;
20		use Rector\Rector\AbstractRector;
21		use Rector\ValueObject\PhpVersion;
22		use Rector\VersionBonding\Contract\MinPhpVersionInterface;
23		use SavinMikhail\AddNamedArgumentsRector\Config\ConfigStrategy;
24		use SavinMikhail\AddNamedArgumentsRector\Config\DefaultStrategy;
		0 ignored issues – show Bug introduced 2025-01-21 03:50 UTC by Report Bug Copy Issue Report The type `SavinMikhail\AddNamedArg...\Config\DefaultStrategy` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
25		use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
26		use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
27		use Webmozart\Assert\Assert;
28
29		use function count;
30
31		/**
32		* @see AddNamedArgumentsRectorTest
33		*/
34		final class AddNamedArgumentsRector extends AbstractRector implements MinPhpVersionInterface, ConfigurableRectorInterface
35		{
36		private string $configStrategy = DefaultStrategy::class;
37
38	2	public function __construct(
39		private readonly ReflectionProvider $reflectionProvider,
40	2	) {}
41
42		public function getRuleDefinition(): RuleDefinition
43		{
44		return new RuleDefinition('Convert all arguments to named arguments', codeSamples: [
45		new CodeSample(
46		badCode: '$user->setPassword("123456");',
47		goodCode: '$user->changePassword(password: "123456");',
48		),
49		]);
50		}
51
52	8	public function getNodeTypes(): array
53		{
54	8	return [FuncCall::class, StaticCall::class, MethodCall::class, New_::class];
55		}
56
57	8	public function refactor(Node $node): ?Node
58		{
59	8	$parameters = $this->getParameters($node);
60
61	8	if (!$this->configStrategy::shouldApply($node, $parameters)) {
62	1	return null;
63		}
64
65		/** @var FuncCall\|StaticCall\|MethodCall\|New_ $node */
66	8	$hasChanged = $this->addNamesToArgs($node, $parameters);
67
68	8	return $hasChanged ? $node : null;
69		}
70
71		/**
72		* @return ExtendedParameterReflection[]
73		*/
74	8	private function getParameters(Node $node): array
75		{
76	8	$parameters = [];
77
78	8	if ($node instanceof New_) {
79	2	$parameters = $this->getConstructorArgs($node);
80	7	} elseif ($node instanceof MethodCall) {
81	1	$parameters = $this->getMethodArgs($node);
82	6	} elseif ($node instanceof StaticCall) {
83	1	$parameters = $this->getStaticMethodArgs($node);
84	5	} elseif ($node instanceof FuncCall) {
85	5	$parameters = $this->getFuncArgs($node);
86		}
87
88	8	return $parameters;
89		}
90
91		/**
92		* @return ExtendedParameterReflection[]
93		*/
94	1	private function getStaticMethodArgs(StaticCall $node): array
95		{
96	1	if (! $node->class instanceof Name) {
97		return [];
98		}
99
100	1	$className = $this->getName($node->class);
101	1	if (! $this->reflectionProvider->hasClass($className)) {
102		return [];
103		}
104
105	1	$classReflection = $this->reflectionProvider->getClass($className);
106
107	1	if ($node->name instanceof Identifier) {
108	1	$methodName = $node->name->name;
109		} elseif ($node->name instanceof Name) {
		0 ignored issues – show introduced 2025-01-21 03:50 UTC by Report Bug Copy Issue Report `$node->name` is never a sub-type of `PhpParser\Node\Name`. Loading history...
110		$methodName = (string) $node->name;
111		} else {
112		return [];
113		}
114
115	1	if (! $classReflection->hasMethod($methodName)) {
116		return [];
117		}
118
119		/** @var ClassMemberAccessAnswerer $scope */
120	1	$scope = $node->getAttribute(AttributeKey::SCOPE);
121	1	$methodReflection = $classReflection->getMethod($methodName, $scope);
122
123	1	return $methodReflection->getOnlyVariant()
124	1	->getParameters();
125		}
126
127		/**
128		* @return ExtendedParameterReflection[]
129		*/
130	1	private function getMethodArgs(MethodCall $node): array
131		{
132	1	$callerType = $this->nodeTypeResolver->getType($node->var);
133	1	$name = $node->name;
134	1	if ($name instanceof Node\Expr) {
135		return [];
136		}
137	1	$methodName = $name->name;
138
139	1	if (! $callerType->hasMethod($methodName)->yes()) {
140		return [];
141		}
142
143		/** @var ClassMemberAccessAnswerer $scope */
144	1	$scope = $node->getAttribute(AttributeKey::SCOPE);
145	1	$methodReflection = $callerType->getMethod($methodName, $scope);
146
147	1	return $methodReflection->getOnlyVariant()
148	1	->getParameters();
149		}
150
151	7	private function resolveCalledName(Node $node): ?string
152		{
153	7	if ($node instanceof FuncCall && $node->name instanceof Name) {
154	5	return (string) $node->name;
155		}
156
157	2	if ($node instanceof MethodCall && $node->name instanceof Identifier) {
158		return (string) $node->name;
159		}
160
161	2	if ($node instanceof StaticCall && $node->name instanceof Identifier) {
162		return (string) $node->name;
163		}
164
165	2	if ($node instanceof New_ && $node->class instanceof Name) {
166	2	return (string) $node->class;
167		}
168
169		return null;
170		}
171
172		/**
173		* @return ExtendedParameterReflection[]
174		*/
175	2	private function getConstructorArgs(New_ $node): array
176		{
177	2	$calledName = $this->resolveCalledName($node);
178	2	if ($calledName === null) {
179		return [];
180		}
181
182	2	if (! $this->reflectionProvider->hasClass($calledName)) {
183		return [];
184		}
185	2	$classReflection = $this->reflectionProvider->getClass($calledName);
186
187	2	if (! $classReflection->hasConstructor()) {
188		return [];
189		}
190
191	2	$constructorReflection = $classReflection->getConstructor();
192
193	2	return $constructorReflection->getOnlyVariant()
194	2	->getParameters();
195		}
196
197		/**
198		* @return ExtendedParameterReflection[]
199		*/
200	5	private function getFuncArgs(FuncCall $node): array
201		{
202	5	$calledName = $this->resolveCalledName($node);
203	5	if ($calledName === null) {
204		return [];
205		}
206
207	5	$scope = $node->getAttribute(AttributeKey::SCOPE);
208
209	5	if (! $this->reflectionProvider->hasFunction(new Name($calledName), $scope)) {
210		return [];
211		}
212	5	$reflection = $this->reflectionProvider->getFunction(new Name($calledName), $scope);
213
214	5	return $reflection
215	5	->getOnlyVariant()
216	5	->getParameters();
217		}
218
219		/**
220		* @param ExtendedParameterReflection[] $parameters
221		*/
222	8	private function addNamesToArgs(
223		FuncCall\|StaticCall\|MethodCall\|New_ $node,
224		array $parameters,
225		): bool {
226	8	$argNames = [];
227	8	foreach ($node->args as $index => $arg) {
228	8	if (! isset($parameters[$index])) {
229		return false;
230		}
231
232		// Skip variadic parameters (...$param)
233	8	if ($parameters[$index]->isVariadic()) {
234	1	return false;
235		}
236
237		// Skip unpacking arguments (...$var)
238	8	if ($arg instanceof Node\Arg && $arg->unpack) {
239	1	return false;
240		}
241
242	7	if ($arg instanceof Node\VariadicPlaceholder) {
243		return false;
244		}
245
246	7	$argNames[$index] = new Identifier($parameters[$index]->getName());
247		}
248
249	6	foreach ($node->args as $index => $arg) {
250	6	$arg->name = $argNames[$index];
		0 ignored issues – show Bug introduced 2025-02-16 05:21 UTC by Report Bug Copy Issue Report The property `name` does not seem to exist on `PhpParser\Node\VariadicPlaceholder`. Loading history...
251		}
252
253	6	return true;
254		}
255
256	2	public function provideMinPhpVersion(): int
257		{
258	2	return PhpVersion::PHP_80;
259		}
260
261	1	public function configure(array $configuration): void
262		{
263	1	Assert::lessThan(count($configuration), 2, 'You can pass only 1 strategy');
264	1	if ($configuration === []) {
265		return;
266		}
267	1	$strategyClass = $configuration[0];
268
269	1	if (!class_exists($strategyClass)) {
270		throw new InvalidArgumentException("Class {$strategyClass} does not exist.");
271		}
272
273	1	$strategy = new $strategyClass();
274
275	1	Assert::isInstanceOf($strategy, ConfigStrategy::class, 'Your strategy must implement ConfigStrategy interface');
276
277	1	$this->configStrategy = $strategyClass;
278		}
279		}
280

savinmikhail / AddNamedArgumentsRector

Push — main ( 6ae173...96ec27 )

AddNamedArgumentsRector::addNamesToArgs() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like