LiipImagineExtension::load() - Code Metrics - Inspection of "Fix symfony 5.1 deprecations (#1282)" - liip/LiipImagineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 16c28a...fd0ed7 )

by David

created 2020-06-25 11:59 UTC

LiipImagineExtension::load() B

↳ Parent: LiipImagineExtension

Complexity

Conditions	6
Paths	16

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	71
rs	8.0105
c	0
b	0
f	0
cc	6
nc	16
nop	2

How to fix Long Method

<?php

/*
 * This file is part of the `liip/LiipImagineBundle` project.
 *
 * (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
 *
 * For the full copyright and license information, please view the LICENSE.md
 * file that was distributed with this source code.
 */

namespace Liip\ImagineBundle\DependencyInjection;

use Liip\ImagineBundle\DependencyInjection\Factory\Loader\LoaderFactoryInterface;
use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\ResolverFactoryInterface;
use Liip\ImagineBundle\Imagine\Cache\CacheManager;
use Liip\ImagineBundle\Imagine\Data\DataManager;
use Liip\ImagineBundle\Imagine\Filter\FilterManager;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Alias;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;
use Symfony\Component\Mime\MimeTypeGuesserInterface;
use Symfony\Component\Mime\MimeTypes;

class LiipImagineExtension extends Extension
{
    /**
     * @var ResolverFactoryInterface[]
     */
    private $resolversFactories = [];

    /**
     * @var LoaderFactoryInterface[]
     */
    private $loadersFactories = [];

    /**
     * @param ResolverFactoryInterface $resolverFactory
     */
    public function addResolverFactory(ResolverFactoryInterface $resolverFactory)
    {
        $this->resolversFactories[$resolverFactory->getName()] = $resolverFactory;
    }

    /**
     * @param LoaderFactoryInterface $loaderFactory
     */
    public function addLoaderFactory(LoaderFactoryInterface $loaderFactory)
    {
        $this->loadersFactories[$loaderFactory->getName()] = $loaderFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function getConfiguration(array $config, ContainerBuilder $container)
    {
        return new Configuration($this->resolversFactories, $this->loadersFactories);
    }

    /**
     * @see \Symfony\Component\DependencyInjection\Extension.ExtensionInterface::load()
     *
     * @param array            $configs
     * @param ContainerBuilder $container
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $config = $this->processConfiguration(
            $this->getConfiguration($configs, $container),
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            $configs
        );

        if (interface_exists(MimeTypeGuesserInterface::class)) {
            $mimeTypes = new Definition(MimeTypes::class);
            $mimeTypes->setFactory([MimeTypes::class, 'getDefault']);

            $container->setDefinition('liip_imagine.mime_types', $mimeTypes);
        }

        $container->setParameter('liip_imagine.resolvers', $config['resolvers']);
        $container->setParameter('liip_imagine.loaders', $config['loaders']);

        $this->loadResolvers($config['resolvers'], $container);
        $this->loadLoaders($config['loaders'], $container);

        $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
        $loader->load('imagine.xml');
        $loader->load('commands.xml');

        if ($config['enqueue']) {
            $loader->load('enqueue.xml');
        }

        if ($config['templating']) {
            $loader->load('templating.xml');
        }

        $container->setParameter('liip_imagine.driver_service', 'liip_imagine.'.$config['driver']);

        $container
            ->getDefinition('liip_imagine.controller.config')
            ->replaceArgument(0, $config['controller']['redirect_response_code']);

        $container->setAlias('liip_imagine', new Alias('liip_imagine.'.$config['driver']));
        $container->setAlias(CacheManager::class, new Alias('liip_imagine.cache.manager', false));
        $container->setAlias(DataManager::class, new Alias('liip_imagine.data.manager', false));
        $container->setAlias(FilterManager::class, new Alias('liip_imagine.filter.manager', false));

        $container->setParameter('liip_imagine.cache.resolver.default', $config['cache']);

        $container->setParameter('liip_imagine.default_image', $config['default_image']);

        $filterSets = $this->createFilterSets($config['default_filter_set_settings'], $config['filter_sets']);

        $container->setParameter('liip_imagine.filter_sets', $filterSets);
        $container->setParameter('liip_imagine.binary.loader.default', $config['data_loader']);

        $container->setParameter('liip_imagine.controller.filter_action', $config['controller']['filter_action']);
        $container->setParameter('liip_imagine.controller.filter_runtime_action', $config['controller']['filter_runtime_action']);

        $container->setParameter('twig.form.resources', array_merge(
            $container->hasParameter('twig.form.resources') ? $container->getParameter('twig.form.resources') : [],
            ['@LiipImagine/Form/form_div_layout.html.twig']
        ));

        if ($container->hasDefinition('liip_imagine.mime_types')) {
            $mimeTypes = $container->getDefinition('liip_imagine.mime_types');
            $container->getDefinition('liip_imagine.binary.mime_type_guesser')
                ->replaceArgument(0, $mimeTypes);

            $container->getDefinition('liip_imagine.data.manager')
                ->replaceArgument(1, $mimeTypes);
        }

        $this->deprecationTemplatingFilterHelper($container);
    }

    private function createFilterSets(array $defaultFilterSets, array $filterSets): array
    {
        return array_map(function (array $filterSet) use ($defaultFilterSets) {
            return array_replace_recursive($defaultFilterSets, $filterSet);
        }, $filterSets);
    }

    /**
     * @param array            $config
     * @param ContainerBuilder $container
     */
    private function loadResolvers(array $config, ContainerBuilder $container)
    {
        $this->createFactories($this->resolversFactories, $config, $container);
    }

    /**
     * @param array            $config
     * @param ContainerBuilder $container
     */
    private function loadLoaders(array $config, ContainerBuilder $container)
    {
        $this->createFactories($this->loadersFactories, $config, $container);
    }

    /**
     * @param array            $factories
     * @param array            $configurations
     * @param ContainerBuilder $container
     */
    private function createFactories(array $factories, array $configurations, ContainerBuilder $container)
    {
        foreach ($configurations as $name => $conf) {
            $factories[key($conf)]->create($container, $name, $conf[key($conf)]);
        }
    }

    private function deprecationTemplatingFilterHelper(ContainerBuilder $container): void
    {
        if (!$container->hasDefinition('liip_imagine.templating.filter_helper')) {
            return;
        }

        $message = 'The "%service_id%" service is deprecated since LiipImagineBundle 2.2 and will be removed in 3.0.';
        $definition = $container->getDefinition('liip_imagine.templating.filter_helper');

        if (method_exists(Definition::class, 'getDeprecation')) {
            $definition->setDeprecated('liip/imagine-bundle', '2.2', $message);
        } else {
            $definition->setDeprecated(true, $message);
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the `liip/LiipImagineBundle` project.
5			*
6			* (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
7			*
8			* For the full copyright and license information, please view the LICENSE.md
9			* file that was distributed with this source code.
10			*/
11
12			namespace Liip\ImagineBundle\DependencyInjection;
13
14			use Liip\ImagineBundle\DependencyInjection\Factory\Loader\LoaderFactoryInterface;
15			use Liip\ImagineBundle\DependencyInjection\Factory\Resolver\ResolverFactoryInterface;
16			use Liip\ImagineBundle\Imagine\Cache\CacheManager;
17			use Liip\ImagineBundle\Imagine\Data\DataManager;
18			use Liip\ImagineBundle\Imagine\Filter\FilterManager;
19			use Symfony\Component\Config\FileLocator;
20			use Symfony\Component\DependencyInjection\Alias;
21			use Symfony\Component\DependencyInjection\ContainerBuilder;
22			use Symfony\Component\DependencyInjection\Definition;
23			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
24			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
25			use Symfony\Component\Mime\MimeTypeGuesserInterface;
26			use Symfony\Component\Mime\MimeTypes;
27
28			class LiipImagineExtension extends Extension
29			{
30			/**
31			* @var ResolverFactoryInterface[]
32			*/
33			private $resolversFactories = [];
34
35			/**
36			* @var LoaderFactoryInterface[]
37			*/
38			private $loadersFactories = [];
39
40			/**
41			* @param ResolverFactoryInterface $resolverFactory
42			*/
43			public function addResolverFactory(ResolverFactoryInterface $resolverFactory)
44			{
45			$this->resolversFactories[$resolverFactory->getName()] = $resolverFactory;
46			}
47
48			/**
49			* @param LoaderFactoryInterface $loaderFactory
50			*/
51			public function addLoaderFactory(LoaderFactoryInterface $loaderFactory)
52			{
53			$this->loadersFactories[$loaderFactory->getName()] = $loaderFactory;
54			}
55
56			/**
57			* {@inheritdoc}
58			*/
59			public function getConfiguration(array $config, ContainerBuilder $container)
60			{
61			return new Configuration($this->resolversFactories, $this->loadersFactories);
62			}
63
64			/**
65			* @see \Symfony\Component\DependencyInjection\Extension.ExtensionInterface::load()
66			*
67			* @param array $configs
68			* @param ContainerBuilder $container
69			*/
70			public function load(array $configs, ContainerBuilder $container)
71			{
72			$config = $this->processConfiguration(
73			$this->getConfiguration($configs, $container),
			0 ignored issues – show Bug introduced 2016-07-22 12:31 UTC by Report Bug Copy Issue Report It seems like `$this->getConfiguration($configs, $container)` can be `null`; however, `processConfiguration()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
74			$configs
75			);
76
77			if (interface_exists(MimeTypeGuesserInterface::class)) {
78			$mimeTypes = new Definition(MimeTypes::class);
79			$mimeTypes->setFactory([MimeTypes::class, 'getDefault']);
80
81			$container->setDefinition('liip_imagine.mime_types', $mimeTypes);
82			}
83
84			$container->setParameter('liip_imagine.resolvers', $config['resolvers']);
85			$container->setParameter('liip_imagine.loaders', $config['loaders']);
86
87			$this->loadResolvers($config['resolvers'], $container);
88			$this->loadLoaders($config['loaders'], $container);
89
90			$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
91			$loader->load('imagine.xml');
92			$loader->load('commands.xml');
93
94			if ($config['enqueue']) {
95			$loader->load('enqueue.xml');
96			}
97
98			if ($config['templating']) {
99			$loader->load('templating.xml');
100			}
101
102			$container->setParameter('liip_imagine.driver_service', 'liip_imagine.'.$config['driver']);
103
104			$container
105			->getDefinition('liip_imagine.controller.config')
106			->replaceArgument(0, $config['controller']['redirect_response_code']);
107
108			$container->setAlias('liip_imagine', new Alias('liip_imagine.'.$config['driver']));
109			$container->setAlias(CacheManager::class, new Alias('liip_imagine.cache.manager', false));
110			$container->setAlias(DataManager::class, new Alias('liip_imagine.data.manager', false));
111			$container->setAlias(FilterManager::class, new Alias('liip_imagine.filter.manager', false));
112
113			$container->setParameter('liip_imagine.cache.resolver.default', $config['cache']);
114
115			$container->setParameter('liip_imagine.default_image', $config['default_image']);
116
117			$filterSets = $this->createFilterSets($config['default_filter_set_settings'], $config['filter_sets']);
118
119			$container->setParameter('liip_imagine.filter_sets', $filterSets);
120			$container->setParameter('liip_imagine.binary.loader.default', $config['data_loader']);
121
122			$container->setParameter('liip_imagine.controller.filter_action', $config['controller']['filter_action']);
123			$container->setParameter('liip_imagine.controller.filter_runtime_action', $config['controller']['filter_runtime_action']);
124
125			$container->setParameter('twig.form.resources', array_merge(
126			$container->hasParameter('twig.form.resources') ? $container->getParameter('twig.form.resources') : [],
127			['@LiipImagine/Form/form_div_layout.html.twig']
128			));
129
130			if ($container->hasDefinition('liip_imagine.mime_types')) {
131			$mimeTypes = $container->getDefinition('liip_imagine.mime_types');
132			$container->getDefinition('liip_imagine.binary.mime_type_guesser')
133			->replaceArgument(0, $mimeTypes);
134
135			$container->getDefinition('liip_imagine.data.manager')
136			->replaceArgument(1, $mimeTypes);
137			}
138
139			$this->deprecationTemplatingFilterHelper($container);
140			}
141
142			private function createFilterSets(array $defaultFilterSets, array $filterSets): array
143			{
144			return array_map(function (array $filterSet) use ($defaultFilterSets) {
145			return array_replace_recursive($defaultFilterSets, $filterSet);
146			}, $filterSets);
147			}
148
149			/**
150			* @param array $config
151			* @param ContainerBuilder $container
152			*/
153			private function loadResolvers(array $config, ContainerBuilder $container)
154			{
155			$this->createFactories($this->resolversFactories, $config, $container);
156			}
157
158			/**
159			* @param array $config
160			* @param ContainerBuilder $container
161			*/
162			private function loadLoaders(array $config, ContainerBuilder $container)
163			{
164			$this->createFactories($this->loadersFactories, $config, $container);
165			}
166
167			/**
168			* @param array $factories
169			* @param array $configurations
170			* @param ContainerBuilder $container
171			*/
172			private function createFactories(array $factories, array $configurations, ContainerBuilder $container)
173			{
174			foreach ($configurations as $name => $conf) {
175			$factories[key($conf)]->create($container, $name, $conf[key($conf)]);
176			}
177			}
178
179			private function deprecationTemplatingFilterHelper(ContainerBuilder $container): void
180			{
181			if (!$container->hasDefinition('liip_imagine.templating.filter_helper')) {
182			return;
183			}
184
185			$message = 'The "%service_id%" service is deprecated since LiipImagineBundle 2.2 and will be removed in 3.0.';
186			$definition = $container->getDefinition('liip_imagine.templating.filter_helper');
187
188			if (method_exists(Definition::class, 'getDeprecation')) {
189			$definition->setDeprecated('liip/imagine-bundle', '2.2', $message);
190			} else {
191			$definition->setDeprecated(true, $message);
192			}
193			}
194			}
195

liip / LiipImagineBundle

Push — master ( 16c28a...fd0ed7 )

LiipImagineExtension::load() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like