Yiisoft\Composer\Config\Reader\PhpReader::readRaw()

Size

Total Lines	83
Code Lines	43

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	PhpReader.php$0 ➔ leaveNode()	0	6	1
A	PhpReader.php$0 ➔ enterNode()	0	2	1
A	PhpReader.php$0 ➔ processNode()	0	19	6
A	PhpReader.php$0 ➔ inDefine()	0	9	3
A	PhpReader.php$0 ➔ beginTraverse()	0	2	1

<?php

declare(strict_types=1);

namespace Yiisoft\Composer\Config\Reader;

use PhpParser\Node;
use PhpParser\Node\Expr\ArrayDimFetch;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\String_;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use PhpParser\ParserFactory;
use Yiisoft\Composer\Config\Env;
use PhpParser\Node\Expr\FuncCall;

/**
 * PhpReader - reads PHP files.
 */
class PhpReader extends AbstractReader
{
    protected function readRaw(string $path)
    {
        $parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
        $saves = [];
        try {
            $names = [];

The assignment to $names is dead and can be removed.

            $ast = $parser->parse(file_get_contents($path));

            $traverser = new NodeTraverser;
            $visitor = new class extends NodeVisitorAbstract {
                public static $names;
                private $stack;

                public function beginTraverse(array $nodes) {

The parameter $nodes is not used and could be removed.

                    $this->stack = [];
                }

                public function enterNode(Node $node) {
                    $this->stack[] = $node;
                }

                public function leaveNode(Node $node)
                {
                    $this->processNode($node);
                    array_pop($this->stack);

                    return $node;
                }

                private function processNode(Node $node)
                {
                    if (! $node instanceof ArrayDimFetch) {
                        return;
                    }
                    if (! $node->var instanceof Variable) {
                        return;
                    }
                    if (! $node->var->name === '_ENV') {

The condition ! $node->var->name === '_ENV' is always false.

                        return;
                    }
                    if (! $node->dim instanceof String_) {
                        return;
                    }
                    if ($this->inDefine($node)) {

The call to anonymous//src/Reader/PhpReader.php$0::inDefine() has too many arguments starting with $node.

                        return;
                    }
                    $name = $node->dim->value;
                    self::$names[$name] = $name;
                }

                private function inDefine(): bool
                {
                    foreach ($this->stack as $node) {
                        if ($node instanceof FuncCall) {
                            return true;
                        }
                    }

                    return false;
                }
            };
            $traverser->addVisitor($visitor);
            $ast = $traverser->traverse($ast);

The assignment to $ast is dead and can be removed.

It seems like $ast can also be of type null; however, parameter $nodes of PhpParser\NodeTraverser::traverse() does only seem to accept array, maybe add an additional type check?

            foreach ($visitor::$names as $name) {
                $saves[$name] = $_ENV[$name];
                $_ENV[$name] = Env::get($name);
            }
        } catch (\Exception $e) {
            // do nothing
        }

        $params = $this->builder->getVars()['params'] ?? [];

        $result = static function (array $params) {
            return require func_get_arg(1);
        };

        $res = $result($params, $path);
        foreach ($saves as $key => $value) {
            $_ENV[$key] = $value;
        }

        return $res;
    }
}