HttplugExtension::configureAuthentication() - Code Metrics - Inspection of "Updated the authentication configuration to suppor..." - php-http/HttplugBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#44)

by Tobias

created 2016-02-25 13:52 UTC

HttplugExtension::configureAuthentication() B

↳ Parent: HttplugExtension

Complexity

Conditions	5
Paths	5

Size

Total Lines	26
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	26
rs	8.439
cc	5
eloc	21
nc	5
nop	2

<?php

namespace Http\HttplugBundle\DependencyInjection;

use Http\Client\Plugin\AuthenticationPlugin;
use Http\Client\Plugin\PluginClient;
use Http\HttplugBundle\ClientFactory\DummyClient;
use Http\Message\Authentication\BasicAuth;
use Http\Message\Authentication\Bearer;
use Http\Message\Authentication\Wsse;
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;

/**
 * @author David Buchmann <[email protected]>
 * @author Tobias Nyholm <[email protected]>
 */
class HttplugExtension extends Extension
{
    /**
     * {@inheritdoc}
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $configuration = $this->getConfiguration($configs, $container);
        $config = $this->processConfiguration($configuration, $configs);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));

        $loader->load('services.xml');
        $loader->load('plugins.xml');
        $loader->load('discovery.xml');

        $enabled = is_bool($config['toolbar']['enabled']) ? $config['toolbar']['enabled'] : $container->hasParameter('kernel.debug') && $container->getParameter('kernel.debug');
        if ($enabled) {
            $loader->load('data-collector.xml');
            $config['_inject_collector_plugin'] = true;

            if (!empty($config['toolbar']['formatter'])) {
                $container->getDefinition('httplug.collector.message_journal')
                    ->replaceArgument(0, new Reference($config['toolbar']['formatter']));
            }
        }

        foreach ($config['classes'] as $service => $class) {
            if (!empty($class)) {
                $container->removeDefinition(sprintf('httplug.%s.default', $service));
                $container->register(sprintf('httplug.%s.default', $service), $class);
            }
        }

        foreach ($config['main_alias'] as $type => $id) {
            $container->setAlias(sprintf('httplug.%s', $type), $id);
        }
        $this->configurePlugins($container, $config['plugins']);
        $this->configureClients($container, $config);
    }

    /**
     * Configure client services.
     *
     * @param ContainerBuilder $container
     * @param array            $config
     */
    private function configureClients(ContainerBuilder $container, array $config)
    {
        $first = isset($config['clients']['default']) ? 'default' : null;
        foreach ($config['clients'] as $name => $arguments) {
            if ($first === null) {
                $first = $name;
            }

            if (isset($config['_inject_collector_plugin'])) {
                array_unshift($arguments['plugins'], 'httplug.collector.history_plugin');
            }

            $def = $container->register('httplug.client.'.$name, DummyClient::class);

            if (empty($arguments['plugins'])) {
                $def->setFactory([new Reference($arguments['factory']), 'createClient'])
                    ->addArgument($arguments['config']);
            } else {
                $def->setFactory('Http\HttplugBundle\ClientFactory\PluginClientFactory::createPluginClient')
                    ->addArgument(array_map(function ($id) {
                        return new Reference($id);
                    }, $arguments['plugins']))
                    ->addArgument(new Reference($arguments['factory']))
                    ->addArgument($arguments['config']);
            }
        }

        // Alias the first client to httplug.client.default
        if ($first !== null) {
            $container->setAlias('httplug.client.default', 'httplug.client.'.$first);
        } elseif (isset($config['_inject_collector_plugin'])) {
            // No client was configured. Make sure to inject history plugin to the auto discovery client.
            $container->register('httplug.client', PluginClient::class)
                ->addArgument(new Reference('httplug.client.default'))
                ->addArgument([new Reference('httplug.collector.history_plugin')]);
        }
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     */
    private function configurePlugins(ContainerBuilder $container, array $config)
    {
        if (!empty($config['authentication'])) {
            $this->configureAuthentication($container, $config['authentication']);
        }
        unset($config['authentication']);

        foreach ($config as $name => $pluginConfig) {
            $pluginId = 'httplug.plugin.'.$name;
            if ($pluginConfig['enabled']) {
                $def = $container->getDefinition($pluginId);
                $this->configurePluginByName($name, $def, $pluginConfig);
            } else {
                $container->removeDefinition($pluginId);
            }
        }
    }

    /**
     * @param string     $name
     * @param Definition $definition
     * @param array      $config
     */
    private function configurePluginByName($name, Definition $definition, array $config)
    {
        switch ($name) {
            case 'cache':
                $definition
                    ->replaceArgument(0, new Reference($config['cache_pool']))
                    ->replaceArgument(1, new Reference($config['stream_factory']))
                    ->replaceArgument(2, $config['config']);
                break;
            case 'cookie':
                $definition->replaceArgument(0, new Reference($config['cookie_jar']));
                break;
            case 'decoder':
                $definition->addArgument($config['use_content_encoding']);
                break;
            case 'history':
                $definition->replaceArgument(0, new Reference($config['journal']));
                break;
            case 'logger':
                $definition->replaceArgument(0, new Reference($config['logger']));
                if (!empty($config['formatter'])) {
                    $definition->replaceArgument(1, new Reference($config['formatter']));
                }
                break;
            case 'redirect':
                $definition
                    ->addArgument($config['preserve_header'])
                    ->addArgument($config['use_default_for_multiple']);
                break;
            case 'retry':
                $definition->addArgument($config['retry']);
                break;
            case 'stopwatch':
                $definition->replaceArgument(0, new Reference($config['stopwatch']));
                break;
        }
    }

    /**
     * @param ContainerBuilder $container
     * @param Definition       $parent
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param array            $config
     */
    private function configureAuthentication(ContainerBuilder $container, array $config)
    {
        foreach ($config as $name => $values) {
            $authServiceKey = sprintf('httplug.plugin.authentication.%s.auth', $name);
            if ($values['type'] === 'bearer') {
                $this->validateAuthenticationConfiguration($values, 'bearer', $name, ['token']);
                $container->register($authServiceKey, Bearer::class)
                    ->addArgument($values['token']);
            } elseif ($values['type'] === 'basic') {
                $this->validateAuthenticationConfiguration($values, 'bearer', $name, ['username', 'password']);
                $container->register($authServiceKey, BasicAuth::class)
                    ->addArgument($values['username'])
                    ->addArgument($values['password']);
            } elseif ($values['type'] === 'wsse') {
                $this->validateAuthenticationConfiguration($values, 'bearer', $name, ['username', 'password']);
                $container->register($authServiceKey, Wsse::class)
                    ->addArgument($values['username'])
                    ->addArgument($values['password']);
            } else {
                throw new \LogicException(sprintf('Unknown authentication type: "%s"', $values['type']));
            }

            $container->register('httplug.plugin.authentication.'.$name, AuthenticationPlugin::class)
                ->addArgument(new Reference($authServiceKey));
        }
    }

    /**
     * Throw a Logic error with a descriptive error if some configuration is missing.
     *
     * @param array  $config
     * @param string $authType
     * @param string $type
     * @param array  $names
     */
    private function validateAuthenticationConfiguration(array $config, $type, $authType, array $names)
    {
        foreach ($names as $name) {
            if (empty($config[$name])) {
                throw new \LogicException(sprintf('When using %s ahtnetication you must configure a value for "httplug.plugins.authentication.%s.%s".', $type, $authType, $name));
            }
        }
    }
}


1			<?php
2
3			namespace Http\HttplugBundle\DependencyInjection;
4
5			use Http\Client\Plugin\AuthenticationPlugin;
6			use Http\Client\Plugin\PluginClient;
7			use Http\HttplugBundle\ClientFactory\DummyClient;
8			use Http\Message\Authentication\BasicAuth;
9			use Http\Message\Authentication\Bearer;
10			use Http\Message\Authentication\Wsse;
11			use Symfony\Component\Config\FileLocator;
12			use Symfony\Component\DependencyInjection\ContainerBuilder;
13			use Symfony\Component\DependencyInjection\Definition;
14			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
15			use Symfony\Component\DependencyInjection\Reference;
16			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
17
18			/**
19			* @author David Buchmann <[email protected]>
20			* @author Tobias Nyholm <[email protected]>
21			*/
22			class HttplugExtension extends Extension
23			{
24			/**
25			* {@inheritdoc}
26			*/
27			public function load(array $configs, ContainerBuilder $container)
28			{
29			$configuration = $this->getConfiguration($configs, $container);
30			$config = $this->processConfiguration($configuration, $configs);
			0 ignored issues – show Documentation introduced 2016-01-15 17:50 UTC by Report Bug Copy Issue Report `$configuration` is of type `object\|null`, but the function expects a `object<Symfony\Component...ConfigurationInterface>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
31
32			$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
33
34			$loader->load('services.xml');
35			$loader->load('plugins.xml');
36			$loader->load('discovery.xml');
37
38			$enabled = is_bool($config['toolbar']['enabled']) ? $config['toolbar']['enabled'] : $container->hasParameter('kernel.debug') && $container->getParameter('kernel.debug');
39			if ($enabled) {
40			$loader->load('data-collector.xml');
41			$config['_inject_collector_plugin'] = true;
42
43			if (!empty($config['toolbar']['formatter'])) {
44			$container->getDefinition('httplug.collector.message_journal')
45			->replaceArgument(0, new Reference($config['toolbar']['formatter']));
46			}
47			}
48
49			foreach ($config['classes'] as $service => $class) {
50			if (!empty($class)) {
51			$container->removeDefinition(sprintf('httplug.%s.default', $service));
52			$container->register(sprintf('httplug.%s.default', $service), $class);
53			}
54			}
55
56			foreach ($config['main_alias'] as $type => $id) {
57			$container->setAlias(sprintf('httplug.%s', $type), $id);
58			}
59			$this->configurePlugins($container, $config['plugins']);
60			$this->configureClients($container, $config);
61			}
62
63			/**
64			* Configure client services.
65			*
66			* @param ContainerBuilder $container
67			* @param array $config
68			*/
69			private function configureClients(ContainerBuilder $container, array $config)
70			{
71			$first = isset($config['clients']['default']) ? 'default' : null;
72			foreach ($config['clients'] as $name => $arguments) {
73			if ($first === null) {
74			$first = $name;
75			}
76
77			if (isset($config['_inject_collector_plugin'])) {
78			array_unshift($arguments['plugins'], 'httplug.collector.history_plugin');
79			}
80
81			$def = $container->register('httplug.client.'.$name, DummyClient::class);
82
83			if (empty($arguments['plugins'])) {
84			$def->setFactory([new Reference($arguments['factory']), 'createClient'])
85			->addArgument($arguments['config']);
86			} else {
87			$def->setFactory('Http\HttplugBundle\ClientFactory\PluginClientFactory::createPluginClient')
88			->addArgument(array_map(function ($id) {
89			return new Reference($id);
90			}, $arguments['plugins']))
91			->addArgument(new Reference($arguments['factory']))
92			->addArgument($arguments['config']);
93			}
94			}
95
96			// Alias the first client to httplug.client.default
97			if ($first !== null) {
98			$container->setAlias('httplug.client.default', 'httplug.client.'.$first);
99			} elseif (isset($config['_inject_collector_plugin'])) {
100			// No client was configured. Make sure to inject history plugin to the auto discovery client.
101			$container->register('httplug.client', PluginClient::class)
102			->addArgument(new Reference('httplug.client.default'))
103			->addArgument([new Reference('httplug.collector.history_plugin')]);
104			}
105			}
106
107			/**
108			* @param ContainerBuilder $container
109			* @param array $config
110			*/
111			private function configurePlugins(ContainerBuilder $container, array $config)
112			{
113			if (!empty($config['authentication'])) {
114			$this->configureAuthentication($container, $config['authentication']);
115			}
116			unset($config['authentication']);
117
118			foreach ($config as $name => $pluginConfig) {
119			$pluginId = 'httplug.plugin.'.$name;
120			if ($pluginConfig['enabled']) {
121			$def = $container->getDefinition($pluginId);
122			$this->configurePluginByName($name, $def, $pluginConfig);
123			} else {
124			$container->removeDefinition($pluginId);
125			}
126			}
127			}
128
129			/**
130			* @param string $name
131			* @param Definition $definition
132			* @param array $config
133			*/
134			private function configurePluginByName($name, Definition $definition, array $config)
135			{
136			switch ($name) {
137			case 'cache':
138			$definition
139			->replaceArgument(0, new Reference($config['cache_pool']))
140			->replaceArgument(1, new Reference($config['stream_factory']))
141			->replaceArgument(2, $config['config']);
142			break;
143			case 'cookie':
144			$definition->replaceArgument(0, new Reference($config['cookie_jar']));
145			break;
146			case 'decoder':
147			$definition->addArgument($config['use_content_encoding']);
148			break;
149			case 'history':
150			$definition->replaceArgument(0, new Reference($config['journal']));
151			break;
152			case 'logger':
153			$definition->replaceArgument(0, new Reference($config['logger']));
154			if (!empty($config['formatter'])) {
155			$definition->replaceArgument(1, new Reference($config['formatter']));
156			}
157			break;
158			case 'redirect':
159			$definition
160			->addArgument($config['preserve_header'])
161			->addArgument($config['use_default_for_multiple']);
162			break;
163			case 'retry':
164			$definition->addArgument($config['retry']);
165			break;
166			case 'stopwatch':
167			$definition->replaceArgument(0, new Reference($config['stopwatch']));
168			break;
169			}
170			}
171
172			/**
173			* @param ContainerBuilder $container
174			* @param Definition $parent
			0 ignored issues – show Bug introduced 2016-02-25 14:23 UTC by Report Bug Copy Issue Report There is no parameter named `$parent`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
175			* @param array $config
176			*/
177			private function configureAuthentication(ContainerBuilder $container, array $config)
178			{
179			foreach ($config as $name => $values) {
180			$authServiceKey = sprintf('httplug.plugin.authentication.%s.auth', $name);
181			if ($values['type'] === 'bearer') {
182			$this->validateAuthenticationConfiguration($values, 'bearer', $name, ['token']);
183			$container->register($authServiceKey, Bearer::class)
184			->addArgument($values['token']);
185			} elseif ($values['type'] === 'basic') {
186			$this->validateAuthenticationConfiguration($values, 'bearer', $name, ['username', 'password']);
187			$container->register($authServiceKey, BasicAuth::class)
188			->addArgument($values['username'])
189			->addArgument($values['password']);
190			} elseif ($values['type'] === 'wsse') {
191			$this->validateAuthenticationConfiguration($values, 'bearer', $name, ['username', 'password']);
192			$container->register($authServiceKey, Wsse::class)
193			->addArgument($values['username'])
194			->addArgument($values['password']);
195			} else {
196			throw new \LogicException(sprintf('Unknown authentication type: "%s"', $values['type']));
197			}
198
199			$container->register('httplug.plugin.authentication.'.$name, AuthenticationPlugin::class)
200			->addArgument(new Reference($authServiceKey));
201			}
202			}
203
204			/**
205			* Throw a Logic error with a descriptive error if some configuration is missing.
206			*
207			* @param array $config
208			* @param string $authType
209			* @param string $type
210			* @param array $names
211			*/
212			private function validateAuthenticationConfiguration(array $config, $type, $authType, array $names)
213			{
214			foreach ($names as $name) {
215			if (empty($config[$name])) {
216			throw new \LogicException(sprintf('When using %s ahtnetication you must configure a value for "httplug.plugins.authentication.%s.%s".', $type, $authType, $name));
217			}
218			}
219			}
220			}
221

php-http / HttplugBundle

Pull Request — master (#44)

HttplugExtension::configureAuthentication() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like