SpomkyLabsJoseBundleExtension::initConfiguration() - Code Metrics - Inspection of "Code design" - Spomky-Labs/jose-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b866d4...755e9e )

by Florent

created 2016-05-27 23:27 UTC

SpomkyLabsJoseBundleExtension::initConfiguration() B

↳ Parent: SpomkyLabsJoseBundleExtension

Complexity

Conditions	5
Paths	12

Size

Total Lines	25
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes	10
Bugs	3	Features	3

Metric	Value
c	10
b	3
f	3
dl	0
loc	25
rs	8.439
cc	5
eloc	16
nc	12
nop	2

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2016 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace SpomkyLabs\JoseBundle\DependencyInjection;

use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\Config\FileLocator;
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\Extension;

final class SpomkyLabsJoseBundleExtension extends Extension
{
    /**
     * @var \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSource\JWKSourceInterface[]
     */
    private $jwk_sources;

    /**
     * @var \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSetSource\JWKSetSourceInterface[]
     */
    private $jwk_set_sources;

    /**
     * @var string
     */
    private $alias;

    /**
     * @param string $alias
     */
    public function __construct($alias)
    {
        $this->alias = $alias;
    }

    /**
     * {@inheritdoc}
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $processor = new Processor();

        $config = $processor->processConfiguration(
            $this->getConfiguration($configs, $container),
            $configs
        );

        $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
        $services = $this->getXmlFileToLoad();
        foreach ($services as $basename) {
            $loader->load(sprintf('%s.xml', $basename));
        }

        $this->initConfiguration($container, $config);
    }

    /**
     * {@inheritdoc}
     */
    public function getConfiguration(array $configs, ContainerBuilder $container)
    {
        $jwk_sources = $this->createJWKSources();
        $jwk_set_sources = $this->createJWKSetSources();

        return new Configuration($this->getAlias(), $jwk_sources, $jwk_set_sources);
    }

    /**
     * {@inheritdoc}
     */
    public function getAlias()
    {
        return $this->alias;
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param array                                                   $config
     */
    private function initConfiguration(ContainerBuilder $container, array $config)
    {
        foreach ($config['keys'] as $name => $key) {
            $this->createJWK($name, $key, $container, $this->jwk_sources);
        }

        foreach ($config['key_sets'] as $name => $key_set) {
            $this->createJWKSet($name, $key_set, $container, $this->jwk_set_sources);
        }

        $services = [
            'encrypters' => 'createEncrypter',
            'decrypters' => 'createDecrypter',
            'signers' => 'createSigner',
            'verifiers' => 'createVerifier',
            'checkers' => 'createChecker',
            'jwt_loaders' => 'createJWTLoader',
            'jwt_creators' => 'createJWTCreator',
        ];
        foreach ($services as $service=>$method) {
            foreach ($config[$service] as $name => $data) {
                $this->$method($name, $data, $container);
            }
        }
    }

    /**
     * @param string                                                                                 $name
     * @param array                                                                                  $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder                                $container
     * @param \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSetSource\JWKSetSourceInterface[] $jwk_set_sources
     */
    private function createJWKSet($name, array $config, ContainerBuilder $container, array $jwk_set_sources)
    {
        foreach ($config as $key => $adapter) {
            if (array_key_exists($key, $jwk_set_sources)) {
                $service_id = sprintf('jose.key_set.%s', $name);
                $jwk_set_sources[$key]->create($container, $service_id, $adapter);

                return;
            }
        }
        throw new \LogicException(sprintf('The JWKSet definition "%s" is not configured.', $name));
    }

    /**
     * @param string                                                                           $name
     * @param array                                                                            $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder                          $container
     * @param \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSource\JWKSourceInterface[] $jwk_sources
     */
    private function createJWK($name, array $config, ContainerBuilder $container, array $jwk_sources)
    {
        foreach ($config as $key => $adapter) {
            if (array_key_exists($key, $jwk_sources)) {
                $service_id = sprintf('jose.key.%s', $name);
                $jwk_sources[$key]->create($container, $service_id, $adapter);

                return;
            }
        }
        throw new \LogicException(sprintf('The JWK definition "%s" is not configured.', $name));
    }

    /**
     * @param string                                                  $name
     * @param array                                                   $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     */
    private function createEncrypter($name, array $config, ContainerBuilder $container)
    {
        $service_id = sprintf('jose.encrypter.%s', $name);
        $definition = new Definition('Jose\Encrypter');
        $definition->setFactory([
            new Reference('jose.factory.service'),
            'createEncrypter',
        ]);
        $definition->setArguments([
            $config['key_encryption_algorithms'],
            $config['content_encryption_algorithms'],
            $config['compression_methods'],
            null === $config['logger'] ? null : new Reference($config['logger']),
        ]);

        $container->setDefinition($service_id, $definition);

        if (true === $config['create_decrypter']) {
            $this->createDecrypter($name, $config, $container);
        }
    }

    /**
     * @param string                                                  $name
     * @param array                                                   $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     */
    private function createDecrypter($name, array $config, ContainerBuilder $container)
    {
        $service_id = sprintf('jose.decrypter.%s', $name);
        $definition = new Definition('Jose\Decrypter');
        $definition->setFactory([
            new Reference('jose.factory.service'),
            'createDecrypter',
        ]);
        $definition->setArguments([
            $config['key_encryption_algorithms'],
            $config['content_encryption_algorithms'],
            $config['compression_methods'],
            null === $config['logger'] ? null : new Reference($config['logger']),
        ]);

        $container->setDefinition($service_id, $definition);
    }

    /**
     * @param string                                                  $name
     * @param array                                                   $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     */
    private function createSigner($name, array $config, ContainerBuilder $container)
    {
        $service_id = sprintf('jose.signer.%s', $name);
        $definition = new Definition('Jose\Signer');
        $definition->setFactory([
            new Reference('jose.factory.service'),
            'createSigner',
        ]);
        $definition->setArguments([
            $config['algorithms'],
            null === $config['logger'] ? null : new Reference($config['logger']),
        ]);

        $container->setDefinition($service_id, $definition);

        if (true === $config['create_verifier']) {
            $this->createVerifier($name, $config, $container);
        }
    }

    /**
     * @param string                                                  $name
     * @param array                                                   $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     */
    private function createVerifier($name, array $config, ContainerBuilder $container)
    {
        $service_id = sprintf('jose.verifier.%s', $name);
        $definition = new Definition('Jose\Verifier');
        $definition->setFactory([
            new Reference('jose.factory.service'),
            'createVerifier',
        ]);
        $definition->setArguments([
            $config['algorithms'],
            null === $config['logger'] ? null : new Reference($config['logger']),
        ]);

        $container->setDefinition($service_id, $definition);
    }

    /**
     * @param string                                                  $name
     * @param array                                                   $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     */
    private function createChecker($name, array $config, ContainerBuilder $container)
    {
        $service_id = sprintf('jose.checker.%s', $name);
        $definition = new Definition('Jose\Checker\CheckerManager');
        $definition->setFactory([
            new Reference('jose.factory.service'),
            'createChecker',
        ]);
        $definition->setArguments([
            $config['claims'],
            $config['headers'],
        ]);

        $container->setDefinition($service_id, $definition);
    }

    /**
     * @param string                                                  $name
     * @param array                                                   $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     */
    private function createJWTLoader($name, array $config, ContainerBuilder $container)
    {
        $service_id = sprintf('jose.jwt_loader.%s', $name);
        $definition = new Definition('Jose\JWTLoader');
        $definition->setFactory([
            new Reference('jose.factory.service'),
            'createJWTLoader',
        ]);
        $definition->setArguments([
            new Reference($config['checker']),
            new Reference($config['verifier']),
            null === $config['decrypter'] ? null : new Reference($config['decrypter']),
            null === $config['logger'] ? null : new Reference($config['logger']),
        ]);

        $container->setDefinition($service_id, $definition);
    }

    /**
     * @param string                                                  $name
     * @param array                                                   $config
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     */
    private function createJWTCreator($name, array $config, ContainerBuilder $container)
    {
        $service_id = sprintf('jose.jwt_creator.%s', $name);
        $definition = new Definition('Jose\JWTCreator');
        $definition->setFactory([
            new Reference('jose.factory.service'),
            'createJWTCreator',
        ]);
        $definition->setArguments([
            new Reference($config['signer']),
            null === $config['encrypter'] ? null : new Reference($config['encrypter']),
        ]);

        $container->setDefinition($service_id, $definition);
    }

    /**
     * @return string[]
     */
    private function getXmlFileToLoad()
    {
        $services = [
            'services',
            'compression_methods',
            'checkers',
            'signature_algorithms',
            'encryption_algorithms',
            'checkers',
        ];

        return $services;
    }

    private function createJWKSources()
    {
        if (null !== $this->jwk_sources) {
            return $this->jwk_sources;
        }

        // load bundled adapter factories
        $tempContainer = new ContainerBuilder();
        $loader = new XmlFileLoader($tempContainer, new FileLocator(__DIR__.'/../Resources/config'));
        $loader->load('jwk_sources.xml');

        $services = $tempContainer->findTaggedServiceIds('jose.jwk_source');
        $jwk_sources = [];
        foreach (array_keys($services) as $id) {
            $factory = $tempContainer->get($id);
            $jwk_sources[str_replace('-', '_', $factory->getKey())] = $factory;
        }

        return $this->jwk_sources = $jwk_sources;
    }

    private function createJWKSetSources()
    {
        if (null !== $this->jwk_set_sources) {
            return $this->jwk_set_sources;
        }

        // load bundled adapter factories
        $tempContainer = new ContainerBuilder();
        $loader = new XmlFileLoader($tempContainer, new FileLocator(__DIR__.'/../Resources/config'));
        $loader->load('jwk_set_sources.xml');

        $services = $tempContainer->findTaggedServiceIds('jose.jwk_set_source');
        $jwk_set_sources = [];
        foreach (array_keys($services) as $id) {
            $factory = $tempContainer->get($id);
            $jwk_set_sources[str_replace('-', '_', $factory->getKeySet())] = $factory;
        }

        return $this->jwk_set_sources = $jwk_set_sources;
    }
}


1			<?php
2
3			/*
4			* The MIT License (MIT)
5			*
6			* Copyright (c) 2014-2016 Spomky-Labs
7			*
8			* This software may be modified and distributed under the terms
9			* of the MIT license. See the LICENSE file for details.
10			*/
11
12			namespace SpomkyLabs\JoseBundle\DependencyInjection;
13
14			use Symfony\Component\Config\Definition\Processor;
15			use Symfony\Component\Config\FileLocator;
16			use Symfony\Component\DependencyInjection\ContainerBuilder;
17			use Symfony\Component\DependencyInjection\Definition;
18			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
19			use Symfony\Component\DependencyInjection\Reference;
20			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
21
22			final class SpomkyLabsJoseBundleExtension extends Extension
23			{
24			/**
25			* @var \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSource\JWKSourceInterface[]
26			*/
27			private $jwk_sources;
28
29			/**
30			* @var \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSetSource\JWKSetSourceInterface[]
31			*/
32			private $jwk_set_sources;
33
34			/**
35			* @var string
36			*/
37			private $alias;
38
39			/**
40			* @param string $alias
41			*/
42			public function __construct($alias)
43			{
44			$this->alias = $alias;
45			}
46
47			/**
48			* {@inheritdoc}
49			*/
50			public function load(array $configs, ContainerBuilder $container)
51			{
52			$processor = new Processor();
53
54			$config = $processor->processConfiguration(
55			$this->getConfiguration($configs, $container),
56			$configs
57			);
58
59			$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
60			$services = $this->getXmlFileToLoad();
61			foreach ($services as $basename) {
62			$loader->load(sprintf('%s.xml', $basename));
63			}
64
65			$this->initConfiguration($container, $config);
66			}
67
68			/**
69			* {@inheritdoc}
70			*/
71			public function getConfiguration(array $configs, ContainerBuilder $container)
72			{
73			$jwk_sources = $this->createJWKSources();
74			$jwk_set_sources = $this->createJWKSetSources();
75
76			return new Configuration($this->getAlias(), $jwk_sources, $jwk_set_sources);
77			}
78
79			/**
80			* {@inheritdoc}
81			*/
82			public function getAlias()
83			{
84			return $this->alias;
85			}
86
87			/**
88			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
89			* @param array $config
90			*/
91			private function initConfiguration(ContainerBuilder $container, array $config)
92			{
93			foreach ($config['keys'] as $name => $key) {
94			$this->createJWK($name, $key, $container, $this->jwk_sources);
95			}
96
97			foreach ($config['key_sets'] as $name => $key_set) {
98			$this->createJWKSet($name, $key_set, $container, $this->jwk_set_sources);
99			}
100
101			$services = [
102			'encrypters' => 'createEncrypter',
103			'decrypters' => 'createDecrypter',
104			'signers' => 'createSigner',
105			'verifiers' => 'createVerifier',
106			'checkers' => 'createChecker',
107			'jwt_loaders' => 'createJWTLoader',
108			'jwt_creators' => 'createJWTCreator',
109			];
110			foreach ($services as $service=>$method) {
111			foreach ($config[$service] as $name => $data) {
112			$this->$method($name, $data, $container);
113			}
114			}
115			}
116
117			/**
118			* @param string $name
119			* @param array $config
120			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
121			* @param \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSetSource\JWKSetSourceInterface[] $jwk_set_sources
122			*/
123			private function createJWKSet($name, array $config, ContainerBuilder $container, array $jwk_set_sources)
124			{
125			foreach ($config as $key => $adapter) {
126			if (array_key_exists($key, $jwk_set_sources)) {
127			$service_id = sprintf('jose.key_set.%s', $name);
128			$jwk_set_sources[$key]->create($container, $service_id, $adapter);
129
130			return;
131			}
132			}
133			throw new \LogicException(sprintf('The JWKSet definition "%s" is not configured.', $name));
134			}
135
136			/**
137			* @param string $name
138			* @param array $config
139			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
140			* @param \SpomkyLabs\JoseBundle\DependencyInjection\Source\JWKSource\JWKSourceInterface[] $jwk_sources
141			*/
142			private function createJWK($name, array $config, ContainerBuilder $container, array $jwk_sources)
143			{
144			foreach ($config as $key => $adapter) {
145			if (array_key_exists($key, $jwk_sources)) {
146			$service_id = sprintf('jose.key.%s', $name);
147			$jwk_sources[$key]->create($container, $service_id, $adapter);
148
149			return;
150			}
151			}
152			throw new \LogicException(sprintf('The JWK definition "%s" is not configured.', $name));
153			}
154
155			/**
156			* @param string $name
157			* @param array $config
158			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
159			*/
160			private function createEncrypter($name, array $config, ContainerBuilder $container)
161			{
162			$service_id = sprintf('jose.encrypter.%s', $name);
163			$definition = new Definition('Jose\Encrypter');
164			$definition->setFactory([
165			new Reference('jose.factory.service'),
166			'createEncrypter',
167			]);
168			$definition->setArguments([
169			$config['key_encryption_algorithms'],
170			$config['content_encryption_algorithms'],
171			$config['compression_methods'],
172			null === $config['logger'] ? null : new Reference($config['logger']),
173			]);
174
175			$container->setDefinition($service_id, $definition);
176
177			if (true === $config['create_decrypter']) {
178			$this->createDecrypter($name, $config, $container);
179			}
180			}
181
182			/**
183			* @param string $name
184			* @param array $config
185			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
186			*/
187			private function createDecrypter($name, array $config, ContainerBuilder $container)
188			{
189			$service_id = sprintf('jose.decrypter.%s', $name);
190			$definition = new Definition('Jose\Decrypter');
191			$definition->setFactory([
192			new Reference('jose.factory.service'),
193			'createDecrypter',
194			]);
195			$definition->setArguments([
196			$config['key_encryption_algorithms'],
197			$config['content_encryption_algorithms'],
198			$config['compression_methods'],
199			null === $config['logger'] ? null : new Reference($config['logger']),
200			]);
201
202			$container->setDefinition($service_id, $definition);
203			}
204
205			/**
206			* @param string $name
207			* @param array $config
208			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
209			*/
210			private function createSigner($name, array $config, ContainerBuilder $container)
211			{
212			$service_id = sprintf('jose.signer.%s', $name);
213			$definition = new Definition('Jose\Signer');
214			$definition->setFactory([
215			new Reference('jose.factory.service'),
216			'createSigner',
217			]);
218			$definition->setArguments([
219			$config['algorithms'],
220			null === $config['logger'] ? null : new Reference($config['logger']),
221			]);
222
223			$container->setDefinition($service_id, $definition);
224
225			if (true === $config['create_verifier']) {
226			$this->createVerifier($name, $config, $container);
227			}
228			}
229
230			/**
231			* @param string $name
232			* @param array $config
233			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
234			*/
235			private function createVerifier($name, array $config, ContainerBuilder $container)
236			{
237			$service_id = sprintf('jose.verifier.%s', $name);
238			$definition = new Definition('Jose\Verifier');
239			$definition->setFactory([
240			new Reference('jose.factory.service'),
241			'createVerifier',
242			]);
243			$definition->setArguments([
244			$config['algorithms'],
245			null === $config['logger'] ? null : new Reference($config['logger']),
246			]);
247
248			$container->setDefinition($service_id, $definition);
249			}
250
251			/**
252			* @param string $name
253			* @param array $config
254			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
255			*/
256			private function createChecker($name, array $config, ContainerBuilder $container)
257			{
258			$service_id = sprintf('jose.checker.%s', $name);
259			$definition = new Definition('Jose\Checker\CheckerManager');
260			$definition->setFactory([
261			new Reference('jose.factory.service'),
262			'createChecker',
263			]);
264			$definition->setArguments([
265			$config['claims'],
266			$config['headers'],
267			]);
268
269			$container->setDefinition($service_id, $definition);
270			}
271
272			/**
273			* @param string $name
274			* @param array $config
275			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
276			*/
277			private function createJWTLoader($name, array $config, ContainerBuilder $container)
278			{
279			$service_id = sprintf('jose.jwt_loader.%s', $name);
280			$definition = new Definition('Jose\JWTLoader');
281			$definition->setFactory([
282			new Reference('jose.factory.service'),
283			'createJWTLoader',
284			]);
285			$definition->setArguments([
286			new Reference($config['checker']),
287			new Reference($config['verifier']),
288			null === $config['decrypter'] ? null : new Reference($config['decrypter']),
289			null === $config['logger'] ? null : new Reference($config['logger']),
290			]);
291
292			$container->setDefinition($service_id, $definition);
293			}
294
295			/**
296			* @param string $name
297			* @param array $config
298			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
299			*/
300			private function createJWTCreator($name, array $config, ContainerBuilder $container)
301			{
302			$service_id = sprintf('jose.jwt_creator.%s', $name);
303			$definition = new Definition('Jose\JWTCreator');
304			$definition->setFactory([
305			new Reference('jose.factory.service'),
306			'createJWTCreator',
307			]);
308			$definition->setArguments([
309			new Reference($config['signer']),
310			null === $config['encrypter'] ? null : new Reference($config['encrypter']),
311			]);
312
313			$container->setDefinition($service_id, $definition);
314			}
315
316			/**
317			* @return string[]
318			*/
319			private function getXmlFileToLoad()
320			{
321			$services = [
322			'services',
323			'compression_methods',
324			'checkers',
325			'signature_algorithms',
326			'encryption_algorithms',
327			'checkers',
328			];
329
330			return $services;
331			}
332
333			private function createJWKSources()
334			{
335			if (null !== $this->jwk_sources) {
336			return $this->jwk_sources;
337			}
338
339			// load bundled adapter factories
340			$tempContainer = new ContainerBuilder();
341			$loader = new XmlFileLoader($tempContainer, new FileLocator(__DIR__.'/../Resources/config'));
342			$loader->load('jwk_sources.xml');
343
344			$services = $tempContainer->findTaggedServiceIds('jose.jwk_source');
345			$jwk_sources = [];
346			foreach (array_keys($services) as $id) {
347			$factory = $tempContainer->get($id);
348			$jwk_sources[str_replace('-', '_', $factory->getKey())] = $factory;
349			}
350
351			return $this->jwk_sources = $jwk_sources;
352			}
353
354			private function createJWKSetSources()
355			{
356			if (null !== $this->jwk_set_sources) {
357			return $this->jwk_set_sources;
358			}
359
360			// load bundled adapter factories
361			$tempContainer = new ContainerBuilder();
362			$loader = new XmlFileLoader($tempContainer, new FileLocator(__DIR__.'/../Resources/config'));
363			$loader->load('jwk_set_sources.xml');
364
365			$services = $tempContainer->findTaggedServiceIds('jose.jwk_set_source');
366			$jwk_set_sources = [];
367			foreach (array_keys($services) as $id) {
368			$factory = $tempContainer->get($id);
369			$jwk_set_sources[str_replace('-', '_', $factory->getKeySet())] = $factory;
370			}
371
372			return $this->jwk_set_sources = $jwk_set_sources;
373			}
374			}
375

Spomky-Labs / jose-bundle

Push — master ( b866d4...755e9e )

SpomkyLabsJoseBundleExtension::initConfiguration() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like