KernelSubExtension::loadInitializer() - Code Metrics - Inspection of "remove behat log" - yoanm/Behat3SymfonyExtension - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — feature/improve ( ac6d69...acfd74 )

by Yo

created 2016-12-04 05:15 UTC

KernelSubExtension::loadInitializer() A

↳ Parent: KernelSubExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines	18
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	18
ccs	0
cts	0
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	13
nc	1
nop	1
crap	2

<?php
namespace Yoanm\Behat3SymfonyExtension\ServiceContainer\SubExtension;

use Behat\MinkExtension\ServiceContainer\MinkExtension;
use Behat\Testwork\EventDispatcher\ServiceContainer\EventDispatcherExtension;
use Behat\Testwork\ServiceContainer\Exception\ProcessingException;
use Behat\Testwork\ServiceContainer\ExtensionManager;
use Symfony\Component\BrowserKit\CookieJar;
use Symfony\Component\BrowserKit\History;
use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
use Yoanm\Behat3SymfonyExtension\Client\Client;
use Yoanm\Behat3SymfonyExtension\Context\Initializer\KernelAwareInitializer;
use Yoanm\Behat3SymfonyExtension\Context\Initializer\KernelHandlerAwareInitializer;
use Yoanm\Behat3SymfonyExtension\Handler\KernelHandler;
use Yoanm\Behat3SymfonyExtension\ServiceContainer\AbstractExtension;
use Yoanm\Behat3SymfonyExtension\ServiceContainer\DriverFactory\Behat3SymfonyFactory;
use Yoanm\Behat3SymfonyExtension\Subscriber\RebootKernelSubscriber;

class KernelSubExtension extends AbstractExtension
{
    /**
     * @inheritDoc
     */
    public function getConfigKey()
    {
        return 'kernel';
    }

    // @codeCoverageIgnoreStart
    // Not possible to cover this because ExtensionManager is a final class
    /**
     * @inheritDoc
     */
    public function initialize(ExtensionManager $extensionManager)
    {
        $minExtension = $extensionManager->getExtension('mink');
        if ($minExtension instanceof MinkExtension) {
            $minExtension->registerDriverFactory(new Behat3SymfonyFactory());
        }
    }
    // @codeCoverageIgnoreEnd

    // @codeCoverageIgnoreStart
    // Will be covered by FT
    /**
     * @inheritDoc
     */
    public function configure(ArrayNodeDefinition $builder)
    {
        $castToBool = function ($value) {
            $filtered = filter_var(
                $value,
                FILTER_VALIDATE_BOOLEAN,
                FILTER_NULL_ON_FAILURE
            );

            return (null === $filtered) ? (bool) $value : $filtered;
        };
        $builder
            ->addDefaultsIfNotSet()
            ->children()
                ->scalarNode('bootstrap')
                    ->defaultValue('app/autoload.php')
                ->end()
                ->scalarNode('path')
                    ->defaultValue('app/AppKernel.php')
                ->end()
                ->scalarNode('class')
                    ->defaultValue('AppKernel')
                ->end()
                ->scalarNode('env')
                    ->defaultValue('test')
                ->end()
                ->booleanNode('debug')
                    ->beforeNormalization()
                    ->always()
                        ->then($castToBool)
                    ->end()
                    ->defaultTrue()
                ->end()
                ->booleanNode('reboot')
                    ->info('If true symfony kernel will be rebooted after each scenario/example')
                    ->beforeNormalization()
                        ->always()
                        ->then($castToBool)
                    ->end()
                    ->defaultTrue()
                ->end()
            ->end();
    }

    /**
     * {@inheritdoc}
     */
    public function load(ContainerBuilder $container, array $config)
    {
        $kernelConfig = $config[$this->getConfigKey()];

        $this->loadContainerParameter($container, $kernelConfig);
        $this->loadInitializer($container);
        $this->loadSubscriber($container, $kernelConfig);
        $this
            ->createService(
                $container,
                'test.client',
                Client::class,
                [
                    new Reference($this->buildContainerId('handler.kernel')),
                    new Reference(self::KERNEL_SERVICE_ID),
                    [],
                    new Reference($this->buildContainerId('test.client.history')),
                    new Reference($this->buildContainerId('test.client.cookiejar'))
                ]
            )
            ->setShared(false);
        $this
            ->createService(
                $container,
                'test.client.history',
                History::class
            )
            ->setShared(false);
        $this
            ->createService(
                $container,
                'test.client.cookiejar',
                CookieJar::class
            )
            ->setShared(false);
        $this->createService(
            $container,
            'kernel',
            $kernelConfig['class'],
            [$kernelConfig['env'], $kernelConfig['debug']],
            [],
            [['boot']]
        );
        $this->createService(
            $container,
            'handler.kernel',
            KernelHandler::class,
            [
                new Reference('event_dispatcher'),
                new Reference(self::KERNEL_SERVICE_ID),
            ]
        );
    }

    /**
     * {@inheritdoc}
     */
    public function process(ContainerBuilder $container)
    {
        $basePath = $container->getParameter('paths.base');
        $bootstrapPath = $container->getParameter($this->buildContainerId('kernel.bootstrap'));
        if ($bootstrapPath) {
            $bootstrapPathUnderBasePath = sprintf('%s/%s', $basePath, $bootstrapPath);
            if (file_exists($bootstrapPathUnderBasePath)) {
                $bootstrapPath = $bootstrapPathUnderBasePath;
            }
            if (file_exists($bootstrapPath)) {
                require_once($bootstrapPath);
            } else {
                throw new ProcessingException('Could not find bootstrap file !');
            }
        }

        // load kernel
        $kernelPath = $container->getParameter($this->buildContainerId('kernel.path'));
        $kernelPathUnderBasePath = sprintf('%s/%s', $basePath, $kernelPath);
        if (file_exists($kernelPathUnderBasePath)) {
            $kernelPath = $kernelPathUnderBasePath;
        }

        $container->getDefinition(self::KERNEL_SERVICE_ID)
            ->setFile($kernelPath);

    }


    /**
     * @param ContainerBuilder $container
     */
    protected function loadInitializer(ContainerBuilder $container)
    {
        $this->createService(
            $container,
            'initializer.kernel_aware',
            KernelAwareInitializer::class,
            [new Reference(self::KERNEL_SERVICE_ID)],
            ['context.initializer']
        );

        $this->createService(
            $container,
            'initializer.kernel_handler_aware',
            KernelHandlerAwareInitializer::class,
            [new Reference($this->buildContainerId('handler.kernel'))],
            ['context.initializer']
        );
    }

    /**
     * @param ContainerBuilder $container
     * @param $kernelConfig
     */
    protected function loadSubscriber(ContainerBuilder $container, $kernelConfig)
    {
        if (true === $kernelConfig['reboot']) {
            $this->createService(
                $container,
                'subscriber.reboot_kernel',
                RebootKernelSubscriber::class,
                [new Reference($this->buildContainerId('handler.kernel'))],
                [EventDispatcherExtension::SUBSCRIBER_TAG]
            );
        }
    }

    /**
     * @param ContainerBuilder $container
     * @param $kernelConfig
     */
    protected function loadContainerParameter(ContainerBuilder $container, $kernelConfig)
    {
        foreach ($kernelConfig as $key => $value) {
            $container->setParameter($this->buildContainerId(sprintf('kernel.%s', $key)), $value);
        }
    }
}


1		<?php
2		namespace Yoanm\Behat3SymfonyExtension\ServiceContainer\SubExtension;
3
4		use Behat\MinkExtension\ServiceContainer\MinkExtension;
5		use Behat\Testwork\EventDispatcher\ServiceContainer\EventDispatcherExtension;
6		use Behat\Testwork\ServiceContainer\Exception\ProcessingException;
7		use Behat\Testwork\ServiceContainer\ExtensionManager;
8		use Symfony\Component\BrowserKit\CookieJar;
9		use Symfony\Component\BrowserKit\History;
10		use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
11		use Symfony\Component\DependencyInjection\ContainerBuilder;
12		use Symfony\Component\DependencyInjection\Reference;
13		use Yoanm\Behat3SymfonyExtension\Client\Client;
14		use Yoanm\Behat3SymfonyExtension\Context\Initializer\KernelAwareInitializer;
15		use Yoanm\Behat3SymfonyExtension\Context\Initializer\KernelHandlerAwareInitializer;
16		use Yoanm\Behat3SymfonyExtension\Handler\KernelHandler;
17		use Yoanm\Behat3SymfonyExtension\ServiceContainer\AbstractExtension;
18		use Yoanm\Behat3SymfonyExtension\ServiceContainer\DriverFactory\Behat3SymfonyFactory;
19		use Yoanm\Behat3SymfonyExtension\Subscriber\RebootKernelSubscriber;
20
21		class KernelSubExtension extends AbstractExtension
22		{
23		/**
24		* @inheritDoc
25		*/
26	3	public function getConfigKey()
27		{
28	3	return 'kernel';
29		}
30
31		// @codeCoverageIgnoreStart
32		// Not possible to cover this because ExtensionManager is a final class
33		/**
34		* @inheritDoc
35		*/
36		public function initialize(ExtensionManager $extensionManager)
37		{
38		$minExtension = $extensionManager->getExtension('mink');
39		if ($minExtension instanceof MinkExtension) {
40		$minExtension->registerDriverFactory(new Behat3SymfonyFactory());
41		}
42		}
43		// @codeCoverageIgnoreEnd
44
45		// @codeCoverageIgnoreStart
46		// Will be covered by FT
47		/**
48		* @inheritDoc
49		*/
50		public function configure(ArrayNodeDefinition $builder)
51		{
52		$castToBool = function ($value) {
53		$filtered = filter_var(
54		$value,
55		FILTER_VALIDATE_BOOLEAN,
56		FILTER_NULL_ON_FAILURE
57		);
58
59		return (null === $filtered) ? (bool) $value : $filtered;
60		};
61		$builder
62		->addDefaultsIfNotSet()
63		->children()
64		->scalarNode('bootstrap')
65		->defaultValue('app/autoload.php')
66		->end()
67		->scalarNode('path')
68		->defaultValue('app/AppKernel.php')
69		->end()
70		->scalarNode('class')
71		->defaultValue('AppKernel')
72		->end()
73		->scalarNode('env')
74		->defaultValue('test')
75		->end()
76		->booleanNode('debug')
77		->beforeNormalization()
78		->always()
79		->then($castToBool)
80		->end()
81		->defaultTrue()
82		->end()
83		->booleanNode('reboot')
84		->info('If true symfony kernel will be rebooted after each scenario/example')
85		->beforeNormalization()
86		->always()
87		->then($castToBool)
88		->end()
89		->defaultTrue()
90		->end()
91		->end();
92		}
93
94		/**
95		* {@inheritdoc}
96		*/
97		public function load(ContainerBuilder $container, array $config)
98		{
99		$kernelConfig = $config[$this->getConfigKey()];
100
101		$this->loadContainerParameter($container, $kernelConfig);
102		$this->loadInitializer($container);
103		$this->loadSubscriber($container, $kernelConfig);
104		$this
105		->createService(
106		$container,
107		'test.client',
108		Client::class,
109		[
110		new Reference($this->buildContainerId('handler.kernel')),
111		new Reference(self::KERNEL_SERVICE_ID),
112		[],
113		new Reference($this->buildContainerId('test.client.history')),
114		new Reference($this->buildContainerId('test.client.cookiejar'))
115		]
116		)
117		->setShared(false);
118		$this
119		->createService(
120		$container,
121		'test.client.history',
122		History::class
123		)
124		->setShared(false);
125		$this
126		->createService(
127		$container,
128		'test.client.cookiejar',
129		CookieJar::class
130		)
131		->setShared(false);
132		$this->createService(
133		$container,
134		'kernel',
135		$kernelConfig['class'],
136		[$kernelConfig['env'], $kernelConfig['debug']],
137		[],
138		[['boot']]
139		);
140		$this->createService(
141		$container,
142		'handler.kernel',
143		KernelHandler::class,
144		[
145		new Reference('event_dispatcher'),
146		new Reference(self::KERNEL_SERVICE_ID),
147		]
148		);
149		}
150
151		/**
152		* {@inheritdoc}
153		*/
154		public function process(ContainerBuilder $container)
155		{
156		$basePath = $container->getParameter('paths.base');
157		$bootstrapPath = $container->getParameter($this->buildContainerId('kernel.bootstrap'));
158		if ($bootstrapPath) {
159		$bootstrapPathUnderBasePath = sprintf('%s/%s', $basePath, $bootstrapPath);
160		if (file_exists($bootstrapPathUnderBasePath)) {
161		$bootstrapPath = $bootstrapPathUnderBasePath;
162		}
163		if (file_exists($bootstrapPath)) {
164		require_once($bootstrapPath);
165		} else {
166		throw new ProcessingException('Could not find bootstrap file !');
167		}
168		}
169
170		// load kernel
171		$kernelPath = $container->getParameter($this->buildContainerId('kernel.path'));
172		$kernelPathUnderBasePath = sprintf('%s/%s', $basePath, $kernelPath);
173		if (file_exists($kernelPathUnderBasePath)) {
174		$kernelPath = $kernelPathUnderBasePath;
175		}
176
177		$container->getDefinition(self::KERNEL_SERVICE_ID)
178		->setFile($kernelPath);
179
180		}
		0 ignored issues – show Coding Style introduced 2016-12-04 05:17 UTC by Report Bug Copy Issue Report Function closing brace must go on the next line following the body; found 1 blank lines before brace Loading history...
181
182		/**
183		* @param ContainerBuilder $container
184		*/
185		protected function loadInitializer(ContainerBuilder $container)
186		{
187		$this->createService(
188		$container,
189		'initializer.kernel_aware',
190		KernelAwareInitializer::class,
191		[new Reference(self::KERNEL_SERVICE_ID)],
192		['context.initializer']
193		);
194
195		$this->createService(
196		$container,
197		'initializer.kernel_handler_aware',
198		KernelHandlerAwareInitializer::class,
199		[new Reference($this->buildContainerId('handler.kernel'))],
200		['context.initializer']
201		);
202		}
203
204		/**
205		* @param ContainerBuilder $container
206		* @param $kernelConfig
207		*/
208		protected function loadSubscriber(ContainerBuilder $container, $kernelConfig)
209		{
210		if (true === $kernelConfig['reboot']) {
211		$this->createService(
212		$container,
213		'subscriber.reboot_kernel',
214		RebootKernelSubscriber::class,
215		[new Reference($this->buildContainerId('handler.kernel'))],
216		[EventDispatcherExtension::SUBSCRIBER_TAG]
217		);
218		}
219		}
220
221		/**
222		* @param ContainerBuilder $container
223		* @param $kernelConfig
224		*/
225		protected function loadContainerParameter(ContainerBuilder $container, $kernelConfig)
226		{
227		foreach ($kernelConfig as $key => $value) {
228		$container->setParameter($this->buildContainerId(sprintf('kernel.%s', $key)), $value);
229		}
230		}
231		}
232

yoanm / Behat3SymfonyExtension

Push — feature/improve ( ac6d69...acfd74 )

KernelSubExtension::loadInitializer() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like