You are here

Home » API reference » Loft Data Grids 7.2 » Parser.php » Parser

private function Parser::doParse in Loft Data Grids 7.2

1 call to Parser::doParse()
Parser::parse in vendor/symfony/yaml/Parser.php
Parses a YAML string to a PHP value.

File

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

Class

Parser
Parser parses YAML strings to convert them to PHP arrays.

Namespace

Symfony\Component\Yaml

Code

private function doParse($value, $exceptionOnInvalidType = false, $objectSupport = false, $objectForMap = false) {
  $this->currentLineNb = -1;
  $this->currentLine = '';
  $value = $this
    ->cleanup($value);
  $this->lines = explode("\n", $value);
  $this->locallySkippedLineNumbers = array();
  if (null === $this->totalNumberOfLines) {
    $this->totalNumberOfLines = count($this->lines);
  }
  $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 (self::preg_match('#^\\-((?P<leadspaces>\\s+)(?P<value>.+))?$#u', rtrim($this->currentLine), $values)) {
      if ($context && 'mapping' == $context) {
        throw new ParseException('You cannot define a sequence item when in a mapping', $this
          ->getRealCurrentLineNb() + 1, $this->currentLine);
      }
      $context = 'sequence';
      if (isset($values['value']) && self::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'], ' '), '#')) {
        $data[] = $this
          ->parseBlock($this
          ->getRealCurrentLineNb() + 1, $this
          ->getNextEmbedBlock(null, true), $exceptionOnInvalidType, $objectSupport, $objectForMap);
      }
      else {
        if (isset($values['leadspaces']) && self::preg_match('#^(?P<key>' . Inline::REGEX_QUOTED_STRING . '|[^ \'"\\{\\[].*?) *\\:(\\s+(?P<value>.+))?$#u', rtrim($values['value']), $matches)) {

          // this is a compact notation element, add to next block and parse
          $block = $values['value'];
          if ($this
            ->isNextLineIndented()) {
            $block .= "\n" . $this
              ->getNextEmbedBlock($this
              ->getCurrentLineIndentation() + strlen($values['leadspaces']) + 1);
          }
          $data[] = $this
            ->parseBlock($this
            ->getRealCurrentLineNb(), $block, $exceptionOnInvalidType, $objectSupport, $objectForMap);
        }
        else {
          $data[] = $this
            ->parseValue($values['value'], $exceptionOnInvalidType, $objectSupport, $objectForMap, $context);
        }
      }
      if ($isRef) {
        $this->refs[$isRef] = end($data);
      }
    }
    elseif (self::preg_match('#^(?P<key>' . Inline::REGEX_QUOTED_STRING . '|[^ \'"\\[\\{].*?) *\\:(\\s+(?P<value>.+))?$#u', rtrim($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', $this->currentLineNb + 1, $this->currentLine);
      }
      $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 && (!isset($values['value']) || !self::preg_match('#^&(?P<ref>[^ ]+)#u', $values['value'], $refMatches))) {
        $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);
          }
          $data += $refValue;

          // array union
        }
        else {
          if (isset($values['value']) && '' !== $values['value']) {
            $value = $values['value'];
          }
          else {
            $value = $this
              ->getNextEmbedBlock();
          }
          $parsed = $this
            ->parseBlock($this
            ->getRealCurrentLineNb() + 1, $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);
              }
              $data += $parsedItem;

              // array union
            }
          }
          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.
            $data += $parsed;

            // array union
          }
        }
      }
      elseif ('<<' !== $key && isset($values['value']) && self::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'], ' '), '#') || '<<' === $key) {

        // 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 {
          $value = $this
            ->parseBlock($this
            ->getRealCurrentLineNb() + 1, $this
            ->getNextEmbedBlock(), $exceptionOnInvalidType, $objectSupport, $objectForMap);
          if ('<<' === $key) {
            $this->refs[$refMatches['ref']] = $value;
            $data += $value;
          }
          elseif ($allowOverwrite || !isset($data[$key])) {

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

        // 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.', $this->currentLineNb + 1, $this->currentLine);
      }

      // 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;
        }
        return $value;
      }
      throw new ParseException('Unable to parse.', $this
        ->getRealCurrentLineNb() + 1, $this->currentLine);
    }
  }
  if ($objectForMap && !is_object($data) && 'mapping' === $context) {
    $object = new \stdClass();
    foreach ($data as $key => $value) {
      $object->{$key} = $value;
    }
    $data = $object;
  }
  return empty($data) ? null : $data;
}