HttplugExtension::configureAuthentication() - Code Metrics - Inspection of "Adding clients factories for Curl, React and Socke..." - php-http/HttplugBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#59)

by Tobias

created 2016-03-01 17:14 UTC

HttplugExtension::configureAuthentication() B

↳ Parent: HttplugExtension

Complexity

Conditions	6
Paths	6

Size

Total Lines	30
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	30
ccs	0
cts	0
cp	0
rs	8.439
cc	6
eloc	25
nc	6
nop	2
crap	42

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

        // If we have clients configured
        if ($first !== null) {
            if ($first !== 'default') {
                // Alias the first client to httplug.client.default
                $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);
            switch ($values['type']) {
                case 'bearer':
                    $container->register($authServiceKey, Bearer::class)
                        ->addArgument($values['token']);
                    break;
                case 'basic':
                    $container->register($authServiceKey, BasicAuth::class)
                        ->addArgument($values['username'])
                        ->addArgument($values['password']);
                    break;
                case 'wsse':
                    $container->register($authServiceKey, Wsse::class)
                        ->addArgument($values['username'])
                        ->addArgument($values['password']);
                    break;
                case 'service':
                    $authServiceKey = $values['service'];
                    break;
                default:
                    throw new \LogicException(sprintf('Unknown authentication type: "%s"', $values['type']));
            }

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


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	3	public function load(array $configs, ContainerBuilder $container)
28		{
29	3	$configuration = $this->getConfiguration($configs, $container);
30	3	$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	3	$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
33
34	3	$loader->load('services.xml');
35	3	$loader->load('plugins.xml');
36	3	$loader->load('discovery.xml');
37
38	3	$enabled = is_bool($config['toolbar']['enabled']) ? $config['toolbar']['enabled'] : $container->hasParameter('kernel.debug') && $container->getParameter('kernel.debug');
39	3	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	3	foreach ($config['classes'] as $service => $class) {
50	3	if (!empty($class)) {
51	1	$container->removeDefinition(sprintf('httplug.%s.default', $service));
52	1	$container->register(sprintf('httplug.%s.default', $service), $class);
53	1	}
54	3	}
55
56	3	foreach ($config['main_alias'] as $type => $id) {
57	3	$container->setAlias(sprintf('httplug.%s', $type), $id);
58	3	}
59	3	$this->configurePlugins($container, $config['plugins']);
60	3	$this->configureClients($container, $config);
61	3	}
62
63		/**
64		* Configure client services.
65		*
66		* @param ContainerBuilder $container
67		* @param array $config
68		*/
69	3	private function configureClients(ContainerBuilder $container, array $config)
70		{
71	3	$first = isset($config['clients']['default']) ? 'default' : null;
72	3	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	3	}
95
96		// If we have clients configured
97	3	if ($first !== null) {
98		if ($first !== 'default') {
99		// Alias the first client to httplug.client.default
100		$container->setAlias('httplug.client.default', 'httplug.client.'.$first);
101		}
102	3	} elseif (isset($config['_inject_collector_plugin'])) {
103		// No client was configured. Make sure to inject history plugin to the auto discovery client.
104		$container->register('httplug.client', PluginClient::class)
105		->addArgument(new Reference('httplug.client.default'))
106		->addArgument([new Reference('httplug.collector.history_plugin')]);
107		}
108		}
109
110		/**
111		* @param ContainerBuilder $container
112		* @param array $config
113		*/
114		private function configurePlugins(ContainerBuilder $container, array $config)
115		{
116		if (!empty($config['authentication'])) {
117		$this->configureAuthentication($container, $config['authentication']);
118		}
119		unset($config['authentication']);
120
121		foreach ($config as $name => $pluginConfig) {
122		$pluginId = 'httplug.plugin.'.$name;
123		if ($pluginConfig['enabled']) {
124		$def = $container->getDefinition($pluginId);
125		$this->configurePluginByName($name, $def, $pluginConfig);
126		} else {
127		$container->removeDefinition($pluginId);
128		}
129		}
130		}
131
132		/**
133		* @param string $name
134		* @param Definition $definition
135		* @param array $config
136		*/
137		private function configurePluginByName($name, Definition $definition, array $config)
138		{
139		switch ($name) {
140		case 'cache':
141		$definition
142		->replaceArgument(0, new Reference($config['cache_pool']))
143		->replaceArgument(1, new Reference($config['stream_factory']))
144		->replaceArgument(2, $config['config']);
145		break;
146		case 'cookie':
147		$definition->replaceArgument(0, new Reference($config['cookie_jar']));
148		break;
149		case 'decoder':
150		$definition->addArgument($config['use_content_encoding']);
151		break;
152		case 'history':
153		$definition->replaceArgument(0, new Reference($config['journal']));
154		break;
155		case 'logger':
156		$definition->replaceArgument(0, new Reference($config['logger']));
157		if (!empty($config['formatter'])) {
158		$definition->replaceArgument(1, new Reference($config['formatter']));
159		}
160		break;
161		case 'redirect':
162		$definition
163		->addArgument($config['preserve_header'])
164		->addArgument($config['use_default_for_multiple']);
165		break;
166		case 'retry':
167		$definition->addArgument($config['retry']);
168		break;
169		case 'stopwatch':
170		$definition->replaceArgument(0, new Reference($config['stopwatch']));
171		break;
172		}
173		}
174
175		/**
176		* @param ContainerBuilder $container
177		* @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...
178		* @param array $config
179		*/
180		private function configureAuthentication(ContainerBuilder $container, array $config)
181		{
182		foreach ($config as $name => $values) {
183		$authServiceKey = sprintf('httplug.plugin.authentication.%s.auth', $name);
184		switch ($values['type']) {
185		case 'bearer':
186		$container->register($authServiceKey, Bearer::class)
187		->addArgument($values['token']);
188		break;
189		case 'basic':
190		$container->register($authServiceKey, BasicAuth::class)
191		->addArgument($values['username'])
192		->addArgument($values['password']);
193		break;
194		case 'wsse':
195		$container->register($authServiceKey, Wsse::class)
196		->addArgument($values['username'])
197		->addArgument($values['password']);
198		break;
199		case 'service':
200		$authServiceKey = $values['service'];
201		break;
202		default:
203		throw new \LogicException(sprintf('Unknown authentication type: "%s"', $values['type']));
204		}
205
206		$container->register('httplug.plugin.authentication.'.$name, AuthenticationPlugin::class)
207		->addArgument(new Reference($authServiceKey));
208		}
209		}
210		}
211

php-http / HttplugBundle

Pull Request — master (#59)

HttplugExtension::configureAuthentication() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like