OrmUtils - Code Metrics - Inspection of "Router v0" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 31895c...135d28 )

by Jean-Christophe

created 2017-04-11 23:49 UTC

OrmUtils B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	180
Duplicated Lines	14.44 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

Metric	Value
wmc	49
lcom	1
cbo	2
dl	26
loc	180
rs	8.5454
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	getModelMetadata()	0	6	2
A	isSerializable()	7	7	2
A	isNullable()	7	7	2
A	getFieldName()	8	8	2
A	getTableName()	0	3	1
A	getKeyFieldsAndValues()	0	4	1
A	getKeyFields()	0	3	1
A	getMembers()	0	6	2
B	getMembersAndValues()	4	16	9
A	getFirstKey()	0	4	1
A	getFirstKeyValue()	0	4	1
B	getManyToOneMembersAndValues()	0	21	6
A	getMembersWithAnnotation()	0	5	2
B	exists()	0	12	5
A	getJoinColumnName()	0	9	2
A	getAnnotationInfo()	0	5	2
A	getAnnotationInfoMember()	0	9	3
A	getSerializableFields()	0	5	1
A	getFieldsInRelations()	0	10	3
A	getDefaultFk()	0	3	1

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 OrmUtils 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 OrmUtils, and based on these observations, apply Extract Interface, too.

<?php
namespace micro\orm;

use mindplay\annotations\Annotations;
use mindplay\annotations\AnnotationCache;
use mindplay\annotations\AnnotationManager;
use micro\orm\parser\Reflexion;
use micro\cache\CacheManager;

/**
 * Utilitaires de mappage Objet/relationnel
 * @author jc
 * @version 1.0.0.5
 * @package orm
 */
class OrmUtils{
	private static $modelsMetadatas;

	public static function getModelMetadata($className){
		if(!isset(self::$modelsMetadatas[$className])){
			self::$modelsMetadatas[$className]=CacheManager::createOrmModelCache($className);
		}
		return self::$modelsMetadatas[$className];
	}

	public static function isSerializable($class,$member){

		$ret=self::getAnnotationInfo($class,"#notSerializable");
		if ($ret!==false)
			return \array_search($member, $ret)===false;
		else
			return true;
	}

	public static function isNullable($class,$member){

		$ret=self::getAnnotationInfo($class,"#nullable");
		if ($ret!==false)
			return \array_search($member, $ret)!==false;
		else
			return false;
	}

	public static function getFieldName($class,$member){

		$ret=self::getAnnotationInfo($class, "#fieldNames");
		if($ret===false)
			$ret=$member;
		else
			$ret=$ret[$member];
		return $ret;
	}

	public static function getTableName($class){
		return self::getModelMetadata($class)["#tableName"];
	}

	public static function getKeyFieldsAndValues($instance){
		$kf=self::getAnnotationInfo(get_class($instance), "#primaryKeys");
		return self::getMembersAndValues($instance,$kf);
	}

	public static function getKeyFields($instance){
		return self::getAnnotationInfo(get_class($instance), "#primaryKeys");
	}

	public function getMembers($className){
		$fieldNames=self::getAnnotationInfo($className, "#fieldNames");
		if($fieldNames!==false)
			return \array_keys($fieldNames);
		return [];
	}

	public static function getMembersAndValues($instance,$members=NULL){
		$ret=array();
		$className=get_class($instance);
		if(is_null($members))
			$members=self::getMembers($className);
		foreach ($members as $member){
			if(OrmUtils::isSerializable($className,$member)){
				$v=Reflexion::getMemberValue($instance, $member);
				if(($v!==null && $v!=="") || (($v===null || $v==="") && OrmUtils::isNullable($className, $member))){

					$name=self::getFieldName($className, $member);
					$ret[$name]=$v;
				}
			}
		}
		return $ret;
	}

	public static function getFirstKey($class){
		$kf=self::getAnnotationInfo($class, "#primaryKeys");
		return \reset($kf);
	}

	public static function getFirstKeyValue($instance){
		$fkv=self::getKeyFieldsAndValues($instance);
		return \reset($fkv);
	}

	/**
	 * @param object $instance
	 * @return mixed[]
	 */
	public static function getManyToOneMembersAndValues($instance){
		$ret=array();
		$class=get_class($instance);
		$members=self::getAnnotationInfo($class, "#manyToOne");
		if($members!==false){
			foreach ($members as $member){
				$memberAccessor="get".ucfirst($member);
				if(method_exists($instance,$memberAccessor)){
					$memberInstance=$instance->$memberAccessor();
					if(isset($memberInstance)){
						$keyValues=self::getKeyFieldsAndValues($memberInstance);
						if(sizeof($keyValues)>0){
							$fkName=self::getJoinColumnName($class, $member);
							$ret[$fkName]=reset($keyValues);
						}
					}
				}
			}
		}
		return $ret;
	}

	public static function getMembersWithAnnotation($class,$annotation){
		if(isset(self::getModelMetadata($class)[$annotation]))
			return self::getModelMetadata($class)[$annotation];
		return [];
	}

	/**
	 * @param object $instance
	 * @param string $memberKey
	 * @param array $array
	 * @return boolean
	 */
	public static function exists($instance,$memberKey,$array){
		$accessor="get".ucfirst($memberKey);
		if(method_exists($instance, $accessor)){
			if($array!==null){
				foreach ($array as $value){
					if($value->$accessor()==$instance->$accessor())
						return true;
				}
			}
		}
		return false;
	}

	public static function getJoinColumnName($class,$member){
		$annot=self::getAnnotationInfoMember($class, "#joinColumn",$member);
		if($annot!==false){
			$fkName=$annot["name"];
		}else{
			$fkName="id".ucfirst(self::getTableName(ucfirst($member)));
		}
		return $fkName;
	}

	public static function getAnnotationInfo($class,$keyAnnotation){
		if(isset(self::getModelMetadata($class)[$keyAnnotation]))
			return self::getModelMetadata($class)[$keyAnnotation];
		return false;
	}

	public static function getAnnotationInfoMember($class,$keyAnnotation,$member){
		$info=self::getAnnotationInfo($class, $keyAnnotation);
		if($info!==false){
			if(isset($info[$member])){
				return $info[$member];
			}
		}
		return false;
	}

	public static function getSerializableFields($class){
		$notSerializable=self::getAnnotationInfo($class, "#notSerializable");
		$fieldNames=\array_keys(self::getAnnotationInfo($class, "#fieldNames"));
		return \array_diff($fieldNames, $notSerializable);
	}

	public static function getFieldsInRelations($class){
		$result=[];
		if($manyToOne=self::getAnnotationInfo($class, "#manyToOne")){
			$result=\array_merge($result,$manyToOne);
		}
		if($oneToMany=self::getAnnotationInfo($class, "#oneToMany")){
			$result=\array_merge($result,\array_keys($oneToMany));
		}
		return $result;
	}

	public static function getDefaultFk($classname){
		return "id".\ucfirst(self::getTableName($classname));
	}
}


1		<?php
2		namespace micro\orm;
3
4		use mindplay\annotations\Annotations;
5		use mindplay\annotations\AnnotationCache;
6		use mindplay\annotations\AnnotationManager;
7		use micro\orm\parser\Reflexion;
8		use micro\cache\CacheManager;
9
10		/**
11		* Utilitaires de mappage Objet/relationnel
12		* @author jc
13		* @version 1.0.0.5
14		* @package orm
15		*/
16		class OrmUtils{
17		private static $modelsMetadatas;
18
19		public static function getModelMetadata($className){
20		if(!isset(self::$modelsMetadatas[$className])){
21		self::$modelsMetadatas[$className]=CacheManager::createOrmModelCache($className);
22		}
23		return self::$modelsMetadatas[$className];
24		}
25
26	View Code Duplication	public static function isSerializable($class,$member){
		1 ignored issue – show Duplication introduced 2017-04-06 23:43 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...
27		$ret=self::getAnnotationInfo($class,"#notSerializable");
28		if ($ret!==false)
29		return \array_search($member, $ret)===false;
30		else
31		return true;
32		}
33
34	View Code Duplication	public static function isNullable($class,$member){
		1 ignored issue – show Duplication introduced 2017-04-06 23:43 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...
35		$ret=self::getAnnotationInfo($class,"#nullable");
36		if ($ret!==false)
37		return \array_search($member, $ret)!==false;
38		else
39		return false;
40		}
41
42	View Code Duplication	public static function getFieldName($class,$member){
		1 ignored issue – show Duplication introduced 2017-04-06 23:43 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...
43		$ret=self::getAnnotationInfo($class, "#fieldNames");
44		if($ret===false)
45		$ret=$member;
46		else
47		$ret=$ret[$member];
48		return $ret;
49		}
50
51		public static function getTableName($class){
52		return self::getModelMetadata($class)["#tableName"];
53		}
54
55		public static function getKeyFieldsAndValues($instance){
56		$kf=self::getAnnotationInfo(get_class($instance), "#primaryKeys");
57		return self::getMembersAndValues($instance,$kf);
58		}
59
60		public static function getKeyFields($instance){
61		return self::getAnnotationInfo(get_class($instance), "#primaryKeys");
62		}
63
64		public function getMembers($className){
65		$fieldNames=self::getAnnotationInfo($className, "#fieldNames");
66		if($fieldNames!==false)
67		return \array_keys($fieldNames);
68		return [];
69		}
70
71		public static function getMembersAndValues($instance,$members=NULL){
72		$ret=array();
73		$className=get_class($instance);
74		if(is_null($members))
75		$members=self::getMembers($className);
76		foreach ($members as $member){
77		if(OrmUtils::isSerializable($className,$member)){
78		$v=Reflexion::getMemberValue($instance, $member);
79	View Code Duplication	if(($v!==null && $v!=="") \|\| (($v===null \|\| $v==="") && OrmUtils::isNullable($className, $member))){
		0 ignored issues – show Duplication introduced 2017-04-06 23:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
80		$name=self::getFieldName($className, $member);
81		$ret[$name]=$v;
82		}
83		}
84		}
85		return $ret;
86		}
87
88		public static function getFirstKey($class){
89		$kf=self::getAnnotationInfo($class, "#primaryKeys");
90		return \reset($kf);
91		}
92
93		public static function getFirstKeyValue($instance){
94		$fkv=self::getKeyFieldsAndValues($instance);
95		return \reset($fkv);
96		}
97
98		/**
99		* @param object $instance
100		* @return mixed[]
101		*/
102		public static function getManyToOneMembersAndValues($instance){
103		$ret=array();
104		$class=get_class($instance);
105		$members=self::getAnnotationInfo($class, "#manyToOne");
106		if($members!==false){
107		foreach ($members as $member){
108		$memberAccessor="get".ucfirst($member);
109		if(method_exists($instance,$memberAccessor)){
110		$memberInstance=$instance->$memberAccessor();
111		if(isset($memberInstance)){
112		$keyValues=self::getKeyFieldsAndValues($memberInstance);
113		if(sizeof($keyValues)>0){
114		$fkName=self::getJoinColumnName($class, $member);
115		$ret[$fkName]=reset($keyValues);
116		}
117		}
118		}
119		}
120		}
121		return $ret;
122		}
123
124		public static function getMembersWithAnnotation($class,$annotation){
125		if(isset(self::getModelMetadata($class)[$annotation]))
126		return self::getModelMetadata($class)[$annotation];
127		return [];
128		}
129
130		/**
131		* @param object $instance
132		* @param string $memberKey
133		* @param array $array
134		* @return boolean
135		*/
136		public static function exists($instance,$memberKey,$array){
137		$accessor="get".ucfirst($memberKey);
138		if(method_exists($instance, $accessor)){
139		if($array!==null){
140		foreach ($array as $value){
141		if($value->$accessor()==$instance->$accessor())
142		return true;
143		}
144		}
145		}
146		return false;
147		}
148
149		public static function getJoinColumnName($class,$member){
150		$annot=self::getAnnotationInfoMember($class, "#joinColumn",$member);
151		if($annot!==false){
152		$fkName=$annot["name"];
153		}else{
154		$fkName="id".ucfirst(self::getTableName(ucfirst($member)));
155		}
156		return $fkName;
157		}
158
159		public static function getAnnotationInfo($class,$keyAnnotation){
160		if(isset(self::getModelMetadata($class)[$keyAnnotation]))
161		return self::getModelMetadata($class)[$keyAnnotation];
162		return false;
163		}
164
165		public static function getAnnotationInfoMember($class,$keyAnnotation,$member){
166		$info=self::getAnnotationInfo($class, $keyAnnotation);
167		if($info!==false){
168		if(isset($info[$member])){
169		return $info[$member];
170		}
171		}
172		return false;
173		}
174
175		public static function getSerializableFields($class){
176		$notSerializable=self::getAnnotationInfo($class, "#notSerializable");
177		$fieldNames=\array_keys(self::getAnnotationInfo($class, "#fieldNames"));
178		return \array_diff($fieldNames, $notSerializable);
179		}
180
181		public static function getFieldsInRelations($class){
182		$result=[];
183		if($manyToOne=self::getAnnotationInfo($class, "#manyToOne")){
184		$result=\array_merge($result,$manyToOne);
185		}
186		if($oneToMany=self::getAnnotationInfo($class, "#oneToMany")){
187		$result=\array_merge($result,\array_keys($oneToMany));
188		}
189		return $result;
190		}
191
192		public static function getDefaultFk($classname){
193		return "id".\ucfirst(self::getTableName($classname));
194		}
195		}
196

phpMv / ubiquity