Zalas\Toolbox\Cli\ServiceContainer

Complexity

Total Complexity

13

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$1 ➔ createListCommand()	0	3	1
A	hp$1 ➔ has()	0	3	2
A	hp$1 ➔ createTestToolsUseCase()	0	3	1
	createListCommand()	0	3	?
	createTestToolsUseCase()	0	3	?
	createInstallCommand()	0	3	?
A	hp$0 ➔ set()	0	8	2
	has()	0	3	?
A	hp$1 ➔ createRunner()	0	3	1
A	hp$1 ➔ createInstallToolsUseCase()	0	3	1
	createTools()	0	4	?
	createListToolsUseCase()	0	3	?
	get()	0	11	?
A	hp$1 ➔ get()	0	11	3
	createRunner()	0	3	?
A	hp$1 ➔ createTools()	0	4	1
	createTestCommand()	0	3	?
	set()	0	8	?
	createInstallToolsUseCase()	0	3	?
A	hp$1 ➔ createListToolsUseCase()	0	3	1
A	hp$1 ➔ createInstallCommand()	0	3	1
A	hp$1 ➔ createTestCommand()	0	3	1

<?php declare(strict_types=1);

namespace Zalas\Toolbox\Cli;

use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use RuntimeException;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Zalas\Toolbox\Cli\Command\InstallCommand;
use Zalas\Toolbox\Cli\Command\ListCommand;
use Zalas\Toolbox\Cli\Command\TestCommand;
use Zalas\Toolbox\Cli\ServiceContainer\LazyRunner;
use Zalas\Toolbox\Cli\ServiceContainer\RunnerFactory;
use Zalas\Toolbox\Json\JsonTools;
use Zalas\Toolbox\Runner\Runner;
use Zalas\Toolbox\Tool\Tools;
use Zalas\Toolbox\UseCase\InstallTools;
use Zalas\Toolbox\UseCase\ListTools;
use Zalas\Toolbox\UseCase\TestTools;

class ServiceContainer implements ContainerInterface
{
    private $services = [
        InstallCommand::class => 'createInstallCommand',
        ListCommand::class => 'createListCommand',
        TestCommand::class => 'createTestCommand',
        Runner::class => 'createRunner',
        InstallTools::class => 'createInstallToolsUseCase',
        ListTools::class => 'createListToolsUseCase',
        TestTools::class => 'createTestToolsUseCase',
        Tools::class => 'createTools',
    ];

    private $runtimeServices = [
        InputInterface::class => null,
        OutputInterface::class => null,
    ];

    public function set(string $id, /*object */$service): void
    {
        if (!\array_key_exists($id, $this->runtimeServices)) {
            throw new class(\sprintf('The "%s" runtime service is not expected.', $id)) extends RuntimeException implements ContainerExceptionInterface {
            };
        }

        $this->runtimeServices[$id] = $service;
    }

    /**
     * {@inheritdoc}
     */
    public function get($id)
    {
        if (isset($this->runtimeServices[$id])) {
            return $this->runtimeServices[$id];
        }

        if (isset($this->services[$id])) {
            return \call_user_func([$this, $this->services[$id]]);
        }

        throw new class(\sprintf('The "%s" service is not registered in the service container.', $id)) extends RuntimeException implements NotFoundExceptionInterface {
        };
    }

    /**
     * {@inheritdoc}
     */
    public function has($id)
    {
        return isset($this->services[$id]) || isset($this->runtimeServices[$id]);
    }

    private function createInstallCommand(): InstallCommand
    {
        return new InstallCommand($this->get(InstallTools::class), $this->get(Runner::class));
    }

    private function createListCommand(): ListCommand
    {
        return new ListCommand($this->get(ListTools::class));
    }

    private function createTestCommand(): TestCommand
    {
        return new TestCommand($this->get(TestTools::class), $this->get(Runner::class));
    }

    private function createRunner(): Runner
    {
        return new LazyRunner(new RunnerFactory($this));
    }

    private function createInstallToolsUseCase(): InstallTools
    {
        return new InstallTools($this->get(Tools::class));
    }

    private function createListToolsUseCase(): ListTools
    {
        return new ListTools($this->get(Tools::class));
    }

    private function createTestToolsUseCase(): TestTools
    {
        return new TestTools($this->get(Tools::class));
    }

    private function createTools(): Tools
    {
        return new JsonTools(function (): array {
            return $this->get(InputInterface::class)->getOption('tools');
        });
    }
}