SymfonyExtension::handleAutoWiring() - Code Metrics - Inspection of "feat(issue_62): autoconfigure & autowire" - FriendsOfBehat/SymfonyExtension - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#125)

by Guillaume

created 2020-06-03 06:48 UTC

SymfonyExtension::handleAutoWiring() A

↳ Parent: SymfonyExtension

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php

declare(strict_types=1);

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

namespace FriendsOfBehat\SymfonyExtension\ServiceContainer;

use Behat\Behat\Context\Context;
use Behat\Behat\Context\ServiceContainer\ContextExtension;
use Behat\Mink\Session;
use Behat\MinkExtension\ServiceContainer\MinkExtension;
use Behat\Testwork\Environment\ServiceContainer\EnvironmentExtension;
use Behat\Testwork\EventDispatcher\ServiceContainer\EventDispatcherExtension;
use Behat\Testwork\ServiceContainer\Extension;
use Behat\Testwork\ServiceContainer\ExtensionManager;
use FriendsOfBehat\SymfonyExtension\Context\Environment\Handler\ContextServiceEnvironmentHandler;
use FriendsOfBehat\SymfonyExtension\Driver\Factory\SymfonyDriverFactory;
use FriendsOfBehat\SymfonyExtension\Listener\KernelOrchestrator;
use FriendsOfBehat\SymfonyExtension\Mink\Mink;
use FriendsOfBehat\SymfonyExtension\Mink\MinkParameters;
use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Symfony\Component\DependencyInjection\Alias;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Parameter;
use Symfony\Component\DependencyInjection\Reference;

final class SymfonyExtension implements Extension
{
    /**
     * Kernel used inside Behat contexts or to create services injected to them.
     * Container is rebuilt before every scenario.
     */
    public const KERNEL_ID = 'fob_symfony.kernel';

    /**
     * Kernel used by Symfony driver to isolate web container from contexts' container.
     * Container is rebuilt before every request.
     */
    public const DRIVER_KERNEL_ID = 'fob_symfony.driver_kernel';

    /**
     * Used to auto tag every context injected in the container.
     */
    private const CONTEXT_TAG = 'fob_symfony.context';

    /** @var bool */
    private $minkExtensionFound = false;

    public function getConfigKey(): string
    {
        return 'fob_symfony';
    }

    public function initialize(ExtensionManager $extensionManager): void
    {
        $this->registerMinkDriver($extensionManager);
    }

    public function configure(ArrayNodeDefinition $builder): void
    {
        $builder
            ->addDefaultsIfNotSet()
            ->children()
                ->scalarNode('bootstrap')->defaultNull()->end()
                ->arrayNode('kernel')
                    ->addDefaultsIfNotSet()
                    ->children()
                        ->scalarNode('path')->defaultNull()->end()
                        ->scalarNode('class')->defaultNull()->end()
                        ->scalarNode('environment')->defaultNull()->end()
                        ->booleanNode('debug')->defaultNull()->end()
                        ->booleanNode('autoconfigure')->defaultFalse()->end()
                        ->booleanNode('step_autowiring')->defaultFalse()->end()
                    ->end()
                ->end()
            ->end()
        ;
    }

    public function load(ContainerBuilder $container, array $config): void
    {
        $this->fallbackToTestEnvironment();

        $this->loadBootstrap($this->autodiscoverBootstrap($config['bootstrap']));

        $this->loadKernel($container, $this->autodiscoverKernelConfiguration($config['kernel']));
        $this->loadDriverKernel($container);

        $this->loadKernelRebooter($container);

        $this->loadEnvironmentHandler($container);

        if ($this->minkExtensionFound) {
            $this->loadMink($container);
            $this->loadMinkDefaultSession($container);
            $this->loadMinkParameters($container);
        }

        if ($config['autoconfigure']) {
            $this->handleAutoConfiguration($container);
        }

        if ($config['step_autowiring']) {
            $this->handleAutoWiring($container);
        }

    }

    public function process(ContainerBuilder $container): void
    {
        $this->processEnvironmentHandler($container);

        if ($this->minkExtensionFound) {
            $container->getDefinition(MinkExtension::MINK_ID)->setClass(Mink::class);
        }
    }

    private function registerMinkDriver(ExtensionManager $extensionManager): void
    {
        /** @var MinkExtension|null $minkExtension */
        $minkExtension = $extensionManager->getExtension('mink');
        if (null === $minkExtension) {
            return;
        }

        $minkExtension->registerDriverFactory(new SymfonyDriverFactory('symfony', new Reference(self::DRIVER_KERNEL_ID)));

        $this->minkExtensionFound = true;
    }

    private function loadKernel(ContainerBuilder $container, array $config): void
    {
        $definition = new Definition($config['class'], [
            $config['environment'] ?? $_SERVER['APP_ENV'] ?? $_ENV['APP_ENV'] ?? 'test',
            (bool) ($config['debug'] ?? $_SERVER['APP_DEBUG'] ?? $_ENV['APP_DEBUG'] ?? true),
        ]);
        $definition->addMethodCall('boot');
        $definition->setPublic(true);

        if ($config['path'] !== null) {
            $definition->setFile($config['path']);
        }

        $container->setDefinition(self::KERNEL_ID, $definition);
    }

    private function loadDriverKernel(ContainerBuilder $container): void
    {
        $container->setDefinition(self::DRIVER_KERNEL_ID, $container->findDefinition(self::KERNEL_ID));
    }

    private function loadKernelRebooter(ContainerBuilder $container): void
    {
        $definition = new Definition(KernelOrchestrator::class, [new Reference(self::KERNEL_ID), $container]);
        $definition->addTag(EventDispatcherExtension::SUBSCRIBER_TAG);

        $container->setDefinition('fob_symfony.kernel_orchestrator', $definition);
    }

    private function loadEnvironmentHandler(ContainerBuilder $container): void
    {
        $definition = new Definition(ContextServiceEnvironmentHandler::class, [
            new Reference(self::KERNEL_ID),
            new Reference('environment.handler.context'),
        ]);
        $definition->addTag(EnvironmentExtension::HANDLER_TAG, ['priority' => 128]);

        $container->setDefinition('fob_symfony.environment_handler.context_service', $definition);
    }

    private function loadMink(ContainerBuilder $container): void
    {
        $container->setAlias('fob_symfony.mink', (new Alias('mink'))->setPublic(true));
    }

    private function loadMinkDefaultSession(ContainerBuilder $container): void
    {
        $minkDefaultSessionDefinition = new Definition(Session::class);
        $minkDefaultSessionDefinition->setPublic(true);
        $minkDefaultSessionDefinition->setFactory([new Reference('mink'), 'getSession']);

        $container->setDefinition('fob_symfony.mink.default_session', $minkDefaultSessionDefinition);
    }

    private function loadMinkParameters(ContainerBuilder $container): void
    {
        $minkParametersDefinition = new Definition(MinkParameters::class, [new Parameter('mink.parameters')]);
        $minkParametersDefinition->setPublic(true);

        $container->setDefinition('fob_symfony.mink.parameters', $minkParametersDefinition);
    }

    private function loadBootstrap(?string $bootstrap): void
    {
        if ($bootstrap === null) {
            return;
        }

        require_once $bootstrap;
    }

    private function fallbackToTestEnvironment(): void
    {
        // If there's no defined server / environment variable with an environment, default to test
        if (($_SERVER['APP_ENV'] ?? $_ENV['APP_ENV'] ?? null) === null) {
            putenv('APP_ENV=' . $_SERVER['APP_ENV'] = $_ENV['APP_ENV'] = 'test');
        }
    }

    private function processEnvironmentHandler(ContainerBuilder $container): void
    {
        $definition = $container->findDefinition('fob_symfony.environment_handler.context_service');
        foreach ($container->findTaggedServiceIds(ContextExtension::INITIALIZER_TAG) as $serviceId => $tags) {
            $definition->addMethodCall('registerContextInitializer', [new Reference($serviceId)]);
        }
    }

    private function autodiscoverKernelConfiguration(array $config): array
    {
        if ($config['class'] !== null) {
            return $config;
        }

        $autodiscovered = 0;

        if (class_exists('\App\Kernel')) {
            $config['class'] = '\App\Kernel';

            ++$autodiscovered;
        }

        if (file_exists('app/AppKernel.php')) {
            $config['class'] = '\AppKernel';
            $config['path'] = 'app/AppKernel.php';

            ++$autodiscovered;
        }

        if ($autodiscovered !== 1) {
            throw new \RuntimeException(
                'Could not autodiscover the application kernel. ' .
                'Please define it manually with "FriendsOfBehat\SymfonyExtension.kernel" configuration option.'
            );
        }

        return $config;
    }

    /**
     * @param string|bool|null $bootstrap
     */
    private function autodiscoverBootstrap($bootstrap): ?string
    {
        if (is_string($bootstrap)) {
            return $bootstrap;
        }

        if ($bootstrap === false) {
            return null;
        }

        $autodiscovered = 0;

        if (file_exists('config/bootstrap.php')) {
            $bootstrap = 'config/bootstrap.php';

            ++$autodiscovered;
        }

        if (file_exists('app/autoload.php')) {
            $bootstrap = 'app/autoload.php';

            ++$autodiscovered;
        }

        if ($autodiscovered === 2) {
            throw new \RuntimeException(
                'Could not autodiscover the bootstrap file. ' .
                'Please define it manually with "FriendsOfBehat\SymfonyExtension.bootstrap" configuration option. ' .
                'Setting that option to "false" disables autodiscovering.'
            );
        }

        return is_string($bootstrap) ? $bootstrap : null;
    }

    private function handleAutoConfiguration(ContainerBuilder $container): void
    {
        $container->registerForAutoconfiguration(Context::class)->addTag(self::CONTEXT_TAG);
    }

    private function handleAutoWiring(ContainerBuilder $container): void
    {
        foreach ($container->findTaggedServiceIds(self::CONTEXT_TAG) as $contextId => $tags) {

        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the SymfonyExtension package.
7			*
8			* (c) Kamil Kokot <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace FriendsOfBehat\SymfonyExtension\ServiceContainer;
15
16			use Behat\Behat\Context\Context;
17			use Behat\Behat\Context\ServiceContainer\ContextExtension;
18			use Behat\Mink\Session;
19			use Behat\MinkExtension\ServiceContainer\MinkExtension;
20			use Behat\Testwork\Environment\ServiceContainer\EnvironmentExtension;
21			use Behat\Testwork\EventDispatcher\ServiceContainer\EventDispatcherExtension;
22			use Behat\Testwork\ServiceContainer\Extension;
23			use Behat\Testwork\ServiceContainer\ExtensionManager;
24			use FriendsOfBehat\SymfonyExtension\Context\Environment\Handler\ContextServiceEnvironmentHandler;
25			use FriendsOfBehat\SymfonyExtension\Driver\Factory\SymfonyDriverFactory;
26			use FriendsOfBehat\SymfonyExtension\Listener\KernelOrchestrator;
27			use FriendsOfBehat\SymfonyExtension\Mink\Mink;
28			use FriendsOfBehat\SymfonyExtension\Mink\MinkParameters;
29			use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
30			use Symfony\Component\DependencyInjection\Alias;
31			use Symfony\Component\DependencyInjection\ContainerBuilder;
32			use Symfony\Component\DependencyInjection\Definition;
33			use Symfony\Component\DependencyInjection\Parameter;
34			use Symfony\Component\DependencyInjection\Reference;
35
36			final class SymfonyExtension implements Extension
37			{
38			/**
39			* Kernel used inside Behat contexts or to create services injected to them.
40			* Container is rebuilt before every scenario.
41			*/
42			public const KERNEL_ID = 'fob_symfony.kernel';
43
44			/**
45			* Kernel used by Symfony driver to isolate web container from contexts' container.
46			* Container is rebuilt before every request.
47			*/
48			public const DRIVER_KERNEL_ID = 'fob_symfony.driver_kernel';
49
50			/**
51			* Used to auto tag every context injected in the container.
52			*/
53			private const CONTEXT_TAG = 'fob_symfony.context';
54
55			/** @var bool */
56			private $minkExtensionFound = false;
57
58			public function getConfigKey(): string
59			{
60			return 'fob_symfony';
61			}
62
63			public function initialize(ExtensionManager $extensionManager): void
64			{
65			$this->registerMinkDriver($extensionManager);
66			}
67
68			public function configure(ArrayNodeDefinition $builder): void
69			{
70			$builder
71			->addDefaultsIfNotSet()
72			->children()
73			->scalarNode('bootstrap')->defaultNull()->end()
74			->arrayNode('kernel')
75			->addDefaultsIfNotSet()
76			->children()
77			->scalarNode('path')->defaultNull()->end()
78			->scalarNode('class')->defaultNull()->end()
79			->scalarNode('environment')->defaultNull()->end()
80			->booleanNode('debug')->defaultNull()->end()
81			->booleanNode('autoconfigure')->defaultFalse()->end()
82			->booleanNode('step_autowiring')->defaultFalse()->end()
83			->end()
84			->end()
85			->end()
86			;
87			}
88
89			public function load(ContainerBuilder $container, array $config): void
90			{
91			$this->fallbackToTestEnvironment();
92
93			$this->loadBootstrap($this->autodiscoverBootstrap($config['bootstrap']));
94
95			$this->loadKernel($container, $this->autodiscoverKernelConfiguration($config['kernel']));
96			$this->loadDriverKernel($container);
97
98			$this->loadKernelRebooter($container);
99
100			$this->loadEnvironmentHandler($container);
101
102			if ($this->minkExtensionFound) {
103			$this->loadMink($container);
104			$this->loadMinkDefaultSession($container);
105			$this->loadMinkParameters($container);
106			}
107
108			if ($config['autoconfigure']) {
109			$this->handleAutoConfiguration($container);
110			}
111
112			if ($config['step_autowiring']) {
113			$this->handleAutoWiring($container);
114			}
115
116			}
117
118			public function process(ContainerBuilder $container): void
119			{
120			$this->processEnvironmentHandler($container);
121
122			if ($this->minkExtensionFound) {
123			$container->getDefinition(MinkExtension::MINK_ID)->setClass(Mink::class);
124			}
125			}
126
127			private function registerMinkDriver(ExtensionManager $extensionManager): void
128			{
129			/** @var MinkExtension\|null $minkExtension */
130			$minkExtension = $extensionManager->getExtension('mink');
131			if (null === $minkExtension) {
132			return;
133			}
134
135			$minkExtension->registerDriverFactory(new SymfonyDriverFactory('symfony', new Reference(self::DRIVER_KERNEL_ID)));
136
137			$this->minkExtensionFound = true;
138			}
139
140			private function loadKernel(ContainerBuilder $container, array $config): void
141			{
142			$definition = new Definition($config['class'], [
143			$config['environment'] ?? $_SERVER['APP_ENV'] ?? $_ENV['APP_ENV'] ?? 'test',
144			(bool) ($config['debug'] ?? $_SERVER['APP_DEBUG'] ?? $_ENV['APP_DEBUG'] ?? true),
145			]);
146			$definition->addMethodCall('boot');
147			$definition->setPublic(true);
148
149			if ($config['path'] !== null) {
150			$definition->setFile($config['path']);
151			}
152
153			$container->setDefinition(self::KERNEL_ID, $definition);
154			}
155
156			private function loadDriverKernel(ContainerBuilder $container): void
157			{
158			$container->setDefinition(self::DRIVER_KERNEL_ID, $container->findDefinition(self::KERNEL_ID));
159			}
160
161			private function loadKernelRebooter(ContainerBuilder $container): void
162			{
163			$definition = new Definition(KernelOrchestrator::class, [new Reference(self::KERNEL_ID), $container]);
164			$definition->addTag(EventDispatcherExtension::SUBSCRIBER_TAG);
165
166			$container->setDefinition('fob_symfony.kernel_orchestrator', $definition);
167			}
168
169			private function loadEnvironmentHandler(ContainerBuilder $container): void
170			{
171			$definition = new Definition(ContextServiceEnvironmentHandler::class, [
172			new Reference(self::KERNEL_ID),
173			new Reference('environment.handler.context'),
174			]);
175			$definition->addTag(EnvironmentExtension::HANDLER_TAG, ['priority' => 128]);
176
177			$container->setDefinition('fob_symfony.environment_handler.context_service', $definition);
178			}
179
180			private function loadMink(ContainerBuilder $container): void
181			{
182			$container->setAlias('fob_symfony.mink', (new Alias('mink'))->setPublic(true));
183			}
184
185			private function loadMinkDefaultSession(ContainerBuilder $container): void
186			{
187			$minkDefaultSessionDefinition = new Definition(Session::class);
188			$minkDefaultSessionDefinition->setPublic(true);
189			$minkDefaultSessionDefinition->setFactory([new Reference('mink'), 'getSession']);
190
191			$container->setDefinition('fob_symfony.mink.default_session', $minkDefaultSessionDefinition);
192			}
193
194			private function loadMinkParameters(ContainerBuilder $container): void
195			{
196			$minkParametersDefinition = new Definition(MinkParameters::class, [new Parameter('mink.parameters')]);
197			$minkParametersDefinition->setPublic(true);
198
199			$container->setDefinition('fob_symfony.mink.parameters', $minkParametersDefinition);
200			}
201
202			private function loadBootstrap(?string $bootstrap): void
203			{
204			if ($bootstrap === null) {
205			return;
206			}
207
208			require_once $bootstrap;
209			}
210
211			private function fallbackToTestEnvironment(): void
212			{
213			// If there's no defined server / environment variable with an environment, default to test
214			if (($_SERVER['APP_ENV'] ?? $_ENV['APP_ENV'] ?? null) === null) {
215			putenv('APP_ENV=' . $_SERVER['APP_ENV'] = $_ENV['APP_ENV'] = 'test');
216			}
217			}
218
219			private function processEnvironmentHandler(ContainerBuilder $container): void
220			{
221			$definition = $container->findDefinition('fob_symfony.environment_handler.context_service');
222			foreach ($container->findTaggedServiceIds(ContextExtension::INITIALIZER_TAG) as $serviceId => $tags) {
223			$definition->addMethodCall('registerContextInitializer', [new Reference($serviceId)]);
224			}
225			}
226
227			private function autodiscoverKernelConfiguration(array $config): array
228			{
229			if ($config['class'] !== null) {
230			return $config;
231			}
232
233			$autodiscovered = 0;
234
235			if (class_exists('\App\Kernel')) {
236			$config['class'] = '\App\Kernel';
237
238			++$autodiscovered;
239			}
240
241			if (file_exists('app/AppKernel.php')) {
242			$config['class'] = '\AppKernel';
243			$config['path'] = 'app/AppKernel.php';
244
245			++$autodiscovered;
246			}
247
248			if ($autodiscovered !== 1) {
249			throw new \RuntimeException(
250			'Could not autodiscover the application kernel. ' .
251			'Please define it manually with "FriendsOfBehat\SymfonyExtension.kernel" configuration option.'
252			);
253			}
254
255			return $config;
256			}
257
258			/**
259			* @param string\|bool\|null $bootstrap
260			*/
261			private function autodiscoverBootstrap($bootstrap): ?string
262			{
263			if (is_string($bootstrap)) {
264			return $bootstrap;
265			}
266
267			if ($bootstrap === false) {
268			return null;
269			}
270
271			$autodiscovered = 0;
272
273			if (file_exists('config/bootstrap.php')) {
274			$bootstrap = 'config/bootstrap.php';
275
276			++$autodiscovered;
277			}
278
279			if (file_exists('app/autoload.php')) {
280			$bootstrap = 'app/autoload.php';
281
282			++$autodiscovered;
283			}
284
285			if ($autodiscovered === 2) {
286			throw new \RuntimeException(
287			'Could not autodiscover the bootstrap file. ' .
288			'Please define it manually with "FriendsOfBehat\SymfonyExtension.bootstrap" configuration option. ' .
289			'Setting that option to "false" disables autodiscovering.'
290			);
291			}
292
293			return is_string($bootstrap) ? $bootstrap : null;
294			}
295
296			private function handleAutoConfiguration(ContainerBuilder $container): void
297			{
298			$container->registerForAutoconfiguration(Context::class)->addTag(self::CONTEXT_TAG);
299			}
300
301			private function handleAutoWiring(ContainerBuilder $container): void
302			{
303			foreach ($container->findTaggedServiceIds(self::CONTEXT_TAG) as $contextId => $tags) {
304
305			}
306			}
307			}
308

FriendsOfBehat / SymfonyExtension

Pull Request — master (#125)

SymfonyExtension::handleAutoWiring() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like