ylvarw /
module
| Conditions | 113 |
| Paths | > 20000 |
| Total Lines | 336 |
| Code Lines | 200 |
| Lines | 0 |
| Ratio | 0 % |
| 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 |
||
| 165 | private function doParse($value, $flags) |
||
| 166 | { |
||
| 167 | $this->currentLineNb = -1; |
||
| 168 | $this->currentLine = ''; |
||
| 169 | $value = $this->cleanup($value); |
||
| 170 | $this->lines = explode("\n", $value); |
||
| 171 | $this->locallySkippedLineNumbers = []; |
||
| 172 | |||
| 173 | if (null === $this->totalNumberOfLines) { |
||
| 174 | $this->totalNumberOfLines = \count($this->lines); |
||
| 175 | } |
||
| 176 | |||
| 177 | if (!$this->moveToNextLine()) { |
||
| 178 | return null; |
||
| 179 | } |
||
| 180 | |||
| 181 | $data = []; |
||
| 182 | $context = null; |
||
| 183 | $allowOverwrite = false; |
||
| 184 | |||
| 185 | while ($this->isCurrentLineEmpty()) { |
||
| 186 | if (!$this->moveToNextLine()) { |
||
| 187 | return null; |
||
| 188 | } |
||
| 189 | } |
||
| 190 | |||
| 191 | // Resolves the tag and returns if end of the document |
||
| 192 | if (null !== ($tag = $this->getLineTag($this->currentLine, $flags, false)) && !$this->moveToNextLine()) { |
||
| 193 | return new TaggedValue($tag, ''); |
||
| 194 | } |
||
| 195 | |||
| 196 | do { |
||
| 197 | if ($this->isCurrentLineEmpty()) { |
||
| 198 | continue; |
||
| 199 | } |
||
| 200 | |||
| 201 | // tab? |
||
| 202 | if ("\t" === $this->currentLine[0]) { |
||
| 203 | throw new ParseException('A YAML file cannot contain tabs as indentation.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename); |
||
| 204 | } |
||
| 205 | |||
| 206 | Inline::initialize($flags, $this->getRealCurrentLineNb(), $this->filename); |
||
| 207 | |||
| 208 | $isRef = $mergeNode = false; |
||
| 209 | if (self::preg_match('#^\-((?P<leadspaces>\s+)(?P<value>.+))?$#u', rtrim($this->currentLine), $values)) { |
||
| 210 | if ($context && 'mapping' == $context) { |
||
| 211 | throw new ParseException('You cannot define a sequence item when in a mapping.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename); |
||
| 212 | } |
||
| 213 | $context = 'sequence'; |
||
| 214 | |||
| 215 | if (isset($values['value']) && self::preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches)) { |
||
| 216 | $isRef = $matches['ref']; |
||
| 217 | $this->refsBeingParsed[] = $isRef; |
||
| 218 | $values['value'] = $matches['value']; |
||
| 219 | } |
||
| 220 | |||
| 221 | if (isset($values['value'][1]) && '?' === $values['value'][0] && ' ' === $values['value'][1]) { |
||
| 222 | @trigger_error($this->getDeprecationMessage('Starting an unquoted string with a question mark followed by a space is deprecated since Symfony 3.3 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.'), \E_USER_DEPRECATED); |
||
| 223 | } |
||
| 224 | |||
| 225 | // array |
||
| 226 | if (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#')) { |
||
| 227 | $data[] = $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(null, true), $flags); |
||
| 228 | } elseif (null !== $subTag = $this->getLineTag(ltrim($values['value'], ' '), $flags)) { |
||
| 229 | $data[] = new TaggedValue( |
||
| 230 | $subTag, |
||
| 231 | $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(null, true), $flags) |
||
| 232 | ); |
||
| 233 | } else { |
||
| 234 | if ( |
||
| 235 | isset($values['leadspaces']) |
||
| 236 | && ( |
||
| 237 | '!' === $values['value'][0] |
||
| 238 | || self::preg_match('#^(?P<key>'.Inline::REGEX_QUOTED_STRING.'|[^ \'"\{\[].*?) *\:(\s+(?P<value>.+?))?\s*$#u', $this->trimTag($values['value']), $matches) |
||
| 239 | ) |
||
| 240 | ) { |
||
| 241 | // this is a compact notation element, add to next block and parse |
||
| 242 | $block = $values['value']; |
||
| 243 | if ($this->isNextLineIndented()) { |
||
| 244 | $block .= "\n".$this->getNextEmbedBlock($this->getCurrentLineIndentation() + \strlen($values['leadspaces']) + 1); |
||
| 245 | } |
||
| 246 | |||
| 247 | $data[] = $this->parseBlock($this->getRealCurrentLineNb(), $block, $flags); |
||
| 248 | } else { |
||
| 249 | $data[] = $this->parseValue($values['value'], $flags, $context); |
||
| 250 | } |
||
| 251 | } |
||
| 252 | if ($isRef) { |
||
| 253 | $this->refs[$isRef] = end($data); |
||
| 254 | array_pop($this->refsBeingParsed); |
||
| 255 | } |
||
| 256 | } elseif ( |
||
| 257 | self::preg_match('#^(?P<key>(?:![^\s]++\s++)?(?:'.Inline::REGEX_QUOTED_STRING.'|(?:!?!php/const:)?[^ \'"\[\{!].*?)) *\:(\s++(?P<value>.+))?$#u', rtrim($this->currentLine), $values) |
||
| 258 | && (false === strpos($values['key'], ' #') || \in_array($values['key'][0], ['"', "'"])) |
||
| 259 | ) { |
||
| 260 | if ($context && 'sequence' == $context) { |
||
| 261 | throw new ParseException('You cannot define a mapping item when in a sequence.', $this->currentLineNb + 1, $this->currentLine, $this->filename); |
||
| 262 | } |
||
| 263 | $context = 'mapping'; |
||
| 264 | |||
| 265 | try { |
||
| 266 | $i = 0; |
||
| 267 | $evaluateKey = !(Yaml::PARSE_KEYS_AS_STRINGS & $flags); |
||
| 268 | |||
| 269 | // constants in key will be evaluated anyway |
||
| 270 | if (isset($values['key'][0]) && '!' === $values['key'][0] && Yaml::PARSE_CONSTANT & $flags) { |
||
| 271 | $evaluateKey = true; |
||
| 272 | } |
||
| 273 | |||
| 274 | $key = Inline::parseScalar($values['key'], 0, null, $i, $evaluateKey); |
||
| 275 | } catch (ParseException $e) { |
||
| 276 | $e->setParsedLine($this->getRealCurrentLineNb() + 1); |
||
| 277 | $e->setSnippet($this->currentLine); |
||
| 278 | |||
| 279 | throw $e; |
||
| 280 | } |
||
| 281 | |||
| 282 | if (!\is_string($key) && !\is_int($key)) { |
||
| 283 | $keyType = is_numeric($key) ? 'numeric key' : 'non-string key'; |
||
| 284 | @trigger_error($this->getDeprecationMessage(sprintf('Implicit casting of %s to string is deprecated since Symfony 3.3 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0. Quote your evaluable mapping keys instead.', $keyType)), \E_USER_DEPRECATED); |
||
| 285 | } |
||
| 286 | |||
| 287 | // Convert float keys to strings, to avoid being converted to integers by PHP |
||
| 288 | if (\is_float($key)) { |
||
| 289 | $key = (string) $key; |
||
| 290 | } |
||
| 291 | |||
| 292 | if ('<<' === $key && (!isset($values['value']) || !self::preg_match('#^&(?P<ref>[^ ]+)#u', $values['value'], $refMatches))) { |
||
| 293 | $mergeNode = true; |
||
| 294 | $allowOverwrite = true; |
||
| 295 | if (isset($values['value'][0]) && '*' === $values['value'][0]) { |
||
| 296 | $refName = substr(rtrim($values['value']), 1); |
||
| 297 | if (!\array_key_exists($refName, $this->refs)) { |
||
| 298 | if (false !== $pos = array_search($refName, $this->refsBeingParsed, true)) { |
||
| 299 | throw new ParseException(sprintf('Circular reference [%s, %s] detected for reference "%s".', implode(', ', \array_slice($this->refsBeingParsed, $pos)), $refName, $refName), $this->currentLineNb + 1, $this->currentLine, $this->filename); |
||
| 300 | } |
||
| 301 | |||
| 302 | throw new ParseException(sprintf('Reference "%s" does not exist.', $refName), $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename); |
||
| 303 | } |
||
| 304 | |||
| 305 | $refValue = $this->refs[$refName]; |
||
| 306 | |||
| 307 | if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $refValue instanceof \stdClass) { |
||
| 308 | $refValue = (array) $refValue; |
||
| 309 | } |
||
| 310 | |||
| 311 | if (!\is_array($refValue)) { |
||
| 312 | throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename); |
||
| 313 | } |
||
| 314 | |||
| 315 | $data += $refValue; // array union |
||
| 316 | } else { |
||
| 317 | if (isset($values['value']) && '' !== $values['value']) { |
||
| 318 | $value = $values['value']; |
||
| 319 | } else { |
||
| 320 | $value = $this->getNextEmbedBlock(); |
||
| 321 | } |
||
| 322 | $parsed = $this->parseBlock($this->getRealCurrentLineNb() + 1, $value, $flags); |
||
| 323 | |||
| 324 | if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $parsed instanceof \stdClass) { |
||
| 325 | $parsed = (array) $parsed; |
||
| 326 | } |
||
| 327 | |||
| 328 | if (!\is_array($parsed)) { |
||
| 329 | throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename); |
||
| 330 | } |
||
| 331 | |||
| 332 | if (isset($parsed[0])) { |
||
| 333 | // If the value associated with the merge key is a sequence, then this sequence is expected to contain mapping nodes |
||
| 334 | // and each of these nodes is merged in turn according to its order in the sequence. Keys in mapping nodes earlier |
||
| 335 | // in the sequence override keys specified in later mapping nodes. |
||
| 336 | foreach ($parsed as $parsedItem) { |
||
| 337 | if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $parsedItem instanceof \stdClass) { |
||
| 338 | $parsedItem = (array) $parsedItem; |
||
| 339 | } |
||
| 340 | |||
| 341 | if (!\is_array($parsedItem)) { |
||
| 342 | throw new ParseException('Merge items must be arrays.', $this->getRealCurrentLineNb() + 1, $parsedItem, $this->filename); |
||
| 343 | } |
||
| 344 | |||
| 345 | $data += $parsedItem; // array union |
||
| 346 | } |
||
| 347 | } else { |
||
| 348 | // If the value associated with the key is a single mapping node, each of its key/value pairs is inserted into the |
||
| 349 | // current mapping, unless the key already exists in it. |
||
| 350 | $data += $parsed; // array union |
||
| 351 | } |
||
| 352 | } |
||
| 353 | } elseif ('<<' !== $key && isset($values['value']) && self::preg_match('#^&(?P<ref>[^ ]++) *+(?P<value>.*)#u', $values['value'], $matches)) { |
||
| 354 | $isRef = $matches['ref']; |
||
| 355 | $this->refsBeingParsed[] = $isRef; |
||
| 356 | $values['value'] = $matches['value']; |
||
| 357 | } |
||
| 358 | |||
| 359 | $subTag = null; |
||
| 360 | if ($mergeNode) { |
||
| 361 | // Merge keys |
||
| 362 | } elseif (!isset($values['value']) || '' === $values['value'] || 0 === strpos($values['value'], '#') || (null !== $subTag = $this->getLineTag($values['value'], $flags)) || '<<' === $key) { |
||
| 363 | // hash |
||
| 364 | // if next line is less indented or equal, then it means that the current value is null |
||
| 365 | if (!$this->isNextLineIndented() && !$this->isNextLineUnIndentedCollection()) { |
||
| 366 | // Spec: Keys MUST be unique; first one wins. |
||
| 367 | // But overwriting is allowed when a merge node is used in current block. |
||
| 368 | if ($allowOverwrite || !isset($data[$key])) { |
||
| 369 | if (null !== $subTag) { |
||
| 370 | $data[$key] = new TaggedValue($subTag, ''); |
||
| 371 | } else { |
||
| 372 | $data[$key] = null; |
||
| 373 | } |
||
| 374 | } else { |
||
| 375 | @trigger_error($this->getDeprecationMessage(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since Symfony 3.2 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.', $key)), \E_USER_DEPRECATED); |
||
| 376 | } |
||
| 377 | } else { |
||
| 378 | $value = $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(), $flags); |
||
| 379 | if ('<<' === $key) { |
||
| 380 | $this->refs[$refMatches['ref']] = $value; |
||
| 381 | |||
| 382 | if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $value instanceof \stdClass) { |
||
| 383 | $value = (array) $value; |
||
| 384 | } |
||
| 385 | |||
| 386 | $data += $value; |
||
| 387 | } elseif ($allowOverwrite || !isset($data[$key])) { |
||
| 388 | // Spec: Keys MUST be unique; first one wins. |
||
| 389 | // But overwriting is allowed when a merge node is used in current block. |
||
| 390 | if (null !== $subTag) { |
||
| 391 | $data[$key] = new TaggedValue($subTag, $value); |
||
| 392 | } else { |
||
| 393 | $data[$key] = $value; |
||
| 394 | } |
||
| 395 | } else { |
||
| 396 | @trigger_error($this->getDeprecationMessage(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since Symfony 3.2 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.', $key)), \E_USER_DEPRECATED); |
||
| 397 | } |
||
| 398 | } |
||
| 399 | } else { |
||
| 400 | $value = $this->parseValue(rtrim($values['value']), $flags, $context); |
||
| 401 | // Spec: Keys MUST be unique; first one wins. |
||
| 402 | // But overwriting is allowed when a merge node is used in current block. |
||
| 403 | if ($allowOverwrite || !isset($data[$key])) { |
||
| 404 | $data[$key] = $value; |
||
| 405 | } else { |
||
| 406 | @trigger_error($this->getDeprecationMessage(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since Symfony 3.2 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.', $key)), \E_USER_DEPRECATED); |
||
| 407 | } |
||
| 408 | } |
||
| 409 | if ($isRef) { |
||
| 410 | $this->refs[$isRef] = $data[$key]; |
||
| 411 | array_pop($this->refsBeingParsed); |
||
| 412 | } |
||
| 413 | } else { |
||
| 414 | // multiple documents are not supported |
||
| 415 | if ('---' === $this->currentLine) { |
||
| 416 | throw new ParseException('Multiple documents are not supported.', $this->currentLineNb + 1, $this->currentLine, $this->filename); |
||
| 417 | } |
||
| 418 | |||
| 419 | if ($deprecatedUsage = (isset($this->currentLine[1]) && '?' === $this->currentLine[0] && ' ' === $this->currentLine[1])) { |
||
| 420 | @trigger_error($this->getDeprecationMessage('Starting an unquoted string with a question mark followed by a space is deprecated since Symfony 3.3 and will throw \Symfony\Component\Yaml\Exception\ParseException in 4.0.'), \E_USER_DEPRECATED); |
||
| 421 | } |
||
| 422 | |||
| 423 | // 1-liner optionally followed by newline(s) |
||
| 424 | if (\is_string($value) && $this->lines[0] === trim($value)) { |
||
| 425 | try { |
||
| 426 | $value = Inline::parse($this->lines[0], $flags, $this->refs); |
||
| 427 | } catch (ParseException $e) { |
||
| 428 | $e->setParsedLine($this->getRealCurrentLineNb() + 1); |
||
| 429 | $e->setSnippet($this->currentLine); |
||
| 430 | |||
| 431 | throw $e; |
||
| 432 | } |
||
| 433 | |||
| 434 | return $value; |
||
| 435 | } |
||
| 436 | |||
| 437 | // try to parse the value as a multi-line string as a last resort |
||
| 438 | if (0 === $this->currentLineNb) { |
||
| 439 | $previousLineWasNewline = false; |
||
| 440 | $previousLineWasTerminatedWithBackslash = false; |
||
| 441 | $value = ''; |
||
| 442 | |||
| 443 | foreach ($this->lines as $line) { |
||
| 444 | if ('' !== ltrim($line) && '#' === ltrim($line)[0]) { |
||
| 445 | continue; |
||
| 446 | } |
||
| 447 | // If the indentation is not consistent at offset 0, it is to be considered as a ParseError |
||
| 448 | if (0 === $this->offset && !$deprecatedUsage && isset($line[0]) && ' ' === $line[0]) { |
||
| 449 | throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename); |
||
| 450 | } |
||
| 451 | if ('' === trim($line)) { |
||
| 452 | $value .= "\n"; |
||
| 453 | } elseif (!$previousLineWasNewline && !$previousLineWasTerminatedWithBackslash) { |
||
| 454 | $value .= ' '; |
||
| 455 | } |
||
| 456 | |||
| 457 | if ('' !== trim($line) && '\\' === substr($line, -1)) { |
||
| 458 | $value .= ltrim(substr($line, 0, -1)); |
||
| 459 | } elseif ('' !== trim($line)) { |
||
| 460 | $value .= trim($line); |
||
| 461 | } |
||
| 462 | |||
| 463 | if ('' === trim($line)) { |
||
| 464 | $previousLineWasNewline = true; |
||
| 465 | $previousLineWasTerminatedWithBackslash = false; |
||
| 466 | } elseif ('\\' === substr($line, -1)) { |
||
| 467 | $previousLineWasNewline = false; |
||
| 468 | $previousLineWasTerminatedWithBackslash = true; |
||
| 469 | } else { |
||
| 470 | $previousLineWasNewline = false; |
||
| 471 | $previousLineWasTerminatedWithBackslash = false; |
||
| 472 | } |
||
| 473 | } |
||
| 474 | |||
| 475 | try { |
||
| 476 | return Inline::parse(trim($value)); |
||
| 477 | } catch (ParseException $e) { |
||
| 478 | // fall-through to the ParseException thrown below |
||
| 479 | } |
||
| 480 | } |
||
| 481 | |||
| 482 | throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename); |
||
| 483 | } |
||
| 484 | } while ($this->moveToNextLine()); |
||
| 485 | |||
| 486 | if (null !== $tag) { |
||
| 487 | $data = new TaggedValue($tag, $data); |
||
| 488 | } |
||
| 489 | |||
| 490 | if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && !\is_object($data) && 'mapping' === $context) { |
||
| 491 | $object = new \stdClass(); |
||
| 492 | |||
| 493 | foreach ($data as $key => $value) { |
||
| 494 | $object->$key = $value; |
||
| 495 | } |
||
| 496 | |||
| 497 | $data = $object; |
||
| 498 | } |
||
| 499 | |||
| 500 | return empty($data) ? null : $data; |
||
| 501 | } |
||
| 1157 |
Loading history...
This class constant has been deprecated. The supplier of the class has supplied an explanatory message.
The explanatory message should give you some clue as to whether and when the constant will be removed from the class and what other constant to use instead.