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

Complexity

Conditions	14
Paths	123

Size

Total Lines

91

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function sequence(): ComponentInterface
    {
        // Root context - the only symbols that cause any context switching are curly brace open and tag start, but
        // only if they are not preceded by a backslash character; in which case the symbol is ignored and merely
        // collected as part of the output string. NULL bytes are ignored in this context (the Splitter will yield
        // a single NULL byte when end of source is reached).
        $this->sequence = $this->splitter->parse();

It seems like $this->splitter->parse() can also be of type array<integer,string> or array<integer,null>. However, the property $sequence is declared as type object<NoRewindIterator>. Maybe add an additional type check?

        $countedEscapes = 0;
        foreach ($this->sequence as $symbol => $captured) {
            $node = end($this->nodeStack);
            $text = $captured . ($countedEscapes > 0 ? chr($symbol) : '');
            if ($text !== '') {
                $node->addChild(new TextNode($text));
            }

            if ($countedEscapes > 0) {
                $countedEscapes = 0;
                continue;
            }

            switch ($symbol) {
                case self::BYTE_BACKSLASH:
                    ++$countedEscapes;
                    break;

                case self::BYTE_INLINE:
                    $countedEscapes = 0;
                    try {
                        $childNode = $this->sequenceInlineNodes(false);
                    } catch (Exception $exception) {
                        $childNode = new TextNode(
                            $this->renderingContext->getErrorHandler()->handleParserError(
                                $this->createErrorAtPosition(
                                    $exception->getMessage(),
                                    $exception->getCode()
                                )
                            )
                        );
                    }
                    $node->addChild($childNode);
                    $this->splitter->switch($this->contexts->root);
                    break;

                case self::BYTE_TAG:
                    $countedEscapes = 0;
                    try {
                        $childNode = $this->sequenceTagNode();
                    } catch (Exception $exception) {
                        $childNode = new TextNode(
                            $this->renderingContext->getErrorHandler()->handleParserError(
                                $this->createErrorAtPosition(
                                    $exception->getMessage(),
                                    $exception->getCode()
                                )
                            )
                        );
                    }
                    $this->splitter->switch($this->contexts->root);

                    if ($childNode) {
                        end($this->nodeStack)->addChild($childNode);
                    }
                    break;

                case self::BYTE_NULL:
                    break;
            }
        }

        // If there is more than a single node remaining in the stack this indicates an error. More precisely it
        // indicates that some function called in the above switch added a node to the stack but failed to remove it
        // before returning, which usually indicates that the template contains one or more incorrectly closed tags.
        // In order to report this as error we collect the classes of every remaining node in the stack. Unfortunately
        // we cannot report the position of where the closing tag was expected - this is simply not known to Fluid.
        if (count($this->nodeStack) !== 1) {
            $names = [];
            while (($unterminatedNode = array_pop($this->nodeStack))) {
                $names[] = get_class($unterminatedNode);
            }
            throw $this->createErrorAtPosition(
                'Unterminated node(s) detected: ' . implode(', ', array_reverse($names)),
                1562671632
            );
        }

        // Finishing sequencing means returning the single node that remains in the node stack, firing the onClose
        // method on it and assigning the rendering context to the ArgumentCollection carried by the root node.
        $node = array_pop($this->nodeStack)->onClose($this->renderingContext);
        $node->getArguments()->setRenderingContext($this->renderingContext);
        return $node;
    }

}