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

Complexity

Conditions	75
Paths	195

Size

Total Lines

353

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    protected function sequenceInlineNodes(bool $allowArray = true): ComponentInterface
    {
        $text = '{';
        /** @var ComponentInterface|null $node */
        $node = null;
        $key = null;
        $namespace = null;
        $method = null;

$method is not used, you could remove the assignment.

        $definitions = null;

$definitions is not used, you could remove the assignment.

        $potentialAccessor = null;
        $callDetected = false;
        $hasPass = false;
        $hasColon = null;
        $hasWhitespace = false;
        $isArray = false;
        $arguments = new ArgumentCollection();
        $parts = [];
        $ignoredEndingBraces = 0;
        $countedEscapes = 0;
        $restore = $this->splitter->switch($this->contexts->inline);
        $this->sequence->next();
        foreach ($this->sequence as $symbol => $captured) {
            $text .= $captured;
            switch ($symbol) {
                case self::BYTE_AT:
                    $this->sequenceToggleInstruction();
                    $this->splitter->switch($restore);
                    return new TextNode('');
                    break;

break is not strictly necessary here and could be removed.

                case self::BYTE_BACKSLASH:
                    // Increase the number of counted escapes (is passed to sequenceNode() in the "QUOTE" cases and reset
                    // after the quoted string is extracted).
                    ++$countedEscapes;
                    if ($hasWhitespace) {
                        $node = $node ?? new RootNode();
                    } else {
                        $node = $node ?? new ObjectAccessorNode();
                    }
                    if ($captured !== null) {
                        $node->addChild(new TextNode((string) $captured));
                    }
                    break;

                case self::BYTE_ARRAY_START:
                    $text .= chr($symbol);
                    $isArray = $allowArray;

                    // Sequence the node. Pass the "use numeric keys?" boolean based on the current byte. Only array
                    // start creates numeric keys. Inline start with keyless values creates ECMA style {foo:foo, bar:bar}
                    // from {foo, bar}.
                    $arguments[$key ?? $captured ?? 0] = $node = new ArrayNode();
                    $this->sequenceArrayNode($node, true);
                    $key = null;
                    break;

                case self::BYTE_INLINE:
                    // Encountering this case can mean different things: sub-syntax like {foo.{index}} or array, depending
                    // on presence of either a colon or comma before the inline. In protected mode it is simply added.
                    $text .= '{';
                    $node = $node ?? new ObjectAccessorNode();
                    if ($countedEscapes > 0) {
                        ++$ignoredEndingBraces;
                        $countedEscapes = 0;
                        if ($captured !== null) {
                            $node->addChild(new TextNode((string)$captured));
                        }
                    } elseif ($this->splitter->context->context === Context::CONTEXT_PROTECTED) {
                        // Ignore one ending additional curly brace. Subtracted in the BYTE_INLINE_END case below.
                        // The expression in this case looks like {{inline}.....} and we capture the curlies.
                        $potentialAccessor .= $captured;
                    } elseif ($allowArray || $isArray) {
                        $isArray = true;
                        $captured = $key ?? $captured ?? $potentialAccessor;
                        // This is a sub-syntax following a colon - meaning it is an array.
                        if ($captured !== null) {
                            $arguments[$key ?? $captured ?? 0] = $node = new ArrayNode();
                            $this->sequenceArrayNode($node);
                        }
                    } else {
                        if ($captured !== null) {
                            $node->addChild(new TextNode((string) $captured));
                        }
                        $childNodeToAdd = $this->sequenceInlineNodes($allowArray);
                        $node->addChild($childNodeToAdd);
                    }
                    break;

                case self::BYTE_MINUS:
                    $text .= '-';
                    $potentialAccessor = $potentialAccessor ?? $captured;
                    break;

                // Backtick may be encountered in two different contexts: normal inline context, in which case it has
                // the same meaning as any quote and causes sequencing of a quoted string. Or protected context, in
                // which case it also sequences a quoted node but appends the result instead of assigning to array.
                // Note that backticks do not support escapes (they are a new feature that does not require escaping).
                case self::BYTE_BACKTICK:
                    if ($this->splitter->context->context === Context::CONTEXT_PROTECTED) {
                        $node->addChild(new TextNode($text));
                        $node->addChild($this->sequenceQuotedNode()->flatten());
                        $text = '';
                        break;
                    }
                // Fallthrough is intentional: if not in protected context, consider the backtick a normal quote.

                // Case not normally countered in straight up "inline" context, but when encountered, means we have
                // explicitly found a quoted array key - and we extract it.
                case self::BYTE_QUOTE_SINGLE:
                case self::BYTE_QUOTE_DOUBLE:
                    if (!$allowArray) {
                        $text .= chr($symbol);
                        break;
                    }
                    if ($key !== null) {
                        $arguments[$key] = $this->sequenceQuotedNode($countedEscapes)->flatten(true);
                        $key = null;
                    } else {
                        $key = $this->sequenceQuotedNode($countedEscapes)->flatten(true);
                    }
                    $countedEscapes = 0;
                    $isArray = $allowArray;
                    break;

                case self::BYTE_SEPARATOR_COMMA:
                    if (!$allowArray) {
                        $text .= ',';
                        break;
                    }
                    if ($captured !== null) {
                        $arguments[$key ?? $captured] = new ObjectAccessorNode($captured);
                    }
                    $key = null;
                    $isArray = $allowArray;
                    break;

                case self::BYTE_SEPARATOR_EQUALS:
                    $text .= '=';
                    if (!$allowArray) {
                        $node = new RootNode();
                        $this->splitter->switch($this->contexts->protected);
                        break;
                    }
                    $key = $captured;
                    $isArray = $allowArray;
                    break;

                case self::BYTE_SEPARATOR_COLON:
                    $text .= ':';
                    $hasColon = true;
                    $namespace = $captured;
                    $key = $key ?? $captured;
                    $isArray = $isArray || ($allowArray && is_numeric($key));
                    if ($captured !== null) {
                        $parts[] = $captured;
                    }
                    $parts[] = ':';
                    break;

                case self::BYTE_WHITESPACE_SPACE:
                case self::BYTE_WHITESPACE_EOL:
                case self::BYTE_WHITESPACE_RETURN:
                case self::BYTE_WHITESPACE_TAB:
                    // If we already collected some whitespace we must enter protected context.
                    $text .= $this->source->source[$this->splitter->index - 1];

                    if ($captured !== null) {
                        // Store a captured part: a whitespace inside inline syntax will engage the expression matching
                        // that occurs when the node is closed. Allows matching the various parts to create the appropriate
                        // node type.
                        $parts[] = $captured;
                    }

                    if ($hasWhitespace && !$hasPass && !$allowArray) {
                        // Protection mode: this very limited context does not allow tags or inline syntax, and will
                        // protect things like CSS and JS - and will only enter a more reactive context if encountering
                        // the backtick character, meaning a quoted string will be sequenced. This backtick-quoted
                        // string can then contain inline syntax like variable accessors.
                        $node = $node ?? new RootNode();
                        $this->splitter->switch($this->contexts->protected);
                        break;
                    }

                    if ($captured === 'namespace') {
                        // Special case: we catch namespace definitions with {namespace xyz=foo} syntax here, although
                        // the proper way with current code is to use {@namespace xyz=foo}. We have this case here since
                        // it is relatively cheap (only happens when we see a space inside inline and a straight-up
                        // string comparison with strict types enabled). We then return an empty TextNode which is
                        // ignored by the parent node when attached so we don't create any output.
                        $this->sequenceToggleInstruction('namespace');
                        $this->splitter->switch($restore);
                        return new TextNode('');
                    }
                    $key = $key ?? $captured;
                    $hasWhitespace = true;
                    $isArray = $allowArray && ($hasColon ?? $isArray ?? is_numeric($captured));
                    $potentialAccessor = ($potentialAccessor ?? $captured);
                    break;

                case self::BYTE_TAG_END:
                case self::BYTE_PIPE:
                    // If there is an accessor on the left side of the pipe and $node is not defined, we create $node
                    // as an object accessor. If $node already exists we do nothing (and expect the VH trigger, the
                    // parenthesis start case below, to add $node as childnode and create a new $node).
                    $hasPass = true;
                    $isArray = $allowArray;
                    $callDetected = false;

                    $text .=  $this->source->source[$this->splitter->index - 1];
                    $node = $node ?? new ObjectAccessorNode();
                    if ($potentialAccessor ?? $captured) {
                        $node->addChild(new TextNode($potentialAccessor . $captured));
                    }

                    $potentialAccessor = $namespace = $method = $key = null;

$method is not used, you could remove the assignment.

                    break;

                case self::BYTE_PARENTHESIS_START:
                    $isArray = false;
                    // Special case: if a parenthesis start was preceded by whitespace but had no pass operator we are
                    // not dealing with a ViewHelper call and will continue the sequencing, grabbing the parenthesis as
                    // part of the expression.
                    $text .= '(';
                    if (!$hasColon || ($hasWhitespace && !$hasPass)) {

The expression $hasColon of type null|boolean is loosely compared to false; this is ambiguous if the boolean can be false. You might want to explicitly use !== null instead.

                        $this->splitter->switch($this->contexts->protected);
                        $namespace = $method = null;

$method is not used, you could remove the assignment.

                        break;
                    }

                    $callDetected = true;
                    $method = $captured;
                    $childNodeToAdd = $node;
                    try {
                        $node = $this->resolver->createViewHelperInstance($namespace, $method);
                        $arguments = $node->getArguments();
                        $node = $this->callInterceptor($node, self::INTERCEPT_OPENING_VIEWHELPER);
                    } catch (\TYPO3Fluid\Fluid\Core\Exception $exception) {
                        throw $this->createErrorAtPosition($exception->getMessage(), $exception->getCode());
                    }

                    $this->sequenceArrayNode($arguments);
                    $arguments->setRenderingContext($this->renderingContext)->validate();
                    $node = $node->onOpen($this->renderingContext);

                    if ($childNodeToAdd) {
                        if ($childNodeToAdd instanceof ObjectAccessorNode) {
                            $childNodeToAdd = $this->callInterceptor($childNodeToAdd, self::INTERCEPT_OBJECTACCESSOR);
                        }
                        $node->addChild($childNodeToAdd);
                    }
                    $node = $node->onClose($this->renderingContext);
                    $text .= ')';
                    $potentialAccessor = null;
                    break;

                case self::BYTE_INLINE_END:
                    $text .= '}';

                    if (--$ignoredEndingBraces >= 0) {
                        if ($captured !== null) {
                            $node->addChild(new TextNode('{' . $captured . '}'));
                        }
                        break;
                    }

                    if ($text === '{}') {
                        // Edge case handling of empty JS objects
                        return new TextNode('{}');
                    }

                    $isArray = $allowArray && ($isArray ?: ($hasColon && !$hasPass && !$callDetected));
                    $potentialAccessor .= $captured;
                    $interceptionPoint = self::INTERCEPT_OBJECTACCESSOR;

                    // Decision: if we did not detect a ViewHelper we match the *entire* expression, from the cached
                    // starting index, to see if it matches a known type of expression. If it does, we must return the
                    // appropriate type of ExpressionNode.
                    if ($isArray) {
                        if ($captured !== null) {
                            $arguments[$key ?? $captured] = is_numeric($captured) ? $captured + 0 : new ObjectAccessorNode($captured);
                        }
                        $this->splitter->switch($restore);
                        return $arguments->toArrayNode();
                    } elseif ($callDetected) {
                        // The first-priority check is for a ViewHelper used right before the inline expression ends,
                        // in which case there is no further syntax to come.
                        $arguments->validate();
                        $node = $node->onOpen($this->renderingContext)->onClose($this->renderingContext);
                        $interceptionPoint = self::INTERCEPT_SELFCLOSING_VIEWHELPER;
                    } elseif ($this->splitter->context->context === Context::CONTEXT_PROTECTED || ($hasWhitespace && !$callDetected && !$hasPass)) {
                        // In order to qualify for potentially being an expression, the entire inline node must contain
                        // whitespace, must not contain parenthesis, must not contain a colon and must not contain an
                        // inline pass operand. This significantly limits the number of times this (expensive) routine
                        // has to be executed.
                        $parts[] = $captured;
                        try {
                            foreach ($this->renderingContext->getExpressionNodeTypes() as $expressionNodeTypeClassName) {
                                if ($expressionNodeTypeClassName::matches($parts)) {
                                    $childNodeToAdd = new $expressionNodeTypeClassName($parts);
                                    $childNodeToAdd = $this->callInterceptor($childNodeToAdd, self::INTERCEPT_EXPRESSION);
                                    break;
                                }
                            }
                        } catch (ExpressionException $exception) {
                            // ErrorHandler will either return a string or throw the exception anew, depending on the
                            // exact implementation of ErrorHandlerInterface. When it returns a string we use that as
                            // text content of a new TextNode so the message is output as part of the rendered result.
                            $childNodeToAdd = new TextNode(
                                $this->renderingContext->getErrorHandler()->handleExpressionError($exception)
                            );
                        }
                        $node = $childNodeToAdd ?? ($node ?? new RootNode())->addChild(new TextNode($text));
                        return $node;
                    } elseif (!$hasPass && !$callDetected) {
                        $node = $node ?? new ObjectAccessorNode();
                        if ($potentialAccessor !== '') {
                            $node->addChild(new TextNode((string) $potentialAccessor));
                        }
                    } elseif ($hasPass && $this->resolver->isAliasRegistered((string) $potentialAccessor)) {
                        // Fourth priority check is for a pass to a ViewHelper alias, e.g. "{value | raw}" in which case
                        // we look for the alias used and create a ViewHelper with no arguments.
                        $childNodeToAdd = $node;
                        $node = $this->resolver->createViewHelperInstance(null, (string) $potentialAccessor);
                        $arguments = $node->getArguments()->validate()->setRenderingContext($this->renderingContext);

$arguments is not used, you could remove the assignment.

                        $node = $node->onOpen($this->renderingContext);
                        $node->addChild($childNodeToAdd);
                        $node->onClose(
                            $this->renderingContext
                        );
                        $interceptionPoint = self::INTERCEPT_SELFCLOSING_VIEWHELPER;
                    } else {
                        # TODO: should this be an error case, or should it result in a TextNode?
                        throw $this->createErrorAtPosition(
                            'Invalid inline syntax - not accessor, not expression, not array, not ViewHelper, but ' .
                            'contains the tokens used by these in a sequence that is not valid Fluid syntax. You can ' .
                            'most likely avoid this by adding whitespace inside the curly braces before the first ' .
                            'Fluid-like symbol in the expression. Symbols recognized as Fluid are: "' .
                            addslashes(implode('","', array_map('chr', $this->contexts->inline->bytes))) . '"',
                            1558782228
                        );
                    }

                    $node = $this->callInterceptor($node, $interceptionPoint);
                    $this->splitter->switch($restore);
                    return $node;
            }
        }

        // See note in sequenceTagNode() end of method body. TL;DR: this is intentionally here instead of as "default"
        // case in the switch above for a very specific reason: the case is only encountered if seeing EOF before the
        // inline expression was closed.
        throw $this->createErrorAtPosition('Unterminated inline syntax', 1557838506);
    }

}