LiipImagineExtension::createFilterSets() - Code Metrics - Inspection of "Add support for default filter sets configuration" - liip/LiipImagineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1221)

unknown

created 2019-09-02 22:16 UTC

LiipImagineExtension::createFilterSets() A

↳ Parent: LiipImagineExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	10
c	0
b	0
f	0
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 = [];

    /**
     * @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');
        }

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

        $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);
        }
    }

    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)]);
        }
    }
}


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			$container->setParameter('liip_imagine.driver_service', 'liip_imagine.'.$config['driver']);
99
100			$container->setAlias('liip_imagine', new Alias('liip_imagine.'.$config['driver']));
101			$container->setAlias(CacheManager::class, new Alias('liip_imagine.cache.manager', false));
102			$container->setAlias(DataManager::class, new Alias('liip_imagine.data.manager', false));
103			$container->setAlias(FilterManager::class, new Alias('liip_imagine.filter.manager', false));
104
105			$container->setParameter('liip_imagine.cache.resolver.default', $config['cache']);
106
107			$container->setParameter('liip_imagine.default_image', $config['default_image']);
108
109			$filterSets = $this->createFilterSets($config['default_filter_set_settings'], $config['filter_sets']);
110
111			$container->setParameter('liip_imagine.filter_sets', $filterSets);
112			$container->setParameter('liip_imagine.binary.loader.default', $config['data_loader']);
113
114			$container->setParameter('liip_imagine.controller.filter_action', $config['controller']['filter_action']);
115			$container->setParameter('liip_imagine.controller.filter_runtime_action', $config['controller']['filter_runtime_action']);
116
117			$container->setParameter('twig.form.resources', array_merge(
118			$container->hasParameter('twig.form.resources') ? $container->getParameter('twig.form.resources') : [],
119			['@LiipImagine/Form/form_div_layout.html.twig']
120			));
121
122			if ($container->hasDefinition('liip_imagine.mime_types')) {
123			$mimeTypes = $container->getDefinition('liip_imagine.mime_types');
124			$container->getDefinition('liip_imagine.binary.mime_type_guesser')
125			->replaceArgument(0, $mimeTypes);
126
127			$container->getDefinition('liip_imagine.data.manager')
128			->replaceArgument(1, $mimeTypes);
129			}
130			}
131
132			private function createFilterSets(array $defaultFilterSets, array $filterSets): array
133			{
134			return array_map(function (array $filterSet) use ($defaultFilterSets) {
135			return array_replace_recursive($defaultFilterSets, $filterSet);
136			}, $filterSets);
137			}
138
139			/**
140			* @param array $config
141			* @param ContainerBuilder $container
142			*/
143			private function loadResolvers(array $config, ContainerBuilder $container)
144			{
145			$this->createFactories($this->resolversFactories, $config, $container);
146			}
147
148			/**
149			* @param array $config
150			* @param ContainerBuilder $container
151			*/
152			private function loadLoaders(array $config, ContainerBuilder $container)
153			{
154			$this->createFactories($this->loadersFactories, $config, $container);
155			}
156
157			/**
158			* @param array $factories
159			* @param array $configurations
160			* @param ContainerBuilder $container
161			*/
162			private function createFactories(array $factories, array $configurations, ContainerBuilder $container)
163			{
164			foreach ($configurations as $name => $conf) {
165			$factories[key($conf)]->create($container, $name, $conf[key($conf)]);
166			}
167			}
168			}
169

liip / LiipImagineBundle

Pull Request — master (#1221)

LiipImagineExtension::createFilterSets() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like