ComposerRequireChecker\NodeVisitor\DefinedSymbolCollector

Complexity

Total Complexity

27

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Test Coverage

Coverage

94.55%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefinedSymbols()	0	3	1
A	__construct()	0	2	1
A	recordInterfaceDefinition()	0	4	2
A	recordClassDefinition()	0	4	3
A	recordFunctionDefinition()	0	4	2
A	recordDefinitionOfStringSymbol()	0	3	1
A	recordConstDefinition()	0	5	3
A	enterNode()	0	8	1
B	recordDefinedConstDefinition()	0	12	8
A	beforeTraverse()	0	5	1
A	recordDefinitionOf()	0	12	2
A	recordTraitDefinition()	0	4	2

<?php

namespace ComposerRequireChecker\NodeVisitor;

use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;

final class DefinedSymbolCollector extends NodeVisitorAbstract
{
    /**
     * @var mixed[]
     */
    private $definedSymbols = [];

    public function __construct()
    {
    }

    /**
     * {@inheritDoc}
     */
    public function beforeTraverse(array $nodes)
    {
        $this->definedSymbols = [];

        return parent::beforeTraverse($nodes);

Are you sure the usage of parent::beforeTraverse($nodes) targeting PhpParser\NodeVisitorAbstract::beforeTraverse() seems to always return null.

    }

    /**
     * @return string[]
     */
    public function getDefinedSymbols(): array
    {
        return array_keys($this->definedSymbols);
    }

    /**
     * {@inheritDoc}
     */
    public function enterNode(Node $node)
    {
        $this->recordClassDefinition($node);
        $this->recordInterfaceDefinition($node);
        $this->recordTraitDefinition($node);
        $this->recordFunctionDefinition($node);
        $this->recordConstDefinition($node);
        $this->recordDefinedConstDefinition($node);
    }

    private function recordClassDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Class_ && !$node->isAnonymous()) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordInterfaceDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Interface_) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordTraitDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Trait_) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordFunctionDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Function_) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordConstDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Const_) {
            foreach ($node->consts as $const) {
                $this->recordDefinitionOf($const);
            }
        }
    }

    private function recordDefinedConstDefinition(Node $node)
    {
        if ($node instanceof Node\Expr\FuncCall && $node->name instanceof Node\Name && $node->name->toString() === 'define') {
            if ($node->name->hasAttribute('namespacedName')
                && $node->name->getAttribute('namespacedName') instanceof Node\Name\FullyQualified
                && $node->name->getAttribute('namespacedName')->toString() !== 'define'
            ) {
                return;
            }

            if ($node->args[0]->value instanceof Node\Scalar\String_) {
                $this->recordDefinitionOfStringSymbol((string)$node->args[0]->value->value);
            }
        }
    }

    /**
     * @param Node $node
     *
     * @return void
     */
    private function recordDefinitionOf(Node $node)
    {
        if (!isset($node->namespacedName)) {

Accessing namespacedName on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

            throw new \UnexpectedValueException(sprintf(
                'Given node of type "%s" (defined at line %s)does not have an assigned "namespacedName" property: '
                . 'did you pass it through a name resolver visitor?',
                get_class($node),
                $node->getLine()
            ));
        }

        $this->recordDefinitionOfStringSymbol((string)$node->namespacedName);
    }

    private function recordDefinitionOfStringSymbol(string $symbolName)
    {
        $this->definedSymbols[$symbolName] = $symbolName;
    }
}