webonyx /
graphql-php
| Conditions | 31 |
| Paths | 69 |
| Total Lines | 183 |
| Code Lines | 119 |
| Lines | 0 |
| Ratio | 0 % |
| Tests | 107 |
| CRAP Score | 31.6006 |
| 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 |
||
| 37 | 71 | public static function coerceValue($value, InputType $type, $blameNode = null, ?array $path = null) |
|
| 38 | { |
||
| 39 | 71 | if ($type instanceof NonNull) { |
|
| 40 | 32 | if ($value === null) { |
|
| 41 | 6 | return self::ofErrors([ |
|
| 42 | 6 | self::coercionError( |
|
| 43 | 6 | sprintf('Expected non-nullable type %s not to be null', $type), |
|
| 44 | 6 | $blameNode, |
|
| 45 | 6 | $path |
|
| 46 | ), |
||
| 47 | ]); |
||
| 48 | } |
||
| 49 | |||
| 50 | 29 | return self::coerceValue($value, $type->getWrappedType(), $blameNode, $path); |
|
|
Bug
introduced
by
|
|||
| 51 | } |
||
| 52 | |||
| 53 | 68 | if ($value === null) { |
|
| 54 | // Explicitly return the value null. |
||
| 55 | 4 | return self::ofValue(null); |
|
| 56 | } |
||
| 57 | |||
| 58 | 66 | if ($type instanceof ScalarType) { |
|
| 59 | // Scalars determine if a value is valid via parseValue(), which can |
||
| 60 | // throw to indicate failure. If it throws, maintain a reference to |
||
| 61 | // the original error. |
||
| 62 | try { |
||
| 63 | 58 | return self::ofValue($type->parseValue($value)); |
|
| 64 | 19 | } catch (\Exception $error) { |
|
| 65 | 19 | return self::ofErrors([ |
|
| 66 | 19 | self::coercionError( |
|
| 67 | 19 | sprintf('Expected type %s', $type->name), |
|
| 68 | 19 | $blameNode, |
|
| 69 | 19 | $path, |
|
| 70 | 19 | $error->getMessage(), |
|
| 71 | 19 | $error |
|
| 72 | ), |
||
| 73 | ]); |
||
| 74 | } catch (\Throwable $error) { |
||
| 75 | return self::ofErrors([ |
||
| 76 | self::coercionError( |
||
| 77 | sprintf('Expected type %s', $type->name), |
||
| 78 | $blameNode, |
||
| 79 | $path, |
||
| 80 | $error->getMessage(), |
||
| 81 | $error |
||
| 82 | ), |
||
| 83 | ]); |
||
| 84 | } |
||
| 85 | } |
||
| 86 | |||
| 87 | 23 | if ($type instanceof EnumType) { |
|
| 88 | 7 | if (is_string($value)) { |
|
| 89 | 5 | $enumValue = $type->getValue($value); |
|
| 90 | 5 | if ($enumValue) { |
|
| 91 | 4 | return self::ofValue($enumValue->value); |
|
| 92 | } |
||
| 93 | } |
||
| 94 | |||
| 95 | 3 | $suggestions = Utils::suggestionList( |
|
| 96 | 3 | Utils::printSafe($value), |
|
| 97 | 3 | array_map( |
|
| 98 | function ($enumValue) { |
||
| 99 | 3 | return $enumValue->name; |
|
| 100 | 3 | }, |
|
| 101 | 3 | $type->getValues() |
|
| 102 | ) |
||
| 103 | ); |
||
| 104 | |||
| 105 | 3 | $didYouMean = $suggestions |
|
| 106 | 1 | ? 'did you mean ' . Utils::orList($suggestions) . '?' |
|
| 107 | 3 | : null; |
|
| 108 | |||
| 109 | 3 | return self::ofErrors([ |
|
| 110 | 3 | self::coercionError( |
|
| 111 | 3 | sprintf('Expected type %s', $type->name), |
|
| 112 | 3 | $blameNode, |
|
| 113 | 3 | $path, |
|
| 114 | 3 | $didYouMean |
|
| 115 | ), |
||
| 116 | ]); |
||
| 117 | } |
||
| 118 | |||
| 119 | 16 | if ($type instanceof ListOfType) { |
|
| 120 | 9 | $itemType = $type->getWrappedType(); |
|
| 121 | 9 | if (is_array($value) || $value instanceof \Traversable) { |
|
| 122 | 9 | $errors = []; |
|
| 123 | 9 | $coercedValue = []; |
|
| 124 | 9 | foreach ($value as $index => $itemValue) { |
|
| 125 | 9 | $coercedItem = self::coerceValue( |
|
| 126 | 9 | $itemValue, |
|
| 127 | 9 | $itemType, |
|
| 128 | 9 | $blameNode, |
|
| 129 | 9 | self::atPath($path, $index) |
|
| 130 | ); |
||
| 131 | 9 | if ($coercedItem['errors']) { |
|
| 132 | 2 | $errors = self::add($errors, $coercedItem['errors']); |
|
| 133 | } else { |
||
| 134 | 9 | $coercedValue[] = $coercedItem['value']; |
|
| 135 | } |
||
| 136 | } |
||
| 137 | |||
| 138 | 9 | return $errors ? self::ofErrors($errors) : self::ofValue($coercedValue); |
|
| 139 | } |
||
| 140 | // Lists accept a non-list value as a list of one. |
||
| 141 | 1 | $coercedItem = self::coerceValue($value, $itemType, $blameNode); |
|
| 142 | |||
| 143 | 1 | return $coercedItem['errors'] ? $coercedItem : self::ofValue([$coercedItem['value']]); |
|
| 144 | } |
||
| 145 | |||
| 146 | 8 | if ($type instanceof InputObjectType) { |
|
| 147 | 8 | if (! is_object($value) && ! is_array($value) && ! $value instanceof \Traversable) { |
|
| 148 | 2 | return self::ofErrors([ |
|
| 149 | 2 | self::coercionError( |
|
| 150 | 2 | sprintf('Expected type %s to be an object', $type->name), |
|
| 151 | 2 | $blameNode, |
|
| 152 | 2 | $path |
|
| 153 | ), |
||
| 154 | ]); |
||
| 155 | } |
||
| 156 | |||
| 157 | 7 | $errors = []; |
|
| 158 | 7 | $coercedValue = []; |
|
| 159 | 7 | $fields = $type->getFields(); |
|
| 160 | 7 | foreach ($fields as $fieldName => $field) { |
|
| 161 | 7 | if (array_key_exists($fieldName, $value)) { |
|
| 162 | 7 | $fieldValue = $value[$fieldName]; |
|
| 163 | 7 | $coercedField = self::coerceValue( |
|
| 164 | 7 | $fieldValue, |
|
| 165 | 7 | $field->getType(), |
|
| 166 | 7 | $blameNode, |
|
| 167 | 7 | self::atPath($path, $fieldName) |
|
| 168 | ); |
||
| 169 | 7 | if ($coercedField['errors']) { |
|
| 170 | 3 | $errors = self::add($errors, $coercedField['errors']); |
|
| 171 | } else { |
||
| 172 | 7 | $coercedValue[$fieldName] = $coercedField['value']; |
|
| 173 | } |
||
| 174 | 6 | } elseif ($field->defaultValueExists()) { |
|
| 175 | $coercedValue[$fieldName] = $field->defaultValue; |
||
| 176 | 6 | } elseif ($field->getType() instanceof NonNull) { |
|
| 177 | 2 | $fieldPath = self::printPath(self::atPath($path, $fieldName)); |
|
| 178 | 2 | $errors = self::add( |
|
| 179 | 2 | $errors, |
|
| 180 | 2 | self::coercionError( |
|
| 181 | 2 | sprintf( |
|
| 182 | 2 | 'Field %s of required type %s was not provided', |
|
| 183 | 2 | $fieldPath, |
|
| 184 | 2 | $field->type->toString() |
|
| 185 | ), |
||
| 186 | 7 | $blameNode |
|
| 187 | ) |
||
| 188 | ); |
||
| 189 | } |
||
| 190 | } |
||
| 191 | |||
| 192 | // Ensure every provided field is defined. |
||
| 193 | 7 | foreach ($value as $fieldName => $field) { |
|
| 194 | 7 | if (array_key_exists($fieldName, $fields)) { |
|
| 195 | 7 | continue; |
|
| 196 | } |
||
| 197 | |||
| 198 | 3 | $suggestions = Utils::suggestionList( |
|
| 199 | 3 | $fieldName, |
|
| 200 | 3 | array_keys($fields) |
|
| 201 | ); |
||
| 202 | 3 | $didYouMean = $suggestions |
|
| 203 | 1 | ? 'did you mean ' . Utils::orList($suggestions) . '?' |
|
| 204 | 3 | : null; |
|
| 205 | 3 | $errors = self::add( |
|
| 206 | 3 | $errors, |
|
| 207 | 3 | self::coercionError( |
|
| 208 | 3 | sprintf('Field "%s" is not defined by type %s', $fieldName, $type->name), |
|
| 209 | 3 | $blameNode, |
|
| 210 | 3 | $path, |
|
| 211 | 3 | $didYouMean |
|
| 212 | ) |
||
| 213 | ); |
||
| 214 | } |
||
| 215 | |||
| 216 | 7 | return $errors ? self::ofErrors($errors) : self::ofValue($coercedValue); |
|
| 217 | } |
||
| 218 | |||
| 219 | throw new Error(sprintf('Unexpected type %s', $type->name)); |
||
| 220 | } |
||
| 307 |
Loading history...
