16321661677

Committed 16 Jul 2025 01:41PM UTC coverage: 94.38% (+0.6%) from 93.814%

Build Type

push

github

Committed by

Commit Message

Filter |escape is globally forbidden

To avoid problems with automatic and forced escaping

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

39 existing lines in 5 files now uncovered.

5223 of 5534 relevant lines covered (94.38%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.88

/src/Latte/Compiler/TemplateParserHtml.php

<?php

/**
 * This file is part of the Latte (https://latte.nette.org)
 * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
 */

declare(strict_types=1);

namespace Latte\Compiler;

use Latte;
use Latte\CompileException;
use Latte\Compiler\Nodes\AreaNode;
use Latte\Compiler\Nodes\FragmentNode;
use Latte\Compiler\Nodes\Html;
use Latte\ContentType;
use Latte\Helpers;
use Latte\SecurityViolationException;
use function array_keys, array_pop, end, implode, in_array, key, preg_replace, str_starts_with, strlen, substr;


/**
 * Template parser extension for HTML.
 */
final class TemplateParserHtml
{
        /** @var array<string, callable(Tag, TemplateParser): (Node|\Generator|void)> */
        private array /*readonly*/ $attrParsers;
        private ?Html\ElementNode $element = null;
        private TemplateParser /*readonly*/ $parser;

        /** @var array{string, ?Nodes\Php\ExpressionNode} */
        private ?array $endName = null;

        /** @var \WeakMap<Html\ElementNode, object{tag: mixed, textualName: string, unclosedTags?: array<string>}> */
        private \WeakMap $elementData;


        public function __construct(TemplateParser $parser, array $attrParsers)
        {
                $this->parser = $parser;
                $this->attrParsers = $attrParsers;
                $this->elementData = new \WeakMap;
        }


        public function getElement(): ?Html\ElementNode
        {
                return $this->element;
        }


        public function inTextResolve(): ?Node
        {
                $stream = $this->parser->getStream();
                $token = $stream->peek();
                return match ($token->type) {
                        Token::Html_TagOpen => $this->parseTag(),
                        Token::Html_CommentOpen => $this->parseComment(),
                        Token::Html_BogusOpen => $this->parseBogusTag(),
                        default => $this->parser->inTextResolve(),
                };
        }


        public function inTagResolve(): ?Node
        {
                $stream = $this->parser->getStream();
                $token = $stream->peek();
                return match ($token->type) {
                        Token::Html_Name => str_starts_with($token->text, TemplateLexer::NPrefix)
                                ? $this->parseNAttribute()
                                : $this->parseAttribute(),
                        Token::Latte_TagOpen => $this->parseAttribute(),
                        Token::Whitespace => $this->parseAttributeWhitespace(),
                        Token::Html_TagClose => null,
                        default => $this->parser->inTextResolve(),
                };
        }


        private function parseTag(): ?Node
        {
                $stream = $this->parser->getStream();
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);
                if (!$stream->peek(1)?->is(Token::Slash)) {
                        return $this->parseElement();
                }

                if ($this->element
                        && $this->parser->peekTag() === $this->elementData[$this->element]->tag // is directly in the element
                ) {
                        $save = $stream->getIndex();
                        $this->endName = [$endText] = $this->parseEndTag();
                        if ($this->element->is($endText) || $this->elementData[$this->element]->textualName === $endText) {
                                return null; // go to parseElement() one level up to close the element
                        }
                        $stream->seek($save);
                        if (!in_array($endText, $this->elementData[$this->element]->unclosedTags ?? [], true)) {
                                return null; // go to parseElement() one level up to collapse
                        }
                }

                if ($this->parser->strict) {
                        $stream->throwUnexpectedException(excerpt: '/');
                }
                return $this->parseBogusEndTag();
        }


        private function parseElement(): Node
        {
                $res = new FragmentNode;
                $res->append($this->extractIndentation());
                $res->append($this->parseStartTag($this->element));
                $elem = $this->element;

                $stream = $this->parser->getStream();
                $void = $this->resolveVoidness($elem);
                $attrs = $this->prepareNAttrs($elem->nAttributes, $void);
                $outerNodes = $this->openNAttrNodes($attrs[Tag::PrefixNone] ?? []);
                $tagNodes = $this->openNAttrNodes($attrs[Tag::PrefixTag] ?? []);
                $elem->tagNode = $this->finishNAttrNodes($elem->tagNode, $tagNodes);
                $elem->captureTagName = (bool) $tagNodes;

                if (!$void) {
                        $content = new FragmentNode;
                        if ($token = $stream->tryConsume(Token::Newline)) {
                                $content->append(new Nodes\TextNode($token->text, $token->position));
                        }

                        $innerNodes = $this->openNAttrNodes($attrs[Tag::PrefixInner] ?? []);
                        $this->elementData[$elem]->tag = $this->parser->peekTag();
                        $frag = $this->parser->parseFragment($this->inTextResolve(...));
                        $content->append($this->finishNAttrNodes($frag, $innerNodes));

                        [$endText, $endVariable] = $this->endName;
                        $this->endName = null;
                        if ($endText && ($this->element->is($endText) || $this->elementData[$this->element]->textualName === $endText)) {
                                $elem->content = $content;
                                $elem->content->append($this->extractIndentation());

                        } elseif ($outerNodes || $innerNodes || $tagNodes
                                || $this->parser->strict
                                || $elem->variableName
                                || $endVariable
                                || $elem->isRawText()
                        ) {
                                $stream->throwUnexpectedException(
                                        addendum: ", expecting </{$this->elementData[$elem]->textualName}> for element started $elem->position",
                                        excerpt: $endText ? "/{$endText}>" : $stream->peek(1)?->text . $stream->peek(2)?->text,
                                );
                        } else { // element collapsed to tags
                                $res->append($content);
                                $this->element = $elem->parent;
                                if ($this->element && !$stream->is(Token::Html_TagOpen)) {
                                        $this->elementData[$this->element]->unclosedTags[] = $elem->name;
                                }
                                return $res;
                        }
                }

                if ($token = $stream->tryConsume(Token::Newline)) {
                        $res->append(new Nodes\TextNode($token->text, $token->position));
                }

                $res = $this->finishNAttrNodes($res, $outerNodes);
                $this->element = $elem->parent;
                return $res;
        }


        private function extractIndentation(): AreaNode
        {
                if ($this->parser->lastIndentation) {
                        $dolly = clone $this->parser->lastIndentation;
                        $this->parser->lastIndentation->content = '';
                        return $dolly;
                } else {
                        return new Nodes\NopNode;
                }
        }


        private function parseStartTag(&$elem = null): Html\ElementNode
        {
                $stream = $this->parser->getStream();
                $openToken = $stream->consume(Token::Html_TagOpen);
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);

                [$textual, $variable] = $this->parseTagName($this->parser->strict);
                if (($this->parser->strict || $variable)
                        && !$stream->is(Token::Whitespace, Token::Slash, Token::Html_TagClose)
                ) {
                        throw $stream->throwUnexpectedException();
                }

                $this->parser->lastIndentation = null;
                $this->parser->inHead = false;
                $elem = new Html\ElementNode(
                        name: $variable ? '' : $textual,
                        position: $openToken->position,
                        parent: $this->element,
                        contentType: $this->parser->getContentType(),
                );
                $this->elementData[$elem] = (object) [
                        'tag' => $this->parser->peekTag(),
                        'textualName' => $textual,
                ];
                $elem->attributes = $this->parser->parseFragment($this->inTagResolve(...));
                $elem->selfClosing = (bool) $stream->tryConsume(Token::Slash);
                $elem->variableName = $variable;
                $stream->consume(Token::Html_TagClose);
                $state = !$elem->selfClosing && $elem->isRawText()
                        ? TemplateLexer::StateHtmlRawText
                        : TemplateLexer::StateHtmlText;
                $this->parser->getLexer()->setState($state, $elem->name);
                return $elem;
        }


        /** @return array{string, ?Nodes\Php\ExpressionNode} */
        private function parseEndTag(): array
        {
                $stream = $this->parser->getStream();
                $lexer = $this->parser->getLexer();
                $stream->consume(Token::Html_TagOpen);
                $lexer->setState(TemplateLexer::StateHtmlTag);
                $stream->consume(Token::Slash);
                if (isset($this->element->nAttributes['syntax'])) {  // hardcoded
                        $lexer->popSyntax();
                }
                $name = $this->parseTagName();
                $stream->tryConsume(Token::Whitespace);
                $stream->consume(Token::Html_TagClose);
                $lexer->setState(TemplateLexer::StateHtmlText);
                return $name;
        }


        /** @return array{string, ?Nodes\Php\ExpressionNode} */
        private function parseTagName(bool $strict = true): array
        {
                $variable = $text = null;
                $parts = [];
                $stream = $this->parser->getStream();
                do {
                        if ($stream->is(Token::Latte_TagOpen)) {
                                $save = $stream->getIndex();
                                $statement = $this->parser->parseLatteStatement($this->inTagResolve(...));
                                if (!$statement instanceof Nodes\PrintNode) {
                                        if (!$parts || $strict) {
                                                throw new CompileException('Only expression can be used as a HTML tag name.', $statement->position);
                                        }
                                        $stream->seek($save);
                                        break;
                                }
                                $parts[] = $statement->expression;
                                $save -= $stream->getIndex();
                                while ($save < 0) {
                                        $text .= $stream->peek($save++)->text;
                                }
                                $variable = true;

                        } elseif ($token = $stream->tryConsume(Token::Html_Name)) {
                                $parts[] = new Latte\Compiler\Nodes\Php\Scalar\StringNode($token->text, $token->position);
                                $text .= $token->text;

                        } elseif (!$parts) {
                                throw $stream->throwUnexpectedException([Token::Html_Name, Token::Latte_TagOpen]);
                        } else {
                                break;
                        }
                } while (true);

                $variable = $variable
                        ? Latte\Compiler\Nodes\Php\Expression\BinaryOpNode::nest('.', ...$parts)
                        : null;
                return [$text, $variable];
        }


        private function parseBogusEndTag(): ?Html\BogusTagNode
        {
                $stream = $this->parser->getStream();
                $openToken = $stream->consume(Token::Html_TagOpen);
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);
                $this->parser->lastIndentation = null;
                $this->parser->inHead = false;
                $node = new Html\BogusTagNode(
                        openDelimiter: $openToken->text . $stream->consume(Token::Slash)->text . $stream->consume(Token::Html_Name)->text,
                        content: new Nodes\TextNode($stream->tryConsume(Token::Whitespace)->text ?? ''),
                        endDelimiter: $stream->consume(Token::Html_TagClose)->text,
                        position: $openToken->position,
                );
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlText);
                return $node;
        }


        private function parseBogusTag(): Html\BogusTagNode
        {
                $stream = $this->parser->getStream();
                $openToken = $stream->consume(Token::Html_BogusOpen);
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlBogus);
                $this->parser->lastIndentation = null;
                $this->parser->inHead = false;
                $content = $this->parser->parseFragment($this->parser->inTextResolve(...));
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlText);
                return new Html\BogusTagNode(
                        openDelimiter: $openToken->text,
                        content: $content,
                        endDelimiter: $stream->consume(Token::Html_TagClose)->text,
                        position: $openToken->position,
                );
        }


        private function resolveVoidness(Html\ElementNode $elem): bool
        {
                if ($elem->contentType !== ContentType::Html) {
                        return $elem->selfClosing;
                } elseif (Latte\Runtime\HtmlHelpers::isVoidElement($elem->name)) {
                        return true;
                } elseif ($elem->selfClosing) { // auto-correct
                        $elem->content = new Nodes\NopNode;
                        $elem->selfClosing = false;
                        $last = end($elem->attributes->children);
                        if ($last instanceof Nodes\TextNode && $last->isWhitespace()) {
                                array_pop($elem->attributes->children);
                        }
                        return true;
                }

                return $elem->selfClosing;
        }


        private function parseAttributeWhitespace(): Node
        {
                $stream = $this->parser->getStream();
                $token = $stream->consume(Token::Whitespace);
                return $stream->is(Token::Html_Name) && str_starts_with($stream->peek()->text, TemplateLexer::NPrefix)
                        ? new Nodes\NopNode
                        : new Nodes\TextNode($token->text, $token->position);
        }


        private function parseAttribute(): ?Node
        {
                $stream = $this->parser->getStream();
                if ($stream->is(Token::Latte_TagOpen)) {
                        $name = $this->parser->parseLatteStatement();
                        if (!$name instanceof Nodes\PrintNode) {
                                return $name; // value like '<span {if true}attr1=val{/if}>'
                        }
                } else {
                        $name = $this->parser->parseText();
                }

                [$value, $quote] = $this->parseAttributeValue();
                return new Html\AttributeNode(
                        name: $name,
                        value: $value,
                        quote: $quote,
                        position: $name->position,
                );
        }


        private function parseAttributeValue(): ?array
        {
                $stream = $this->parser->getStream();
                $save = $stream->getIndex();
                $this->consumeIgnored();
                if (!$stream->tryConsume(Token::Equals)) {
                        $stream->seek($save);
                        return null;
                }

                $this->consumeIgnored();
                if ($quoteToken = $stream->tryConsume(Token::Quote)) {
                        $this->parser->getLexer()->setState(TemplateLexer::StateHtmlQuotedValue, $quoteToken->text);
                        $value = $this->parser->parseFragment($this->parser->inTextResolve(...))->simplify(allowsNull: false);
                        $stream->tryConsume(Token::Quote) || $stream->throwUnexpectedException([$quoteToken->text], addendum: ", end of HTML attribute started $quoteToken->position");
                        $this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);
                        return [$value, $quoteToken->text];
                }

                $value = $this->parser->parseFragment(
                        fn() => match ($stream->peek()->type) {
                                Token::Html_Name => $this->parser->parseText(),
                                Token::Latte_TagOpen => $this->parser->parseLatteStatement(),
                                Token::Latte_CommentOpen => $this->parser->parseLatteComment(),
                                default => null,
                        },
                )->simplify() ?? $stream->throwUnexpectedException();
                return [$value, null];
        }


        private function parseNAttribute(): Nodes\TextNode
        {
                $stream = $this->parser->getStream();
                $nameToken = $stream->consume(Token::Html_Name);
                $save = $stream->getIndex();
                $pos = $stream->peek()->position;
                $name = substr($nameToken->text, strlen(TemplateLexer::NPrefix));
                if ($this->parser->peekTag() !== $this->elementData[$this->element]->tag) {
                        throw new CompileException("Attribute n:$name must not appear inside {tags}", $nameToken->position);

                } elseif (isset($this->element->nAttributes[$name])) {
                        throw new CompileException("Found multiple attributes n:$name.", $nameToken->position);
                }

                $this->consumeIgnored();
                if ($stream->tryConsume(Token::Equals)) {
                        $this->consumeIgnored();
                        if ($quoteToken = $stream->tryConsume(Token::Quote)) {
                                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlQuotedNAttrValue, $quoteToken->text);
                                $valueToken = $stream->tryConsume(Token::Text);
                                $pos = $stream->peek()->position;
                                $stream->tryConsume(Token::Quote) || $stream->throwUnexpectedException([$quoteToken->text], addendum: ", end of n:attribute started $quoteToken->position");
                                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);
                        } else {
                                $valueToken = $stream->consume(Token::Html_Name);
                        }
                        if ($valueToken) {
                                $tokens = (new TagLexer)->tokenize($valueToken->text, $valueToken->position);
                        }
                } else {
                        $stream->seek($save);
                }
                $tokens ??= [new Token(Token::End, '', $pos)];

                $this->element->nAttributes[$name] = new Tag(
                        name: preg_replace('~(inner-|tag-|)~', '', $name),
                        tokens: $tokens,
                        position: $nameToken->position,
                        prefix: $this->getPrefix($name),
                        inTag: true,
                        htmlElement: $this->element,
                        nAttributeNode: $node = new Nodes\TextNode(''),
                );
                return $node;
        }


        private function parseComment(): Html\CommentNode
        {
                $this->parser->lastIndentation = null;
                $this->parser->inHead = false;
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlComment);
                $stream = $this->parser->getStream();
                $openToken = $stream->consume(Token::Html_CommentOpen);
                $node = new Html\CommentNode(
                        position: $openToken->position,
                        content: $this->parser->parseFragment($this->parser->inTextResolve(...)),
                );
                $stream->tryConsume(Token::Html_CommentClose) || $stream->throwUnexpectedException([Token::Html_CommentClose], addendum: " started $openToken->position");
                $this->parser->getLexer()->setState(TemplateLexer::StateHtmlText);
                return $node;
        }


        private function consumeIgnored(): void
        {
                $stream = $this->parser->getStream();
                do {
                        if ($stream->tryConsume(Token::Whitespace)) {
                                continue;
                        }
                        if ($stream->tryConsume(Token::Latte_CommentOpen)) {
                                $this->parser->getLexer()->pushState(TemplateLexer::StateLatteComment);
                                $stream->consume(Token::Text);
                                $stream->consume(Token::Latte_CommentClose);
                                $this->parser->getLexer()->popState();
                                $stream->tryConsume(Token::Newline);
                                continue;
                        }
                        return;
                } while (true);
        }


        private function prepareNAttrs(array $attrs, bool $void): array
        {
                $res = [];
                foreach ($this->attrParsers as $name => $foo) {
                        if ($tag = $attrs[$name] ?? null) {
                                $prefix = $this->getPrefix($name);
                                if (!$prefix || !$void) {
                                        $res[$prefix][] = $tag;
                                        unset($attrs[$name]);
                                }
                        }
                }

                if ($attrs) {
                        $hint = Helpers::getSuggestion(array_keys($this->attrParsers), $k = key($attrs));
                        throw new CompileException('Unexpected attribute n:'
                                . ($hint ? "$k, did you mean n:$hint?" : implode(' and n:', array_keys($attrs))), $attrs[$k]->position);
                }

                return $res;
        }


        /**
         * @param  array<Tag>  $toOpen
         * @return array<array{\Generator, Tag}>
         */
        private function openNAttrNodes(array $toOpen): array
        {
                $toClose = [];
                foreach ($toOpen as $tag) {
                        $parser = $this->getAttrParser($tag->name, $tag->position);
                        $this->parser->pushTag($tag);
                        $res = $parser($tag, $this->parser);
                        if ($res instanceof \Generator && $res->valid()) {
                                $toClose[] = [$res, $tag];

                        } elseif ($res instanceof AreaNode) {
                                $this->parser->ensureIsConsumed($tag);
                                $res->position = $tag->position;
                                $tag->replaceNAttribute($res);
                                $this->parser->popTag();

                        } elseif (!$res) {
                                $this->parser->ensureIsConsumed($tag);
                                $this->parser->popTag();

                        } else {
                                throw new CompileException("Unexpected value returned by {$tag->getNotation()} parser.", $tag->position);
                        }
                }

                return $toClose;
        }


        /** @param  array<array{\Generator, Tag}>  $toClose */
        private function finishNAttrNodes(AreaNode $node, array $toClose): AreaNode
        {
                while ([$gen, $tag] = array_pop($toClose)) {
                        $gen->send([$node, null]);
                        $node = $gen->getReturn();
                        $node->position = $tag->position;
                        $this->parser->popTag();
                        $this->parser->ensureIsConsumed($tag);
                }

                return $node;
        }


        /** @return callable(Tag, TemplateParser): (Node|\Generator|void) */
        private function getAttrParser(string $name, Position $pos): callable
        {
                if (!isset($this->attrParsers[$name])) {
                        $hint = ($t = Helpers::getSuggestion(array_keys($this->attrParsers), $name))
                                ? ", did you mean n:$t?"
                                : '';
                        throw new CompileException("Unknown n:{$name}{$hint}", $pos);
                } elseif (!$this->parser->isTagAllowed($name)) {
                        throw new SecurityViolationException("Attribute n:$name is not allowed", $pos);
                }
                return $this->attrParsers[$name];
        }


        private function getPrefix(string $name): string
        {
                return match (true) {
                        str_starts_with($name, 'inner-') => Tag::PrefixInner,
                        str_starts_with($name, 'tag-') => Tag::PrefixTag,
                        default => Tag::PrefixNone,
                };
        }
}

1	<?php
2
3	/**
4	* This file is part of the Latte (https://latte.nette.org)
5	* Copyright (c) 2008 David Grudl (https://davidgrudl.com)
6	*/
7
8	declare(strict_types=1);
9
10	namespace Latte\Compiler;
11
12	use Latte;
13	use Latte\CompileException;
14	use Latte\Compiler\Nodes\AreaNode;
15	use Latte\Compiler\Nodes\FragmentNode;
16	use Latte\Compiler\Nodes\Html;
17	use Latte\ContentType;
18	use Latte\Helpers;
19	use Latte\SecurityViolationException;
20	use function array_keys, array_pop, end, implode, in_array, key, preg_replace, str_starts_with, strlen, substr;
21
22
23	/**
24	* Template parser extension for HTML.
25	*/
26	final class TemplateParserHtml
27	{
28	/** @var array<string, callable(Tag, TemplateParser): (Node\|\Generator\|void)> */
29	private array /readonly/ $attrParsers;
30	private ?Html\ElementNode $element = null;
31	private TemplateParser /readonly/ $parser;
32
33	/** @var array{string, ?Nodes\Php\ExpressionNode} */
34	private ?array $endName = null;
35
36	/** @var \WeakMap<Html\ElementNode, object{tag: mixed, textualName: string, unclosedTags?: array<string>}> */
37	private \WeakMap $elementData;
38
39
40	public function __construct(TemplateParser $parser, array $attrParsers)	1✔
41	{
42	$this->parser = $parser;	1✔
43	$this->attrParsers = $attrParsers;	1✔
44	$this->elementData = new \WeakMap;	1✔
45	}	1✔
46
47
48	public function getElement(): ?Html\ElementNode
49	{
50	return $this->element;	1✔
51	}
52
53
54	public function inTextResolve(): ?Node
55	{
56	$stream = $this->parser->getStream();	1✔
57	$token = $stream->peek();	1✔
58	return match ($token->type) {	1✔
59	Token::Html_TagOpen => $this->parseTag(),	1✔
60	Token::Html_CommentOpen => $this->parseComment(),	1✔
61	Token::Html_BogusOpen => $this->parseBogusTag(),	1✔
62	default => $this->parser->inTextResolve(),	1✔
63	};
64	}
65
66
67	public function inTagResolve(): ?Node
68	{
69	$stream = $this->parser->getStream();	1✔
70	$token = $stream->peek();	1✔
71	return match ($token->type) {	1✔
72	Token::Html_Name => str_starts_with($token->text, TemplateLexer::NPrefix)	1✔
73	? $this->parseNAttribute()	1✔
74	: $this->parseAttribute(),	1✔
75	Token::Latte_TagOpen => $this->parseAttribute(),	1✔
76	Token::Whitespace => $this->parseAttributeWhitespace(),	1✔
77	Token::Html_TagClose => null,	1✔
78	default => $this->parser->inTextResolve(),	1✔
79	};
80	}
81
82
83	private function parseTag(): ?Node
84	{
85	$stream = $this->parser->getStream();	1✔
86	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);	1✔
87	if (!$stream->peek(1)?->is(Token::Slash)) {	1✔
88	return $this->parseElement();	1✔
89	}
90
91	if ($this->element	1✔
92	&& $this->parser->peekTag() === $this->elementData[$this->element]->tag // is directly in the element	1✔
93	) {
94	$save = $stream->getIndex();	1✔
95	$this->endName = [$endText] = $this->parseEndTag();	1✔
96	if ($this->element->is($endText) \|\| $this->elementData[$this->element]->textualName === $endText) {	1✔
97	return null; // go to parseElement() one level up to close the element	1✔
98	}
99	$stream->seek($save);	1✔
100	if (!in_array($endText, $this->elementData[$this->element]->unclosedTags ?? [], true)) {	1✔
101	return null; // go to parseElement() one level up to collapse	1✔
102	}
103	}
104
105	if ($this->parser->strict) {	1✔
106	$stream->throwUnexpectedException(excerpt: '/');	1✔
107	}
108	return $this->parseBogusEndTag();	1✔
109	}
110
111
112	private function parseElement(): Node
113	{
114	$res = new FragmentNode;	1✔
115	$res->append($this->extractIndentation());	1✔
116	$res->append($this->parseStartTag($this->element));	1✔
117	$elem = $this->element;	1✔
118
119	$stream = $this->parser->getStream();	1✔
120	$void = $this->resolveVoidness($elem);	1✔
121	$attrs = $this->prepareNAttrs($elem->nAttributes, $void);	1✔
122	$outerNodes = $this->openNAttrNodes($attrs[Tag::PrefixNone] ?? []);	1✔
123	$tagNodes = $this->openNAttrNodes($attrs[Tag::PrefixTag] ?? []);	1✔
124	$elem->tagNode = $this->finishNAttrNodes($elem->tagNode, $tagNodes);	1✔
125	$elem->captureTagName = (bool) $tagNodes;	1✔
126
127	if (!$void) {	1✔
128	$content = new FragmentNode;	1✔
129	if ($token = $stream->tryConsume(Token::Newline)) {	1✔
130	$content->append(new Nodes\TextNode($token->text, $token->position));	1✔
131	}
132
133	$innerNodes = $this->openNAttrNodes($attrs[Tag::PrefixInner] ?? []);	1✔
134	$this->elementData[$elem]->tag = $this->parser->peekTag();	1✔
135	$frag = $this->parser->parseFragment($this->inTextResolve(...));	1✔
136	$content->append($this->finishNAttrNodes($frag, $innerNodes));	1✔
137
138	[$endText, $endVariable] = $this->endName;	1✔
139	$this->endName = null;	1✔
140	if ($endText && ($this->element->is($endText) \|\| $this->elementData[$this->element]->textualName === $endText)) {	1✔
141	$elem->content = $content;	1✔
142	$elem->content->append($this->extractIndentation());	1✔
143
144	} elseif ($outerNodes \|\| $innerNodes \|\| $tagNodes	1✔
145	\|\| $this->parser->strict	1✔
146	\|\| $elem->variableName	1✔
147	\|\| $endVariable	1✔
148	\|\| $elem->isRawText()	1✔
149	) {
150	$stream->throwUnexpectedException(	1✔
151	addendum: ", expecting </{$this->elementData[$elem]->textualName}> for element started $elem->position",	1✔
152	excerpt: $endText ? "/{$endText}>" : $stream->peek(1)?->text . $stream->peek(2)?->text,	1✔
153	);
154	} else { // element collapsed to tags
155	$res->append($content);	1✔
156	$this->element = $elem->parent;	1✔
157	if ($this->element && !$stream->is(Token::Html_TagOpen)) {	1✔
158	$this->elementData[$this->element]->unclosedTags[] = $elem->name;	1✔
159	}
160	return $res;	1✔
161	}
162	}
163
164	if ($token = $stream->tryConsume(Token::Newline)) {	1✔
165	$res->append(new Nodes\TextNode($token->text, $token->position));	1✔
166	}
167
168	$res = $this->finishNAttrNodes($res, $outerNodes);	1✔
169	$this->element = $elem->parent;	1✔
170	return $res;	1✔
171	}
172
173
174	private function extractIndentation(): AreaNode
175	{
176	if ($this->parser->lastIndentation) {	1✔
177	$dolly = clone $this->parser->lastIndentation;	1✔
178	$this->parser->lastIndentation->content = '';	1✔
179	return $dolly;	1✔
180	} else {
181	return new Nodes\NopNode;	1✔
182	}
183	}
184
185
186	private function parseStartTag(&$elem = null): Html\ElementNode
187	{
188	$stream = $this->parser->getStream();	1✔
189	$openToken = $stream->consume(Token::Html_TagOpen);	1✔
190	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);	1✔
191
192	[$textual, $variable] = $this->parseTagName($this->parser->strict);	1✔
193	if (($this->parser->strict \|\| $variable)	1✔
194	&& !$stream->is(Token::Whitespace, Token::Slash, Token::Html_TagClose)	1✔
195	) {
UNCOV 196	throw $stream->throwUnexpectedException();	×
197	}
198
199	$this->parser->lastIndentation = null;	1✔
200	$this->parser->inHead = false;	1✔
201	$elem = new Html\ElementNode(	1✔
202	name: $variable ? '' : $textual,	1✔
203	position: $openToken->position,	1✔
204	parent: $this->element,	1✔
205	contentType: $this->parser->getContentType(),	1✔
206	);
207	$this->elementData[$elem] = (object) [	1✔
208	'tag' => $this->parser->peekTag(),	1✔
209	'textualName' => $textual,	1✔
210	];
211	$elem->attributes = $this->parser->parseFragment($this->inTagResolve(...));	1✔
212	$elem->selfClosing = (bool) $stream->tryConsume(Token::Slash);	1✔
213	$elem->variableName = $variable;	1✔
214	$stream->consume(Token::Html_TagClose);	1✔
215	$state = !$elem->selfClosing && $elem->isRawText()	1✔
216	? TemplateLexer::StateHtmlRawText	1✔
217	: TemplateLexer::StateHtmlText;	1✔
218	$this->parser->getLexer()->setState($state, $elem->name);	1✔
219	return $elem;	1✔
220	}
221
222
223	/** @return array{string, ?Nodes\Php\ExpressionNode} */
224	private function parseEndTag(): array
225	{
226	$stream = $this->parser->getStream();	1✔
227	$lexer = $this->parser->getLexer();	1✔
228	$stream->consume(Token::Html_TagOpen);	1✔
229	$lexer->setState(TemplateLexer::StateHtmlTag);	1✔
230	$stream->consume(Token::Slash);	1✔
231	if (isset($this->element->nAttributes['syntax'])) { // hardcoded	1✔
232	$lexer->popSyntax();	1✔
233	}
234	$name = $this->parseTagName();	1✔
235	$stream->tryConsume(Token::Whitespace);	1✔
236	$stream->consume(Token::Html_TagClose);	1✔
237	$lexer->setState(TemplateLexer::StateHtmlText);	1✔
238	return $name;	1✔
239	}
240
241
242	/** @return array{string, ?Nodes\Php\ExpressionNode} */
243	private function parseTagName(bool $strict = true): array	1✔
244	{
245	$variable = $text = null;	1✔
246	$parts = [];	1✔
247	$stream = $this->parser->getStream();	1✔
248	do {
249	if ($stream->is(Token::Latte_TagOpen)) {	1✔
250	$save = $stream->getIndex();	1✔
251	$statement = $this->parser->parseLatteStatement($this->inTagResolve(...));	1✔
252	if (!$statement instanceof Nodes\PrintNode) {	1✔
253	if (!$parts \|\| $strict) {	1✔
254	throw new CompileException('Only expression can be used as a HTML tag name.', $statement->position);	1✔
255	}
256	$stream->seek($save);	1✔
257	break;	1✔
258	}
259	$parts[] = $statement->expression;	1✔
260	$save -= $stream->getIndex();	1✔
261	while ($save < 0) {	1✔
262	$text .= $stream->peek($save++)->text;	1✔
263	}
264	$variable = true;	1✔
265
266	} elseif ($token = $stream->tryConsume(Token::Html_Name)) {	1✔
267	$parts[] = new Latte\Compiler\Nodes\Php\Scalar\StringNode($token->text, $token->position);	1✔
268	$text .= $token->text;	1✔
269
270	} elseif (!$parts) {	1✔
UNCOV 271	throw $stream->throwUnexpectedException([Token::Html_Name, Token::Latte_TagOpen]);	×
272	} else {
273	break;	1✔
274	}
275	} while (true);	1✔
276
277	$variable = $variable	1✔
278	? Latte\Compiler\Nodes\Php\Expression\BinaryOpNode::nest('.', ...$parts)	1✔
279	: null;	1✔
280	return [$text, $variable];	1✔
281	}
282
283
284	private function parseBogusEndTag(): ?Html\BogusTagNode
285	{
286	$stream = $this->parser->getStream();	1✔
287	$openToken = $stream->consume(Token::Html_TagOpen);	1✔
288	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);	1✔
289	$this->parser->lastIndentation = null;	1✔
290	$this->parser->inHead = false;	1✔
291	$node = new Html\BogusTagNode(	1✔
292	openDelimiter: $openToken->text . $stream->consume(Token::Slash)->text . $stream->consume(Token::Html_Name)->text,	1✔
293	content: new Nodes\TextNode($stream->tryConsume(Token::Whitespace)->text ?? ''),	1✔
294	endDelimiter: $stream->consume(Token::Html_TagClose)->text,	1✔
295	position: $openToken->position,	1✔
296	);
297	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlText);	1✔
298	return $node;	1✔
299	}
300
301
302	private function parseBogusTag(): Html\BogusTagNode
303	{
304	$stream = $this->parser->getStream();	1✔
305	$openToken = $stream->consume(Token::Html_BogusOpen);	1✔
306	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlBogus);	1✔
307	$this->parser->lastIndentation = null;	1✔
308	$this->parser->inHead = false;	1✔
309	$content = $this->parser->parseFragment($this->parser->inTextResolve(...));	1✔
310	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlText);	1✔
311	return new Html\BogusTagNode(	1✔
312	openDelimiter: $openToken->text,	1✔
313	content: $content,
314	endDelimiter: $stream->consume(Token::Html_TagClose)->text,	1✔
315	position: $openToken->position,	1✔
316	);
317	}
318
319
320	private function resolveVoidness(Html\ElementNode $elem): bool	1✔
321	{
322	if ($elem->contentType !== ContentType::Html) {	1✔
323	return $elem->selfClosing;	1✔
324	} elseif (Latte\Runtime\HtmlHelpers::isVoidElement($elem->name)) {	1✔
325	return true;	1✔
326	} elseif ($elem->selfClosing) { // auto-correct	1✔
327	$elem->content = new Nodes\NopNode;	1✔
328	$elem->selfClosing = false;	1✔
329	$last = end($elem->attributes->children);	1✔
330	if ($last instanceof Nodes\TextNode && $last->isWhitespace()) {	1✔
331	array_pop($elem->attributes->children);	1✔
332	}
333	return true;	1✔
334	}
335
336	return $elem->selfClosing;	1✔
337	}
338
339
340	private function parseAttributeWhitespace(): Node
341	{
342	$stream = $this->parser->getStream();	1✔
343	$token = $stream->consume(Token::Whitespace);	1✔
344	return $stream->is(Token::Html_Name) && str_starts_with($stream->peek()->text, TemplateLexer::NPrefix)	1✔
345	? new Nodes\NopNode	1✔
346	: new Nodes\TextNode($token->text, $token->position);	1✔
347	}
348
349
350	private function parseAttribute(): ?Node
351	{
352	$stream = $this->parser->getStream();	1✔
353	if ($stream->is(Token::Latte_TagOpen)) {	1✔
354	$name = $this->parser->parseLatteStatement();	1✔
355	if (!$name instanceof Nodes\PrintNode) {	1✔
356	return $name; // value like '<span {if true}attr1=val{/if}>'	1✔
357	}
358	} else {
359	$name = $this->parser->parseText();	1✔
360	}
361
362	[$value, $quote] = $this->parseAttributeValue();	1✔
363	return new Html\AttributeNode(	1✔
364	name: $name,	1✔
365	value: $value,
366	quote: $quote,
367	position: $name->position,	1✔
368	);
369	}
370
371
372	private function parseAttributeValue(): ?array
373	{
374	$stream = $this->parser->getStream();	1✔
375	$save = $stream->getIndex();	1✔
376	$this->consumeIgnored();	1✔
377	if (!$stream->tryConsume(Token::Equals)) {	1✔
378	$stream->seek($save);	1✔
379	return null;	1✔
380	}
381
382	$this->consumeIgnored();	1✔
383	if ($quoteToken = $stream->tryConsume(Token::Quote)) {	1✔
384	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlQuotedValue, $quoteToken->text);	1✔
385	$value = $this->parser->parseFragment($this->parser->inTextResolve(...))->simplify(allowsNull: false);	1✔
386	$stream->tryConsume(Token::Quote) \|\| $stream->throwUnexpectedException([$quoteToken->text], addendum: ", end of HTML attribute started $quoteToken->position");	1✔
387	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);	1✔
388	return [$value, $quoteToken->text];	1✔
389	}
390
391	$value = $this->parser->parseFragment(	1✔
392	fn() => match ($stream->peek()->type) {	1✔
393	Token::Html_Name => $this->parser->parseText(),	1✔
394	Token::Latte_TagOpen => $this->parser->parseLatteStatement(),	1✔
395	Token::Latte_CommentOpen => $this->parser->parseLatteComment(),
396	default => null,	1✔
397	},	1✔
398	)->simplify() ?? $stream->throwUnexpectedException();	1✔
399	return [$value, null];	1✔
400	}
401
402
403	private function parseNAttribute(): Nodes\TextNode
404	{
405	$stream = $this->parser->getStream();	1✔
406	$nameToken = $stream->consume(Token::Html_Name);	1✔
407	$save = $stream->getIndex();	1✔
408	$pos = $stream->peek()->position;	1✔
409	$name = substr($nameToken->text, strlen(TemplateLexer::NPrefix));	1✔
410	if ($this->parser->peekTag() !== $this->elementData[$this->element]->tag) {	1✔
411	throw new CompileException("Attribute n:$name must not appear inside {tags}", $nameToken->position);	1✔
412
413	} elseif (isset($this->element->nAttributes[$name])) {	1✔
414	throw new CompileException("Found multiple attributes n:$name.", $nameToken->position);	1✔
415	}
416
417	$this->consumeIgnored();	1✔
418	if ($stream->tryConsume(Token::Equals)) {	1✔
419	$this->consumeIgnored();	1✔
420	if ($quoteToken = $stream->tryConsume(Token::Quote)) {	1✔
421	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlQuotedNAttrValue, $quoteToken->text);	1✔
422	$valueToken = $stream->tryConsume(Token::Text);	1✔
423	$pos = $stream->peek()->position;	1✔
424	$stream->tryConsume(Token::Quote) \|\| $stream->throwUnexpectedException([$quoteToken->text], addendum: ", end of n:attribute started $quoteToken->position");	1✔
425	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlTag);	1✔
426	} else {
427	$valueToken = $stream->consume(Token::Html_Name);	1✔
428	}
429	if ($valueToken) {	1✔
430	$tokens = (new TagLexer)->tokenize($valueToken->text, $valueToken->position);	1✔
431	}
432	} else {
433	$stream->seek($save);	1✔
434	}
435	$tokens ??= [new Token(Token::End, '', $pos)];	1✔
436
437	$this->element->nAttributes[$name] = new Tag(	1✔
438	name: preg_replace('~(inner-\|tag-\|)~', '', $name),	1✔
439	tokens: $tokens,
440	position: $nameToken->position,	1✔
441	prefix: $this->getPrefix($name),	1✔
442	inTag: true,	1✔
443	htmlElement: $this->element,	1✔
444	nAttributeNode: $node = new Nodes\TextNode(''),	1✔
445	);
446	return $node;	1✔
447	}
448
449
450	private function parseComment(): Html\CommentNode
451	{
452	$this->parser->lastIndentation = null;	1✔
453	$this->parser->inHead = false;	1✔
454	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlComment);	1✔
455	$stream = $this->parser->getStream();	1✔
456	$openToken = $stream->consume(Token::Html_CommentOpen);	1✔
457	$node = new Html\CommentNode(	1✔
458	position: $openToken->position,	1✔
459	content: $this->parser->parseFragment($this->parser->inTextResolve(...)),	1✔
460	);
461	$stream->tryConsume(Token::Html_CommentClose) \|\| $stream->throwUnexpectedException([Token::Html_CommentClose], addendum: " started $openToken->position");	1✔
462	$this->parser->getLexer()->setState(TemplateLexer::StateHtmlText);	1✔
463	return $node;	1✔
464	}
465
466
467	private function consumeIgnored(): void
468	{
469	$stream = $this->parser->getStream();	1✔
470	do {
471	if ($stream->tryConsume(Token::Whitespace)) {	1✔
472	continue;	1✔
473	}
474	if ($stream->tryConsume(Token::Latte_CommentOpen)) {	1✔
475	$this->parser->getLexer()->pushState(TemplateLexer::StateLatteComment);	1✔
476	$stream->consume(Token::Text);	1✔
477	$stream->consume(Token::Latte_CommentClose);	1✔
478	$this->parser->getLexer()->popState();	1✔
479	$stream->tryConsume(Token::Newline);	1✔
480	continue;	1✔
481	}
482	return;	1✔
483	} while (true);	1✔
484	}
485
486
487	private function prepareNAttrs(array $attrs, bool $void): array	1✔
488	{
489	$res = [];	1✔
490	foreach ($this->attrParsers as $name => $foo) {	1✔
491	if ($tag = $attrs[$name] ?? null) {	1✔
492	$prefix = $this->getPrefix($name);	1✔
493	if (!$prefix \|\| !$void) {	1✔
494	$res[$prefix][] = $tag;	1✔
495	unset($attrs[$name]);	1✔
496	}
497	}
498	}
499
500	if ($attrs) {	1✔
501	$hint = Helpers::getSuggestion(array_keys($this->attrParsers), $k = key($attrs));	1✔
502	throw new CompileException('Unexpected attribute n:'	1✔
503	. ($hint ? "$k, did you mean n:$hint?" : implode(' and n:', array_keys($attrs))), $attrs[$k]->position);	1✔
504	}
505
506	return $res;	1✔
507	}
508
509
510	/**
511	* @param array<Tag> $toOpen
512	* @return array<array{\Generator, Tag}>
513	*/
514	private function openNAttrNodes(array $toOpen): array	1✔
515	{
516	$toClose = [];	1✔
517	foreach ($toOpen as $tag) {	1✔
518	$parser = $this->getAttrParser($tag->name, $tag->position);	1✔
519	$this->parser->pushTag($tag);	1✔
520	$res = $parser($tag, $this->parser);	1✔
521	if ($res instanceof \Generator && $res->valid()) {	1✔
522	$toClose[] = [$res, $tag];	1✔
523
524	} elseif ($res instanceof AreaNode) {	1✔
525	$this->parser->ensureIsConsumed($tag);	1✔
526	$res->position = $tag->position;	1✔
527	$tag->replaceNAttribute($res);	1✔
528	$this->parser->popTag();	1✔
529
530	} elseif (!$res) {	1✔
531	$this->parser->ensureIsConsumed($tag);	1✔
532	$this->parser->popTag();	1✔
533
534	} else {
UNCOV 535	throw new CompileException("Unexpected value returned by {$tag->getNotation()} parser.", $tag->position);	×
536	}
537	}
538
539	return $toClose;	1✔
540	}
541
542
543	/** @param array<array{\Generator, Tag}> $toClose */
544	private function finishNAttrNodes(AreaNode $node, array $toClose): AreaNode	1✔
545	{
546	while ([$gen, $tag] = array_pop($toClose)) {	1✔
547	$gen->send([$node, null]);	1✔
548	$node = $gen->getReturn();	1✔
549	$node->position = $tag->position;	1✔
550	$this->parser->popTag();	1✔
551	$this->parser->ensureIsConsumed($tag);	1✔
552	}
553
554	return $node;	1✔
555	}
556
557
558	/** @return callable(Tag, TemplateParser): (Node\|\Generator\|void) */
559	private function getAttrParser(string $name, Position $pos): callable	1✔
560	{
561	if (!isset($this->attrParsers[$name])) {	1✔
UNCOV 562	$hint = ($t = Helpers::getSuggestion(array_keys($this->attrParsers), $name))	×
UNCOV 563	? ", did you mean n:$t?"	×
UNCOV 564	: '';	×
UNCOV 565	throw new CompileException("Unknown n:{$name}{$hint}", $pos);	×
566	} elseif (!$this->parser->isTagAllowed($name)) {	1✔
567	throw new SecurityViolationException("Attribute n:$name is not allowed", $pos);	1✔
568	}
569	return $this->attrParsers[$name];	1✔
570	}
571
572
573	private function getPrefix(string $name): string	1✔
574	{
575	return match (true) {
576	str_starts_with($name, 'inner-') => Tag::PrefixInner,	1✔
577	str_starts_with($name, 'tag-') => Tag::PrefixTag,	1✔
578	default => Tag::PrefixNone,	1✔
579	};
580	}
581	}

nette / latte / 16321661677

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous