ClassDefinition - Code Metrics - Inspection of "[Compiler] ClassDefinition - hasProperty (check th..." - ovr/phpsa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 715ffd...149c2d )

by Дмитрий

created 2016-12-29 11:44 UTC

ClassDefinition C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	439
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	13

Test Coverage

Coverage

72.82%

Importance

Changes

Metric	Value
dl	0
loc	439
ccs	126
cts	173
cp	0.7282
rs	5.4022
c	0
b	0
f	0
wmc	66
lcom	3
cbo	13

21 Methods

Rating	Name	Size	Complexity
A	__construct()	6	1
A	addMethod()	15	3
A	addProperty()	8	2
A	addConst()	4	1
D	compile()	98	12
A	hasConst()	8	4
B	hasMethod()	13	7
A	getMethod()	12	4
B	hasProperty()	19	6
A	getProperty()	14	4
A	getPropertyStatement()	12	4
A	getFilepath()	4	1
A	setFilepath()	4	1
A	isAbstract()	4	1
A	isFinal()	4	1
A	setExtendsClass()	4	1
A	getExtendsClassDefinition()	4	1
A	setExtendsClassDefinition()	4	1
A	addInterface()	4	1
A	getExtendsClass()	4	1
D	mergeTrait()	29	9

How to fix Complexity

<?php
/**
 * @author Patsura Dmitry https://github.com/ovr <[email protected]>
 */

namespace PHPSA\Definition;

use PHPSA\CompiledExpression;
use PHPSA\Context;
use PhpParser\Node;
use PHPSA\Variable;
use PHPSA\Compiler\Event;

/**
 * Class Definition
 *
 * @package PHPSA\Definition
 */
class ClassDefinition extends ParentDefinition

{
    /**
     * @var int
     */
    protected $type;

    /**
     * Class methods
     *
     * @var ClassMethod[]
     */
    protected $methods = [];

    /**
     * Class properties
     *
     * @var Node\Stmt\PropertyProperty[]
     */
    protected $properties = [];

    /**
     * Property Statements
     *
     * @var Node\Stmt\Property[]
     */
    protected $propertyStatements = [];

    /**
     * Class constants
     *
     * @var string[]
     */
    protected $constants = [];

    /**
     * @todo Use Finder
     *
     * @var string
     */
    protected $filepath;

    /**
     * @var Node\Stmt\Class_|null
     */
    protected $statement;

    /**
     * @var string|null
     */
    protected $extendsClass;

    /**
     * @var ClassDefinition|null
     */
    protected $extendsClassDefinition;


    /**
     * @var array
     */
    protected $interfaces = [];

    /**
     * @param string $name
     * @param Node\Stmt\Class_ $statement
     * @param integer $type
     */
    public function __construct($name, Node\Stmt\Class_ $statement = null, $type = 0)
    {
        $this->name = $name;
        $this->statement = $statement;
        $this->type = $type;
    }

    /**
     * @param ClassMethod $classMethod
     * @param bool $overwrite Should we overwrite method if it already exists
     * @return bool Did we overwrite method?
     */
    public function addMethod(ClassMethod $classMethod, $overwrite = true)
    {
        if ($overwrite) {
            $this->methods[$classMethod->getName()] = $classMethod;
        } else {
            $name = $classMethod->getName();
            if (isset($this->methods[$name])) {
                return false;
            } else {
                $this->methods[$name] = $classMethod;
            }
        }

        return true;
    }

    /**
     * @param Node\Stmt\Property $property
     */
    public function addProperty(Node\Stmt\Property $property)
    {
        foreach ($property->props as $propertyDefinition) {
            $this->properties[$propertyDefinition->name] = $propertyDefinition;
        }

        $this->propertyStatements[$propertyDefinition->name] = $property;
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
    }

    /**
     * @param Node\Stmt\ClassConst $const
     */
    public function addConst(Node\Stmt\ClassConst $const)
    {
        $this->constants[$const->consts[0]->name] = $const;
    }

    /**
     * @param Context $context
     * @return $this
     */
    public function compile(Context $context)

    {
        if ($this->compiled) {
            return true;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $this->compiled = true;
        $context->setFilepath($this->filepath);
        $context->setScope($this);

        $context->getEventManager()->fire(
            Event\StatementBeforeCompile::EVENT_NAME,
            new Event\StatementBeforeCompile(
                $this->statement,
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                $context
            )
        );

        // Compile event for properties
        foreach ($this->properties as $property) {
            if (!$property->default) {
                continue;
            }

            // fire expression event for property default
            $context->getEventManager()->fire(
                Event\ExpressionBeforeCompile::EVENT_NAME,
                new Event\ExpressionBeforeCompile(
                    $property->default,
                    $context
                )
            );
        }

        // Compile event for PropertyProperty
        foreach ($this->properties as $property) {
            $context->getEventManager()->fire(
                Event\StatementBeforeCompile::EVENT_NAME,
                new Event\StatementBeforeCompile(
                    $property,
                    $context
                )
            );
        }

        // Compile event for constants
        foreach ($this->constants as $const) {
            $context->getEventManager()->fire(
                Event\StatementBeforeCompile::EVENT_NAME,
                new Event\StatementBeforeCompile(
                    $const,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $context
                )
            );
        }

        // Compiler event for property statements
        foreach ($this->propertyStatements as $prop) {
            $context->getEventManager()->fire(
                Event\StatementBeforeCompile::EVENT_NAME,
                new Event\StatementBeforeCompile(
                    $prop,
                    $context
                )
            );
        }

        // Compile each method
        foreach ($this->methods as $method) {
            $context->clearSymbols();

            if (!$method->isStatic()) {
                $thisPtr = new Variable('this', $this, CompiledExpression::OBJECT);
                $thisPtr->incGets();
                $context->addVariable($thisPtr);
            }

            $method->compile($context);

            $symbols = $context->getSymbols();
            if (count($symbols) > 0) {
                foreach ($symbols as $name => $variable) {
                    if ($variable->isUnused()) {
                        $context->warning(
                            'unused-' . $variable->getSymbolType(),
                            sprintf(
                                'Unused ' . $variable->getSymbolType() . ' $%s in method %s()',
                                $variable->getName(),
                                $method->getName()
                            )
                        );
                    }
                }
            }
        }

        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @param string $name
     * @param boolean|false $inherit
     * @return bool
     */
    public function hasMethod($name, $inherit = false)
    {
        if (isset($this->methods[$name])) {
            return true;
        }

        if ($inherit && $this->extendsClassDefinition && $this->extendsClassDefinition->hasMethod($name, $inherit)) {
            $method = $this->extendsClassDefinition->getMethod($name, $inherit);
            return $method && ($method->isPublic() || $method->isProtected());
        }

        return false;
    }

    /**
     * @param string $name
     * @param bool $inherit
     * @return bool
     */
    public function hasConst($name, $inherit = false)
    {
        if ($inherit && $this->extendsClassDefinition && $this->extendsClassDefinition->hasConst($name, $inherit)) {
            return true;
        }

        return isset($this->constants[$name]);
    }

    /**
     * @param $name
     * @param boolean|false $inherit
     * @return ClassMethod|null
     */
    public function getMethod($name, $inherit = false)
    {
        if (isset($this->methods[$name])) {
            return $this->methods[$name];
        }

        if ($inherit && $this->extendsClassDefinition) {
            return $this->extendsClassDefinition->getMethod($name, $inherit);
        }

        return null;
    }

    /**
     * @param $name
     * @param bool $inherit
     * @param bool $isParent It's an internal parameter
     * @return bool
     */
    public function hasProperty($name, $inherit = false, $isParent = true)
    {
        if (isset($this->properties[$name])) {
            if (!$isParent) {
                $property = $this->propertyStatements[$name];
                if ($property->isPrivate()) {
                    return false;
                }
            }

            return true;
        }

        if ($inherit && $this->extendsClassDefinition) {
            return $this->extendsClassDefinition->hasProperty($name, true, false);
        }

        return false;
    }

    /**
     * @param string $name
     * @param bool $inherit
     * @return Node\Stmt\PropertyProperty
     */
    public function getProperty($name, $inherit = false)
    {
        assert($this->hasProperty($name, $inherit));

        if (isset($this->properties[$name])) {
            return $this->properties[$name];
        }

        if ($inherit && $this->extendsClassDefinition) {
            return $this->extendsClassDefinition->getProperty($name, true);
        }

        return null;
    }

    /**
     * @param string $name
     * @param bool $inherit
     * @return Node\Stmt\Property
     */
    public function getPropertyStatement($name, $inherit = false)
    {
        if (isset($this->propertyStatements[$name])) {
            return $this->propertyStatements[$name];
        }

        if ($inherit && $this->extendsClassDefinition) {
            return $this->extendsClassDefinition->getPropertyStatement($name, true);
        }

        return null;
    }

    /**
     * @return string
     */
    public function getFilepath()
    {
        return $this->filepath;
    }

    /**
     * @param string $filepath
     */
    public function setFilepath($filepath)
    {
        $this->filepath = $filepath;
    }

    /**
     * @return bool
     */
    public function isAbstract()
    {
        return (bool) ($this->type & Node\Stmt\Class_::MODIFIER_ABSTRACT);
    }

    /**
     * @return bool
     */
    public function isFinal()
    {
        return (bool) ($this->type & Node\Stmt\Class_::MODIFIER_FINAL);
    }

    /**
     * @param null|string $extendsClass
     */
    public function setExtendsClass($extendsClass)
    {
        $this->extendsClass = $extendsClass;
    }

    /**
     * @return null|ClassDefinition
     */
    public function getExtendsClassDefinition()
    {
        return $this->extendsClassDefinition;
    }

    /**
     * @param ClassDefinition $extendsClassDefinition
     */
    public function setExtendsClassDefinition(ClassDefinition $extendsClassDefinition)

    {
        $this->extendsClassDefinition = $extendsClassDefinition;
    }

    /**
     * @param string $interface
     */
    public function addInterface($interface)
    {
        $this->interfaces[] = $interface;
    }

    /**
     * @return null|string
     */
    public function getExtendsClass()
    {
        return $this->extendsClass;
    }

    /**
     * @param TraitDefinition $definition
     * @param Node\Stmt\TraitUseAdaptation\Alias[] $adaptations
     */
    public function mergeTrait(TraitDefinition $definition, array $adaptations)
    {
        $methods = $definition->getMethods();
        if ($methods) {

            foreach ($adaptations as $adaptation) {
                // We don't support Trait name for now
                if (!$adaptation->trait) {
                    $methodNameFromTrait = $adaptation->method;
                    if (isset($methods[$methodNameFromTrait])) {
                        /** @var ClassMethod $method Method from Trait */
                        $method = $methods[$methodNameFromTrait];
                        if ($adaptation->newName
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                            || ($adaptation->newModifier && $method->getModifier() != $adaptation->newModifier)) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
                            // Don't modify original method from Trait
                            $method = clone $method;
                            $method->setName($adaptation->newName);
                            $method->setModifier($adaptation->newModifier);

                            $methods[$methodNameFromTrait] = $method;
                        }
                    }
                }
            }

            foreach ($methods as $method) {
                $this->addMethod($method, false);
            }
        }
    }
}


1		<?php
2		/**
3		* @author Patsura Dmitry https://github.com/ovr <[email protected]>
4		*/
5
6		namespace PHPSA\Definition;
7
8		use PHPSA\CompiledExpression;
9		use PHPSA\Context;
10		use PhpParser\Node;
11		use PHPSA\Variable;
12		use PHPSA\Compiler\Event;
13
14		/**
15		* Class Definition
16		*
17		* @package PHPSA\Definition
18		*/
19		class ClassDefinition extends ParentDefinition
		0 ignored issues – show Complexity introduced 2016-10-02 11:53 UTC by Report Bug Copy Issue Report This class has a complexity of 66 which exceeds the configured maximum of 50. The class complexity is the sum of the complexity of all methods. A very high value is usually an indication that your class does not follow the single reponsibility principle and does more than one job. Some resources for further reading: Single Reponsibility Principle Open/Closed Principle You can also find more detailed suggestions for refactoring in the “Code” section of your repository. Loading history...
20		{
21		/**
22		* @var int
23		*/
24		protected $type;
25
26		/**
27		* Class methods
28		*
29		* @var ClassMethod[]
30		*/
31		protected $methods = [];
32
33		/**
34		* Class properties
35		*
36		* @var Node\Stmt\PropertyProperty[]
37		*/
38		protected $properties = [];
39
40		/**
41		* Property Statements
42		*
43		* @var Node\Stmt\Property[]
44		*/
45		protected $propertyStatements = [];
46
47		/**
48		* Class constants
49		*
50		* @var string[]
51		*/
52		protected $constants = [];
53
54		/**
55		* @todo Use Finder
56		*
57		* @var string
58		*/
59		protected $filepath;
60
61		/**
62		* @var Node\Stmt\Class_\|null
63		*/
64		protected $statement;
65
66		/**
67		* @var string\|null
68		*/
69		protected $extendsClass;
70
71		/**
72		* @var ClassDefinition\|null
73		*/
74		protected $extendsClassDefinition;
		0 ignored issues – show Comprehensibility Naming introduced 2016-02-06 15:22 UTC by Report Bug Copy Issue Report The variable name `$extendsClassDefinition` exceeds the maximum configured length of `20`. Very long variable names usually make code harder to read. It is therefore recommended not to make variable names too verbose. Loading history...
75
76		/**
77		* @var array
78		*/
79		protected $interfaces = [];
80
81		/**
82		* @param string $name
83		* @param Node\Stmt\Class_ $statement
84		* @param integer $type
85		*/
86	56	public function __construct($name, Node\Stmt\Class_ $statement = null, $type = 0)
87		{
88	56	$this->name = $name;
89	56	$this->statement = $statement;
90	56	$this->type = $type;
91	56	}
92
93		/**
94		* @param ClassMethod $classMethod
95		* @param bool $overwrite Should we overwrite method if it already exists
96		* @return bool Did we overwrite method?
97		*/
98	48	public function addMethod(ClassMethod $classMethod, $overwrite = true)
99		{
100	48	if ($overwrite) {
101	48	$this->methods[$classMethod->getName()] = $classMethod;
102	48	} else {
103		$name = $classMethod->getName();
104		if (isset($this->methods[$name])) {
105		return false;
106		} else {
107		$this->methods[$name] = $classMethod;
108		}
109		}
110
111	48	return true;
112		}
113
114		/**
115		* @param Node\Stmt\Property $property
116		*/
117	8	public function addProperty(Node\Stmt\Property $property)
118		{
119	8	foreach ($property->props as $propertyDefinition) {
120	8	$this->properties[$propertyDefinition->name] = $propertyDefinition;
121	8	}
122
123	8	$this->propertyStatements[$propertyDefinition->name] = $property;
		0 ignored issues – show Bug introduced 2016-10-07 18:49 UTC by Report Bug Copy Issue Report The variable `$propertyDefinition` seems to be defined by a `foreach` iteration on line `119`. Are you sure the iterator is never empty, otherwise this variable is not defined? It seems like you are relying on a variable being defined by an iteration: foreach ($a as $b) { } // $b is defined here only if $a has elements, for example if $a is array() // then $b would not be defined here. To avoid that, we recommend to set a // default value for $b. // Better $b = 0; // or whatever default makes sense in your context foreach ($a as $b) { } // $b is now guaranteed to be defined here. Loading history...
124	8	}
125
126		/**
127		* @param Node\Stmt\ClassConst $const
128		*/
129	4	public function addConst(Node\Stmt\ClassConst $const)
130		{
131	4	$this->constants[$const->consts[0]->name] = $const;
132	4	}
133
134		/**
135		* @param Context $context
136		* @return $this
137		*/
138	50	public function compile(Context $context)
		0 ignored issues – show Complexity introduced 2016-09-28 15:06 UTC by Report Bug Copy Issue Report This operation has 432 execution paths which exceeds the configured maximum of 200. A high number of execution paths generally suggests many nested conditional statements and make the code less readible. This can usually be fixed by splitting the method into several smaller methods. You can also find more information in the “Code” section of your repository. Loading history...
139		{
140	50	if ($this->compiled) {
141		return true;
		0 ignored issues – show Bug Best Practice introduced 2015-12-20 20:34 UTC by Report Bug Copy Issue Report The return type of `return true;` (`boolean`) is incompatible with the return type documented by `PHPSA\Definition\ClassDefinition::compile` of type `PHPSA\Definition\ClassDefinition`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
142		}
143
144	50	$this->compiled = true;
145	50	$context->setFilepath($this->filepath);
146	50	$context->setScope($this);
147
148	50	$context->getEventManager()->fire(
149	50	Event\StatementBeforeCompile::EVENT_NAME,
150	50	new Event\StatementBeforeCompile(
151	50	$this->statement,
		0 ignored issues – show Bug introduced 2016-09-08 19:07 UTC by Report Bug Copy Issue Report It seems like `$this->statement` can be `null`; however, `__construct()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
152		$context
153	50	)
154	50	);
155
156		// Compile event for properties
157	50	foreach ($this->properties as $property) {
158	7	if (!$property->default) {
159	3	continue;
160		}
161
162		// fire expression event for property default
163	6	$context->getEventManager()->fire(
164	6	Event\ExpressionBeforeCompile::EVENT_NAME,
165	6	new Event\ExpressionBeforeCompile(
166	6	$property->default,
167		$context
168	6	)
169	6	);
170	50	}
171
172		// Compile event for PropertyProperty
173	50	foreach ($this->properties as $property) {
174	7	$context->getEventManager()->fire(
175	7	Event\StatementBeforeCompile::EVENT_NAME,
176	7	new Event\StatementBeforeCompile(
177	7	$property,
178		$context
179	7	)
180	7	);
181	50	}
182
183		// Compile event for constants
184	50	foreach ($this->constants as $const) {
185	2	$context->getEventManager()->fire(
186	2	Event\StatementBeforeCompile::EVENT_NAME,
187	2	new Event\StatementBeforeCompile(
188	2	$const,
		0 ignored issues – show Documentation introduced 2016-12-15 10:01 UTC by Report Bug Copy Issue Report `$const` is of type `string`, but the function expects a `object<PhpParser\Node\Stmt>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
189		$context
190	2	)
191	2	);
192	50	}
193
194		// Compiler event for property statements
195	50	foreach ($this->propertyStatements as $prop) {
196	7	$context->getEventManager()->fire(
197	7	Event\StatementBeforeCompile::EVENT_NAME,
198	7	new Event\StatementBeforeCompile(
199	7	$prop,
200		$context
201	7	)
202	7	);
203	50	}
204
205		// Compile each method
206	50	foreach ($this->methods as $method) {
207	47	$context->clearSymbols();
208
209	47	if (!$method->isStatic()) {
210	46	$thisPtr = new Variable('this', $this, CompiledExpression::OBJECT);
211	46	$thisPtr->incGets();
212	46	$context->addVariable($thisPtr);
213	46	}
214
215	47	$method->compile($context);
216
217	47	$symbols = $context->getSymbols();
218	47	if (count($symbols) > 0) {
219	46	foreach ($symbols as $name => $variable) {
220	46	if ($variable->isUnused()) {
221	13	$context->warning(
222	13	'unused-' . $variable->getSymbolType(),
223	13	sprintf(
224	13	'Unused ' . $variable->getSymbolType() . ' $%s in method %s()',
225	13	$variable->getName(),
226	13	$method->getName()
227	13	)
228	13	);
229	13	}
230	46	}
231	46	}
232	50	}
233
234	50	return $this;
		0 ignored issues – show Bug Best Practice introduced 2015-11-22 15:25 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`PHPSA\Definition\ClassDefinition`) is incompatible with the return type declared by the abstract method `PHPSA\Definition\AbstractDefinition::compile` of type `boolean`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
235		}
236
237		/**
238		* @param string $name
239		* @param boolean\|false $inherit
240		* @return bool
241		*/
242	4	public function hasMethod($name, $inherit = false)
243		{
244	4	if (isset($this->methods[$name])) {
245	2	return true;
246		}
247
248	3	if ($inherit && $this->extendsClassDefinition && $this->extendsClassDefinition->hasMethod($name, $inherit)) {
249	2	$method = $this->extendsClassDefinition->getMethod($name, $inherit);
250	2	return $method && ($method->isPublic() \|\| $method->isProtected());
251		}
252
253	1	return false;
254		}
255
256		/**
257		* @param string $name
258		* @param bool $inherit
259		* @return bool
260		*/
261	2	public function hasConst($name, $inherit = false)
262		{
263	2	if ($inherit && $this->extendsClassDefinition && $this->extendsClassDefinition->hasConst($name, $inherit)) {
264	1	return true;
265		}
266
267	2	return isset($this->constants[$name]);
268		}
269
270		/**
271		* @param $name
272		* @param boolean\|false $inherit
273		* @return ClassMethod\|null
274		*/
275	4	public function getMethod($name, $inherit = false)
276		{
277	4	if (isset($this->methods[$name])) {
278	2	return $this->methods[$name];
279		}
280
281	2	if ($inherit && $this->extendsClassDefinition) {
282	2	return $this->extendsClassDefinition->getMethod($name, $inherit);
283		}
284
285		return null;
286		}
287
288		/**
289		* @param $name
290		* @param bool $inherit
291		* @param bool $isParent It's an internal parameter
292		* @return bool
293	1	*/
294		public function hasProperty($name, $inherit = false, $isParent = true)
295	1	{
296	1	if (isset($this->properties[$name])) {
297		if (!$isParent) {
298		$property = $this->propertyStatements[$name];
299	1	if ($property->isPrivate()) {
300		return false;
301		}
302		}
303
304		return true;
305		}
306
307		if ($inherit && $this->extendsClassDefinition) {
308		return $this->extendsClassDefinition->hasProperty($name, true, false);
309		}
310
311		return false;
312		}
313
314		/**
315		* @param string $name
316		* @param bool $inherit
317		* @return Node\Stmt\PropertyProperty
318		*/
319		public function getProperty($name, $inherit = false)
320		{
321		assert($this->hasProperty($name, $inherit));
322
323		if (isset($this->properties[$name])) {
324		return $this->properties[$name];
325		}
326
327		if ($inherit && $this->extendsClassDefinition) {
328		return $this->extendsClassDefinition->getProperty($name, true);
329		}
330
331		return null;
332		}
333
334		/**
335		* @param string $name
336		* @param bool $inherit
337		* @return Node\Stmt\Property
338		*/
339		public function getPropertyStatement($name, $inherit = false)
340		{
341		if (isset($this->propertyStatements[$name])) {
342		return $this->propertyStatements[$name];
343	50	}
344
345	50	if ($inherit && $this->extendsClassDefinition) {
346		return $this->extendsClassDefinition->getPropertyStatement($name, true);
347		}
348
349		return null;
350		}
351	50
352		/**
353	50	* @return string
354	50	*/
355		public function getFilepath()
356		{
357		return $this->filepath;
358		}
359	1
360		/**
361	1	* @param string $filepath
362		*/
363		public function setFilepath($filepath)
364		{
365		$this->filepath = $filepath;
366		}
367	1
368		/**
369	1	* @return bool
370		*/
371		public function isAbstract()
372		{
373		return (bool) ($this->type & Node\Stmt\Class_::MODIFIER_ABSTRACT);
374		}
375	2
376		/**
377	2	* @return bool
378	2	*/
379		public function isFinal()
380		{
381		return (bool) ($this->type & Node\Stmt\Class_::MODIFIER_FINAL);
382		}
383
384		/**
385		* @param null\|string $extendsClass
386		*/
387		public function setExtendsClass($extendsClass)
388		{
389		$this->extendsClass = $extendsClass;
390		}
391	3
392		/**
393	3	* @return null\|ClassDefinition
394	3	*/
395		public function getExtendsClassDefinition()
396		{
397		return $this->extendsClassDefinition;
398		}
399
400		/**
401		* @param ClassDefinition $extendsClassDefinition
402		*/
403		public function setExtendsClassDefinition(ClassDefinition $extendsClassDefinition)
		0 ignored issues – show Comprehensibility Naming introduced 2016-02-06 15:22 UTC by Report Bug Copy Issue Report The variable name `$extendsClassDefinition` exceeds the maximum configured length of `20`. Very long variable names usually make code harder to read. It is therefore recommended not to make variable names too verbose. Loading history...
404		{
405		$this->extendsClassDefinition = $extendsClassDefinition;
406		}
407	50
408		/**
409	50	* @param string $interface
410		*/
411		public function addInterface($interface)
412		{
413		$this->interfaces[] = $interface;
414		}
415
416		/**
417		* @return null\|string
418		*/
419		public function getExtendsClass()
420		{
421		return $this->extendsClass;
422		}
423
424		/**
425		* @param TraitDefinition $definition
426		* @param Node\Stmt\TraitUseAdaptation\Alias[] $adaptations
427		*/
428		public function mergeTrait(TraitDefinition $definition, array $adaptations)
429		{
430		$methods = $definition->getMethods();
431		if ($methods) {
		0 ignored issues – show Bug Best Practice introduced 2016-10-02 11:53 UTC by Report Bug Copy Issue Report The expression `$methods` of type `PHPSA\Definition\ClassMethod[]` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
432		foreach ($adaptations as $adaptation) {
433		// We don't support Trait name for now
434		if (!$adaptation->trait) {
435		$methodNameFromTrait = $adaptation->method;
436		if (isset($methods[$methodNameFromTrait])) {
437		/** @var ClassMethod $method Method from Trait */
438		$method = $methods[$methodNameFromTrait];
439		if ($adaptation->newName
		0 ignored issues – show Bug Best Practice introduced 2016-10-03 12:48 UTC by Report Bug Copy Issue Report The expression `$adaptation->newName` of type `null\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
440		\|\| ($adaptation->newModifier && $method->getModifier() != $adaptation->newModifier)) {
		0 ignored issues – show Bug Best Practice introduced 2016-10-03 12:48 UTC by Report Bug Copy Issue Report The expression `$adaptation->newModifier` of type `null\|integer` is loosely compared to `true`; this is ambiguous if the integer can be zero. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
441		// Don't modify original method from Trait
442		$method = clone $method;
443		$method->setName($adaptation->newName);
444		$method->setModifier($adaptation->newModifier);
445
446		$methods[$methodNameFromTrait] = $method;
447		}
448		}
449		}
450		}
451
452		foreach ($methods as $method) {
453		$this->addMethod($method, false);
454		}
455		}
456		}
457		}
458

ovr / phpsa

Push — master ( 715ffd...149c2d )

ClassDefinition C

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

21 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like