LiipImagineExtension::load()   B
last analyzed

Complexity

Conditions 6
Paths 16

Size

Total Lines 76

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
dl 0
loc 76
rs 7.9014
c 0
b 0
f 0
cc 6
nc 16
nop 2

How to fix   Long Method   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

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 by
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