phpMv /
ubiquity
| Total Complexity | 51 |
| Total Lines | 226 |
| Duplicated Lines | 0 % |
| Changes | 0 | ||
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.
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.
| 1 | <?php |
||
| 37 | class ValidatorsManager { |
||
| 38 | use ValidatorsManagerInitTrait; |
||
| 39 | protected static $instanceValidators=[]; |
||
| 40 | protected static $cache; |
||
| 41 | |||
| 42 | public static function start(){ |
||
| 43 | self::$cache=new SessionCache(); |
||
| 44 | } |
||
| 45 | |||
| 46 | public static $validatorTypes=[ |
||
| 47 | "notNull"=>NotNullValidator::class, |
||
| 48 | "isNull"=>IsNullValidator::class, |
||
| 49 | "notEmpty"=>NotEmptyValidator::class, |
||
| 50 | "isEmpty"=>IsEmptyValidator::class, |
||
| 51 | "isTrue"=>IsTrueValidator::class, |
||
| 52 | "isFalse"=>IsFalseValidator::class, |
||
| 53 | "isBool"=>IsBooleanValidator::class, |
||
| 54 | "equals"=>EqualsValidator::class, |
||
| 55 | "type"=>TypeValidator::class, |
||
| 56 | "greaterThan"=>GreaterThanValidator::class, |
||
| 57 | "greaterThanOrEqual"=>GreaterThanOrEqualValidator::class, |
||
| 58 | "lessThan"=>LessThanValidator::class, |
||
| 59 | "lessThanOrEqual"=>LessThanOrEqualValidator::class, |
||
| 60 | "length"=>LengthValidator::class, |
||
| 61 | "id"=>IdValidator::class, |
||
| 62 | "regex"=>RegexValidator::class, |
||
| 63 | "email"=>EmailValidator::class, |
||
| 64 | "url"=>UrlValidator::class, |
||
| 65 | "ip"=>IpValidator::class, |
||
| 66 | "range"=>RangeValidator::class, |
||
| 67 | "date"=>DateValidator::class, |
||
| 68 | "dateTime"=>DateTimeValidator::class, |
||
| 69 | "time"=>TimeValidator::class |
||
| 70 | |||
| 71 | ]; |
||
| 72 | |||
| 73 | protected static $key="contents/validators/"; |
||
| 74 | |||
| 75 | protected static function store($model,$validators){ |
||
| 77 | } |
||
| 78 | |||
| 79 | protected static function fetch($model){ |
||
| 85 | } |
||
| 86 | |||
| 87 | protected static function getGroupArrayValidators(array $validators,$group){ |
||
| 88 | $result=[]; |
||
| 89 | foreach ($validators as $member=>$validators){ |
||
| 90 | $filteredValidators=self::getGroupMemberValidators($validators, $group); |
||
| 91 | if(sizeof($filteredValidators)){ |
||
| 92 | $result[$member]=$filteredValidators; |
||
| 93 | } |
||
| 94 | } |
||
| 95 | return $result; |
||
| 96 | } |
||
| 97 | |||
| 98 | protected static function getGroupMemberValidators(array $validators,$group){ |
||
| 99 | $result=[]; |
||
| 100 | foreach ($validators as $validator){ |
||
| 101 | if(isset($validator["group"]) && $validator["group"]===$group){ |
||
| 102 | $result[]=$validator; |
||
| 103 | } |
||
| 104 | } |
||
| 105 | return $result; |
||
| 106 | } |
||
| 107 | |||
| 108 | private static function getCacheValidators($instance,$group=""){ |
||
| 109 | if(isset(self::$cache)){ |
||
| 110 | $key=self::getHash(get_class($instance).$group); |
||
| 111 | if(self::$cache->exists($key)){ |
||
| 112 | return self::$cache->fetch($key); |
||
| 113 | } |
||
| 114 | } |
||
| 115 | return false; |
||
| 116 | } |
||
| 117 | |||
| 118 | /** |
||
| 119 | * Validates an instance |
||
| 120 | * @param object $instance |
||
| 121 | * @param string $group |
||
| 122 | * @return \Ubiquity\contents\validation\validators\ConstraintViolation[] |
||
| 123 | */ |
||
| 124 | public static function validate($instance,$group=""){ |
||
| 125 | $cache=self::getCacheValidators($instance,$group); |
||
| 126 | if($cache!==false){ |
||
| 127 | return self::validateFromCache_($instance,$cache); |
||
| 128 | } |
||
| 129 | $members=self::fetch(get_class($instance)); |
||
| 130 | if($group!==""){ |
||
| 131 | $members=self::getGroupArrayValidators($members, $group); |
||
| 132 | } |
||
| 133 | return self::validate_($instance,$members); |
||
| 134 | } |
||
| 135 | |||
| 136 | /** |
||
| 137 | * Validates an array of objects |
||
| 138 | * @param array $instances |
||
| 139 | * @param string $group |
||
| 140 | * @return \Ubiquity\contents\validation\validators\ConstraintViolation[] |
||
| 141 | */ |
||
| 142 | public static function validateInstances($instances,$group=""){ |
||
| 143 | if(sizeof($instances)>0){ |
||
| 144 | $instance=reset($instances); |
||
| 145 | $cache=self::getCacheValidators($instance,$group); |
||
| 146 | if($cache===false){ |
||
| 147 | $class=get_class($instance); |
||
| 148 | $members=self::fetch($class); |
||
| 149 | self::initInstancesValidators($instance, $members,$group); |
||
| 150 | $cache=self::$instanceValidators[$class]; |
||
| 151 | } |
||
| 152 | return self::validateInstances_($instances,$cache); |
||
| 153 | } |
||
| 154 | return []; |
||
| 155 | } |
||
| 156 | |||
| 157 | public static function clearCache($model=null,$group=""){ |
||
| 158 | if(isset(self::$cache)){ |
||
| 159 | if(isset($model)){ |
||
| 160 | $key=self::getHash($model.$group); |
||
| 161 | self::$cache->remove($key); |
||
| 162 | }else{ |
||
| 163 | self::$cache->clear(); |
||
| 164 | } |
||
| 165 | } |
||
| 166 | } |
||
| 167 | |||
| 168 | protected static function validateInstances_($instances,$members){ |
||
| 169 | $result=[]; |
||
| 170 | foreach ($instances as $instance){ |
||
| 171 | foreach ($members as $accessor=>$validators){ |
||
| 172 | foreach ($validators as $validator){ |
||
| 173 | $valid=$validator->validate_($instance->$accessor()); |
||
| 174 | if($valid!==true){ |
||
| 175 | $result[]=$valid; |
||
| 176 | } |
||
| 177 | } |
||
| 178 | } |
||
| 179 | } |
||
| 180 | return $result; |
||
| 181 | } |
||
| 182 | |||
| 183 | protected static function validate_($instance,$members){ |
||
| 184 | $result=[]; |
||
| 185 | foreach ($members as $member=>$validators){ |
||
| 186 | $accessor="get".ucfirst($member); |
||
| 187 | if(method_exists($instance, $accessor)){ |
||
| 188 | foreach ($validators as $validator){ |
||
| 189 | $validatorInstance=self::getValidatorInstance($validator["type"]); |
||
| 190 | if($validatorInstance!==false){ |
||
| 191 | $validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]); |
||
| 192 | $valid=$validatorInstance->validate_($instance->$accessor()); |
||
| 193 | if($valid!==true){ |
||
| 194 | $result[]=$valid; |
||
| 195 | } |
||
| 196 | } |
||
| 197 | } |
||
| 198 | } |
||
| 199 | } |
||
| 200 | return $result; |
||
| 201 | } |
||
| 202 | |||
| 203 | protected static function validateFromCache_($instance,$members){ |
||
| 204 | $result=[]; |
||
| 205 | foreach ($members as $accessor=>$validators){ |
||
| 206 | foreach ($validators as $validatorInstance){ |
||
| 207 | $valid=$validatorInstance->validate_($instance->$accessor()); |
||
| 208 | if($valid!==true){ |
||
| 209 | $result[]=$valid; |
||
| 210 | } |
||
| 211 | } |
||
| 212 | } |
||
| 213 | return $result; |
||
| 214 | } |
||
| 215 | |||
| 216 | /** |
||
| 217 | * Initializes the cache (SessionCache) for the class of înstance |
||
| 218 | * @param object $instance |
||
| 219 | * @param string $group |
||
| 220 | */ |
||
| 221 | public static function initCacheInstanceValidators($instance,$group=""){ |
||
| 222 | $class=get_class($instance); |
||
| 223 | $members=self::fetch($class); |
||
| 224 | self::initInstancesValidators($instance, $members,$group); |
||
| 225 | } |
||
| 226 | |||
| 227 | protected static function initInstancesValidators($instance,$members,$group=""){ |
||
| 228 | $class=get_class($instance); |
||
| 229 | $result=[]; |
||
| 230 | foreach ($members as $member=>$validators){ |
||
| 231 | $accessor="get".ucfirst($member); |
||
| 232 | if(method_exists($instance, $accessor)){ |
||
| 233 | foreach ($validators as $validator){ |
||
| 234 | $validatorInstance=self::getValidatorInstance($validator["type"]); |
||
| 235 | if($validatorInstance!==false){ |
||
| 236 | $validatorInstance->setValidationParameters($member,$validator["constraints"],@$validator["severity"],@$validator["message"]); |
||
| 237 | if($group==="" || (isset($validator["group"]) && $validator["group"]===$group)){ |
||
| 238 | self::$instanceValidators[$class][$accessor][]=$validatorInstance; |
||
| 239 | $result[$accessor][]=$validatorInstance; |
||
| 240 | } |
||
| 241 | } |
||
| 242 | } |
||
| 243 | } |
||
| 244 | } |
||
| 245 | self::$cache->store(self::getHash($class.$group), $result); |
||
| 246 | } |
||
| 247 | |||
| 248 | protected static function getHash($class){ |
||
| 249 | return hash("sha1", $class); |
||
| 250 | } |
||
| 251 | |||
| 252 | protected static function getModelCacheKey($classname){ |
||
| 254 | } |
||
| 255 | |||
| 256 | protected static function getValidatorInstance($type){ |
||
| 263 | } |
||
| 264 | } |
||
| 265 | } |
||
| 266 | |||
| 267 |
