[0.3] Replace guzzle/http with custom implementation

composer.json

@@ -10,7 +10,6 @@
     "require": {
         "php": ">=5.3.3",
         "evenement/evenement": "1.0.*",
-        "guzzle/http": "3.0.*",
         "guzzle/parser": "3.0.*",
         "react/promise": "1.0.*"
     },

src/React/Http/Response.php

@@ -3,7 +3,6 @@
 namespace React\Http;
 
 use Evenement\EventEmitter;
-use Guzzle\Http\Message\Response as GuzzleResponse;
 use React\Socket\ConnectionInterface;
 use React\Stream\WritableStreamInterface;
 
@@ -59,18 +58,37 @@ public function writeHead($status = 200, array $headers = array())
             $this->chunkedEncoding = false;
         }
 
-        $response = new GuzzleResponse($status);
-        $response->setHeader('X-Powered-By', 'React/alpha');
-        $response->addHeaders($headers);
+        $headers = array_merge(
+            array('X-Powered-By' => 'React/alpha'),
+            $headers
+        );
         if ($this->chunkedEncoding) {
-            $response->setHeader('Transfer-Encoding', 'chunked');
+            $headers['Transfer-Encoding'] = 'chunked';
         }
-        $data = (string) $response;
+
+        $data = $this->formatHead($status, $headers);
         $this->conn->write($data);
 
         $this->headWritten = true;
     }
 
+    private function formatHead($status, array $headers)
+    {
+        $status = (int) $status;
+        $text = isset(ResponseCodes::$statusTexts[$status]) ? ResponseCodes::$statusTexts[$status] : '';
+        $data = "HTTP/1.1 $status $text\r\n";
+
+        foreach ($headers as $name => $value) {
+            $name = str_replace(array("\r", "\n"), '', $name);
+            $value = str_replace(array("\r", "\n"), '', $value);
+
+            $data .= "$name: $value\r\n";
+        }
+        $data .= "\r\n";
+
+        return $data;
+    }
+
     public function write($data)
     {
         if (!$this->headWritten) {

src/React/Http/ResponseCodes.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace React\Http;
+
+/**
+ * This is copy-pasted from Symfony2's Response class
+ */
+class ResponseCodes
+{
+    public static $statusTexts = array(
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        102 => 'Processing',            // RFC2518
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        207 => 'Multi-Status',          // RFC4918
+        208 => 'Already Reported',      // RFC5842
+        226 => 'IM Used',               // RFC3229
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        306 => 'Reserved',
+        307 => 'Temporary Redirect',
+        308 => 'Permanent Redirect',    // RFC-reschke-http-status-308-07
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        418 => 'I\'m a teapot',                                               // RFC2324
+        422 => 'Unprocessable Entity',                                        // RFC4918
+        423 => 'Locked',                                                      // RFC4918
+        424 => 'Failed Dependency',                                           // RFC4918
+        425 => 'Reserved for WebDAV advanced collections expired proposal',   // RFC2817
+        426 => 'Upgrade Required',                                            // RFC2817
+        428 => 'Precondition Required',                                       // RFC6585
+        429 => 'Too Many Requests',                                           // RFC6585
+        431 => 'Request Header Fields Too Large',                             // RFC6585
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported',
+        506 => 'Variant Also Negotiates (Experimental)',                      // RFC2295
+        507 => 'Insufficient Storage',                                        // RFC4918
+        508 => 'Loop Detected',                                               // RFC5842
+        510 => 'Not Extended',                                                // RFC2774
+        511 => 'Network Authentication Required',                             // RFC6585
+    );
+}

src/React/Http/composer.json

@@ -5,7 +5,6 @@
     "license": "MIT",
     "require": {
         "php": ">=5.3.3",
-        "guzzle/http": "3.0.*",
         "guzzle/parser": "3.0.*",
         "react/socket": "0.2.*"
     },

src/React/HttpClient/Client.php

@@ -2,18 +2,15 @@
 
 namespace React\HttpClient;
 
-use Guzzle\Http\Message\Request as GuzzleRequest;
 use React\EventLoop\LoopInterface;
 use React\HttpClient\ConnectionManager;
-use React\HttpClient\Request as ClientRequest;
+use React\HttpClient\Request;
 use React\HttpClient\SecureConnectionManager;
 
 class Client
 {
     private $loop;
-
     private $connectionManager;
-
     private $secureConnectionManager;
 
     public function __construct(LoopInterface $loop, ConnectionManagerInterface $connectionManager, ConnectionManagerInterface $secureConnectionManager)
@@ -25,9 +22,9 @@ public function __construct(LoopInterface $loop, ConnectionManagerInterface $con
 
     public function request($method, $url, array $headers = array())
     {
-        $guzzleRequest = new GuzzleRequest($method, $url, $headers);
-        $connectionManager = $this->getConnectionManagerForScheme($guzzleRequest->getScheme());
-        return new ClientRequest($this->loop, $connectionManager, $guzzleRequest);
+        $requestData = new RequestData($method, $url, $headers);
+        $connectionManager = $this->getConnectionManagerForScheme($requestData->getScheme());
+        return new Request($this->loop, $connectionManager, $requestData);
     }
 
     public function setConnectionManager(ConnectionManagerInterface $connectionManager)

src/React/HttpClient/Request.php

@@ -3,8 +3,6 @@
 namespace React\HttpClient;
 
 use Evenement\EventEmitter;
-use Guzzle\Http\Message\Request as GuzzleRequest;
-use Guzzle\Http\Url;
 use Guzzle\Parser\Message\MessageParser;
 use React\EventLoop\LoopInterface;
 use React\HttpClient\ConnectionManagerInterface;
@@ -24,20 +22,21 @@ class Request extends EventEmitter implements WritableStreamInterface
     const STATE_HEAD_WRITTEN = 2;
     const STATE_END = 3;
 
-    private $request;
     private $loop;
     private $connectionManager;
+    private $requestData;
+
     private $stream;
     private $buffer;
     private $responseFactory;
     private $response;
     private $state = self::STATE_INIT;
 
-    public function __construct(LoopInterface $loop, ConnectionManagerInterface $connectionManager, GuzzleRequest $request)
+    public function __construct(LoopInterface $loop, ConnectionManagerInterface $connectionManager, RequestData $requestData)
     {
         $this->loop = $loop;
         $this->connectionManager = $connectionManager;
-        $this->request = $request;
+        $this->requestData = $requestData;
     }
 
     public function isWritable()
@@ -54,23 +53,23 @@ public function writeHead()
         $this->state = self::STATE_WRITING_HEAD;
 
         $that = $this;
-        $request = $this->request;
+        $requestData = $this->requestData;
         $streamRef = &$this->stream;
         $stateRef = &$this->state;
 
         $this
             ->connect()
             ->then(
-                function ($stream) use ($that, $request, &$streamRef, &$stateRef) {
+                function ($stream) use ($that, $requestData, &$streamRef, &$stateRef) {
                     $streamRef = $stream;
 
                     $stream->on('drain', array($that, 'handleDrain'));
                     $stream->on('data', array($that, 'handleData'));
                     $stream->on('end', array($that, 'handleEnd'));
                     $stream->on('error', array($that, 'handleError'));
 
-                    $request->setProtocolVersion('1.0');
-                    $headers = (string) $request;
+                    $requestData->setProtocolVersion('1.0');
+                    $headers = (string) $requestData;
 
                     $stream->write($headers);
 
@@ -215,8 +214,8 @@ protected function parseResponse($data)
 
     protected function connect()
     {
-        $host = $this->request->getHost();
-        $port = $this->request->getPort();
+        $host = $this->requestData->getHost();
+        $port = $this->requestData->getPort();
 
         return $this->connectionManager
             ->getConnection($host, $port);

src/React/HttpClient/RequestData.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace React\HttpClient;
+
+class RequestData
+{
+    private $method;
+    private $url;
+    private $headers;
+
+    private $protocolVersion = '1.1';
+
+    public function __construct($method, $url, array $headers = array())
+    {
+        $this->method = $method;
+        $this->url = $url;
+        $this->headers = $headers;
+    }
+
+    private function mergeDefaultheaders(array $headers)
+    {
+        $port = ($this->getDefaultPort() === $this->getPort()) ? '' : ":{$this->getPort()}";
+        $connectionHeaders = ('1.1' === $this->protocolVersion) ? array('Connection' => 'close') : array();
+
+        return array_merge(
+            array(
+                'Host'          => $this->getHost().$port,
+                'User-Agent'    => 'React/alpha',
+            ),
+            $connectionHeaders,
+            $headers
+        );
+    }
+
+    public function getScheme()
+    {
+        return parse_url($this->url, PHP_URL_SCHEME);
+    }
+
+    public function getHost()
+    {
+        return parse_url($this->url, PHP_URL_HOST);
+    }
+
+    public function getPort()
+    {
+        return (int) parse_url($this->url, PHP_URL_PORT) ?: $this->getDefaultPort();
+    }
+
+    public function getDefaultPort()
+    {
+        return ('https' === $this->getScheme()) ? 443 : 80;
+    }
+
+    public function getPath()
+    {
+        $path = parse_url($this->url, PHP_URL_PATH) ?: '/';
+        $queryString = parse_url($this->url, PHP_URL_QUERY);
+
+        return $path.($queryString ? "?$queryString" : '');
+    }
+
+    public function setProtocolVersion($version)
+    {
+        $this->protocolVersion = $version;
+    }
+
+    public function __toString()
+    {
+        $headers = $this->mergeDefaultheaders($this->headers);
+
+        $data = '';
+        $data .= "{$this->method} {$this->getPath()} HTTP/{$this->protocolVersion}\r\n";
+        foreach ($headers as $name => $value) {
+            $data .= "$name: $value\r\n";
+        }
+        $data .= "\r\n";
+
+        return $data;
+    }
+}

src/React/HttpClient/composer.json

@@ -5,7 +5,6 @@
     "license": "MIT",
     "require": {
         "php": ">=5.3.3",
-        "guzzle/http": "2.8.*",
         "guzzle/parser": "2.8.*",
         "react/socket": "0.2.*",
         "react/dns": "0.2.*"

tests/React/Tests/Http/RequestHeaderParserTest.php

@@ -91,7 +91,7 @@ public function testHeadersEventShouldParsePathAndQueryString()
         $this->assertSame('1.1', $request->getHttpVersion());
         $headers = array(
             'Host' => 'example.com:80',
-            'User-Agent' => 'Guzzle/2.0 (Language=PHP/5.3.8; curl=7.21.4; Host=universal-apple-darwin11.0)',
+            'User-Agent' => 'react/alpha',
             'Connection' => 'close',
         );
         $this->assertSame($headers, $request->getHeaders());
@@ -128,7 +128,7 @@ private function createAdvancedPostRequest()
     {
         $data = "POST /foo?bar=baz HTTP/1.1\r\n";
         $data .= "Host: example.com:80\r\n";
-        $data .= "User-Agent: Guzzle/2.0 (Language=PHP/5.3.8; curl=7.21.4; Host=universal-apple-darwin11.0)\r\n";
+        $data .= "User-Agent: react/alpha\r\n";
         $data .= "Connection: close\r\n";
         $data .= "\r\n";
 

tests/React/Tests/Http/ResponseTest.php

@@ -124,4 +124,43 @@ public function shouldForwardEndDrainAndErrorEvents()
 
         $response = new Response($conn);
     }
+
+    /** @test */
+    public function shouldRemoveNewlinesFromHeaders()
+    {
+        $expected = '';
+        $expected .= "HTTP/1.1 200 OK\r\n";
+        $expected .= "X-Powered-By: React/alpha\r\n";
+        $expected .= "FooBar: BazQux\r\n";
+        $expected .= "Transfer-Encoding: chunked\r\n";
+        $expected .= "\r\n";
+
+        $conn = $this->getMock('React\Socket\ConnectionInterface');
+        $conn
+            ->expects($this->once())
+            ->method('write')
+            ->with($expected);
+
+        $response = new Response($conn);
+        $response->writeHead(200, array("Foo\nBar" => "Baz\rQux"));
+    }
+
+    /** @test */
+    public function missingStatusCodeTextShouldResultInNumberOnlyStatus()
+    {
+        $expected = '';
+        $expected .= "HTTP/1.1 700 \r\n";
+        $expected .= "X-Powered-By: React/alpha\r\n";
+        $expected .= "Transfer-Encoding: chunked\r\n";
+        $expected .= "\r\n";
+
+        $conn = $this->getMock('React\Socket\ConnectionInterface');
+        $conn
+            ->expects($this->once())
+            ->method('write')
+            ->with($expected);
+
+        $response = new Response($conn);
+        $response->writeHead(700);
+    }
 }