DetectorVisitor::checkNameContainsLanguage() - Code Metrics - Inspection of "Check for named constants" - povils/phpmnd - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#86)

by Scott

created 2019-03-05 21:01 UTC

DetectorVisitor::checkNameContainsLanguage() A

↳ Parent: DetectorVisitor

Complexity

Conditions	4
Paths	5

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	20
rs	9.6
c	0
b	0
f	0
cc	4
nc	5
nop	2

<?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;

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

    public function enterNode(Node $node): ?int
    {
        if ($this->isIgnoreableConst($node)) {
            if ($this->checkNameContainsLanguage(
                $node->name->name,
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $node->value->value ?? 0
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            )) {
                $this->fileReport->addEntry($node->getLine(), $node->value->value);
            }

            return NodeTraverser::DONT_TRAVERSE_CHILDREN;
        }

        /** @var LNumber|DNumber|String_ $scalar */
        $scalar = $node;
        if ($this->hasSign($scalar) && $this->isNumber($scalar)) {
            $node = $scalar->getAttribute('parent');
            if ($this->isMinus($node)) {
                $scalar->value = -$scalar->value;
            }
        }

        if ($this->isNumber($scalar) || $this->isString($scalar)) {

            if ($this->checkNameContainsLanguage(
                $scalar->getAttribute('parent')->var->name ?? '',
                $scalar->value
            )) {
                $this->fileReport->addEntry($node->getLine(), $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;
    }

    private function isIgnoreableConst(Node $node): bool
    {
        return $node instanceof Const_ &&
            ($this->isNumber($node->value) || $this->isString($node->value));
    }

    private function isNumber(Node $node): bool
    {
        $isNumber = (
            $node instanceof LNumber ||
            $node instanceof DNumber ||
            $this->isValidNumeric($node)
        );

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

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

    private function ignoreNumber(Node $node): bool
    {
        return in_array($node->value, $this->option->getIgnoreNumbers(), true);
    }

    private function ignoreString(Node $node): bool
    {
        return in_array($node->value, $this->option->getIgnoreStrings(), true);
    }

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

    private function isMinus(Node $node): bool
    {
        return $node instanceof UnaryMinus;
    }

    private function isValidNumeric(Node $node): bool
    {
        return $this->option->includeNumericStrings() &&
        isset($node->value) &&
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        is_numeric($node->value) &&
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        false === $this->ignoreString($node);
    }

    /**
     * @param string $name
     * @param string|int $value
     * @return bool
     */
    private function checkNameContainsLanguage(string $name, $value): bool
    {
        foreach ($this->option->checkNaming() as $language) {
            $generatedNumbers = $language->parse($value);

            $regex = '/(?<name>';
            foreach ($generatedNumbers as $word) {
                $regex .= "(?:{$word}[\s_-]*)?";
            }

            $regex .= ')/i';
            preg_match($regex, $name, $matches);

            if (strlen($matches['name']) > 0) {
                return true;
            }
        }

        return false;
    }
}


1			<?php
2
3			namespace Povils\PHPMND\Visitor;
4
5			use PhpParser\Node;
6			use PhpParser\Node\Const_;
7			use PhpParser\Node\Expr\UnaryMinus;
8			use PhpParser\Node\Expr\UnaryPlus;
9			use PhpParser\Node\Scalar;
10			use PhpParser\Node\Scalar\DNumber;
11			use PhpParser\Node\Scalar\LNumber;
12			use PhpParser\Node\Scalar\String_;
13			use PhpParser\NodeTraverser;
14			use PhpParser\NodeVisitorAbstract;
15			use Povils\PHPMND\Console\Option;
16			use Povils\PHPMND\Extension\ArrayAwareExtension;
17			use Povils\PHPMND\Extension\Extension;
18			use Povils\PHPMND\Extension\FunctionAwareExtension;
19			use Povils\PHPMND\FileReport;
20
21			/**
22			* Class DetectorVisitor
23			*
24			* @package Povils\PHPMND
25			*/
26			class DetectorVisitor extends NodeVisitorAbstract
27			{
28			/**
29			* @var FileReport
30			*/
31			private $fileReport;
32
33			/**
34			* @var Option
35			*/
36			private $option;
37
38			public function __construct(FileReport $fileReport, Option $option)
39			{
40			$this->fileReport = $fileReport;
41			$this->option = $option;
42			}
43
44			public function enterNode(Node $node): ?int
45			{
46			if ($this->isIgnoreableConst($node)) {
47			if ($this->checkNameContainsLanguage(
48			$node->name->name,
			0 ignored issues – show Bug introduced 2019-01-28 06:45 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
49			$node->value->value ?? 0
			0 ignored issues – show Bug introduced 2019-01-28 06:45 UTC by Report Bug Copy Issue Report Accessing `value` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
50			)) {
51			$this->fileReport->addEntry($node->getLine(), $node->value->value);
52			}
53
54			return NodeTraverser::DONT_TRAVERSE_CHILDREN;
55			}
56
57			/** @var LNumber\|DNumber\|String_ $scalar */
58			$scalar = $node;
59			if ($this->hasSign($scalar) && $this->isNumber($scalar)) {
60			$node = $scalar->getAttribute('parent');
61			if ($this->isMinus($node)) {
62			$scalar->value = -$scalar->value;
63			}
64			}
65
66			if ($this->isNumber($scalar) \|\| $this->isString($scalar)) {
67
68			if ($this->checkNameContainsLanguage(
69			$scalar->getAttribute('parent')->var->name ?? '',
70			$scalar->value
71			)) {
72			$this->fileReport->addEntry($node->getLine(), $scalar->value);
73			}
74
75			foreach ($this->option->getExtensions() as $extension) {
76			$extension->setOption($this->option);
77			if ($extension->extend($node)) {
78			$this->fileReport->addEntry($scalar->getLine(), $scalar->value);
79
80			return null;
81			}
82			}
83			}
84
85			return null;
86			}
87
88			private function isIgnoreableConst(Node $node): bool
89			{
90			return $node instanceof Const_ &&
91			($this->isNumber($node->value) \|\| $this->isString($node->value));
92			}
93
94			private function isNumber(Node $node): bool
95			{
96			$isNumber = (
97			$node instanceof LNumber \|\|
98			$node instanceof DNumber \|\|
99			$this->isValidNumeric($node)
100			);
101
102			return $isNumber && false === $this->ignoreNumber($node);
103			}
104
105			private function isString(Node $node): bool
106			{
107			return $this->option->includeStrings() && $node instanceof String_ && false === $this->ignoreString($node);
108			}
109
110			private function ignoreNumber(Node $node): bool
111			{
112			return in_array($node->value, $this->option->getIgnoreNumbers(), true);
113			}
114
115			private function ignoreString(Node $node): bool
116			{
117			return in_array($node->value, $this->option->getIgnoreStrings(), true);
118			}
119
120			private function hasSign(Node $node): bool
121			{
122			return $node->getAttribute('parent') instanceof UnaryMinus
123			\|\| $node->getAttribute('parent') instanceof UnaryPlus;
124			}
125
126			private function isMinus(Node $node): bool
127			{
128			return $node instanceof UnaryMinus;
129			}
130
131			private function isValidNumeric(Node $node): bool
132			{
133			return $this->option->includeNumericStrings() &&
134			isset($node->value) &&
			0 ignored issues – show Bug introduced 2018-02-26 21:05 UTC by Report Bug Copy Issue Report Accessing `value` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
135			is_numeric($node->value) &&
			0 ignored issues – show Bug introduced 2018-03-17 19:09 UTC by Report Bug Copy Issue Report Accessing `value` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
136			false === $this->ignoreString($node);
137			}
138
139			/**
140			* @param string $name
141			* @param string\|int $value
142			* @return bool
143			*/
144			private function checkNameContainsLanguage(string $name, $value): bool
145			{
146			foreach ($this->option->checkNaming() as $language) {
147			$generatedNumbers = $language->parse($value);
148
149			$regex = '/(?<name>';
150			foreach ($generatedNumbers as $word) {
151			$regex .= "(?:{$word}[\s_-]*)?";
152			}
153
154			$regex .= ')/i';
155			preg_match($regex, $name, $matches);
156
157			if (strlen($matches['name']) > 0) {
158			return true;
159			}
160			}
161
162			return false;
163			}
164			}
165

povils / phpmnd

Pull Request — master (#86)

DetectorVisitor::checkNameContainsLanguage() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like