Flux Capacitor: A runtime attribute cache for Flux components

composer.json

@@ -18,11 +18,20 @@
         "livewire/livewire": "^3.5.19",
         "laravel/prompts": "^0.1|^0.2|^0.3"
     },
+    "require-dev": {
+        "orchestra/testbench": "^9.2 || ^10.0",
+        "pestphp/pest": "^2"
+    },
     "autoload": {
         "psr-4": {
             "Flux\\": "src/"
         }
     },
+    "autoload-dev": {
+        "psr-4": {
+            "Flux\\Tests\\": "tests"
+        }
+    },
     "extra": {
         "laravel": {
             "providers": [
@@ -32,5 +41,10 @@
                 "Flux": "Flux\\Flux"
             }
         }
+    },
+    "config": {
+        "allow-plugins": {
+            "pestphp/pest-plugin": true
+        }
     }
 }

src/Compiler/ComponentCompiler.php

@@ -0,0 +1,159 @@
+<?php
+
+namespace Flux\Compiler;
+
+use Flux\Flux;
+use Illuminate\Support\Str;
+use Illuminate\View\Compilers\BladeCompiler;
+use Illuminate\View\Compilers\ComponentTagCompiler;
+
+class ComponentCompiler extends ComponentTagCompiler
+{
+    protected $isOptimizedComponent = false;
+
+    public $outputOptimizations = false;
+
+    protected $uncachedBuffer = [];
+
+    public function isFluxComponent($value)
+    {
+        return Str::startsWith(ltrim($value), ['@cached', '@optimized']);
+    }
+
+    protected function compileOptimizedComponent($value)
+    {
+        $this->isOptimizedComponent = true;
+
+        return OptimizedComponentCompiler::compile($value);
+    }
+
+    protected function compileComponent($value)
+    {
+        $value = $this->compileSetupComponent($value);
+        $value = $this->compileSetupDirective($value);
+        $value = $this->compileUncachedComponent($value);
+        $value = $this->compileUncachedDirective($value);
+
+        $value .= implode('', $this->uncachedBuffer);
+
+        $this->uncachedBuffer = [];
+
+        return $value;
+    }
+
+    protected function removeCacheFeatures($value)
+    {
+        $value = preg_replace('/(?<!@)@optimized/', '', $value);
+        $value = preg_replace('/(?<!@)@cached/', '', $value);
+
+        return $this->compileComponent($value);
+    }
+
+    public function compile($value)
+    {
+        if (! $value) {
+            return $value;
+        }
+
+        if (! $this->isFluxComponent($value)) {
+            return $value;
+        }
+
+        if (! $this->outputOptimizations) {
+            return $this->removeCacheFeatures($value);
+        }
+
+        $value = ltrim($value);
+
+        if (Str::startsWith($value, '@optimized')) {
+            $value = $this->compileOptimizedComponent($value);
+        }
+
+        if (! $this->isOptimizedComponent) {
+            $value = preg_replace('/(?<!@)@aware\(/', '@fluxAware(', $value);
+        }
+
+        return $this->compileComponent($value);
+    }
+
+    protected function compileSetup($content)
+    {
+        if (! $this->outputOptimizations) {
+            return $content;
+        }
+
+        return <<<PHP
+<?php
+    \Flux\Flux::cache()->registerSetup(function (\$__tmpComponentData) {
+        extract(\$__tmpComponentData);
+        \$__env = \$__env ?? view();
+        ?>{$content}<?php
+        unset(\$__tmpComponentData);
+        return get_defined_vars();
+    });
+    extract(\Flux\Flux::cache()->runCurrentComponentSetup(get_defined_vars()));
+?>
+PHP;
+    }
+
+    protected function compileUncached($content, $excludeExpression)
+    {
+        if (! $this->outputOptimizations) {
+            return $content;
+        }
+
+        $replacement = '__FLUX::SWAP_REPLACEMENT::'. Str::random();
+
+        if (strlen($excludeExpression) > 0) {
+            $this->uncachedBuffer[] = "<?php \Flux\Flux::cache()->exclude({$excludeExpression}); ?>";
+        }
+
+        return <<<PHP
+[FLUX_SWAP:BEGIN $replacement]
+$content
+[FLUX_SWAP:END]
+PHP;
+    }
+
+    protected function compileSetupComponent($value)
+    {
+        return preg_replace_callback('/<flux:setup(?:\s+([^>]+))?>(.*?)<\/flux:setup>/s', function ($matches) {
+            return $this->compileSetup(trim($matches[2]));
+        }, $value);
+    }
+
+    protected function compileUncachedComponent($value)
+    {
+        return preg_replace_callback('/<flux:uncached(?:\s+([^>]+))?>(.*?)<\/flux:uncached>/s', function ($matches) {
+            $excludeExpression = '';
+
+            if ($matches[1]) {
+                $attributes = $this->getAttributesFromAttributeString($matches[1]);
+
+                if (isset($attributes['exclude'])) {
+                    $variables = str(mb_substr($attributes['exclude'], 1, -1))
+                        ->explode(',')
+                        ->map(fn ($var) => "'{$var}'")
+                        ->implode(', ');
+                    $excludeExpression = '['.$variables.']';
+                }
+            }
+
+            return $this->compileUncached(trim($matches[2]), $excludeExpression);
+        }, $value);
+    }
+
+    protected function compileSetupDirective($value)
+    {
+        return preg_replace_callback('/@setup(?:\((.*?)\))?([\s\S]*?)@endsetup/s', function ($matches) {
+            return $this->compileSetup(trim($matches[2]));
+        }, $value);
+    }
+
+    protected function compileUncachedDirective($value)
+    {
+        return preg_replace_callback('/@uncached(?:\((.*?)\))?([\s\S]*?)@enduncached/s', function ($matches) {
+            return $this->compileUncached(trim($matches[2]), $matches[1] ?? '');
+        }, $value);
+    }
+}

src/Compiler/ComponentHashes.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Flux\Compiler;
+
+use Illuminate\View\Compilers\BladeCompiler;
+
+class ComponentHashes extends BladeCompiler
+{
+    public static function newComponentHash(string $component)
+    {
+        return parent::newComponentHash($component);
+    }
+
+    public static function popHash()
+    {
+        return array_pop(static::$componentHashStack);
+    }
+}

src/Compiler/FluxComponentDirectives.php

@@ -0,0 +1,143 @@
+<?php
+
+namespace Flux\Compiler;
+
+use Flux\Support\StrUtil;
+use Illuminate\Support\Str;
+use Illuminate\View\AnonymousComponent;
+
+class FluxComponentDirectives
+{
+    public static function compileFluxComponentClass($expression)
+    {
+        [$component, $alias, $data] = str_contains($expression, ',')
+            ? array_map('trim', explode(',', trim($expression, '()'), 3)) + ['', '', '']
+            : [trim($expression, '()'), '', ''];
+
+        $component = trim($component, '\'"');
+
+        $hash = ComponentHashes::newComponentHash(
+            $component === AnonymousComponent::class ? $component.':'.trim($alias, '\'"') : $component
+        );
+
+        if (Str::contains($component, ['::class', '\\'])) {
+            return static::compileClassComponentOpening($component, $alias, $data, $hash);
+        }
+
+        return "<?php \$__env->startComponent{$expression}; ?>";
+    }
+
+    public static function compileClassComponentOpening(string $component, string $alias, string $data, string $hash)
+    {
+        $componentData = $data ?: '[]';
+
+        return implode("\n", [
+            '<?php if (isset($component)) { $__componentOriginal'.$hash.' = $component; } ?>',
+            '<?php if (isset($attributes)) { $__attributesOriginal'.$hash.' = $attributes; } ?>',
+            '<?php $component = '.$component.'::resolve('.$data.' ?? [] + (isset($attributes) && $attributes instanceof Illuminate\View\ComponentAttributeBag ? $attributes->all() : [])); ?>',
+            '<?php $component->withName('.$alias.'); ?>',
+            '<?php if ($component->shouldRender()): ?>', /* START: RENDER */
+            '<?php $__env->startComponent($component->resolveView(), $component->data()); ?>',
+        ]);
+    }
+
+    public static function compileEndFluxComponentClass()
+    {
+        $hash = ComponentHashes::popHash();
+
+        return <<<PHP
+<?php
+    if (isset(\$__fluxCacheKey{$hash})) { \$__fluxCacheKeyOriginal{$hash} = \$__fluxCacheKey{$hash}; }
+    \$__componentRenderData{$hash} = \$__env->fluxComponentData();
+    \$__fluxCacheKey{$hash} = \Flux\Flux::cache()->key(\$component->componentName, \$__componentRenderData{$hash}, \$__env);
+    if (\$__fluxCacheKey{$hash} === null || \Flux\Flux::cache()->has(\$__fluxCacheKey{$hash}) === false): /* START: CACHE BLOCK */
+
+    \Flux\Flux::cache()->startObserving(\$component->componentName);
+    \$__fluxTmpOutput{$hash} = \$__env->renderFluxComponent(\$__componentRenderData{$hash});
+    \Flux\Flux::cache()->stopObserving(\$component->componentName);
+    \$__fluxCacheKey{$hash} = \Flux\Flux::cache()->key(\$component->componentName, \$__componentRenderData{$hash}, \$__env);
+
+    if (\$__fluxCacheKey{$hash} !== null) {
+        \Flux\Flux::cache()->put(\$component->componentName, \$__fluxCacheKey{$hash}, \$__fluxTmpOutput{$hash});
+        \$__fluxTmpOutput{$hash} = \Flux\Flux::cache()->swap(
+            \$component->componentName,
+            \$__fluxTmpOutput{$hash},
+            \Flux\Flux::cache()->runComponentSetup(\$component->componentName, \$__componentRenderData{$hash})
+        );
+    }
+
+    echo \$__fluxTmpOutput{$hash};
+    unset(\$__fluxTmpOutput{$hash});
+
+    else: /* ELSE: CACHE BLOCK */
+        \$__env->popFluxComponent();
+        \$__fluxTmpOutput{$hash} = \Flux\Flux::cache()->swap(
+            \$component->componentName,
+            \Flux\Flux::cache()->get(\$__fluxCacheKey{$hash}),
+            \Flux\Flux::cache()->runComponentSetup(\$component->componentName, \$__componentRenderData{$hash})
+        );
+        echo \$__fluxTmpOutput{$hash};
+
+        unset(\$__fluxTmpOutput{$hash});
+    endif; /* END: CACHE BLOCK */
+
+    endif; /* END: RENDER */
+
+
+    if (isset(\$__fluxCacheKey{$hash})) { unset(\$__fluxCacheKey{$hash}); }
+    if (isset(\$__fluxCacheKeyOriginal{$hash})) {
+        \$__fluxCacheKey{$hash} = \$__fluxCacheKeyOriginal{$hash};
+        unset(\$__fluxCacheKeyOriginal{$hash});
+    }
+    if (isset(\$__componentRenderData{$hash})) { unset(\$__componentRenderData{$hash}); }
+    if (isset(\$__attributesOriginal{$hash})) {
+        \$attributes = \$__attributesOriginal{$hash}; unset(\$__attributesOriginal{$hash});
+    }
+
+    if (isset(\$__componentOriginal{$hash})) {
+        \$component = \$__componentOriginal{$hash}; unset(\$__componentOriginal{$hash});
+    }
+?>
+PHP;
+    }
+
+    public static function compileCached($expression)
+    {
+        $expression = trim($expression);
+
+        while (Str::startsWith($expression, '(') && Str::endsWith($expression, ')')) {
+            $expression = trim(Str::substr($expression, 1, -1));
+        }
+
+        if (! $expression) {
+            return '<?php Flux::shouldCache(); ?>';
+        }
+
+        return <<<PHP
+<?php
+    Flux::shouldCache();
+    \$__fluxCacheOptions = $expression;
+
+    if (isset(\$__fluxCacheOptions['except'])) {
+        \$attributes = Flux::cache()->ignoreAttributes(\$__fluxCacheOptions['except'], get_defined_vars());
+    }
+
+    unset(\$__fluxCacheOptions);
+?>
+PHP;
+    }
+
+    public static function compileFluxAware($expression)
+    {
+        return "<?php foreach ({$expression} as \$__key => \$__value) {
+    \$__consumeVariable = is_string(\$__key) ? \$__key : \$__value;
+    if (is_string (\$__key)) {
+        \$\$__consumeVariable = \$__env->getConsumableComponentData(\$__key, \$__value);
+        \Flux\Flux::cache()->usesVariable(\$___key, \$\$__consumeVariable, \$__value);
+    } else {
+        \$\$__consumeVariable = \$__env->getConsumableComponentData(\$__value);
+        \Flux\Flux::cache()->usesVariable(\$__value, \$\$__consumeVariable);
+    }
+} ?>";
+    }
+}