hatetepe 0.2.3 → 0.2.4

data/lib/hatetepe/builder.rb

@@ -60,40 +60,42 @@ module Hatetepe
       @chunked
     end
     
-    def request(verb, uri, version = "1.1")
+    def request(req)
+      request_line req[0], req[1]
+      headers req[2]
+      body req[3] if req[3]
+      complete
+    end
+    
+    def request_line(verb, uri, version = "1.1")
       complete unless ready?
       write "#{verb.upcase} #{uri} HTTP/#{version}\r\n"
       @state = :writing_headers
     end
     
-    def response(code, version = "1.1")
-      if Array === code
-        response(code[0])
-        code[1].each_pair {|name, value| header(name, value) }
-        if code[2]
-          code[2].each {|chunk| body(chunk) }
-          complete
-        end
-        return
-      end
-      
+    def response(res)
+      response_line res[0]
+      headers res[1]
+      body res[2] if res[2]
+      complete
+    end
+    
+    def response_line(code, version = "1.1")
       complete unless ready?
       unless status = STATUS_CODES[code]
         error "Unknown status code: #{code}"
       end
+      
       write "HTTP/#{version} #{code} #{status}\r\n"
       @state = :writing_headers
     end
     
-    def header(name, value, charset = nil)
-      charset = charset ? "; charset=#{charset}" : ""
-      raw_header "#{name}: #{value}#{charset}"
+    def header(name, value)
+      raw_header "#{name}: #{value}"
     end
     
     def headers(hash)
-      # wrong number of arguments (1 for 2)
-      #hash.each_pair &method(:header)
-      hash.each_pair {|name, value| header name, value }
+      hash.each {|k, v| header k, v }
     end
     
     def raw_header(header)
@@ -105,7 +107,7 @@ module Hatetepe
         @state = :writing_trailing_headers
       end
       
-      if header[0..13] == "Content-Length"
+      if @chunked.nil? && header[0..13] == "Content-Length"
         @chunked = false
       elsif @chunked.nil? && header[0..16] == "Transfer-Encoding"
         @chunked = true
@@ -114,12 +116,12 @@ module Hatetepe
       write "#{header}\r\n"
     end
     
-    def body(chunk)
-      if chunk.respond_to? :each
-        chunk.each &method(:body)
-        return
-      end
-      
+    def body(body)
+      body.each {|c| body_chunk c }
+      # XXX complete here?
+    end
+    
+    def body_chunk(chunk)
       if ready?
         error "A request or response line and headers are required before writing body"
       elsif writing_trailing_headers?
@@ -135,29 +137,28 @@ module Hatetepe
       if chunked?
         write "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
       else
-        write chunk
+        write chunk unless chunk.empty?
       end
     end
     
     def complete
-      return if ready?
-      
-      if writing_headers? || writing_trailing_headers?
+      if ready?
+        return
+      elsif writing_headers? && @chunked.nil?
         header "Content-Length", "0"
       end
-      body ""
-      
+      body_chunk ""
+
       on_complete.each {|blk| blk.call }
       reset
     end
     
-    def write(chunk)
-      on_write.each {|blk| blk.call(chunk) }
+    def write(data)
+      on_write.each {|blk| blk.call data }
     end
     
     def error(message)
       exception = BuilderError.new(message)
-      exception.set_backtrace(caller[1..-1])
       unless on_error.empty?
         on_error.each {|blk| blk.call(exception) }
       else

data/lib/hatetepe/cli.rb

@@ -22,8 +22,8 @@ module Hatetepe
     method_option :rackup, :aliases => "-r", :type => :string,
       :banner => "Load specified rackup (.ru) file (default: config.ru)"
     def start
-      rackup = options[:rackup] || "config.ru"
-      $stderr << "Booting from #{File.expand_path rackup}\n"
+      rackup = File.expand_path(options[:rackup] || "config.ru")
+      $stderr << "Booting from #{rackup}\n"
       $stderr.flush
       app = Rack::Builder.parse_file(rackup)[0]
 

data/lib/hatetepe/client.rb

@@ -74,7 +74,7 @@ module Hatetepe
 
       requests << request
       Fiber.new {
-        builder.request request.verb, request.uri
+        builder.request_line request.verb, request.uri
         
         if request.headers["Content-Type"] == "application/x-www-form-urlencoded"
           if request.body.respond_to? :read
@@ -89,7 +89,7 @@ module Hatetepe
         if Body === b || b.respond_to?(:each)
           builder.body b
         elsif b.respond_to? :read
-          builder.body b.read
+          builder.body [b.read]
         else
           builder.body [b]
         end

data/lib/hatetepe/server.rb

@@ -75,11 +75,13 @@ module Hatetepe
         e["stream.start"] = proc {|response|
           e.delete "stream.start"
           EM::Synchrony.sync previous if previous
+          
+          builder.response_line response[0]
           response[1]["Server"] = "hatetepe/#{VERSION}"
-          builder.response response[0..1]
+          builder.headers response[1]
         }
         
-        e["stream.send"] = builder.method(:body)
+        e["stream.send"] = builder.method(:body_chunk)
         
         e["stream.close"] = proc {
           e.delete "stream.send"

data/lib/hatetepe/version.rb

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

data/spec/unit/builder_spec.rb

@@ -0,0 +1,372 @@
+require "spec_helper"
+require "hatetepe/builder"
+
+describe Hatetepe::Builder do
+  let(:builder) { Hatetepe::Builder.allocate }
+  
+  describe ".build {|builder| ... }"
+  
+  describe "#initialize" do
+    it "resets the builder" do
+      builder.should_receive :reset
+      builder.send :initialize
+    end
+    
+    it "initializes the on_complete, on_write, on_error hooks" do
+      builder.send :initialize
+      [:complete, :write, :error].each do |hook|
+        builder.send(:"on_#{hook}").tap do |h|
+          h.should be_an(Array)
+          h.should be_empty
+        end
+      end
+    end
+  end
+  
+  describe "#initialize {|builder| ... }" do
+    it "yields the builder" do
+      arg = nil
+      builder.send(:initialize) {|b| arg = b }
+      arg.should equal(builder)
+    end
+  end
+  
+  [:complete, :write, :error].each do |hook|
+    describe "#on_#{hook} {|*| ... }" do
+      let(:block) { proc {} }
+      before { builder.send :initialize }
+      
+      it "adds a hook block" do
+        builder.send :"on_#{hook}", &block
+        builder.send(:"on_#{hook}").should include(block)
+      end
+    end
+  end
+  
+  describe "#writing_trailing_headers?" do
+    it "returns true if the builder state is :ready" do
+      builder.stub :state => :ready
+      builder.ready?.should be_true
+    end
+    
+    it "returns false otherwise" do
+      builder.stub :state => :something
+      builder.ready?.should be_false
+    end
+  end
+  
+  describe "#reset" do
+    before { builder.send :reset }
+    
+    # XXX maybe don't test chunked flag
+    it "resets the chunked flag and the builder state" do
+      builder.chunked?.should be_nil
+      builder.ready?.should be_true
+    end
+  end
+  
+  # XXX maybe test states and flags where they are being mutated
+  describe "#ready?"
+  describe "#writing_headers?"
+  describe "#writing_body?"
+  describe "#writing_trailing_headers?"
+  describe "#chunked?"
+
+  describe "#request(array)" do
+    let(:req) { [:get, "/foo", {"Key" => "value"}, stub("body")] }
+    
+    before { builder.send :initialize }
+    
+    it "is a shortcut for #request_line, #headers, #body, #complete" do
+      builder.should_receive(:request_line).with req[0], req[1]
+      builder.should_receive(:headers).with req[2]
+      builder.should_receive(:body).with req[3]
+      builder.should_receive :complete
+      builder.request req
+    end
+    
+    it "doesn't require a body (fourth element)" do
+      builder.should_receive(:request_line).with req[0], req[1]
+      builder.should_receive(:headers).with req[2]
+      builder.should_not_receive :body
+      builder.request req[0..2]
+    end
+  end
+    
+  describe "#request_line(verb, uri, version)" do
+    before { builder.send :initialize }
+    
+    it "writes a request line" do
+      builder.should_receive(:write).with "GET /foo HTTP/1.0\r\n"
+      builder.request_line :get, "/foo", "1.0"
+    end
+    
+    it "changes the state to :writing_headers" do
+      builder.request_line :get, "/foo"
+      builder.state.should equal(:writing_headers)
+    end
+    
+    it "defaults the version to 1.1" do
+      builder.should_receive(:write).with "GET /foo HTTP/1.1\r\n"
+      builder.request_line :get, "/foo"
+    end
+  end
+  
+  describe "#response_line(code, version)" do
+    before { builder.send :initialize }
+    
+    it "writes a response line" do
+      builder.should_receive(:write).with "HTTP/1.0 403 Forbidden\r\n"
+      builder.response_line 403, "1.0"
+    end
+    
+    it "changes the state to :writing_headers" do
+      builder.response_line 403
+      builder.state.should equal(:writing_headers)
+    end
+    
+    it "default the version to 1.1" do
+      builder.should_receive(:write).with "HTTP/1.1 403 Forbidden\r\n"
+      builder.response_line 403
+    end
+    
+    it "fails if there's no status message for code" do
+      builder.should_receive :error
+      builder.response_line 666
+    end
+  end
+  
+  describe "#response(array)" do
+    let(:res) { [201, {"Key" => "value"}, stub("body")] }
+    
+    before { builder.send :initialize }
+    
+    it "is a shortcut for #response_line, #headers, #body, #complete" do
+      builder.should_receive(:response_line).with res[0]
+      builder.should_receive(:headers).with res[1]
+      builder.should_receive(:body).with res[2]
+      builder.should_receive :complete
+      builder.response res
+    end
+    
+    it "doesn't require a body (third element)" do
+      builder.should_receive(:response_line).with res[0]
+      builder.should_receive(:headers).with res[1]
+      builder.should_not_receive :body
+      builder.response res[0..1]
+    end
+  end
+  
+  describe "#headers(hash)" do
+    it "writes each of the header pairs" do
+      builder.should_receive(:header).with "Key", "value"
+      builder.should_receive(:header).with "Key2", "value2"
+      builder.headers "Key" => "value", "Key2" => "value2"
+    end
+  end
+  
+  describe "#header(name, value)" do
+    it "writes the header pair" do
+      builder.should_receive(:raw_header).with "Key: value"
+      builder.header "Key", "value"
+    end
+  end
+  
+  describe "#raw_header(header)" do
+    before do
+      builder.send :initialize
+      builder.response_line 200
+    end
+    
+    it "writes the header line" do
+      builder.should_receive(:write).with "Key: value\r\n"
+      builder.raw_header "Key: value"
+    end
+    
+    it "fails if no request or response line has been written" do
+      builder.reset
+      builder.should_receive :error
+      builder.raw_header "Key: value"
+    end
+    
+    it "fails if body already started" do
+      builder.header "Content-Length", 5
+      builder.body_chunk "asd"
+      
+      builder.should_receive :error
+      builder.raw_header "Key: value"
+    end
+    
+    it "writes trailing header if body already started and transfer is chunked" do
+      builder.header "Transfer-Encoding", "chunked"
+      builder.body_chunk "asd"
+      
+      builder.should_not_receive :error
+      builder.should_receive(:write).with "0\r\n"
+      builder.should_receive(:write).with "Key: value\r\n"
+      builder.raw_header "Key: value"
+      
+      builder.state.should equal(:writing_trailing_headers)
+    end
+    
+    it "sets the chunked flag" do
+      builder.header "Transfer-Encoding", "chunked"
+      builder.chunked?.should be_true
+      
+      builder.reset
+      builder.response_line 200
+      
+      builder.header "Content-Length", "0"
+      builder.chunked?.should be_false
+    end
+    
+    it "doesn't set the chunked flag a second time" do
+      builder.header "Transfer-Encoding", "chunked"
+      builder.chunked?.should be_true
+      
+      builder.header "Content-Length", "0"
+      builder.chunked?.should be_true
+    end
+  end
+  
+  describe "#body(#each)" do
+    let(:body) { [stub("chunk#1"), stub("chunk#2")] }
+    
+    it "calls #body_chunk for each element" do
+      builder.should_receive(:body_chunk).with body[0]
+      builder.should_receive(:body_chunk).with body[1]
+      builder.body body
+    end
+  end
+  
+  describe "#body_chunk(chunk)" do
+    before do
+      builder.send :initialize
+      builder.response_line 200
+    end
+    
+    it "fails if no request or response line has been written" do
+      builder.reset
+      builder.should_receive :error
+      builder.body_chunk "asd"
+    end
+    
+    it "fails if already writing trailing headers" do
+      builder.body_chunk "asd"
+      builder.header "Key", "value"
+      builder.should_receive :error
+      builder.body_chunk "asd"
+    end
+    
+    it "assumes Transfer-Encoding: chunked if chunked flag isn't set" do
+      builder.should_receive(:header).with "Transfer-Encoding", "chunked"
+      builder.body_chunk "asd"
+    end
+    
+    it "changes the state to :writing_body" do
+      builder.body_chunk "asd"
+      builder.state.should equal(:writing_body)
+    end
+    
+    it "writes chunked body data" do
+      builder.body_chunk ""
+      builder.should_receive(:write).with "c\r\nasdfoobarbaz\r\n"
+      builder.body_chunk "asdfoobarbaz"
+    end
+    
+    it "writes empty chunked data" do
+      builder.body_chunk ""
+      builder.should_receive(:write).with "0\r\n\r\n"
+      builder.body_chunk ""
+    end
+    
+    it "writes plain body data" do
+      builder.header "Content-Length", "12"
+      builder.body_chunk ""
+      builder.should_receive(:write).with "asdfoobarbaz"
+      builder.body_chunk "asdfoobarbaz"
+    end
+    
+    it "doesn't write empty plain data" do
+      builder.header "Content-Length", "123"
+      builder.body_chunk ""
+      builder.should_not_receive :write
+      builder.body_chunk ""
+    end
+  end
+  
+  describe "#complete" do
+    before do
+      builder.send :initialize
+      builder.response_line 200
+      builder.stub :body_chunk
+    end
+    
+    it "does nothing if state is :ready" do
+      builder.reset
+      builder.should_not_receive :write
+      builder.complete
+    end
+    
+    it "sets Content-Length to 0 if no body has been sent and transfer is chunked" do
+      builder.should_receive(:header).with "Content-Length", "0"
+      builder.complete
+    end
+    
+    it "writes an empty body chunk" do
+      builder.should_receive(:body_chunk).with ""
+      builder.complete
+    end
+    
+    let(:hook) { stub "hook", :call => nil }
+    
+    it "calls the on_complete hooks" do
+      builder.on_complete << hook
+      hook.should_receive :call
+      builder.complete
+    end
+    
+    it "calls #reset" do
+      builder.should_receive :reset
+      builder.complete
+    end
+  end
+  
+  describe "#write(data)" do
+    let(:hook) { stub "hook" }
+    let(:data) { stub "data" }
+    
+    before { builder.send :initialize }
+    
+    it "calls the on_write hooks" do
+      builder.on_write << hook
+      hook.should_receive(:call).with data
+      builder.write data
+    end
+  end
+  
+  describe "#error(message)" do
+    let(:hook1) { stub "hook#1" }
+    let(:hook2) { stub "hook#2" }
+    let(:message) { "error! error!" }
+    let(:exception) { stub "exception" }
+    
+    before do
+      builder.send :initialize
+      builder.on_error << hook1 << hook2
+    end
+    
+    it "calls the error hooks" do
+      Hatetepe::BuilderError.stub :new => exception
+      
+      hook1.should_receive(:call).with exception
+      hook2.should_receive(:call).with exception
+      builder.error message
+    end
+    
+    it "raises the exception if no hooks were added" do
+      builder.on_error.clear
+      proc { builder.error message }.should raise_error(Hatetepe::BuilderError, message)
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -210,7 +210,7 @@ describe Hatetepe::Client do
     it "feeds the builder" do
       request.body.write "asdf"
       
-      builder.should_receive(:request).with request.verb, request.uri
+      builder.should_receive(:request_line).with request.verb, request.uri
       builder.should_receive(:headers).with request.headers
       builder.should_receive(:body).with request.body
       builder.should_receive(:complete)
@@ -220,7 +220,7 @@ describe Hatetepe::Client do
     
     it "wraps the builder feeding within a Fiber" do
       outer, inner = Fiber.current, nil
-      builder.should_receive(:request) {
+      builder.should_receive(:request_line) {
         inner = Fiber.current
       }
       

data/spec/unit/server_spec.rb

@@ -159,7 +159,8 @@ describe Hatetepe::Server do
       server.requests.unshift previous
       app.stub(:call) {|e| response }
       request.stub :succeed
-      server.builder.stub :response
+      server.builder.stub :response_line
+      server.builder.stub :headers
     }
     
     it "deletes itself from env[] to prevent multiple calls" do
@@ -178,10 +179,12 @@ describe Hatetepe::Server do
     end
     
     it "initiates the response" do
-      server.builder.should_receive(:response) {|res|
-        res[0].should equal(response[0])
-        res[1]["Key"].should equal(response[1]["Key"])
-        res[1]["Server"].should == "hatetepe/#{Hatetepe::VERSION}"
+      server.builder.should_receive(:response_line) {|code|
+        code.should equal(response[0])
+      }
+      server.builder.should_receive(:headers) {|headers|
+        headers["Key"].should equal(response[1]["Key"])
+        headers["Server"].should == "hatetepe/#{Hatetepe::VERSION}"
       }
       previous.succeed
       server.process
@@ -191,7 +194,7 @@ describe Hatetepe::Server do
   context "env[stream.send].call(chunk)" do
     it "passes data to the builder" do
       app.stub(:call) {|e|
-        e["stream.send"].should == server.builder.method(:body)
+        e["stream.send"].should == server.builder.method(:body_chunk)
         [-1]
       }
       server.process

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hatetepe
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-02 00:00:00.000000000Z
+date: 2011-10-24 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
-  requirement: &75172870 !ruby/object:Gem::Requirement
+  requirement: &77539070 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.5.3
   type: :runtime
   prerelease: false
-  version_requirements: *75172870
+  version_requirements: *77539070
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &75172660 !ruby/object:Gem::Requirement
+  requirement: &77524530 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *75172660
+  version_requirements: *77524530
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &75172390 !ruby/object:Gem::Requirement
+  requirement: &77524030 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *75172390
+  version_requirements: *77524030
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &75172180 !ruby/object:Gem::Requirement
+  requirement: &77523660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *75172180
+  version_requirements: *77523660
 - !ruby/object:Gem::Dependency
   name: async-rack
-  requirement: &75171950 !ruby/object:Gem::Requirement
+  requirement: &77523290 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *75171950
+  version_requirements: *77523290
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &75171740 !ruby/object:Gem::Requirement
+  requirement: &77522880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *75171740
+  version_requirements: *77522880
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &75171530 !ruby/object:Gem::Requirement
+  requirement: &77521160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *75171530
+  version_requirements: *77521160
 - !ruby/object:Gem::Dependency
   name: fakefs
-  requirement: &75171320 !ruby/object:Gem::Requirement
+  requirement: &77520680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *75171320
+  version_requirements: *77520680
 - !ruby/object:Gem::Dependency
   name: em-http-request
-  requirement: &75171070 !ruby/object:Gem::Requirement
+  requirement: &77519340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -109,7 +109,7 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *75171070
+  version_requirements: *77519340
 description: 
 email:
 - lars.gierth@gmail.com
@@ -148,6 +148,7 @@ files:
 - spec/spec_helper.rb
 - spec/unit/app_spec.rb
 - spec/unit/body_spec.rb
+- spec/unit/builder_spec.rb
 - spec/unit/client_spec.rb
 - spec/unit/events_spec.rb
 - spec/unit/parser_spec.rb
@@ -178,3 +179,4 @@ signing_key:
 specification_version: 3
 summary: The HTTP toolkit
 test_files: []
+has_rdoc: