Merge pull request #9 from php-http/remove_response

sagikazarmark · sagikazarmark · commit 0f930b66b7db · 2016-01-25T22:55:46.000+01:00
Remove PSR-7 dependency
diff --git a/composer.json b/composer.json
@@ -14,9 +14,6 @@
             "email": "mark.sagikazar@gmail.com"
         }
     ],
-    "require": {
-        "psr/http-message": "^1.0"
-    },
     "require-dev": {
         "phpspec/phpspec": "^2.4",
         "henrikbjorn/phpspec-code-coverage" : "^1.0"
diff --git a/spec/FulfilledPromiseSpec.php b/spec/FulfilledPromiseSpec.php
@@ -3,19 +3,17 @@
 namespace spec\Http\Promise;
 
 use Http\Promise\Promise;
-use Psr\Http\Message\RequestInterface;
-use Psr\Http\Message\ResponseInterface;
 use PhpSpec\ObjectBehavior;
 use Prophecy\Argument;
 
 class FulfilledPromiseSpec extends ObjectBehavior
 {
-    function let(ResponseInterface $response)
+    function let()
     {
-        $this->beConstructedWith($response);
+        $this->beConstructedWith('result');
     }
 
-    function it_is_initializable(ResponseInterface $response)
+    function it_is_initializable()
     {
         $this->shouldHaveType('Http\Promise\FulfilledPromise');
     }
@@ -25,28 +23,24 @@ function it_is_a_promise()
         $this->shouldImplement('Http\Promise\Promise');
     }
 
-    function it_returns_a_fulfilled_promise(ResponseInterface $response)
+    function it_returns_a_fulfilled_promise()
     {
-        $promise = $this->then(function (ResponseInterface $responseReceived) use ($response) {
-            if (Argument::is($responseReceived)->scoreArgument($response->getWrappedObject())) {
-                return $response->getWrappedObject();
-            }
+        $promise = $this->then(function ($result) {
+            return $result;
         });
 
         $promise->shouldHaveType('Http\Promise\Promise');
         $promise->shouldHaveType('Http\Promise\FulfilledPromise');
         $promise->getState()->shouldReturn(Promise::FULFILLED);
-        $promise->wait()->shouldReturn($response);
+        $promise->wait()->shouldReturn('result');
     }
 
-    function it_returns_a_rejected_promise(RequestInterface $request, ResponseInterface $response)
+    function it_returns_a_rejected_promise()
     {
         $exception = new \Exception();
 
-        $promise = $this->then(function (ResponseInterface $responseReceived) use ($response, $exception) {
-            if (Argument::is($responseReceived)->scoreArgument($response->getWrappedObject())) {
-                throw $exception;
-            }
+        $promise = $this->then(function () use ($exception) {
+            throw $exception;
         });
 
         $promise->shouldHaveType('Http\Promise\Promise');
@@ -65,13 +59,13 @@ function it_is_in_fulfilled_state()
         $this->getState()->shouldReturn(Promise::FULFILLED);
     }
 
-    function it_has_a_response(ResponseInterface $response)
+    function it_has_a_result()
     {
-        $this->wait()->shouldReturn($response);
+        $this->wait()->shouldReturn('result');
     }
 
-    function it_does_not_unwrap_a_value(ResponseInterface $response)
+    function it_does_not_unwrap_a_value()
     {
-        $this->wait(false)->shouldNotReturn($response);
+        $this->wait(false)->shouldNotReturn('result');
     }
 }
diff --git a/spec/RejectedPromiseSpec.php b/spec/RejectedPromiseSpec.php
@@ -3,7 +3,6 @@
 namespace spec\Http\Promise;
 
 use Http\Promise\Promise;
-use Psr\Http\Message\ResponseInterface;
 use PhpSpec\ObjectBehavior;
 use Prophecy\Argument;
 
@@ -24,21 +23,19 @@ function it_is_a_promise()
         $this->shouldImplement('Http\Promise\Promise');
     }
 
-    function it_returns_a_fulfilled_promise(ResponseInterface $response)
+    function it_returns_a_fulfilled_promise()
     {
         $exception = new \Exception();
         $this->beConstructedWith($exception);
 
-        $promise = $this->then(null, function (\Exception $exceptionReceived) use($exception, $response) {
-            if (Argument::is($exceptionReceived)->scoreArgument($exception)) {
-                return $response->getWrappedObject();
-            }
+        $promise = $this->then(null, function (\Exception $exceptionReceived) use($exception) {
+            return 'result';
         });
 
         $promise->shouldHaveType('Http\Promise\Promise');
         $promise->shouldHaveType('Http\Promise\FulfilledPromise');
         $promise->getState()->shouldReturn(Promise::FULFILLED);
-        $promise->wait()->shouldReturn($response);
+        $promise->wait()->shouldReturn('result');
     }
 
     function it_returns_a_rejected_promise()
@@ -76,7 +73,7 @@ function it_returns_an_exception()
         $this->shouldThrow($exception)->duringWait();
     }
 
-    function it_does_not_unwrap_a_value(ResponseInterface $response)
+    function it_does_not_unwrap_a_value()
     {
         $this->shouldNotThrow('Exception')->duringWait(false);
     }
diff --git a/src/FulfilledPromise.php b/src/FulfilledPromise.php
@@ -2,8 +2,6 @@
 
 namespace Http\Promise;
 
-use Psr\Http\Message\ResponseInterface;
-
 /**
  * A promise already fulfilled.
  *
@@ -12,16 +10,16 @@
 final class FulfilledPromise implements Promise
 {
     /**
-     * @var ResponseInterface
+     * @var mixed
      */
-    private $response;
+    private $result;
 
     /**
-     * @param ResponseInterface $response
+     * @param $result
      */
-    public function __construct(ResponseInterface $response)
+    public function __construct($result)
     {
-        $this->response = $response;
+        $this->result = $result;
     }
 
     /**
@@ -34,7 +32,7 @@ public function then(callable $onFulfilled = null, callable $onRejected = null)
         }
 
         try {
-            return new self($onFulfilled($this->response));
+            return new self($onFulfilled($this->result));
         } catch (\Exception $e) {
             return new RejectedPromise($e);
         }
@@ -54,7 +52,7 @@ public function getState()
     public function wait($unwrap = true)
     {
         if ($unwrap) {
-            return $this->response;
+            return $this->result;
         }
     }
 }
diff --git a/src/Promise.php b/src/Promise.php
@@ -2,8 +2,6 @@
 
 namespace Http\Promise;
 
-use Psr\Http\Message\ResponseInterface;
-
 /**
  * Promise represents a value that may not be available yet, but will be resolved at some point in future.
  * It acts like a proxy to the actual value.
@@ -63,7 +61,7 @@ public function getState();
      *
      * @param bool $unwrap Whether to return resolved value / throw reason or not
      *
-     * @return ResponseInterface|null Resolved value, null if $unwrap is set to false
+     * @return mixed Resolved value, null if $unwrap is set to false
      *
      * @throws \Exception The rejection reason if $unwrap is set to true and the request failed.
      */

Original file line number	Diff line number	Diff line change
`@@ -3,19 +3,17 @@`
`3`	`3`	`namespace spec\Http\Promise;`
`4`	`4`
`5`	`5`	`use Http\Promise\Promise;`
`6`		`-use Psr\Http\Message\RequestInterface;`
`7`		`-use Psr\Http\Message\ResponseInterface;`
`8`	`6`	`use PhpSpec\ObjectBehavior;`
`9`	`7`	`use Prophecy\Argument;`
`10`	`8`
`11`	`9`	`class FulfilledPromiseSpec extends ObjectBehavior`
`12`	`10`	`{`
`13`		`- function let(ResponseInterface $response)`
	`11`	`+ function let()`
`14`	`12`	`{`
`15`		`- $this->beConstructedWith($response);`
	`13`	`+ $this->beConstructedWith('result');`
`16`	`14`	`}`
`17`	`15`
`18`		`- function it_is_initializable(ResponseInterface $response)`
	`16`	`+ function it_is_initializable()`
`19`	`17`	`{`
`20`	`18`	`$this->shouldHaveType('Http\Promise\FulfilledPromise');`
`21`	`19`	`}`
`@@ -25,28 +23,24 @@ function it_is_a_promise()`
`25`	`23`	`$this->shouldImplement('Http\Promise\Promise');`
`26`	`24`	`}`
`27`	`25`
`28`		`- function it_returns_a_fulfilled_promise(ResponseInterface $response)`
	`26`	`+ function it_returns_a_fulfilled_promise()`
`29`	`27`	`{`
`30`		`- $promise = $this->then(function (ResponseInterface $responseReceived) use ($response) {`
`31`		`- if (Argument::is($responseReceived)->scoreArgument($response->getWrappedObject())) {`
`32`		`- return $response->getWrappedObject();`
`33`		`- }`
	`28`	`+ $promise = $this->then(function ($result) {`
	`29`	`+ return $result;`
`34`	`30`	`});`
`35`	`31`
`36`	`32`	`$promise->shouldHaveType('Http\Promise\Promise');`
`37`	`33`	`$promise->shouldHaveType('Http\Promise\FulfilledPromise');`
`38`	`34`	`$promise->getState()->shouldReturn(Promise::FULFILLED);`
`39`		`- $promise->wait()->shouldReturn($response);`
	`35`	`+ $promise->wait()->shouldReturn('result');`
`40`	`36`	`}`
`41`	`37`
`42`		`- function it_returns_a_rejected_promise(RequestInterface $request, ResponseInterface $response)`
	`38`	`+ function it_returns_a_rejected_promise()`
`43`	`39`	`{`
`44`	`40`	`$exception = new \Exception();`
`45`	`41`
`46`		`- $promise = $this->then(function (ResponseInterface $responseReceived) use ($response, $exception) {`
`47`		`- if (Argument::is($responseReceived)->scoreArgument($response->getWrappedObject())) {`
`48`		`- throw $exception;`
`49`		`- }`
	`42`	`+ $promise = $this->then(function () use ($exception) {`
	`43`	`+ throw $exception;`
`50`	`44`	`});`
`51`	`45`
`52`	`46`	`$promise->shouldHaveType('Http\Promise\Promise');`
`@@ -65,13 +59,13 @@ function it_is_in_fulfilled_state()`
`65`	`59`	`$this->getState()->shouldReturn(Promise::FULFILLED);`
`66`	`60`	`}`
`67`	`61`
`68`		`- function it_has_a_response(ResponseInterface $response)`
	`62`	`+ function it_has_a_result()`
`69`	`63`	`{`
`70`		`- $this->wait()->shouldReturn($response);`
	`64`	`+ $this->wait()->shouldReturn('result');`
`71`	`65`	`}`
`72`	`66`
`73`		`- function it_does_not_unwrap_a_value(ResponseInterface $response)`
	`67`	`+ function it_does_not_unwrap_a_value()`
`74`	`68`	`{`
`75`		`- $this->wait(false)->shouldNotReturn($response);`
	`69`	`+ $this->wait(false)->shouldNotReturn('result');`
`76`	`70`	`}`
`77`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`namespace spec\Http\Promise;`
`4`	`4`
`5`	`5`	`use Http\Promise\Promise;`
`6`		`-use Psr\Http\Message\ResponseInterface;`
`7`	`6`	`use PhpSpec\ObjectBehavior;`
`8`	`7`	`use Prophecy\Argument;`
`9`	`8`
`@@ -24,21 +23,19 @@ function it_is_a_promise()`
`24`	`23`	`$this->shouldImplement('Http\Promise\Promise');`
`25`	`24`	`}`
`26`	`25`
`27`		`- function it_returns_a_fulfilled_promise(ResponseInterface $response)`
	`26`	`+ function it_returns_a_fulfilled_promise()`
`28`	`27`	`{`
`29`	`28`	`$exception = new \Exception();`
`30`	`29`	`$this->beConstructedWith($exception);`
`31`	`30`
`32`		`- $promise = $this->then(null, function (\Exception $exceptionReceived) use($exception, $response) {`
`33`		`- if (Argument::is($exceptionReceived)->scoreArgument($exception)) {`
`34`		`- return $response->getWrappedObject();`
`35`		`- }`
	`31`	`+ $promise = $this->then(null, function (\Exception $exceptionReceived) use($exception) {`
	`32`	`+ return 'result';`
`36`	`33`	`});`
`37`	`34`
`38`	`35`	`$promise->shouldHaveType('Http\Promise\Promise');`
`39`	`36`	`$promise->shouldHaveType('Http\Promise\FulfilledPromise');`
`40`	`37`	`$promise->getState()->shouldReturn(Promise::FULFILLED);`
`41`		`- $promise->wait()->shouldReturn($response);`
	`38`	`+ $promise->wait()->shouldReturn('result');`
`42`	`39`	`}`
`43`	`40`
`44`	`41`	`function it_returns_a_rejected_promise()`
`@@ -76,7 +73,7 @@ function it_returns_an_exception()`
`76`	`73`	`$this->shouldThrow($exception)->duringWait();`
`77`	`74`	`}`
`78`	`75`
`79`		`- function it_does_not_unwrap_a_value(ResponseInterface $response)`
	`76`	`+ function it_does_not_unwrap_a_value()`
`80`	`77`	`{`
`81`	`78`	`$this->shouldNotThrow('Exception')->duringWait(false);`
`82`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,6 @@`
`2`	`2`
`3`	`3`	`namespace Http\Promise;`
`4`	`4`
`5`		`-use Psr\Http\Message\ResponseInterface;`
`6`		`-`
`7`	`5`	`/**`
`8`	`6`	`* A promise already fulfilled.`
`9`	`7`	`*`
`@@ -12,16 +10,16 @@`
`12`	`10`	`final class FulfilledPromise implements Promise`
`13`	`11`	`{`
`14`	`12`	`/**`
`15`		`- * @var ResponseInterface`
	`13`	`+ * @var mixed`
`16`	`14`	`*/`
`17`		`- private $response;`
	`15`	`+ private $result;`
`18`	`16`
`19`	`17`	`/**`
`20`		`- * @param ResponseInterface $response`
	`18`	`+ * @param $result`
`21`	`19`	`*/`
`22`		`- public function __construct(ResponseInterface $response)`
	`20`	`+ public function __construct($result)`
`23`	`21`	`{`
`24`		`- $this->response = $response;`
	`22`	`+ $this->result = $result;`
`25`	`23`	`}`
`26`	`24`
`27`	`25`	`/**`
`@@ -34,7 +32,7 @@ public function then(callable $onFulfilled = null, callable $onRejected = null)`
`34`	`32`	`}`
`35`	`33`
`36`	`34`	`try {`
`37`		`- return new self($onFulfilled($this->response));`
	`35`	`+ return new self($onFulfilled($this->result));`
`38`	`36`	`} catch (\Exception $e) {`
`39`	`37`	`return new RejectedPromise($e);`
`40`	`38`	`}`
`@@ -54,7 +52,7 @@ public function getState()`
`54`	`52`	`public function wait($unwrap = true)`
`55`	`53`	`{`
`56`	`54`	`if ($unwrap) {`
`57`		`- return $this->response;`
	`55`	`+ return $this->result;`
`58`	`56`	`}`
`59`	`57`	`}`
`60`	`58`	`}`