rity 0.0.3 → 0.1.0

data/.yardopts

@@ -0,0 +1 @@
+- LICENSE

data/Gemfile

@@ -4,3 +4,10 @@ gemspec
 
 gem "rake"
 gem "awesome_print"
+
+gem "yard"
+gem "rdiscount"
+
+gem "em-synchrony", :git => "git://github.com/lgierth/em-synchrony",
+                    :branch => "immediately-return-from-sync"
+gem "em-http-request", :git => "git://github.com/igrigorik/em-http-request"

data/README.md

@@ -7,8 +7,11 @@ TODO
 ----
 
 - Proxying via EM.enable_proxy
+- Investigate side effects of sending 500 for errors
 - Rack Handler
 - Support for keep-alive connections
 - Investigate MVM support in JRuby/Rubinius/MRI
 - Support for SPDY
 - Investigate preforking and letting multiple EventMachine loops listen on a shared socket
+- Support for X-Sendfile header
+- Deamonizing & dropping privileges

data/Rakefile

@@ -1,9 +1,13 @@
 require "bundler"
-Bundler.setup :default
+Bundler.setup :default, :development
 
 task :default => :spec
 
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new :spec
 
+require "bundler/gem_helper"
 Bundler::GemHelper.install_tasks
+
+require "yard"
+YARD::Rake::YardocTask.new

data/config.ru

@@ -0,0 +1,102 @@
+#
+# streaming response body
+#
+
+run proc {|env|
+  EM.add_timer(1) {
+    env["stream.start"].call 200, "Content-Type" => "image/png"
+    EM.add_periodic_timer(1) { env["stream.send"].call "\n" }
+  }
+  EM.add_timer(10) { env["stream.close"].call }
+  [-1, {}, []]
+  
+  # or instantly:
+  EM.add_periodic_timer(1) { env["stream.send"].call "\n" }
+  EM.add_timer(10) { env["stream.close"].call }
+  [200, {"Content-Type" => "image/png"}, Rack::STREAMING]
+}
+
+#
+# async response (though all responses are async by default, anyway)
+#
+
+run proc {|env|
+  Fiber.new {
+    do_something
+    env["async.callback"].call [201, {"Content-Type" => "text/plain"}, ["Great!"]]
+  }.resume
+  
+  [-1, {}, []]
+}
+
+#
+# streaming request body
+#
+
+run proc {|env|
+  # will return when the input is write-closed
+  env["rack.input"].receive {|chunk| }
+  
+  # same here
+  env["rack.input"].sync
+  File.open("input.dat", "w") {|f| f << env["rack.input"] }
+  
+  [201, {"The" => "headers"}, []]
+}
+
+#
+# proxying
+#
+
+class MySimpleProxy
+  def initialize(env)
+    @env = env
+  end
+  
+  def call(response)
+    @env["async.callback"].call response
+    
+    # or modify the ouput via streaming:
+    @env["stream.start"].call *response[0..1]
+    response[2].each do |chunk|
+      @env["stream.send"].call chunk.upcase
+    end
+    @env["stream.close"].call
+  end
+end
+
+class MyProxy
+  def initialize(env)
+    @env = env
+  end
+  
+  def call(response)
+    @env["proxy.start_reverse"].call *response[0..1]
+  end
+end
+
+class MyApp
+  def headers(env)
+    shard = sharding_func.call env["REQUEST_URI"]
+    #  env["rity.callback"] = MySimpleProxy.new(env)
+    env["proxy.callback"] = MyProxy.new(env)
+    env["proxy.start"].call shard.uri, "X-Sharding-Func" => "skip"
+  end
+end
+
+run MyApp.new
+
+# or in short:
+
+run proc {|env|
+  shard = sharding_func.call(env["REQUEST_URI"])
+  # if no block is passed to proxy.start, it will use EM's native proxying to
+  # pass the response to the client
+  env["proxy.start"].call shard.uri, "Additional" => "headers" do |response|
+    @env["stream.start"].call *response[0..1]
+    response[2].each do |chunk|
+      @env["stream.send"].call chunk.upcase
+    end
+    @env["stream.close"].call
+  end
+}

data/lib/rity.rb

@@ -1,3 +1,7 @@
 require "rity/connection"
 require "rity/request"
 require "rity/version"
+
+module Rack
+  STREAMING = "Rack::STREAMING"
+end

data/lib/rity/body.rb

@@ -0,0 +1,29 @@
+require "eventmachine"
+require "em-synchrony"
+require "stringio"
+
+module Rity
+  class Body < StringIO
+    include EM::Deferrable
+    
+    def close_write
+      super
+      succeed
+    end
+    
+    def write(str)
+      super
+      @receiver.call str if @receiver
+    end
+    
+    def receive(&block)
+      string.each_line &block
+      @receiver = block
+      sync
+    end
+    
+    def sync
+      EM::Synchrony.sync self
+    end
+  end
+end

data/lib/rity/cli.rb

@@ -49,7 +49,7 @@ module Rity
         
         EM.epoll
         
-        EM.start_server(address, port, Connection) do |conn|
+        EM.start_server address, port, Connection do |conn|
           conn.app = app
           conn.log = log if defined? log
         end

data/lib/rity/connection.rb

@@ -1,78 +1,72 @@
 require "eventmachine"
+require "em-synchrony"
 require "hatetepe"
-
 require "rity/request"
 
 module Rity
-  class Connection < EM::Connection
+  module Connection
     attr_accessor :app, :log
-    attr_reader :requests, :parser, :builder, :responder
     
     def post_init
-      @requests, request = [], nil
+      @parser = Hatetepe::Parser.new
+      @builder = Hatetepe::Builder.new
       
-      @parser = Hatetepe::Parser.new do |p|
-        p.on_request do |verb, url|
-          request = Request.new(@app, verb, url)
-          request.log = log
-          @requests.push(request)
-          @requests.last.callback &method(:write_responses)
-        end
-        
-        p.on_header do |name, value|
-          @requests.last.add_header(name, value)
-        end
-        
-        p.on_headers_complete do
-          @requests.last.precall
-        end
-        
-        p.on_body_chunk do |chunk|
-          @requests.last.add_body_chunk(chunk)
-        end
-        
-        p.on_complete do
-          @requests.last.call
-          request = nil
-        end
-        
-        p.on_error do |e|
-          if request
-            request.error(e)
-          else
-            raise(e)
-          end
-        end
+      (previous = EM::DefaultDeferrable.new).succeed
+      request = nil
+      
+      @parser.on_response { close_connection }
+      
+      @parser.on_request do |verb, uri|
+        previous = request if request
+        request = Request.new(@app, verb, uri)
       end
       
-      @builder = Hatetepe::Builder.new do |b|
-        b.on_write &method(:send_data)
+      @parser.on_header do |name, value|
+        request.add_header name, value
+      end
+      
+      @parser.on_headers_complete do
+        prev, req = previous, request
         
-        b.on_complete do
-          close_connection_after_writing if @requests.empty?
+        req.env["stream.start"] = proc do |response|
+          EM::Synchrony.sync prev
+          
+          @builder.response response[0..1]
+          req.env["stream.send"] = proc do |chunk|
+            @builder.body chunk
+          end
+          
+          req.env["stream.close"] = proc do
+            @builder.complete
+            req.succeed
+            close_connection_after_writing if req == request
+          end
         end
         
-        b.on_error &method(:error)
+        req.process
       end
-    end
-    
-    def write_responses
-      while requests[0] && requests[0].response
-        request = requests.shift
-        builder.response(request.response)
+      
+      @parser.on_body_chunk do |chunk|
+        request.add_body_chunk chunk
+      end
+      
+      @parser.on_complete do
+        request.close_body
+      end
+      
+      @builder.on_write do |data|
+        send_data data
       end
     end
     
     def receive_data(data)
       @parser << data
-    rescue Exception => e
-      error(e)
-    end
-    
-    def error(e)
+    rescue Hatetepe::ParserError
+      close_connection
+    rescue Exception => ex
       if log
-        log.error(e.message)
-        log << e.backtrace.join("\n") + "\n"
+        log.error ex.message
+        log << ex.backtrace.map {|line| "  #{line}" }.join("\n") + "\n"
       end
       close_connection
     end

data/lib/rity/request.rb

@@ -1,77 +1,52 @@
-require "em/deferrable"
-require "fiber"
-require "stringio"
-
-require "rack"
-require "async-rack"
+require "eventmachine"
+require "em-synchrony"
+require "rity/body"
 
 module Rity
   class Request
     include EM::Deferrable
     
-    attr_reader :log
-    attr_reader :app, :env, :response
+    attr_reader :app, :env
     
-    def initialize(app, verb, url)
-      @app = app
-      @env = {
+    def initialize(app, verb, uri)
+      @app, @env = app, {
+        "rack.input" => Body.new,
         "REQUEST_METHOD" => verb,
-        "REQUEST_URI" => url,
-        "rack.input" => StringIO.new,
-        "async.callback" => method(:postcall),
+        "REQUEST_URI" => uri,
+        "async.callback" => method(:postprocess),
+#        "proxy.start" => &method(:proxy_start),
+#        "proxy.callback" => &method(:proxy_start_reverse),
+#        "proxy.start_reverse" => &method(:proxy_start_reverse),
       }
     end
     
-    def log=(log)
-      @log = log
-      @env["rack.logger"] = log
-    end
-    
-    def add_body_chunk(chunk)
-      env["rack.input"] << chunk
-    end
-    
     def add_header(name, value)
       key = "HTTP_" + name.upcase.gsub("-", "_")
-      @env[key] = value
+      env[key] = value
     end
     
-    def precall
-      Fiber.new do
-        rescue_errors { app.precall(env) }
-      end.resume if app.respond_to?(:precall)
-    end
-    
-    def call
-      env["rack.input"].close
-      env["rack.input"].rewind
-      
-      Fiber.new do
-        rescue_errors { postcall(app.call(env)) }
-      end.resume
+    def add_body_chunk(chunk)
+      env["rack.input"].write chunk
     end
     
-    def postcall(response)
-      return if @response || response[0] < 0
-      @response = response
-      succeed
+    def close_body
+      env["rack.input"].close_write
     end
     
-    def error(e)
-      if log
-        log.error(e.message)
-        log << e.backtrace.join("\n") + "\n"
-      end
-      postcall [500, {"Content-Type" => "text/html"},
-        ["<h1>#{Hatetepe::STATUS_CODES[500]}</h1>"]]
+    def process
+      Fiber.new {
+        postprocess app.call(env)
+      }.resume
     end
     
-    def rescue_errors
-      begin
-        yield
-      rescue Exception => e
-        error(e)
-      end
+    def postprocess(response)
+      return if response[0] < 0
+      
+      env["stream.start"].call response[0..1]
+      return if response[2] == Rack::STREAMING
+      
+      response[2].each {|chunk| env["stream.send"].call chunk }
+      env["stream.close"].call
     end
   end
 end

data/lib/rity/version.rb

@@ -1,3 +1,3 @@
 module Rity
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/myapp.rb

@@ -1,20 +1,30 @@
 require "bundler"
 Bundler.setup :default
 
-require "rity"
+require "logger"
+require "eventmachine"
+require "em-synchrony"
+require "rity/new_connection"
 require "awesome_print"
 
-class MyApp
-  def call(env)
-    #raise "Error, Error!"
-    
-    response = [200, {"Content-Type" => "text/html"}, ["Hello!"]]
-    return response
-    
-    EM.add_timer(2) { env["async.callback"].call(response) }
-    
-    [-1, {}, []]
-  end
+address, port = "127.0.0.1", 3000
+
+app = proc {|env|
+  [200, {"Content-Type" => "text/html"}, ["You requested: #{env["REQUEST_URI"]}"]]
+}
+
+log = Logger.new($stderr)
+log.formatter = proc do |severity, time, progname, message|
+  "[#{time}] #{severity}: #{message}\n"
 end
 
-Rity::Server.start "127.0.0.1", 3000, MyApp.new
+log.info("Binding to #{address}:#{port}")
+
+EM.synchrony do
+  trap("INT") { EM.stop }
+  trap("TERM") { EM.stop }
+  
+  EM.epoll
+  
+  EM.start_server address, port, Rity::Connection, app, log
+end

data/spec/unit/body_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+describe Rity::Body do
+  let(:body) { Rity::Body.new }
+  
+  it "is deferrable" do
+    body.should respond_to(:callback)
+  end
+  
+  describe "#close_write" do
+    it "closes the body for writing" do
+      body.close_write
+      expect { body.write "" }.to raise_error
+    end
+    
+    it "succeeds the deferrable" do
+      body.should_receive :succeed
+      body.close_write
+    end
+  end
+  
+  describe "#write" do
+    it "writes data to the IO" do
+      body.write "asdf"
+      body.string.should == "asdf"
+    end
+    
+    it "yields the data to the receiver block if any" do
+      str = nil
+      Fiber.new {
+        body.receive {|s| str = s }
+      }.resume
+      
+      body.write "asdf"
+      str.should == "asdf"
+    end
+  end
+  
+  describe "#receive" do
+    it "yields each line that has already been written" do
+      body.write "as\ndf"
+      lines = []
+      Fiber.new {
+        body.receive {|l| lines << l }
+      }.resume
+      
+      body.close_write
+      lines.should == ["as\n", "df"]
+    end
+    
+    it "saves the receiver block for future writes" do
+      chunks = []
+      Fiber.new {
+        body.receive {|c| chunks << c }
+      }.resume
+      
+      body.write "as"
+      chunks.should == ["as"]
+      body.write "df"
+      chunks.should == ["as", "df"]
+      body.close_write
+    end
+  end
+  
+  describe "#sync" do
+    it "waits until the body is closed for writing" do
+      closed = false
+      Fiber.new {
+        body.sync
+        expect { body.write "" }.to raise_error
+        closed = true
+      }.resume
+      
+      body.close_write
+      closed.should be_true
+    end
+  end
+end

data/spec/unit/connection_spec.rb

@@ -1,112 +1,181 @@
 require "spec_helper"
 
 describe Rity::Connection do
-  before do
-    @conn = Rity::Connection.new("blah")
-    @app = stub("app")
-    @conn.app = @app
-  end
+  let(:conn) { Class.new { include Rity::Connection }.new }
+  let(:app) { mock "app" }
+  let(:log) { mock "log" }
+  let(:parser) { Hatetepe::Parser.new }
+  let(:builder) { Hatetepe::Builder.new }
+  let(:requests) { [] }
   
-  it "has an app, requests and a logger" do
-    @conn.app.should == @app
-    @conn.should have(0).requests
+  before do
+    Hatetepe::Parser.stub :new => parser
+    Hatetepe::Builder.stub :new => builder
     
-    log = stub("log")
-    @conn.log = log
-    @conn.log.should == log
-  end
-  
-  it "passes incoming data to the parser" do
-    @conn.parser.should_receive(:<<).with("asdfg")
-    @conn.receive_data("asdfg")
+    Rity::Request.singleton_class.send :alias_method, :spec_original_new, :new
+    Rity::Request.stub :new do |*args|
+      requests << request = Rity::Request.spec_original_new(*args)
+      request
+    end
+    
+    conn.post_init
   end
   
-  it "closes the connection if parsing fails" do
-    @conn.should_receive(:close_connection)
-    @conn.receive_data("this will definitely fail!")
+  it "can have an app and a logger" do
+    conn.app, conn.log = app, log
+    conn.app.should == app
+    conn.log.should == log
   end
   
-  it "creates a new request as soon as headers are parsed" do
-    request, log = stub("request", :callback => nil), stub("log")
-    @conn.log = log
+  describe "#receive_data" do
+    it "feeds the parser with data" do
+      parser.should_receive(:<<).with "asdf"
+      conn.receive_data "asdf"
+    end
     
-    Rity::Request.should_receive(:new).with(@conn.app, "GET", "/").and_return(request)
-    request.should_receive(:log=).with(log)
+    it "closes the connection if parsing fails" do
+      parser.stub(:<<) {|data| raise Hatetepe::ParserError, "parser error" }
+      conn.should_receive :close_connection
+      
+      conn.receive_data "asdf"
+    end
     
-    @conn.parser.on_request[0].call("GET", "/")
-    @conn.requests[0].should == request
-  end
-  
-  it "adds the responder as request's callback" do
-    @conn.should_receive(:write_responses)
-    @conn.parser.on_request[0].call("GET", "/")
-    @conn.requests[0].succeed
-  end
-  
-  it "adds each parsed header to the request" do
-    @conn.requests.push(Rity::Request.new(nil, nil, nil))
-    @conn.requests.last.should_receive(:add_header).with("Asd", "123")
-    @conn.parser.on_header[0].call("Asd", "123")
-  end
-  
-  it "calls the request's #precall method when headers are finished" do
-    @conn.requests.push(Rity::Request.new(nil, nil, nil))
-    @conn.requests.last.should_receive(:precall)
-    @conn.parser.on_headers_complete[0].call
-  end
-  
-  it "adds each parsed body chunk to the request" do
-    @conn.requests.push(Rity::Request.new(nil, nil, nil))
-    @conn.requests.last.should_receive(:add_body_chunk).with("asdf")
-    @conn.parser.on_body_chunk[0].call("asdf")
+    it "logs and closes the connection if other errors happen" do
+      parser.stub(:<<) {|data| raise "some other error" }
+      conn.should_receive :close_connection
+      
+      conn.log = log
+      log.should_receive(:error).with "some other error"
+      log.should_receive(:<<)
+      
+      conn.receive_data "asdf"
+    end
   end
   
-  it "calls the request's #call method when the whole message is parsed" do
-    @conn.requests.push(Rity::Request.new(nil, nil, nil))
-    @conn.requests.last.should_receive(:call)
-    @conn.parser.on_complete[0].call()
+  describe "the parser" do
+    it "closes the connection if a response comes in" do
+      conn.should_receive :close_connection
+      parser.on_response[0].call
+    end
+    
+    it "creates a request object for each incoming request" do
+      parser.on_request[0].call "GET", "/"
+      requests[0].env["REQUEST_METHOD"].should == "GET"
+      requests[0].env["REQUEST_URI"].should == "/"
+    end
+    
+    it "adds each header to the request object" do
+      parser.on_request[0].call "GET", "/"
+      requests[0].should_receive(:add_header).with "Key", "value"
+      parser.on_header[0].call "Key", "value"
+    end
+    
+    it "processes the request when the headers are complete" do
+      parser.on_request[0].call "GET", "/"
+      requests[0].should_receive :process
+      parser.on_headers_complete[0].call
+    end
+    
+    it "adds the stream.start proc to the request before processing" do
+      parser.on_request[0].call "GET", "/"
+      requests[0].stub :process
+      parser.on_headers_complete[0].call
+      requests[0].env["stream.start"].should respond_to(:call)
+    end
   end
   
-  describe "the responder" do
-    it "pushes the request's response to the builder" do
-      @conn.requests.push(Rity::Request.new(nil, nil, nil))
-      response = stub("response")
-      @conn.requests[0].stub(:response => response)
-      
-      @conn.builder.should_receive(:response).with(response)
-      @conn.write_responses
-    end
+  describe "response stream" do
+    let(:env) { requests[0].env }
     
-    it "doesn't push the response until it's ready" do
-      @conn.requests.push(Rity::Request.new(nil, nil, nil))
-      @conn.builder.should_not_receive(:response)
-      @conn.write_responses
+    before do
+      conn.stub :send_data
+      
+      parser.on_request[0].call "GET", "/"
+      requests[0].stub :process
+      parser.on_headers_complete[0].call
     end
     
-    it "pushes responses in the order the resp. requests came in" do
-      request1, request2 = mock("request1"), mock("request2")
-      response1, response2 = stub("response1"), stub("response2")
-      @conn.requests.push(request1, request2)
+    describe "stream.start" do
+      it "waits until the previous request is finished" do
+        expected_responses = []
+        2.times do |i|
+          response = stub "response##{i}"
+          response.stub :[] => response
+          expected_responses << response
+        end
+        
+        actual_responses = []
+        builder.stub :response do |response|
+          actual_responses << response
+        end
+        
+        parser.on_request[0].call "GET", "/another"
+        requests[1].stub :process
+        parser.on_headers_complete[0].call
+        
+        Fiber.new {
+          requests[1].env["stream.start"].call expected_responses[1]
+        }.resume
+        Fiber.new {
+          requests[0].env["stream.start"].call expected_responses[0]
+        }.resume
+        
+        requests[0].env["stream.close"].call
+        actual_responses.should == expected_responses
+      end
       
-      request1.stub(:response => nil)
-      request2.stub(:response => response2)
-      @conn.builder.should_not_receive(:response)
-      @conn.write_responses
+      it "passes response status and headers to the builder" do
+        response = [200, {"Key" => "value"}, []]
+        builder.should_receive(:response).with response[0..1]
+        requests[0].env["stream.start"].call response
+      end
       
-      request1.stub(:response => response1)
-      request2.stub(:response => nil)
-      @conn.builder.rspec_reset
-      @conn.builder.should_receive(:response).with(response1)
-      @conn.write_responses
+      it "sets stream.send and stream.close" do
+        env["stream.send"].should be_nil
+        env["stream.close"].should be_nil
+        
+        env["stream.start"].call [200, {}, []]
+        env["stream.send"].should respond_to(:call)
+        env["stream.close"].should respond_to(:call)
+      end
+    end
+    
+    describe "stream.send" do
+      it "passes a body chunk to the builder" do
+        env["stream.start"].call [200, {}, []]
+        
+        builder.should_receive(:body).with "asdf"
+        env["stream.send"].call "asdf"
+      end
+    end
+    
+    describe "stream.close" do
+      before do
+        env["stream.start"].call [200, {}, []]
+        conn.stub :close_connection_after_writing
+      end
       
-      @conn.requests.should_not include(request1)
+      it "completes building the response" do
+        builder.should_receive :complete
+        env["stream.close"].call
+      end
       
-      request2.stub(:response => response2)
-      @conn.builder.rspec_reset
-      @conn.builder.should_receive(:response).with(response2)
-      @conn.write_responses
+      it "finishes the request" do
+        requests[0].should_receive :succeed
+        env["stream.close"].call
+      end
       
-      @conn.requests.should be_empty
+      it "closes the connection" do
+        conn.should_receive :close_connection_after_writing
+        env["stream.close"].call
+      end
+    end
+  end
+  
+  describe "the builder" do
+    it "writes to the connection" do
+      conn.should_receive(:send_data).with "asdf"
+      builder.on_write[0].call "asdf"
     end
   end
 end

data/spec/unit/request_spec.rb

@@ -1,132 +1,103 @@
 require "spec_helper"
 
 describe Rity::Request do
-  before do
-    @app = proc {|env|}
-    @request = Rity::Request.new(@app, "GET", "/")
-  end
+  let(:app) { mock "app" }
+  let(:request) { Rity::Request.new app, "GET", "/" }
   
-  it "is deferrable" do
-    @request.should respond_to(:callback)
-    @request.should respond_to(:succeed)
+  describe "#initialize" do
+    it "sets the app" do
+      request.app.should == app
+    end
+    
+    it "initializes the env hash" do
+      request.env["REQUEST_METHOD"].should == "GET"
+      request.env["REQUEST_URI"].should == "/"
+      request.env["rack.input"].should be_kind_of(Rity::Body)
+      request.env["async.callback"].should == request.method(:postprocess)
+    end
   end
   
-  it "initializes the env hash" do
-    @request.env["REQUEST_METHOD"].should == "GET"
-    @request.env["REQUEST_URI"].should == "/"
-    StringIO.should === @request.env["rack.input"]
-    @request.env["async.callback"].should respond_to(:call)
+  describe "#add_header" do
+    it "adds a header to the env hash" do
+      request.add_header "Content-Type", "text/html"
+      request.env["HTTP_CONTENT_TYPE"].should == "text/html"
+    end
   end
   
-  it "puts the logger into the env hash" do
-    log = stub("log")
-    @request.log = log
-    @request.env["rack.logger"].should == log
+  describe "#add_body_chunk" do
+    it "adds a chunk to the body input" do
+      request.env["rack.input"].should_receive(:write).with "asdf"
+      request.add_body_chunk "asdf"
+    end
   end
   
-  it "calls the app and stores its response" do
-    response = [303, {"Content-Type" => "text/html"}, ["foo bar"]]
-    @app.should_receive(:call).with(@request.env).and_return(response)
-    @request.should_receive(:succeed)
-    @request.call
-    @request.response.should == response
+  describe "#close_body" do
+    it "closes the body input for writing" do
+      request.env["rack.input"].should_receive(:close_write)
+      request.close_body
+    end
   end
   
-  it "fetches async responses" do
-    response = [-1, {}, []]
-    async_response = [200, {}, "okokok"]
-    @app.should_receive(:call).with(@request.env).and_return(response)
+  describe "#process" do
+    let(:response) { [-1, {}, []] }
     
-    @request.call
+    before { @outer_fiber = Fiber.current }
     
-    @request.should_receive(:succeed)
-    @request.env["async.callback"].call(async_response)
-    @request.response.should == async_response
-  end
-  
-  it "calls the app in a separate fiber" do
-    outer_fiber = Fiber.current
-    inner_fiber = nil
-    @app.singleton_class.send(:define_method, :call) do |env|
-      inner_fiber = Fiber.current
+    it "calls the app in a separate fiber" do
+      app.should_receive :call do |env|
+        request.env.should == env
+        @outer_fiber.should_not == Fiber.current
+        response
+      end
+      
+      request.process
     end
-    @request.call
     
-    outer_fiber.should_not == inner_fiber
-  end
-  
-  it "rescues errors in app's #call" do
-    @app.should_receive(:call) do
-      raise "error"
+    it "hands the response to post-processing in the same fiber" do
+      app.stub :call => response
+      request.should_receive :postprocess do |resp|
+        response.should == resp
+        @outer_fiber.should_not == Fiber.current
+      end
+      
+      request.process
     end
-    @request.should_receive(:succeed)
-    @request.call
-    
-    @request.response[0].should == 500
-    @request.response[1].should == {"Content-Type" => "text/html"}
-    @request.response[2].should == ["<h1>Internal Server Error</h1>"]
   end
   
-  it "rescues errors in app's #precall" do
-    @app.should_receive(:precall) do
-      raise "error"
+  describe "#postprocess" do
+    let :response do
+      [200, {"Content-Type" => "text/html"}, ["Hello", "World!"]]
     end
-    @request.should_receive(:succeed)
-    @request.precall
     
-    @request.response[0].should == 500
-    @request.response[1].should == {"Content-Type" => "text/html"}
-    @request.response[2].should == ["<h1>Internal Server Error</h1>"]
-  end
-  
-  it "calls the app's #precall method if it exists" do
-    called = false
-    request = @request
-    @app.singleton_class.send(:define_method, :precall) do |env|
-      env.should == request.env
-      called = true
+    before do
+      request.env.merge!({
+        "stream.start" => mock("stream.start"),
+        "stream.send" => mock("stream.send"),
+        "stream.close" => mock("stream.close")
+      })
     end
     
-    @app.stub(:respond_to? => false)
-    @request.precall
-    called.should be_false
-    
-    @app.stub(:respond_to? => true)
-    @request.precall
-    called.should be_true
-  end
-  
-  it "calls the app's #precall method in a separate fiber" do
-    outer_fiber = Fiber.current
-    inner_fiber = nil
-    @app.singleton_class.send(:define_method, :precall) do |env|
-      inner_fiber = Fiber.current
+    it "ignores responses with a status < 0" do
+      response[0] = -1
+      request.env["stream.start"].should_not_receive :call
+      
+      request.postprocess response
     end
-    @request.precall
-    
-    outer_fiber.should_not == inner_fiber
-  end
-  
-  it "adds headers to the env hash" do
-    @request.add_header("Content-Type", "text/html; charset=utf-8")
-    @request.env["HTTP_CONTENT_TYPE"].should == "text/html; charset=utf-8"
-  end
-  
-  it "adds data to the body" do
-    @request.add_body_chunk "asdf"
-    @request.env["rack.input"].string.should == "asdf"
     
-    @request.add_body_chunk "foo"
-    @request.env["rack.input"].string.should == "asdffoo"
-  end
-  
-  it "rewinds the body and closes its input before calling the app" do
-    @request.add_body_chunk "asdf"
-    @app.should_receive(:call) do |env|
-      env["rack.input"].closed_write?.should be_true
-      env["rack.input"].pos.should == 0
+    it "only sends response line and headers for streaming responses" do
+      response[2] = Rack::STREAMING
+      request.env["stream.start"].should_receive(:call).with response[0..1]
+      
+      request.postprocess response
     end
     
-    @request.call
+    it "sends the response and closes the stream" do
+      request.env["stream.start"].should_receive(:call).with response[0..1]
+      request.env["stream.send"].should_receive(:call).with response[2][0]
+      request.env["stream.send"].should_receive(:call).with response[2][1]
+      request.env["stream.close"].should_receive :call
+      
+      request.postprocess response
+    end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: rity
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Lars Gierth
@@ -10,10 +10,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-12 00:00:00 Z
+date: 2011-06-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -21,10 +22,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :runtime
-  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: em-synchrony
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -32,10 +33,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :runtime
-  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: hatetepe
+  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -43,10 +44,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :runtime
-  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: rack
+  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -54,10 +55,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :runtime
-  prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: async-rack
+  prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -65,10 +66,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :runtime
-  prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: thor
+  prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -76,10 +77,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :runtime
-  prerelease: false
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: rspec
+  prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -87,10 +88,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: fakefs
+  prerelease: false
   requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -98,10 +99,10 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: em-http-request
+  prerelease: false
   requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -109,7 +110,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id009
 description: Rity is a lightweight Ruby webserver that runs inside an EventMachine loop and puts each request into a fiber.
 email: 
@@ -122,12 +122,15 @@ extra_rdoc_files: []
 
 files: 
 - .rspec
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - bin/rity
+- config.ru
 - lib/rity.rb
+- lib/rity/body.rb
 - lib/rity/cli.rb
 - lib/rity/connection.rb
 - lib/rity/request.rb
@@ -136,6 +139,7 @@ files:
 - rity.gemspec
 - spec/integration/start_spec.rb
 - spec/spec_helper.rb
+- spec/unit/body_spec.rb
 - spec/unit/connection_spec.rb
 - spec/unit/request_spec.rb
 homepage: https://github.com/lgierth/rity
@@ -151,18 +155,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -888247411
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -888247411
-      segments: 
-      - 0
       version: "0"
 requirements: []