PluginClient::configure() - Code Metrics - Inspection of "deprecate debug_plugin options" - php-http/client-common - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#64)

by Fabien

created 2017-03-24 12:28 UTC

PluginClient::configure() B

↳ Parent: PluginClient

Complexity

Conditions	4
Paths	2

Size

Total Lines	27
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	4.0032

Importance

Changes

Metric	Value
dl	0
loc	27
ccs	16
cts	17
cp	0.9412
rs	8.5806
c	0
b	0
f	0
cc	4
eloc	15
nc	2
nop	1
crap	4.0032

<?php

namespace Http\Client\Common;

use Http\Client\Common\Exception\LoopException;
use Http\Client\Exception as HttplugException;
use Http\Client\HttpAsyncClient;
use Http\Client\HttpClient;
use Http\Client\Promise\HttpFulfilledPromise;
use Http\Client\Promise\HttpRejectedPromise;
use Psr\Http\Message\RequestInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

/**
 * The client managing plugins and providing a decorator around HTTP Clients.
 *
 * @author Joel Wurtz <[email protected]>
 */
final class PluginClient implements HttpClient, HttpAsyncClient
{
    /**
     * An HTTP async client.
     *
     * @var HttpAsyncClient
     */
    private $client;

    /**
     * The plugin chain.
     *
     * @var Plugin[]
     */
    private $plugins;

    /**
     * A list of options.
     *
     * @var array
     */
    private $options;

    /**
     * @param HttpClient|HttpAsyncClient $client
     * @param Plugin[]                   $plugins
     * @param array                      $options {
     *
     *     @var int      $max_restarts
     *     @var Plugin[] $debug_plugins an array of plugins that are injected between each normal plugin
     * }
     *
     * @throws \RuntimeException if client is not an instance of HttpClient or HttpAsyncClient
     */
    public function __construct($client, array $plugins = [], array $options = [])
    {
        if ($client instanceof HttpAsyncClient) {
            $this->client = $client;
        } elseif ($client instanceof HttpClient) {
            $this->client = new EmulatedHttpAsyncClient($client);
        } else {
            throw new \RuntimeException('Client must be an instance of Http\\Client\\HttpClient or Http\\Client\\HttpAsyncClient');
        }

        $this->plugins = $plugins;
        $this->options = $this->configure($options);
    }

    /**
     * {@inheritdoc}
     */
    public function sendRequest(RequestInterface $request)
    {
        // If we don't have an http client, use the async call
        if (!($this->client instanceof HttpClient)) {
            return $this->sendAsyncRequest($request)->wait();
        }

        // Else we want to use the synchronous call of the underlying client, and not the async one in the case
        // we have both an async and sync call
        $pluginChain = $this->createPluginChain($this->plugins, function (RequestInterface $request) {
            try {
                return new HttpFulfilledPromise($this->client->sendRequest($request));
            } catch (HttplugException $exception) {
                return new HttpRejectedPromise($exception);
            }
        });

        return $pluginChain($request)->wait();
    }

    /**
     * {@inheritdoc}
     */
    public function sendAsyncRequest(RequestInterface $request)
    {
        $pluginChain = $this->createPluginChain($this->plugins, function (RequestInterface $request) {
            return $this->client->sendAsyncRequest($request);
        });

        return $pluginChain($request);
    }

    /**
     * Configure the plugin client.
     *
     * @param array $options
     *
     * @return array
     */
    private function configure(array $options = [])
    {
        if (isset($options['debug_plugins'])) {
            @trigger_error('The "debug_plugins" option is deprecated since 1.5 and will be removed in 2.0.', E_USER_DEPRECATED);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
        }

        $resolver = new OptionsResolver();
        $resolver->setDefaults([
            'max_restarts' => 10,
            'debug_plugins' => [],
        ]);

        $resolver
            ->setAllowedTypes('debug_plugins', 'array')
            ->setAllowedValues('debug_plugins', function (array $plugins) {
                foreach ($plugins as $plugin) {
                    // Make sure each object passed with the `debug_plugins` is an instance of Plugin.
                    if (!$plugin instanceof Plugin) {
                        return false;
                    }
                }

                return true;
            });

        return $resolver->resolve($options);
    }

    /**
     * Create the plugin chain.
     *
     * @param Plugin[] $pluginList     A list of plugins
     * @param callable $clientCallable Callable making the HTTP call
     *
     * @return callable
     */
    private function createPluginChain($pluginList, callable $clientCallable)
    {
        $firstCallable = $lastCallable = $clientCallable;

        /*
         * Inject debug plugins between each plugin.
         */
        $pluginListWithDebug = $this->options['debug_plugins'];
        foreach ($pluginList as $plugin) {
            $pluginListWithDebug[] = $plugin;
            $pluginListWithDebug = array_merge($pluginListWithDebug, $this->options['debug_plugins']);
        }

        while ($plugin = array_pop($pluginListWithDebug)) {
            $lastCallable = function (RequestInterface $request) use ($plugin, $lastCallable, &$firstCallable) {
                return $plugin->handleRequest($request, $lastCallable, $firstCallable);
            };

            $firstCallable = $lastCallable;
        }

        $firstCalls = 0;
        $firstCallable = function (RequestInterface $request) use ($lastCallable, &$firstCalls) {
            if ($firstCalls > $this->options['max_restarts']) {
                throw new LoopException('Too many restarts in plugin client', $request);
            }

            ++$firstCalls;

            return $lastCallable($request);
        };

        return $firstCallable;
    }
}


1		<?php
2
3		namespace Http\Client\Common;
4
5		use Http\Client\Common\Exception\LoopException;
6		use Http\Client\Exception as HttplugException;
7		use Http\Client\HttpAsyncClient;
8		use Http\Client\HttpClient;
9		use Http\Client\Promise\HttpFulfilledPromise;
10		use Http\Client\Promise\HttpRejectedPromise;
11		use Psr\Http\Message\RequestInterface;
12		use Symfony\Component\OptionsResolver\OptionsResolver;
13
14		/**
15		* The client managing plugins and providing a decorator around HTTP Clients.
16		*
17		* @author Joel Wurtz <[email protected]>
18		*/
19		final class PluginClient implements HttpClient, HttpAsyncClient
20		{
21		/**
22		* An HTTP async client.
23		*
24		* @var HttpAsyncClient
25		*/
26		private $client;
27
28		/**
29		* The plugin chain.
30		*
31		* @var Plugin[]
32		*/
33		private $plugins;
34
35		/**
36		* A list of options.
37		*
38		* @var array
39		*/
40		private $options;
41
42		/**
43		* @param HttpClient\|HttpAsyncClient $client
44		* @param Plugin[] $plugins
45		* @param array $options {
46		*
47		* @var int $max_restarts
48		* @var Plugin[] $debug_plugins an array of plugins that are injected between each normal plugin
49		* }
50		*
51		* @throws \RuntimeException if client is not an instance of HttpClient or HttpAsyncClient
52		*/
53	9	public function __construct($client, array $plugins = [], array $options = [])
54		{
55	9	if ($client instanceof HttpAsyncClient) {
56	3	$this->client = $client;
57	9	} elseif ($client instanceof HttpClient) {
58	6	$this->client = new EmulatedHttpAsyncClient($client);
59	6	} else {
60		throw new \RuntimeException('Client must be an instance of Http\\Client\\HttpClient or Http\\Client\\HttpAsyncClient');
61		}
62
63	9	$this->plugins = $plugins;
64	9	$this->options = $this->configure($options);
65	9	}
66
67		/**
68		* {@inheritdoc}
69		*/
70	5	public function sendRequest(RequestInterface $request)
71		{
72		// If we don't have an http client, use the async call
73	5	if (!($this->client instanceof HttpClient)) {
74	1	return $this->sendAsyncRequest($request)->wait();
75		}
76
77		// Else we want to use the synchronous call of the underlying client, and not the async one in the case
78		// we have both an async and sync call
79		$pluginChain = $this->createPluginChain($this->plugins, function (RequestInterface $request) {
80		try {
81	3	return new HttpFulfilledPromise($this->client->sendRequest($request));
82		} catch (HttplugException $exception) {
83		return new HttpRejectedPromise($exception);
84		}
85	4	});
86
87	4	return $pluginChain($request)->wait();
88		}
89
90		/**
91		* {@inheritdoc}
92		*/
93	2	public function sendAsyncRequest(RequestInterface $request)
94		{
95		$pluginChain = $this->createPluginChain($this->plugins, function (RequestInterface $request) {
96	2	return $this->client->sendAsyncRequest($request);
97	2	});
98
99	2	return $pluginChain($request);
100		}
101
102		/**
103		* Configure the plugin client.
104		*
105		* @param array $options
106		*
107		* @return array
108		*/
109	9	private function configure(array $options = [])
110		{
111	9	if (isset($options['debug_plugins'])) {
112	1	@trigger_error('The "debug_plugins" option is deprecated since 1.5 and will be removed in 2.0.', E_USER_DEPRECATED);
		0 ignored issues – show Security Best Practice introduced 2017-03-21 13:09 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
113	1	}
114
115	9	$resolver = new OptionsResolver();
116	9	$resolver->setDefaults([
117	9	'max_restarts' => 10,
118	9	'debug_plugins' => [],
119	9	]);
120
121		$resolver
122	9	->setAllowedTypes('debug_plugins', 'array')
123		->setAllowedValues('debug_plugins', function (array $plugins) {
124	9	foreach ($plugins as $plugin) {
125		// Make sure each object passed with the `debug_plugins` is an instance of Plugin.
126	1	if (!$plugin instanceof Plugin) {
127		return false;
128		}
129	9	}
130
131	9	return true;
132	9	});
133
134	9	return $resolver->resolve($options);
135		}
136
137		/**
138		* Create the plugin chain.
139		*
140		* @param Plugin[] $pluginList A list of plugins
141		* @param callable $clientCallable Callable making the HTTP call
142		*
143		* @return callable
144		*/
145	6	private function createPluginChain($pluginList, callable $clientCallable)
146		{
147	6	$firstCallable = $lastCallable = $clientCallable;
148
149		/*
150		* Inject debug plugins between each plugin.
151		*/
152	6	$pluginListWithDebug = $this->options['debug_plugins'];
153	6	foreach ($pluginList as $plugin) {
154	2	$pluginListWithDebug[] = $plugin;
155	2	$pluginListWithDebug = array_merge($pluginListWithDebug, $this->options['debug_plugins']);
156	6	}
157
158	6	while ($plugin = array_pop($pluginListWithDebug)) {
159		$lastCallable = function (RequestInterface $request) use ($plugin, $lastCallable, &$firstCallable) {
160	2	return $plugin->handleRequest($request, $lastCallable, $firstCallable);
161	2	};
162
163	2	$firstCallable = $lastCallable;
164	2	}
165
166	6	$firstCalls = 0;
167	6	$firstCallable = function (RequestInterface $request) use ($lastCallable, &$firstCalls) {
168	6	if ($firstCalls > $this->options['max_restarts']) {
169	1	throw new LoopException('Too many restarts in plugin client', $request);
170		}
171
172	6	++$firstCalls;
173
174	6	return $lastCallable($request);
175	6	};
176
177	6	return $firstCallable;
178		}
179		}
180

php-http / client-common

Pull Request — master (#64)

PluginClient::configure() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like