CCNChecker::getComplexityAdders() - Code Metrics - kabirbaidhya/Inspector - Measure and Improve Code Quality continuously with Scrutinizer

CCNChecker::getComplexityAdders() B
last analyzed 2018-02-21 22:08 UTC

↳ Parent: CCNChecker

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	21
nc	1
nop	0
dl	0
loc	32
rs	8.8571
c	0
b	0
f	0

<?php

namespace Inspector\Analysis\Complexity;

use PhpParser\Node;
use PhpParser\Node\Stmt\If_;
use PhpParser\Node\Stmt\Do_;
use PhpParser\Node\Stmt\For_;
use PhpParser\Node\Stmt\Case_;
use PhpParser\Node\Stmt\While_;
use PhpParser\Node\Stmt\Catch_;
use PhpParser\Node\Expr\Closure;
use PhpParser\Node\Stmt\ElseIf_;
use PhpParser\Node\Stmt\Foreach_;
use PhpParser\Node\Stmt\Function_;
use PhpParser\Node\Expr\BooleanNot;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Expr\BinaryOp\BooleanOr;
use PhpParser\Node\Expr\BinaryOp\LogicalOr;
use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
use PhpParser\Node\Expr\BinaryOp\LogicalAnd;
use PhpParser\Node\Expr\BinaryOp\LogicalXor;

/**
 * Class responsible for checking the Cylomatic Complexity Number (CCN) value of a node.
 *
 * @author Kabir Baidhya
 */
class CCNChecker implements ValueCheckerInterface
{

    /**
     * Checks the cyclomatic complexity value of a given node
     *
     * @param Node $node
     * @return int
     */
    public function getValue(Node $node)
    {
        $complexityAdders = $this->getComplexityAdders();

        foreach ($complexityAdders as $nodeClass) {
            if ($this->nodePassesFor($nodeClass, $node)) {
                return 1;
            }
        }

        return 0;
    }

    /**
     * Checks to make sure the node is an instance of complexity adder node classes,
     * and also passes any extra conditions (if any)
     *
     * @param array $nodeClass
     * @param Node $node
     * @return bool
     */
    protected function nodePassesFor(array $nodeClass, Node $node)
    {
        $class = array_shift($nodeClass);
        $callbackCondition = array_shift($nodeClass);

        // If node is an instance of a complexity adder class
        if (is_a($node, $class)) {

            if (!is_callable($callbackCondition)) {
                // if it doesn't have any extra callback condition then
                return true;
            } elseif ($callbackCondition($node)) {
                // if it has extra callback condition then that condition also
                // must hold true
                return true;
            }
        }

        return false;
    }

    /**
     * Get the class names of all the nodes which adds complexity in the code
     *
     * @return array
     */
    protected function getComplexityAdders()
    {
        return [
            // the control structures
            [If_::class],
            [ElseIf_::class],
            [For_::class],
            [Foreach_::class],
            [While_::class],
            [Do_::class],
            [Catch_::class],
            [
                Case_::class,
                function (Node $node) {
                    // Return true for all switch 'case' statements

                    // except the 'default' case
                    return !empty($node->cond);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                }
            ],
            // class methods, functions or closures(anonymous functions)
            [ClassMethod::class],
            [Function_::class],
            [Closure::class],
            // logical operators
            [LogicalAnd::class],
            [BooleanAnd::class],
            [LogicalOr::class],
            [BooleanOr::class],
            [BooleanNot::class],
            [LogicalXor::class],
        ];
    }
}


1			<?php
2
3			namespace Inspector\Analysis\Complexity;
4
5			use PhpParser\Node;
6			use PhpParser\Node\Stmt\If_;
7			use PhpParser\Node\Stmt\Do_;
8			use PhpParser\Node\Stmt\For_;
9			use PhpParser\Node\Stmt\Case_;
10			use PhpParser\Node\Stmt\While_;
11			use PhpParser\Node\Stmt\Catch_;
12			use PhpParser\Node\Expr\Closure;
13			use PhpParser\Node\Stmt\ElseIf_;
14			use PhpParser\Node\Stmt\Foreach_;
15			use PhpParser\Node\Stmt\Function_;
16			use PhpParser\Node\Expr\BooleanNot;
17			use PhpParser\Node\Stmt\ClassMethod;
18			use PhpParser\Node\Expr\BinaryOp\BooleanOr;
19			use PhpParser\Node\Expr\BinaryOp\LogicalOr;
20			use PhpParser\Node\Expr\BinaryOp\BooleanAnd;
21			use PhpParser\Node\Expr\BinaryOp\LogicalAnd;
22			use PhpParser\Node\Expr\BinaryOp\LogicalXor;
23
24			/**
25			* Class responsible for checking the Cylomatic Complexity Number (CCN) value of a node.
26			*
27			* @author Kabir Baidhya
28			*/
29			class CCNChecker implements ValueCheckerInterface
30			{
31
32			/**
33			* Checks the cyclomatic complexity value of a given node
34			*
35			* @param Node $node
36			* @return int
37			*/
38			public function getValue(Node $node)
39			{
40			$complexityAdders = $this->getComplexityAdders();
41
42			foreach ($complexityAdders as $nodeClass) {
43			if ($this->nodePassesFor($nodeClass, $node)) {
44			return 1;
45			}
46			}
47
48			return 0;
49			}
50
51			/**
52			* Checks to make sure the node is an instance of complexity adder node classes,
53			* and also passes any extra conditions (if any)
54			*
55			* @param array $nodeClass
56			* @param Node $node
57			* @return bool
58			*/
59			protected function nodePassesFor(array $nodeClass, Node $node)
60			{
61			$class = array_shift($nodeClass);
62			$callbackCondition = array_shift($nodeClass);
63
64			// If node is an instance of a complexity adder class
65			if (is_a($node, $class)) {
66
67			if (!is_callable($callbackCondition)) {
68			// if it doesn't have any extra callback condition then
69			return true;
70			} elseif ($callbackCondition($node)) {
71			// if it has extra callback condition then that condition also
72			// must hold true
73			return true;
74			}
75			}
76
77			return false;
78			}
79
80			/**
81			* Get the class names of all the nodes which adds complexity in the code
82			*
83			* @return array
84			*/
85			protected function getComplexityAdders()
86			{
87			return [
88			// the control structures
89			[If_::class],
90			[ElseIf_::class],
91			[For_::class],
92			[Foreach_::class],
93			[While_::class],
94			[Do_::class],
95			[Catch_::class],
96			[
97			Case_::class,
98			function (Node $node) {
99			// Return true for all switch 'case' statements
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-03-04 20:08 UTC by Report Bug Copy Issue Report `36%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
100			// except the 'default' case
101			return !empty($node->cond);
			0 ignored issues – show Bug introduced 2016-03-04 20:08 UTC by Report Bug Copy Issue Report Accessing `cond` 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...
102			}
103			],
104			// class methods, functions or closures(anonymous functions)
105			[ClassMethod::class],
106			[Function_::class],
107			[Closure::class],
108			// logical operators
109			[LogicalAnd::class],
110			[BooleanAnd::class],
111			[LogicalOr::class],
112			[BooleanOr::class],
113			[BooleanNot::class],
114			[LogicalXor::class],
115			];
116			}
117			}
118

kabirbaidhya / Inspector

GitHub Access Token became invalid

CCNChecker::getComplexityAdders() B last analyzed 2018-02-21 22:08 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

CCNChecker::getComplexityAdders() B
last analyzed 2018-02-21 22:08 UTC