AlexMasterov\PsyshBundle\DependencyInjection\Compiler\SetVariablePass

Complexity

Total Complexity

12

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Test Coverage

Coverage

60%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	classify()	0	10	2
B	process()	0	27	6
A	mergeMethodCall()	0	19	4

<?php
declare(strict_types=1);

namespace AlexMasterov\PsyshBundle\DependencyInjection\Compiler;

use Symfony\Component\DependencyInjection\{
    Compiler\CompilerPassInterface,
    ContainerBuilder,
    Definition,
    Reference
};

class SetVariablePass implements CompilerPassInterface
{
    /** @const */
    const METHOD = 'setScopeVariables';

    /**
     * {@inheritdoc}
     */
    public function process(ContainerBuilder $container)
    {
        if (!$container->has('psysh.shell')) {
            return;
        }

        $variables = [];

        foreach ($container->findTaggedServiceIds('psysh.variable', true) as $id => [$attributes]) {
            $variable = $attributes['var'] ?? (\class_exists($id) ? $this->classify($id) : $id);
            $variables[$variable] = new Reference($id);
        }

        if (empty($variables)) {
            return;
        }

        $definition = $container->getDefinition('psysh.shell');

        if ($definition->hasMethodCall(self::METHOD)) {
            $this->mergeMethodCall($definition, $variables);

            return;
        }

        $definition->addMethodCall(self::METHOD, [$variables]);
    }

    // NameSpace\SomeName -> nameSpaceSomeName
    private function classify(string $spec): string
    {
        $parts = \explode('\\', $spec);

        if (!empty($parts[1])) {
            $parts[0] = \strtolower($parts[0]);
        }

        return \implode($parts);
    }

    private function mergeMethodCall(Definition $definition, array $variables): void
    {
        $calls = $definition->getMethodCalls();

        foreach ($calls as $call => [$method, $arguments]) {
            if (self::METHOD === $method) {
                foreach ($arguments as $argument) {
                    $variables += $argument;
                }
                unset($calls[$call]);
            }
        }

        $mergedCalls += [

The variable $mergedCalls does not exist. Did you forget to declare it?

            [self::METHOD, [$variables]],
        ];

        $definition->setMethodCalls($mergedCalls);
    }
}