update: container is only accepted only at load time.

- refactor: now accepts any implementation of PSR-11 Container Interface.
- refactor: other codes and comments.

Author: hsehszroc

Src/CommandLoader.php

@@ -4,9 +4,10 @@
 namespace TheWebSolver\Codegarage\Cli;
 
 use Countable;
+use LogicException;
+use Psr\Container\ContainerInterface;
 use TheWebSolver\Codegarage\Cli\Console;
 use TheWebSolver\Codegarage\Cli\Data\EventTask;
-use TheWebSolver\Codegarage\Container\Container;
 use TheWebSolver\Codegarage\Cli\Event\AfterLoadEvent;
 use Symfony\Component\EventDispatcher\EventDispatcher;
 use TheWebSolver\Codegarage\Cli\Event\CommandSubscriber;
@@ -19,23 +20,18 @@ class CommandLoader implements Countable {
 	/** @var array{dirpath:string,namespace:string} */
 	protected array $base;
 	private bool $scanStarted;
+	private ContainerInterface $container;
 
 	/**
-	 * @param Container                           $container
 	 * @param array<int,array<string,string>>     $namespacedDirectory
 	 * @param array<string,class-string<Console>> $commands
 	 */
 	final private function __construct(
-		private Container $container,
 		private array $namespacedDirectory = array(),
 		private array $commands = array(),
 		private ?EventDispatcher $dispatcher = null
 	) {}
 
-	public function getContainer(): Container {
-		return $this->container;
-	}
-
 	/** @return array<int,array<string,string>> List of directory path indexed by its namespace. */
 	public function getNamespacedDirectories(): array {
 		return $this->namespacedDirectory;
@@ -46,22 +42,22 @@ public function getCommands(): array {
 		return $this->commands;
 	}
 
-	public static function with( ?Container $container ): static {
-		return self::getInstance( $container );
+	public static function start(): static {
+		return self::getInstance();
 	}
 
 	/** @param callable(EventTask): void $listener */
-	public static function withEvent( callable $listener, ?Container $container = null ): static {
-		return self::getInstance( $container, event: true )->withListener( $listener );
+	public static function withEvent( callable $listener ): static {
+		return self::getInstance( event: true )->withListener( $listener );
 	}
 
 	/** @param array<int,array<string,string>> $namespacedDirectories */
-	public static function loadCommands( array $namespacedDirectories, ?Container $container = null ): static {
-		$loader = self::getInstance( $container );
+	public static function loadCommands( array $namespacedDirectories, ContainerInterface $container ): static {
+		$loader = self::getInstance();
 
 		$loader->namespacedDirectory = $namespacedDirectories;
 
-		return $loader->load();
+		return $loader->load( $container );
 	}
 
 	public function inDirectory( string $path, string $namespace ): static {
@@ -70,18 +66,55 @@ public function inDirectory( string $path, string $namespace ): static {
 		return $this;
 	}
 
-	public function load(): static {
+	final public function load( ContainerInterface $container ): static {
 		if ( $this->scanStarted ?? false ) {
 			return $this;
 		}
 
 		$this->scanStarted = true;
+		$this->container   = $container;
 
-		$this->container->get( Cli::class )->eventDispatcher()->addSubscriber( new CommandSubscriber() );
+		$this->getApp()->eventDispatcher()->addSubscriber( new CommandSubscriber() );
+
+		$this->initialize();
 
 		return $this->startScan();
 	}
 
+	/**
+	 * Allows inheriting class to initialize its actions before scan has started.
+	 */
+	protected function initialize(): void {}
+
+	/**
+	 * Returns an instance of Console application (Cli by default).
+	 *
+	 * This may throw PSR-11 exceptions if no container binding identifier exists with $id as `Cli::class`.
+	 *
+	 * @throws LogicException When container resolves something other than `Cli` or its inheritance.
+	 */
+	final protected function getApp(): Cli {
+		return ( $app = $this->container->get( Cli::class ) ) instanceof Cli
+			? $app
+			: throw new LogicException( 'Impossible to start Cli application using container.' );
+	}
+
+	/**
+	 * Allows inheriting class to handle the found command.
+	 *
+	 * By default, it defers command instantiation until current command is ran. The provided container
+	 * must have `ContainerInterface::set()` method to defer command instantiation. If that is not the
+	 * case, then this method must be overridden to handle found command (preferably defer loading).
+	 *
+	 * @param class-string<Console>              $classname
+	 * @param callable(ContainerInterface): void $command
+	 * @link https://symfony.com/doc/current/console/lazy_commands.html
+	 */
+	protected function useFoundCommand( string $classname, callable $command, string $commandName ): void {
+		/** @disregard P1013 Undefined method 'set' */
+		method_exists( $this->container, 'set' ) && $this->container->set( $classname, $command );
+	}
+
 	protected function getRootPath(): string {
 		return $this->base['dirpath'];
 	}
@@ -99,29 +132,16 @@ protected function forCurrentFile(): void {
 		$commandName                    = $commandClass::asCommandName();
 		$this->commands[ $commandName ] = $commandClass;
 
-		$this->handleResolved( $commandClass, $lazyload, $commandName );
+		$this->useFoundCommand( $commandClass, $lazyload, $commandName );
 
 		// Allow developers to listen for resolved command by Command Loader with the "EventTask".
 		if ( $commandRunner = $this->getCommandRunnerFromEvent() ) {
 			$commandRunner( new EventTask( $lazyload( ... ), $commandClass, $commandName, $this->container ) );
 		}
 	}
 
-	/**
-	 * Allows developers to handle the resolved command.
-	 *
-	 * By default, it defers command instantiation until current command is ran.
-	 *
-	 * @param class-string<Console>     $classname
-	 * @param callable(Container): void $command
-	 * @link https://symfony.com/doc/current/console/lazy_commands.html
-	 */
-	protected function handleResolved( string $classname, callable $command, string $commandName ): void {
-		$this->container->set( $classname, $command );
-	}
-
-	private static function getInstance( ?Container $container, bool $event = false ): static {
-		return new static( $container ??= Container::boot(), dispatcher: $event ? new EventDispatcher() : null );
+	private static function getInstance( bool $event = false ): static {
+		return new static( dispatcher: $event ? new EventDispatcher() : null );
 	}
 
 	private function fromFilePathToPsr4SpecificationFullyQualifiedClassName(): ?string {
@@ -143,9 +163,7 @@ private function withListener( callable $listener ): static {
 	private function startScan(): static {
 		array_walk( $this->namespacedDirectory, $this->scanBaseDirectory( ... ) );
 
-		$this->container->get( Cli::class )->setCommandLoader(
-			new ContainerCommandLoader( $this->container, $this->commands )
-		);
+		$this->getApp()->setCommandLoader( new ContainerCommandLoader( $this->container, $this->commands ) );
 
 		return $this;
 	}

Src/Data/EventTask.php

@@ -4,18 +4,18 @@
 namespace TheWebSolver\Codegarage\Cli\Data;
 
 use Closure;
+use Psr\Container\ContainerInterface;
 use TheWebSolver\Codegarage\Cli\Console;
-use TheWebSolver\Codegarage\Container\Container;
 
 /**
- * @param Closure(?Container): Console $command
+ * @param Closure(ContainerInterface): Console $command
  * @param class-string<Console>        $className
  */
 readonly class EventTask {
 	public function __construct(
 		public Closure $command,
 		public string $className,
 		public string $commandName,
-		public Container $container
+		public ContainerInterface $container
 	) {}
 }

Tests/CommandLoaderTest.php

@@ -31,7 +31,7 @@ protected function setUp(): void {
 
 	#[Test]
 	public function itScansAndLazyloadCommandFromGivenLocation(): void {
-		$loader = CommandLoader::loadCommands( array( self::NAMESPACED_DIR ) );
+		$loader = CommandLoader::loadCommands( array( self::NAMESPACED_DIR ), new Container() );
 
 		$this->assertEmpty( array_diff_key( self::EXPECTED_COMMANDS, $loader->getCommands() ) );
 		$this->assertEmpty( array_diff( self::EXPECTED_FILENAMES, $loader->getScannedItems() ) );
@@ -41,7 +41,7 @@ public function itScansAndLazyloadCommandFromGivenLocation(): void {
 	public function itListensForEventsForEachResolvedCommandFile(): void {
 		$loader = CommandLoader::withEvent( $this->assertLoadedCommandIsListened( ... ) )
 			->inDirectory( ...self::LOCATION )
-			->load();
+			->load( new Container() );
 
 		$this->assertCount( 2, $fileNames = $loader->getScannedItems() );
 		$this->assertEmpty( array_diff( self::EXPECTED_FILENAMES, $fileNames ) );
@@ -59,13 +59,13 @@ public function assertLoadedCommandIsListened( EventTask $task ): void {
 
 	#[Test]
 	public function itEnsuresCommandsAreLazyLoadedToContainer(): void {
-		$loader = CommandLoader::loadCommands( array( self::NAMESPACED_DIR ), new Container() );
+		CommandLoader::loadCommands( array( self::NAMESPACED_DIR ), $container = new Container() );
 
 		foreach ( self::EXPECTED_COMMANDS as $class ) {
 			// The command is registered to container as a closure by CommandLoader.
-			$this->assertEquals( $class::start( ... ), $loader->getContainer()->getBinding( $class )->material );
+			$this->assertEquals( $class::start( ... ), $container->getBinding( $class )->material );
 			// But once the command is resolved by container, it becomes a singleton.
-			$this->assertSame( $loader->getContainer()->get( $class ), $loader->getContainer()->get( $class ) );
+			$this->assertSame( $container->get( $class ), $container->get( $class ) );
 		}
 	}
 
@@ -75,8 +75,9 @@ public function itProvidesLazyLoadedCommandsToCli(): void {
 
 		$container->setShared( Cli::class );
 
-		$loader = CommandLoader::loadCommands( array( self::NAMESPACED_DIR ), $container );
-		$cli    = $loader->getContainer()->get( Cli::class );
+		CommandLoader::loadCommands( array( self::NAMESPACED_DIR ), $container );
+
+		$cli = $container->get( Cli::class );
 
 		$this->assertCount( 1, $cli->all( 'app' ) );
 		$this->assertCount( 1, $cli->all( 'scanned' ) );
@@ -86,28 +87,21 @@ public function itProvidesLazyLoadedCommandsToCli(): void {
 		}
 	}
 
-	#[Test]
-	public function itEnsuresCommandLoaderIsInstantiatedWithContainer(): void {
-		$loader = CommandLoader::loadCommands( array( self::LOCATION ), $c = new Container() );
-
-		$this->assertSame( $c, $loader->getContainer() );
-	}
-
 	#[Test]
 	public function itRegistersCommandsFromSubDirectories(): void {
-		$subDirLoader = SubDirectoryAwareLoader::with( container: null )
+		$subDirLoader = SubDirectoryAwareLoader::start()
 			->usingSubDirectory( 'SubStub', 2 )
 			->inDirectory( ...self::LOCATION )
-			->load();
+			->load( new Container() );
 
 		$this->assertContains( FirstDepthCommand::class, $subDirLoader->getCommands() );
 		$this->assertCount( 4, $subDirLoader->getScannedItems() );
 
-		$subDirLoader = SubDirectoryAwareLoader::with( container: null )
+		$subDirLoader = SubDirectoryAwareLoader::start()
 			->inDirectory( DirectoryScannerTest::SCAN_PATH, __NAMESPACE__ . '\\Scan' )
 			->usingSubDirectory( 'SubStub', 2 )
 			->inDirectory( ...self::LOCATION )
-			->load();
+			->load( new Container() );
 
 		$this->assertContains( Valid::class, $subDirLoader->getCommands() );
 		$this->assertCount( 6, $subDirLoader->getScannedItems() );

bootstrap.php

@@ -22,7 +22,6 @@
 use Closure;
 use LogicException;
 use TheWebSolver\Codegarage\Cli\CommandLoader;
-use TheWebSolver\Codegarage\Container\Container;
 
 abstract class Bootstrap {
 	final private function __construct( private string $packageRootPath = '' ) {}
@@ -128,7 +127,7 @@ private function configure( string $slash = DIRECTORY_SEPARATOR ): array {
 
 		/** @var class-string<CommandLoader> */
 		$commandLoaderClass = $config['commandLoader'] ?? CommandLoader::class;
-		$commandLoader      = $commandLoaderClass::with( Container::boot() );
+		$commandLoader      = $commandLoaderClass::start();
 		$packageRootPath    = $hasPackageConfig ? $this->packageRootPath : $this->cliPackagePath();
 
 		foreach ( $config['directory'] ?? array() as ['path' => $dirname, 'namespace' => $namespace] ) {

phpstan.neon

@@ -14,11 +14,18 @@ parameters:
 		-
 			path: Src/CommandLoader.php
 			identifier: argument.type
-			count: 3 # 1 for ConsoleChildClass::start() as container binding & others related to "ScannedItemAware" methods.
+			message: '|CommandLoader\:\:useFoundCommand\(\) expects callable|'
+			count: 1 # 1 for ConsoleChildClass::start() as container binding.
 		-
 			path: Src/Traits/DirectoryScanner.php
 			identifier: method.notFound
 			message: "|::registerCurrentItemDepth|"
+		-
+			path: Src/Traits/DirectoryScanner.php
+			identifier: argument.type
+			messages:
+				- '|\$value of function count expects array\|Countable\, mixed given|'
+				- '|\:\:maybeRegisterCurrentDepth\(\) expects array\<string\>\, mixed given|'
 		-
 			paths:
 				- Src/CommandLoader.php