AutowiringResolver::doReplacement() - Code Metrics - Inspection of "Improving for stability" - divineniiquaye/rade-di - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Pull Request — master (#37)

by Divine Niiquaye
created 2022-04-06 15:47 UTC
AutowiringResolver::doReplacement() A

↳ Parent: AutowiringResolver
Complexity

Conditions	6
Paths	5
Size

Total Lines	17
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
eloc	11
c	2
b	0
f	0
dl	0
loc	17
rs	9.2222
cc	6
nc	5
nop	4
<?php

declare(strict_types=1);

/*
 * This file is part of DivineNii opensource projects.
 *
 * PHP version 7.4 and above required
 *
 * @author    Divine Niiquaye Ibok <[email protected]>
 * @copyright 2021 DivineNii (https://divinenii.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Rade\DI\NodeVisitor;

use PhpParser\Node\Expr;
use PhpParser\Node\Stmt\{Class_, ClassMethod, Expression, Nop, Return_};
use PhpParser\NodeVisitorAbstract;

/**
 * Autowiring Enhancement for class methods stmts.
 *
 * Resolves same object id used multiple times in class methods stmts
 * and create a variable for the object.
 *
 * Example of how it works:
 *
 * ```php
 * $hello = $container->call(HelloWorld::class);
 * $container->set('foo', new Definition('MyWorld', [$hello]))->bind('addGreeting', [$hello]);
 *
 * // A variable is created for $hello object, then mapped to receiving nodes.
 * ```
 *
 * @author Divine Niiquaye Ibok <[email protected]>
 */
class AutowiringResolver extends NodeVisitorAbstract
{
    /** @var array<string,array<int,Expr\Assign> */

    private array $replacement = [];

    /** @var array<string,array<string,string>> */
    private array $sameArgs = [];

    /**
     * {@inheritdoc}
     */
    public function enterNode(\PhpParser\Node $node)
    {
        if ($node instanceof ClassMethod) {
            $nodeId = $node->name->toString();

            if (!isset($this->sameArgs[$nodeId])) {
                $methodsStmts = &$node->stmts;
                $this->resolveStmt($methodsStmts, $nodeId);
                $this->resolveStmt(/** @scrutinizer ignore-type */ $methodsStmts, $nodeId);
            }
        }

        return parent::enterNode($node);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * {@inheritdoc}
     */
    public function afterTraverse(array $nodes)
    {
        foreach ($nodes as $node) {
            if ($node instanceof Class_) {
                foreach ($node->stmts as $methodNode) {
                    if ($methodNode instanceof ClassMethod) {
                        $nodeId = $methodNode->name->toString();

                        if (isset($this->replacement[$nodeId])) {
                            $methodsStmts = &$methodNode->stmts;
                            $this->resolveStmt($methodsStmts, $nodeId, true);
                            $this->resolveStmt(/** @scrutinizer ignore-type */ $methodsStmts, $nodeId, true);

                            $replacements = \array_map(fn (Expr\Assign $node) => new Expression($node), $this->replacement[$nodeId]);
                            $methodNode->stmts = [...\array_values($replacements), new Nop(), ...$methodsStmts];
                        }
                    }
                }
            }
        }

        return parent::afterTraverse($nodes);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @param array<int,Expression|Return_|Expr> $expressions
     */
    private function resolveStmt(array $expressions, string $parentId, bool $leaveNodes = false): void
    {
        foreach ($expressions as &$expression) {
            if ($expression instanceof Expression || $expression instanceof Return_) {
                $expression = $expression->expr;
                $fromStmt = true; // $expression is from stmt

                if ($expression instanceof Expr\Assign) {
                    $expression = &$expression->expr;
                }
            } elseif (\property_exists($expression, 'value') && $expression->value instanceof \PhpParser\Node) {
                $expression = &$expression->value;
            }

            if (\property_exists($expression, 'expr')) {
                $this->doReplacement($expression, $parentId, $leaveNodes, $expR);

                if ($expression instanceof Expr\Variable || $expR) {
                    continue;
                }

                $expression = &$expression->expr;
            }

            if ($expression instanceof Expr\MethodCall) {
                $exprVar = &$expression->var;

                if (!$expression instanceof Expr\Variable) {
                    $this->doReplacement($exprVar, $parentId, $leaveNodes);
                }
            }

            if ($expression instanceof Expr\CallLike) {
                $this->resolveStmt($expression->args, $parentId, $leaveNodes);

                if (isset($fromStmt)) {
                    continue;
                }
            }

            if ($expression instanceof Expr\Array_) {
                if (isset($this->replacement[$parentId][\spl_object_id($expression)]) && $leaveNodes) {
                    $removeIds = \array_intersect_key(
                        \array_keys($this->replacement[$parentId]),
                        \array_map(fn (Expr\ArrayItem $i) => \spl_object_id($i->value), $expression->items)
                    );

                    foreach ($removeIds as $removeId) {
                        unset($this->replacement[$parentId][$removeId]);
                    }
                }

                $this->resolveStmt($expression->items, $parentId, $leaveNodes);
            }

            $this->doReplacement($expression, $parentId, $leaveNodes);
        }
    }

    private function doReplacement(\PhpParser\Node &$nodeValue, string $parentId, bool $leaveNodes, ?bool &$replaced = false): void
    {
        if ($nodeValue instanceof Expr\Variable || $nodeValue instanceof Expr\Closure) {
            return; // @Todo: work in progress ...
        }

        $nodeId = \spl_object_id($nodeValue);

        if ($leaveNodes) {
            if (isset($this->replacement[$parentId][$nodeId])) {
                $nodeValue = $this->replacement[$parentId][$nodeId]->var;
            }
        } elseif (null === $varName = $this->sameArgs[$parentId][$nodeId] ?? null) {
            $this->sameArgs[$parentId][$nodeId] = 'v_' . \substr(\hash('sha256', \serialize($nodeValue)), 0, 5);
        } else {
            $this->replacement[$parentId][$nodeId] = new Expr\Assign(new Expr\Variable($varName), $nodeValue);
            $replaced = true;
        }
    }
}

divineniiquaye / rade-di

Pull Request — master (#37)

AutowiringResolver::doReplacement() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
