HttplugExtension - Code Metrics - Inspection of "Merge pull request #118 from php-http/test-journal" - php-http/HttplugBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4408c9...ec48ab )

by Tobias

created 2016-08-12 09:46 UTC

HttplugExtension B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	378
Duplicated Lines	11.64 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

66.67%

Importance

Changes	23
Bugs	5	Features	9

Metric	Value
wmc	46
c	23
b	5
f	9
lcom	1
cbo	7
dl	44
loc	378
ccs	78
cts	117
cp	0.6667
rs	8.3999

10 Methods

Rating	Name	Duplication	Size	Complexity
B	configureClients()	0	22	5
A	configurePlugins()	0	18	4
B	load()	0	44	6
B	configureClient()	20	70	6
B	configureAutoDiscoveryClients()	24	38	5
B	registerAutoDiscoverableClient()	0	26	2
A	registerDebugPlugin()	0	13	1
A	getConfiguration()	0	4	1
D	configurePluginByName()	0	45	10
B	configureAuthentication()	0	30	6

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like HttplugExtension often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use HttplugExtension, and based on these observations, apply Extract Interface, too.

<?php

namespace Http\HttplugBundle\DependencyInjection;

use Http\Client\Common\BatchClient;
use Http\Client\Common\FlexibleHttpClient;
use Http\Client\Common\HttpMethodsClient;
use Http\Client\Common\Plugin\AuthenticationPlugin;
use Http\Discovery\HttpAsyncClientDiscovery;
use Http\Discovery\HttpClientDiscovery;
use Http\HttplugBundle\ClientFactory\DummyClient;
use Http\HttplugBundle\ClientFactory\PluginClientFactory;
use Http\HttplugBundle\Collector\DebugPlugin;
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);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

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

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

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

        // Set main aliases
        foreach ($config['main_alias'] as $type => $id) {
            $container->setAlias(sprintf('httplug.%s', $type), $id);
        }

        // Configure toolbar
        if ($config['profiling']['enabled']) {
            $loader->load('data-collector.xml');

            if (!empty($config['profiling']['formatter'])) {
                // Add custom formatter
                $container
                    ->getDefinition('httplug.collector.debug_collector')
                    ->replaceArgument(0, new Reference($config['profiling']['formatter']))
                ;
            }

            $container
                ->getDefinition('httplug.formatter.full_http_message')
                ->addArgument($config['profiling']['captured_body_length'])
            ;
        }

        $this->configurePlugins($container, $config['plugins']);
        $this->configureClients($container, $config);
        $this->configureAutoDiscoveryClients($container, $config);
    }

    /**
     * Configure client services.
     *
     * @param ContainerBuilder $container
     * @param array            $config
     */
    private function configureClients(ContainerBuilder $container, array $config)
    {
        $first = null;

        foreach ($config['clients'] as $name => $arguments) {
            if ($first === null) {
                // Save the name of the first configurated client.
                $first = $name;
            }

            $this->configureClient($container, $name, $arguments, $config['profiling']['enabled']);
        }

        // If we have clients configured
        if ($first !== null) {
            // If we do not have a client named 'default'
            if (!isset($config['clients']['default'])) {
                // Alias the first client to httplug.client.default
                $container->setAlias('httplug.client.default', 'httplug.client.'.$first);
            }
        }
    }

    /**
     * @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([
                    'use_content_encoding' => $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([
                    'preserve_header' => $config['preserve_header'],
                    'use_default_for_multiple' => $config['use_default_for_multiple'],
                ]);
                break;
            case 'retry':
                $definition->addArgument([
                    'retries' => $config['retry'],
                ]);
                break;
            case 'stopwatch':
                $definition->replaceArgument(0, new Reference($config['stopwatch']));
                break;

            default:
                throw new \InvalidArgumentException(sprintf('Internal exception: Plugin %s is not handled', $name));
        }
    }

    /**
     * @param ContainerBuilder $container
     * @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));
        }
    }

    /**
     * @param ContainerBuilder $container
     * @param string           $name
     * @param array            $arguments
     * @param bool             $profiling
     */
    private function configureClient(ContainerBuilder $container, $name, array $arguments, $profiling)
    {
        $serviceId = 'httplug.client.'.$name;

        $pluginClientOptions = [];

        if ($profiling) {
            if (!in_array('httplug.plugin.stopwatch', $arguments['plugins'])) {
                // Add the stopwatch plugin
                array_unshift($arguments['plugins'], 'httplug.plugin.stopwatch');
            }

            // Tell the plugin journal what plugins we used
            $container
                ->getDefinition('httplug.collector.plugin_journal')
                ->addMethodCall('setPlugins', [$name, $arguments['plugins']])
            ;

            $debugPluginServiceId = $this->registerDebugPlugin($container, $serviceId);

            $pluginClientOptions['debug_plugins'] = [new Reference($debugPluginServiceId)];
        }

        $container
            ->register($serviceId, DummyClient::class)
            ->setFactory([PluginClientFactory::class, 'createPluginClient'])
            ->addArgument(
                array_map(
                    function ($id) {
                        return new Reference($id);
                    },
                    $arguments['plugins']
                )
            )
            ->addArgument(new Reference($arguments['factory']))
            ->addArgument($arguments['config'])
            ->addArgument($pluginClientOptions)
        ;


        /*
         * Decorate the client with clients from client-common
         */
        if ($arguments['flexible_client']) {

            $container
                ->register($serviceId.'.flexible', FlexibleHttpClient::class)
                ->addArgument(new Reference($serviceId.'.flexible.inner'))
                ->setPublic(false)
                ->setDecoratedService($serviceId)
            ;
        }

        if ($arguments['http_methods_client']) {

            $container
                ->register($serviceId.'.http_methods', HttpMethodsClient::class)
                ->setArguments([new Reference($serviceId.'.http_methods.inner'), new Reference('httplug.message_factory')])
                ->setPublic(false)
                ->setDecoratedService($serviceId)
            ;
        }

        if ($arguments['batch_client']) {

            $container
                ->register($serviceId.'.batch_client', BatchClient::class)
                ->setArguments([new Reference($serviceId.'.batch_client.inner')])
                ->setPublic(false)
                ->setDecoratedService($serviceId)
            ;
        }
    }

    /**
     * Make the user can select what client is used for auto discovery. If none is provided, a service will be created
     * by finding a client using auto discovery.
     *
     * @param ContainerBuilder $container
     * @param array            $config
     */
    private function configureAutoDiscoveryClients(ContainerBuilder $container, array $config)
    {
        $httpClient = $config['discovery']['client'];

        if (!empty($httpClient)) {

            if ($httpClient === 'auto') {
                $httpClient = $this->registerAutoDiscoverableClient(
                    $container,
                    'auto_discovered_client',
                    [HttpClientDiscovery::class, 'find'],
                    $config['profiling']['enabled']
                );
            }

            $httpClient = new Reference($httpClient);
        }

        $asyncHttpClient = $config['discovery']['async_client'];

        if (!empty($asyncHttpClient)) {

            if ($asyncHttpClient === 'auto') {
                $asyncHttpClient = $this->registerAutoDiscoverableClient(
                    $container,
                    'auto_discovered_async',
                    [HttpAsyncClientDiscovery::class, 'find'],
                    $config['profiling']['enabled']
                );
            }

            $asyncHttpClient = new Reference($asyncHttpClient);
        }

        $container
            ->getDefinition('httplug.strategy')
            ->addArgument($httpClient)
            ->addArgument($asyncHttpClient)
        ;
    }

    /**
     * Find a client with auto discovery and return a service Reference to it.
     *
     * @param ContainerBuilder $container
     * @param string           $name
     * @param callable         $factory
     * @param bool             $profiling
     *
     * @return string service id
     */
    private function registerAutoDiscoverableClient(ContainerBuilder $container, $name, $factory, $profiling)
    {
        $serviceId = 'httplug.auto_discovery.'.$name;

        $pluginClientOptions = [];

        if ($profiling) {
            // Tell the plugin journal what plugins we used
            $container
                ->getDefinition('httplug.collector.plugin_journal')
                ->addMethodCall('setPlugins', [$name, ['httplug.plugin.stopwatch']])
            ;

            $debugPluginServiceId = $this->registerDebugPlugin($container, $serviceId);

            $pluginClientOptions['debug_plugins'] = [new Reference($debugPluginServiceId)];
        }

        $container
            ->register($serviceId, DummyClient::class)
            ->setFactory([PluginClientFactory::class, 'createPluginClient'])
            ->setArguments([[new Reference('httplug.plugin.stopwatch')], $factory, [], $pluginClientOptions])
        ;

        return $serviceId;
    }

    /**
     * Create a new plugin service for this client.
     *
     * @param ContainerBuilder $container
     * @param string           $serviceId
     *
     * @return string
     */
    private function registerDebugPlugin(ContainerBuilder $container, $serviceId)
    {
        $serviceIdDebugPlugin = $serviceId.'.debug_plugin';

        $container
            ->register($serviceIdDebugPlugin, DebugPlugin::class)
            ->addArgument(new Reference('httplug.collector.debug_collector'))
            ->addArgument(substr($serviceId, strrpos($serviceId, '.') + 1))
            ->setPublic(false)
        ;

        return $serviceIdDebugPlugin;
    }

    /**
     * {@inheritdoc}
     */
    public function getConfiguration(array $config, ContainerBuilder $container)
    {
        return new Configuration($container->getParameter('kernel.debug'));
    }
}


1			<?php
2
3			namespace Http\HttplugBundle\DependencyInjection;
4
5			use Http\Client\Common\BatchClient;
6			use Http\Client\Common\FlexibleHttpClient;
7			use Http\Client\Common\HttpMethodsClient;
8			use Http\Client\Common\Plugin\AuthenticationPlugin;
9			use Http\Discovery\HttpAsyncClientDiscovery;
10			use Http\Discovery\HttpClientDiscovery;
11			use Http\HttplugBundle\ClientFactory\DummyClient;
12			use Http\HttplugBundle\ClientFactory\PluginClientFactory;
13			use Http\HttplugBundle\Collector\DebugPlugin;
14			use Http\Message\Authentication\BasicAuth;
15			use Http\Message\Authentication\Bearer;
16			use Http\Message\Authentication\Wsse;
17			use Symfony\Component\Config\FileLocator;
18			use Symfony\Component\DependencyInjection\ContainerBuilder;
19			use Symfony\Component\DependencyInjection\Definition;
20			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
21			use Symfony\Component\DependencyInjection\Reference;
22			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
23
24			/**
25			* @author David Buchmann <[email protected]>
26			* @author Tobias Nyholm <[email protected]>
27			*/
28			class HttplugExtension extends Extension
29			{
30			/**
31			* {@inheritdoc}
32			*/
33	8		public function load(array $configs, ContainerBuilder $container)
34			{
35	8		$configuration = $this->getConfiguration($configs, $container);
36	8		$config = $this->processConfiguration($configuration, $configs);
			1 ignored issue – show Bug introduced 2016-07-24 10:10 UTC by Report Bug Copy Issue Report It seems like `$configuration` defined by `$this->getConfiguration($configs, $container)` on line `35` can be `null`; however, `Symfony\Component\Depend...:processConfiguration()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
37
38	8		$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
39
40	8		$loader->load('services.xml');
41	8		$loader->load('plugins.xml');
42
43			// Register default services
44	8		foreach ($config['classes'] as $service => $class) {
45	8		if (!empty($class)) {
46	1		$container->register(sprintf('httplug.%s.default', $service), $class);
47	1		}
48	8		}
49
50			// Set main aliases
51	8		foreach ($config['main_alias'] as $type => $id) {
52	8		$container->setAlias(sprintf('httplug.%s', $type), $id);
53	8		}
54
55			// Configure toolbar
56	8		if ($config['profiling']['enabled']) {
57	5		$loader->load('data-collector.xml');
58
59	5		if (!empty($config['profiling']['formatter'])) {
60			// Add custom formatter
61			$container
62			->getDefinition('httplug.collector.debug_collector')
63			->replaceArgument(0, new Reference($config['profiling']['formatter']))
64			;
65			}
66
67			$container
68	5		->getDefinition('httplug.formatter.full_http_message')
69	5		->addArgument($config['profiling']['captured_body_length'])
70			;
71	5		}
72
73	8		$this->configurePlugins($container, $config['plugins']);
74	8		$this->configureClients($container, $config);
75	8		$this->configureAutoDiscoveryClients($container, $config);
76	8		}
77
78			/**
79			* Configure client services.
80			*
81			* @param ContainerBuilder $container
82			* @param array $config
83			*/
84	8		private function configureClients(ContainerBuilder $container, array $config)
85			{
86	8		$first = null;
87
88	8		foreach ($config['clients'] as $name => $arguments) {
89	5		if ($first === null) {
90			// Save the name of the first configurated client.
91	5		$first = $name;
92	5		}
93
94	5		$this->configureClient($container, $name, $arguments, $config['profiling']['enabled']);
95	8		}
96
97			// If we have clients configured
98	8		if ($first !== null) {
99			// If we do not have a client named 'default'
100	5		if (!isset($config['clients']['default'])) {
101			// Alias the first client to httplug.client.default
102	5		$container->setAlias('httplug.client.default', 'httplug.client.'.$first);
103	5		}
104	5		}
105	8		}
106
107			/**
108			* @param ContainerBuilder $container
109			* @param array $config
110			*/
111	8		private function configurePlugins(ContainerBuilder $container, array $config)
112			{
113	8		if (!empty($config['authentication'])) {
114			$this->configureAuthentication($container, $config['authentication']);
115			}
116	8		unset($config['authentication']);
117
118	8		foreach ($config as $name => $pluginConfig) {
119	8		$pluginId = 'httplug.plugin.'.$name;
120
121	8		if ($pluginConfig['enabled']) {
122	8		$def = $container->getDefinition($pluginId);
123	8		$this->configurePluginByName($name, $def, $pluginConfig);
124	8		} else {
125	8		$container->removeDefinition($pluginId);
126			}
127	8		}
128	8		}
129
130			/**
131			* @param string $name
132			* @param Definition $definition
133			* @param array $config
134			*/
135	8		private function configurePluginByName($name, Definition $definition, array $config)
136			{
137			switch ($name) {
138	8		case 'cache':
139			$definition
140			->replaceArgument(0, new Reference($config['cache_pool']))
141			->replaceArgument(1, new Reference($config['stream_factory']))
142			->replaceArgument(2, $config['config']);
143			break;
144	8		case 'cookie':
145			$definition->replaceArgument(0, new Reference($config['cookie_jar']));
146			break;
147	8		case 'decoder':
148	8		$definition->addArgument([
149	8		'use_content_encoding' => $config['use_content_encoding'],
150	8		]);
151	8		break;
152	8		case 'history':
153			$definition->replaceArgument(0, new Reference($config['journal']));
154			break;
155	8		case 'logger':
156	8		$definition->replaceArgument(0, new Reference($config['logger']));
157	8		if (!empty($config['formatter'])) {
158			$definition->replaceArgument(1, new Reference($config['formatter']));
159			}
160	8		break;
161	8		case 'redirect':
162	8		$definition->addArgument([
163	8		'preserve_header' => $config['preserve_header'],
164	8		'use_default_for_multiple' => $config['use_default_for_multiple'],
165	8		]);
166	8		break;
167	8		case 'retry':
168	8		$definition->addArgument([
169	8		'retries' => $config['retry'],
170	8		]);
171	8		break;
172	8		case 'stopwatch':
173	8		$definition->replaceArgument(0, new Reference($config['stopwatch']));
174	8		break;
175
176			default:
177			throw new \InvalidArgumentException(sprintf('Internal exception: Plugin %s is not handled', $name));
178			}
179	8		}
180
181			/**
182			* @param ContainerBuilder $container
183			* @param array $config
184			*/
185			private function configureAuthentication(ContainerBuilder $container, array $config)
186			{
187			foreach ($config as $name => $values) {
188			$authServiceKey = sprintf('httplug.plugin.authentication.%s.auth', $name);
189			switch ($values['type']) {
190			case 'bearer':
191			$container->register($authServiceKey, Bearer::class)
192			->addArgument($values['token']);
193			break;
194			case 'basic':
195			$container->register($authServiceKey, BasicAuth::class)
196			->addArgument($values['username'])
197			->addArgument($values['password']);
198			break;
199			case 'wsse':
200			$container->register($authServiceKey, Wsse::class)
201			->addArgument($values['username'])
202			->addArgument($values['password']);
203			break;
204			case 'service':
205			$authServiceKey = $values['service'];
206			break;
207			default:
208			throw new \LogicException(sprintf('Unknown authentication type: "%s"', $values['type']));
209			}
210
211			$container->register('httplug.plugin.authentication.'.$name, AuthenticationPlugin::class)
212			->addArgument(new Reference($authServiceKey));
213			}
214			}
215
216			/**
217			* @param ContainerBuilder $container
218			* @param string $name
219			* @param array $arguments
220			* @param bool $profiling
221			*/
222			private function configureClient(ContainerBuilder $container, $name, array $arguments, $profiling)
223			{
224			$serviceId = 'httplug.client.'.$name;
225
226			$pluginClientOptions = [];
227
228			if ($profiling) {
229			if (!in_array('httplug.plugin.stopwatch', $arguments['plugins'])) {
230			// Add the stopwatch plugin
231			array_unshift($arguments['plugins'], 'httplug.plugin.stopwatch');
232			}
233
234			// Tell the plugin journal what plugins we used
235			$container
236			->getDefinition('httplug.collector.plugin_journal')
237			->addMethodCall('setPlugins', [$name, $arguments['plugins']])
238			;
239
240			$debugPluginServiceId = $this->registerDebugPlugin($container, $serviceId);
241
242			$pluginClientOptions['debug_plugins'] = [new Reference($debugPluginServiceId)];
243			}
244
245			$container
246			->register($serviceId, DummyClient::class)
247			->setFactory([PluginClientFactory::class, 'createPluginClient'])
248			->addArgument(
249			array_map(
250			function ($id) {
251			return new Reference($id);
252			},
253			$arguments['plugins']
254			)
255			)
256			->addArgument(new Reference($arguments['factory']))
257			->addArgument($arguments['config'])
258			->addArgument($pluginClientOptions)
259			;
260
261
262			/*
263			* Decorate the client with clients from client-common
264			*/
265		View Code Duplication	if ($arguments['flexible_client']) {
			0 ignored issues – show Duplication introduced 2016-06-29 21:35 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
266			$container
267			->register($serviceId.'.flexible', FlexibleHttpClient::class)
268			->addArgument(new Reference($serviceId.'.flexible.inner'))
269			->setPublic(false)
270			->setDecoratedService($serviceId)
271			;
272			}
273
274		View Code Duplication	if ($arguments['http_methods_client']) {
			0 ignored issues – show Duplication introduced 2016-06-30 08:00 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
275			$container
276			->register($serviceId.'.http_methods', HttpMethodsClient::class)
277			->setArguments([new Reference($serviceId.'.http_methods.inner'), new Reference('httplug.message_factory')])
278			->setPublic(false)
279			->setDecoratedService($serviceId)
280			;
281			}
282
283		View Code Duplication	if ($arguments['batch_client']) {
			0 ignored issues – show Duplication introduced 2016-07-25 01:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
284			$container
285			->register($serviceId.'.batch_client', BatchClient::class)
286			->setArguments([new Reference($serviceId.'.batch_client.inner')])
287			->setPublic(false)
288			->setDecoratedService($serviceId)
289			;
290			}
291			}
292
293			/**
294			* Make the user can select what client is used for auto discovery. If none is provided, a service will be created
295			* by finding a client using auto discovery.
296			*
297			* @param ContainerBuilder $container
298			* @param array $config
299			*/
300			private function configureAutoDiscoveryClients(ContainerBuilder $container, array $config)
301			{
302			$httpClient = $config['discovery']['client'];
303
304		View Code Duplication	if (!empty($httpClient)) {
			0 ignored issues – show Duplication introduced 2016-07-20 16:14 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
305			if ($httpClient === 'auto') {
306			$httpClient = $this->registerAutoDiscoverableClient(
307			$container,
308			'auto_discovered_client',
309			[HttpClientDiscovery::class, 'find'],
310			$config['profiling']['enabled']
311			);
312			}
313
314			$httpClient = new Reference($httpClient);
315			}
316
317			$asyncHttpClient = $config['discovery']['async_client'];
318
319		View Code Duplication	if (!empty($asyncHttpClient)) {
			0 ignored issues – show Duplication introduced 2016-07-20 16:14 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
320			if ($asyncHttpClient === 'auto') {
321			$asyncHttpClient = $this->registerAutoDiscoverableClient(
322			$container,
323			'auto_discovered_async',
324			[HttpAsyncClientDiscovery::class, 'find'],
325			$config['profiling']['enabled']
326			);
327			}
328
329			$asyncHttpClient = new Reference($asyncHttpClient);
330			}
331
332			$container
333			->getDefinition('httplug.strategy')
334			->addArgument($httpClient)
335			->addArgument($asyncHttpClient)
336			;
337			}
338
339			/**
340			* Find a client with auto discovery and return a service Reference to it.
341			*
342			* @param ContainerBuilder $container
343			* @param string $name
344			* @param callable $factory
345			* @param bool $profiling
346			*
347			* @return string service id
348			*/
349			private function registerAutoDiscoverableClient(ContainerBuilder $container, $name, $factory, $profiling)
350			{
351			$serviceId = 'httplug.auto_discovery.'.$name;
352
353			$pluginClientOptions = [];
354
355			if ($profiling) {
356			// Tell the plugin journal what plugins we used
357			$container
358			->getDefinition('httplug.collector.plugin_journal')
359			->addMethodCall('setPlugins', [$name, ['httplug.plugin.stopwatch']])
360			;
361
362			$debugPluginServiceId = $this->registerDebugPlugin($container, $serviceId);
363
364			$pluginClientOptions['debug_plugins'] = [new Reference($debugPluginServiceId)];
365			}
366
367			$container
368			->register($serviceId, DummyClient::class)
369			->setFactory([PluginClientFactory::class, 'createPluginClient'])
370			->setArguments([[new Reference('httplug.plugin.stopwatch')], $factory, [], $pluginClientOptions])
371			;
372
373			return $serviceId;
374			}
375
376			/**
377			* Create a new plugin service for this client.
378			*
379			* @param ContainerBuilder $container
380			* @param string $serviceId
381			*
382			* @return string
383			*/
384			private function registerDebugPlugin(ContainerBuilder $container, $serviceId)
385			{
386			$serviceIdDebugPlugin = $serviceId.'.debug_plugin';
387
388			$container
389			->register($serviceIdDebugPlugin, DebugPlugin::class)
390			->addArgument(new Reference('httplug.collector.debug_collector'))
391			->addArgument(substr($serviceId, strrpos($serviceId, '.') + 1))
392			->setPublic(false)
393			;
394
395			return $serviceIdDebugPlugin;
396			}
397
398			/**
399			* {@inheritdoc}
400			*/
401			public function getConfiguration(array $config, ContainerBuilder $container)
402			{
403			return new Configuration($container->getParameter('kernel.debug'));
404			}
405			}
406

php-http / HttplugBundle