hatetepe 0.2.4 → 0.3.0

data/.yardopts

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

data/Gemfile

@@ -4,3 +4,6 @@ gemspec
 
 gem "rake"
 gem "awesome_print"
+
+gem "yard"
+gem "rdiscount"

data/README.md

@@ -1,17 +1,190 @@
-The HTTP toolkit
+The HTTP Toolkit
 ================
 
-Documentation is asking why you don't write it.
+Hatetepe is a framework for building HTTP servers, clients and proxies using the
+Ruby programming language. It makes use of EventMachine and uses a Fiber for
+each request/response cycle to ensure maximum efficiency. It has some great
+features that make it a good choice for building HTTP APIs.
 
-TODO
-----
+Install it via `gem install hatetepe` or add `gem "hatetepe"` to your Gemfile.
+
+Hatetepe only implements core HTTP functionality. If you need stuff like
+automatic JSON or form-data encoding, have a look at
+[Faraday](https://github.com/technoweenie/faraday), there's also an
+[Hatetepe adapter](https://github.com/lgierth/faraday/tree/hatetepe-support)
+for it being worked on.
+
+[![Build status](https://secure.travis-ci.org/lgierth/hatetepe.png?branch=master)](http://travis-ci.org/lgierth/hatetepe)
+
+
+Getting Started (Server)
+------------------------
+
+Using Hatetepe as your HTTP server is easy. Simply use the CLI that ships with
+the gem:
+
+    $ hatetepe
+    Booting from /home/lars/workspace/hatetepe/config.ru
+    Binding to 127.0.0.1:3000
+
+You can configure the network port and interface as well as the Rackup (.ru)
+file to be used. More help is available via the `hatetepe help` command.
+
+
+Getting Started (Client)
+------------------------
+
+The `Hatetepe::Client` class can be used to make requests to an HTTP server.
+
+    client = Hatetepe::Client.start(:host => "example.org", :port => 80)
+    request = Hatetepe::Request.new("POST", "/search", {}, :q => "herp derp")
+    client << request
+    request.callback do |response|
+      puts "Results:"
+      puts response.body.read
+    end
+    request.errback do |response|
+      puts "Error Code: #{response.status}"
+    end
+
+`Request` and `Response` objects are mostly the same, they offer:
+
+- `#verb` (only `Request`)
+- `#uri` (only `Request`)
+- `#status` (only `Response`)
+- `#http_version`
+- `#headers`
+- `#body`
+
+`Request` also has `#to_hash` which will turn the object into something your
+app can respond to.
+
+
+Async Responses
+---------------
+
+Like Thin and Goliath, Hatetepe provides `env["async.callback"]` for responding
+in an asynchronous fashion. Don't forget to synchronously indicate an
+asynchronous response by responding with a status of `-1`.
+
+    def call(env)
+      EM.add_timer(5) do
+        env["async.callback"].call [200, {"Content-Type" => "text/html"}, ["Hello!"]]
+      end
+      [-1]
+    end
+
+The reactor won't block while waiting for the timer to kick in, it will
+instead process other requests meanwhile.
+
+
+Proxying
+--------
+
+You can easily proxy a request to another HTTP server. The response will be
+proxied back to the original client automatically. Remember to return an
+async response.
+
+    def call(env)
+      env["proxy.start"].call "http://intra.example.org/derp"
+      [-1]
+    end
+
+This will internally just call `env["proxy.callback"]` (which defaults to
+`env["async.callback"]`). So if you want to send the response yourself, just
+override `env["proxy.callback"]`.
+
+If you want to reuse proxy connections (e.g. when doing Connection Pooling),
+simply create a `Client` instance and pass it to `env["proxy.start"]`.
+
+    env["proxy.start"].call "http://intra.example.org/derp", pool.acquire
+
+The reactor won't block while waiting for the proxy endpoint's response,
+it will instead process other requests meanwhile.
+
+
+Response Streaming
+------------------
+
+Streaming a response is easy. Just make your Rack app return a `-1` status code
+and use the `stream.start`, `stream.send` and `stream.close` helpers.
+
+    def call(env)
+      EM.add_timer 0.5 do
+        env["stream.start"].call [200, {"Content-Type" => "text/plain"}]
+      end
+      
+      1.upto 3 do |i|
+        EM.add_timer i do
+          env["stream.send"].call "I feel alive!\n"
+          env["stream.close"].call if i == 3
+        end
+      end
+      
+      [-1]
+    end
+
+There's no limit on how long you can stream, keep in mind though that you might
+hit timeouts. You can occasionally send LFs or something similar to prevent this
+from happening.
+
+
+Sending and Receiving BLOBs
+---------------------------
+
+Hatetepe provides a thin wrapper around StringIO that makes it easier to handle
+streaming of request and response bodies. That means your app will be `#call`ed as
+soon as all headers have arrived. It can then do stuff while it's still
+receiving body data. You might for example want to track upload progress.
+
+    received = nil
+    total = nil
+
+    post "/upload" do
+      total = request.headers["Content-Length"].to_i
+      request.env["rack.input"].each do |chunk|
+        received += chunk.bytesize
+      end
+      request.env["rack.input"].rewind
+    end
+    
+    get "/progress" do
+      json [received, total]
+    end
+
+`Hatetepe::Body#each` will block until the response has been received completely
+and yield each time a new chunk arrives. Calls to `#read`, `#gets` and `#length`
+will block until everything arrived and then return their normal return value
+as expected. `Body` includes `EM::Deferrable`, meaning you can attach
+callbacks to it. `#close_write` will succeed it - this is important if you
+want to make a request with a streaming body.
+
+
+Contributing
+------------
+
+1. Fork at [github.com/lgierth/hatetepe](https://github.com/lgierth/hatetepe)
+2. Create a new branch
+3. Commit, commit, commit!
+4. Open a Pull Request
+
+You can also open an issue for discussion first, if you like.
+
+
+License
+-------
+
+Hatetepe is subject to an MIT-style license (see LICENSE file).
+
+
+To Do and Ideas
+---------------
 
 - Proxy
 - Code reloading
-- Client
 - Keep-alive
-- Preforking
 - Native file sending/receiving
+- Preforking
 - MVM support via Thread Pool
 - Support for SPDY
 - Serving via filesystem or in-memory
@@ -20,9 +193,6 @@ TODO
 - Trailing headers
 - Propagating connection errors to the app
 
-Things to check out
--------------------
-
 - Fix http_parser.rb's parsing of chunked bodies
 - Does http_parser.rb recognize trailing headers?
 - Encoding support (see https://github.com/tmm1/http_parser.rb/pull/1)

data/lib/hatetepe/app.rb

@@ -9,13 +9,29 @@ module Hatetepe
   ERROR_RESPONSE = [500, {"Content-Type" => "text/html"},
                     ["Internal Server Error"]].freeze
   
+  # Interface between Rack-compatible applications and Hatetepe's server.
+  # Provides support for both synchronous and asynchronous responses.
   class App
     attr_reader :app
     
+    # Initializes a new App object.
+    #
+    # @param [#call] app
+    #   The Rack app
+    #
     def initialize(app)
       @app = app
     end
     
+    # Processes the request.
+    #
+    # Will call #postprocess with the Rack app's response. Catches :async
+    # as an additional indicator for an asynchronous response. Uses a standard
+    # 500 response if the Rack app raises an error.
+    #
+    # @param [Hash] env
+    #   The Rack environment
+    #
     def call(env)
       env["async.callback"] = proc {|response|
         postprocess env, response
@@ -28,6 +44,21 @@ module Hatetepe
       postprocess env, response
     end
     
+    # Sends the response.
+    #
+    # Does nothing if response status is indicating an asynchronous response.
+    # This is the case if the response Array's first element equals -1.
+    # Otherwise it will start sending the response (status and headers).
+    #
+    # If the body indicates streaming it will return after sending the status
+    # and headers. This happens if the body equals Rack::STREAMING. Otherwise
+    # it sends each body chunk and then closes the response stream.
+    #
+    # @param [Hash] env
+    #   The Rack environment
+    # @param [Array] response
+    #   An array of 1..3 length containing the status, headers, body
+    #
     def postprocess(env, response)
       return if response[0] == ASYNC_RESPONSE[0]
       

data/lib/hatetepe/body.rb

@@ -3,77 +3,163 @@ require "eventmachine"
 require "stringio"
 
 module Hatetepe
+  # Thin wrapper around StringIO for asynchronous body processing.
   class Body
     include EM::Deferrable
     
+    # The wrapped StringIO.
     attr_reader :io
+    
+    # The origin Client or Server connection.
     attr_accessor :source
     
-    def initialize(string = "")
+    # Create a new Body instance.
+    #
+    # @param [String] data
+    #   Initial content of the StringIO object.
+    def initialize(data = "")
       @receivers = []
-      @io = StringIO.new(string)
+      @io = StringIO.new(data)
     end
     
+    # Blocks until the Body is write-closed.
+    #
+    # Use this if you want to wait until _all_ of the body has arrived before
+    # continuing. It will resume the originating connection if it's paused.
+    #
+    # @return [undefined]
     def sync
       source.resume if source && source.paused?
       EM::Synchrony.sync self
     end
     
+    # Forwards to StringIO#length.
+    #
+    # Blocks until the Body is write-closed. Returns the current length of the
+    # underlying StringIO's content.
+    #
+    # @return [Fixnum]
+    #   The StringIO's length.
     def length
-      # TODO maybe I want to #sync here
-      @io.length
+      sync
+      io.length
     end
     
+    # Returns true if the underlying StringIO is empty, false otherwise.
+    #
+    # @return [Boolean]
+    #   True if empty, false otherwise.
     def empty?
       length == 0
     end
     
+    # Forwards to StringIO#pos.
+    #
+    # Returns the underlying StringIO's current pointer position.
+    #
+    # @return [Fixnum]
+    #   The current pointer position.
     def pos
-      @io.pos
+      io.pos
     end
     
+    # Forwards to StringIO#rewind.
+    #
+    # Moves the underlying StringIO's pointer back to the beginnung.
+    #
+    # @return [undefined]
     def rewind
-      @io.rewind
+      io.rewind
     end
     
+    # Forwards to StringIO#close_write.
+    #
+    # Write-closes the body and succeeds, thus releasing all blocking method
+    # calls like #length, #each, #read and #get.
+    #
+    # @return [undefined]
     def close_write
-      ret = @io.close_write
+      io.close_write
       succeed
-      ret
     end
     
+    # Forwards to StringIO#closed_write?.
+    #
+    # Returns true if the body is write-closed, false otherwise.
+    #
+    # @return [Boolean]
+    #   True if the body is write-closed, false otherwise.
     def closed_write?
-      @io.closed_write?
+      io.closed_write?
     end
     
+    # Yields incoming body data.
+    #
+    # Immediately yields all data that has already arrived. Blocks until the
+    # Body is write-closed and yields for each call to #write until then.
+    #
+    # @yield [String] Block to execute for each incoming data chunk
+    #
+    # @return [undefined]
     def each(&block)
       @receivers << block
-      block.call @io.string.dup unless @io.string.empty?
+      block.call io.string.dup unless io.string.empty?
       sync
     end
     
+    # Forwards to StringIO#read.
+    #
+    # From the Rack Spec: If given, +length+ must be a non-negative Integer
+    # (>= 0) or +nil+, and +buffer+ must be a String and may not be nil. If
+    # +length+ is given and not nil, then this method reads at most +length+
+    # bytes from the input stream. If +length+ is not given or nil, then this
+    # method reads all data until EOF. When EOF is reached, this method returns
+    # nil if +length+ is given and not nil, or "" if +length+ is not given or
+    # is nil. If +buffer+ is given, then the read data will be placed into
+    # +buffer+ instead of a newly created String object.
+    #
+    # @param [Fixnum] length (optional)
+    #   How many bytes to read.
+    # @param [String] buffer (optional)
+    #   Buffer for read data.
+    #
+    # @return [nil]
+    #   +nil+ if EOF has been reached.
+    # @return [String]
+    #   All data or at most +length+ bytes of data if +length+ is given.
     def read(*args)
       sync
-      @io.read *args
+      io.read *args
     end
     
+    # Forwards to StringIO#gets.
+    #
+    # Reads one line from the IO. Returns the line or +nil+ if EOF has been
+    # reached.
+    #
+    # @return [String]
+    #   One line.
+    # @return [nil]
+    #   If has been reached.
     def gets
       sync
-      @io.gets
-    end
-    
-    def write(chunk)
-      ret = @io.write chunk
-      Fiber.new {
-        @receivers.each {|r| r.call chunk }
-      }.resume
-      ret
+      io.gets
     end
     
-    def <<(chunk)
-      ret = @io << chunk
+    # Forwards to StringIO#write.
+    #
+    # Appends the given String to the underlying StringIO annd returns the
+    # number of bytes written.
+    #
+    # @param [String] data
+    #   The data to append
+    #
+    # @return [Fixnum]
+    #   The number of bytes written.
+    def write(data)
+      ret = io.write data
       Fiber.new {
-        @receivers.each {|r| r.call chunk }
+        @receivers.each {|r| r.call data }
       }.resume
       ret
     end

data/lib/hatetepe/builder.rb

@@ -1,5 +1,3 @@
-require "hatetepe/status"
-
 module Hatetepe
   class BuilderError < StandardError; end
   
@@ -82,7 +80,7 @@ module Hatetepe
     
     def response_line(code, version = "1.1")
       complete unless ready?
-      unless status = STATUS_CODES[code]
+      unless status = Rack::Utils::HTTP_STATUS_CODES[code]
         error "Unknown status code: #{code}"
       end
       

data/lib/hatetepe/client.rb

@@ -59,6 +59,7 @@ module Hatetepe
       parser.on_headers {
         requests.reverse.find {|req| !!req.response }.tap {|req|
           req.succeed req.response
+          # XXX do i want to treat HEAD individually?
           parser.complete if req.verb == :head
         }
       }

data/lib/hatetepe/parser.rb

@@ -38,7 +38,7 @@ module Hatetepe
         }
         
         p.on_body = proc {|chunk|
-          message.body << chunk unless message.body.closed_write?
+          message.body.write chunk unless message.body.closed_write?
         }
         
         p.on_message_complete = method(:complete)

data/lib/hatetepe/proxy.rb

@@ -1,58 +1,54 @@
-require "eventmachine"
-require "uri"
-
 require "hatetepe/client"
+require "hatetepe/request"
+require "uri"
 
 module Hatetepe
   class Proxy
-    attr_reader :app, :env
+    attr_reader :app
     
     def initialize(app)
       @app = app
     end
     
     def call(env)
-      @env = env
-      env["proxy.start"] = method(:start)
-      
+      env["proxy.start"] = proc do |target, client = nil|
+        start env, target, client
+      end
       app.call env
     end
     
-    def start(target)
-      uri = build_uri(target)
-      
+    def start(env, target, client)
+      target = URI.parse(target)
       env.delete "proxy.start"
-      env["proxy.callback"] ||= method(:callback)
       
-      response = Client.request(verb, uri, headers)
-      env["proxy.callback"].call @response, env
-    end
-    
-    def callback(response, env)
-      response
-    end
-  end
-end
-
-module Hatetepe
-  class OldProxy
-    attr_reader :env, :target
-    
-    def initialize(env, target)
-      client = EM.connect target.host, target.port, Client
-      client.request env["rity.request"].verb, env["rity.request"].uri
+      env["proxy.callback"] ||= env["async.callback"]
       
-      env["proxy.callback"] ||= proc {|response|
-        env["proxy.start_reverse"].call response
-      }
-      env["proxy.start_reverse"] = proc {|response|
-        env["stream.start"].call *response[0..1]
-        env["stream.send_raw"].call client.requests
-      }
+      cl = client || Client.start(:host => target.host, :port => target.port)
+      build_request(env, target).tap do |req|
+        cl << req
+        EM::Synchrony.sync req
+        cl.stop unless client
+        env["proxy.callback"].call req.response
+      end
     end
     
-    def initialize(env, target)
-      response = Client.request(env["rity.request"])
+    # TODO only use +env+ to build the request
+    def build_request(env, target)
+      unless base = env["hatetepe.request"]
+        raise ArgumentError, "Proxying requires env[hatetepe.request] to be set"
+      end
+      
+      uri = target.path + base.uri
+      host = "#{target.host}:#{target.port}"
+      headers = base.headers.merge({
+        "X-Forwarded-For" => env["REMOTE_ADDR"],
+        "Host" => [base.headers["Host"], host].compact.join(", ")
+      })
+      
+      Request.new(base.verb, uri, base.http_version).tap do |req|
+        req.headers = headers
+        req.body = base.body
+      end
     end
   end
 end

data/lib/hatetepe/server.rb

@@ -24,7 +24,7 @@ module Hatetepe
       
       @app = Rack::Builder.new.tap {|b|
         b.use Hatetepe::App
-        #b.use Hatetepe::Proxy
+        b.use Hatetepe::Proxy
         b.run config[:app]
       }
 

data/lib/hatetepe/version.rb

@@ -1,3 +1,3 @@
 module Hatetepe
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
 end

data/spec/unit/body_spec.rb

@@ -17,6 +17,8 @@ describe Hatetepe::Body do
   context "#initialize(string)" do
     let(:body) { Hatetepe::Body.new "herp derp" }
     
+    before { body.close_write }
+    
     it "writes the passed string" do
       body.length.should equal(9)
       body.io.read.should == "herp derp"
@@ -44,9 +46,24 @@ describe Hatetepe::Body do
     let(:length) { stub "length" }
     
     it "forwards to io#length" do
+      body.stub :sync
       body.io.stub :length => length
+      
       body.length.should equal(length)
     end
+    
+    it "waits for the body to succeed" do
+      succeeded = false
+      Fiber.new {
+        body.length
+        succeeded = true
+      }.resume
+      
+      succeeded.should be_false
+      
+      body.close_write
+      succeeded.should be_true
+    end
   end
   
   context "#empty?" do
@@ -81,10 +98,8 @@ describe Hatetepe::Body do
   
   context "#close_write" do
     it "forwards to io#close_write" do
-      ret = stub("return")
-      body.io.should_receive(:close_write) { ret }
-      
-      body.close_write.should equal(ret)
+      body.io.should_receive :close_write
+      body.close_write
     end
     
     it "succeeds the body" do
@@ -107,7 +122,7 @@ describe Hatetepe::Body do
       chunks = ["111", "222"]
       received, succeeded = [], false
       
-      body << chunks[0]
+      body.write chunks[0]
       Fiber.new {
         body.each {|chunk| received << chunk }
         succeeded = true
@@ -115,7 +130,7 @@ describe Hatetepe::Body do
       received.should == chunks.values_at(0)
       succeeded.should be_false
       
-      body << chunks[1]
+      body.write chunks[1]
       received.should == chunks
       succeeded.should be_false
       
@@ -172,13 +187,4 @@ describe Hatetepe::Body do
       body.write(arg).should equal(ret)
     end
   end
-  
-  context "#<<(chunk)" do
-    it "forwards to io#<<" do
-      arg, ret = stub("arg"), stub("ret")
-      body.io.should_receive(:<<).with(arg) { ret }
-      
-      body.<<(arg).should equal(ret)
-    end
-  end
 end

data/spec/unit/parser_spec.rb

@@ -165,7 +165,8 @@ describe Hatetepe::Parser do
       block.should_receive(:call) {|body|
         body.should equal(parser.message.body)
         
-        body.should be_empty
+        # we'd have to #close_write to get body#length
+        body.io.length.should == 0
       }
       
       parser.on_body &block

data/spec/unit/proxy_spec.rb

@@ -0,0 +1,154 @@
+require "spec_helper"
+require "hatetepe/proxy"
+
+describe Hatetepe::Proxy do
+  let(:app) { stub "app" }
+  
+  describe "#initialize(app)" do
+    it "sets the app" do
+      Hatetepe::Proxy.new(app).app.should equal(app)
+    end
+  end
+  
+  let(:proxy) { Hatetepe::Proxy.new app }
+  let(:target) { stub "target" }
+  let(:env) { {} }
+  let(:client) { stub "client", :<< => nil }
+  
+  describe "#call(env)" do
+    it "sets env[proxy.start]" do
+      app.stub :call do |env|
+        env["proxy.start"].should respond_to(:call)
+      end
+      proxy.call env
+    end
+    
+    let(:response) { stub "response" }
+    
+    it "calls the app" do
+      app.should_receive(:call).with(env) { response }
+      proxy.call(env).should equal(response)
+    end
+    
+    describe "env[proxy.start]" do
+      it "forwards to #start" do
+        proxy.should_receive(:start).with(env, target, client)
+        app.stub :call do |env|
+          env["proxy.start"].call target, client
+        end
+        proxy.call env
+      end
+    end
+  end
+  
+  describe "#start(env, target, client)" do
+    let(:request) { stub "request" }
+    let(:response) { stub "response" }
+    let(:callback) { stub "async.callback", :call => nil }
+    
+    let(:host) { stub "host" }
+    let(:port) { stub "port" }
+    let(:target) { stub "target", :host => host, :port => port }
+    
+    before do
+      URI.stub :parse => target
+      proxy.stub :build_request => request
+      
+      request.stub :dup => request, :response => response
+      request.extend EM::Deferrable
+      env["async.callback"] = callback
+    end
+    
+    it "deletes env[proxy.start] from the env hash" do
+      env.should_receive(:delete).with "proxy.start"
+      Fiber.new { proxy.start env, target, client }.resume
+    end
+    
+    it "defaults env[proxy.callback] to env[async.callback]" do
+      Fiber.new { proxy.start env, target, client }.resume
+      env["proxy.callback"].should equal(env["async.callback"])
+    end
+    
+    let(:new_client) { stub "new client" }
+    
+    it "starts a client if none was passed" do
+      Hatetepe::Client.stub :start do |config|
+        config[:host].should equal(host)
+        config[:port].should equal(port)
+        new_client
+      end
+      new_client.should_receive(:<<).with request
+      Fiber.new { proxy.start env, target, nil }.resume
+    end
+    
+    it "doesn't stop a client that was passed" do
+      client.should_not_receive :stop
+      Fiber.new { proxy.start env, target, client }.resume
+      request.succeed
+    end
+    
+    it "passes the request to the client" do
+      proxy.should_receive :build_request do |e, t|
+        env.should equal(e)
+        target.should equal(t)
+        request
+      end
+      client.should_receive(:<<).with request
+      Fiber.new { proxy.start env, target, client }.resume
+    end
+    
+    it "passes the response to env[async.callback]" do
+      callback.should_receive(:call).with response
+      Fiber.new { proxy.start env, target, client }.resume
+      request.succeed
+    end
+    
+    it "waits for the request to succeed" do
+      succeeded = false
+      callback.stub(:call) {|response| succeeded = true }
+      
+      Fiber.new { proxy.start env, target, client }.resume
+      succeeded.should be_false
+      
+      request.succeed
+      succeeded.should be_true
+    end
+  end
+  
+  describe "#build_request(env, target)" do
+    let(:target) { URI.parse "http://localhost:3000/bar" }
+    let(:base_request) { Hatetepe::Request.new "GET", "/foo" }
+    
+    before do
+      env["hatetepe.request"] = base_request
+      env["REMOTE_ADDR"] = "123.234.123.234"
+    end
+    
+    it "fails if env[hatetepe.request] isn't set" do
+      env.delete "hatetepe.request"
+      proc { proxy.build_request env, target }.should raise_error(ArgumentError)
+    end
+    
+    it "combines the original URI with the target URI" do
+      proxy.build_request(env, target).uri.should == "/bar/foo"
+    end
+    
+    it "sets X-Forwarded-For header" do
+      xff = proxy.build_request(env, target).headers["X-Forwarded-For"]
+      env["REMOTE_ADDR"].should == xff
+    end
+    
+    it "adds the target to Host header" do
+      host = "localhost:3000"
+      proxy.build_request(env, target).headers["Host"].should == host
+      
+      base_request.headers["Host"] = host
+      host = "localhost:3000, localhost:3000"
+      proxy.build_request(env, target).headers["Host"].should == host
+    end
+    
+    it "builds a new request" do
+      proxy.build_request(env, target).should_not equal(base_request)
+    end
+  end
+end

data/spec/unit/server_spec.rb

@@ -45,6 +45,7 @@ describe Hatetepe::Server do
     it "builds the app" do
       Rack::Builder.stub :new => builder
       builder.should_receive(:use).with Hatetepe::App
+      builder.should_receive(:use).with Hatetepe::Proxy
       builder.should_receive(:run).with app
       
       server.send :initialize, config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hatetepe
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-24 00:00:00.000000000Z
+date: 2011-11-01 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
-  requirement: &77539070 !ruby/object:Gem::Requirement
+  requirement: &85707400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.5.3
   type: :runtime
   prerelease: false
-  version_requirements: *77539070
+  version_requirements: *85707400
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &77524530 !ruby/object:Gem::Requirement
+  requirement: &85706930 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *77524530
+  version_requirements: *85706930
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &77524030 !ruby/object:Gem::Requirement
+  requirement: &85706430 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *77524030
+  version_requirements: *85706430
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &77523660 !ruby/object:Gem::Requirement
+  requirement: &85705840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *77523660
+  version_requirements: *85705840
 - !ruby/object:Gem::Dependency
   name: async-rack
-  requirement: &77523290 !ruby/object:Gem::Requirement
+  requirement: &85705450 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *77523290
+  version_requirements: *85705450
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &77522880 !ruby/object:Gem::Requirement
+  requirement: &85705070 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *77522880
+  version_requirements: *85705070
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &77521160 !ruby/object:Gem::Requirement
+  requirement: &85704360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *77521160
+  version_requirements: *85704360
 - !ruby/object:Gem::Dependency
   name: fakefs
-  requirement: &77520680 !ruby/object:Gem::Requirement
+  requirement: &85703690 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *77520680
+  version_requirements: *85703690
 - !ruby/object:Gem::Dependency
   name: em-http-request
-  requirement: &77519340 !ruby/object:Gem::Requirement
+  requirement: &85703190 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -109,7 +109,7 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *77519340
+  version_requirements: *85703190
 description: 
 email:
 - lars.gierth@gmail.com
@@ -120,6 +120,7 @@ extra_rdoc_files: []
 files:
 - .rspec
 - .travis.yml
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
@@ -135,13 +136,10 @@ files:
 - lib/hatetepe/events.rb
 - lib/hatetepe/message.rb
 - lib/hatetepe/parser.rb
-- lib/hatetepe/prefork.rb
 - lib/hatetepe/proxy.rb
 - lib/hatetepe/request.rb
 - lib/hatetepe/response.rb
 - lib/hatetepe/server.rb
-- lib/hatetepe/status.rb
-- lib/hatetepe/thread_pool.rb
 - lib/hatetepe/version.rb
 - lib/rack/handler/hatetepe.rb
 - spec/integration/cli/start_spec.rb
@@ -152,6 +150,7 @@ files:
 - spec/unit/client_spec.rb
 - spec/unit/events_spec.rb
 - spec/unit/parser_spec.rb
+- spec/unit/proxy_spec.rb
 - spec/unit/rack_handler_spec.rb
 - spec/unit/server_spec.rb
 homepage: https://github.com/lgierth/hatetepe

data/lib/hatetepe/prefork.rb

@@ -1,11 +0,0 @@
-module Hatetepe
-  class Prefork
-    def self.run(server)
-      prefork = new(server)
-      fork {
-        prefork.serve
-      }
-      prefork.manage
-    end
-  end
-end

data/lib/hatetepe/status.rb

@@ -1,42 +0,0 @@
-module Hatetepe
-  # @author Mongrel
-  STATUS_CODES = {
-    100 => "Continue",
-    101 => "Switching Protocols",
-    200 => "OK",
-    201 => "Created",
-    202 => "Accepted",
-    203 => "Non-Authoritative Information",
-    204 => "No Content",
-    205 => "Reset Content",
-    206 => "Partial Content",
-    300 => "Multiple Choices",
-    301 => "Moved Permanently",
-    302 => "Moved Temporarily",
-    303 => "See Other",
-    304 => "Not Modified",
-    305 => "Use Proxy",
-    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 Time-out",
-    409 => "Conflict",
-    410 => "Gone",
-    411 => "Length Required",
-    412 => "Precondition Failed",
-    413 => "Request Entity Too Large",
-    414 => "Request-URI Too Large",
-    415 => "Unsupported Media Type",
-    500 => "Internal Server Error",
-    501 => "Not Implemented",
-    502 => "Bad Gateway",
-    503 => "Service Unavailable",
-    504 => "Gateway Time-out",
-    505 => "HTTP Version Not Supported"
-  }
-end

data/lib/hatetepe/thread_pool.rb

@@ -1,4 +0,0 @@
-module Hatetepe
-  class ThreadPool
-  end
-end