StepsPass::processStepAction() - Code Metrics - Inspection of "More CI fixes" - Pierstoval/CharacterManagerBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f4a302...e32202 )

by Alex

created 2017-12-27 11:05 UTC

StepsPass::processStepAction() B

↳ Parent: StepsPass

Complexity

Conditions	4
Paths	5

Size

Total Lines	46
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	46
rs	8.6315
c	0
b	0
f	0
cc	4
eloc	27
nc	5
nop	4

<?php

/**
 * This file is part of the PierstovalCharacterManagerBundle package.
 *
 * (c) Alexandre Rock Ancelet <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Pierstoval\Bundle\CharacterManagerBundle\DependencyInjection\Compiler;

use Doctrine\Common\Inflector\Inflector;
use Doctrine\Common\Persistence\ObjectManager;
use Pierstoval\Bundle\CharacterManagerBundle\Action\AbstractStepAction;
use Pierstoval\Bundle\CharacterManagerBundle\Action\StepActionInterface;
use Pierstoval\Bundle\CharacterManagerBundle\Registry\ActionsRegistry;
use Pierstoval\Bundle\CharacterManagerBundle\Resolver\StepActionConfigurator;
use Pierstoval\Bundle\CharacterManagerBundle\Resolver\StepResolverInterface;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Translation\TranslatorInterface;
use Twig\Environment;

/**
 * Check that every action class extends the right action interface.
 * And for each step-tagged service, if the class extends the provided abstract class,
 *  calls some useful methods.
 */
class StepsPass implements CompilerPassInterface
{
    public const PARAMETERS_MANAGERS = 'pierstoval_character_manager.managers';

    /**
     * {@inheritdoc}
     */
    public function process(ContainerBuilder $container)
    {
        $this->validateManagers($container);
        $this->processConfiguredServices($container);
    }

    private function validateManagers(ContainerBuilder $container): void
    {
        $managers = $container->getParameter(static::PARAMETERS_MANAGERS);

        foreach ($managers as $name => $config) {
            $config['name'] = $name;
            $managers[$name] = $this->validateManagerSteps($config, $container);
        }

        $container->setParameter(static::PARAMETERS_MANAGERS, $managers);
    }

    /**
     * Validate steps defined in configuration, and makes sure all "action" classes are instances of StepActionInterface
     */
    private function validateManagerSteps(array $managerConfiguration, ContainerBuilder $container): array
    {
        /** @var array[] $steps */
        $steps = $managerConfiguration['steps'];

        $stepNumber = 1;

        // Validate steps that can't be validated in Configuration.
        // First loop mandatory because we re-validate each step dependency in another loop after normalization.
        foreach ($steps as $id => $step) {
            $name = $step['name'] = $id;

            if (!$step['label']) {
                $step['label'] = $this->generateStepLabel($step['name']);
            }

            $step['manager_name'] = $managerConfiguration['name'];

            $step['number'] = $stepNumber++;

            $steps[$name] = $step;
        }

        foreach ($steps as $name => $step) {
            // Validate steps to disable on change, to be sure each step is defined.
            foreach ($step['onchange_clear'] as $stepToDisable) {
                if (!array_key_exists($stepToDisable, $steps)) {
                    throw new InvalidConfigurationException(sprintf(
                        'Step to disable must be a valid step name, "%s" given.'."\n".
                        'Available steps: %s',
                        $stepToDisable, implode(', ', array_keys($steps))
                    ));
                }
            }

            // Validate steps dependencies, to be sure each step is defined.
            foreach ($step['dependencies'] as $stepDependency) {
                if (!array_key_exists($stepDependency, $steps)) {
                    throw new InvalidConfigurationException(sprintf(
                        'Step dependency must be a valid step name, "%s" given.'."\n".
                        'Available steps: %s',
                        $stepDependency, implode(', ', array_keys($steps))
                    ));
                }
            }

            // Validate step actions.
            $action = $step['action'];

            // Check if action defined as a service or as a simple class.
            $class = $container->has($action) ? $container->getDefinition($action)->getClass() : $action;

            if (!class_exists($class) || !is_a($class, StepActionInterface::class, true)) {
                throw new InvalidArgumentException(sprintf(
                    'Step action must be a valid class implementing %s. "%s" given.',
                    StepActionInterface::class, class_exists($class) ? $class : \gettype($class)
                ));
            }
        }

        // And update all steps.
        $managerConfiguration['steps'] = $steps;

        return $managerConfiguration;
    }

    /**
     * Automatically convert the actions into services.
     * If they're defined as classes, this has the advantage to autowire them, etc.
     *
     * @param ContainerBuilder $container
     */
    private function processConfiguredServices(ContainerBuilder $container)
    {
        if (!$container->hasDefinition(ActionsRegistry::class)) {
            throw new InvalidConfigurationException('Step actions registry not set in your configuration. Maybe the extension was not processed properly?');
        }

        $registryDefinition = $container->getDefinition(ActionsRegistry::class);

        foreach ($container->getParameter(static::PARAMETERS_MANAGERS) as $managerName => $config) {
            $this->processStepAction($managerName, $config, $registryDefinition, $container);
        }
    }

    private function processStepAction(string $managerName, array $config, Definition $registryDefinition, ContainerBuilder $container): void
    {
        /** @var array[] $finalSteps */
        $finalSteps = $config['steps'];

        foreach ($finalSteps as $step) {
            $action = $step['action'];
            if ($container->has($action)) {
                /** @var  $definition */
                $definition = $container->getDefinition($action);
            } else {
                // If action is not yet a service, it means it's a class name.
                // In this case, we create a new service.
                $definition = new Definition($action);
                $definition
                    ->setLazy(true)
                    ->setPrivate(true)
                    ->setAutowired(true)
                ;
                $container->setDefinition($action, $definition);
            }

            $definition
                ->addMethodCall('configure', [
                    $managerName,
                    $step['name'],
                    $config['character_class'],
                    new Reference(StepResolverInterface::class),
                ])
            ;

            // If class extends the abstract one, we inject some cool services.
            if (is_a($definition->getClass(), AbstractStepAction::class, true)) {
                $ignoreOnInvalid = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
                $definition
                    ->addMethodCall('setObjectManager', [new Reference(ObjectManager::class, $ignoreOnInvalid)])
                    ->addMethodCall('setTwig', [new Reference(Environment::class, $ignoreOnInvalid)])
                    ->addMethodCall('setRouter', [new Reference(RouterInterface::class, $ignoreOnInvalid)])
                    ->addMethodCall('setTranslator', [new Reference(TranslatorInterface::class, $ignoreOnInvalid)])
                ;
            }

            // Finally add the step action to the registry
            $registryDefinition->addMethodCall('addStepAction', [$step['name'], new Reference($action)]);
        }
    }

    private function generateStepLabel(string $name): string
    {
        $name = str_replace(['.', '_', '-'], ' ', $name);
        $name = trim($name);
        $name = Inflector::ucwords($name);

        return $name;
    }
}


1			<?php
2
3			/**
4			* This file is part of the PierstovalCharacterManagerBundle package.
5			*
6			* (c) Alexandre Rock Ancelet <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Pierstoval\Bundle\CharacterManagerBundle\DependencyInjection\Compiler;
13
14			use Doctrine\Common\Inflector\Inflector;
15			use Doctrine\Common\Persistence\ObjectManager;
16			use Pierstoval\Bundle\CharacterManagerBundle\Action\AbstractStepAction;
17			use Pierstoval\Bundle\CharacterManagerBundle\Action\StepActionInterface;
18			use Pierstoval\Bundle\CharacterManagerBundle\Registry\ActionsRegistry;
19			use Pierstoval\Bundle\CharacterManagerBundle\Resolver\StepActionConfigurator;
20			use Pierstoval\Bundle\CharacterManagerBundle\Resolver\StepResolverInterface;
21			use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
22			use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
23			use Symfony\Component\DependencyInjection\ContainerBuilder;
24			use Symfony\Component\DependencyInjection\ContainerInterface;
25			use Symfony\Component\DependencyInjection\Definition;
26			use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
27			use Symfony\Component\DependencyInjection\Reference;
28			use Symfony\Component\Routing\RouterInterface;
29			use Symfony\Component\Translation\TranslatorInterface;
30			use Twig\Environment;
31
32			/**
33			* Check that every action class extends the right action interface.
34			* And for each step-tagged service, if the class extends the provided abstract class,
35			* calls some useful methods.
36			*/
37			class StepsPass implements CompilerPassInterface
38			{
39			public const PARAMETERS_MANAGERS = 'pierstoval_character_manager.managers';
40
41			/**
42			* {@inheritdoc}
43			*/
44			public function process(ContainerBuilder $container)
45			{
46			$this->validateManagers($container);
47			$this->processConfiguredServices($container);
48			}
49
50			private function validateManagers(ContainerBuilder $container): void
51			{
52			$managers = $container->getParameter(static::PARAMETERS_MANAGERS);
53
54			foreach ($managers as $name => $config) {
55			$config['name'] = $name;
56			$managers[$name] = $this->validateManagerSteps($config, $container);
57			}
58
59			$container->setParameter(static::PARAMETERS_MANAGERS, $managers);
60			}
61
62			/**
63			* Validate steps defined in configuration, and makes sure all "action" classes are instances of StepActionInterface
64			*/
65			private function validateManagerSteps(array $managerConfiguration, ContainerBuilder $container): array
66			{
67			/** @var array[] $steps */
68			$steps = $managerConfiguration['steps'];
69
70			$stepNumber = 1;
71
72			// Validate steps that can't be validated in Configuration.
73			// First loop mandatory because we re-validate each step dependency in another loop after normalization.
74			foreach ($steps as $id => $step) {
75			$name = $step['name'] = $id;
76
77			if (!$step['label']) {
78			$step['label'] = $this->generateStepLabel($step['name']);
79			}
80
81			$step['manager_name'] = $managerConfiguration['name'];
82
83			$step['number'] = $stepNumber++;
84
85			$steps[$name] = $step;
86			}
87
88			foreach ($steps as $name => $step) {
89			// Validate steps to disable on change, to be sure each step is defined.
90			foreach ($step['onchange_clear'] as $stepToDisable) {
91			if (!array_key_exists($stepToDisable, $steps)) {
92			throw new InvalidConfigurationException(sprintf(
93			'Step to disable must be a valid step name, "%s" given.'."\n".
94			'Available steps: %s',
95			$stepToDisable, implode(', ', array_keys($steps))
96			));
97			}
98			}
99
100			// Validate steps dependencies, to be sure each step is defined.
101			foreach ($step['dependencies'] as $stepDependency) {
102			if (!array_key_exists($stepDependency, $steps)) {
103			throw new InvalidConfigurationException(sprintf(
104			'Step dependency must be a valid step name, "%s" given.'."\n".
105			'Available steps: %s',
106			$stepDependency, implode(', ', array_keys($steps))
107			));
108			}
109			}
110
111			// Validate step actions.
112			$action = $step['action'];
113
114			// Check if action defined as a service or as a simple class.
115			$class = $container->has($action) ? $container->getDefinition($action)->getClass() : $action;
116
117			if (!class_exists($class) \|\| !is_a($class, StepActionInterface::class, true)) {
118			throw new InvalidArgumentException(sprintf(
119			'Step action must be a valid class implementing %s. "%s" given.',
120			StepActionInterface::class, class_exists($class) ? $class : \gettype($class)
121			));
122			}
123			}
124
125			// And update all steps.
126			$managerConfiguration['steps'] = $steps;
127
128			return $managerConfiguration;
129			}
130
131			/**
132			* Automatically convert the actions into services.
133			* If they're defined as classes, this has the advantage to autowire them, etc.
134			*
135			* @param ContainerBuilder $container
136			*/
137			private function processConfiguredServices(ContainerBuilder $container)
138			{
139			if (!$container->hasDefinition(ActionsRegistry::class)) {
140			throw new InvalidConfigurationException('Step actions registry not set in your configuration. Maybe the extension was not processed properly?');
141			}
142
143			$registryDefinition = $container->getDefinition(ActionsRegistry::class);
144
145			foreach ($container->getParameter(static::PARAMETERS_MANAGERS) as $managerName => $config) {
146			$this->processStepAction($managerName, $config, $registryDefinition, $container);
147			}
148			}
149
150			private function processStepAction(string $managerName, array $config, Definition $registryDefinition, ContainerBuilder $container): void
151			{
152			/** @var array[] $finalSteps */
153			$finalSteps = $config['steps'];
154
155			foreach ($finalSteps as $step) {
156			$action = $step['action'];
157			if ($container->has($action)) {
158			/** @var $definition */
159			$definition = $container->getDefinition($action);
160			} else {
161			// If action is not yet a service, it means it's a class name.
162			// In this case, we create a new service.
163			$definition = new Definition($action);
164			$definition
165			->setLazy(true)
166			->setPrivate(true)
167			->setAutowired(true)
168			;
169			$container->setDefinition($action, $definition);
170			}
171
172			$definition
173			->addMethodCall('configure', [
174			$managerName,
175			$step['name'],
176			$config['character_class'],
177			new Reference(StepResolverInterface::class),
178			])
179			;
180
181			// If class extends the abstract one, we inject some cool services.
182			if (is_a($definition->getClass(), AbstractStepAction::class, true)) {
183			$ignoreOnInvalid = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
184			$definition
185			->addMethodCall('setObjectManager', [new Reference(ObjectManager::class, $ignoreOnInvalid)])
186			->addMethodCall('setTwig', [new Reference(Environment::class, $ignoreOnInvalid)])
187			->addMethodCall('setRouter', [new Reference(RouterInterface::class, $ignoreOnInvalid)])
188			->addMethodCall('setTranslator', [new Reference(TranslatorInterface::class, $ignoreOnInvalid)])
189			;
190			}
191
192			// Finally add the step action to the registry
193			$registryDefinition->addMethodCall('addStepAction', [$step['name'], new Reference($action)]);
194			}
195			}
196
197			private function generateStepLabel(string $name): string
198			{
199			$name = str_replace(['.', '_', '-'], ' ', $name);
200			$name = trim($name);
201			$name = Inflector::ucwords($name);
202
203			return $name;
204			}
205			}
206

Pierstoval / CharacterManagerBundle

Push — master ( f4a302...e32202 )

StepsPass::processStepAction() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like