http_parser 0.1.0 → 0.1.3

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.3

data/lib/http/native_parser.rb

@@ -63,16 +63,16 @@ module Http
     # Regex used to match a header line. Lines suspected of
     # being headers are also checked against the HeaderContinueMatch
     # to deal with multiline headers
-    HeaderLineMatch = %r{^([a-zA-Z-]+):[ \t]*([[:print:]]+)\r?\n}
-    HeaderContinueMatch = %r{^[ \t]+([[:print:]]+)\r?\n}
+    HeaderLineMatch = %r{^([a-zA-Z-]+):[ \t]*([[:print:]]+?)\r?\n}
+    HeaderContinueMatch = %r{^[ \t]+([[:print:]]+?)\r?\n}
     EmptyLineMatch = %r{^\r?\n}
     
     # Regex used to match a size specification for a chunked segment
-    ChunkSizeLineMatch = %r{^[0-9]+\r?\n}
+    ChunkSizeLineMatch = %r{^[0-9a-fA-F]+\r?\n}
     
     # Used as a fallback in error detection for a malformed request line or header.
     AnyLineMatch = %r{^.+?\r?\n}
-    
+        
     def initialize(options = DefaultOptions)
       @method = nil
       @path = nil
@@ -163,7 +163,7 @@ module Http
           if (can_have_body?)
             if (@body_length >= @options[:min_tempfile_size])
               @body = @options[:tempfile_class].new("http_parser")
-              @body.unlink # unlink immediately so we don't rely on the caller to do it.
+              File.unlink(@body.to_path) rescue nil # ruby 1.9.1 does Tempfile.unlink wrong, so we do it ourselves.
             else
               @body = StringIO.new
             end
@@ -213,7 +213,7 @@ module Http
           if (@body.length >= @options[:min_tempfile_size] && @body.kind_of?(StringIO))
             @body_str = @body.string
             @body = @options[:tempfile_class].new("http_parser")
-            @body.unlink # unlink immediately so we don't rely on the caller to do it.
+            File.unlink(@body.to_path) rescue nil # ruby 1.9.1 does Tempfile.unlink wrong, so we do it ourselves.
             @body << @body_str
           end
         else
@@ -227,7 +227,7 @@ module Http
           end
         end
       elsif (scanner.scan(ChunkSizeLineMatch))
-        @chunk_remain = scanner[0].to_i
+        @chunk_remain = scanner[0].to_i(16)
         if (@chunk_remain < 1)
           @state = :body_chunked_tail
         end
@@ -286,6 +286,33 @@ module Http
     end
     private :normalize_header
     
+    # Given a basic rack environment, will properly fill it in
+    # with the information gleaned from the parsed request. Note that
+    # this only fills the subset that can be determined by the parser
+    # library. Namely, the only rack. variable set is rack.input. You should also
+    # have defaults in place for SERVER_NAME and SERVER_PORT, as they
+    # are required.
+    def fill_rack_env(env = {})
+      env["rack.input"] = @body || StringIO.new
+      env["REQUEST_METHOD"] = @method
+      env["SCRIPT_NAME"] = ""
+      env["REQUEST_URI"] = @path
+      env["PATH_INFO"], query = @path.split("?", 2)
+      env["QUERY_STRING"] = query || ""
+      if (@headers["HOST"] && !env["SERVER_NAME"])
+        env["SERVER_NAME"], port = @headers["HOST"].split(":", 2)
+        env["SERVER_PORT"] = port if port
+      end
+      @headers.each do |key, val|
+        if (key == 'CONTENT_LENGTH' || key == 'CONTENT_TYPE')
+          env[key] = val
+        else
+          env["HTTP_#{key}"] = val
+        end
+      end
+      return env
+    end
+    
     # Returns true if the request is completely done.
     def done?
       @state == :done

data/spec/http_parser_spec.rb

@@ -63,6 +63,71 @@ test_parsers.each do |parser|
     	p.body.read.should == "stuff"
   	end
   	
+  	describe "fill_rack_env" do
+  	  it "should fill in a simple request correctly" do
+  	    p = parser.new
+  	    p.parse("GET /blah HTTP/1.1\r\nHost: blorp\r\n\r\n")
+  	    p.done?.should be_true
+  	    env = p.fill_rack_env
+  	    env["rack.input"].should be_kind_of(StringIO)
+  	    env["REQUEST_METHOD"].should == "GET"
+  	    env["SCRIPT_NAME"].should == ""
+  	    env["REQUEST_URI"].should == "/blah"
+  	    env["PATH_INFO"].should == "/blah"
+  	    env["QUERY_STRING"].should == ""
+  	    env["SERVER_NAME"].should == "blorp"
+  	    env["SERVER_PORT"].should be_nil
+  	    env["HTTP_HOST"].should == "blorp"
+	    end
+	    
+      it "should give Content-Type and Content-Length as CONTENT_* rather than HTTP_CONTENT_*" do
+        p = parser.new
+        p.parse("POST /blah HTTP/1.1\r\nContent-Type: text/text\r\nContent-Length: 4\r\n\r\ntest")
+        p.done?.should be_true
+        env = p.fill_rack_env
+        env["CONTENT_LENGTH"].should == "4"
+        env["CONTENT_TYPE"].should == "text/text"
+        env["HTTP_CONTENT_LENGTH"].should be_nil
+        env["HTTP_CONTENT_TYPE"].should be_nil
+      end
+
+	    it "should split the query string from the request uri" do
+	      p = parser.new
+	      p.parse("GET /blah?blorp HTTP/1.1\r\nHost: blorp\r\n\r\n")
+	      p.done?.should be_true
+	      env = p.fill_rack_env
+	      env["REQUEST_URI"].should == "/blah?blorp"
+	      env["PATH_INFO"].should == "/blah"
+	      env["QUERY_STRING"].should == "blorp"
+      end
+      it "should split the query string from the path only once" do
+        p = parser.new
+        p.parse("GET /blah?blorp?bloop HTTP/1.1\r\nHost:blorp\r\n\r\n")
+        p.done?.should be_true
+        env = p.fill_rack_env
+        env["REQUEST_URI"].should == "/blah?blorp?bloop"
+        env["PATH_INFO"].should == "/blah"
+        env["QUERY_STRING"].should == "blorp?bloop"
+      end
+      
+      it "should split the host from the port when doing SERVER_NAME/SERVER_PORT" do
+        p = parser.new
+        p.parse("GET /blah HTTP/1.1\r\nHost: blorp.com:1234\r\n\r\n")
+        p.done?.should be_true
+        env = p.fill_rack_env
+        env["SERVER_NAME"].should == "blorp.com"
+        env["SERVER_PORT"].should == "1234"
+      end
+      
+      it "should not fill in SERVER_NAME and SERVER_PORT if SERVER_NAME is already set" do
+        p = parser.new
+        p.parse("GET /blah HTTP/1.1\r\nHost: blah.com:324\r\n\r\n")
+        p.done?.should be_true
+        env = p.fill_rack_env({"SERVER_NAME"=>"woop.com"})
+        env["SERVER_NAME"].should == "woop.com"
+      end
+    end
+
   	it "should be able to parse two simple requests from the same string" do
   	  req = <<REQ
 GET /first HTTP/1.1\r
@@ -170,7 +235,7 @@ POST / HTTP/1.1\r
 Host: blah.com\r
 Transfer-Encoding: chunked\r
 \r
-10\r
+A\r
 stuffstuff\r
 0\r
 \r
@@ -214,7 +279,7 @@ Transfer-Encoding: chunked\r
 \r
 REQ
       1.upto(200) do
-        p.parse("10\r\n")
+        p.parse("A\r\n")
         p.parse("x"*10 + "\r\n")
       end
       p.parse("0\r\n\r\n")
@@ -405,7 +470,7 @@ POST / HTTP/1.1\r
 Content-Length: 5
 Transfer-Encoding: chunked
 
-10
+A
 stuffstuff
 0
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Graham Batty
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-07 00:00:00 -07:00
+date: 2010-03-17 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency