Reflexion - Code Metrics - Inspection of "Adds server side validation" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f8bd36...f2dc96 )

by Jean-Christophe

created 2018-12-28 02:55 UTC

Reflexion C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	199
Duplicated Lines	15.58 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

Metric	Value
wmc	53
lcom	1
cbo	1
dl	31
loc	199
rs	6.96
c	0
b	0
f	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	getProperties()	0	8	2
A	getMethods()	0	5	1
A	getKeyFields()	0	3	1
A	getMemberValue()	0	5	1
A	setMemberValue()	0	9	2
A	getProperty()	0	7	2
A	getPropertiesAndValues()	4	17	5
A	getAnnotationClass()	0	4	1
A	getAnnotationMember()	0	6	2
A	getAnnotationsMember()	0	3	1
A	getAnnotationsMethod()	0	16	5
A	getMembersAnnotationWithAnnotation()	10	10	3
A	getMembersWithAnnotation()	0	10	3
A	getMembersNameWithAnnotation()	10	10	3
A	isNullable()	0	7	2
A	getDbType()	0	7	2
A	isSerializable()	0	6	5
A	getFieldName()	0	8	3
A	getTableName()	0	12	3
A	getMethodParameters()	0	7	2
A	getJoinTables()	0	8	2
A	getAllJoinTables()	7	7	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Reflexion often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Reflexion, and based on these observations, apply Extract Interface, too.

<?php

namespace Ubiquity\orm\parser;

use mindplay\annotations\Annotations;
use Ubiquity\orm\OrmUtils;

/**
 * Utilitaires de Reflexion
 * @author jc
 * @version 1.0.0.2
 */
class Reflexion {

	public static function getProperties($instance) {
		if (\is_string($instance)) {
			$instance=new $instance();
		}
		$reflect=new \ReflectionClass($instance);
		$props=$reflect->getProperties();
		return $props;
	}

	public static function getMethods($instance, $filter=null) {
		$reflect=new \ReflectionClass($instance);
		$methods=$reflect->getMethods($filter);
		return $methods;
	}

	public static function getKeyFields($instance) {
		return Reflexion::getMembersNameWithAnnotation(get_class($instance), "@id");
	}

	public static function getMemberValue($instance, $member) {
		$prop=self::getProperty($instance, $member);
		$prop->setAccessible(true);
		return $prop->getValue($instance);
	}

	public static function setMemberValue($instance, $member,$value) {
		$prop=self::getProperty($instance, $member);
		if($prop){
			$prop->setAccessible(true);
			$prop->setValue($instance,$value);
			return true;
		}
		return false;
	}

	public static function getProperty($instance, $member) {
		$reflect=new \ReflectionClass($instance);
		$prop=false;
		if($reflect->hasProperty($member))
			$prop=$reflect->getProperty($member);
		return $prop;
	}

	public static function getPropertiesAndValues($instance, $props=NULL) {
		$ret=array ();
		$className=get_class($instance);
		if (is_null($props))
			$props=self::getProperties($instance);
		foreach ( $props as $prop ) {
			$prop->setAccessible(true);
			$v=$prop->getValue($instance);
			if (OrmUtils::isSerializable($className, $prop->getName())) {
				if (OrmUtils::isNotNullOrNullAccepted($v, $className, $prop->getName())) {
					$name=OrmUtils::getFieldName($className, $prop->getName());
					$ret[$name]=$v;
				}
			}
		}
		return $ret;
	}

	public static function getAnnotationClass($class, $annotation) {
		$annot=Annotations::ofClass($class, $annotation);
		return $annot;
	}

	public static function getAnnotationMember($class, $member, $annotation) {
		$annot=Annotations::ofProperty($class, $member, $annotation);
		if (\sizeof($annot) > 0)
			return $annot[0];
		return false;
	}
	
	public static function getAnnotationsMember($class, $member, $annotation) {
		return Annotations::ofProperty($class, $member, $annotation);
	}

	public static function getAnnotationsMethod($class, $method, $annotation) {
		if(is_array($annotation)){
			$result=[];
			foreach($annotation as $annot){
				$annots=Annotations::ofMethod($class, $method, $annot);
				if(sizeof($annots)>0){
					$result=array_merge($result,$annots);
				}
			}
			return $result;
		}
		$annots=Annotations::ofMethod($class, $method, $annotation);
		if (\sizeof($annots) > 0)
			return $annots;
		return false;
	}

	public static function getMembersAnnotationWithAnnotation($class, $annotation) {
		$props=self::getProperties($class);
		$ret=array ();
		foreach ( $props as $prop ) {
			$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
			if ($annot !== false)
				$ret[$prop->getName()]=$annot;
		}
		return $ret;
	}

	public static function getMembersWithAnnotation($class, $annotation) {
		$props=self::getProperties($class);
		$ret=array ();
		foreach ( $props as $prop ) {
			$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
			if ($annot !== false)
				$ret[]=$prop;
		}
		return $ret;
	}

	public static function getMembersNameWithAnnotation($class, $annotation) {
		$props=self::getProperties($class);
		$ret=array ();
		foreach ( $props as $prop ) {
			$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
			if ($annot !== false)
				$ret[]=$prop->getName();
		}
		return $ret;
	}

	public static function isNullable($class, $member) {
		$ret=self::getAnnotationMember($class, $member, "@column");
		if (!$ret)
			return false;
		else
			return $ret->nullable;
	}

	public static function getDbType($class, $member) {
		$ret=self::getAnnotationMember($class, $member, "@column");
		if (!$ret)
			return false;
		else
			return $ret->dbType;
	}

	public static function isSerializable($class, $member) {
		if (self::getAnnotationMember($class, $member, "@transient") !== false || self::getAnnotationMember($class, $member, "@manyToOne") !== false || self::getAnnotationMember($class, $member, "@manyToMany") !== false || self::getAnnotationMember($class, $member, "@oneToMany") !== false)
			return false;
		else
			return true;
	}

	public static function getFieldName($class, $member) {
		$ret=self::getAnnotationMember($class, $member, "@column");
		if ($ret === false || !isset($ret->name))
			$ret=$member;
		else
			$ret=$ret->name;
		return $ret;
	}

	public static function getTableName($class) {
		$ret=Reflexion::getAnnotationClass($class, "@table");
		if (\sizeof($ret) === 0) {
			$posSlash=strrpos($class, '\\');
			if ($posSlash !== false)
				$class=substr($class, $posSlash + 1);
			$ret=$class;
		} else {
			$ret=$ret[0]->name;
		}
		return $ret;
	}

	public static function getMethodParameters(\ReflectionMethod $method) {
		$result=array ();
		foreach ( $method->getParameters() as $param ) {
			$result[]=$param->name;
		}
		return $result;
	}
	
	public static function getJoinTables($class){
		$result=[];
		$annots=self::getMembersAnnotationWithAnnotation($class, "@joinTable");
		foreach ($annots as $annot){
			$result[]=$annot->name;
		}
		return $result;
	}
	
	public static function getAllJoinTables($models){

		$result=[];
		foreach ($models as $model){
			$result=array_merge($result,self::getJoinTables($model));
		}
		return $result;
	}
}


1		<?php
2
3		namespace Ubiquity\orm\parser;
4
5		use mindplay\annotations\Annotations;
6		use Ubiquity\orm\OrmUtils;
7
8		/**
9		* Utilitaires de Reflexion
10		* @author jc
11		* @version 1.0.0.2
12		*/
13		class Reflexion {
14
15		public static function getProperties($instance) {
16		if (\is_string($instance)) {
17		$instance=new $instance();
18		}
19		$reflect=new \ReflectionClass($instance);
20		$props=$reflect->getProperties();
21		return $props;
22		}
23
24		public static function getMethods($instance, $filter=null) {
25		$reflect=new \ReflectionClass($instance);
26		$methods=$reflect->getMethods($filter);
27		return $methods;
28		}
29
30		public static function getKeyFields($instance) {
31		return Reflexion::getMembersNameWithAnnotation(get_class($instance), "@id");
32		}
33
34		public static function getMemberValue($instance, $member) {
35		$prop=self::getProperty($instance, $member);
36		$prop->setAccessible(true);
37		return $prop->getValue($instance);
38		}
39
40		public static function setMemberValue($instance, $member,$value) {
41		$prop=self::getProperty($instance, $member);
42		if($prop){
43		$prop->setAccessible(true);
44		$prop->setValue($instance,$value);
45		return true;
46		}
47		return false;
48		}
49
50		public static function getProperty($instance, $member) {
51		$reflect=new \ReflectionClass($instance);
52		$prop=false;
53		if($reflect->hasProperty($member))
54		$prop=$reflect->getProperty($member);
55		return $prop;
56		}
57
58		public static function getPropertiesAndValues($instance, $props=NULL) {
59		$ret=array ();
60		$className=get_class($instance);
61		if (is_null($props))
62		$props=self::getProperties($instance);
63		foreach ( $props as $prop ) {
64		$prop->setAccessible(true);
65		$v=$prop->getValue($instance);
66		if (OrmUtils::isSerializable($className, $prop->getName())) {
67	View Code Duplication	if (OrmUtils::isNotNullOrNullAccepted($v, $className, $prop->getName())) {
68		$name=OrmUtils::getFieldName($className, $prop->getName());
69		$ret[$name]=$v;
70		}
71		}
72		}
73		return $ret;
74		}
75
76		public static function getAnnotationClass($class, $annotation) {
77		$annot=Annotations::ofClass($class, $annotation);
78		return $annot;
79		}
80
81		public static function getAnnotationMember($class, $member, $annotation) {
82		$annot=Annotations::ofProperty($class, $member, $annotation);
83		if (\sizeof($annot) > 0)
84		return $annot[0];
85		return false;
86		}
87
88		public static function getAnnotationsMember($class, $member, $annotation) {
89		return Annotations::ofProperty($class, $member, $annotation);
90		}
91
92		public static function getAnnotationsMethod($class, $method, $annotation) {
93		if(is_array($annotation)){
94		$result=[];
95		foreach($annotation as $annot){
96		$annots=Annotations::ofMethod($class, $method, $annot);
97		if(sizeof($annots)>0){
98		$result=array_merge($result,$annots);
99		}
100		}
101		return $result;
102		}
103		$annots=Annotations::ofMethod($class, $method, $annotation);
104		if (\sizeof($annots) > 0)
105		return $annots;
106		return false;
107		}
108
109	View Code Duplication	public static function getMembersAnnotationWithAnnotation($class, $annotation) {
110		$props=self::getProperties($class);
111		$ret=array ();
112		foreach ( $props as $prop ) {
113		$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
114		if ($annot !== false)
115		$ret[$prop->getName()]=$annot;
116		}
117		return $ret;
118		}
119
120		public static function getMembersWithAnnotation($class, $annotation) {
121		$props=self::getProperties($class);
122		$ret=array ();
123		foreach ( $props as $prop ) {
124		$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
125		if ($annot !== false)
126		$ret[]=$prop;
127		}
128		return $ret;
129		}
130
131	View Code Duplication	public static function getMembersNameWithAnnotation($class, $annotation) {
132		$props=self::getProperties($class);
133		$ret=array ();
134		foreach ( $props as $prop ) {
135		$annot=self::getAnnotationMember($class, $prop->getName(), $annotation);
136		if ($annot !== false)
137		$ret[]=$prop->getName();
138		}
139		return $ret;
140		}
141
142		public static function isNullable($class, $member) {
143		$ret=self::getAnnotationMember($class, $member, "@column");
144		if (!$ret)
145		return false;
146		else
147		return $ret->nullable;
148		}
149
150		public static function getDbType($class, $member) {
151		$ret=self::getAnnotationMember($class, $member, "@column");
152		if (!$ret)
153		return false;
154		else
155		return $ret->dbType;
156		}
157
158		public static function isSerializable($class, $member) {
159		if (self::getAnnotationMember($class, $member, "@transient") !== false \|\| self::getAnnotationMember($class, $member, "@manyToOne") !== false \|\| self::getAnnotationMember($class, $member, "@manyToMany") !== false \|\| self::getAnnotationMember($class, $member, "@oneToMany") !== false)
160		return false;
161		else
162		return true;
163		}
164
165		public static function getFieldName($class, $member) {
166		$ret=self::getAnnotationMember($class, $member, "@column");
167		if ($ret === false \|\| !isset($ret->name))
168		$ret=$member;
169		else
170		$ret=$ret->name;
171		return $ret;
172		}
173
174		public static function getTableName($class) {
175		$ret=Reflexion::getAnnotationClass($class, "@table");
176		if (\sizeof($ret) === 0) {
177		$posSlash=strrpos($class, '\\');
178		if ($posSlash !== false)
179		$class=substr($class, $posSlash + 1);
180		$ret=$class;
181		} else {
182		$ret=$ret[0]->name;
183		}
184		return $ret;
185		}
186
187		public static function getMethodParameters(\ReflectionMethod $method) {
188		$result=array ();
189		foreach ( $method->getParameters() as $param ) {
190		$result[]=$param->name;
191		}
192		return $result;
193		}
194
195		public static function getJoinTables($class){
196		$result=[];
197		$annots=self::getMembersAnnotationWithAnnotation($class, "@joinTable");
198		foreach ($annots as $annot){
199		$result[]=$annot->name;
200		}
201		return $result;
202		}
203
204	View Code Duplication	public static function getAllJoinTables($models){
		1 ignored issue – show Duplication introduced 2018-06-04 00:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
205		$result=[];
206		foreach ($models as $model){
207		$result=array_merge($result,self::getJoinTables($model));
208		}
209		return $result;
210		}
211		}
212

phpMv / ubiquity