AddNamedArgumentsRector::refactor() - Code Metrics - savinmikhail/AddNamedArgumentsRector - Measure and Improve Code Quality continuously with Scrutinizer

AddNamedArgumentsRector::refactor() A
last analyzed 2025-09-04 07:18 UTC

↳ Parent: AddNamedArgumentsRector

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	2
eloc	6
c	3
b	0
f	0
nc	2
nop	1
dl	0
loc	13
ccs	7
cts	7
cp	1
crap	2
rs	10

<?php

declare(strict_types=1);

namespace SavinMikhail\AddNamedArgumentsRector;

use InvalidArgumentException;
use PhpParser\ConstExprEvaluator;
use PhpParser\Node;
use PhpParser\Node\Arg;
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 PHPStan\Reflection\ExtendedParameterReflection;
filter:
    dependency_paths: ["lib/*"]
use PHPStan\Reflection\ReflectionProvider;
filter:
    dependency_paths: ["lib/*"]
use PHPStan\Type\ConstantScalarType;
filter:
    dependency_paths: ["lib/*"]
use Rector\Contract\Rector\ConfigurableRectorInterface;
use Rector\NodeNameResolver\NodeNameResolver;
use Rector\NodeTypeResolver\NodeTypeResolver;
use Rector\Rector\AbstractRector;
use Rector\ValueObject\PhpVersion;
use Rector\VersionBonding\Contract\MinPhpVersionInterface;
use RuntimeException;
use SavinMikhail\AddNamedArgumentsRector\Config\ConfigStrategy;
use SavinMikhail\AddNamedArgumentsRector\Config\DefaultStrategy;
filter:
    dependency_paths: ["lib/*"]
use SavinMikhail\AddNamedArgumentsRector\Reflection\Reflection;
filter:
    dependency_paths: ["lib/*"]
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
use Throwable;
use Webmozart\Assert\Assert;

use function constant;
use function count;
use function defined;

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

    private readonly Reflection $reflectionService;

    private readonly ConstExprEvaluator $constExprEvaluator;

    public function __construct(
        ReflectionProvider $reflectionProvider,
        NodeNameResolver $nodeNameResolver,
        NodeTypeResolver $nodeTypeResolver,
        ?Reflection $reflectionService = null,
        ?ConstExprEvaluator $constExprEvaluator = null,
    ) {
        if ($reflectionService === null) {
            $reflectionService = new Reflection(
                reflectionProvider: $reflectionProvider,
                nodeNameResolver: $nodeNameResolver,
                nodeTypeResolver: $nodeTypeResolver,
            );
        }
        $this->reflectionService = $reflectionService;

        $this->constExprEvaluator = $constExprEvaluator ?? new ConstExprEvaluator(static function (string $name) {

            if (defined($name)) {
                return constant($name);
            }

            throw new RuntimeException("Undefined constant: {$name}");
        });
    }

    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
    {
        /** @var FuncCall|StaticCall|MethodCall|New_ $node */
        $parameters = $this->reflectionService->getParameters(node: $node);
        $classReflection = $this->reflectionService->getClassReflection(node: $node);

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

        $this->addNamesToArgs(node: $node, parameters: $parameters);

        return $node;
    }

    /**
     * @param ExtendedParameterReflection[] $parameters
     */
    private function addNamesToArgs(
        FuncCall|StaticCall|MethodCall|New_ $node,
        array $parameters,
    ): void {
        $namedArgs = [];
        foreach ($node->args as $index => $arg) {
            $parameter = $parameters[$index] ?? null;
            if ($parameter === null) {
                $namedArgs[] = $arg;

                continue;
            }

            if ($this->shouldSkipArg($arg, $parameter)) {
            if ($this->shouldSkipArg(/** @scrutinizer ignore-type */ $arg, $parameter)) {
                continue;
            }

            $arg->name = new Identifier(name: $parameter->getName());

            $namedArgs[] = $arg;
        }

        $node->args = $namedArgs;
    }

    private function shouldSkipArg(Arg $arg, ExtendedParameterReflection $parameter): bool
    {
        try {
            $defaultValue = $parameter->getDefaultValue();
        } catch (Throwable) {
            return false;
        }

        try {
            $argValue = $this->constExprEvaluator->evaluateDirectly($arg->value);
        } catch (Throwable) {
            return false;
        }

        if ($defaultValue instanceof ConstantScalarType) {
            $defaultValue = $defaultValue->getValue();
        }

        return $argValue === $defaultValue;
    }

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

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

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

        $strategy = new $strategyClass();

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

        $this->configStrategy = $strategyClass;
    }
}


savinmikhail / AddNamedArgumentsRector

AddNamedArgumentsRector::refactor() A last analyzed 2025-09-04 07:18 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AddNamedArgumentsRector::refactor() A
last analyzed 2025-09-04 07:18 UTC