LiipImagineExtension::loadResolvers() - Code Metrics - liip/LiipImagineBundle - Measure and Improve Code Quality continuously with Scrutinizer

LiipImagineExtension::loadResolvers() A
last analyzed 2021-01-05 12:31 UTC

↳ Parent: LiipImagineExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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 = [];

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

    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()
     */
    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);

        $container->setParameter('liip_imagine.webp.generate', $config['webp']['generate']);
        $webpOptions = $config['webp'];
        unset($webpOptions['generate']);
        $container->setParameter('liip_imagine.webp.options', $webpOptions);
    }

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

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

    private function loadLoaders(array $config, ContainerBuilder $container)
    {
        $this->createFactories($this->loadersFactories, $config, $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			public function addResolverFactory(ResolverFactoryInterface $resolverFactory)
41			{
42			$this->resolversFactories[$resolverFactory->getName()] = $resolverFactory;
43			}
44
45			public function addLoaderFactory(LoaderFactoryInterface $loaderFactory)
46			{
47			$this->loadersFactories[$loaderFactory->getName()] = $loaderFactory;
48			}
49
50			/**
51			* {@inheritdoc}
52			*/
53			public function getConfiguration(array $config, ContainerBuilder $container)
54			{
55			return new Configuration($this->resolversFactories, $this->loadersFactories);
56			}
57
58			/**
59			* @see \Symfony\Component\DependencyInjection\Extension.ExtensionInterface::load()
60			*/
61			public function load(array $configs, ContainerBuilder $container)
62			{
63			$config = $this->processConfiguration(
64			$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...
65			$configs
66			);
67
68			if (interface_exists(MimeTypeGuesserInterface::class)) {
69			$mimeTypes = new Definition(MimeTypes::class);
70			$mimeTypes->setFactory([MimeTypes::class, 'getDefault']);
71
72			$container->setDefinition('liip_imagine.mime_types', $mimeTypes);
73			}
74
75			$container->setParameter('liip_imagine.resolvers', $config['resolvers']);
76			$container->setParameter('liip_imagine.loaders', $config['loaders']);
77
78			$this->loadResolvers($config['resolvers'], $container);
79			$this->loadLoaders($config['loaders'], $container);
80
81			$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
82			$loader->load('imagine.xml');
83			$loader->load('commands.xml');
84
85			if ($config['enqueue']) {
86			$loader->load('enqueue.xml');
87			}
88
89			if ($config['templating']) {
90			$loader->load('templating.xml');
91			}
92
93			$container->setParameter('liip_imagine.driver_service', 'liip_imagine.'.$config['driver']);
94
95			$container
96			->getDefinition('liip_imagine.controller.config')
97			->replaceArgument(0, $config['controller']['redirect_response_code']);
98
99			$container->setAlias('liip_imagine', new Alias('liip_imagine.'.$config['driver']));
100			$container->setAlias(CacheManager::class, new Alias('liip_imagine.cache.manager', false));
101			$container->setAlias(DataManager::class, new Alias('liip_imagine.data.manager', false));
102			$container->setAlias(FilterManager::class, new Alias('liip_imagine.filter.manager', false));
103
104			$container->setParameter('liip_imagine.cache.resolver.default', $config['cache']);
105
106			$container->setParameter('liip_imagine.default_image', $config['default_image']);
107
108			$filterSets = $this->createFilterSets($config['default_filter_set_settings'], $config['filter_sets']);
109
110			$container->setParameter('liip_imagine.filter_sets', $filterSets);
111			$container->setParameter('liip_imagine.binary.loader.default', $config['data_loader']);
112
113			$container->setParameter('liip_imagine.controller.filter_action', $config['controller']['filter_action']);
114			$container->setParameter('liip_imagine.controller.filter_runtime_action', $config['controller']['filter_runtime_action']);
115
116			$container->setParameter('twig.form.resources', array_merge(
117			$container->hasParameter('twig.form.resources') ? $container->getParameter('twig.form.resources') : [],
118			['@LiipImagine/Form/form_div_layout.html.twig']
119			));
120
121			if ($container->hasDefinition('liip_imagine.mime_types')) {
122			$mimeTypes = $container->getDefinition('liip_imagine.mime_types');
123			$container->getDefinition('liip_imagine.binary.mime_type_guesser')
124			->replaceArgument(0, $mimeTypes);
125
126			$container->getDefinition('liip_imagine.data.manager')
127			->replaceArgument(1, $mimeTypes);
128			}
129
130			$this->deprecationTemplatingFilterHelper($container);
131
132			$container->setParameter('liip_imagine.webp.generate', $config['webp']['generate']);
133			$webpOptions = $config['webp'];
134			unset($webpOptions['generate']);
135			$container->setParameter('liip_imagine.webp.options', $webpOptions);
136			}
137
138			private function createFilterSets(array $defaultFilterSets, array $filterSets): array
139			{
140			return array_map(function (array $filterSet) use ($defaultFilterSets) {
141			return array_replace_recursive($defaultFilterSets, $filterSet);
142			}, $filterSets);
143			}
144
145			private function loadResolvers(array $config, ContainerBuilder $container)
146			{
147			$this->createFactories($this->resolversFactories, $config, $container);
148			}
149
150			private function loadLoaders(array $config, ContainerBuilder $container)
151			{
152			$this->createFactories($this->loadersFactories, $config, $container);
153			}
154
155			private function createFactories(array $factories, array $configurations, ContainerBuilder $container)
156			{
157			foreach ($configurations as $name => $conf) {
158			$factories[key($conf)]->create($container, $name, $conf[key($conf)]);
159			}
160			}
161
162			private function deprecationTemplatingFilterHelper(ContainerBuilder $container): void
163			{
164			if (!$container->hasDefinition('liip_imagine.templating.filter_helper')) {
165			return;
166			}
167
168			$message = 'The "%service_id%" service is deprecated since LiipImagineBundle 2.2 and will be removed in 3.0.';
169			$definition = $container->getDefinition('liip_imagine.templating.filter_helper');
170
171			if (method_exists(Definition::class, 'getDeprecation')) {
172			$definition->setDeprecated('liip/imagine-bundle', '2.2', $message);
173			} else {
174			$definition->setDeprecated(true, $message);
175			}
176			}
177			}
178

liip / LiipImagineBundle

LiipImagineExtension::loadResolvers() A last analyzed 2021-01-05 12:31 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

LiipImagineExtension::loadResolvers() A
last analyzed 2021-01-05 12:31 UTC