HttplugExtension::load() - Code Metrics - Inspection of "[POC] how to not be dependent on discovery" - php-http/HttplugBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#54)

by Tobias

created 2016-02-29 05:17 UTC

HttplugExtension::load() D

↳ Parent: HttplugExtension

Complexity

Conditions	9
Paths	144

Size

Total Lines	44
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	22
CRAP Score	10.1394

Importance

Changes	7
Bugs	1	Features	3

Metric	Value
c	7
b	1
f	3
dl	0
loc	44
ccs	22
cts	29
cp	0.7586
rs	4.6666
cc	9
eloc	27
nc	144
nop	2
crap	10.1394

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

        $useDiscovery = false;
        foreach ($config['classes'] as $service => $class) {
            if (!empty($class)) {
                $container->removeDefinition(sprintf('httplug.%s.default', $service));
                $container->register(sprintf('httplug.%s.default', $service), $class);
            } else {
                // we have to use discovery to find this class
                $useDiscovery = true;
            }
        }

        if ($useDiscovery) {
            $this->verifyDiscoveryInstalled($container);
        }


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

    /**
     * Verify that Puli is installed
     *
     * @param ContainerBuilder $container
     * @throws \Exception
     */
    private function verifyDiscoveryInstalled(ContainerBuilder $container)
    {
        $enabledBundles = $container->getParameter('kernel.bundles');
        if (!isset($enabledBundles['PuliSymfonyBundle'])) {
            throw new \Exception(
                'You need to install puli/symfony-bundle or add configuration at httplug.classes in order to use this bundle. Refer to http://some.doc'
            );
        }

        // .... OR
        if (defined('PULI_FACTORY')) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
            // Throw exception
        }
    }
}


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	$useDiscovery = false;
50	3	foreach ($config['classes'] as $service => $class) {
51	1	if (!empty($class)) {
52	1	$container->removeDefinition(sprintf('httplug.%s.default', $service));
53	1	$container->register(sprintf('httplug.%s.default', $service), $class);
54	3	} else {
55		// we have to use discovery to find this class
56	3	$useDiscovery = true;
57	3	}
58	3	}
59	3
60	3	if ($useDiscovery) {
61	3	$this->verifyDiscoveryInstalled($container);
62		}
63
64
65		foreach ($config['main_alias'] as $type => $id) {
66		$container->setAlias(sprintf('httplug.%s', $type), $id);
67		}
68		$this->configurePlugins($container, $config['plugins']);
69	3	$this->configureClients($container, $config);
70		}
71	3
72	3	/**
73		* Configure client services.
74		*
75		* @param ContainerBuilder $container
76		* @param array $config
77		*/
78		private function configureClients(ContainerBuilder $container, array $config)
79		{
80		$first = isset($config['clients']['default']) ? 'default' : null;
81		foreach ($config['clients'] as $name => $arguments) {
82		if ($first === null) {
83		$first = $name;
84		}
85
86		if (isset($config['_inject_collector_plugin'])) {
87		array_unshift($arguments['plugins'], 'httplug.collector.history_plugin');
88		}
89
90		$def = $container->register('httplug.client.'.$name, DummyClient::class);
91
92		if (empty($arguments['plugins'])) {
93		$def->setFactory([new Reference($arguments['factory']), 'createClient'])
94	3	->addArgument($arguments['config']);
95		} else {
96		$def->setFactory('Http\HttplugBundle\ClientFactory\PluginClientFactory::createPluginClient')
97	3	->addArgument(array_map(function ($id) {
98		return new Reference($id);
99		}, $arguments['plugins']))
100		->addArgument(new Reference($arguments['factory']))
101		->addArgument($arguments['config']);
102	3	}
103		}
104
105		// If we have clients configured
106		if ($first !== null) {
107		if ($first !== 'default') {
108		// Alias the first client to httplug.client.default
109		$container->setAlias('httplug.client.default', 'httplug.client.'.$first);
110		}
111		} elseif (isset($config['_inject_collector_plugin'])) {
112		// No client was configured. Make sure to inject history plugin to the auto discovery client.
113		$container->register('httplug.client', PluginClient::class)
114		->addArgument(new Reference('httplug.client.default'))
115		->addArgument([new Reference('httplug.collector.history_plugin')]);
116		}
117		}
118
119		/**
120		* @param ContainerBuilder $container
121		* @param array $config
122		*/
123		private function configurePlugins(ContainerBuilder $container, array $config)
124		{
125		if (!empty($config['authentication'])) {
126		$this->configureAuthentication($container, $config['authentication']);
127		}
128		unset($config['authentication']);
129
130		foreach ($config as $name => $pluginConfig) {
131		$pluginId = 'httplug.plugin.'.$name;
132		if ($pluginConfig['enabled']) {
133		$def = $container->getDefinition($pluginId);
134		$this->configurePluginByName($name, $def, $pluginConfig);
135		} else {
136		$container->removeDefinition($pluginId);
137		}
138		}
139		}
140
141		/**
142		* @param string $name
143		* @param Definition $definition
144		* @param array $config
145		*/
146		private function configurePluginByName($name, Definition $definition, array $config)
147		{
148		switch ($name) {
149		case 'cache':
150		$definition
151		->replaceArgument(0, new Reference($config['cache_pool']))
152		->replaceArgument(1, new Reference($config['stream_factory']))
153		->replaceArgument(2, $config['config']);
154		break;
155		case 'cookie':
156		$definition->replaceArgument(0, new Reference($config['cookie_jar']));
157		break;
158		case 'decoder':
159		$definition->addArgument($config['use_content_encoding']);
160		break;
161		case 'history':
162		$definition->replaceArgument(0, new Reference($config['journal']));
163		break;
164		case 'logger':
165		$definition->replaceArgument(0, new Reference($config['logger']));
166		if (!empty($config['formatter'])) {
167		$definition->replaceArgument(1, new Reference($config['formatter']));
168		}
169		break;
170		case 'redirect':
171		$definition
172		->addArgument($config['preserve_header'])
173		->addArgument($config['use_default_for_multiple']);
174		break;
175		case 'retry':
176		$definition->addArgument($config['retry']);
177		break;
178		case 'stopwatch':
179		$definition->replaceArgument(0, new Reference($config['stopwatch']));
180		break;
181		}
182		}
183
184		/**
185		* @param ContainerBuilder $container
186		* @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...
187		* @param array $config
188		*/
189		private function configureAuthentication(ContainerBuilder $container, array $config)
190		{
191		foreach ($config as $name => $values) {
192		$authServiceKey = sprintf('httplug.plugin.authentication.%s.auth', $name);
193		switch ($values['type']) {
194		case 'bearer':
195		$container->register($authServiceKey, Bearer::class)
196		->addArgument($values['token']);
197		break;
198		case 'basic':
199		$container->register($authServiceKey, BasicAuth::class)
200		->addArgument($values['username'])
201		->addArgument($values['password']);
202		break;
203		case 'wsse':
204		$container->register($authServiceKey, Wsse::class)
205		->addArgument($values['username'])
206		->addArgument($values['password']);
207		break;
208		case 'service':
209		$authServiceKey = $values['service'];
210		break;
211		default:
212		throw new \LogicException(sprintf('Unknown authentication type: "%s"', $values['type']));
213		}
214
215		$container->register('httplug.plugin.authentication.'.$name, AuthenticationPlugin::class)
216		->addArgument(new Reference($authServiceKey));
217		}
218		}
219
220		/**
221		* Verify that Puli is installed
222		*
223		* @param ContainerBuilder $container
224		* @throws \Exception
225		*/
226		private function verifyDiscoveryInstalled(ContainerBuilder $container)
227		{
228		$enabledBundles = $container->getParameter('kernel.bundles');
229		if (!isset($enabledBundles['PuliSymfonyBundle'])) {
230		throw new \Exception(
231		'You need to install puli/symfony-bundle or add configuration at httplug.classes in order to use this bundle. Refer to http://some.doc'
232		);
233		}
234
235		// .... OR
236		if (defined('PULI_FACTORY')) {
		0 ignored issues – show Unused Code introduced 2016-02-29 05:25 UTC by Report Bug Copy Issue Report This `if` statement is empty and can be removed. This check looks for the bodies of `if` statements that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. These `if` bodies can be removed. If you have an empty if but statements in the `else` branch, consider inverting the condition. if (rand(1, 6) > 3) { //print "Check failed"; } else { print "Check succeeded"; } could be turned into if (rand(1, 6) <= 3) { print "Check succeeded"; } This is much more concise to read. Loading history...
237		// Throw exception
238		}
239		}
240		}
241

php-http / HttplugBundle

Pull Request — master (#54)

HttplugExtension::load() D

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like