http_parser.rb 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb02853976523252e0d5f36af3ba83b363010d4c163d9a4951b419054e7486ae
-  data.tar.gz: 3b7ac3ea5df5866582e0f68653d205764498e60e01835d2e19661cf4e1089d1b
+  metadata.gz: 7fb5f5d030bfee30671d56b87acf02da0839051af33452843cef949f11dc5f14
+  data.tar.gz: d232aab15c4758a799a6cf9c59d315ecbd814259aba71bcc609728b651841e1b
 SHA512:
-  metadata.gz: 67516e3f1024e4bbf8dd00ae441646d53ca279313683b6f8da24668901c59b364608ecd9c69dab63709d9f89245ddc5363e0865f294a5af9d8e0b39d4712328f
-  data.tar.gz: 505a790706bc8f84404c2c6dd7e2b0025d591ca30311ca93d4eda4cf58a274c105acf68ed029ce96e38b04b040b86d4e953cf944a80a1e66a72f2a737d8cbfba
+  metadata.gz: 263ea218dabc076ae0b10b8ed63d1383263a11d7c9d42539fd0e0349e78ffc9fb38a9e731f76d83367d1354e5b0c4d345d79b79be7d87327012d39a879a3f62d
+  data.tar.gz: b8118b7aa966b1be6b315c956afe8d55d633e5f5dfa8fc9a3f28e53b1b31d7d32624c905de208b29804336afe9f4ae64f52b29615c84846bbf44e326b6a60f66

data/.github/workflows/linux.yml

@@ -8,11 +8,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.6', '2.7', '3.0' ]
+        ruby: [ '3.1', '3.2', '3.3', '3.4', 'head' ]
         os: [ 'ubuntu-latest' ]
     name: Ruby ${{ matrix.ruby }} unit testing on ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}

data/.github/workflows/windows.yml

@@ -8,11 +8,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.6', '2.7', '3.0' ]
+        ruby: [ '3.1', '3.2', '3.3', '3.4', 'head' ]
         os: [ 'windows-latest' ]
     name: Ruby ${{ matrix.ruby }} unit testing on ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}

data/ext/ruby_http_parser/ext_help.h

@@ -2,7 +2,12 @@
 #define ext_help_h
 
 #define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
-#define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
+#ifdef TypedData_Get_Struct
+#define DATA_GET_STRUCT(from,type,name) TypedData_Get_Struct(from,type,&type##_type,name)
+#else
+#define DATA_GET_STRUCT(from,type,name) Data_Get_Struct(from,type,name)
+#endif
+#define DATA_GET(from,type,name) DATA_GET_STRUCT(from,type,name); RAISE_NOT_NULL(name);
 #define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
 
 /* for compatibility with Ruby 1.8.5, which doesn't declare RSTRING_PTR */

data/ext/ruby_http_parser/ruby_http_parser.c

@@ -81,6 +81,14 @@ void ParserWrapper_free(void *data) {
   }
 }
 
+static const rb_data_type_t ParserWrapper_type = {
+  "ParserWrapper",
+  {
+    ParserWrapper_mark,
+    ParserWrapper_free,
+  },
+};
+
 static VALUE cParser;
 static VALUE cRequestParser;
 static VALUE cResponseParser;
@@ -293,7 +301,7 @@ VALUE Parser_alloc_by_type(VALUE klass, enum ryah_http_parser_type type) {
 
   ParserWrapper_init(wrapper);
 
-  return Data_Wrap_Struct(klass, ParserWrapper_mark, ParserWrapper_free, wrapper);
+  return TypedData_Wrap_Struct(klass, &ParserWrapper_type, wrapper);
 }
 
 VALUE Parser_alloc(VALUE klass) {

data/http_parser.rb.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "http_parser.rb"
-  s.version = "0.8.0"
+  s.version = "0.8.1"
   s.summary = "Simple callback-based HTTP request/response parser"
   s.description = "Ruby bindings to https://github.com/joyent/http-parser and https://github.com/http-parser/http-parser.java"
 
@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.license = 'MIT'
 
   s.homepage = "https://github.com/tmm1/http_parser.rb"
-  s.files = `git ls-files`.split("\n") + Dir['ext/ruby_http_parser/vendor/**/*']
+  s.files = `git ls-files`.split("\n").grep_v(%r{spec/}) + Dir['ext/ruby_http_parser/vendor/**/*']
 
   s.require_paths = ["lib"]
   s.extensions    = ["ext/ruby_http_parser/extconf.rb"]

data/tasks/compile.rake

@@ -34,7 +34,7 @@ RUBY_VERSION =~ /(\\d+.\\d+)/
 require "\#{$1}/ruby_http_parser"
     eoruby
   end
-  at_exit{ FileUtils.rm t.name if File.exists?(t.name) }
+  at_exit{ FileUtils.rm t.name if File.exist?(t.name) }
 end
 
 if Rake::Task.task_defined?(:cross)

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: http_parser.rb
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Marc-Andre Cournoyer
 - Aman Gupta
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -182,10 +181,6 @@ files:
 - http_parser.rb.gemspec
 - lib/http/parser.rb
 - lib/http_parser.rb
-- spec/parser_spec.rb
-- spec/spec_helper.rb
-- spec/support/requests.json
-- spec/support/responses.json
 - tasks/compile.rake
 - tasks/fixtures.rake
 - tasks/spec.rake
@@ -194,7 +189,6 @@ homepage: https://github.com/tmm1/http_parser.rb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -209,8 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Simple callback-based HTTP request/response parser
 test_files: []

data/spec/parser_spec.rb

@@ -1,428 +0,0 @@
-if defined?(Encoding)
-  Encoding.default_external = "UTF-8"
-end
-require "spec_helper"
-require "json"
-
-describe HTTP::Parser do
-  before do
-    @parser = HTTP::Parser.new
-
-    @headers = nil
-    @body = ""
-    @started = false
-    @done = false
-
-    @parser.on_message_begin = proc{ @started = true }
-    @parser.on_headers_complete = proc { |e| @headers = e }
-    @parser.on_body = proc { |chunk| @body << chunk }
-    @parser.on_message_complete = proc{ @done = true }
-  end
-
-  it "should have initial state" do
-    expect(@parser.headers).to be_nil
-
-    expect(@parser.http_version).to be_nil
-    expect(@parser.http_method).to be_nil
-    expect(@parser.status_code).to be_nil
-
-    expect(@parser.request_url).to be_nil
-
-    expect(@parser.header_value_type).to eq(:mixed)
-  end
-
-  it "should be able to run in non-main ractors" do
-    skip unless Kernel.const_defined?(:Ractor)
-    default_header_value_type = HTTP::Parser.default_header_value_type
-    r = Ractor.new(default_header_value_type) { |type|
-      parser = HTTP::Parser.new(default_header_value_type: type)
-      done = false
-      parser.on_message_complete = proc {
-        done = true
-      }
-      parser <<
-        "GET /ractor HTTP/1.1\r\n" +
-        "Content-Length: 5\r\n" +
-        "\r\n" +
-        "World"
-      done
-    }
-    expect(r.take).to be true
-  end
-
-  it "should allow us to set the header value type" do
-    [:mixed, :arrays, :strings].each do |type|
-      @parser.header_value_type = type
-      expect(@parser.header_value_type).to eq(type)
-
-      parser_tmp = HTTP::Parser.new(nil, type)
-      expect(parser_tmp.header_value_type).to eq(type)
-
-      parser_tmp2 = HTTP::Parser.new(default_header_value_type: type)
-      expect(parser_tmp2.header_value_type).to eq(type)
-    end
-  end
-
-  it "should allow us to set the default header value type" do
-    [:mixed, :arrays, :strings].each do |type|
-      HTTP::Parser.default_header_value_type = type
-
-      parser = HTTP::Parser.new
-      expect(parser.header_value_type).to eq(type)
-    end
-  end
-
-  it "should throw an Argument Error if header value type is invalid" do
-    expect{ @parser.header_value_type = 'bob' }.to raise_error(ArgumentError)
-  end
-
-  it "should throw an Argument Error if default header value type is invalid" do
-    expect{ HTTP::Parser.default_header_value_type = 'bob' }.to raise_error(ArgumentError)
-  end
-
-  it "should implement basic api" do
-    @parser <<
-      "GET /test?ok=1 HTTP/1.1\r\n" +
-      "User-Agent: curl/7.18.0\r\n" +
-      "Host: 0.0.0.0:5000\r\n" +
-      "Accept: */*\r\n" +
-      "Content-Length: 5\r\n" +
-      "\r\n" +
-      "World"
-
-    expect(@started).to be true
-    expect(@done).to be true
-
-    expect(@parser.http_major).to eq(1)
-    expect(@parser.http_minor).to eq(1)
-    expect(@parser.http_version).to eq([1,1])
-    expect(@parser.http_method).to eq('GET')
-    expect(@parser.status_code).to be_nil
-
-    expect(@parser.request_url).to eq('/test?ok=1')
-
-    expect(@parser.headers).to eq(@headers)
-    expect(@parser.headers['User-Agent']).to eq('curl/7.18.0')
-    expect(@parser.headers['Host']).to eq('0.0.0.0:5000')
-
-    expect(@body).to eq("World")
-  end
-
-  it "should raise errors on invalid data" do
-    expect{ @parser << "BLAH" }.to raise_error(HTTP::Parser::Error)
-  end
-
-  it "should abort parser via header complete callback with a body" do
-    @parser.on_headers_complete = proc { |e| @headers = e; :stop }
-
-    data =
-      "GET / HTTP/1.0\r\n" +
-      "Content-Length: 5\r\n" +
-      "\r\n" +
-      "World"
-
-    bytes = @parser << data
-
-    expect(bytes).to eq(37)
-    expect(data[bytes..-1]).to eq('World')
-
-    expect(@headers).to eq({'Content-Length' => '5'})
-    expect(@body).to be_empty
-    expect(@done).to be false
-  end
-
-  it "should abort parser via header complete callback without a body" do
-    @parser.on_headers_complete = proc { |e| @headers = e; :stop }
-
-    data =
-      "GET / HTTP/1.0\r\n" +
-      "Content-Length: 0\r\n" +
-      "\r\n"
-
-    bytes = @parser << data
-
-    expect(bytes).to eq(37)
-    expect(data[bytes..-1]).to eq('')
-
-    expect(@headers).to eq({'Content-Length' => '0'})
-    expect(@body).to be_empty
-    expect(@done).to be false
-  end
-
-  it "should abort parser via message complete callback with a body" do
-    @parser.on_message_complete = proc { :stop }
-
-    data =
-      "CONNECT www.example.com:443 HTTP/1.0\r\n" +
-      "Connection: keep-alive\r\n" +
-      "\r\n" +
-      "World"
-
-    bytes = @parser << data
-
-    expect(bytes).to eq(64)
-    expect(data[bytes..-1]).to eq('World')
-
-    expect(@headers).to eq({'Connection' => 'keep-alive'})
-    expect(@parser.upgrade_data).to eq('World')
-    expect(@body).to be_empty
-    expect(@done).to be false
-  end
-
-  it "should abort parser via message complete callback without a body" do
-    @parser.on_message_complete = proc { :stop }
-
-    data =
-      "CONNECT www.example.com:443 HTTP/1.0\r\n" +
-      "Connection: keep-alive\r\n" +
-      "\r\n"
-
-    bytes = @parser << data
-
-    expect(bytes).to eq(64)
-    expect(data[bytes..-1]).to eq('')
-
-    expect(@headers).to eq({'Connection' => 'keep-alive'})
-    expect(@parser.upgrade_data).to eq('')
-    expect(@body).to be_empty
-    expect(@done).to be false
-  end
-
-  it "should reset to initial state" do
-    @parser << "GET / HTTP/1.0\r\n\r\n"
-
-    expect(@parser.http_method).to eq('GET')
-    expect(@parser.http_version).to eq([1,0])
-
-    expect(@parser.request_url).to eq('/')
-
-    expect(@parser.reset!).to be true
-
-    expect(@parser.http_version).to be_nil
-    expect(@parser.http_method).to be_nil
-    expect(@parser.status_code).to be_nil
-
-    expect(@parser.request_url).to be_nil
-  end
-
-  it "should optionally reset parser state on no-body responses" do
-   expect(@parser.reset!).to be true
-
-   @head, @complete = 0, 0
-   @parser.on_headers_complete = proc {|h| @head += 1; :reset }
-   @parser.on_message_complete = proc { @complete += 1 }
-   @parser.on_body = proc {|b| fail }
-
-   head_response = "HTTP/1.1 200 OK\r\nContent-Length:10\r\n\r\n"
-
-   @parser << head_response
-   expect(@head).to eq(1)
-   expect(@complete).to eq(1)
-
-   @parser << head_response
-   expect(@head).to eq(2)
-   expect(@complete).to eq(2)
-  end
-
-  it "should retain callbacks after reset" do
-    expect(@parser.reset!).to be true
-
-    @parser << "GET / HTTP/1.0\r\n\r\n"
-    expect(@started).to be true
-    expect(@headers).to eq({})
-    expect(@done).to be true
-  end
-
-  it "should parse headers incrementally" do
-    request =
-      "GET / HTTP/1.0\r\n" +
-      "Header1: value 1\r\n" +
-      "Header2: value 2\r\n" +
-      "\r\n"
-
-    while chunk = request.slice!(0,2) and !chunk.empty?
-      @parser << chunk
-    end
-
-    expect(@parser.headers).to eq({
-      'Header1' => 'value 1',
-      'Header2' => 'value 2'
-    })
-  end
-
-  it "should handle multiple headers using strings" do
-    @parser.header_value_type = :strings
-
-    @parser <<
-      "GET / HTTP/1.0\r\n" +
-      "Set-Cookie: PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com\r\n" +
-      "Set-Cookie: NID=46jSHxPM; path=/; domain=.bob.com; HttpOnly\r\n" +
-      "\r\n"
-
-    expect(@parser.headers["Set-Cookie"]).to eq("PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com, NID=46jSHxPM; path=/; domain=.bob.com; HttpOnly")
-  end
-
-  it "should handle multiple headers using strings" do
-    @parser.header_value_type = :arrays
-
-    @parser <<
-      "GET / HTTP/1.0\r\n" +
-      "Set-Cookie: PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com\r\n" +
-      "Set-Cookie: NID=46jSHxPM; path=/; domain=.bob.com; HttpOnly\r\n" +
-      "\r\n"
-
-    expect(@parser.headers["Set-Cookie"]).to eq([
-        "PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com",
-        "NID=46jSHxPM; path=/; domain=.bob.com; HttpOnly"
-    ])
-  end
-
-  it "should handle multiple headers using mixed" do
-    @parser.header_value_type = :mixed
-
-    @parser <<
-      "GET / HTTP/1.0\r\n" +
-      "Set-Cookie: PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com\r\n" +
-      "Set-Cookie: NID=46jSHxPM; path=/; domain=.bob.com; HttpOnly\r\n" +
-      "\r\n"
-
-    expect(@parser.headers["Set-Cookie"]).to eq([
-        "PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com",
-        "NID=46jSHxPM; path=/; domain=.bob.com; HttpOnly"
-    ])
-  end
-
-  it "should handle a single cookie using mixed" do
-    @parser.header_value_type = :mixed
-
-    @parser <<
-      "GET / HTTP/1.0\r\n" +
-      "Set-Cookie: PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com\r\n" +
-      "\r\n"
-
-    expect(@parser.headers["Set-Cookie"]).to eq("PREF=ID=a7d2c98; expires=Fri, 05-Apr-2013 05:00:45 GMT; path=/; domain=.bob.com")
-  end
-
-  it "should support alternative api" do
-    callbacks = double('callbacks')
-    allow(callbacks).to receive(:on_message_begin){ @started = true }
-    allow(callbacks).to receive(:on_headers_complete){ |e| @headers = e }
-    allow(callbacks).to receive(:on_body){ |chunk| @body << chunk }
-    allow(callbacks).to receive(:on_message_complete){ @done = true }
-
-    @parser = HTTP::Parser.new(callbacks)
-    @parser << "GET / HTTP/1.0\r\n\r\n"
-
-    expect(@started).to be true
-    expect(@headers).to eq({})
-    expect(@body).to eq('')
-    expect(@done).to be true
-  end
-
-  it "should ignore extra content beyond specified length" do
-    @parser <<
-      "GET / HTTP/1.0\r\n" +
-      "Content-Length: 5\r\n" +
-      "\r\n" +
-      "hello" +
-      "  \n"
-
-    expect(@body).to eq('hello')
-    expect(@done).to be true
-  end
-
-  it 'sets upgrade_data if available' do
-    @parser <<
-      "GET /demo HTTP/1.1\r\n" +
-      "Connection: Upgrade\r\n" +
-      "Upgrade: WebSocket\r\n\r\n" +
-      "third key data"
-
-    expect(@parser.upgrade?).to be true
-    expect(@parser.upgrade_data).to eq('third key data')
-  end
-
-  it 'sets upgrade_data to blank if un-available' do
-    @parser <<
-      "GET /demo HTTP/1.1\r\n" +
-      "Connection: Upgrade\r\n" +
-      "Upgrade: WebSocket\r\n\r\n"
-
-    expect(@parser.upgrade?).to be true
-    expect(@parser.upgrade_data).to eq('')
-  end
-
-  it 'should stop parsing headers when instructed' do
-    request = "GET /websocket HTTP/1.1\r\n" +
-      "host: localhost\r\n" +
-      "connection: Upgrade\r\n" +
-      "upgrade: websocket\r\n" +
-      "sec-websocket-key: SD6/hpYbKjQ6Sown7pBbWQ==\r\n" +
-      "sec-websocket-version: 13\r\n" +
-      "\r\n"
-
-    @parser.on_headers_complete = proc { |e| :stop }
-    offset = (@parser << request)
-    expect(@parser.upgrade?).to be true
-    expect(@parser.upgrade_data).to eq('')
-    expect(offset).to eq(request.length)
-  end
-
-  it "should execute on_body on requests with no content-length" do
-   expect(@parser.reset!).to be true
-
-   @head, @complete, @body = 0, 0, 0
-   @parser.on_headers_complete = proc {|h| @head += 1 }
-   @parser.on_message_complete = proc { @complete += 1 }
-   @parser.on_body = proc {|b| @body += 1 }
-
-   head_response = "HTTP/1.1 200 OK\r\n\r\nstuff"
-
-   @parser << head_response
-   @parser << ''
-   expect(@head).to eq(1)
-   expect(@complete).to eq(1)
-   expect(@body).to eq(1)
-  end
-
-
-  %w[ request response ].each do |type|
-    JSON.parse(File.read(File.expand_path("../support/#{type}s.json", __FILE__))).each do |test|
-      test['headers'] ||= {}
-      next if !defined?(JRUBY_VERSION) and HTTP::Parser.strict? != test['strict']
-
-      it "should parse #{type}: #{test['name']}" do
-        @parser << test['raw']
-
-        expect(@parser.http_method).to eq(test['method'])
-        expect(@parser.keep_alive?).to eq(test['should_keep_alive'])
-
-        if test.has_key?('upgrade') and test['upgrade'] != 0
-          expect(@parser.upgrade?).to be true
-          expect(@parser.upgrade_data).to eq(test['upgrade'])
-        end
-
-        expect(@parser.send("http_major")).to eq(test["http_major"])
-        expect(@parser.send("http_minor")).to eq(test["http_minor"])
-
-        if test['type'] == 'HTTP_REQUEST'
-          if defined?(JRUBY_VERSION)
-            expect(@parser.send("request_url")).to eq(test["request_url"])
-          else
-            # It's created by rb_str_new(), so that encoding is Encoding::ASCII_8BIT a.k.a Encoding::BINARY
-            expect(@parser.send("request_url")).to eq(test["request_url"].force_encoding(Encoding::ASCII_8BIT))
-          end
-        else
-          expect(@parser.send("status_code")).to eq(test["status_code"])
-          expect(@parser.send("status")).to eq(test["status"].force_encoding(Encoding::ASCII_8BIT)) if !defined?(JRUBY_VERSION)
-        end
-
-        expect(@headers.size).to eq(test['num_headers'])
-        expect(@headers).to eq(test['headers'])
-
-        expect(@body).to eq(test['body'])
-        expect(@body.size).to eq(test['body_size']) if test['body_size']
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1 +0,0 @@
-require "http_parser"