From d404376fd0fc17c991eb1aab4b66dd44dd5368b6 Mon Sep 17 00:00:00 2001
From: Sebastian Edwards <s.thursday@gmail.com>
Date: Tue, 15 May 2012 00:20:49 +1200
Subject: [PATCH 1/2] Fixing Reel adapter.

- Ensure callback only runs when connection has a request.
- Pull 'Host' header out with fetch to bypass transform_key.
- Reference correct variable in body-prepping case statement.
---
 lib/webmachine/adapters/reel.rb | 41 +++++++++++++++++----------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/lib/webmachine/adapters/reel.rb b/lib/webmachine/adapters/reel.rb
index 567e8a99..a9cbdf1a 100644
--- a/lib/webmachine/adapters/reel.rb
+++ b/lib/webmachine/adapters/reel.rb
@@ -20,28 +20,29 @@ def run
       end
 
       def process(connection)
-        wreq = connection.request
-        header = Webmachine::Headers[wreq.headers.dup]
-        requri = URI::HTTP.build(:host => header.host.split(':').first,
-                                 :port => header.host.split(':').last,
+        if wreq = connection.request
+          header = Webmachine::Headers[wreq.headers.dup]
+          requri = URI::HTTP.build(:host => header.fetch('Host').split(':').first,
+                                 :port => header.fetch('Host').split(':').last.to_i,
                                  :path => wreq.url.split('?').first,
                                  :query => wreq.url.split('?').last)
-        request = Webmachine::Request.new(wreq.method.to_s.upcase,
-                                          requri,
-                                          header,
-                                          LazyRequestBody.new(wreq))
-        response = Webmachine::Response.new
-        @dispatcher.dispatch(request,response)
-        # TODO: Chunked encoding support? This completely misses the
-        # opportunity to stream efficiently.
-        body = case response.body
-               when String
-                 body
-               when Enumerable
-                 body.to_a.join
-               end
-        wres = ::Reel::Response.new(response.code, response.headers, body)
-        connection.respond(wres)
+          request = Webmachine::Request.new(wreq.method.to_s.upcase,
+                                            requri,
+                                            header,
+                                            LazyRequestBody.new(wreq))
+          response = Webmachine::Response.new
+          @dispatcher.dispatch(request,response)
+          # TODO: Chunked encoding support? This completely misses the
+          # opportunity to stream efficiently.
+          body = case response.body
+                 when String
+                   response.body
+                 when Enumerable
+                   response.body.to_a.join
+                 end
+          wres = ::Reel::Response.new(response.code, response.headers, body)
+          connection.respond(wres)
+        end
       end
     end
   end

From f5a08cdf94d3619d9c981e6e52853e7b42b01482 Mon Sep 17 00:00:00 2001
From: Sebastian Edwards <s.thursday@gmail.com>
Date: Wed, 16 May 2012 19:22:20 +1200
Subject: [PATCH 2/2] Use streaming response to handle enumerable bodies.

---
 lib/webmachine/adapters/reel.rb | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/lib/webmachine/adapters/reel.rb b/lib/webmachine/adapters/reel.rb
index a9cbdf1a..304e79ff 100644
--- a/lib/webmachine/adapters/reel.rb
+++ b/lib/webmachine/adapters/reel.rb
@@ -32,15 +32,14 @@ def process(connection)
                                             LazyRequestBody.new(wreq))
           response = Webmachine::Response.new
           @dispatcher.dispatch(request,response)
-          # TODO: Chunked encoding support? This completely misses the
-          # opportunity to stream efficiently.
-          body = case response.body
-                 when String
-                   response.body
-                 when Enumerable
-                   response.body.to_a.join
-                 end
-          wres = ::Reel::Response.new(response.code, response.headers, body)
+
+          wres = case response.body
+          when String
+            ::Reel::Response.new(response.code, response.headers, response.body)
+          when Enumerable
+            ::Reel::StreamingResponse.new(response.code, response.headers, response.body)
+          end
+
           connection.respond(wres)
         end
       end