Provide POC cross-compatibility between new and old plugins

The deprecated PluginClient now wraps the new one internally
and dispatches the requests to it.
Full BC should be preserved, relevant exceptions caught
and rethrown with the appropriate wrapping.

Author: sagikazarmark

src/PluginClient.php

@@ -2,15 +2,10 @@
 
 namespace Http\Client\Plugin;
 
-use Http\Client\Common\EmulatedHttpAsyncClient;
-use Http\Client\Exception;
 use Http\Client\HttpAsyncClient;
 use Http\Client\HttpClient;
 use Http\Client\Plugin\Exception\LoopException;
-use Http\Promise\FulfilledPromise;
-use Http\Promise\RejectedPromise;
 use Psr\Http\Message\RequestInterface;
-use Symfony\Component\OptionsResolver\OptionsResolver;
 
 /**
  * The client managing plugins and providing a decorator around HTTP Clients.
@@ -22,25 +17,9 @@
 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
+     * @var \Http\Client\Common\PluginClient
      */
-    private $options;
+    private $pluginClient;
 
     /**
      * @param HttpClient|HttpAsyncClient $client
@@ -54,101 +33,30 @@ final class PluginClient implements HttpClient, 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);
+        $this->pluginClient = new \Http\Client\Common\PluginClient($client, $plugins, $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();
+        try {
+            return $this->pluginClient->sendRequest($request);
+        } catch (\Http\Client\Common\Exception\LoopException $e) {
+            throw new LoopException($e->getMessage(), $e->getRequest(), $e);
         }
-
-        // 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 FulfilledPromise($this->client->sendRequest($request));
-            } catch (Exception $exception) {
-                return new RejectedPromise($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 = [])
-    {
-        $resolver = new OptionsResolver();
-        $resolver->setDefaults([
-            'max_restarts' => 10,
-        ]);
-
-        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;
-
-        while ($plugin = array_pop($pluginList)) {
-            $lastCallable = function (RequestInterface $request) use ($plugin, $lastCallable, &$firstCallable) {
-                return $plugin->handleRequest($request, $lastCallable, $firstCallable);
-            };
-
-            $firstCallable = $lastCallable;
+        try {
+            return $this->pluginClient->sendAsyncRequest($request);
+        } catch (\Http\Client\Common\Exception\LoopException $e) {
+            throw new LoopException($e->getMessage(), $e->getRequest(), $e);
         }
-
-        $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;
     }
 }