ValidatorsManager::initCacheInstanceValidators() - Code Metrics - Inspection of "Add validation in webtools" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 74c5b9...c6a028 )

by Jean-Christophe

created 2019-02-21 03:50 UTC

ValidatorsManager::initCacheInstanceValidators() A

↳ Parent: ValidatorsManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

namespace Ubiquity\contents\validation;

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

/**
 * Validators manager
 *
 * Ubiquity\contents\validation$ValidatorsManager
 * This class is part of Ubiquity
 *
 * @author jcheron <[email protected]>
 * @version 1.0.2
 *
 */
class ValidatorsManager {
	use ValidatorsManagerInitTrait;
	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/";

	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 [ ];
	}

	public static function getCacheInfo($model) {
		return self::fetch ( $model );
	}

	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 = "") {
		return self::getClassCacheValidators ( get_class ( $instance ), $group );
	}

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

phpMv / ubiquity

Push — master ( 74c5b9...c6a028 )

ValidatorsManager::initCacheInstanceValidators() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like