http_parser.rb 0.5.2 → 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: afdb28464ccb0f753a1d66be02b667683d6aadfe31fe03a88f889252b457761d
+  data.tar.gz: 6041b3dc3f212160ae00b72b193e4620c5facd59096a28b122c0ef5a901dc80b
+SHA512:
+  metadata.gz: 41249c628f931cd9721e32bd378a44b8e49b25706b491ae3761d641e55bac1205afe9d3d02d88d5b4f3161adee4a65416c5eec2a51fcacad1b050d6f6d2637fc
+  data.tar.gz: ae5718390cce25d2ee7fcbaf923fac015189079b64ea2f37759c41ee2e7f2714dafaf6bf37ed6434f540e82e87c6a13723e226ac27000d1f0e2d7b2681643514

data/.github/workflows/linux.yml

@@ -0,0 +1,23 @@
+name: Testing on Ubuntu
+on:
+  - push
+  - pull_request
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '2.6', '2.7', '3.0' ]
+        os: [ 'ubuntu-latest' ]
+    name: Ruby ${{ matrix.ruby }} unit testing on ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: unit testing
+      run: |
+        gem install bundler rake
+        bundle install --jobs 4 --retry 3
+        bundle exec rake

data/.github/workflows/windows.yml

@@ -0,0 +1,23 @@
+name: Testing on Windows
+on:
+  - push
+  - pull_request
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '2.6', '2.7', '3.0' ]
+        os: [ 'windows-latest' ]
+    name: Ruby ${{ matrix.ruby }} unit testing on ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: unit testing
+      run: |
+        gem install bundler rake
+        bundle install --jobs 4 --retry 3
+        bundle exec rake

data/.gitignore

@@ -1,11 +1,12 @@
-tmp
+*.bundle
 *.bundle
 *.gem
+*.jar
 *.o
+*.rbc
 *.so
-*.bundle
-*.jar
 *.swp
+Gemfile.lock
 Makefile
 tags
-*.rbc
+tmp

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/ry/http-parser.git
-[submodule "ext/ruby_http_parser/vendor/http-parser-java"]
+	url = https://github.com/nodejs/http-parser.git
+[submodule "http-parser-java"]
 	path = ext/ruby_http_parser/vendor/http-parser-java
-	url = git://github.com/a2800276/http-parser.java.git
+	url = https://github.com/tmm1/http-parser.java

data/Gemfile

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

data/README.md

@@ -3,83 +3,88 @@
 A simple callback-based HTTP request/response parser for writing http
 servers, clients and proxies.
 
-This gem is built on top of [ry/http-parser](http://github.com/ry/http-parser) and its java port [a2800276/http-parser.java](http://github.com/a2800276/http-parser.java).
+This gem is built on top of [joyent/http-parser](https://github.com/joyent/http-parser) and its java port [http-parser/http-parser.java](https://github.com/http-parser/http-parser.java).
 
 ## Supported Platforms
 
 This gem aims to work on all major Ruby platforms, including:
 
-- MRI 1.8 and 1.9
+- MRI 1.8, 1.9 and 2.0; should work on MRI 2.4+
 - Rubinius
 - JRuby
 - win32
 
 ## 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/Rakefile

@@ -1,4 +1,5 @@
 # load tasks
+require 'bundler/gem_tasks'
 Dir['tasks/*.rake'].sort.each { |f| load f }
 
 # default task

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/extconf.rb

@@ -18,7 +18,7 @@ src_dir = File.expand_path('../', __FILE__)
   }
 end
 
-$CFLAGS << " -I#{src_dir}"
+$CFLAGS << " -I\"#{src_dir}\""
 
 dir_config("ruby_http_parser")
 create_makefile("ruby_http_parser")

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);
@@ -55,6 +64,7 @@ public class RubyHttpParser extends RubyObject {
   private IRubyObject on_body;
   private IRubyObject on_message_complete;
 
+  private IRubyObject status;
   private IRubyObject requestUrl;
   private IRubyObject requestPath;
   private IRubyObject queryString;
@@ -65,14 +75,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 +95,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();
@@ -90,49 +107,52 @@ public class RubyHttpParser extends RubyObject {
   private void initSettings() {
     this.settings = new ParserSettings();
 
-    this.settings.on_url = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
+    this.settings.on_status = new HTTPDataCallback() {
+      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)));
+        if (runtime.is1_9() || runtime.is2_0()) {
+          ((RubyString) status).cat(data, 0, data.length, UTF8);
+        } else {
+          ((RubyString) status).cat(data);
+        }
         return 0;
       }
     };
-    this.settings.on_fragment = new HTTPDataCallback() {
-      public int cb (http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
+
+    this.settings.on_url = 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 +164,76 @@ 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()) {
+          status = RubyString.newEmptyString(runtime, UTF8);
+          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 {
+          status = RubyString.newEmptyString(runtime);
+          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 +242,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 +250,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 +265,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 +273,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 +286,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,8 +322,10 @@ public class RubyHttpParser extends RubyObject {
 
   private void init() {
     this.parser = new HTTPParser();
+    this.parser.HTTP_PARSER_STRICT = true;
     this.headers = null;
-
+    
+    this.status = runtime.getNil();
     this.requestUrl = runtime.getNil();
     this.requestPath = runtime.getNil();
     this.queryString = runtime.getNil();
@@ -331,8 +377,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 +392,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 +407,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")
@@ -412,6 +462,11 @@ public class RubyHttpParser extends RubyObject {
     return headers == null ? runtime.getNil() : headers;
   }
 
+  @JRubyMethod(name = "status")
+  public IRubyObject getStatus() {
+    return status == null ? runtime.getNil() : status;
+  }
+
   @JRubyMethod(name = "request_url")
   public IRubyObject getRequestUrl() {
     return requestUrl == null ? runtime.getNil() : requestUrl;
@@ -439,7 +494,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;