14024978163

Committed 23 Mar 2025 05:55PM UTC coverage: 79.391% (-0.05%) from 79.441%

Build # 14024978163

Build Type

push

github

Committed by

web-flow

Commit Message

feat(view): cache Blade and Twig templates in internal storage (#1061)

Run Details

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

912 existing lines in 110 files now uncovered.

10478 of 13198 relevant lines covered (79.39%)

91.09 hits per line

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

94.31

/src/Tempest/View/src/Renderers/TempestViewCompiler.php

<?php

declare(strict_types=1);

namespace Tempest\View\Renderers;

use Dom\HTMLDocument;
use Dom\NodeList;
use Stringable;
use Tempest\Core\Kernel;
use Tempest\Discovery\DiscoveryLocation;
use Tempest\Mapper\Exceptions\ViewNotFound;
use Tempest\Support\Str\ImmutableString;
use Tempest\View\Attributes\AttributeFactory;
use Tempest\View\Element;
use Tempest\View\Elements\ElementFactory;
use Tempest\View\View;

use function Tempest\Support\arr;
use function Tempest\Support\Html\is_void_tag;
use function Tempest\Support\path;
use function Tempest\Support\str;

use const Dom\HTML_NO_DEFAULT_NS;

final readonly class TempestViewCompiler
{
    public const string TOKEN_PHP_OPEN = '<!--TOKEN_PHP_OPEN__';

    public const string TOKEN_PHP_SHORT_ECHO = '<!--TOKEN_PHP_SHORT_ECHO__';

    public const string TOKEN_PHP_CLOSE = '__TOKEN_PHP_CLOSE-->';

    public const array TOKEN_MAPPING = [
        '<?php' => self::TOKEN_PHP_OPEN,
        '<?=' => self::TOKEN_PHP_SHORT_ECHO,
        '?>' => self::TOKEN_PHP_CLOSE,
    ];

    public function __construct(
        private ElementFactory $elementFactory,
        private AttributeFactory $attributeFactory,
        private Kernel $kernel,
    ) {
    }

    public function compile(string|View $view): string
    {
        $this->elementFactory->setViewCompiler($this);

        // 1. Retrieve template
        $template = $this->retrieveTemplate($view);

        // 2. Parse as DOM
        $dom = $this->parseDom($template);

        // 3. Map to elements
        $elements = $this->mapToElements($dom);

        // 4. Apply attributes
        $elements = $this->applyAttributes($elements);

        // 5. Compile to PHP
        $compiled = $this->compileElements($elements);

        return $compiled;
    }

    private function retrieveTemplate(string|View $view): string
    {
        $path = ($view instanceof View) ? $view->path : $view;

        if (! str_ends_with($path, '.php')) {
            return $path;
        }

        $searchPathOptions = [
            $path,
        ];

        if ($view instanceof View && $view->relativeRootPath !== null) {
            $searchPathOptions[] = path($view->relativeRootPath, $path)->toString();
        }

        $searchPathOptions = [
            ...$searchPathOptions,
            ...arr($this->kernel->discoveryLocations)
                ->map(fn (DiscoveryLocation $discoveryLocation) => path($discoveryLocation->path, $path)->toString())
                ->toArray(),
        ];

        foreach ($searchPathOptions as $searchPath) {
            if (file_exists($searchPath)) {
                break;
            }
        }

        if (! file_exists($searchPath)) {
            throw new ViewNotFound($path);
        }

        return file_get_contents($searchPath);
    }

    private function parseDom(string $template): NodeList
    {
        $parserFlags = LIBXML_HTML_NOIMPLIED | LIBXML_NOERROR | HTML_NO_DEFAULT_NS;

        $template = str($template)
            // Convert self-closing and void tags
            ->replaceRegex(
                regex: '/<(?<element>\w[^<]*?)\/>/',
                replace: function (array $match) {
                    $element = str($match['element'])->trim();

                    if (is_void_tag($element)) {
                        // Void tags must not have a closing tag
                        return sprintf('<%s>', $element->toString());
                    }

                    // Other self-closing tags must get a proper closing tag
                    return sprintf(
                        '<%s></%s>',
                        $match['element'],
                        $element->before(' ')->toString(),
                    );
                },
            );

        // Find head nodes, these are parsed separately so that we skip HTML's head-parsing rules
        $headNodes = [];

        $headTemplate = $template->match('/<head>((.|\n)*?)<\/head>/')[1] ?? null;

        if ($headTemplate) {
            $headNodes = HTMLDocument::createFromString(
                source: $this->cleanupTemplate($headTemplate)->toString(),
                options: $parserFlags,
            )->childNodes;
        }

        $mainTemplate = $this->cleanupTemplate($template)
            // Cleanup head, we'll insert it after having parsed the DOM
            ->replaceRegex('/<head>((.|\n)*?)<\/head>/', '<head></head>');

        $dom = HTMLDocument::createFromString(
            source: $mainTemplate->toString(),
            options: $parserFlags,
        );

        // If we have head nodes and a head tag, we inject them back
        if (($headElement = $dom->getElementsByTagName('head')->item(0)) !== null) {
            foreach ($headNodes as $headNode) {
                $headElement->appendChild($dom->importNode($headNode, deep: true));
            }
        }

        return $dom->childNodes;
    }

    /**
     * @return Element[]
     */
    private function mapToElements(NodeList $nodes): array
    {
        $elements = [];

        foreach ($nodes as $node) {
            $element = $this->elementFactory->make($node);

            if ($element === null) {
                continue;
            }

            $elements[] = $element;
        }

        return $elements;
    }

    /**
     * @param Element[] $elements
     * @return Element[]
     */
    private function applyAttributes(array $elements): array
    {
        $appliedElements = [];

        $previous = null;

        foreach ($elements as $element) {
            $children = $this->applyAttributes($element->getChildren());

            $element
                ->setPrevious($previous)
                ->setChildren($children);

            foreach ($element->getAttributes() as $name => $value) {
                $attribute = $this->attributeFactory->make($element, $name);

                $element = $attribute->apply($element);

                if ($element === null) {
                    break;
                }
            }

            if ($element === null) {
                continue;
            }

            $appliedElements[] = $element;

            $previous = $element;
        }

        return $appliedElements;
    }

    /** @param \Tempest\View\Element[] $elements */
    private function compileElements(array $elements): string
    {
        $compiled = arr();

        foreach ($elements as $element) {
            $compiled[] = $element->compile();
        }

        return $compiled
            ->implode(PHP_EOL)
            // Unescape PHP tags
            ->replace(
                array_values(self::TOKEN_MAPPING),
                array_keys(self::TOKEN_MAPPING),
            )
            ->toString();
    }

    private function cleanupTemplate(string|Stringable $template): ImmutableString
    {
        return str($template)
            // Escape PHP tags
            ->replace(
                search: array_keys(self::TOKEN_MAPPING),
                replace: array_values(self::TOKEN_MAPPING),
            )
            // Convert self-closing tags
            ->replaceRegex(
                regex: '/<x-(?<element>.*?)\/>/',
                replace: function (array $match) {
                    $closingTag = str($match['element'])->before(' ')->toString();

                    return sprintf(
                        '<x-%s></x-%s>',
                        $match['element'],
                        $closingTag,
                    );
                },
            );
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Tempest\View\Renderers;
6
7	use Dom\HTMLDocument;
8	use Dom\NodeList;
9	use Stringable;
10	use Tempest\Core\Kernel;
11	use Tempest\Discovery\DiscoveryLocation;
12	use Tempest\Mapper\Exceptions\ViewNotFound;
13	use Tempest\Support\Str\ImmutableString;
14	use Tempest\View\Attributes\AttributeFactory;
15	use Tempest\View\Element;
16	use Tempest\View\Elements\ElementFactory;
17	use Tempest\View\View;
18
19	use function Tempest\Support\arr;
20	use function Tempest\Support\Html\is_void_tag;
21	use function Tempest\Support\path;
22	use function Tempest\Support\str;
23
24	use const Dom\HTML_NO_DEFAULT_NS;
25
26	final readonly class TempestViewCompiler
27	{
28	public const string TOKEN_PHP_OPEN = '<!--TOKEN_PHP_OPEN__';
29
30	public const string TOKEN_PHP_SHORT_ECHO = '<!--TOKEN_PHP_SHORT_ECHO__';
31
32	public const string TOKEN_PHP_CLOSE = '__TOKEN_PHP_CLOSE-->';
33
34	public const array TOKEN_MAPPING = [
35	'<?php' => self::TOKEN_PHP_OPEN,
36	'<?=' => self::TOKEN_PHP_SHORT_ECHO,
37	'?>' => self::TOKEN_PHP_CLOSE,
38	];
39
40	public function __construct(	116✔
41	private ElementFactory $elementFactory,
42	private AttributeFactory $attributeFactory,
43	private Kernel $kernel,
44	) {
45	}	116✔
46
47	public function compile(string\|View $view): string	110✔
48	{
49	$this->elementFactory->setViewCompiler($this);	110✔
50
51	// 1. Retrieve template
52	$template = $this->retrieveTemplate($view);	110✔
53
54	// 2. Parse as DOM
55	$dom = $this->parseDom($template);	110✔
56
57	// 3. Map to elements
58	$elements = $this->mapToElements($dom);	110✔
59
60	// 4. Apply attributes
61	$elements = $this->applyAttributes($elements);	110✔
62
63	// 5. Compile to PHP
64	$compiled = $this->compileElements($elements);	104✔
65
66	return $compiled;	104✔
67	}
68
69	private function retrieveTemplate(string\|View $view): string	110✔
70	{
71	$path = ($view instanceof View) ? $view->path : $view;	110✔
72
73	if (! str_ends_with($path, '.php')) {	110✔
74	return $path;	103✔
75	}
76
77	$searchPathOptions = [	15✔
78	$path,	15✔
79	];	15✔
80
81	if ($view instanceof View && $view->relativeRootPath !== null) {	15✔
82	$searchPathOptions[] = path($view->relativeRootPath, $path)->toString();	12✔
83	}
84
85	$searchPathOptions = [	15✔
86	...$searchPathOptions,	15✔
87	...arr($this->kernel->discoveryLocations)	15✔
88	->map(fn (DiscoveryLocation $discoveryLocation) => path($discoveryLocation->path, $path)->toString())	15✔
89	->toArray(),	15✔
90	];	15✔
91
92	foreach ($searchPathOptions as $searchPath) {	15✔
93	if (file_exists($searchPath)) {	15✔
94	break;	15✔
95	}
96	}
97
98	if (! file_exists($searchPath)) {	15✔
UNCOV 99	throw new ViewNotFound($path);	×
100	}
101
102	return file_get_contents($searchPath);	15✔
103	}
104
105	private function parseDom(string $template): NodeList	110✔
106	{
107	$parserFlags = LIBXML_HTML_NOIMPLIED \| LIBXML_NOERROR \| HTML_NO_DEFAULT_NS;	110✔
108
109	$template = str($template)	110✔
110	// Convert self-closing and void tags	110✔
111	->replaceRegex(	110✔
112	regex: '/<(?<element>\w[^<]*?)\/>/',	110✔
113	replace: function (array $match) {	110✔
114	$element = str($match['element'])->trim();	26✔
115
116	if (is_void_tag($element)) {	26✔
117	// Void tags must not have a closing tag
118	return sprintf('<%s>', $element->toString());	1✔
119	}
120
121	// Other self-closing tags must get a proper closing tag
122	return sprintf(	25✔
123	'<%s></%s>',	25✔
124	$match['element'],	25✔
125	$element->before(' ')->toString(),	25✔
126	);	25✔
127	},	110✔
128	);	110✔
129
130	// Find head nodes, these are parsed separately so that we skip HTML's head-parsing rules
131	$headNodes = [];	110✔
132
133	$headTemplate = $template->match('/<head>((.\|\n)*?)<\/head>/')[1] ?? null;	110✔
134
135	if ($headTemplate) {	110✔
136	$headNodes = HTMLDocument::createFromString(	18✔
137	source: $this->cleanupTemplate($headTemplate)->toString(),	18✔
138	options: $parserFlags,	18✔
139	)->childNodes;	18✔
140	}
141
142	$mainTemplate = $this->cleanupTemplate($template)	110✔
143	// Cleanup head, we'll insert it after having parsed the DOM	110✔
144	->replaceRegex('/<head>((.\|\n)*?)<\/head>/', '<head></head>');	110✔
145
146	$dom = HTMLDocument::createFromString(	110✔
147	source: $mainTemplate->toString(),	110✔
148	options: $parserFlags,	110✔
149	);	110✔
150
151	// If we have head nodes and a head tag, we inject them back
152	if (($headElement = $dom->getElementsByTagName('head')->item(0)) !== null) {	110✔
153	foreach ($headNodes as $headNode) {	18✔
154	$headElement->appendChild($dom->importNode($headNode, deep: true));	17✔
155	}
156	}
157
158	return $dom->childNodes;	110✔
159	}
160
161	/**
162	* @return Element[]
163	*/
164	private function mapToElements(NodeList $nodes): array	110✔
165	{
166	$elements = [];	110✔
167
168	foreach ($nodes as $node) {	110✔
169	$element = $this->elementFactory->make($node);	110✔
170
171	if ($element === null) {	110✔
172	continue;	26✔
173	}
174
175	$elements[] = $element;	110✔
176	}
177
178	return $elements;	110✔
179	}
180
181	/**
182	* @param Element[] $elements
183	* @return Element[]
184	*/
185	private function applyAttributes(array $elements): array	110✔
186	{
187	$appliedElements = [];	110✔
188
189	$previous = null;	110✔
190
191	foreach ($elements as $element) {	110✔
192	$children = $this->applyAttributes($element->getChildren());	110✔
193
194	$element	110✔
195	->setPrevious($previous)	110✔
196	->setChildren($children);	110✔
197
198	foreach ($element->getAttributes() as $name => $value) {	110✔
199	$attribute = $this->attributeFactory->make($element, $name);	90✔
200
201	$element = $attribute->apply($element);	90✔
202
203	if ($element === null) {	85✔
204	break;	13✔
205	}
206	}
207
208	if ($element === null) {	110✔
209	continue;	13✔
210	}
211
212	$appliedElements[] = $element;	110✔
213
214	$previous = $element;	110✔
215	}
216
217	return $appliedElements;	110✔
218	}
219
220	/** @param \Tempest\View\Element[] $elements */
221	private function compileElements(array $elements): string	104✔
222	{
223	$compiled = arr();	104✔
224
225	foreach ($elements as $element) {	104✔
226	$compiled[] = $element->compile();	104✔
227	}
228
229	return $compiled	104✔
230	->implode(PHP_EOL)	104✔
231	// Unescape PHP tags	104✔
232	->replace(	104✔
233	array_values(self::TOKEN_MAPPING),	104✔
234	array_keys(self::TOKEN_MAPPING),	104✔
235	)	104✔
236	->toString();	104✔
237	}
238
239	private function cleanupTemplate(string\|Stringable $template): ImmutableString	110✔
240	{
241	return str($template)	110✔
242	// Escape PHP tags	110✔
243	->replace(	110✔
244	search: array_keys(self::TOKEN_MAPPING),	110✔
245	replace: array_values(self::TOKEN_MAPPING),	110✔
246	)	110✔
247	// Convert self-closing tags	110✔
248	->replaceRegex(	110✔
249	regex: '/<x-(?<element>.*?)\/>/',	110✔
250	replace: function (array $match) {	110✔
UNCOV 251	$closingTag = str($match['element'])->before(' ')->toString();	×
252
UNCOV 253	return sprintf(	×
UNCOV 254	'<x-%s></x-%s>',	×
UNCOV 255	$match['element'],	×
UNCOV 256	$closingTag,	×
UNCOV 257	);	×
258	},	110✔
259	);	110✔
260	}
261	}

tempestphp / tempest-framework / 14024978163

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