wip

Author: brendt

packages/core/src/Commands/DiscoveryClearCommand.php

@@ -4,16 +4,19 @@
 
 namespace Tempest\Core\Commands;
 
-use Tempest\Console\Console;
 use Tempest\Console\ConsoleCommand;
+use Tempest\Console\HasConsole;
+use Tempest\Discovery\ClearDiscoveryCache;
 use Tempest\Discovery\DiscoveryCache;
 
 if (class_exists(\Tempest\Console\ConsoleCommand::class)) {
     final readonly class DiscoveryClearCommand
     {
+        use HasConsole;
+
         public function __construct(
             private DiscoveryCache $discoveryCache,
-            private Console $console,
+            private ClearDiscoveryCache $clearDiscoveryCache,
         ) {}
 
         #[ConsoleCommand(
@@ -25,7 +28,7 @@ public function __invoke(): void
         {
             $this->console->task(
                 label: 'Clearing discovery cache',
-                handler: fn () => $this->discoveryCache->clear(),
+                handler: fn () => ($this->clearDiscoveryCache)($this->discoveryCache),
             );
         }
     }

packages/core/src/Commands/DiscoveryGenerateCommand.php

@@ -7,23 +7,28 @@
 use Closure;
 use Tempest\Console\ConsoleCommand;
 use Tempest\Console\HasConsole;
+use Tempest\Container\Container;
 use Tempest\Container\GenericContainer;
 use Tempest\Core\FrameworkKernel;
-use Tempest\Core\Kernel;
 use Tempest\Discovery\BootDiscovery;
+use Tempest\Discovery\ClearDiscoveryCache;
 use Tempest\Discovery\DiscoveryCache;
 use Tempest\Discovery\DiscoveryCacheStrategy;
 use Tempest\Discovery\DiscoveryConfig;
+use Tempest\Discovery\GenerateDiscoveryCache;
 
 if (class_exists(\Tempest\Console\ConsoleCommand::class)) {
     final readonly class DiscoveryGenerateCommand
     {
         use HasConsole;
 
         public function __construct(
-            private DiscoveryConfig $discoveryConfig,
             private FrameworkKernel $kernel,
+            private Container $container,
+            private DiscoveryConfig $discoveryConfig,
             private DiscoveryCache $discoveryCache,
+            private GenerateDiscoveryCache $generateDiscoveryCache,
+            private ClearDiscoveryCache $clearDiscoveryCache,
         ) {}
 
         #[ConsoleCommand(
@@ -41,20 +46,26 @@ public function __invoke(): void
                 return;
             }
 
-            $this->clearDiscoveryCache();
-
             $this->console->task(
-                label: "Generating discovery cache using the `{$strategy->value}` strategy",
-                handler: fn (Closure $log) => $this->generateDiscoveryCache($strategy, $log),
+                label: 'Clearing discovery cache',
+                handler: fn () => ($this->clearDiscoveryCache)($this->discoveryCache),
             );
-        }
 
-        public function clearDiscoveryCache(): void
-        {
-            $this->console->call(DiscoveryClearCommand::class);
+            $this->console->task(
+                label: "Generating {$strategy->value} discovery cache",
+                handler: function () use ($strategy) {
+                    $kernel = $this->resolveKernel();
+
+                    ($this->generateDiscoveryCache)(
+                        $kernel->container,
+                        $kernel->discoveryConfig,
+                        $this->discoveryCache->withStrategy($strategy),
+                    );
+                },
+            );
         }
 
-        public function generateDiscoveryCache(DiscoveryCacheStrategy $strategy, Closure $log): void
+        private function generateDiscoveryCache(DiscoveryCacheStrategy $strategy, Closure $log): void
         {
             $kernel = $this->resolveKernel();
 
@@ -74,7 +85,7 @@ public function generateDiscoveryCache(DiscoveryCacheStrategy $strategy, Closure
             $this->discoveryCache->storeStrategy($strategy);
         }
 
-        public function resolveKernel(): Kernel
+        private function resolveKernel(): FrameworkKernel
         {
             $container = new GenericContainer();
             $container->singleton(DiscoveryConfig::class, $this->discoveryConfig);
@@ -86,6 +97,7 @@ public function resolveKernel(): Kernel
             )
                 ->registerKernel()
                 ->loadComposer()
+                ->loadDiscoveryConfig()
                 ->loadConfig();
         }
     }

packages/discovery/src/ClearDiscoveryCache.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Tempest\Discovery;
+
+final class ClearDiscoveryCache
+{
+    public function __invoke(DiscoveryCache $cache): void
+    {
+        $cache->clear();
+    }
+}

packages/discovery/src/DiscoveryCache.php

@@ -23,14 +23,21 @@ final class DiscoveryCache
     }
 
     public function __construct(
-        private(set) DiscoveryCacheStrategy $strategy,
+        private(set) readonly DiscoveryCacheStrategy $strategy,
         private ?CacheItemPoolInterface $pool = null,
     ) {
         $this->pool = $pool ?? new PhpFilesAdapter(
             directory: self::getCachePath(),
         );
     }
 
+    public function withStrategy(DiscoveryCacheStrategy $strategy): self
+    {
+        return clone($this, [
+            'strategy' => $strategy,
+        ]);
+    }
+
     /**
      * @return array<class-string<\Tempest\Discovery\Discovery>, DiscoveryItems>
      */

packages/discovery/src/GenerateDiscoveryCache.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Tempest\Discovery;
+
+use Psr\Container\ContainerInterface;
+
+final class GenerateDiscoveryCache
+{
+    public function __invoke(
+        ContainerInterface $container,
+        DiscoveryConfig $config,
+        DiscoveryCache $cache,
+    ): void {
+        $bootDiscovery = new BootDiscovery(
+            container: $container,
+            config: $config,
+            cache: $cache->withStrategy(DiscoveryCacheStrategy::NONE),
+        );
+
+        $discoveries = $bootDiscovery->build();
+
+        foreach ($config->locations as $location) {
+            $cache->store($location, $discoveries);
+        }
+
+        $cache->storeStrategy($cache->strategy);
+    }
+}

packages/discovery/tests/Fixtures/ContainerWithoutAutowiring.php

@@ -6,7 +6,7 @@
 
 final class ContainerWithoutAutowiring implements ContainerInterface
 {
-    public function get(string $id)
+    public function get(string $id): null
     {
         return null;
     }