http_parser.rb 0.5.3-java → 0.6.0.beta.2-java

data/.gitmodules

@@ -1,6 +1,6 @@
-[submodule "ext/ruby_http_parser/vendor/http-parser"]
+[submodule "http-parser"]
 	path = ext/ruby_http_parser/vendor/http-parser
 	url = git://github.com/joyent/http-parser.git
-[submodule "ext/ruby_http_parser/vendor/http-parser-java"]
+[submodule "http-parser-java"]
 	path = ext/ruby_http_parser/vendor/http-parser-java
-	url = git://github.com/a2800276/http-parser.java.git
+	url = git://github.com/tmm1/http-parser.java

data/Gemfile

@@ -1,2 +1,2 @@
-source :rubygems
+source 'https://rubygems.org'
 gemspec

data/Gemfile.lock

@@ -1,13 +1,20 @@
 PATH
   remote: .
   specs:
-    http_parser.rb (0.5.2)
+    http_parser.rb (0.6.0.beta.2)
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
+    benchmark_suite (0.8.0)
+    bouncy-castle-java (1.5.0147)
     diff-lcs (1.1.2)
-    json (1.5.1)
+    ffi (1.0.11)
+    ffi (1.0.11-java)
+    jruby-openssl (0.8.8)
+      bouncy-castle-java (>= 1.5.0147)
+    json (1.8.0)
+    json (1.8.0-java)
     rake (0.9.2)
     rake-compiler (0.7.9)
       rake
@@ -19,14 +26,16 @@ GEM
     rspec-expectations (2.4.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.4.0)
-    yajl-ruby (0.8.2)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
+  benchmark_suite
+  ffi
   http_parser.rb!
+  jruby-openssl
   json (>= 1.4.6)
   rake-compiler (>= 0.7.9)
   rspec (>= 2.0.1)
-  yajl-ruby (>= 0.8.1)

data/README.md

@@ -16,70 +16,75 @@ This gem aims to work on all major Ruby platforms, including:
 
 ## Usage
 
-    require "http/parser"
+```ruby
+require "http/parser"
 
-    parser = Http::Parser.new
+parser = Http::Parser.new
 
-    parser.on_headers_complete = proc do
-      p parser.http_version
+parser.on_headers_complete = proc do
+  p parser.http_version
 
-      p parser.http_method # for requests
-      p parser.request_url
+  p parser.http_method # for requests
+  p parser.request_url
 
-      p parser.status_code # for responses
+  p parser.status_code # for responses
 
-      p parser.headers
-    end
+  p parser.headers
+end
 
-    parser.on_body = proc do |chunk|
-      # One chunk of the body
-      p chunk
-    end
+parser.on_body = proc do |chunk|
+  # One chunk of the body
+  p chunk
+end
 
-    parser.on_message_complete = proc do |env|
-      # Headers and body is all parsed
-      puts "Done!"
-    end
+parser.on_message_complete = proc do |env|
+  # Headers and body is all parsed
+  puts "Done!"
+end
+```
 
-    # Feed raw data from the socket to the parser
-    parser << raw_data
+# Feed raw data from the socket to the parser
+`parser << raw_data`
 
 ## Advanced Usage
 
 ### Accept callbacks on an object
 
-    module MyHttpConnection
-      def connection_completed
-        @parser = Http::Parser.new(self)
-      end
+```ruby
+module MyHttpConnection
+  def connection_completed
+    @parser = Http::Parser.new(self)
+  end
 
-      def receive_data(data)
-        @parser << data
-      end
+  def receive_data(data)
+    @parser << data
+  end
 
-      def on_message_begin
-        @headers = nil
-        @body = ''
-      end
+  def on_message_begin
+    @headers = nil
+    @body = ''
+  end
 
-      def on_headers_complete
-        @headers = @parser.headers
-      end
+  def on_headers_complete(headers)
+    @headers = headers
+  end
 
-      def on_body(chunk)
-        @body << chunk
-      end
+  def on_body(chunk)
+    @body << chunk
+  end
 
-      def on_message_complete
-        p [@headers, @body]
-      end
-    end
+  def on_message_complete
+    p [@headers, @body]
+  end
+end
+```
 
 ### Stop parsing after headers
 
-    parser = Http::Parser.new
-    parser.on_headers_complete = proc{ :stop }
-
-    offset = parser << request_data
-    body = request_data[offset..-1]
+```ruby
+parser = Http::Parser.new
+parser.on_headers_complete = proc{ :stop }
 
+offset = parser << request_data
+body = request_data[offset..-1]
+```

data/bench/standalone.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require "rubygems"
+require "http/parser"
+require "benchmark/ips"
+
+request = <<-REQUEST
+GET / HTTP/1.1
+Host: www.example.com
+Connection: keep-alive
+User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.78 S
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Encoding: gzip,deflate,sdch
+Accept-Language: en-US,en;q=0.8
+Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
+
+REQUEST
+request.gsub!(/\n/m, "\r\n")
+
+Benchmark.ips do |ips|
+  ips.report("instance") { Http::Parser.new }
+  ips.report("parsing")  { Http::Parser.new << request }
+end

data/bench/thin.rb

@@ -3,6 +3,7 @@ require "rubygems"
 require "thin_parser"
 require "http_parser"
 require "benchmark"
+require "stringio"
 
 data = "POST /postit HTTP/1.1\r\n" +
        "Host: localhost:3000\r\n" +

data/ext/ruby_http_parser/org/ruby_http_parser/RubyHttpParser.java

@@ -1,36 +1,45 @@
 package org.ruby_http_parser;
 
+import http_parser.HTTPException;
+import http_parser.HTTPMethod;
+import http_parser.HTTPParser;
+import http_parser.lolevel.HTTPCallback;
+import http_parser.lolevel.HTTPDataCallback;
+import http_parser.lolevel.ParserSettings;
+
+import java.nio.ByteBuffer;
+
+import org.jcodings.Encoding;
+import org.jcodings.specific.UTF8Encoding;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.RubyHash;
-import org.jruby.RubyModule;
 import org.jruby.RubyNumeric;
 import org.jruby.RubyObject;
 import org.jruby.RubyString;
-
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-
-import org.jruby.anno.JRubyMethod;
-import org.jruby.exceptions.RaiseException;
-
-import java.nio.ByteBuffer;
-import http_parser.*;
-import http_parser.lolevel.ParserSettings;
-import http_parser.lolevel.HTTPCallback;
-import http_parser.lolevel.HTTPDataCallback;
+import org.jruby.util.ByteList;
 
 public class RubyHttpParser extends RubyObject {
 
+  @JRubyMethod(name = "strict?", module = true)
+  public static IRubyObject strict(IRubyObject recv) {
+    return recv.getRuntime().newBoolean(true);
+  }
+
   public static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
     public IRubyObject allocate(Ruby runtime, RubyClass klass) {
       return new RubyHttpParser(runtime, klass);
     }
   };
 
-  byte[] fetchBytes (ByteBuffer b, int pos, int len) {
+  byte[] fetchBytes(ByteBuffer b, int pos, int len) {
     byte[] by = new byte[len];
     int saved = b.position();
     b.position(pos);
@@ -65,14 +74,18 @@ public class RubyHttpParser extends RubyObject {
 
   private IRubyObject callback_object;
 
-  private String _current_header;
-  private String _last_header;
+  private boolean completed;
+
+  private byte[] _current_header;
+  private byte[] _last_header;
+
+  private static final Encoding UTF8 = UTF8Encoding.INSTANCE;
 
   public RubyHttpParser(final Ruby runtime, RubyClass clazz) {
-    super(runtime,clazz);
+    super(runtime, clazz);
 
     this.runtime = runtime;
-    this.eParserError = (RubyClass)runtime.getModule("HTTP").getClass("Parser").getConstant("Error");
+    this.eParserError = (RubyClass) runtime.getModule("HTTP").getClass("Parser").getConstant("Error");
 
     this.on_message_begin = null;
     this.on_headers_complete = null;
@@ -81,7 +94,10 @@ public class RubyHttpParser extends RubyObject {
 
     this.callback_object = null;
 
-    this.header_value_type = runtime.getModule("HTTP").getClass("Parser").getInstanceVariable("@default_header_value_type");
+    this.completed = false;
+
+    this.header_value_type = runtime.getModule("HTTP").getClass("Parser")
+        .getInstanceVariable("@default_header_value_type");
 
     initSettings();
     init();
@@ -91,48 +107,39 @@ public class RubyHttpParser extends RubyObject {
     this.settings = new ParserSettings();
 
     this.settings.on_url = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
+      public int cb(http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
         byte[] data = fetchBytes(buf, pos, len);
-        ((RubyString)requestUrl).concat(runtime.newString(new String(data)));
-        return 0;
-      }
-    };
-    this.settings.on_path = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
-        byte[] data = fetchBytes(buf, pos, len);
-        ((RubyString)requestPath).concat(runtime.newString(new String(data)));
-        return 0;
-      }
-    };
-    this.settings.on_query_string = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
-        byte[] data = fetchBytes(buf, pos, len);
-        ((RubyString)queryString).concat(runtime.newString(new String(data)));
-        return 0;
-      }
-    };
-    this.settings.on_fragment = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
-        byte[] data = fetchBytes(buf, pos, len);
-        ((RubyString)fragment).concat(runtime.newString(new String(data)));
+        if (runtime.is1_9() || runtime.is2_0()) {
+          ((RubyString) requestUrl).cat(data, 0, data.length, UTF8);
+        } else {
+          ((RubyString) requestUrl).cat(data);
+        }
         return 0;
       }
     };
 
     this.settings.on_header_field = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
+      public int cb(http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
         byte[] data = fetchBytes(buf, pos, len);
 
         if (_current_header == null)
-          _current_header = new String(data);
-        else
-          _current_header = _current_header.concat(new String(data));
+          _current_header = data;
+        else {
+          byte[] tmp = new byte[_current_header.length + data.length];
+          System.arraycopy(_current_header, 0, tmp, 0, _current_header.length);
+          System.arraycopy(data, 0, tmp, _current_header.length, data.length);
+          _current_header = tmp;
+        }
 
         return 0;
       }
     };
+    final RubySymbol arraysSym = runtime.newSymbol("arrays");
+    final RubySymbol mixedSym = runtime.newSymbol("mixed");
+    final RubySymbol stopSym = runtime.newSymbol("stop");
+    final RubySymbol resetSym = runtime.newSymbol("reset");
     this.settings.on_header_value = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
+      public int cb(http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
         byte[] data = fetchBytes(buf, pos, len);
         ThreadContext context = headers.getRuntime().getCurrentContext();
         IRubyObject key, val;
@@ -144,57 +151,74 @@ public class RubyHttpParser extends RubyObject {
           _current_header = null;
         }
 
-        key = (IRubyObject)runtime.newString(_last_header);
+        key = RubyString.newString(runtime, new ByteList(_last_header, UTF8, false));
         val = headers.op_aref(context, key);
 
         if (new_field == 1) {
           if (val.isNil()) {
-            if (header_value_type == runtime.newSymbol("arrays")) {
-              headers.op_aset(context, key, RubyArray.newArrayLight(runtime, runtime.newString("")));
+            if (header_value_type == arraysSym) {
+              headers.op_aset(context, key,
+                  RubyArray.newArrayLight(runtime, RubyString.newStringLight(runtime, 10, UTF8)));
             } else {
-              headers.op_aset(context, key, runtime.newString(""));
+              headers.op_aset(context, key, RubyString.newStringLight(runtime, 10, UTF8));
             }
           } else {
-            if (header_value_type == runtime.newSymbol("mixed")) {
+            if (header_value_type == mixedSym) {
               if (val instanceof RubyString) {
-                headers.op_aset(context, key, RubyArray.newArrayLight(runtime, val, runtime.newString("")));
+                headers.op_aset(context, key,
+                    RubyArray.newArrayLight(runtime, val, RubyString.newStringLight(runtime, 10, UTF8)));
               } else {
-                ((RubyArray)val).add(runtime.newString(""));
+                ((RubyArray) val).add(RubyString.newStringLight(runtime, 10, UTF8));
               }
-            } else if (header_value_type == runtime.newSymbol("arrays")) {
-              ((RubyArray)val).add(runtime.newString(""));
+            } else if (header_value_type == arraysSym) {
+              ((RubyArray) val).add(RubyString.newStringLight(runtime, 10, UTF8));
             } else {
-              ((RubyString)val).cat(", ".getBytes());
+              if (runtime.is1_9() || runtime.is2_0()) {
+                ((RubyString) val).cat(',', UTF8).cat(' ', UTF8);
+              } else {
+                ((RubyString) val).cat(',').cat(' ');
+              }
             }
           }
           val = headers.op_aref(context, key);
         }
 
         if (val instanceof RubyArray) {
-          val = ((RubyArray)val).entry(-1);
+          val = ((RubyArray) val).entry(-1);
         }
 
-        ((RubyString)val).cat(data);
+        if (runtime.is1_9() || runtime.is2_0()) {
+          ((RubyString) val).cat(data, 0, data.length, UTF8);
+        } else {
+          ((RubyString) val).cat(data);
+        }
 
         return 0;
       }
     };
 
     this.settings.on_message_begin = new HTTPCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p) {
+      public int cb(http_parser.lolevel.HTTPParser p) {
         headers = new RubyHash(runtime);
 
-        requestUrl = runtime.newString("");
-        requestPath = runtime.newString("");
-        queryString = runtime.newString("");
-        fragment = runtime.newString("");
-
-        upgradeData = runtime.newString("");
+        if (runtime.is1_9() || runtime.is2_0()) {
+          requestUrl = RubyString.newEmptyString(runtime, UTF8);
+          requestPath = RubyString.newEmptyString(runtime, UTF8);
+          queryString = RubyString.newEmptyString(runtime, UTF8);
+          fragment = RubyString.newEmptyString(runtime, UTF8);
+          upgradeData = RubyString.newEmptyString(runtime, UTF8);
+        } else {
+          requestUrl = RubyString.newEmptyString(runtime);
+          requestPath = RubyString.newEmptyString(runtime);
+          queryString = RubyString.newEmptyString(runtime);
+          fragment = RubyString.newEmptyString(runtime);
+          upgradeData = RubyString.newEmptyString(runtime);
+        }
 
         IRubyObject ret = runtime.getNil();
 
         if (callback_object != null) {
-          if (((RubyObject)callback_object).respond_to_p(runtime.newSymbol("on_message_begin")).toJava(Boolean.class) == Boolean.TRUE) {
+          if (((RubyObject) callback_object).respondsTo("on_message_begin")) {
             ThreadContext context = callback_object.getRuntime().getCurrentContext();
             ret = callback_object.callMethod(context, "on_message_begin");
           }
@@ -203,7 +227,7 @@ public class RubyHttpParser extends RubyObject {
           ret = on_message_begin.callMethod(context, "call");
         }
 
-        if (ret == runtime.newSymbol("stop")) {
+        if (ret == stopSym) {
           throw new StopException();
         } else {
           return 0;
@@ -211,11 +235,13 @@ public class RubyHttpParser extends RubyObject {
       }
     };
     this.settings.on_message_complete = new HTTPCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p) {
+      public int cb(http_parser.lolevel.HTTPParser p) {
         IRubyObject ret = runtime.getNil();
 
+        completed = true;
+
         if (callback_object != null) {
-          if (((RubyObject)callback_object).respond_to_p(runtime.newSymbol("on_message_complete")).toJava(Boolean.class) == Boolean.TRUE) {
+          if (((RubyObject) callback_object).respondsTo("on_message_complete")) {
             ThreadContext context = callback_object.getRuntime().getCurrentContext();
             ret = callback_object.callMethod(context, "on_message_complete");
           }
@@ -224,7 +250,7 @@ public class RubyHttpParser extends RubyObject {
           ret = on_message_complete.callMethod(context, "call");
         }
 
-        if (ret == runtime.newSymbol("stop")) {
+        if (ret == stopSym) {
           throw new StopException();
         } else {
           return 0;
@@ -232,11 +258,11 @@ public class RubyHttpParser extends RubyObject {
       }
     };
     this.settings.on_headers_complete = new HTTPCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p) {
+      public int cb(http_parser.lolevel.HTTPParser p) {
         IRubyObject ret = runtime.getNil();
 
         if (callback_object != null) {
-          if (((RubyObject)callback_object).respond_to_p(runtime.newSymbol("on_headers_complete")).toJava(Boolean.class) == Boolean.TRUE) {
+          if (((RubyObject) callback_object).respondsTo("on_headers_complete")) {
             ThreadContext context = callback_object.getRuntime().getCurrentContext();
             ret = callback_object.callMethod(context, "on_headers_complete", headers);
           }
@@ -245,29 +271,32 @@ public class RubyHttpParser extends RubyObject {
           ret = on_headers_complete.callMethod(context, "call", headers);
         }
 
-        if (ret == runtime.newSymbol("stop")) {
+        if (ret == stopSym) {
           throw new StopException();
+        } else if (ret == resetSym) {
+          return 1;
         } else {
           return 0;
         }
       }
     };
     this.settings.on_body = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
+      public int cb(http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
         IRubyObject ret = runtime.getNil();
         byte[] data = fetchBytes(buf, pos, len);
 
         if (callback_object != null) {
-          if (((RubyObject)callback_object).respond_to_p(runtime.newSymbol("on_body")).toJava(Boolean.class) == Boolean.TRUE) {
+          if (((RubyObject) callback_object).respondsTo("on_body")) {
             ThreadContext context = callback_object.getRuntime().getCurrentContext();
-            ret = callback_object.callMethod(context, "on_body", callback_object.getRuntime().newString(new String(data)));
+            ret = callback_object.callMethod(context, "on_body",
+                RubyString.newString(runtime, new ByteList(data, UTF8, false)));
           }
         } else if (on_body != null) {
           ThreadContext context = on_body.getRuntime().getCurrentContext();
-          ret = on_body.callMethod(context, "call", on_body.getRuntime().newString(new String(data)));
+          ret = on_body.callMethod(context, "call", RubyString.newString(runtime, new ByteList(data, UTF8, false)));
         }
 
-        if (ret == runtime.newSymbol("stop")) {
+        if (ret == stopSym) {
           throw new StopException();
         } else {
           return 0;
@@ -278,6 +307,7 @@ public class RubyHttpParser extends RubyObject {
 
   private void init() {
     this.parser = new HTTPParser();
+    this.parser.HTTP_PARSER_STRICT = true;
     this.headers = null;
 
     this.requestUrl = runtime.getNil();
@@ -331,8 +361,9 @@ public class RubyHttpParser extends RubyObject {
 
   @JRubyMethod(name = "<<")
   public IRubyObject execute(IRubyObject data) {
-    RubyString str = (RubyString)data;
-    ByteBuffer buf = ByteBuffer.wrap(str.getBytes());
+    RubyString str = (RubyString) data;
+    ByteList byteList = str.getByteList();
+    ByteBuffer buf = ByteBuffer.wrap(byteList.getUnsafeBytes(), byteList.getBegin(), byteList.getRealSize());
     boolean stopped = false;
 
     try {
@@ -345,9 +376,12 @@ public class RubyHttpParser extends RubyObject {
 
     if (parser.getUpgrade()) {
       byte[] upData = fetchBytes(buf, buf.position(), buf.limit() - buf.position());
-      ((RubyString)upgradeData).concat(runtime.newString(new String(upData)));
-
-    } else if (buf.hasRemaining()) {
+      if (runtime.is1_9() || runtime.is2_0()) {
+        ((RubyString) upgradeData).cat(upData, 0, upData.length, UTF8);
+      } else {
+        ((RubyString) upgradeData).cat(upData);
+      }
+    } else if (buf.hasRemaining() && !completed) {
       if (!stopped)
         throw new RaiseException(runtime, eParserError, "Could not parse data entirely", true);
     }
@@ -357,12 +391,12 @@ public class RubyHttpParser extends RubyObject {
 
   @JRubyMethod(name = "keep_alive?")
   public IRubyObject shouldKeepAlive() {
-    return parser.shouldKeepAlive() ? runtime.getTrue() : runtime.getFalse();
+    return runtime.newBoolean(parser.shouldKeepAlive());
   }
 
   @JRubyMethod(name = "upgrade?")
   public IRubyObject shouldUpgrade() {
-    return parser.getUpgrade() ? runtime.getTrue() : runtime.getFalse();
+    return runtime.newBoolean(parser.getUpgrade());
   }
 
   @JRubyMethod(name = "http_major")
@@ -439,7 +473,8 @@ public class RubyHttpParser extends RubyObject {
 
   @JRubyMethod(name = "header_value_type=")
   public IRubyObject set_header_value_type(IRubyObject val) {
-    if (val != runtime.newSymbol("mixed") && val != runtime.newSymbol("arrays") && val != runtime.newSymbol("strings")) {
+    String valString = val.toString();
+    if (valString != "mixed" && valString != "arrays" && valString != "strings") {
       throw runtime.newArgumentError("Invalid header value type");
     }
     header_value_type = val;