LiipImagineExtension   A
last analyzed

Complexity

Total Complexity 17

Size/Duplication

Total Lines 150
Duplicated Lines 0 %

Coupling/Cohesion

Components 1
Dependencies 9

Importance

Changes 0
Metric Value
wmc 17
lcom 1
cbo 9
dl 0
loc 150
rs 10
c 0
b 0
f 0

9 Methods

Rating   Name   Duplication   Size   Complexity  
A addResolverFactory() 0 4 1
A loadLoaders() 0 4 1
A addLoaderFactory() 0 4 1
A getConfiguration() 0 4 1
B load() 0 76 6
A createFilterSets() 0 6 1
A loadResolvers() 0 4 1
A createFactories() 0 6 2
A deprecationTemplatingFilterHelper() 0 15 3
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