Povils\PHPMND\Visitor\DetectorVisitor

Complexity

Total Complexity

25

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	4
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	enterNode()	0	27	8
A	isNumber()	0	10	4
A	isString()	0	4	3
A	ignoreNumber()	0	4	1
A	ignoreString()	0	4	1
A	hasSign()	0	4	2
A	isMinus()	0	4	1
A	isValidNumeric()	0	7	4

<?php

namespace Povils\PHPMND\Visitor;

use PhpParser\Node;
use PhpParser\Node\Const_;
use PhpParser\Node\Expr\UnaryMinus;
use PhpParser\Node\Expr\UnaryPlus;
use PhpParser\Node\Scalar;
use PhpParser\Node\Scalar\DNumber;
use PhpParser\Node\Scalar\LNumber;
use PhpParser\Node\Scalar\String_;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use Povils\PHPMND\Console\Option;
use Povils\PHPMND\Extension\ArrayAwareExtension;
use Povils\PHPMND\Extension\Extension;
use Povils\PHPMND\Extension\FunctionAwareExtension;
use Povils\PHPMND\FileReport;

/**
 * Class DetectorVisitor
 *
 * @package Povils\PHPMND
 */
class DetectorVisitor extends NodeVisitorAbstract
{
    /**
     * @var FileReport
     */
    private $fileReport;

    /**
     * @var Option
     */
    private $option;

    /**
     * @param FileReport $fileReport
     * @param Option $option
     */
    public function __construct(FileReport $fileReport, Option $option)
    {
        $this->fileReport = $fileReport;
        $this->option = $option;
    }

    /**
     * @inheritdoc
     */
    public function enterNode(Node $node)
    {
        if ($node instanceof Const_) {
            return NodeTraverser::DONT_TRAVERSE_CHILDREN;
        }

        if ($this->isNumber($node) || $this->isString($node)) {
            /** @var LNumber|DNumber|String_ $scalar */
            $scalar = $node;
            if ($this->hasSign($node)) {
                $node = $node->getAttribute('parent');
                if ($this->isMinus($node)) {
                    $scalar->value = -$scalar->value;
                }
            }
            foreach ($this->option->getExtensions() as $extension) {
                $extension->setOption($this->option);
                if ($extension->extend($node)) {
                    $this->fileReport->addEntry($scalar->getLine(), $scalar->value);

                    return null;
                }
            }
        }

        return null;
    }

    /**
     * @param Node $node
     *
     * @return bool
     */
    private function isNumber(Node $node)
    {
        $isNumber = (
            $node instanceof LNumber ||
            $node instanceof DNumber ||
            $this->isValidNumeric($node)
        );

        return $isNumber && false === $this->ignoreNumber($node);
    }

    /**
     * @param Node $node
     *
     * @return bool
     */
    private function isString(Node $node)
    {
        return $this->option->includeStrings() && $node instanceof String_ && false === $this->ignoreString($node);
    }

    /**
     * @param LNumber|DNumber|Node $node
     *
     * @return bool
     */
    private function ignoreNumber(Node $node)
    {
        return in_array($node->value, $this->option->getIgnoreNumbers(), true);
    }

    /**
     * @param String_|Node $node
     *
     * @return bool
     */
    private function ignoreString(Node $node)
    {
        return in_array($node->value, $this->option->getIgnoreStrings(), true);
    }

    /**
     * @param Node $node
     *
     * @return bool
     */
    private function hasSign(Node $node)
    {
        return $node->getAttribute('parent') instanceof UnaryMinus || $node->getAttribute('parent') instanceof UnaryPlus;
    }

    /**
     * @param Node $node
     *
     * @return bool
     */
    private function isMinus(Node $node)
    {
        return $node instanceof UnaryMinus;
    }

    /**
     * @param Node $node
     * @return bool
     */
    private function isValidNumeric(Node $node)
    {
        return $this->option->includeNumericStrings() &&
        isset($node->value) &&

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

        is_numeric($node->value) &&

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

        false === $this->ignoreString($node);
    }
}