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

Completed

Push — master ( 94ddbb...e5219e )

by Jean-Christophe

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

phpMv / ubiquity

Push — master ( 94ddbb...e5219e )

ValidatorsManager::store() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like