TYPO3Fluid\Fluid\Core\Parser\Sequencer::sequenceArrayNode()

Complexity

Conditions	45
Paths	141

Size

Total Lines

133

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    protected function sequenceArrayNode(\Iterator $sequence, array $definitions = null, bool $numeric = false): ArrayNode
    {
        $array = [];

        $keyOrValue = null;
        $key = null;
        $escapingEnabledBackup = $this->escapingEnabled;
        $this->escapingEnabled = false;
        $itemCount = -1;
        $countedEscapes = 0;

        $sequence->next();
        foreach ($sequence as $symbol => $captured) {
            switch ($symbol) {
                case Splitter::BYTE_SEPARATOR_COLON:
                case Splitter::BYTE_SEPARATOR_EQUALS:
                    // Colon or equals has same meaning (which allows tag syntax as argument syntax). Encountering this
                    // byte always means the preceding byte was a key. However, if nothing was captured before this,
                    // it means colon or equals was used without a key which is a syntax error.
                    $key = $key ?? $captured ?? (isset($keyOrValue) ? $keyOrValue->flatten(true) : null);
                    if (!isset($key)) {
                        throw $this->createErrorAtPosition('Unexpected colon or equals sign, no preceding key', 1559250839);
                    }
                    if ($definitions !== null && !$numeric && !isset($definitions[$key])) {
                        throw $this->createUnsupportedArgumentError((string)$key, $definitions);
                    }
                    break;

                case Splitter::BYTE_ARRAY_START:
                case Splitter::BYTE_INLINE:
                    // Minimal safeguards to improve error feedback. Theoretically such "garbage" could simply be ignored
                    // without causing problems to the parser, but it is probably best to report it as it could indicate
                    // the user expected X value but gets Y and doesn't notice why.
                    if ($captured !== null) {
                        throw $this->createErrorAtPosition('Unexpected content before array/inline start in associative array, ASCII: ' . ord($captured), 1559131849);
                    }
                    if (!isset($key) && !$numeric) {
                        throw $this->createErrorAtPosition('Unexpected array/inline start in associative array without preceding key', 1559131848);
                    }

                    // Encountering a curly brace or square bracket start byte will both cause a sub-array to be sequenced,
                    // the difference being that only the square bracket will cause third parameter ($numeric) passed to
                    // sequenceArrayNode() to be true, which in turn causes key-less items to be added with numeric indexes.
                    $key = $key ?? ++$itemCount;
                    $array[$key] = $this->sequenceArrayNode($sequence, null, $symbol === Splitter::BYTE_ARRAY_START);
                    $keyOrValue = null;
                    $key = null;
                    break;

                case Splitter::BYTE_QUOTE_SINGLE:
                case Splitter::BYTE_QUOTE_DOUBLE:
                    // Safeguard: if anything is captured before a quote this indicates garbage leading content. As with
                    // the garbage safeguards above, this one could theoretically be ignored in favor of silently making
                    // the odd syntax "just work".
                    if ($captured !== null) {
                        throw $this->createErrorAtPosition('Unexpected content before quote start in associative array, ASCII: ' . ord($captured), 1559145560);
                    }

                    // Quotes will always cause sequencing of the quoted string, but differs in behavior based on whether
                    // or not the $key is set. If $key is set, we know for sure we can assign a value. If it is not set
                    // we instead leave $keyOrValue defined so this will be processed by one of the next iterations.
                    $keyOrValue = $this->sequenceQuotedNode($sequence, $countedEscapes);
                    if (isset($key)) {
                        $array[$key] = $keyOrValue->flatten(true);
                        $keyOrValue = null;
                        $key = null;
                        $countedEscapes = 0;
                    }
                    break;

                case Splitter::BYTE_SEPARATOR_COMMA:
                    // Comma separator: if we've collected a key or value, use it. Otherwise, use captured string.
                    // If neither key nor value nor captured string exists, ignore the comma (likely a tailing comma).
                    if (isset($keyOrValue)) {
                        // Key or value came as quoted string and exists in $keyOrValue
                        $potentialValue = $keyOrValue->flatten(true);
                        $key = $numeric ? ++$itemCount : $potentialValue;
                        $array[$key] = $numeric ? $potentialValue : (is_numeric($key) ? $key + 0 : new ObjectAccessorNode($key));

It seems like $key defined by $numeric ? ++$itemCount : $potentialValue on line 766 can also be of type object<TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\NodeInterface>; however, TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\ObjectAccessorNode::__construct() does only seem to accept string|null, maybe add an additional type check?

                    } elseif (isset($captured)) {
                        $key = $key ?? ($numeric ? ++$itemCount : $captured);
                        if (!$numeric && isset($definitions) && !isset($definitions[$key])) {
                            throw $this->createUnsupportedArgumentError((string)$key, $definitions);
                        }
                        $array[$key] = is_numeric($captured) ? $captured + 0 : new ObjectAccessorNode($captured);
                    }
                    $keyOrValue = null;
                    $key = null;
                    break;

                case Splitter::BYTE_WHITESPACE_TAB:
                case Splitter::BYTE_WHITESPACE_RETURN:
                case Splitter::BYTE_WHITESPACE_EOL:
                case Splitter::BYTE_WHITESPACE_SPACE:
                    // Any whitespace attempts to set the key, if not already set. The captured string may be null as
                    // well, leaving the $key variable still null and able to be coalesced.
                    $key = $key ?? $captured;
                    break;

                case Splitter::BYTE_BACKSLASH:
                    // Escapes are simply counted and passed to the sequenceQuotedNode() method, causing that method
                    // to ignore exactly this number of backslashes before a matching quote is seen as closing quote.
                    ++$countedEscapes;
                    break;

                case Splitter::BYTE_INLINE_END:
                case Splitter::BYTE_ARRAY_END:
                case Splitter::BYTE_PARENTHESIS_END:
                    // Array end indication. Check if anything was collected previously or was captured currently,
                    // assign that to the array and return an ArrayNode with the full array inside.
                    $captured = $captured ?? (isset($keyOrValue) ? $keyOrValue->flatten(true) : null);
                    $key = $key ?? ($numeric ? ++$itemCount : $captured);
                    if (isset($captured, $key)) {
                        if (is_numeric($captured)) {
                            $array[$key] = $captured + 0;
                        } elseif (isset($keyOrValue)) {
                            $array[$key] = $keyOrValue->flatten();
                        } else {
                            $array[$key] = new ObjectAccessorNode($captured ?? $key);
                        }
                    }
                    if (!$numeric && isset($key, $definitions) && !isset($definitions[$key])) {
                        throw $this->createUnsupportedArgumentError((string)$key, $definitions);
                    }
                    $this->escapingEnabled = $escapingEnabledBackup;
                    return new ArrayNode($array);
            }
        }

        throw $this->createErrorAtPosition(
            'Unterminated array',
            1557748574
        );
    }

}