public function Parser::parse in Zircon Profile 8.0

Same name in this branch

1. 8.0 vendor/symfony/yaml/Parser.php \Symfony\Component\Yaml\Parser::parse()
2. 8.0 vendor/sebastian/diff/src/Parser.php \SebastianBergmann\Diff\Parser::parse()
3. 8.0 vendor/symfony/css-selector/Parser/Parser.php \Symfony\Component\CssSelector\Parser\Parser::parse()
4. 8.0 vendor/egulias/email-validator/src/Egulias/EmailValidator/Parser/Parser.php \Egulias\EmailValidator\Parser\Parser::parse()

Same name and namespace in other branches

1. 8 vendor/symfony/yaml/Parser.php \Symfony\Component\Yaml\Parser::parse()

Parses a YAML string to a PHP value.

Parameters

string $value A YAML string:

bool $exceptionOnInvalidType true if an exception must be thrown on invalid types (a PHP resource or object), false otherwise:

bool $objectSupport true if object support is enabled, false otherwise:

bool $objectForMap true if maps should return a stdClass instead of array():

Return value

mixed A PHP value

Throws

ParseException If the YAML is not valid

File

vendor/symfony/yaml/Parser.php, line 55

Class

Parser

Parser parses YAML strings to convert them to PHP arrays.

Namespace

Symfony\Component\Yaml

Code

public function parse($value, $exceptionOnInvalidType = false, $objectSupport = false, $objectForMap = false) {
  if (!preg_match('//u', $value)) {
    throw new ParseException('The YAML value does not appear to be valid UTF-8.');
  }
  $this->currentLineNb = -1;
  $this->currentLine = '';
  $value = $this
    ->cleanup($value);
  $this->lines = explode("\n", $value);
  if (function_exists('mb_internal_encoding') && (int) ini_get('mbstring.func_overload') & 2) {
    $mbEncoding = mb_internal_encoding();
    mb_internal_encoding('UTF-8');
  }
  $data = array();
  $context = null;
  $allowOverwrite = false;
  while ($this
    ->moveToNextLine()) {
    if ($this
      ->isCurrentLineEmpty()) {
      continue;
    }

    // tab?
    if ("\t" === $this->currentLine[0]) {
      throw new ParseException('A YAML file cannot contain tabs as indentation.', $this
        ->getRealCurrentLineNb() + 1, $this->currentLine);
    }
    $isRef = $mergeNode = false;
    if (preg_match('#^\\-((?P<leadspaces>\\s+)(?P<value>.+?))?\\s*$#u', $this->currentLine, $values)) {
      if ($context && 'mapping' == $context) {
        throw new ParseException('You cannot define a sequence item when in a mapping');
      }
      $context = 'sequence';
      if (isset($values['value']) && preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches)) {
        $isRef = $matches['ref'];
        $values['value'] = $matches['value'];
      }

      // array
      if (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#')) {
        $c = $this
          ->getRealCurrentLineNb() + 1;
        $parser = new self($c);
        $parser->refs =& $this->refs;
        $data[] = $parser
          ->parse($this
          ->getNextEmbedBlock(null, true), $exceptionOnInvalidType, $objectSupport, $objectForMap);
      }
      else {
        if (isset($values['leadspaces']) && preg_match('#^(?P<key>' . Inline::REGEX_QUOTED_STRING . '|[^ \'"\\{\\[].*?) *\\:(\\s+(?P<value>.+?))?\\s*$#u', $values['value'], $matches)) {

          // this is a compact notation element, add to next block and parse
          $c = $this
            ->getRealCurrentLineNb();
          $parser = new self($c);
          $parser->refs =& $this->refs;
          $block = $values['value'];
          if ($this
            ->isNextLineIndented()) {
            $block .= "\n" . $this
              ->getNextEmbedBlock($this
              ->getCurrentLineIndentation() + strlen($values['leadspaces']) + 1);
          }
          $data[] = $parser
            ->parse($block, $exceptionOnInvalidType, $objectSupport, $objectForMap);
        }
        else {
          $data[] = $this
            ->parseValue($values['value'], $exceptionOnInvalidType, $objectSupport, $objectForMap);
        }
      }
      if ($isRef) {
        $this->refs[$isRef] = end($data);
      }
    }
    elseif (preg_match('#^(?P<key>' . Inline::REGEX_QUOTED_STRING . '|[^ \'"\\[\\{].*?) *\\:(\\s+(?P<value>.+?))?\\s*$#u', $this->currentLine, $values) && (false === strpos($values['key'], ' #') || in_array($values['key'][0], array(
      '"',
      "'",
    )))) {
      if ($context && 'sequence' == $context) {
        throw new ParseException('You cannot define a mapping item when in a sequence');
      }
      $context = 'mapping';

      // force correct settings
      Inline::parse(null, $exceptionOnInvalidType, $objectSupport, $objectForMap, $this->refs);
      try {
        $key = Inline::parseScalar($values['key']);
      } catch (ParseException $e) {
        $e
          ->setParsedLine($this
          ->getRealCurrentLineNb() + 1);
        $e
          ->setSnippet($this->currentLine);
        throw $e;
      }

      // Convert float keys to strings, to avoid being converted to integers by PHP
      if (is_float($key)) {
        $key = (string) $key;
      }
      if ('<<' === $key) {
        $mergeNode = true;
        $allowOverwrite = true;
        if (isset($values['value']) && 0 === strpos($values['value'], '*')) {
          $refName = substr($values['value'], 1);
          if (!array_key_exists($refName, $this->refs)) {
            throw new ParseException(sprintf('Reference "%s" does not exist.', $refName), $this
              ->getRealCurrentLineNb() + 1, $this->currentLine);
          }
          $refValue = $this->refs[$refName];
          if (!is_array($refValue)) {
            throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this
              ->getRealCurrentLineNb() + 1, $this->currentLine);
          }
          foreach ($refValue as $key => $value) {
            if (!isset($data[$key])) {
              $data[$key] = $value;
            }
          }
        }
        else {
          if (isset($values['value']) && $values['value'] !== '') {
            $value = $values['value'];
          }
          else {
            $value = $this
              ->getNextEmbedBlock();
          }
          $c = $this
            ->getRealCurrentLineNb() + 1;
          $parser = new self($c);
          $parser->refs =& $this->refs;
          $parsed = $parser
            ->parse($value, $exceptionOnInvalidType, $objectSupport, $objectForMap);
          if (!is_array($parsed)) {
            throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this
              ->getRealCurrentLineNb() + 1, $this->currentLine);
          }
          if (isset($parsed[0])) {

            // If the value associated with the merge key is a sequence, then this sequence is expected to contain mapping nodes
            // and each of these nodes is merged in turn according to its order in the sequence. Keys in mapping nodes earlier
            // in the sequence override keys specified in later mapping nodes.
            foreach ($parsed as $parsedItem) {
              if (!is_array($parsedItem)) {
                throw new ParseException('Merge items must be arrays.', $this
                  ->getRealCurrentLineNb() + 1, $parsedItem);
              }
              foreach ($parsedItem as $key => $value) {
                if (!isset($data[$key])) {
                  $data[$key] = $value;
                }
              }
            }
          }
          else {

            // If the value associated with the key is a single mapping node, each of its key/value pairs is inserted into the
            // current mapping, unless the key already exists in it.
            foreach ($parsed as $key => $value) {
              if (!isset($data[$key])) {
                $data[$key] = $value;
              }
            }
          }
        }
      }
      elseif (isset($values['value']) && preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches)) {
        $isRef = $matches['ref'];
        $values['value'] = $matches['value'];
      }
      if ($mergeNode) {

        // Merge keys
      }
      elseif (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#')) {

        // hash
        // if next line is less indented or equal, then it means that the current value is null
        if (!$this
          ->isNextLineIndented() && !$this
          ->isNextLineUnIndentedCollection()) {

          // Spec: Keys MUST be unique; first one wins.
          // But overwriting is allowed when a merge node is used in current block.
          if ($allowOverwrite || !isset($data[$key])) {
            $data[$key] = null;
          }
        }
        else {
          $c = $this
            ->getRealCurrentLineNb() + 1;
          $parser = new self($c);
          $parser->refs =& $this->refs;
          $value = $parser
            ->parse($this
            ->getNextEmbedBlock(), $exceptionOnInvalidType, $objectSupport, $objectForMap);

          // Spec: Keys MUST be unique; first one wins.
          // But overwriting is allowed when a merge node is used in current block.
          if ($allowOverwrite || !isset($data[$key])) {
            $data[$key] = $value;
          }
        }
      }
      else {
        $value = $this
          ->parseValue($values['value'], $exceptionOnInvalidType, $objectSupport, $objectForMap);

        // Spec: Keys MUST be unique; first one wins.
        // But overwriting is allowed when a merge node is used in current block.
        if ($allowOverwrite || !isset($data[$key])) {
          $data[$key] = $value;
        }
      }
      if ($isRef) {
        $this->refs[$isRef] = $data[$key];
      }
    }
    else {

      // multiple documents are not supported
      if ('---' === $this->currentLine) {
        throw new ParseException('Multiple documents are not supported.');
      }

      // 1-liner optionally followed by newline(s)
      if (is_string($value) && $this->lines[0] === trim($value)) {
        try {
          $value = Inline::parse($this->lines[0], $exceptionOnInvalidType, $objectSupport, $objectForMap, $this->refs);
        } catch (ParseException $e) {
          $e
            ->setParsedLine($this
            ->getRealCurrentLineNb() + 1);
          $e
            ->setSnippet($this->currentLine);
          throw $e;
        }
        if (is_array($value)) {
          $first = reset($value);
          if (is_string($first) && 0 === strpos($first, '*')) {
            $data = array();
            foreach ($value as $alias) {
              $data[] = $this->refs[substr($alias, 1)];
            }
            $value = $data;
          }
        }
        if (isset($mbEncoding)) {
          mb_internal_encoding($mbEncoding);
        }
        return $value;
      }
      switch (preg_last_error()) {
        case PREG_INTERNAL_ERROR:
          $error = 'Internal PCRE error.';
          break;
        case PREG_BACKTRACK_LIMIT_ERROR:
          $error = 'pcre.backtrack_limit reached.';
          break;
        case PREG_RECURSION_LIMIT_ERROR:
          $error = 'pcre.recursion_limit reached.';
          break;
        case PREG_BAD_UTF8_ERROR:
          $error = 'Malformed UTF-8 data.';
          break;
        case PREG_BAD_UTF8_OFFSET_ERROR:
          $error = 'Offset doesn\'t correspond to the begin of a valid UTF-8 code point.';
          break;
        default:
          $error = 'Unable to parse.';
      }
      throw new ParseException($error, $this
        ->getRealCurrentLineNb() + 1, $this->currentLine);
    }
  }
  if (isset($mbEncoding)) {
    mb_internal_encoding($mbEncoding);
  }
  return empty($data) ? null : $data;
}