divineniiquaye / flight-routing

src/Traits/CacheTrait.php

<?php declare(strict_types=1);

/*
 * This file is part of Flight Routing.
 *
 * PHP version 8.0 and above required
 *
 * @author    Divine Niiquaye Ibok <divineibok@gmail.com>
 * @copyright 2019 Divine Niiquaye Ibok (https://divinenii.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Flight\Routing\Traits;

use Flight\Routing\Handlers\ResourceHandler;
use Flight\Routing\RouteCollection;

/**
 * A default cache implementation for route match.
 *
 * @author Divine Niiquaye Ibok <divineibok@gmail.com>
 */
trait CacheTrait
{
    private ?string $cache = null;

    /**
     * @param string $path file path to store compiled routes
     */
    public function setCache(string $path): void
    {
        $this->cache = $path;
    }

    /**
     * A well php value formatter, better than (var_export).
     */
    public static function export(mixed $value, string $indent = ''): string
    {
        switch (true) {
            case [] === $value:
                return '[]';
            case \is_array($value):
                if (!($t = \count($value, \COUNT_RECURSIVE) > 15) && \array_is_list($value)) {
                    \array_walk($value, function ($v) use (&$t, $value) {
                        if (\count($value) > 1 && \is_string($v) && \strlen($v) > 100) {
                            $t = true;
                        }
                    });
                }

                $j = -1;
                $code = $t ? "[\n" : '[';
                $subIndent = $t ? $indent.'  ' : $indent = '';

                foreach ($value as $k => $v) {
                    $code .= $subIndent;

                    if (!\is_int($k) || $k !== ++$j) {
                        $code .= self::export($k, $subIndent).' => ';
                    }

                    $code .= self::export($v, $subIndent).($t ? ",\n" : ', ');
                }

                return \rtrim($code, ', ').$indent.']';
            case (\is_string($value) && (':' === $value[0] && ':' === $value[-1])):
                return \substr($value, 1, -1);
            case $value instanceof ResourceHandler:
                return $value::class.'('.self::export($value(''), $indent).')';
            case $value instanceof \stdClass:
                return '(object) '.self::export((array) $value, $indent);
            case $value instanceof RouteCollection:
                return $value::class.'::__set_state('.self::export([
                    'routes' => $value->getRoutes(),
                    'defaultIndex' => $value->count() - 1,
                    'sorted' => true,
                ], $indent).')';
            case \is_object($value):
                if (\method_exists($value, '__set_state')) {
                    return $value::class.'::__set_state('.self::export(
                        \array_merge(...\array_map(function (\ReflectionProperty $v) use ($value): array {
                            $v->setAccessible(true);

                            return [$v->getName() => $v->getValue($value)];
                        }, (new \ReflectionObject($value))->getProperties()))
                    );
                }

                return 'unserialize(\''.\serialize($value).'\')';
        }

        return \var_export($value, true);
    }

    protected function doCache(): RouteCollection
    {
        if (\is_array($a = @include $this->cache)) {
            $this->optimized = $a;

The property optimized does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            return $this->optimized[2] ??= $this->collection ?? new RouteCollection();
        }

        if (\is_callable($collection = $this->collection ?? new RouteCollection())) {
            $collection($collection = new RouteCollection());
            $collection->sort();
            $doCache = true;
        }

        if (!\is_dir($directory = \dirname($this->cache))) {

It seems like $this->cache can also be of type null; however, parameter $path of dirname() does only seem to accept string, maybe add an additional type check?

            @\mkdir($directory, 0775, true);

It seems like you do not handle an error condition for mkdir(). This can introduce security issues, and is generally not recommended.

        }

        try {
            return $collection;
        } finally {
            $dumpData = $this->buildCache($collection, $doCache ?? false);
            \file_put_contents($this->cache, "<?php // auto generated: AVOID MODIFYING\n\nreturn ".$dumpData.";\n");

It seems like $this->cache can also be of type null; however, parameter $filename of file_put_contents() does only seem to accept string, maybe add an additional type check?

            if (\function_exists('opcache_invalidate') && \filter_var(\ini_get('opcache.enable'), \FILTER_VALIDATE_BOOLEAN)) {
                @\opcache_invalidate($this->cache, true);

It seems like $this->cache can also be of type null; however, parameter $filename of opcache_invalidate() does only seem to accept string, maybe add an additional type check?

It seems like you do not handle an error condition for opcache_invalidate(). This can introduce security issues, and is generally not recommended.

            }

            $this->optimized = require $this->cache;
        }
    }

    protected function buildCache(RouteCollection $collection, bool $doCache): string
    {
        $dynamicRoutes = $dynamicVar = $staticRoutes = [];
        $dynamicString = ":static function (string \$path): ?array {\n      ";

        foreach ($collection->getRoutes() as $i => $route) {
            $trimmed = \preg_replace('/\W$/', '', $path = '/'.\ltrim($route['path'], '/'));

            if (\in_array($prefix = '/'.\ltrim($route['prefix'] ?? '/', '/') ?? '/', [$trimmed, $path], true)) {
                $staticRoutes[$trimmed ?: '/'][] = $i;
                continue;
            }
            [$path, $var] = $this->getCompiler()->compile($path, $route['placeholders'] ?? []);

It seems like getCompiler() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $path = \str_replace('\/', '/', \substr($path, 1 + \strpos($path, '^'), -(\strlen($path) - \strrpos($path, '$'))));

            if (($l = \array_key_last($dynamicRoutes)) && !\in_array($l, ['/', $prefix], true)) {
                for ($o = 0, $new = ''; $o < \strlen($prefix); ++$o) {
                    if ($prefix[$o] !== ($l[$o] ?? null)) {
                        break;
                    }
                    $new .= $l[$o];
                }

                if ($new && '/' !== $new) {
                    if ($l !== $new) {
                        $dynamicRoutes[$new] = $dynamicRoutes[$l];
                        unset($dynamicRoutes[$l]);
                    }
                    $prefix = $new;
                }
            }
            $dynamicRoutes[$prefix][] = \preg_replace('#\?(?|P<\w+>|<\w+>|\'\w+\')#', '', $path)."(*:{$i})";
            $dynamicVar[$i] = $var;
        }
        \ksort($staticRoutes, \SORT_NATURAL);
        \uksort($dynamicRoutes, fn (string $a, string $b): int => \in_array('/', [$a, $b], true) ? \strcmp($b, $a) : \strcmp($a, $b));

        foreach ($dynamicRoutes as $offset => $paths) {
            $numParts = \max(1, \round(($c = \count($paths)) / 30));
            $prefix = '/'.\ltrim($offset, '/');
            $indent = '      ';
            $chunks = self::export(\array_map(fn (array $p): string => "~^(?|".implode('|', $p).")$~", \array_chunk($paths, (int) \ceil($c / $numParts))), $indent);
            $dynamicString .= <<<PHP
            if (\str_starts_with(\$path, '$prefix')) { foreach($chunks as \$p) { if (!\preg_match(\$p, \$path, \$m)) continue; return [\$m]; }}
                  else
            PHP;
        }

        if (\str_ends_with($dynamicString, 'else')) {
            $dynamicString = \substr($dynamicString, 0, -4);
        }

        return self::export([$staticRoutes, [$dynamicString."return null;\n    }:", $dynamicVar], $doCache ? $collection : null]);
    }
}