ValidatorsManager - Code Metrics - Inspection of "Add sessionCache" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3a0750...56d871 )

by Jean-Christophe

created 2019-01-08 02:58 UTC

ValidatorsManager C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	254
Duplicated Lines	10.24 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	55
lcom	1
cbo	4
dl	26
loc	254
rs	6
c	0
b	0
f	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	start()	0	3	1
A	registerType()	0	3	1
A	initModelsValidators()	0	11	3
A	store()	0	3	1
A	fetch()	0	7	2
A	getGroupArrayValidators()	0	10	3
A	getGroupMemberValidators()	0	9	4
A	getCacheValidators()	0	9	3
A	validate()	0	11	3
A	validateInstances()	0	14	3
A	clearCache()	0	10	3
A	validateInstances_()	14	14	5
A	validate_()	0	19	6
A	validateFromCache_()	12	12	4
A	initCacheInstanceValidators()	0	5	1
B	initInstancesValidators()	0	20	8
A	getHash()	0	3	1
A	getModelCacheKey()	0	3	1
A	getValidatorInstance()	0	9	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 ValidatorsManager 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 ValidatorsManager, and based on these observations, apply Extract Interface, too.

<?php

namespace Ubiquity\contents\validation;

use Ubiquity\cache\CacheManager;
use Ubiquity\log\Logger;
use Ubiquity\contents\validation\validators\multiples\LengthValidator;
use Ubiquity\contents\validation\validators\multiples\IdValidator;
use Ubiquity\contents\validation\validators\basic\NotNullValidator;
use Ubiquity\contents\validation\validators\basic\NotEmptyValidator;
use Ubiquity\contents\validation\validators\comparison\EqualsValidator;
use Ubiquity\contents\validation\validators\basic\TypeValidator;
use Ubiquity\contents\validation\validators\comparison\GreaterThanValidator;
use Ubiquity\contents\validation\validators\comparison\LessThanValidator;
use Ubiquity\contents\validation\validators\basic\IsNullValidator;
use Ubiquity\contents\validation\validators\basic\IsEmptyValidator;
use Ubiquity\contents\validation\validators\basic\IsTrueValidator;
use Ubiquity\contents\validation\validators\basic\IsFalseValidator;
use Ubiquity\contents\validation\validators\strings\RegexValidator;
use Ubiquity\contents\validation\validators\strings\EmailValidator;
use Ubiquity\contents\validation\validators\strings\UrlValidator;
use Ubiquity\contents\validation\validators\strings\IpValidator;
use Ubiquity\contents\validation\validators\comparison\RangeValidator;
use Ubiquity\contents\validation\validators\comparison\GreaterThanOrEqualValidator;
use Ubiquity\contents\validation\validators\comparison\LessThanOrEqualValidator;
use Ubiquity\contents\validation\validators\dates\DateValidator;
use Ubiquity\contents\validation\validators\dates\DateTimeValidator;
use Ubiquity\contents\validation\validators\dates\TimeValidator;
use Ubiquity\contents\validation\validators\basic\IsBooleanValidator;
use Ubiquity\cache\objects\SessionCache;

/**
 * Validators manager
 * @author jcheron <[email protected]>
 * @version 1.0.0
 */
class ValidatorsManager {
	protected static $instanceValidators=[];
	protected static $cache;
	
	public static function start(){
		self::$cache=new SessionCache();
	}
	
	public static $validatorTypes=[
			"notNull"=>NotNullValidator::class,
			"isNull"=>IsNullValidator::class,
			"notEmpty"=>NotEmptyValidator::class,
			"isEmpty"=>IsEmptyValidator::class,
			"isTrue"=>IsTrueValidator::class,
			"isFalse"=>IsFalseValidator::class,
			"isBool"=>IsBooleanValidator::class,
			"equals"=>EqualsValidator::class,
			"type"=>TypeValidator::class,
			"greaterThan"=>GreaterThanValidator::class,
			"greaterThanOrEqual"=>GreaterThanOrEqualValidator::class,
			"lessThan"=>LessThanValidator::class,
			"lessThanOrEqual"=>LessThanOrEqualValidator::class,
			"length"=>LengthValidator::class,
			"id"=>IdValidator::class,
			"regex"=>RegexValidator::class,
			"email"=>EmailValidator::class,
			"url"=>UrlValidator::class,
			"ip"=>IpValidator::class,
			"range"=>RangeValidator::class,
			"date"=>DateValidator::class,
			"dateTime"=>DateTimeValidator::class,
			"time"=>TimeValidator::class
			
	];
	
	protected static $key="contents/validators/";
	
	/**
	 * Registers a validator type for using with @validator annotation
	 * @param string $type
	 * @param string $validatorClass
	 */
	public static function registerType($type,$validatorClass){
		self::$validatorTypes[$type]=$validatorClass;
	}
	
	/**
	 * Parses models and save validators in cache
	 * to use in dev only
	 * @param array $config
	 */
	public static function initModelsValidators(&$config){
		$models=CacheManager::getModels($config,true);
		foreach ($models as $model){
			$parser=new ValidationModelParser();
			$parser->parse($model);
			$validators=$parser->getValidators();
			if(sizeof($validators)>0){
				self::store($model, $parser->__toString());
			}
		}
	}
	
	protected static function store($model,$validators){
		CacheManager::$cache->store(self::getModelCacheKey($model), $validators);
	}
	
	protected static function fetch($model){
		$key=self::getModelCacheKey($model);
		if(CacheManager::$cache->exists($key)){
			return CacheManager::$cache->fetch($key);
		}
		return [];
	}
	
	protected static function getGroupArrayValidators(array $validators,$group){
		$result=[];
		foreach ($validators as $member=>$validators){
			$filteredValidators=self::getGroupMemberValidators($validators, $group);
			if(sizeof($filteredValidators)){
				$result[$member]=$filteredValidators;
			}
		}
		return $result;
	}
	
	protected static function getGroupMemberValidators(array $validators,$group){
		$result=[];
		foreach ($validators as $validator){
			if(isset($validator["group"]) && $validator["group"]===$group){
				$result[]=$validator;
			}
		}
		return $result;
	}
	
	private static function getCacheValidators($instance,$group=""){
		if(isset(self::$cache)){
			$key=self::getHash(get_class($instance).$group);
			if(self::$cache->exists($key)){
				return self::$cache->fetch($key);
			}
		}
		return false;
	}
	
	/**
	 * Validates an instance
	 * @param object $instance
	 * @param string $group
	 * @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
	 */
	public static function validate($instance,$group=""){
		$cache=self::getCacheValidators($instance,$group);
		if($cache!==false){
			return self::validateFromCache_($instance,$cache);
		}
		$members=self::fetch(get_class($instance));
		if($group!==""){
			$members=self::getGroupArrayValidators($members, $group);
		}
		return self::validate_($instance,$members);
	}
	
	/**
	 * Validates an array of objects
	 * @param array $instances
	 * @param string $group
	 * @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
	 */
	public static function validateInstances($instances,$group=""){
		if(sizeof($instances)>0){
			$instance=reset($instances);
			$cache=self::getCacheValidators($instance,$group);
			if($cache===false){
				$class=get_class($instance);
				$members=self::fetch($class);
				self::initInstancesValidators($instance, $members,$group);
				$cache=self::$instanceValidators[$class];
			}
			return self::validateInstances_($instances,$cache);
		}
		return [];
	}
	
	public static function clearCache($model=null,$group=""){
		if(isset(self::$cache)){
			if(isset($model)){
				$key=self::getHash($model.$group);
				self::$cache->remove($key);
			}else{
				self::$cache->clear();
			}
		}
	}
	
	protected static function validateInstances_($instances,$members){

		$result=[];
		foreach ($instances as $instance){
			foreach ($members as $accessor=>$validators){
				foreach ($validators as $validator){
					$valid=$validator->validate_($instance->$accessor());
					if($valid!==true){
						$result[]=$valid;
					}
				}
			}
		}
		return $result;
	}
	
	protected static function validate_($instance,$members){
		$result=[];
		foreach ($members as $member=>$validators){
			$accessor="get".ucfirst($member);
			if(method_exists($instance, $accessor)){
				foreach ($validators as $validator){
					$validatorInstance=self::getValidatorInstance($validator["type"]);
					if($validatorInstance!==false){
						$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
						$valid=$validatorInstance->validate_($instance->$accessor());
						if($valid!==true){
							$result[]=$valid;
						}
					}
				}
			}
		}
		return $result;
	}
	
	protected static function validateFromCache_($instance,$members){

		$result=[];
		foreach ($members as $accessor=>$validators){
			foreach ($validators as $validatorInstance){
				$valid=$validatorInstance->validate_($instance->$accessor());
				if($valid!==true){
					$result[]=$valid;
				}
			}
		}
		return $result;
	}
	
	/**
	 * Initializes the cache (SessionCache) for the class of înstance
	 * @param object $instance
	 * @param string $group
	 */
	public static function initCacheInstanceValidators($instance,$group=""){
		$class=get_class($instance);
		$members=self::fetch($class);
		self::initInstancesValidators($instance, $members,$group);
	}
	
	protected static function initInstancesValidators($instance,$members,$group=""){
		$class=get_class($instance);
		$result=[];
		foreach ($members as $member=>$validators){
			$accessor="get".ucfirst($member);
			if(method_exists($instance, $accessor)){
				foreach ($validators as $validator){
					$validatorInstance=self::getValidatorInstance($validator["type"]);
					if($validatorInstance!==false){
						$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
						if($group==="" || (isset($validator["group"]) && $validator["group"]===$group)){
							self::$instanceValidators[$class][$accessor][]=$validatorInstance;
							$result[$accessor][]=$validatorInstance;
						}
					}
				}
			}
		}
		self::$cache->store(self::getHash($class.$group), $result);
	}
	
	protected static function getHash($class){
		return hash("sha1", $class);
	}
	
	protected static function getModelCacheKey($classname){
		return self::$key.\str_replace("\\", DIRECTORY_SEPARATOR, $classname);
	}
	
	protected static function getValidatorInstance($type){
		if(isset(self::$validatorTypes[$type])){
			$class=self::$validatorTypes[$type];
			return new $class();
		}else{
			Logger::warn("validation", "Validator ".$type." does not exists!");
			return false;
		}
	}
}



1		<?php
2
3		namespace Ubiquity\contents\validation;
4
5		use Ubiquity\cache\CacheManager;
6		use Ubiquity\log\Logger;
7		use Ubiquity\contents\validation\validators\multiples\LengthValidator;
8		use Ubiquity\contents\validation\validators\multiples\IdValidator;
9		use Ubiquity\contents\validation\validators\basic\NotNullValidator;
10		use Ubiquity\contents\validation\validators\basic\NotEmptyValidator;
11		use Ubiquity\contents\validation\validators\comparison\EqualsValidator;
12		use Ubiquity\contents\validation\validators\basic\TypeValidator;
13		use Ubiquity\contents\validation\validators\comparison\GreaterThanValidator;
14		use Ubiquity\contents\validation\validators\comparison\LessThanValidator;
15		use Ubiquity\contents\validation\validators\basic\IsNullValidator;
16		use Ubiquity\contents\validation\validators\basic\IsEmptyValidator;
17		use Ubiquity\contents\validation\validators\basic\IsTrueValidator;
18		use Ubiquity\contents\validation\validators\basic\IsFalseValidator;
19		use Ubiquity\contents\validation\validators\strings\RegexValidator;
20		use Ubiquity\contents\validation\validators\strings\EmailValidator;
21		use Ubiquity\contents\validation\validators\strings\UrlValidator;
22		use Ubiquity\contents\validation\validators\strings\IpValidator;
23		use Ubiquity\contents\validation\validators\comparison\RangeValidator;
24		use Ubiquity\contents\validation\validators\comparison\GreaterThanOrEqualValidator;
25		use Ubiquity\contents\validation\validators\comparison\LessThanOrEqualValidator;
26		use Ubiquity\contents\validation\validators\dates\DateValidator;
27		use Ubiquity\contents\validation\validators\dates\DateTimeValidator;
28		use Ubiquity\contents\validation\validators\dates\TimeValidator;
29		use Ubiquity\contents\validation\validators\basic\IsBooleanValidator;
30		use Ubiquity\cache\objects\SessionCache;
31
32		/**
33		* Validators manager
34		* @author jcheron <[email protected]>
35		* @version 1.0.0
36		*/
37		class ValidatorsManager {
38		protected static $instanceValidators=[];
39		protected static $cache;
40
41		public static function start(){
42		self::$cache=new SessionCache();
43		}
44
45		public static $validatorTypes=[
46		"notNull"=>NotNullValidator::class,
47		"isNull"=>IsNullValidator::class,
48		"notEmpty"=>NotEmptyValidator::class,
49		"isEmpty"=>IsEmptyValidator::class,
50		"isTrue"=>IsTrueValidator::class,
51		"isFalse"=>IsFalseValidator::class,
52		"isBool"=>IsBooleanValidator::class,
53		"equals"=>EqualsValidator::class,
54		"type"=>TypeValidator::class,
55		"greaterThan"=>GreaterThanValidator::class,
56		"greaterThanOrEqual"=>GreaterThanOrEqualValidator::class,
57		"lessThan"=>LessThanValidator::class,
58		"lessThanOrEqual"=>LessThanOrEqualValidator::class,
59		"length"=>LengthValidator::class,
60		"id"=>IdValidator::class,
61		"regex"=>RegexValidator::class,
62		"email"=>EmailValidator::class,
63		"url"=>UrlValidator::class,
64		"ip"=>IpValidator::class,
65		"range"=>RangeValidator::class,
66		"date"=>DateValidator::class,
67		"dateTime"=>DateTimeValidator::class,
68		"time"=>TimeValidator::class
69
70		];
71
72		protected static $key="contents/validators/";
73
74		/**
75		* Registers a validator type for using with @validator annotation
76		* @param string $type
77		* @param string $validatorClass
78		*/
79		public static function registerType($type,$validatorClass){
80		self::$validatorTypes[$type]=$validatorClass;
81		}
82
83		/**
84		* Parses models and save validators in cache
85		* to use in dev only
86		* @param array $config
87		*/
88		public static function initModelsValidators(&$config){
89		$models=CacheManager::getModels($config,true);
90		foreach ($models as $model){
91		$parser=new ValidationModelParser();
92		$parser->parse($model);
93		$validators=$parser->getValidators();
94		if(sizeof($validators)>0){
95		self::store($model, $parser->__toString());
96		}
97		}
98		}
99
100		protected static function store($model,$validators){
101		CacheManager::$cache->store(self::getModelCacheKey($model), $validators);
102		}
103
104		protected static function fetch($model){
105		$key=self::getModelCacheKey($model);
106		if(CacheManager::$cache->exists($key)){
107		return CacheManager::$cache->fetch($key);
108		}
109		return [];
110		}
111
112		protected static function getGroupArrayValidators(array $validators,$group){
113		$result=[];
114		foreach ($validators as $member=>$validators){
115		$filteredValidators=self::getGroupMemberValidators($validators, $group);
116		if(sizeof($filteredValidators)){
117		$result[$member]=$filteredValidators;
118		}
119		}
120		return $result;
121		}
122
123		protected static function getGroupMemberValidators(array $validators,$group){
124		$result=[];
125		foreach ($validators as $validator){
126		if(isset($validator["group"]) && $validator["group"]===$group){
127		$result[]=$validator;
128		}
129		}
130		return $result;
131		}
132
133		private static function getCacheValidators($instance,$group=""){
134		if(isset(self::$cache)){
135		$key=self::getHash(get_class($instance).$group);
136		if(self::$cache->exists($key)){
137		return self::$cache->fetch($key);
138		}
139		}
140		return false;
141		}
142
143		/**
144		* Validates an instance
145		* @param object $instance
146		* @param string $group
147		* @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
148		*/
149		public static function validate($instance,$group=""){
150		$cache=self::getCacheValidators($instance,$group);
151		if($cache!==false){
152		return self::validateFromCache_($instance,$cache);
153		}
154		$members=self::fetch(get_class($instance));
155		if($group!==""){
156		$members=self::getGroupArrayValidators($members, $group);
157		}
158		return self::validate_($instance,$members);
159		}
160
161		/**
162		* Validates an array of objects
163		* @param array $instances
164		* @param string $group
165		* @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
166		*/
167		public static function validateInstances($instances,$group=""){
168		if(sizeof($instances)>0){
169		$instance=reset($instances);
170		$cache=self::getCacheValidators($instance,$group);
171		if($cache===false){
172		$class=get_class($instance);
173		$members=self::fetch($class);
174		self::initInstancesValidators($instance, $members,$group);
175		$cache=self::$instanceValidators[$class];
176		}
177		return self::validateInstances_($instances,$cache);
178		}
179		return [];
180		}
181
182		public static function clearCache($model=null,$group=""){
183		if(isset(self::$cache)){
184		if(isset($model)){
185		$key=self::getHash($model.$group);
186		self::$cache->remove($key);
187		}else{
188		self::$cache->clear();
189		}
190		}
191		}
192
193	View Code Duplication	protected static function validateInstances_($instances,$members){
		0 ignored issues – show Duplication introduced 2019-01-08 02:59 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...
194		$result=[];
195		foreach ($instances as $instance){
196		foreach ($members as $accessor=>$validators){
197		foreach ($validators as $validator){
198		$valid=$validator->validate_($instance->$accessor());
199		if($valid!==true){
200		$result[]=$valid;
201		}
202		}
203		}
204		}
205		return $result;
206		}
207
208		protected static function validate_($instance,$members){
209		$result=[];
210		foreach ($members as $member=>$validators){
211		$accessor="get".ucfirst($member);
212		if(method_exists($instance, $accessor)){
213		foreach ($validators as $validator){
214		$validatorInstance=self::getValidatorInstance($validator["type"]);
215		if($validatorInstance!==false){
216		$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
217		$valid=$validatorInstance->validate_($instance->$accessor());
218		if($valid!==true){
219		$result[]=$valid;
220		}
221		}
222		}
223		}
224		}
225		return $result;
226		}
227
228	View Code Duplication	protected static function validateFromCache_($instance,$members){
		0 ignored issues – show Duplication introduced 2019-01-08 02:59 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...
229		$result=[];
230		foreach ($members as $accessor=>$validators){
231		foreach ($validators as $validatorInstance){
232		$valid=$validatorInstance->validate_($instance->$accessor());
233		if($valid!==true){
234		$result[]=$valid;
235		}
236		}
237		}
238		return $result;
239		}
240
241		/**
242		* Initializes the cache (SessionCache) for the class of înstance
243		* @param object $instance
244		* @param string $group
245		*/
246		public static function initCacheInstanceValidators($instance,$group=""){
247		$class=get_class($instance);
248		$members=self::fetch($class);
249		self::initInstancesValidators($instance, $members,$group);
250		}
251
252		protected static function initInstancesValidators($instance,$members,$group=""){
253		$class=get_class($instance);
254		$result=[];
255		foreach ($members as $member=>$validators){
256		$accessor="get".ucfirst($member);
257		if(method_exists($instance, $accessor)){
258		foreach ($validators as $validator){
259		$validatorInstance=self::getValidatorInstance($validator["type"]);
260		if($validatorInstance!==false){
261		$validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]);
262		if($group==="" \|\| (isset($validator["group"]) && $validator["group"]===$group)){
263		self::$instanceValidators[$class][$accessor][]=$validatorInstance;
264		$result[$accessor][]=$validatorInstance;
265		}
266		}
267		}
268		}
269		}
270		self::$cache->store(self::getHash($class.$group), $result);
271		}
272
273		protected static function getHash($class){
274		return hash("sha1", $class);
275		}
276
277		protected static function getModelCacheKey($classname){
278		return self::$key.\str_replace("\\", DIRECTORY_SEPARATOR, $classname);
279		}
280
281		protected static function getValidatorInstance($type){
282		if(isset(self::$validatorTypes[$type])){
283		$class=self::$validatorTypes[$type];
284		return new $class();
285		}else{
286		Logger::warn("validation", "Validator ".$type." does not exists!");
287		return false;
288		}
289		}
290		}
291
292

phpMv / ubiquity