AlexMasterov\PsyshBundle\DependencyInjection\Extension

Complexity

Total Complexity

18

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getAlias()	0	4	1
A	loadInternal()	0	7	1
A	registerTags()	0	11	2
A	registerCommands()	0	6	1
A	registerConfig()	0	14	2
A	registerConfigurationTags()	0	18	5
A	registerShell()	0	13	2
A	scopeVariables()	0	10	4

<?php
declare(strict_types=1);

namespace AlexMasterov\PsyshBundle\DependencyInjection;

use AlexMasterov\PsyshBundle\Command\ShellCommand;
use Psy\{
    Command\Command,
    Configuration,
    Matcher\AbstractMatcher,
    Shell
};
use Symfony\Component\DependencyInjection\{
    ContainerBuilder,
    Definition,
    Reference
};
use Symfony\Component\HttpKernel\DependencyInjection\ConfigurableExtension;
use function is_string;
use function strpos;
use function substr;

class Extension extends ConfigurableExtension
{
    /**
     * {@inheritdoc}
     * @codeCoverageIgnore
     */
    public function getAlias()
    {
        return 'psysh';
    }

    /** {@inheritdoc} */
    protected function loadInternal(array $mergedConfig, ContainerBuilder $container)
    {
        $this->registerTags($container);
        $this->registerCommands($container);
        $this->registerConfig($mergedConfig, $container);
        $this->registerShell($mergedConfig, $container);
    }

    private function registerTags(ContainerBuilder $container): void
    {
        static $tags = [
            'psysh.command' => Command::class,
            'psysh.matcher' => AbstractMatcher::class,
        ];

        foreach ($tags as $tag => $spec) {
            $container->registerForAutoconfiguration($spec)->addTag($tag);
        }
    }

    private function registerCommands(ContainerBuilder $container): void
    {
        $container->register('psysh.command.shell_command', ShellCommand::class)
            ->addArgument(new Reference('psysh.shell'))
            ->setAutoconfigured(true);
    }

    private function registerConfig(array $config, ContainerBuilder $container): void
    {
        $config = $this->registerConfigurationTags($config, $container);

        $definition = (new Definition(Configuration::class))
            ->setShared(false)
            ->addArgument($config);

        if (isset($config['historyFile'])) {
            $definition->addMethodCall('setHistoryFile', [$config['historyFile']]);
        }

        $container->setDefinition('psysh.config', $definition);
    }

    private function registerConfigurationTags(array $config, ContainerBuilder $container): array
    {
        $configurator = function (array $services, ContainerBuilder $container): void {
            foreach ($services as $service) {
                $container->hasDefinition($service) ?: $container->register($service)->setPublic(false);
                $container->getDefinition($service)->setAutoconfigured(true);
            }
        };

        foreach (['commands', 'matchers'] as $option) {
            if (isset($config[$option])) {
                $configurator($config[$option], $container);
                unset($config[$option]);
            }
        }

        return $config;
    }

    private function registerShell(array $config, ContainerBuilder $container): void
    {
        $definition = (new Definition(Shell::class))
            ->addArgument(new Reference('psysh.config'));

        if (isset($config['variables'])) {
            $definition->addMethodCall('setScopeVariables', [
                $this->scopeVariables($config['variables']),
            ]);
        }

        $container->setDefinition('psysh.shell', $definition);
    }

    private function scopeVariables(array $variables): array
    {
        foreach ($variables as &$spec) {
            if (is_string($spec) && 0 === strpos($spec, '@')) {
                $spec = new Reference(substr($spec, 1));
            }
        }

        return $variables;
    }
}