http_tools 0.2.0 → 0.3.0

data/README.rdoc

@@ -22,7 +22,7 @@ possible.
 
   parser = HTTPTools::Parser.new
   parser.on(:header) do |header|
-    puts parser.status_code + " " + parser.method
+    puts parser.status_code + " " + parser.request_method
     puts parser.header.inspect
   end
   parser.on(:stream) {|chunk| print chunk}

data/bench/parser/request_bench.rb

@@ -21,7 +21,8 @@ Benchmark.bm(41) do |x|
   
   x.report("HTTPTools::Parser (reset, with callbacks)") do
     parser = HTTPTools::Parser.new
-    parser.on(:headers) {}
+    parser.on(:header) {}
+    parser.on(:finish) {}
     10_000.times do
        parser << request
        parser.reset

data/example/http_server.rb

@@ -6,7 +6,6 @@ require 'http_tools'
 module HTTP
   class Server
     RACK_INPUT = "rack.input".freeze
-    NO_BODY = {"GET" => true, "HEAD" => true}
     CONNECTION = "Connection".freeze
     KEEP_ALIVE = "Keep-Alive".freeze
     CLOSE = "close".freeze
@@ -16,8 +15,7 @@ module HTTP
       host = options[:host] || options[:Host] || "0.0.0.0"
       port = (options[:port] || options[:Port] || 9292).to_s
       @app = app
-      @instance_env = {"SERVER_NAME" => host, "SERVER_PORT" => port,
-        "rack.multithread" => true}
+      @instance_env = {"rack.multithread" => true}
       @server = TCPServer.new(host, port)
       @server.listen(1024)
     end
@@ -44,12 +42,11 @@ module HTTP
       env, input = nil
       
       parser.on(:header) do
-        parser.force_no_body = NO_BODY[parser.request_method]
         input = StringIO.new
         env = parser.env.merge!(RACK_INPUT => input).merge!(@instance_env)
       end
       parser.on(:stream) {|chunk| input << chunk}
-      parser.on(:finish) do |remainder|
+      parser.on(:finish) do
         input.rewind
         status, header, body = @app.call(env)
         keep_alive = keep_alive?(parser.version, parser.header[CONNECTION])
@@ -57,11 +54,8 @@ module HTTP
         socket << HTTPTools::Builder.response(status, header)
         body.each {|chunk| socket << chunk}
         body.close if body.respond_to?(:close)
-        if keep_alive
-          parser.reset
-          parser << remainder.lstrip if remainder
-          throw :reset
-        end
+        remainder = parser.rest.lstrip
+        parser.reset << remainder and throw :reset if keep_alive
       end
       
       begin
@@ -80,3 +74,7 @@ module HTTP
     
   end
 end
+
+HTTP::Server.run(proc do |env|
+  [200, {"Content-Length" => "5"}, "Hello"]
+end)

data/example/simple_http_client.rb

@@ -0,0 +1,67 @@
+require 'socket'
+require 'rubygems'
+require 'http_tools'
+
+# Usage:
+#   uri = URI.parse("http://example.com/")
+#   client = HTTP::Client.new(uri.host, uri.port)
+#   response = client.get(uri.path)
+#   
+#   puts "#{response.status} #{response.message}"
+#   puts response.headers.inspect
+#   puts response.body
+#   
+module HTTP
+  class Client
+    Response = Struct.new(:status, :message, :headers, :body)
+    
+    def initialize(host, port=80)
+      @host, @port = host, port
+    end
+    
+    def head(path, headers={})
+      request(:head, path, nil, headers, false)
+    end
+    
+    def get(path, headers={})
+      request(:get, path, nil, headers)
+    end
+    
+    def post(path, body=nil, headers={})
+      request(:post, path, body, headers)
+    end
+    
+    def put(path, body=nil, headers={})
+      request(:put, path, body, headers)
+    end
+    
+    def delete(path, headers={})
+      request(:delete, path, nil, headers)
+    end
+    
+    private
+    def request(method, path, body=nil, headers={}, response_has_body=true)
+      parser = HTTPTools::Parser.new
+      parser.force_no_body = !response_has_body
+      response = nil
+      
+      parser.on(:header) do
+        code, message, head = parser.status_code, parser.message, parser.header
+        response = Response.new(code, message, head, "")
+      end
+      parser.on(:stream) {|chunk| response.body << chunk}
+      
+      socket = TCPSocket.new(@host, @port)
+      socket << HTTPTools::Builder.request(method, @host, path, headers)
+      socket << body if body
+      begin
+        parser << socket.sysread(1024 * 16)
+      rescue EOFError
+        break parser.finish
+      end until parser.finished?
+      socket.close
+      
+      response
+    end
+  end
+end

data/lib/http_tools.rb

@@ -92,15 +92,11 @@ module HTTPTools
   
   METHODS = %W{GET POST HEAD PUT DELETE OPTIONS TRACE CONNECT}.freeze
   
-  NO_BODY = Hash.new {|hash, key| hash[key] = false}
-  NO_BODY.merge!(204 => true, 304 => true, nil => false)
+  NO_BODY = {204 => true, 304 => true} # presence of key tested, not value
   100.upto(199) {|status_code| NO_BODY[status_code] = true}
+  NO_BODY.freeze
   
-  ARRAY_VALUE_HEADERS = Hash.new {|hash, key| hash[key] = false}
-  ARRAY_VALUE_HEADERS.merge!("Set-Cookie" => true)
-  
-  CRLF = "\r\n".freeze
-  SPACE = " ".freeze
+  ARRAY_VALUE_HEADERS = {"Set-Cookie" => true} # presence of key tested, not val
   
   require_base = File.dirname(__FILE__) + '/http_tools/'
   autoload :Encoding, require_base + 'encoding'

data/lib/http_tools/encoding.rb

@@ -11,6 +11,7 @@ module HTTPTools
     HEX_BIG_ENDIAN_REPEATING = "H*".freeze
     PERCENT = "%".freeze
     PLUS = "+".freeze
+    SPACE = " ".freeze
     AMPERSAND = "&".freeze
     EQUALS = "=".freeze
     CHUNK_FORMAT = "%x\r\n%s\r\n".freeze
@@ -121,11 +122,11 @@ module HTTPTools
     #   Encoding.transfer_encoding_chunked_decode(encoded_string)\
     # => ["foobar", ""]
     # 
-    # If nothing can be decoded the first element in the array will be an empty
-    # string and the second the remainder
+    # If nothing can be decoded the first element in the array will be nil and
+    # the second the remainder
     #   encoded_string = "3\r\nfo"
     #   Encoding.transfer_encoding_chunked_decode(encoded_string)\
-    # => ["", "3\r\nfo"]
+    # => [nil, "3\r\nfo"]
     # 
     # Example use:
     #   include Encoding

data/lib/http_tools/parser.rb

@@ -12,7 +12,7 @@ module HTTPTools
   # Example:
   #   parser = HTTPTools::Parser.new
   #   parser.on(:header) do |header|
-  #     puts parser.status_code + " " + parser.method
+  #     puts parser.status_code + " " + parser.request_method
   #     puts parser.header.inspect
   #   end
   #   parser.on(:stream) {|chunk| print chunk}
@@ -37,20 +37,17 @@ module HTTPTools
     CONNECTION = "Connection".freeze
     CLOSE = "close".freeze
     CHUNKED = "chunked".freeze
-    EVENTS = %W{header stream trailer finish error}.map do |event|
-      event.freeze
-    end.freeze
+    EVENTS = %W{header stream trailer finish error}.map {|e| e.freeze}.freeze
     
     REQUEST_METHOD = "REQUEST_METHOD".freeze
     PATH_INFO = "PATH_INFO".freeze
     QUERY_STRING = "QUERY_STRING".freeze
-    REQUEST_URI = "REQUEST_URI".freeze
-    FRAGMENT = "FRAGMENT".freeze
+    SERVER_NAME = "SERVER_NAME".freeze
+    SERVER_PORT = "SERVER_PORT".freeze
+    HTTP_HOST = "HTTP_HOST".freeze
     
     PROTOTYPE_ENV = {
       "SCRIPT_NAME" => "".freeze,
-      PATH_INFO => "/".freeze,
-      QUERY_STRING => "".freeze,
       "rack.version" => [1, 1].freeze,
       "rack.url_scheme" => "http".freeze,
       "rack.errors" => STDERR,
@@ -61,10 +58,11 @@ module HTTPTools
     HTTP_ = "HTTP_".freeze
     LOWERCASE = "a-z-".freeze
     UPPERCASE = "A-Z_".freeze
+    NO_HTTP_ = {"CONTENT_LENGTH" => true, "CONTENT_TYPE" => true}
     
     attr_reader :state # :nodoc:
     attr_reader :request_method, :path_info, :query_string, :request_uri,
-      :fragment, :version, :status_code, :message, :header, :trailer
+      :version, :status_code, :message, :header, :trailer
     
     # Force parser to expect and parse a trailer when Trailer header missing.
     attr_accessor :force_trailer
@@ -82,7 +80,6 @@ module HTTPTools
     def initialize
       @state = :start
       @buffer = StringScanner.new("")
-      @buffer_backup_reference = @buffer
       @header = {}
       @trailer = {}
     end
@@ -108,20 +105,23 @@ module HTTPTools
     # Returns a Rack compatible environment hash. Will return nil if called
     # before headers are complete.
     # 
-    # The following are not supplied, and must be added to make the environment
-    # hash fully Rack compliant: SERVER_NAME, SERVER_PORT, rack.input
+    # "rack.input" is not supplied and must be added to make the environment
+    # hash fully Rack compliant.
     # 
     def env
       return unless @header_complete
-      env = PROTOTYPE_ENV.merge(
-        REQUEST_METHOD => @request_method,
-        REQUEST_URI => @request_uri)
-      if @path_info
-        env[PATH_INFO] = @path_info
-        env[QUERY_STRING] = @query_string
+      env = PROTOTYPE_ENV.dup
+      env[REQUEST_METHOD] = @request_method
+      env[PATH_INFO] = @path_info
+      env[QUERY_STRING] = @query_string
+      @header.each do |key, value|
+        upper_key = key.tr(LOWERCASE, UPPERCASE)
+        upper_key = HTTP_ + upper_key unless NO_HTTP_.key?(upper_key)
+        env[upper_key] = value
       end
-      env[FRAGMENT] = @fragment if @fragment
-      @header.each {|k, val| env[HTTP_ + k.tr(LOWERCASE, UPPERCASE)] = val}
+      host, port = env[HTTP_HOST].split(COLON)
+      env[SERVER_NAME] = host
+      env[SERVER_PORT] = port || "80"
       @trailer.each {|k, val| env[HTTP_ + k.tr(LOWERCASE, UPPERCASE)] = val}
       env
     end
@@ -177,6 +177,14 @@ module HTTPTools
       @state == :end_of_message
     end
     
+    # :call-seq: parser.rest -> string
+    # 
+    # Returns unconsumed data in the parser's buffer.
+    # 
+    def rest
+      @buffer.rest
+    end
+    
     # :call-seq: parser.reset -> parser
     # 
     # Reset the parser so it can be used to process a new request.
@@ -184,14 +192,12 @@ module HTTPTools
     # 
     def reset
       @state = :start
-      @buffer = @buffer_backup_reference
       @buffer.string.replace("")
       @buffer.reset
       @request_method = nil
       @path_info = nil
       @query_string = nil
       @request_uri = nil
-      @fragment = nil
       @version = nil
       @status_code = nil
       @header = {}
@@ -201,9 +207,9 @@ module HTTPTools
       self
     end
     
-    # :call-seq: parser.add_listener(event) {|arg1 [, arg2]| block} -> parser
+    # :call-seq: parser.add_listener(event) {|arg| block} -> parser
     # parser.add_listener(event, proc) -> parser
-    # parser.on(event) {|arg1 [, arg2]| block} -> parser
+    # parser.on(event) {|arg| block} -> parser
     # parser.on(event, proc) -> parser
     # 
     # Available events are :header, :stream, :trailer, :finish, and :error.
@@ -219,9 +225,9 @@ module HTTPTools
     # 
     # [trailer]    Called on the completion of the trailer, if present
     # 
-    # [finish]     Supplied with one argument, any data left in the parser's
-    #              buffer after the end of the HTTP message (likely nil, but
-    #              possibly the start of the next message)
+    # [finish]     Called on completion of the entire message. Any unconsumed
+    #              data (such as the start of the next message with keepalive)
+    #              can be retrieved with #rest
     # 
     # [error]      Supplied with one argument, an error encountered while
     #              parsing as a HTTPTools::ParseError. If a listener isn't
@@ -241,7 +247,7 @@ module HTTPTools
         @request_method.chop!
         @request_method.upcase!
         uri
-      elsif @buffer.skip(/HTTP\//i)
+      elsif @buffer.check(/HTTP\//i)
         response_http_version
       elsif @buffer.check(/[a-z]*\Z/i)
         :start
@@ -253,16 +259,13 @@ module HTTPTools
     end
     
     def uri
-      @request_uri= @buffer.scan(/[a-z0-9;\/?:@&=+$,%_.!~*')(#-]*(?=( |\r\n))/i)
+      @request_uri = @buffer.scan(/[a-z0-9;\/?:@&=+$,%_.!~*')(-]*(?=( |\r\n))/i)
       if @request_uri
-        @fragment = @request_uri.slice!(/#[a-z0-9;\/?:@&=+$,%_.!~*')(-]+\Z/i)
-        @fragment.slice!(0) if @fragment
-        if @request_uri =~ /^\//i
-          @path_info = @request_uri.dup
-          @query_string = @path_info.slice!(/\?[a-z0-9;\/?:@&=+$,%_.!~*')(-]*/i)
-          @query_string ? @query_string.slice!(0) : @query_string = ""
-        end
-        space_before_http
+        @path_info = @request_uri.dup
+        @path_info.slice!(/^([a-z0-9+.-]*:\/\/)?[^\/]+/i)
+        @query_string = @path_info.slice!(/\?[a-z0-9;\/?:@&=+$,%_.!~*')(-]*/i)
+        @query_string ? @query_string.slice!(0) : @query_string = ""
+        request_http_version
       elsif @buffer.check(/[a-z0-9;\/?:@&=+$,%_.!~*')(#-]+\Z/i)
         :uri
       else
@@ -270,30 +273,16 @@ module HTTPTools
       end
     end
     
-    def space_before_http
-      if @buffer.skip(/ /i)
-        http
-      elsif @buffer.skip(/\r\n/i)
-        key_or_newline
-      end
-    end
-    
-    def http
-      if @buffer.skip(/HTTP\//i)
-        request_http_version
-      elsif @buffer.eos? || @buffer.check(/H(T(T(P\/?)?)?)?\Z/i)
-        :http
-      else
-        raise ParseError.new("Protocol not recognised")
-      end
-    end
-    
     def request_http_version
-      @version = @buffer.scan(/[0-9]+\.[0-9x]+\r\n/i)
+      @version = @buffer.scan(/ HTTP\/[0-9]+\.[0-9x]+\r\n/i)
       if @version
-        @version.chop!
+        @version.strip!
+        @version.upcase!
         key_or_newline
-      elsif @buffer.eos? || @buffer.check(/\d+(\.(\d+\r?)?)?\Z/i)
+      elsif @buffer.skip(/\r\n/i)
+        key_or_newline
+      elsif @buffer.eos? ||
+        @buffer.check(/ (H(T(T(P(\/(\d+(\.(\d+\r?)?)?)?)?)?)?)?)?\Z/i)
         :request_http_version
       else
         raise ParseError.new("Invalid version specifier")
@@ -301,11 +290,13 @@ module HTTPTools
     end
     
     def response_http_version
-      @version = @buffer.scan(/[0-9]+\.[0-9x]+ /i)
+      @version = @buffer.scan(/HTTP\/[0-9]+\.[0-9x]+ /i)
       if @version
-        version.chop!
+        @version.chop!
+        @version.upcase!
         status
-      elsif @buffer.eos? || @buffer.check(/\d+(\.(\d+)?)?\Z/i)
+      elsif @buffer.eos? ||
+        @buffer.check(/H(T(T(P(\/(\d+(\.(\d+\r?)?)?)?)?)?)?)?\Z/i)
         :response_http_version
       else
         raise ParseError.new("Invalid version specifier")
@@ -365,16 +356,16 @@ module HTTPTools
     end
     
     def value
-      value = @buffer.scan(/[^\x00\n\x7f]*\r?\n/i)
+      value = @buffer.scan(/[^\x00\n\x7f]*\n/i)
       if value
         value.chop!
-        if ARRAY_VALUE_HEADERS[@last_key]
+        if ARRAY_VALUE_HEADERS.key?(@last_key)
           @header.fetch(@last_key) {@header[@last_key] = []}.push(value)
         else
           @header[@last_key] = value
         end
         key_or_newline
-      elsif @buffer.eos? || @buffer.check(/[^\x00\n\x7f]+\r?\Z/i)
+      elsif @buffer.eos? || @buffer.check(/[^\x00\n\x7f]+\Z/i)
         :value
       else
         raise ParseError.new("Illegal character in field body")
@@ -382,7 +373,9 @@ module HTTPTools
     end
     
     def body
-      if @force_no_body || NO_BODY[@status_code]
+      if @request_method &&
+        !(@header.key?(CONTENT_LENGTH) || @header.key?(TRANSFER_ENCODING)) ||
+        NO_BODY.key?(@status_code) || @force_no_body
         end_of_message
       else
         length = @header[CONTENT_LENGTH]
@@ -458,12 +451,12 @@ module HTTPTools
     end
     
     def trailer_value
-      value = @buffer.scan(/[^\000\n\177]+\r?\n/i)
+      value = @buffer.scan(/[^\000\n\177]+\n/i)
       if value
         value.chop!
         @trailer[@last_key] = value
         trailer_key_or_newline
-      elsif @buffer.eos? || @buffer.check(/[^\x00\n\x7f]+\r?\Z/i)
+      elsif @buffer.eos? || @buffer.check(/[^\x00\n\x7f]+\Z/i)
         :trailer_value
       else
         raise ParseError.new("Illegal character in field body")
@@ -472,10 +465,7 @@ module HTTPTools
     
     def end_of_message
       raise EndOfMessageError.new("Message ended") if @state == :end_of_message
-      remainder = @buffer.respond_to?(:rest) ? @buffer.rest : @buffer
-      if @finish_callback
-        @finish_callback.call((remainder if remainder.length > 0))
-      end
+      @finish_callback.call if @finish_callback
       :end_of_message
     end
     

data/test/parser/request_test.rb

@@ -66,7 +66,7 @@ class RequestTest < Test::Unit::TestCase
       path, query = parser.path_info, parser.query_string
     end
     
-    parser << "GET /foo%20bar/baz.html?key=value#qux HTTP/1.1\r\n\r\n"
+    parser << "GET /foo%20bar/baz.html?key=value HTTP/1.1\r\n\r\n"
     
     assert_equal("/foo%20bar/baz.html", path)
     assert_equal("key=value", query)
@@ -82,28 +82,19 @@ class RequestTest < Test::Unit::TestCase
   
   def test_uri
     parser = HTTPTools::Parser.new
-    result = nil
+    uri, path, query = nil
     
     parser.add_listener(:header) do
-      result = parser.request_uri
-    end
-    
-    parser << "GET http://example.com/foo HTTP/1.1\r\n\r\n"
-    
-    assert_equal("http://example.com/foo", result)
-  end
-  
-  def test_path_callback_not_called_with_uri
-    parser = HTTPTools::Parser.new
-    result = nil
-    
-    parser.add_listener(:header) do
-      result = parser.path_info
+      uri = parser.request_uri
+      path = parser.path_info
+      query = parser.query_string
     end
     
-    parser << "GET http://example.com/foo HTTP/1.1\r\n\r\n"
+    parser << "GET http://example.com/foo?bar=baz HTTP/1.1\r\n\r\n"
     
-    assert_nil(result)
+    assert_equal("http://example.com/foo?bar=baz", uri)
+    assert_equal("/foo", path)
+    assert_equal("bar=baz", query)
   end
   
   def test_uri_callback_called_with_path
@@ -127,34 +118,18 @@ class RequestTest < Test::Unit::TestCase
   
   def test_fragment_with_path
     parser = HTTPTools::Parser.new
-    path = nil
-    fragment = nil
     
-    parser.add_listener(:header) do
-      path = parser.path_info
-      fragment = parser.fragment
+    assert_raise(HTTPTools::ParseError) do
+      parser << "GET /foo#bar HTTP/1.1\r\n\r\n"
     end
-    
-    parser << "GET /foo#bar HTTP/1.1\r\n\r\n"
-    
-    assert_equal("/foo", path)
-    assert_equal("bar", fragment)
   end
   
   def test_fragment_with_uri
     parser = HTTPTools::Parser.new
-    uri = nil
-    fragment = nil
     
-    parser.add_listener(:header) do
-      uri = parser.request_uri
-      fragment = parser.fragment
+    assert_raise(HTTPTools::ParseError) do
+      parser << "GET http://example.com/foo#bar HTTP/1.1\r\n\r\n"
     end
-    
-    parser << "GET http://example.com/foo#bar HTTP/1.1\r\n\r\n"
-    
-    assert_equal("http://example.com/foo", uri)
-    assert_equal("bar", fragment)
   end
   
   def test_with_header
@@ -322,7 +297,7 @@ class RequestTest < Test::Unit::TestCase
     
     parser << "GET / HTTP/1.1\r\n\r\n"
     
-    assert_equal("1.1", version)
+    assert_equal("HTTP/1.1", version)
   end
   
   def test_protocol_without_version
@@ -339,7 +314,32 @@ class RequestTest < Test::Unit::TestCase
     
     parser << "GET / HTTP/1.x\r\n\r\n"
     
-    assert_equal("1.x", version)
+    assert_equal("HTTP/1.X", version)
+  end
+  
+  def test_finish_without_body_trigger
+    parser = HTTPTools::Parser.new
+    
+    parser << "GET / HTTP/1.1\r\n\r\n"
+    
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_finish_with_content_length_body_trigger
+    parser = HTTPTools::Parser.new
+    
+    parser << "GET / HTTP/1.1\r\n"
+    parser << "Content-Length: 5\r\n\r\n"
+    
+    assert(!parser.finished?, "parser should not be finished")
+  end
+  
+  def test_finish_with_transfer_encoding_body_trigger
+    parser = HTTPTools::Parser.new
+    parser << "GET / HTTP/1.1\r\n"
+    parser << "Transfer-Encoding: chunked\r\n\r\n"
+    
+    assert(!parser.finished?, "parser should not be finished")
   end
   
   def test_reset
@@ -416,7 +416,7 @@ class RequestTest < Test::Unit::TestCase
     
     parser << "GET / http/1.1\r\n\r\n"
     
-    assert_equal("1.1", version)
+    assert_equal("HTTP/1.1", version)
   end
   
   def test_invalid_version
@@ -472,8 +472,8 @@ class RequestTest < Test::Unit::TestCase
     assert_equal("", env["SCRIPT_NAME"])
     assert_equal("/test", env["PATH_INFO"])
     assert_equal("q=foo", env["QUERY_STRING"])
-    assert_equal(nil, env["SERVER_NAME"])
-    assert_equal(nil, env["SERVER_PORT"])
+    assert_equal("www.example.com", env["SERVER_NAME"])
+    assert_equal("80", env["SERVER_PORT"])
     assert_equal("www.example.com", env["HTTP_HOST"])
     assert_equal("text/html", env["HTTP_ACCEPT"])
     
@@ -505,8 +505,8 @@ class RequestTest < Test::Unit::TestCase
     assert_equal("", env["SCRIPT_NAME"])
     assert_equal("/submit", env["PATH_INFO"])
     assert_equal("", env["QUERY_STRING"])
-    assert_equal(nil, env["SERVER_NAME"])
-    assert_equal(nil, env["SERVER_PORT"])
+    assert_equal("www.example.com", env["SERVER_NAME"])
+    assert_equal("80", env["SERVER_PORT"])
     assert_equal("www.example.com", env["HTTP_HOST"])
     assert_equal("chunked", env["HTTP_TRANSFER_ENCODING"])
     assert_equal("X-Checksum", env["HTTP_TRAILER"])
@@ -521,4 +521,39 @@ class RequestTest < Test::Unit::TestCase
     assert_equal(false, env["rack.run_once"])
   end
   
+  def test_env_server_port
+    parser = HTTPTools::Parser.new
+    env = nil
+    parser.on(:header) {env = parser.env}
+    
+    parser << "GET / HTTP/1.1\r\n"
+    parser << "Host: localhost:9292\r\n"
+    parser << "\r\n"
+    
+    assert_equal("localhost", env["SERVER_NAME"])
+    assert_equal("9292", env["SERVER_PORT"])
+    assert_equal("localhost:9292", env["HTTP_HOST"])
+  end
+  
+  def test_env_post
+    parser = HTTPTools::Parser.new
+    env = nil
+    parser.on(:header) {env = parser.env}
+    
+    parser << "POST / HTTP/1.1\r\n"
+    parser << "Host: www.example.com\r\n"
+    parser << "Content-Length: 7\r\n"
+    parser << "Content-Type: application/x-www-form-urlencoded\r\n"
+    parser << "\r\n"
+    parser << "foo=bar"
+    
+    assert_equal("POST", env["REQUEST_METHOD"])
+    assert(!env.key?("HTTP_CONTENT_LENGTH"), "env must not contain HTTP_CONTENT_LENGTH")
+    assert(!env.key?("HTTP_CONTENT_TYPE"), "env must not contain HTTP_CONTENT_TYPE")
+    assert_equal("7", env["CONTENT_LENGTH"])
+    assert_equal("application/x-www-form-urlencoded", env["CONTENT_TYPE"])
+    
+    assert_equal(nil, env["rack.input"])
+  end
+  
 end

data/test/parser/response_test.rb

@@ -12,7 +12,7 @@ class ResponseTest < Test::Unit::TestCase
     
     parser << "HTTP/1.1 200 OK\r\n\r\n"
     
-    assert_equal("1.1", version)
+    assert_equal("HTTP/1.1", version)
   end
   
   def test_one_dot_x_version
@@ -23,7 +23,7 @@ class ResponseTest < Test::Unit::TestCase
     
     parser << "HTTP/1.x 200 OK\r\n\r\n"
     
-    assert_equal("1.x", version)
+    assert_equal("HTTP/1.X", version)
   end
   
   def test_ok
@@ -83,7 +83,7 @@ class ResponseTest < Test::Unit::TestCase
     
     parser << "HTTP/1.0 200 (OK)\r\n\r\n"
     
-    assert_equal("1.0", version)
+    assert_equal("HTTP/1.0", version)
     assert_equal(200, code)
     assert_equal("(OK)", message)
     assert(!parser.finished?, "parser should not be finished")
@@ -715,7 +715,7 @@ class ResponseTest < Test::Unit::TestCase
       headers = parser.header
     end
     parser.add_listener(:stream) {|chunk| body << chunk}
-    parser.add_listener(:finish) {|r| remainder = r}
+    parser.add_listener(:finish) {remainder = parser.rest}
     
     parser << "HTTP/1.1 200 OK\r\nContent-Length: 20\r\n\r\n"
     parser << "<h1>Hello world</h1>HTTP/1.1 404 Not Found\r\n"
@@ -738,7 +738,7 @@ class ResponseTest < Test::Unit::TestCase
       headers = parser.header
     end
     parser.add_listener(:stream) {|chunk| body << chunk}
-    parser.add_listener(:finish) {|r| remainder = r}
+    parser.add_listener(:finish) {remainder = parser.rest}
     
     parser << "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
     parser << "14\r\n<h1>Hello world</h1>\r\n0\r\nHTTP/1.1 404 Not Found\r\n"
@@ -750,6 +750,29 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_finshed_without_rest
+    parser = HTTPTools::Parser.new
+    code, message, remainder = nil
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    parser.add_listener(:finish) {remainder = parser.rest}
+    
+    parser << "HTTP/1.1 200 OK\r\nContent-Length: 20\r\n\r\n"
+    parser << "<h1>Hello world</h1>"
+    
+    assert_equal(200, code)
+    assert_equal("OK", message)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert_equal("", remainder)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_trailer
     parser = HTTPTools::Parser.new
     trailer = nil

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_tools
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Matthew Sadler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-10 00:00:00 +01:00
+date: 2011-05-10 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -49,6 +49,7 @@ files:
 - profile/parser/response_profile.rb
 - example/http_client.rb
 - example/http_server.rb
+- example/simple_http_client.rb
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/matsadler/http_tools