guzzle /
guzzle-services
| Conditions | 60 |
| Paths | > 20000 |
| Total Lines | 189 |
| Lines | 17 |
| Ratio | 8.99 % |
| Tests | 124 |
| CRAP Score | 60 |
| Changes | 0 | ||
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
| 1 | <?php |
||
| 108 | 15 | protected function recursiveProcess( |
|
| 109 | Parameter $param, |
||
| 110 | &$value, |
||
| 111 | $path = '', |
||
| 112 | $depth = 0 |
||
| 113 | ) { |
||
| 114 | // Update the value by adding default or static values |
||
| 115 | 15 | $value = $param->getValue($value); |
|
| 116 | |||
| 117 | 15 | $required = $param->isRequired(); |
|
| 118 | // if the value is null and the parameter is not required or is static, |
||
| 119 | // then skip any further recursion |
||
| 120 | 15 | if ((null === $value && !$required) || $param->isStatic()) { |
|
| 121 | 6 | return true; |
|
| 122 | } |
||
| 123 | |||
| 124 | 15 | $type = $param->getType(); |
|
| 125 | // Attempt to limit the number of times is_array is called by tracking |
||
| 126 | // if the value is an array |
||
| 127 | 15 | $valueIsArray = is_array($value); |
|
| 128 | // If a name is set then update the path so that validation messages |
||
| 129 | // are more helpful |
||
| 130 | 15 | if ($name = $param->getName()) { |
|
|
Bug
introduced
by
|
|||
| 131 | 15 | $path .= "[{$name}]"; |
|
| 132 | 15 | } |
|
| 133 | |||
| 134 | 15 | if ($type == 'object') { |
|
| 135 | // Determine whether or not this "value" has properties and should |
||
| 136 | // be traversed |
||
| 137 | 12 | $traverse = $temporaryValue = false; |
|
| 138 | |||
| 139 | // Convert the value to an array |
||
| 140 | 12 | if (!$valueIsArray && $value instanceof ToArrayInterface) { |
|
| 141 | 1 | $value = $value->toArray(); |
|
| 142 | 1 | } |
|
| 143 | |||
| 144 | 12 | if ($valueIsArray) { |
|
| 145 | // Ensure that the array is associative and not numerically |
||
| 146 | // indexed |
||
| 147 | 10 | if (isset($value[0])) { |
|
| 148 | 1 | $this->errors[] = "{$path} must be an array of properties. Got a numerically indexed array."; |
|
| 149 | 1 | return false; |
|
| 150 | } |
||
| 151 | 9 | $traverse = true; |
|
| 152 | 11 | } elseif ($value === null) { |
|
| 153 | // Attempt to let the contents be built up by default values if |
||
| 154 | // possible |
||
| 155 | 2 | $value = []; |
|
| 156 | 2 | $temporaryValue = $valueIsArray = $traverse = true; |
|
| 157 | 2 | } |
|
| 158 | |||
| 159 | 11 | if ($traverse) { |
|
| 160 | 9 | if ($properties = $param->getProperties()) { |
|
| 161 | // if properties were found, validate each property |
||
| 162 | 8 | foreach ($properties as $property) { |
|
| 163 | 8 | $name = $property->getName(); |
|
| 164 | 8 | if (isset($value[$name])) { |
|
| 165 | 3 | $this->recursiveProcess($property, $value[$name], $path, $depth + 1); |
|
| 166 | 3 | } else { |
|
| 167 | 8 | $current = null; |
|
| 168 | 8 | $this->recursiveProcess($property, $current, $path, $depth + 1); |
|
| 169 | // Only set the value if it was populated |
||
| 170 | 8 | if (null !== $current) { |
|
| 171 | 3 | $value[$name] = $current; |
|
| 172 | 3 | } |
|
| 173 | } |
||
| 174 | 8 | } |
|
| 175 | 8 | } |
|
| 176 | |||
| 177 | 9 | $additional = $param->getAdditionalProperties(); |
|
| 178 | 9 | if ($additional !== true) { |
|
| 179 | // If additional properties were found, then validate each |
||
| 180 | // against the additionalProperties attr. |
||
| 181 | 3 | $keys = array_keys($value); |
|
| 182 | // Determine the keys that were specified that were not |
||
| 183 | // listed in the properties of the schema |
||
| 184 | 3 | $diff = array_diff($keys, array_keys($properties)); |
|
| 185 | 3 | if (!empty($diff)) { |
|
| 186 | // Determine which keys are not in the properties |
||
| 187 | 3 | if ($additional instanceof Parameter) { |
|
| 188 | 2 | foreach ($diff as $key) { |
|
| 189 | 2 | $this->recursiveProcess($additional, $value[$key], "{$path}[{$key}]", $depth); |
|
| 190 | 2 | } |
|
| 191 | 2 | } else { |
|
| 192 | // if additionalProperties is set to false and there |
||
| 193 | // are additionalProperties in the values, then fail |
||
| 194 | 1 | foreach ($diff as $prop) { |
|
| 195 | 1 | $this->errors[] = sprintf('%s[%s] is not an allowed property', $path, $prop); |
|
| 196 | 1 | } |
|
| 197 | } |
||
| 198 | 3 | } |
|
| 199 | 3 | } |
|
| 200 | |||
| 201 | // A temporary value will be used to traverse elements that |
||
| 202 | // have no corresponding input value. This allows nested |
||
| 203 | // required parameters with default values to bubble up into the |
||
| 204 | // input. Here we check if we used a temp value and nothing |
||
| 205 | // bubbled up, then we need to remote the value. |
||
| 206 | 9 | if ($temporaryValue && empty($value)) { |
|
| 207 | 1 | $value = null; |
|
| 208 | 1 | $valueIsArray = false; |
|
| 209 | 1 | } |
|
| 210 | 9 | } |
|
| 211 | |||
| 212 | 15 | } elseif ($type == 'array' && $valueIsArray && $param->getItems()) { |
|
| 213 | 6 | foreach ($value as $i => &$item) { |
|
| 214 | // Validate each item in an array against the items attribute of the schema |
||
| 215 | 6 | $this->recursiveProcess($param->getItems(), $item, $path . "[{$i}]", $depth + 1); |
|
| 216 | 6 | } |
|
| 217 | 6 | } |
|
| 218 | |||
| 219 | // If the value is required and the type is not null, then there is an |
||
| 220 | // error if the value is not set |
||
| 221 | 15 | if ($required && $value === null && $type != 'null') { |
|
| 222 | 3 | $message = "{$path} is " . ($param->getType() |
|
| 223 | 3 | ? ('a required ' . implode(' or ', (array) $param->getType())) |
|
| 224 | 3 | : 'required'); |
|
| 225 | 3 | if ($param->has('description')) { |
|
| 226 | 1 | $message .= ': ' . $param->getDescription(); |
|
| 227 | 1 | } |
|
| 228 | 3 | $this->errors[] = $message; |
|
| 229 | 3 | return false; |
|
| 230 | } |
||
| 231 | |||
| 232 | // Validate that the type is correct. If the type is string but an |
||
| 233 | // integer was passed, the class can be instructed to cast the integer |
||
| 234 | // to a string to pass validation. This is the default behavior. |
||
| 235 | 14 | if ($type && (!$type = $this->determineType($type, $value))) { |
|
| 236 | 5 | if ($this->castIntegerToStringType |
|
| 237 | 5 | && $param->getType() == 'string' |
|
| 238 | 5 | && is_integer($value) |
|
| 239 | 5 | ) { |
|
| 240 | 1 | $value = (string) $value; |
|
| 241 | 1 | } else { |
|
| 242 | 4 | $this->errors[] = "{$path} must be of type " . implode(' or ', (array) $param->getType()); |
|
| 243 | } |
||
| 244 | 5 | } |
|
| 245 | |||
| 246 | // Perform type specific validation for strings, arrays, and integers |
||
| 247 | 14 | if ($type == 'string') { |
|
| 248 | // Strings can have enums which are a list of predefined values |
||
| 249 | 4 | if (($enum = $param->getEnum()) && !in_array($value, $enum)) { |
|
| 250 | 1 | $this->errors[] = "{$path} must be one of " . implode(' or ', array_map(function ($s) { |
|
| 251 | 1 | return '"' . addslashes($s) . '"'; |
|
| 252 | 1 | }, $enum)); |
|
| 253 | 1 | } |
|
| 254 | // Strings can have a regex pattern that the value must match |
||
| 255 | 4 | if (($pattern = $param->getPattern()) && !preg_match($pattern, $value)) { |
|
| 256 | 1 | $this->errors[] = "{$path} must match the following regular expression: {$pattern}"; |
|
| 257 | 1 | } |
|
| 258 | |||
| 259 | 4 | $strLen = null; |
|
| 260 | 4 | View Code Duplication | if ($min = $param->getMinLength()) { |
| 261 | 1 | $strLen = strlen($value); |
|
| 262 | 1 | if ($strLen < $min) { |
|
| 263 | 1 | $this->errors[] = "{$path} length must be greater than or equal to {$min}"; |
|
| 264 | 1 | } |
|
| 265 | 1 | } |
|
| 266 | 4 | View Code Duplication | if ($max = $param->getMaxLength()) { |
| 267 | 1 | if (($strLen ?: strlen($value)) > $max) { |
|
| 268 | 1 | $this->errors[] = "{$path} length must be less than or equal to {$max}"; |
|
| 269 | 1 | } |
|
| 270 | 1 | } |
|
| 271 | |||
| 272 | 14 | } elseif ($type == 'array') { |
|
| 273 | 6 | $size = null; |
|
| 274 | 6 | View Code Duplication | if ($min = $param->getMinItems()) { |
| 275 | 1 | $size = count($value); |
|
| 276 | 1 | if ($size < $min) { |
|
| 277 | 1 | $this->errors[] = "{$path} must contain {$min} or more elements"; |
|
| 278 | 1 | } |
|
| 279 | 1 | } |
|
| 280 | 6 | if ($max = $param->getMaxItems()) { |
|
| 281 | 1 | if (($size ?: count($value)) > $max) { |
|
| 282 | 1 | $this->errors[] = "{$path} must contain {$max} or fewer elements"; |
|
| 283 | 1 | } |
|
| 284 | 1 | } |
|
| 285 | |||
| 286 | 14 | } elseif ($type == 'integer' || $type == 'number' || $type == 'numeric') { |
|
| 287 | 1 | if (($min = $param->getMinimum()) && $value < $min) { |
|
| 288 | 1 | $this->errors[] = "{$path} must be greater than or equal to {$min}"; |
|
| 289 | 1 | } |
|
| 290 | 1 | if (($max = $param->getMaximum()) && $value > $max) { |
|
| 291 | 1 | $this->errors[] = "{$path} must be less than or equal to {$max}"; |
|
| 292 | 1 | } |
|
| 293 | 1 | } |
|
| 294 | |||
| 295 | 14 | return empty($this->errors); |
|
| 296 | } |
||
| 297 | } |
||
| 298 |
Loading history...