ReflectionAnnotatedClass::getMethod() - Code Metrics - Inspection of "* travis" - Maslosoft/Addendum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 93c108...b5b8be )

by Peter

created 2016-08-04 16:09 UTC

ReflectionAnnotatedClass::getMethod() A

↳ Parent: ReflectionAnnotatedClass

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php

/**
 * This software package is licensed under AGPL, Commercial license.
 *
 * @package maslosoft/addendum
 * @licence AGPL, Commercial
 * @copyright Copyright (c) Piotr Masełkowski <[email protected]> (Meta container, further improvements, bugfixes)
 * @copyright Copyright (c) Maslosoft (Meta container, further improvements, bugfixes)
 * @copyright Copyright (c) Jan Suchal (Original version, builder, parser)
 * @link http://maslosoft.com/addendum/ - maslosoft addendum
 * @link https://code.google.com/p/addendum/ - original addendum project
 */

namespace Maslosoft\Addendum\Reflection;

use Maslosoft\Addendum\Addendum;
use Maslosoft\Addendum\Builder\Builder;
use Maslosoft\Addendum\Collections\AnnotationsCollection;
use Maslosoft\Addendum\Interfaces\AnnotatedReflectorInterface;
use Maslosoft\Addendum\Utilities\ConflictChecker;
use ReflectionClass;

class ReflectionAnnotatedClass extends ReflectionClass implements AnnotatedReflectorInterface
{

	/**
	 * Annotations collection
	 * @var AnnotationsCollection
	 */
	private $annotations = null;

	/**
	 * Addendum instance
	 * @var Addendum
	 */
	private $addendum = null;

	public function __construct($class, Addendum $addendum = null)
	{
		parent::__construct($class);
		$this->annotations = (new Builder($addendum))->build($this);
		$this->addendum = $addendum;
		ConflictChecker::check($this, $this->annotations);
	}

	public function hasAnnotation($class)
	{
		return $this->annotations->hasAnnotation($class);
	}

	public function getAnnotation($annotation)
	{
		return $this->annotations->getAnnotation($annotation);
	}

	public function getAnnotations()
	{
		return $this->annotations->getAnnotations();
	}

	public function getAllAnnotations($restriction = false)
	{
		return $this->annotations->getAllAnnotations($restriction);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

	public function getConstructor()
	{
		return $this->createReflectionAnnotatedMethod(parent::getConstructor());
	}

	public function getMethod($name)
	{
		return $this->createReflectionAnnotatedMethod(parent::getMethod($name));
	}

	public function getMethods($filter = -1)
	{
		$result = [];
		foreach (parent::getMethods($filter) as $method)
		{
			$result[] = $this->createReflectionAnnotatedMethod($method);
		}
		return $result;
	}

	public function getProperty($name)
	{
		return $this->createReflectionAnnotatedProperty(parent::getProperty($name));
	}

	public function getProperties($filter = -1)
	{
		$result = [];
		foreach (parent::getProperties($filter) as $property)
		{
			$result[] = $this->createReflectionAnnotatedProperty($property);
		}
		return $result;
	}

	public function getInterfaces()
	{
		$result = [];
		foreach (parent::getInterfaces() as $interface)
		{
			$result[] = $this->createReflectionAnnotatedClass($interface);
		}
		return $result;
	}

	public function getParentClass()
	{
		$class = parent::getParentClass();
		return $this->createReflectionAnnotatedClass($class);

	}

	private function createReflectionAnnotatedClass($class)
	{
		return ($class !== false) ? new ReflectionAnnotatedClass($class->name, $this->addendum) : false;
	}

	private function createReflectionAnnotatedMethod($method)
	{
		return ($method !== null) ? new ReflectionAnnotatedMethod($this->name, $method->name, $this->addendum) : null;
	}

	private function createReflectionAnnotatedProperty($property)
	{
		return ($property !== null) ? new ReflectionAnnotatedProperty($this->name, $property->name, $this->addendum) : null;
	}

}


1		<?php
2
3		/**
4		* This software package is licensed under AGPL, Commercial license.
5		*
6		* @package maslosoft/addendum
7		* @licence AGPL, Commercial
8		* @copyright Copyright (c) Piotr Masełkowski <[email protected]> (Meta container, further improvements, bugfixes)
9		* @copyright Copyright (c) Maslosoft (Meta container, further improvements, bugfixes)
10		* @copyright Copyright (c) Jan Suchal (Original version, builder, parser)
11		* @link http://maslosoft.com/addendum/ - maslosoft addendum
12		* @link https://code.google.com/p/addendum/ - original addendum project
13		*/
14
15		namespace Maslosoft\Addendum\Reflection;
16
17		use Maslosoft\Addendum\Addendum;
18		use Maslosoft\Addendum\Builder\Builder;
19		use Maslosoft\Addendum\Collections\AnnotationsCollection;
20		use Maslosoft\Addendum\Interfaces\AnnotatedReflectorInterface;
21		use Maslosoft\Addendum\Utilities\ConflictChecker;
22		use ReflectionClass;
23
24		class ReflectionAnnotatedClass extends ReflectionClass implements AnnotatedReflectorInterface
25		{
26
27		/**
28		* Annotations collection
29		* @var AnnotationsCollection
30		*/
31		private $annotations = null;
32
33		/**
34		* Addendum instance
35		* @var Addendum
36		*/
37		private $addendum = null;
38
39	46	public function __construct($class, Addendum $addendum = null)
40		{
41	46	parent::__construct($class);
42	46	$this->annotations = (new Builder($addendum))->build($this);
43	46	$this->addendum = $addendum;
44	46	ConflictChecker::check($this, $this->annotations);
45	46	}
46
47	45	public function hasAnnotation($class)
48		{
49	45	return $this->annotations->hasAnnotation($class);
50		}
51
52	14	public function getAnnotation($annotation)
53		{
54	14	return $this->annotations->getAnnotation($annotation);
55		}
56
57		public function getAnnotations()
58		{
59		return $this->annotations->getAnnotations();
60		}
61
62	21	public function getAllAnnotations($restriction = false)
63		{
64	21	return $this->annotations->getAllAnnotations($restriction);
		0 ignored issues – show Documentation introduced 2015-12-16 15:41 UTC by Report Bug Copy Issue Report `$restriction` is of type `boolean`, but the function expects a `false\|string`. 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...
65		}
66
67		public function getConstructor()
68		{
69		return $this->createReflectionAnnotatedMethod(parent::getConstructor());
70		}
71
72	3	public function getMethod($name)
73		{
74	3	return $this->createReflectionAnnotatedMethod(parent::getMethod($name));
75		}
76
77	21	public function getMethods($filter = -1)
78		{
79	21	$result = [];
80	21	foreach (parent::getMethods($filter) as $method)
81		{
82	3	$result[] = $this->createReflectionAnnotatedMethod($method);
83		}
84	21	return $result;
85		}
86
87	2	public function getProperty($name)
88		{
89	2	return $this->createReflectionAnnotatedProperty(parent::getProperty($name));
90		}
91
92	23	public function getProperties($filter = -1)
93		{
94	23	$result = [];
95	23	foreach (parent::getProperties($filter) as $property)
96		{
97	15	$result[] = $this->createReflectionAnnotatedProperty($property);
98		}
99	21	return $result;
100		}
101
102	43	public function getInterfaces()
103		{
104	43	$result = [];
105	43	foreach (parent::getInterfaces() as $interface)
106		{
107	38	$result[] = $this->createReflectionAnnotatedClass($interface);
108		}
109	43	return $result;
110		}
111
112	43	public function getParentClass()
113		{
114	43	$class = parent::getParentClass();
115	43	return $this->createReflectionAnnotatedClass($class);
		0 ignored issues – show Comprehensibility Best Practice introduced 2016-03-10 10:49 UTC by Report Bug Copy Issue Report The expression `$this->createReflectionAnnotatedClass($class);` of type `Maslosoft\Addendum\Refle...ionAnnotatedClass\|false` adds `false` to the return on line 115 which is incompatible with the return type of the parent method `ReflectionClass::getParentClass` of type `object`. It seems like you forgot to handle an error condition. Loading history...
116		}
117
118	43	private function createReflectionAnnotatedClass($class)
119		{
120	43	return ($class !== false) ? new ReflectionAnnotatedClass($class->name, $this->addendum) : false;
121		}
122
123	6	private function createReflectionAnnotatedMethod($method)
124		{
125	6	return ($method !== null) ? new ReflectionAnnotatedMethod($this->name, $method->name, $this->addendum) : null;
126		}
127
128	17	private function createReflectionAnnotatedProperty($property)
129		{
130	17	return ($property !== null) ? new ReflectionAnnotatedProperty($this->name, $property->name, $this->addendum) : null;
131		}
132
133		}
134

Maslosoft / Addendum

Push — master ( 93c108...b5b8be )

ReflectionAnnotatedClass::getMethod() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like