ValidatorsManager::store() - Code Metrics - Inspection of "Update AuthControllerCreator.php" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3dcefc...33965f )

by Jean-Christophe

created 2019-02-19 14:13 UTC

ValidatorsManager::store() A

↳ Parent: ValidatorsManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?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.1
 *
 */
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 [ ];
	}

	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 = current ( $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 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.1
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	6	protected static function fetch($model) {
81	6	$key = self::getModelCacheKey ( $model );
82	6	if (CacheManager::$cache->exists ( $key )) {
83	6	return CacheManager::$cache->fetch ( $key );
84		}
85		return [ ];
86		}
87
88		protected static function getGroupArrayValidators(array $validators, $group) {
89		$result = [ ];
90		foreach ( $validators as $member => $validators ) {
91		$filteredValidators = self::getGroupMemberValidators ( $validators, $group );
92		if (sizeof ( $filteredValidators )) {
93		$result [$member] = $filteredValidators;
94		}
95		}
96		return $result;
97		}
98
99		protected static function getGroupMemberValidators(array $validators, $group) {
100		$result = [ ];
101		foreach ( $validators as $validator ) {
102		if (isset ( $validator ["group"] ) && $validator ["group"] === $group) {
103		$result [] = $validator;
104		}
105		}
106		return $result;
107		}
108
109	6	private static function getCacheValidators($instance, $group = "") {
110	6	if (isset ( self::$cache )) {
111	6	$key = self::getHash ( get_class ( $instance ) . $group );
112	6	if (self::$cache->exists ( $key )) {
113		return self::$cache->fetch ( $key );
114		}
115		}
116	6	return false;
117		}
118
119		/**
120		* Validates an instance
121		*
122		* @param object $instance
123		* @param string $group
124		* @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
125		*/
126	4	public static function validate($instance, $group = "") {
127	4	$cache = self::getCacheValidators ( $instance, $group );
128	4	if ($cache !== false) {
129		return self::validateFromCache_ ( $instance, $cache );
130		}
131	4	$members = self::fetch ( get_class ( $instance ) );
132	4	if ($group !== "") {
133		$members = self::getGroupArrayValidators ( $members, $group );
134		}
135	4	return self::validate_ ( $instance, $members );
136		}
137
138		/**
139		* Validates an array of objects
140		*
141		* @param array $instances
142		* @param string $group
143		* @return \Ubiquity\contents\validation\validators\ConstraintViolation[]
144		*/
145	2	public static function validateInstances($instances, $group = "") {
146	2	if (sizeof ( $instances ) > 0) {
147	2	$instance = current ( $instances );
148	2	$cache = self::getCacheValidators ( $instance, $group );
149	2	if ($cache === false) {
150	2	$class = get_class ( $instance );
151	2	$members = self::fetch ( $class );
152	2	self::initInstancesValidators ( $instance, $members, $group );
153	2	$cache = self::$instanceValidators [$class];
154		}
155	2	return self::validateInstances_ ( $instances, $cache );
156		}
157		return [ ];
158		}
159
160		public static function clearCache($model = null, $group = "") {
161		if (isset ( self::$cache )) {
162		if (isset ( $model )) {
163		$key = self::getHash ( $model . $group );
164		self::$cache->remove ( $key );
165		} else {
166		self::$cache->clear ();
167		}
168		}
169		}
170
171	2	protected static function validateInstances_($instances, $members) {
172	2	$result = [ ];
173	2	foreach ( $instances as $instance ) {
174	2	foreach ( $members as $accessor => $validators ) {
175	2	foreach ( $validators as $validator ) {
176	2	$valid = $validator->validate_ ( $instance->$accessor () );
177	2	if ($valid !== true) {
178	2	$result [] = $valid;
179		}
180		}
181		}
182		}
183	2	return $result;
184		}
185
186	4	protected static function validate_($instance, $members) {
187	4	$result = [ ];
188	4	foreach ( $members as $member => $validators ) {
189	4	$accessor = "get" . ucfirst ( $member );
190	4	if (method_exists ( $instance, $accessor )) {
191	4	foreach ( $validators as $validator ) {
192	4	$validatorInstance = self::getValidatorInstance ( $validator ["type"] );
193	4	if ($validatorInstance !== false) {
194	4	$validatorInstance->setValidationParameters ( $member, $validator ["constraints"], @$validator ["severity"], @$validator ["message"] );
195	4	$valid = $validatorInstance->validate_ ( $instance->$accessor () );
196	4	if ($valid !== true) {
197	4	$result [] = $valid;
198		}
199		}
200		}
201		}
202		}
203	4	return $result;
204		}
205
206		protected static function validateFromCache_($instance, $members) {
207		$result = [ ];
208		foreach ( $members as $accessor => $validators ) {
209		foreach ( $validators as $validatorInstance ) {
210		$valid = $validatorInstance->validate_ ( $instance->$accessor () );
211		if ($valid !== true) {
212		$result [] = $valid;
213		}
214		}
215		}
216		return $result;
217		}
218
219		/**
220		* Initializes the cache (SessionCache) for the class of instance
221		*
222		* @param object $instance
223		* @param string $group
224		*/
225		public static function initCacheInstanceValidators($instance, $group = "") {
226		$class = get_class ( $instance );
227		$members = self::fetch ( $class );
228		self::initInstancesValidators ( $instance, $members, $group );
229		}
230
231	2	protected static function initInstancesValidators($instance, $members, $group = "") {
232	2	$class = get_class ( $instance );
233	2	$result = [ ];
234	2	foreach ( $members as $member => $validators ) {
235	2	$accessor = "get" . ucfirst ( $member );
236	2	if (method_exists ( $instance, $accessor )) {
237	2	foreach ( $validators as $validator ) {
238	2	$validatorInstance = self::getValidatorInstance ( $validator ["type"] );
239	2	if ($validatorInstance !== false) {
240	2	$validatorInstance->setValidationParameters ( $member, $validator ["constraints"], @$validator ["severity"], @$validator ["message"] );
241	2	if ($group === "" \|\| (isset ( $validator ["group"] ) && $validator ["group"] === $group)) {
242	2	self::$instanceValidators [$class] [$accessor] [] = $validatorInstance;
243	2	$result [$accessor] [] = $validatorInstance;
244		}
245		}
246		}
247		}
248		}
249	2	self::$cache->store ( self::getHash ( $class . $group ), $result );
250	2	}
251
252	6	protected static function getHash($class) {
253	6	return hash ( "sha1", $class );
254		}
255
256	6	protected static function getModelCacheKey($classname) {
257	6	return self::$key . \str_replace ( "\\", \DS, $classname );
258		}
259
260	6	protected static function getValidatorInstance($type) {
261	6	if (isset ( self::$validatorTypes [$type] )) {
262	6	$class = self::$validatorTypes [$type];
263	6	return new $class ();
264		} else {
265		Logger::warn ( "validation", "Validator " . $type . " does not exists!" );
266		return false;
267		}
268		}
269		}
270
271

phpMv / ubiquity

Push — master ( 3dcefc...33965f )

ValidatorsManager::store() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like