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

57.75

/src/Tempest/Core/src/Kernel/LoadDiscoveryClasses.php

<?php

declare(strict_types=1);

namespace Tempest\Core\Kernel;

use FilesystemIterator;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use SplFileInfo;
use Tempest\Cache\DiscoveryCacheStrategy;
use Tempest\Container\Container;
use Tempest\Core\DiscoveryCache;
use Tempest\Core\DiscoveryDiscovery;
use Tempest\Core\Kernel;
use Tempest\Discovery\DiscoversPath;
use Tempest\Discovery\Discovery;
use Tempest\Discovery\DiscoveryItems;
use Tempest\Discovery\DiscoveryLocation;
use Tempest\Discovery\DoNotDiscover;
use Tempest\Reflection\ClassReflector;
use Throwable;

/** @internal */
final class LoadDiscoveryClasses
{
    private array $appliedDiscovery = [];

    public function __construct(
        private readonly Kernel $kernel,
        private readonly Container $container,
        private readonly DiscoveryCache $discoveryCache,
    ) {
    }

    public function __invoke(): void
    {
        $discoveries = $this->build();

        foreach ($discoveries as $discovery) {
            $this->applyDiscovery($discovery);
        }
    }

    /** @return Discovery[] */
    public function build(): array
    {
        // DiscoveryDiscovery needs to be applied before we can build all other discoveries
        $discoveryDiscovery = $this->buildDiscovery(DiscoveryDiscovery::class);
        $this->applyDiscovery($discoveryDiscovery);

        $builtDiscovery = [$discoveryDiscovery];

        foreach ($this->kernel->discoveryClasses as $discoveryClass) {
            $discovery = $this->buildDiscovery($discoveryClass);
            $builtDiscovery[] = $discovery;
        }

        return $builtDiscovery;
    }

    /**
     * Create a discovery instance from a class name.
     * Optionally set the cached discovery items whenever caching is enabled.
     */
    private function resolveDiscovery(string $discoveryClass): Discovery
    {
        /** @var Discovery $discovery */
        $discovery = $this->container->get($discoveryClass);

        if ($this->discoveryCache->isEnabled()) {
            $discovery->setItems(
                $this->discoveryCache->restore($discoveryClass) ?? new DiscoveryItems(),
            );
        } else {
            $discovery->setItems(new DiscoveryItems());
        }

        return $discovery;
    }

    /**
     * Build one specific discovery instance.
     */
    private function buildDiscovery(string $discoveryClass): Discovery
    {
        $discovery = $this->resolveDiscovery($discoveryClass);

        if ($this->discoveryCache->getStrategy() === DiscoveryCacheStrategy::FULL && $discovery->getItems()->isLoaded()) {
            return $discovery;
        }

        foreach ($this->kernel->discoveryLocations as $location) {
            if ($this->shouldSkipLocation($location)) {
                continue;
            }

            $directories = new RecursiveDirectoryIterator($location->path, FilesystemIterator::UNIX_PATHS | FilesystemIterator::SKIP_DOTS);
            $files = new RecursiveIteratorIterator($directories);

            /** @var SplFileInfo $file */
            foreach ($files as $file) {
                $fileName = $file->getFilename();
                if ($fileName === '') {
                    continue;
                }

                if ($fileName === '.') {
                    continue;
                }

                if ($fileName === '..') {
                    continue;
                }

                $input = $file->getPathname();

                // We assume that any PHP file that starts with an uppercase letter will be a class
                if ($file->getExtension() === 'php' && ucfirst($fileName) === $fileName) {
                    $className = $location->toClassName($file->getPathname());

                    // Discovery errors (syntax errors, missing imports, etc.)
                    // are ignored when they happen in vendor files,
                    // but they are allowed to be thrown in project code
                    if ($location->isVendor()) {
                        try {
                            $input = new ClassReflector($className);
                        } catch (Throwable) { // @mago-expect best-practices/no-empty-catch-clause
                        }
                    } elseif (class_exists($className)) {
                        $input = new ClassReflector($className);
                    }
                }

                if ($input instanceof ClassReflector) {
                    // If the input is a class, we'll call `discover`
                    if (! $this->shouldSkipDiscoveryForClass($discovery, $input)) {
                        $discovery->discover($location, $input);
                    }
                } elseif ($discovery instanceof DiscoversPath) {
                    // If the input is NOT a class, AND the discovery class can discover paths, we'll call `discoverPath`
                    $discovery->discoverPath($location, realpath($input));
                }
            }
        }

        return $discovery;
    }

    /**
     * Apply the discovered classes and files. Also store the discovered items into cache, if caching is enabled
     */
    private function applyDiscovery(Discovery $discovery): void
    {
        if ($this->appliedDiscovery[$discovery::class] ?? null) {
            return;
        }

        $discovery->apply();

        $this->appliedDiscovery[$discovery::class] = true;
    }

    /**
     * Check whether discovery for a specific class should be skipped based on the #[DoNotDiscover] attribute
     */
    private function shouldSkipDiscoveryForClass(Discovery $discovery, ClassReflector $input): bool
    {
        $attribute = $input->getAttribute(DoNotDiscover::class);

        if ($attribute === null) {
            return false;
        }

        return ! in_array($discovery::class, $attribute->except, strict: true);
    }

    /**
     * Check whether a discovery location should be skipped based on what's cached for a specific discovery class
     */
    private function shouldSkipLocation(DiscoveryLocation $location): bool
    {
        if (! $this->discoveryCache->isEnabled()) {
            return false;
        }

        return match ($this->discoveryCache->getStrategy()) {
            // If discovery cache is disabled, no locations should be skipped, all should always be discovered
            DiscoveryCacheStrategy::NONE, DiscoveryCacheStrategy::INVALID => false,
            // If discover cache is enabled, all locations cache should be skipped
            DiscoveryCacheStrategy::FULL => true,
            // If partial discovery cache is enabled, vendor locations cache should be skipped
            DiscoveryCacheStrategy::PARTIAL => $location->isVendor(),
        };
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Tempest\Core\Kernel;
6
7	use FilesystemIterator;
8	use RecursiveDirectoryIterator;
9	use RecursiveIteratorIterator;
10	use SplFileInfo;
11	use Tempest\Cache\DiscoveryCacheStrategy;
12	use Tempest\Container\Container;
13	use Tempest\Core\DiscoveryCache;
14	use Tempest\Core\DiscoveryDiscovery;
15	use Tempest\Core\Kernel;
16	use Tempest\Discovery\DiscoversPath;
17	use Tempest\Discovery\Discovery;
18	use Tempest\Discovery\DiscoveryItems;
19	use Tempest\Discovery\DiscoveryLocation;
20	use Tempest\Discovery\DoNotDiscover;
21	use Tempest\Reflection\ClassReflector;
22	use Throwable;
23
24	/** @internal */
25	final class LoadDiscoveryClasses
26	{
27	private array $appliedDiscovery = [];
28
29	public function __construct(	659✔
30	private readonly Kernel $kernel,
31	private readonly Container $container,
32	private readonly DiscoveryCache $discoveryCache,
33	) {
34	}	659✔
35
36	public function __invoke(): void	659✔
37	{
38	$discoveries = $this->build();	659✔
39
40	foreach ($discoveries as $discovery) {	659✔
41	$this->applyDiscovery($discovery);	659✔
42	}
43	}
44
45	/** @return Discovery[] */
46	public function build(): array	659✔
47	{
48	// DiscoveryDiscovery needs to be applied before we can build all other discoveries
49	$discoveryDiscovery = $this->buildDiscovery(DiscoveryDiscovery::class);	659✔
50	$this->applyDiscovery($discoveryDiscovery);	659✔
51
52	$builtDiscovery = [$discoveryDiscovery];	659✔
53
54	foreach ($this->kernel->discoveryClasses as $discoveryClass) {	659✔
55	$discovery = $this->buildDiscovery($discoveryClass);	659✔
56	$builtDiscovery[] = $discovery;	659✔
57	}
58
59	return $builtDiscovery;	659✔
60	}
61
62	/**
63	* Create a discovery instance from a class name.
64	* Optionally set the cached discovery items whenever caching is enabled.
65	*/
66	private function resolveDiscovery(string $discoveryClass): Discovery	659✔
67	{
68	/** @var Discovery $discovery */
69	$discovery = $this->container->get($discoveryClass);	659✔
70
71	if ($this->discoveryCache->isEnabled()) {	659✔
72	$discovery->setItems(	659✔
73	$this->discoveryCache->restore($discoveryClass) ?? new DiscoveryItems(),	659✔
74	);	659✔
75	} else {
UNCOV 76	$discovery->setItems(new DiscoveryItems());	×
77	}
78
79	return $discovery;	659✔
80	}
81
82	/**
83	* Build one specific discovery instance.
84	*/
85	private function buildDiscovery(string $discoveryClass): Discovery	659✔
86	{
87	$discovery = $this->resolveDiscovery($discoveryClass);	659✔
88
89	if ($this->discoveryCache->getStrategy() === DiscoveryCacheStrategy::FULL && $discovery->getItems()->isLoaded()) {	659✔
90	return $discovery;	659✔
91	}
92
93	foreach ($this->kernel->discoveryLocations as $location) {	659✔
94	if ($this->shouldSkipLocation($location)) {	659✔
95	continue;	659✔
96	}
97
UNCOV 98	$directories = new RecursiveDirectoryIterator($location->path, FilesystemIterator::UNIX_PATHS \| FilesystemIterator::SKIP_DOTS);	×
UNCOV 99	$files = new RecursiveIteratorIterator($directories);	×
100
101	/** @var SplFileInfo $file */
UNCOV 102	foreach ($files as $file) {	×
103	$fileName = $file->getFilename();	×
104	if ($fileName === '') {	×
UNCOV 105	continue;	×
106	}
107
108	if ($fileName === '.') {	×
109	continue;	×
110	}
111
UNCOV 112	if ($fileName === '..') {	×
113	continue;	×
114	}
115
UNCOV 116	$input = $file->getPathname();	×
117
118	// We assume that any PHP file that starts with an uppercase letter will be a class
UNCOV 119	if ($file->getExtension() === 'php' && ucfirst($fileName) === $fileName) {	×
UNCOV 120	$className = $location->toClassName($file->getPathname());	×
121
122	// Discovery errors (syntax errors, missing imports, etc.)
123	// are ignored when they happen in vendor files,
124	// but they are allowed to be thrown in project code
125	if ($location->isVendor()) {	×
126	try {
UNCOV 127	$input = new ClassReflector($className);	×
UNCOV 128	} catch (Throwable) { // @mago-expect best-practices/no-empty-catch-clause	×
129	}
130	} elseif (class_exists($className)) {	×
UNCOV 131	$input = new ClassReflector($className);	×
132	}
133	}
134
135	if ($input instanceof ClassReflector) {	×
136	// If the input is a class, we'll call `discover`
UNCOV 137	if (! $this->shouldSkipDiscoveryForClass($discovery, $input)) {	×
UNCOV 138	$discovery->discover($location, $input);	×
139	}
140	} elseif ($discovery instanceof DiscoversPath) {	×
141	// If the input is NOT a class, AND the discovery class can discover paths, we'll call `discoverPath`
142	$discovery->discoverPath($location, realpath($input));	×
143	}
144	}
145	}
146
147	return $discovery;	659✔
148	}
149
150	/**
151	* Apply the discovered classes and files. Also store the discovered items into cache, if caching is enabled
152	*/
153	private function applyDiscovery(Discovery $discovery): void	659✔
154	{
155	if ($this->appliedDiscovery[$discovery::class] ?? null) {	659✔
156	return;	659✔
157	}
158
159	$discovery->apply();	659✔
160
161	$this->appliedDiscovery[$discovery::class] = true;	659✔
162	}
163
164	/**
165	* Check whether discovery for a specific class should be skipped based on the #[DoNotDiscover] attribute
166	*/
UNCOV 167	private function shouldSkipDiscoveryForClass(Discovery $discovery, ClassReflector $input): bool	×
168	{
UNCOV 169	$attribute = $input->getAttribute(DoNotDiscover::class);	×
170
UNCOV 171	if ($attribute === null) {	×
172	return false;	×
173	}
174
UNCOV 175	return ! in_array($discovery::class, $attribute->except, strict: true);	×
176	}
177
178	/**
179	* Check whether a discovery location should be skipped based on what's cached for a specific discovery class
180	*/
181	private function shouldSkipLocation(DiscoveryLocation $location): bool	659✔
182	{
183	if (! $this->discoveryCache->isEnabled()) {	659✔
UNCOV 184	return false;	×
185	}
186
187	return match ($this->discoveryCache->getStrategy()) {	659✔
188	// If discovery cache is disabled, no locations should be skipped, all should always be discovered
189	DiscoveryCacheStrategy::NONE, DiscoveryCacheStrategy::INVALID => false,	659✔
190	// If discover cache is enabled, all locations cache should be skipped
191	DiscoveryCacheStrategy::FULL => true,	659✔
192	// If partial discovery cache is enabled, vendor locations cache should be skipped
193	DiscoveryCacheStrategy::PARTIAL => $location->isVendor(),	659✔
194	};	659✔
195	}
196	}

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