Remove tokenizer config from the boot method

spiral · Jul 21, 2023 · e2b36c7 · e2b36c7
1 parent 0e0c3d5
commit e2b36c7
Show file tree

Hide file tree

Showing 4 changed files with 55 additions and 30 deletions.
diff --git a/src/Tokenizer/src/Bootloader/TokenizerListenerBootloader.php b/src/Tokenizer/src/Bootloader/TokenizerListenerBootloader.php
@@ -56,20 +56,11 @@ public function addListener(TokenizationListenerInterface $listener): void
         $this->listeners[] = $listener;
     }
 
-    public function boot(AbstractKernel $kernel, TokenizerConfig $config): void
+    public function boot(AbstractKernel $kernel): void
     {
-        if ($config->isLoadClassesEnabled()) {
-            $kernel->booted($this->loadClasses(...));
-        }
-
-        if ($config->isLoadEnumsEnabled()) {
-            $kernel->booted($this->loadEnums(...));
-        }
-
-        if ($config->isLoadInterfacesEnabled()) {
-            $kernel->booted($this->loadInterfaces(...));
-        }
-
+        $kernel->booted($this->loadClasses(...));
+        $kernel->booted($this->loadEnums(...));
+        $kernel->booted($this->loadInterfaces(...));
         $kernel->booted($this->finalizeListeners(...));
     }
 
@@ -130,27 +121,36 @@ private function makeCachedLoader(
     }
 
     private function loadClasses(
+        TokenizerConfig $config,
         ClassesInterface $classes,
         ClassesLoaderInterface $loader,
         ListenerInvoker $invoker,
     ): void {
-        $this->loadReflections($invoker, $classes->getClasses(...), $loader->loadClasses(...));
+        if ($config->isLoadClassesEnabled()) {
+            $this->loadReflections($invoker, $classes->getClasses(...), $loader->loadClasses(...));
+        }
     }
 
     private function loadEnums(
+        TokenizerConfig $config,
         EnumsInterface $enums,
         EnumsLoaderInterface $loader,
         ListenerInvoker $invoker,
     ): void {
-        $this->loadReflections($invoker, $enums->getEnums(...), $loader->loadEnums(...));
+        if ($config->isLoadEnumsEnabled()) {
+            $this->loadReflections($invoker, $enums->getEnums(...), $loader->loadEnums(...));
+        }
     }
 
     private function loadInterfaces(
+        TokenizerConfig $config,
         InterfacesInterface $interfaces,
         InterfacesLoaderInterface $loader,
         ListenerInvoker $invoker,
     ): void {
-        $this->loadReflections($invoker, $interfaces->getInterfaces(...), $loader->loadInterfaces(...));
+        if ($config->isLoadInterfacesEnabled()) {
+            $this->loadReflections($invoker, $interfaces->getInterfaces(...), $loader->loadInterfaces(...));
+        }
     }
 
     /**

diff --git a/src/Tokenizer/tests/Bootloader/TokenizerListenerBootloaderTest.php b/src/Tokenizer/tests/Bootloader/TokenizerListenerBootloaderTest.php
@@ -275,7 +275,10 @@ public function testAddDirectoryInBootloaderInit(): void
         $kernel = TestCoreWithTokenizer::create(directories: ['root' => __DIR__], container: $container);
         $kernel->run();
 
-        $this->assertTrue(in_array('/foo', $container->get(TokenizerConfig::class)->getDirectories()));
+        $this->assertTrue(\in_array(
+            \dirname(__DIR__) . '/Fixtures/Bootloader',
+            $container->get(TokenizerConfig::class)->getDirectories()
+        ));
     }
 
     public static function readCacheDataProvider(): \Traversable

diff --git a/src/Tokenizer/tests/Fixtures/Bootloader/DirectoryBootloader.php b/src/Tokenizer/tests/Fixtures/Bootloader/DirectoryBootloader.php
@@ -11,6 +11,6 @@ final class DirectoryBootloader extends Bootloader
 {
     public function init(TokenizerBootloader $tokenizer): void
     {
-        $tokenizer->addDirectory('/foo');
+        $tokenizer->addDirectory(\dirname(__DIR__, 2) . '/Fixtures/Bootloader');
     }
 }
diff --git a/src/Tokenizer/tests/Listener/ListenerInvokerTest.php b/src/Tokenizer/tests/Listener/ListenerInvokerTest.php
@@ -10,7 +10,11 @@
 use Spiral\Tokenizer\Bootloader\TokenizerListenerBootloader;
 use Spiral\Tokenizer\ClassesInterface;
 use Spiral\Tokenizer\Config\TokenizerConfig;
+use Spiral\Tokenizer\EnumsInterface;
+use Spiral\Tokenizer\InterfacesInterface;
 use Spiral\Tokenizer\Listener\ClassesLoaderInterface;
+use Spiral\Tokenizer\Listener\EnumsLoaderInterface;
+use Spiral\Tokenizer\Listener\InterfacesLoaderInterface;
 use Spiral\Tokenizer\Listener\ListenerInvoker;
 use Spiral\Tests\Tokenizer\Classes\Targets;
 use Spiral\Tests\Tokenizer\Fixtures\TestCore;
@@ -55,31 +59,49 @@ public function testInvokerViaKernel(): void
             ->once()
             ->andReturn([self::class => new \ReflectionClass($this)]);
 
-        $loader = \Mockery::mock(ClassesLoaderInterface::class);
-        $loader->shouldReceive('loadClasses')->once()->andReturnFalse();
+        $classesLoader = \Mockery::mock(ClassesLoaderInterface::class);
+        $classesLoader->shouldReceive('loadClasses')->once()->andReturnFalse();
+
+        $enums = \Mockery::mock(EnumsInterface::class);
+        $enums->shouldReceive('getEnums')->never();
+
+        $enumsLoader = \Mockery::mock(EnumsLoaderInterface::class);
+        $enumsLoader->shouldReceive('loadEnums')->never();
+
+        $interfaces = \Mockery::mock(InterfacesInterface::class);
+        $interfaces->shouldReceive('getInterfaces')->never();
+
+        $interfacesLoader = \Mockery::mock(InterfacesLoaderInterface::class);
+        $interfacesLoader->shouldReceive('loadInterfaces')->never();
 
         $listener = \Mockery::mock(TokenizationListenerInterface::class);
         $listener->shouldReceive('listen')->once();
         $listener->shouldReceive('finalize')->once();
 
         $container = new Container();
         $container->bind(ClassesInterface::class, $classes);
-        $container->bind(ClassesLoaderInterface::class, $loader);
-
-        $kernel = TestCore::create(directories: ['root' => __DIR__], container: $container);
-
-        $bootloader = $container->get(TokenizerListenerBootloader::class);
-        $bootloader->addListener($listener);
-
-        $config = new TokenizerConfig([
+        $container->bind(ClassesLoaderInterface::class, $classesLoader);
+        $container->bind(EnumsInterface::class, $enums);
+        $container->bind(EnumsLoaderInterface::class, $enumsLoader);
+        $container->bind(InterfacesInterface::class, $interfaces);
+        $container->bind(InterfacesLoaderInterface::class, $interfacesLoader);
+        $container->bind(TokenizerConfig::class, new TokenizerConfig([
             'load' => [
                 'classes' => true,
                 'enums' => false,
                 'interfaces' => false,
             ],
-        ]);
+        ]));
+
+        $kernel = TestCore::create(directories: ['root' => __DIR__], container: $container);
 
-        $container->invoke([$bootloader, 'boot'], compact('kernel', 'config'));
+        $bootloader = $container->get(TokenizerListenerBootloader::class);
+        $bootloader->addListener($listener);
+
+        $container->invoke(
+            [$bootloader, 'boot'],
+            ['kernel' => $kernel, 'config' => $container->get(TokenizerConfig::class)]
+        );
 
         $kernel->run();
     }