SignpostMarv\DaftFramework\Symfony\Console\Application

Complexity

Total Complexity

12

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	addStrict()	0	19	4
A	add()	0	3	1
A	CollectCommands()	0	23	5
A	CollectApplicationWithCommands()	0	20	1
A	GetCommandCollector()	0	15	1

<?php
/**
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftFramework\Symfony\Console;

use BadMethodCallException;
use SignpostMarv\DaftFramework\AttachDaftFramework;
use SignpostMarv\DaftFramework\Framework;
use SignpostMarv\DaftFramework\Symfony\Console\Command\Command;
use SignpostMarv\DaftInterfaceCollector\StaticMethodCollector;
use Symfony\Component\Console\Application as Base;
use Symfony\Component\Console\Command\Command as BaseCommand;

class Application extends Base
{
	use AttachDaftFramework;

	/**
	* @return BaseCommand|null
	*/
	public function add(BaseCommand $command)
	{
		return $this->addStrict($command);
	}

	public function addStrict(BaseCommand $command) : ? BaseCommand
	{
		$out = parent::add($command);

		if ($out instanceof Command) {
			$maybeFramework = $this->GetDaftFramework();

			if ( ! ($maybeFramework instanceof Framework)) {
				throw new BadMethodCallException(
					'Cannot add a daft framework command without a framework being attached!'
				);
			}

			$out->AttachDaftFramework($maybeFramework);
		} elseif ($command instanceof Command) {
			$command->DetachDaftFramework();
		}

		return $out;
	}

	public function GetCommandCollector() : StaticMethodCollector
	{
		return new StaticMethodCollector(
			[
				DaftConsoleSource::class => [
					'DaftFrameworkConsoleSources' => [
						DaftConsoleSource::class,
						BaseCommand::class,
						Command::class,
					],
				],
			],
			[
				BaseCommand::class,
				Command::class,
			]
		);
	}

	/**
	* @psalm-param class-string ...$sources
	*/
	public function CollectCommands(string ...$sources) : void
	{
		$framework = $this->GetDaftFramework();

		if ( ! ($framework instanceof Framework)) {
			throw new BadMethodCallException(
				'Cannot collect commands without an attached framework instance!'
			);
		}

		/**
		* @var iterable<scalar|array|object|null>
		*/
		$implementations = $this->GetCommandCollector()->Collect(...$sources);

		foreach ($implementations as $implementation) {
			if (is_string($implementation) && is_a($implementation, BaseCommand::class, true)) {
				/**
				* @var BaseCommand
				*/
				$command = new $implementation($implementation::getDefaultName());

				$this->add($command);
			}
		}
	}

	/**
	* @return static
	*/
	public static function CollectApplicationWithCommands(
		string $name,
		string $version,
		Framework $framework
	) : self {
		$application = new static($name, $version);
		$application->AttachDaftFramework($framework);

		$config = (array) ($framework->ObtainConfig()[DaftConsoleSource::class] ?? []);

		/**
		* @var string[]
		*
		* @psalm-var class-string[]
		*/
		$sources = array_values(array_filter($config, 'is_string'));

		$application->CollectCommands(...$sources);

		return $application;
	}
}