Using BootloaderRegistry

.github/workflows/phpunit.yml

@@ -1,4 +1,5 @@
 on:
+  pull_request: null
   push:
     branches:
       - master

.github/workflows/psalm.yml

@@ -1,4 +1,5 @@
 on:
+  pull_request: null
   push:
     branches:
       - master

composer.json

@@ -17,13 +17,13 @@
     ],
     "require": {
         "php": "^8.1",
-        "spiral/boot": "^3.0",
-        "spiral/core": "^3.0"
+        "spiral/boot": "^3.10",
+        "spiral/core": "^3.10"
     },
     "require-dev": {
-        "spiral/framework": "^3.0",
-        "spiral/testing": "^2.0",
-        "vimeo/psalm": "^4.9"
+        "spiral/framework": "dev-feature/bootloaders-registry as 3.10.x-dev",
+        "spiral/testing": "^2.6",
+        "vimeo/psalm": "^5.15"
     },
     "autoload": {
         "psr-4": {

src/Bootloader/BootloaderRegistryInterface.php

@@ -13,7 +13,7 @@
 interface BootloaderRegistryInterface extends RegistryInterface
 {
     /**
-     * @return TClass[]|array<TClass, array<non-empty-string, mixed>>
+     * @return TClass[]|array<TClass, array<string, mixed>>
      */
     public function getBootloaders(): array;
 

src/Bootloader/ConfigRegistry.php

@@ -5,8 +5,12 @@
 namespace Spiral\Discoverer\Bootloader;
 
 use Psr\Container\ContainerInterface;
+use Spiral\Boot\BootloadManagerInterface;
 use Spiral\Discoverer\Config\DiscovererConfig;
 
+/**
+ * @psalm-import-type TClass from BootloadManagerInterface
+ */
 final class ConfigRegistry implements BootloaderRegistryInterface
 {
     private ?DiscovererConfig $config = null;
@@ -21,6 +25,9 @@ public function init(ContainerInterface $container): void
         \assert($this->config instanceof DiscovererConfig);
     }
 
+    /**
+     * @return TClass[]|array<TClass, array<string, mixed>>
+     */
     public function getBootloaders(): array
     {
         return $this->config !== null ? $this->config->getBootloaders() : [];

src/Config/DiscovererConfig.php

@@ -4,34 +4,71 @@
 
 namespace Spiral\Discoverer\Config;
 
-use Spiral\Boot\Bootloader\BootloaderInterface;
 use Spiral\Boot\BootloadManagerInterface;
 use Spiral\Core\InjectableConfig;
+use Spiral\Discoverer\Bootloader\BootloaderRegistryInterface;
+use Spiral\Discoverer\Bootloader as BootloaderRegistry;
+use Spiral\Discoverer\Tokenizer as TokenizerRegistry;
+use Spiral\Discoverer\Tokenizer\DirectoryRegistryInterface;
 
 /**
  * @psalm-import-type TClass from BootloadManagerInterface
+ * @property array{
+ *     bootloaders: array<TClass>|array<TClass, array<string, mixed>>,
+ *     ignoredBootloaders: array<TClass>,
+ *     registries: array{
+ *         bootloaders: array<class-string<BootloaderRegistryInterface>>,
+ *         directories: array<class-string<DirectoryRegistryInterface>>
+ *     }
+ * } $config
  */
 final class DiscovererConfig extends InjectableConfig
 {
     public const CONFIG = 'discoverer';
+
     protected array $config = [
         'bootloaders' => [],
         'ignoredBootloaders' => [],
+        'registries' => [
+            'bootloaders' => [
+                BootloaderRegistry\ComposerRegistry::class,
+                BootloaderRegistry\ConfigRegistry::class,
+            ],
+            'directories' => [
+                TokenizerRegistry\ComposerRegistry::class,
+            ],
+        ],
     ];
 
     /**
-     * @return TClass[]|array<TClass, array<non-empty-string, mixed>>
+     * @return array<TClass>|array<TClass, array<string, mixed>>
      */
     public function getBootloaders(): array
     {
         return (array)$this->config['bootloaders'];
     }
 
     /**
-     * @return TClass[]
+     * @return array<TClass>
      */
     public function getIgnoredBootloaders(): array
     {
         return (array)$this->config['ignoredBootloaders'];
     }
+
+    /**
+     * @return array<class-string<BootloaderRegistryInterface>>
+     */
+    public function getBootloaderRegistries(): array
+    {
+        return $this->config['registries']['bootloaders'] ?? [];
+    }
+
+    /**
+     * @return array<class-string<DirectoryRegistryInterface>>
+     */
+    public function getDirectoryRegistries(): array
+    {
+        return $this->config['registries']['directories'] ?? [];
+    }
 }

src/DiscovererBootloader.php

@@ -4,37 +4,104 @@
 
 namespace Spiral\Discoverer;
 
+use Psr\Container\ContainerExceptionInterface;
 use Psr\Container\ContainerInterface;
+use Psr\Container\NotFoundExceptionInterface;
 use Spiral\Boot\Bootloader\Bootloader;
-use Spiral\Discoverer\Tokenizer\DirectoriesDiscoverer;
+use Spiral\Boot\Bootloader\BootloaderRegistryInterface;
+use Spiral\Config\ConfiguratorInterface;
+use Spiral\Discoverer\Bootloader as BootloaderRegistry;
+use Spiral\Discoverer\Config\DiscovererConfig;
+use Spiral\Discoverer\Tokenizer as TokenizerRegistry;
 use Spiral\Tokenizer\Bootloader\TokenizerBootloader;
 
 final class DiscovererBootloader extends Bootloader
 {
-    protected const DEPENDENCIES = [
-        TokenizerBootloader::class,
-    ];
+    public function __construct(
+        private readonly ConfiguratorInterface $config,
+    ) {
+    }
+
+    public function defineSingletons(): array
+    {
+        return [
+            DiscovererInterface::class => [self::class, 'initDiscoverer'],
+        ];
+    }
+
+    public function init(ContainerInterface $container, TokenizerBootloader $tokenizerBootloader): void
+    {
+        $this->initDefaultConfig();
+        $this->registerDirectories($container, $tokenizerBootloader);
+        $this->registerBootloaders($container);
+    }
+
+    private function initDefaultConfig(): void
+    {
+        $this->config->setDefaults(DiscovererConfig::CONFIG, [
+            'bootloaders' => [],
+            'ignoredBootloaders' => [],
+            'registries' => [
+                'bootloaders' => [
+                    BootloaderRegistry\ComposerRegistry::class,
+                    BootloaderRegistry\ConfigRegistry::class,
+                ],
+                'directories' => [
+                    TokenizerRegistry\ComposerRegistry::class,
+                ],
+            ],
+        ]);
+    }
 
     /**
      * @throws Exception\DiscovererRegistryException
-     * @throws \Psr\Container\ContainerExceptionInterface
-     * @throws \Psr\Container\NotFoundExceptionInterface
+     * @throws ContainerExceptionInterface
+     * @throws NotFoundExceptionInterface
      */
-    public function init(
-        ContainerInterface $container,
-        TokenizerBootloader $tokenizerBootloader
-    ): void {
-        if (!$container->has(DiscovererInterface::class)) {
-            return;
+    private function registerDirectories(ContainerInterface $container, TokenizerBootloader $tokenizerBootloader): void
+    {
+        $discoverer = $container->get(DiscovererInterface::class);
+
+        if ($discoverer->has(TokenizerRegistry\DirectoriesDiscoverer::getName())) {
+            foreach ($discoverer->discover(TokenizerRegistry\DirectoriesDiscoverer::getName()) as $directory) {
+                $tokenizerBootloader->addDirectory($directory);
+            }
         }
+    }
 
+    private function registerBootloaders(ContainerInterface $container): void
+    {
         $discoverer = $container->get(DiscovererInterface::class);
-        \assert($discoverer instanceof DiscovererInterface);
+        $bootloadersRegistry = $container->get(BootloaderRegistryInterface::class);
 
-        if ($discoverer->has(DirectoriesDiscoverer::getName())) {
-            foreach ($discoverer->discover(DirectoriesDiscoverer::getName()) as $directory) {
-                $tokenizerBootloader->addDirectory($directory);
+        if ($discoverer->has(BootloaderRegistry\BootloadersDiscoverer::getName())) {
+            $bootloaders = $discoverer->discover(BootloaderRegistry\BootloadersDiscoverer::getName());
+            foreach ($bootloaders as $bootloader => $options) {
+                $bootloadersRegistry->register([$bootloader => $options]);
             }
-        };
+        }
+    }
+
+    private function initDiscoverer(DiscovererConfig $config, ContainerInterface $container): DiscovererInterface
+    {
+        $bootloaders = [];
+        foreach ($config->getBootloaderRegistries() as $registry) {
+            $registry = $container->get($registry);
+            \assert($registry instanceof BootloaderRegistry\BootloaderRegistryInterface);
+            $bootloaders[] = $registry;
+        }
+
+        $directories = [];
+        foreach ($config->getDirectoryRegistries() as $registry) {
+            $registry = $container->get($registry);
+            \assert($registry instanceof TokenizerRegistry\DirectoryRegistryInterface);
+            $directories[] = $registry;
+        }
+
+        return new Discoverer(
+            $container,
+            new BootloaderRegistry\BootloadersDiscoverer(...$bootloaders),
+            new TokenizerRegistry\DirectoriesDiscoverer(...$directories),
+        );
     }
 }

tests/src/Bootloader/BootloadersDiscovererTest.php

@@ -10,12 +10,9 @@
 
 final class BootloadersDiscovererTest extends TestCase
 {
-    public function testGetsName()
+    public function testGetsName(): void
     {
-        return $this->assertSame(
-            'bootloaders',
-            BootloadersDiscoverer::getName()
-        );
+        $this->assertSame('bootloaders', BootloadersDiscoverer::getName());
     }
 
     public function testDiscover(): void

tests/src/DiscovererBootloaderTest.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Spiral\Discoverer\Tests;
+
+final class DiscovererBootloaderTest extends TestCase
+{
+    public function testTokenizerDirectoriesShouldBeDiscovered(): void
+    {
+        $dirs = $this->getConfig('tokenizer')['directories'];
+
+        $rootDir = $this->getDirectoryByAlias('root');
+
+        $this->assertContains($rootDir.'vendor/composer/../foo/notifications/src/foo', $dirs);
+        $this->assertContains($rootDir.'vendor/composer/../foo/notifications/src/bar', $dirs);
+    }
+}