IvorySerializerExtension::loadEvent() - Code Metrics - Inspection of "Add event support" - egeloen/IvorySerializerBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d49b5b...4e7074 )

by Eric

created 2017-02-11 21:51 UTC

IvorySerializerExtension::loadEvent() A

↳ Parent: IvorySerializerExtension

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	2

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	18
ccs	11
cts	11
cp	1
rs	9.4285
cc	2
eloc	11
nc	2
nop	2
crap	2

<?php

/*
 * This file is part of the Ivory Serializer bundle package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\SerializerBundle\DependencyInjection;

use Ivory\Serializer\Mapping\Loader\AnnotationClassMetadataLoader;
use Ivory\Serializer\Mapping\Loader\DirectoryClassMetadataLoader;
use Ivory\Serializer\Mapping\Loader\FileClassMetadataLoader;
use Ivory\Serializer\Mapping\Loader\ReflectionClassMetadataLoader;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\Config\Resource\DirectoryResource;
use Symfony\Component\Config\Resource\FileResource;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpKernel\DependencyInjection\ConfigurableExtension;

/**
 * @author GeLo <[email protected]>
 */
class IvorySerializerExtension extends ConfigurableExtension
{
    /**
     * {@inheritdoc}
     */
    protected function loadInternal(array $config, ContainerBuilder $container)
    {
        $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));

        $resources = [
            'cache',
            'common',
            'event',
            'fos',
            'mapping',
            'navigator',
            'registry',
            'serializer',
            'type',
            'visitor',
        ];

        foreach ($resources as $resource) {
            $loader->load($resource.'.xml');
        }

        $this->loadCache($config, $container);
        $this->loadEvent($config['event'], $container);
        $this->loadMapping($config['mapping'], $container);
        $this->loadTypes($config['types'], $container);
        $this->loadVisitors($config['visitors'], $container);
    }

    /**
     * @param mixed[]          $config
     * @param ContainerBuilder $container
     */
    private function loadCache(array $config, ContainerBuilder $container)
    {
        $container
            ->getDefinition('ivory.serializer.mapping.factory')
            ->addArgument($cache = new Reference($config['mapping']['cache']['pool']))
            ->addArgument($config['mapping']['cache']['prefix']);

        $container
            ->getDefinition('ivory.serializer.cache_warmer')
            ->addArgument($cache);
    }

    /**
     * @param mixed[]          $config
     * @param ContainerBuilder $container
     */
    private function loadEvent(array $config, ContainerBuilder $container)
    {
        if ($config['enabled']) {
            $container
                ->getDefinition('ivory.serializer.mapping.factory')
                ->replaceArgument(0, new Reference('ivory.serializer.mapping.factory.event'));

            $container->setAlias('ivory.serializer.navigator', 'ivory.serializer.navigator.event');

            return;
        }

        $container->removeDefinition('ivory.serializer.event.dispatcher');
        $container->removeDefinition('ivory.serializer.mapping.factory.event');
        $container->removeDefinition('ivory.serializer.navigator.event');

        $container->setAlias('ivory.serializer.navigator', 'ivory.serializer.navigator.default');
    }

    /**
     * @param mixed[]          $config
     * @param ContainerBuilder $container
     */
    private function loadMapping(array $config, ContainerBuilder $container)
    {
        $directories = $files = [];

        foreach ($this->resolveMappingPaths($config, $container) as $path) {
            if (is_dir($path)) {
                $directories[] = $path;
                $container->addResource(new DirectoryResource($path));
            } elseif (is_file($path)) {
                $files[] = $path;
                $container->addResource(new FileResource($path));
            } else {
                throw new InvalidConfigurationException(sprintf('The path "%s" does not exist.', $path));
            }
        }

        $loaders = [];
        $typeParser = new Reference('ivory.serializer.type.parser');

        if ($config['reflection']) {
            $loaders['reflection'] = new Definition(ReflectionClassMetadataLoader::class, [
                new Reference('property_info', ContainerBuilder::NULL_ON_INVALID_REFERENCE),
                $typeParser,
            ]);
        }

        if ($config['annotation']) {
            $loaders['annotation'] = new Definition(AnnotationClassMetadataLoader::class, [
                new Reference('annotation_reader'),
                $typeParser,
            ]);
        }

        if (!empty($directories)) {
            $loaders['directory'] = new Definition(DirectoryClassMetadataLoader::class, [$directories, $typeParser]);
        }

        foreach ($files as $file) {
            $loaders['file_'.sha1($file)] = new Definition(FileClassMetadataLoader::class, [$file, $typeParser]);
        }

        foreach ($loaders as $key => $loader) {
            $container->setDefinition(
                'ivory.serializer.mapping.loader.'.$key,
                $loader->addTag('ivory.serializer.loader')
            );
        }
    }

    /**
     * @param mixed[]          $config
     * @param ContainerBuilder $container
     */
    private function loadTypes(array $config, ContainerBuilder $container)
    {
        $container
            ->getDefinition('ivory.serializer.type.date_time')
            ->addArgument($config['date_time']['format'])
            ->addArgument($config['date_time']['timezone']);

        $container
            ->getDefinition('ivory.serializer.type.exception')
            ->addArgument($config['exception']['debug']);
    }

    /**
     * @param mixed[]          $config
     * @param ContainerBuilder $container
     */
    private function loadVisitors(array $config, ContainerBuilder $container)
    {
        $container
            ->getDefinition('ivory.serializer.visitor.csv.serialization')
            ->addArgument($config['csv']['delimiter'])
            ->addArgument($config['csv']['enclosure'])
            ->addArgument($config['csv']['escape_char'])
            ->addArgument($config['csv']['key_separator']);

        $container
            ->getDefinition('ivory.serializer.visitor.csv.deserialization')
            ->addArgument($config['csv']['delimiter'])
            ->addArgument($config['csv']['enclosure'])
            ->addArgument($config['csv']['escape_char'])
            ->addArgument($config['csv']['key_separator']);

        $container
            ->getDefinition('ivory.serializer.visitor.json.serialization')
            ->addArgument($config['json']['options']);

        $container
            ->getDefinition('ivory.serializer.visitor.json.deserialization')
            ->addArgument($config['json']['max_depth'])
            ->addArgument($config['json']['options']);

        $container
            ->getDefinition('ivory.serializer.visitor.xml.serialization')
            ->addArgument($config['xml']['version'])
            ->addArgument($config['xml']['encoding'])
            ->addArgument($config['xml']['format_output'])
            ->addArgument($config['xml']['root'])
            ->addArgument($config['xml']['entry'])
            ->addArgument($config['xml']['entry_attribute']);

        $container
            ->getDefinition('ivory.serializer.visitor.xml.deserialization')
            ->addArgument($config['xml']['entry'])
            ->addArgument($config['xml']['entry_attribute']);

        $container
            ->getDefinition('ivory.serializer.visitor.yaml.serialization')
            ->addArgument($config['yaml']['inline'])
            ->addArgument($config['yaml']['indent'])
            ->addArgument($config['yaml']['options']);

        $container
            ->getDefinition('ivory.serializer.visitor.yaml.deserialization')
            ->addArgument($config['yaml']['options']);
    }

    /**
     * @param mixed[]          $config
     * @param ContainerBuilder $container
     *
     * @return string[]
     */
    private function resolveMappingPaths(array $config, ContainerBuilder $container)
    {
        $paths = [];

        if ($config['auto']['enabled']) {
            $bundles = $container->getParameter('kernel.bundles');

            foreach ($bundles as $bundle) {
                $bundlePath = dirname((new \ReflectionClass($bundle))->getFileName());

                foreach ($config['auto']['paths'] as $relativePath) {
                    $path = $bundlePath.'/'.$relativePath;

                    if (file_exists($path)) {
                        $paths[] = $path;
                    }
                }
            }
        }

        return array_merge($paths, $config['paths']);
    }
}


1		<?php
2
3		/*
4		* This file is part of the Ivory Serializer bundle package.
5		*
6		* (c) Eric GELOEN <[email protected]>
7		*
8		* For the full copyright and license information, please read the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Ivory\SerializerBundle\DependencyInjection;
13
14		use Ivory\Serializer\Mapping\Loader\AnnotationClassMetadataLoader;
15		use Ivory\Serializer\Mapping\Loader\DirectoryClassMetadataLoader;
16		use Ivory\Serializer\Mapping\Loader\FileClassMetadataLoader;
17		use Ivory\Serializer\Mapping\Loader\ReflectionClassMetadataLoader;
18		use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
19		use Symfony\Component\Config\FileLocator;
20		use Symfony\Component\Config\Resource\DirectoryResource;
21		use Symfony\Component\Config\Resource\FileResource;
22		use Symfony\Component\DependencyInjection\ContainerBuilder;
23		use Symfony\Component\DependencyInjection\Definition;
24		use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
25		use Symfony\Component\DependencyInjection\Reference;
26		use Symfony\Component\HttpKernel\DependencyInjection\ConfigurableExtension;
27
28		/**
29		* @author GeLo <[email protected]>
30		*/
31		class IvorySerializerExtension extends ConfigurableExtension
32		{
33		/**
34		* {@inheritdoc}
35		*/
36	234	protected function loadInternal(array $config, ContainerBuilder $container)
37		{
38	234	$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
39
40		$resources = [
41	234	'cache',
42	182	'common',
43	182	'event',
44	182	'fos',
45	182	'mapping',
46	182	'navigator',
47	182	'registry',
48	182	'serializer',
49	182	'type',
50	182	'visitor',
51	182	];
52
53	234	foreach ($resources as $resource) {
54	234	$loader->load($resource.'.xml');
55	182	}
56
57	234	$this->loadCache($config, $container);
58	234	$this->loadEvent($config['event'], $container);
59	234	$this->loadMapping($config['mapping'], $container);
60	225	$this->loadTypes($config['types'], $container);
61	225	$this->loadVisitors($config['visitors'], $container);
62	225	}
63
64		/**
65		* @param mixed[] $config
66		* @param ContainerBuilder $container
67		*/
68	234	private function loadCache(array $config, ContainerBuilder $container)
69		{
70		$container
71	234	->getDefinition('ivory.serializer.mapping.factory')
72	234	->addArgument($cache = new Reference($config['mapping']['cache']['pool']))
73	234	->addArgument($config['mapping']['cache']['prefix']);
74
75		$container
76	234	->getDefinition('ivory.serializer.cache_warmer')
77	234	->addArgument($cache);
78	234	}
79
80		/**
81		* @param mixed[] $config
82		* @param ContainerBuilder $container
83		*/
84	234	private function loadEvent(array $config, ContainerBuilder $container)
85		{
86	234	if ($config['enabled']) {
87		$container
88	225	->getDefinition('ivory.serializer.mapping.factory')
89	225	->replaceArgument(0, new Reference('ivory.serializer.mapping.factory.event'));
90
91	225	$container->setAlias('ivory.serializer.navigator', 'ivory.serializer.navigator.event');
92
93	225	return;
94		}
95
96	9	$container->removeDefinition('ivory.serializer.event.dispatcher');
97	9	$container->removeDefinition('ivory.serializer.mapping.factory.event');
98	9	$container->removeDefinition('ivory.serializer.navigator.event');
99
100	9	$container->setAlias('ivory.serializer.navigator', 'ivory.serializer.navigator.default');
101	9	}
102
103		/**
104		* @param mixed[] $config
105		* @param ContainerBuilder $container
106		*/
107	234	private function loadMapping(array $config, ContainerBuilder $container)
108		{
109	234	$directories = $files = [];
110
111	234	foreach ($this->resolveMappingPaths($config, $container) as $path) {
112	36	if (is_dir($path)) {
113	27	$directories[] = $path;
114	27	$container->addResource(new DirectoryResource($path));
115	36	} elseif (is_file($path)) {
116	27	$files[] = $path;
117	27	$container->addResource(new FileResource($path));
118	21	} else {
119	15	throw new InvalidConfigurationException(sprintf('The path "%s" does not exist.', $path));
120		}
121	175	}
122
123	225	$loaders = [];
124	225	$typeParser = new Reference('ivory.serializer.type.parser');
125
126	225	if ($config['reflection']) {
127	216	$loaders['reflection'] = new Definition(ReflectionClassMetadataLoader::class, [
128	216	new Reference('property_info', ContainerBuilder::NULL_ON_INVALID_REFERENCE),
129	216	$typeParser,
130	168	]);
131	168	}
132
133	225	if ($config['annotation']) {
134	207	$loaders['annotation'] = new Definition(AnnotationClassMetadataLoader::class, [
135	207	new Reference('annotation_reader'),
136	207	$typeParser,
137	161	]);
138	161	}
139
140	225	if (!empty($directories)) {
141	27	$loaders['directory'] = new Definition(DirectoryClassMetadataLoader::class, [$directories, $typeParser]);
142	21	}
143
144	225	foreach ($files as $file) {
145	27	$loaders['file_'.sha1($file)] = new Definition(FileClassMetadataLoader::class, [$file, $typeParser]);
146	175	}
147
148	225	foreach ($loaders as $key => $loader) {
149	216	$container->setDefinition(
150	216	'ivory.serializer.mapping.loader.'.$key,
151	216	$loader->addTag('ivory.serializer.loader')
152	168	);
153	175	}
154	225	}
155
156		/**
157		* @param mixed[] $config
158		* @param ContainerBuilder $container
159		*/
160	225	private function loadTypes(array $config, ContainerBuilder $container)
161		{
162		$container
163	225	->getDefinition('ivory.serializer.type.date_time')
164	225	->addArgument($config['date_time']['format'])
165	225	->addArgument($config['date_time']['timezone']);
166
167		$container
168	225	->getDefinition('ivory.serializer.type.exception')
169	225	->addArgument($config['exception']['debug']);
170	225	}
171
172		/**
173		* @param mixed[] $config
174		* @param ContainerBuilder $container
175		*/
176	225	private function loadVisitors(array $config, ContainerBuilder $container)
177		{
178		$container
179	225	->getDefinition('ivory.serializer.visitor.csv.serialization')
180	225	->addArgument($config['csv']['delimiter'])
181	225	->addArgument($config['csv']['enclosure'])
182	225	->addArgument($config['csv']['escape_char'])
183	225	->addArgument($config['csv']['key_separator']);
184
185		$container
186	225	->getDefinition('ivory.serializer.visitor.csv.deserialization')
187	225	->addArgument($config['csv']['delimiter'])
188	225	->addArgument($config['csv']['enclosure'])
189	225	->addArgument($config['csv']['escape_char'])
190	225	->addArgument($config['csv']['key_separator']);
191
192		$container
193	225	->getDefinition('ivory.serializer.visitor.json.serialization')
194	225	->addArgument($config['json']['options']);
195
196		$container
197	225	->getDefinition('ivory.serializer.visitor.json.deserialization')
198	225	->addArgument($config['json']['max_depth'])
199	225	->addArgument($config['json']['options']);
200
201		$container
202	225	->getDefinition('ivory.serializer.visitor.xml.serialization')
203	225	->addArgument($config['xml']['version'])
204	225	->addArgument($config['xml']['encoding'])
205	225	->addArgument($config['xml']['format_output'])
206	225	->addArgument($config['xml']['root'])
207	225	->addArgument($config['xml']['entry'])
208	225	->addArgument($config['xml']['entry_attribute']);
209
210		$container
211	225	->getDefinition('ivory.serializer.visitor.xml.deserialization')
212	225	->addArgument($config['xml']['entry'])
213	225	->addArgument($config['xml']['entry_attribute']);
214
215		$container
216	225	->getDefinition('ivory.serializer.visitor.yaml.serialization')
217	225	->addArgument($config['yaml']['inline'])
218	225	->addArgument($config['yaml']['indent'])
219	225	->addArgument($config['yaml']['options']);
220
221		$container
222	225	->getDefinition('ivory.serializer.visitor.yaml.deserialization')
223	225	->addArgument($config['yaml']['options']);
224	225	}
225
226		/**
227		* @param mixed[] $config
228		* @param ContainerBuilder $container
229		*
230		* @return string[]
231		*/
232	234	private function resolveMappingPaths(array $config, ContainerBuilder $container)
233		{
234	234	$paths = [];
235
236	234	if ($config['auto']['enabled']) {
237	216	$bundles = $container->getParameter('kernel.bundles');
238
239	216	foreach ($bundles as $bundle) {
240	18	$bundlePath = dirname((new \ReflectionClass($bundle))->getFileName());
241
242	18	foreach ($config['auto']['paths'] as $relativePath) {
243	18	$path = $bundlePath.'/'.$relativePath;
244
245	18	if (file_exists($path)) {
246	18	$paths[] = $path;
247	14	}
248	14	}
249	168	}
250	168	}
251
252	234	return array_merge($paths, $config['paths']);
253		}
254		}
255

egeloen / IvorySerializerBundle

Push — master ( d49b5b...4e7074 )

IvorySerializerExtension::loadEvent() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like