Add async capability

Author: joelwurtz

composer.json

@@ -16,13 +16,23 @@
     ],
     "require": {
         "php": ">=5.5.0",
-        "php-http/httplug": "dev-master",
+        "php-http/httplug": "dev-feature/async as 1.0.1",
         "guzzlehttp/guzzle": "^6.0"
     },
     "require-dev": {
         "ext-curl": "*",
-        "php-http/adapter-integration-tests": "^0.2@dev"
+        "php-http/adapter-integration-tests": "dev-feature/async-test"
     },
+    "repositories": [
+        {
+            "type": "vcs",
+            "url": "https://github.com/joelwurtz/httplug"
+        },
+        {
+            "type": "vcs",
+            "url": "https://github.com/joelwurtz/adapter-integration-tests"
+        }
+    ],
     "provide": {
         "php-http/client-implementation": "1.0"
     },

src/Guzzle6HttpAdapter.php

@@ -18,13 +18,14 @@
 use Http\Client\Exception\NetworkException;
 use Http\Client\Exception\RequestException;
 use Http\Client\Exception\TransferException;
+use Http\Client\HttpAsyncClient;
 use Http\Client\HttpClient;
 use Psr\Http\Message\RequestInterface;
 
 /**
  * @author David de Boer <[email protected]>
  */
-class Guzzle6HttpAdapter implements HttpClient
+class Guzzle6HttpAdapter implements HttpClient, HttpAsyncClient
 {
     /**
      * @var ClientInterface
@@ -53,6 +54,14 @@ public function sendRequest(RequestInterface $request)
         }
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function sendAsyncRequest(RequestInterface $request)
+    {
+        return new Guzzle6Promise($this->client->sendAsync($request));
+    }
+
     /**
      * Converts a Guzzle exception into an Httplug exception.
      *

src/Guzzle6Promise.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Http\Adapter;
+
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Promise\PromiseInterface;
+use Http\Client\Exception;
+use Http\Client\Promise;
+use Psr\Http\Message\ResponseInterface;
+
+class Guzzle6Promise implements Promise
+{
+    /**
+     * @var \GuzzleHttp\Promise\PromiseInterface
+     */
+    private $promise;
+
+    /**
+     * @var string State of the promise
+     */
+    private $state;
+
+    /**
+     * @var ResponseInterface
+     */
+    private $response;
+
+    /**
+     * @var Exception
+     */
+    private $error;
+
+    public function __construct(PromiseInterface $promise)
+    {
+        $this->promise = $promise;
+        $this->state   = self::PENDING;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function then(callable $onFulfilled = null, callable $onRejected = null)
+    {
+        $onFulfilledInternal = function ($response) use($onFulfilled) {
+            $this->response = $response;
+            $this->state = self::FULFILLED;
+
+            return $onFulfilled($this->response);
+        };
+
+        $onRejectedInternal = function ($reason) use($onRejected) {
+            if (!($reason instanceof RequestException)) {
+                 throw new \RuntimeException("Invalid reason");
+            }
+
+            $this->state = self::REJECTED;
+            $this->error = new Exception\NetworkException($reason->getMessage(), $reason->getRequest(), $reason);
+
+            if ($reason->hasResponse()) {
+                $this->error = new Exception\HttpException($reason->getMessage(), $reason->getRequest(), $reason->getResponse(), $reason);
+            }
+
+            return $onRejected($this->error);
+        };
+
+        $this->promise = $this->promise->then($onFulfilledInternal, $onRejectedInternal);
+
+        return new static($this->promise);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getState()
+    {
+        return $this->state;
+    }
+
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getResponse()
+    {
+        if (self::FULFILLED !== $this->state) {
+            throw new \LogicException("Response not available for the current state");
+        }
+
+        return $this->response;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getError()
+    {
+        if (self::REJECTED !== $this->state) {
+            throw new \LogicException("Error not available for the current state");
+        }
+
+        return $this->error;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function wait()
+    {
+        $this->promise->wait(false);
+    }
+}
+