h1p 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fb3573e65df46350986981759a454c8bc2c4166901a46dd827fdc17a27b08b5
-  data.tar.gz: afc10ead82e3286f61fa2bee1739499f275b75a386ed3e3401988805470c9b3a
+  metadata.gz: 58f7bb5105298c97edf87c91b8038ccc50ac6732417b981331a39cf56711da9b
+  data.tar.gz: d5745229262d866ed3564eede8b52706b14cb791652886be9f0a3ec2bc44eaf4
 SHA512:
-  metadata.gz: 72ba304cda888fcfb1c8afaee1a03b94ddb15fde0110c303886e4036125fb5b464d214ebb731ea91dac792070c9cc3d5eccb789f667c8a590fae01afb88d5665
-  data.tar.gz: 31cd6c6d7bb6695d338596b56be808cd1fed99cc76f11ee5f38fbdf7ff5d1206960a7134932ac82e9ca9c19116a20ee99db8f2a002fb76c1997134ac4d432dae
+  metadata.gz: d64c4623aa5c1cffd019222f6b75e3ec07da72997a5118490e07437ee0b0449371da96d89f4755182703fc71bc0974f415e6c9eecffa1f173c3bcb59f894d376
+  data.tar.gz: 9df79da840b37ecacb1df7818a661a33560970b5c07e4b82250e29466b868c6087848b527a8123a1373ead55ec1a37a4626e1a702c04037a4515e66ac6220476

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## 0.42 2021-08-16
 
+## 0.2 2021-08-20
+
+- Use uppercase for HTTP method
+
 ## 0.1 2021-08-19
 
 - Import code from Tipi

data/Gemfile.lock

@@ -1,33 +1,24 @@
 PATH
   remote: .
   specs:
-    h1p (0.1)
+    h1p (0.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ansi (1.5.0)
-    builder (3.2.4)
-    minitest (5.11.3)
-    minitest-reporters (1.4.3)
-      ansi
-      builder
-      minitest (>= 5.0)
-      ruby-progressbar
-    rake (12.3.3)
+    minitest (5.14.4)
+    rake (13.0.6)
     rake-compiler (1.1.1)
       rake
-    ruby-progressbar (1.11.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   h1p!
-  minitest (~> 5.11.3)
-  minitest-reporters (~> 1.4.2)
-  rake (~> 12.3.3)
+  minitest (~> 5.14.4)
+  rake (~> 13.0.6)
   rake-compiler (= 1.1.1)
 
 BUNDLED WITH
-   2.1.4
+   2.2.26

data/README.md

@@ -1,5 +1,222 @@
-# h1p
+# H1P - a blocking HTTP/1 parser for Ruby
 
-h1p 
+[![Gem Version](https://badge.fury.io/rb/h1p.svg)](http://rubygems.org/gems/h1p)
+[![Modulation Test](https://github.com/digital-fabric/h1p/workflows/Tests/badge.svg)](https://github.com/digital-fabric/h1p/actions?query=workflow%3ATests)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/h1p/blob/master/LICENSE)
 
-HTTP 1.1 parser for Ruby
+H1P is a blocking/synchronous HTTP/1 parser for Ruby with a simple and intuitive
+API. Its design lends itself to writing HTTP servers in a sequential style. As
+such, it might prove useful in conjunction with the new fiber scheduler
+introduced in Ruby 3.0, but is also useful with a normal thread-based server
+(see
+[example](https://github.com/digital-fabric/h1p/blob/main/examples/http_server.rb).)
+The H1P was originally written as part of
+[Tipi](https://github.com/digital-fabric/tipi), a web server running on top of
+[Polyphony](https://github.com/digital-fabric/polyphony).
+
+> H1P is still a very young project and as such should be used with caution. It
+> has not undergone any significant conformance or security testing, and its API
+> is not yet stable.
+
+## Features
+
+- Simple, blocking/synchronous API
+- Zero dependencies
+- Transport-agnostic
+- Support for chunked encoding
+- Support for both `LF` and `CRLF` line breaks
+- Track total incoming traffic
+
+## Installing
+
+If you're using bundler just add it to your `Gemfile`:
+
+```ruby
+source 'https://rubygems.org'
+
+gem 'h1p'
+```
+
+You can then run `bundle install` to install it. Otherwise, just run `gem install h1p`.
+
+## Usage
+
+Start by creating an instance of H1P::Parser, passing a connection instance:
+
+```ruby
+require 'h1p'
+
+parser = H1P::Parser.new(conn)
+```
+
+To read the next request from the connection, call `#parse_headers`:
+
+```ruby
+loop do
+  headers = parser.parse_headers
+  break unless headers
+
+  handle_request(headers)
+end
+```
+
+The `#parse_headers` method returns a single hash containing the different HTTP
+headers. In case the client has closed the connection, `#parse_headers` will
+return `nil` (see the guard clause above).
+
+In addition to the header keys and values, the resulting hash also contains the
+following "pseudo-headers":
+
+- `:method`: the HTTP method (in upper case)
+- `:path`: the request target
+- `:protocol`: the protocol used (either `'http/1.0'` or `'http/1.1'`)
+- `:rx`: the total bytes read by the parser
+
+The header keys are always lower-cased. Consider the following HTTP request:
+
+```
+GET /foo HTTP/1.1
+Host: example.com
+User-Agent: curl/7.74.0
+Accept: */*
+
+```
+
+The request will be parsed into the following Ruby hash:
+
+```ruby
+{
+  ":method"     => "get",
+  ":path"       => "/foo",
+  ":protocol"   => "http/1.1",
+  "host"        => "example.com",
+  "user-agent"  => "curl/7.74.0",
+  "accept"      => "*/*",
+  ":rx"         => 78
+}
+```
+
+Multiple headers with the same key will be coalesced into a single key-value
+where the value is an array containing the corresponding values. For example,
+multiple `Cookie` headers will appear in the hash as a single `"cookie"` entry,
+e.g. `{ "cookie" => ['a=1', 'b=2'] }`
+
+### Handling of invalid requests 
+
+When an invalid request is encountered, the parser will raise a `H1P::Error`
+exception. An incoming request may be considered invalid if an invalid character
+has been encountered at any point in parsing the request, or if any of the
+tokens have an invalid length. You can consult the limits used by the parser
+[here](https://github.com/digital-fabric/h1p/blob/main/ext/h1p/limits.rb).
+
+### Reading the request body
+
+To read the request body use `#read_body`:
+
+```ruby
+# read entire body
+body = parser.read_body
+```
+
+The H1P parser knows how to read both request bodies with a specified
+`Content-Length` and request bodies in chunked encoding. The method call will
+return when the entire body has been read. If the body is incomplete or has
+invalid formatting, the parser will raise a `H1P::Error` exception.
+
+You can also read a single chunk of the body by calling `#read_body_chunk`:
+
+```ruby
+# read a body chunk
+chunk = parser.read_body_chunk(false)
+
+# read chunk only from buffer:
+chunk = parser.read_body_chunk(true)
+```
+
+If no more chunks are availble, `#read_body_chunk` will return nil. To test
+whether the request is complete, you can call `#complete?`:
+
+```ruby
+headers = parser.parse_headers
+unless parser.complete?
+  body = parser.read_body
+end
+```
+
+The `#read_body` and `#read_body_chunk` methods will return `nil` if no body is
+expected (based on the received headers).
+
+## Parsing from arbitrary transports
+
+The H1P parser was built to read from any arbitrary transport or source, as long
+as they conform to one of two alternative interfaces:
+
+- An object implementing a `__parser_read_method__` method, which returns any of
+  the following values:
+
+  - `:stock_readpartial` - to be used for instances of `IO`, `Socket`,
+    `TCPSocket`, `SSLSocket` etc.
+  - `:backend_read` - for use in Polyphony-based servers.
+  - `:backend_recv` - for use in Polyphony-based servers.
+  - `:readpartial` - for use in Polyphony-based servers.
+
+- An object implementing a `call` method, such as a `Proc` or any other. The
+  call is given a single argument signifying the maximum number of bytes to
+  read, and is expected to return either a string with the read data, or `nil`
+  if no more data is available. The callable can be passed as an argument or as
+  a block. Here's an example for parsing from a callable:
+
+  ```ruby
+  data = ['GET ', '/foo', " HTTP/1.1\r\n", "\r\n"]
+  data = ['GET ', '/foo', " HTTP/1.1\r\n", "\r\n"]
+  parser = H1P::Parser.new { data.shift }
+  parser.parse_headers
+  #=> {":method"=>"get", ":path"=>"/foo", ":protocol"=>"http/1.1", ":rx"=>21}
+  ```
+
+## Design
+
+The H1P parser design is based on the following principles:
+
+- Implement a blocking API for use with a sequential programming style.
+- Minimize copying of data between buffers.
+- Parse each piece of data only once.
+- Minimize object and buffer allocations.
+- Minimize the API surface area.
+
+One of the unique aspects of H1P is that instead of the server needing to feed
+data to the parser, the parser itself reads data from its source whenever it
+needs more of it. If no data is yet available, the parser blocks until more data
+is received.
+
+The different parts of the request are parsed one byte at a time, and once each
+token is considered complete, it is copied from the buffer into a new string, to
+be stored in the headers hash.
+
+## Performance
+
+The included benchmark (against
+[http_parser.rb](https://github.com/tmm1/http_parser.rb), based on the *old*
+[node.js HTTP parser](https://github.com/nodejs/http-parser)) shows the H1P
+parser to be about 10-20% slower than http_parser.rb.
+
+However, in a fiber-based environment such as
+[Polyphony](https://github.com/digital-fabric/polyphony), H1P is slightly
+faster, as the overhead of dealing with pipelined requests (which will cause
+`http_parser.rb` to emit callbacks multiple times) significantly affects its
+performance.
+
+## Roadmap
+
+Here are some of the features and enhancements planned for H1P:
+
+- Add conformance and security tests
+- Add ability to parse HTTP/1 responses (for implementing HTTP clients)
+- Add ability to splice the request body into an arbitrary fd
+  (Polyphony-specific)
+- Improve performance
+
+## Contributing
+
+Issues and pull requests will be gladly accepted. If you have found this gem
+useful, please let me know.

data/benchmarks/bm_http1_parser.rb

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
+HTTP_REQUEST = "GET /foo HTTP/1.1\r\nHost: example.com\r\nAccept: */*\r\nUser-Agent: foobar\r\n\r\n"
 
-HTTP_REQUEST = "GET /foo HTTP/1.1\r\nHost: example.com\r\nAccept: */*\r\n\r\n"
+# HTTP_REQUEST =
+#   "GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1\r\n" +
+#   "Host: www.kittyhell.com\r\n" +
+#   "User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 Pathtraq/0.9\r\n" +
+#   "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n" +
+#   "Accept-Language: ja,en-us;q=0.7,en;q=0.3\r\n" +
+#   "Accept-Encoding: gzip,deflate\r\n" +
+#   "Accept-Charset: Shift_JIS,utf-8;q=0.7,*;q=0.7\r\n" +
+#   "Keep-Alive: 115\r\n" +
+#   "Connection: keep-alive\r\n" +
+#   "Cookie: wp_ozh_wsa_visits=2; wp_ozh_wsa_visit_lasttime=xxxxxxxxxx; __utma=xxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.x; __utmz=xxxxxxxxx.xxxxxxxxxx.x.x.utmccn=(referral)|utmcsr=reader.livedoor.com|utmcct=/reader/|utmcmd=referral\r\n\r\n"
 
 def measure_time_and_allocs
   4.times { GC.start }
@@ -31,10 +41,12 @@ def benchmark_other_http1_parser(iterations)
   parser = Http::Parser.new
   done = false
   headers = nil
+  rx = 0
   parser.on_headers_complete = proc do |h|
     headers = h
     headers[':method'] = parser.http_method
     headers[':path'] = parser.request_url
+    headers[':rx'] = rx
   end
   parser.on_message_complete = proc { done = true }
 
@@ -42,8 +54,10 @@ def benchmark_other_http1_parser(iterations)
     iterations.times do
       o << HTTP_REQUEST
       done = false
+      rx = 0
       while !done
         msg = i.readpartial(4096)
+        rx += msg.bytesize
         parser << msg
       end
     end
@@ -52,11 +66,10 @@ def benchmark_other_http1_parser(iterations)
 end
 
 def benchmark_tipi_http1_parser(iterations)
-  STDOUT << "tipi parser: "
-  require_relative '../lib/tipi_ext'
+  STDOUT << "H1P parser: "
+  require_relative '../lib/h1p'
   i, o = IO.pipe
-  reader = proc { |len| i.readpartial(len) }
-  parser = Tipi::HTTP1Parser.new(reader)
+  parser = H1P::Parser.new(i)
 
   elapsed, allocated = measure_time_and_allocs do
     iterations.times do
@@ -78,8 +91,8 @@ def fork_benchmark(method, iterations)
   Process.wait(pid)
 end
 
-x = 500000
-# fork_benchmark(:benchmark_other_http1_parser, x)
-# fork_benchmark(:benchmark_tipi_http1_parser, x)
+x = 100000
+fork_benchmark(:benchmark_other_http1_parser, x)
+fork_benchmark(:benchmark_tipi_http1_parser, x)
 
-benchmark_tipi_http1_parser(x)
+# benchmark_tipi_http1_parser(x)

data/examples/callable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'h1p'
+
+data = ['GET ', '/foo', " HTTP/1.1\r\n", "\r\n"]
+parser = H1P::Parser.new(proc { data.shift })
+
+headers = parser.parse_headers
+p headers

data/examples/http_server.rb

@@ -1,41 +1,39 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'tipi'
-
-opts = {
-  reuse_addr:  true,
-  dont_linger: true
-}
+require 'h1p'
 
 puts "pid: #{Process.pid}"
-puts 'Listening on port 10080...'
+puts 'Listening on port 1234...'
 
-# GC.disable
-# Thread.current.backend.idle_gc_period = 60
+trap('SIGINT') { exit! }
 
-spin_loop(interval: 10) { p Thread.backend.stats }
+def handle_client(conn)
+  Thread.new do
+    parser = H1P::Parser.new(conn)
+    loop do
+      headers = parser.parse_headers
+      break unless headers
 
-spin_loop(interval: 10) do
-  GC.compact
-end
+      req_body = parser.read_body
+      
+      p headers: headers
+      p body: req_body
 
-spin do
-  Tipi.serve('0.0.0.0', 10080, opts) do |req|
-    if req.path == '/stream'
-      req.send_headers('Foo' => 'Bar')
-      sleep 1
-      req.send_chunk("foo\n")
-      sleep 1
-      req.send_chunk("bar\n")
-      req.finish
-    elsif req.path == '/upload'
-      body = req.read
-      req.respond("Body: #{body.inspect} (#{body.bytesize} bytes)")
-    else
-      req.respond("Hello world!\n")
+      resp = 'Hello, world!'
+      conn << "HTTP/1.1 200 OK\r\nContent-Length: #{resp.bytesize}\r\n\r\n#{resp}"
+    rescue H1P::Error => e
+      puts "Invalid request: #{e.message}"
+    ensure
+      conn.close
+      break
     end
-#    p req.transfer_counts
   end
-  p 'done...'
-end.await
+end
+
+require 'socket'
+server = TCPServer.new('0.0.0.0', 1234)
+loop do
+  conn = server.accept
+  handle_client(conn)
+end

data/ext/h1p/h1p.c

@@ -24,6 +24,7 @@ ID ID_parser_read_method;
 ID ID_read;
 ID ID_readpartial;
 ID ID_to_i;
+ID ID_upcase;
 
 static VALUE mPolyphony = Qnil;
 static VALUE cError;
@@ -145,6 +146,7 @@ VALUE Parser_initialize(VALUE self, VALUE io) {
 ////////////////////////////////////////////////////////////////////////////////
 
 #define str_downcase(str) (rb_funcall((str), ID_downcase, 0))
+#define str_upcase(str) (rb_funcall((str), ID_upcase, 0))
 
 #define FILL_BUFFER_OR_GOTO_EOF(state) { if (!fill_buffer(state)) goto eof; }
 
@@ -155,6 +157,7 @@ VALUE Parser_initialize(VALUE self, VALUE io) {
 #define BUFFER_PTR(state, pos) ((state)->ptr + pos)
 #define BUFFER_STR(state, pos, len) (rb_obj_freeze(rb_utf8_str_new((state)->ptr + pos, len)))
 #define BUFFER_STR_DOWNCASE(state, pos, len) (rb_obj_freeze(str_downcase(rb_utf8_str_new((state)->ptr + pos, len))))
+#define BUFFER_STR_UPCASE(state, pos, len) (rb_obj_freeze(str_upcase(rb_utf8_str_new((state)->ptr + pos, len))))
 
 #define INC_BUFFER_POS(state) { \
   BUFFER_POS(state)++; \
@@ -209,6 +212,12 @@ VALUE Parser_initialize(VALUE self, VALUE io) {
   RB_GC_GUARD(value); \
 }
 
+#define SET_HEADER_UPCASE_VALUE_FROM_BUFFER(state, headers, key, pos, len) { \
+  VALUE value = BUFFER_STR_UPCASE(state, pos, len); \
+  rb_hash_aset(headers, key, value); \
+  RB_GC_GUARD(value); \
+}
+
 #define CONSUME_CRLF(state) { \
   INC_BUFFER_POS(state); \
   if (BUFFER_CUR(state) != '\n') goto bad_request; \
@@ -335,7 +344,7 @@ static inline int parse_method(struct parser_state *state, VALUE headers) {
     }
   }
 done:
-  SET_HEADER_DOWNCASE_VALUE_FROM_BUFFER(state, headers, STR_pseudo_method, pos, len);
+  SET_HEADER_UPCASE_VALUE_FROM_BUFFER(state, headers, STR_pseudo_method, pos, len);
   return 1;
 bad_request:
   RAISE_BAD_REQUEST("Invalid method");
@@ -834,6 +843,7 @@ void Init_H1P() {
   ID_read                   = rb_intern("read");
   ID_readpartial            = rb_intern("readpartial");
   ID_to_i                   = rb_intern("to_i");
+  ID_upcase                 = rb_intern("upcase");
 
   NUM_max_headers_read_length = INT2NUM(MAX_HEADERS_READ_LENGTH);
   NUM_buffer_start = INT2NUM(0);

data/h1p.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.6'
 
   s.add_development_dependency  'rake-compiler',        '1.1.1'
-  s.add_development_dependency  'rake',               '~>12.3.3'
-  s.add_development_dependency  'minitest',           '~>5.11.3'
-  s.add_development_dependency  'minitest-reporters', '~>1.4.2'
+  s.add_development_dependency  'rake',               '~>13.0.6'
+  s.add_development_dependency  'minitest',           '~>5.14.4'
 end

data/lib/h1p.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'h1p_ext'
+require_relative './h1p_ext'
 
 unless Object.const_defined?('Polyphony')
   class IO

data/lib/h1p/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module H1P
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/test/helper.rb

@@ -5,7 +5,6 @@ require 'bundler/setup'
 require 'fileutils'
 
 require 'minitest/autorun'
-require 'minitest/reporters'
 
 module Minitest::Assertions
   def assert_in_range exp_range, act

data/test/test_h1p.rb

@@ -22,7 +22,7 @@ class H1PTest < MiniTest::Test
 
     assert_equal(
       {
-        ':method' => 'get',
+        ':method' => 'GET',
         ':path' => '/',
         ':protocol' => 'http/1.1',
         ':rx' => msg.bytesize
@@ -38,7 +38,7 @@ class H1PTest < MiniTest::Test
 
     assert_equal(
       {
-        ':method' => 'get',
+        ':method' => 'GET',
         ':path' => '/',
         ':protocol' => 'http/1.1',
         ':rx' => msg.bytesize
@@ -57,17 +57,17 @@ class H1PTest < MiniTest::Test
   def test_method_case
     @o << "GET / HTTP/1.1\r\n\r\n"
     headers = @parser.parse_headers
-    assert_equal 'get', headers[':method']
+    assert_equal 'GET', headers[':method']
 
     reset_parser
     @o << "post / HTTP/1.1\r\n\r\n"
     headers = @parser.parse_headers
-    assert_equal 'post', headers[':method']
+    assert_equal 'POST', headers[':method']
 
     reset_parser
     @o << "PoST / HTTP/1.1\r\n\r\n"
     headers = @parser.parse_headers
-    assert_equal 'post', headers[':method']
+    assert_equal 'POST', headers[':method']
   end
 
   def test_bad_method
@@ -80,7 +80,7 @@ class H1PTest < MiniTest::Test
 
     reset_parser
     @o << "#{'a' * max_length} / HTTP/1.1\r\n\r\n"
-    assert_equal 'a' * max_length, @parser.parse_headers[':method']
+    assert_equal 'A' * max_length, @parser.parse_headers[':method']
 
     reset_parser
     @o << "#{'a' * (max_length + 1)} / HTTP/1.1\r\n\r\n"
@@ -245,7 +245,7 @@ class H1PTest < MiniTest::Test
     @o << msg
     headers = @parser.parse_headers
     assert_equal({
-      ':method'   => 'get',
+      ':method'   => 'GET',
       ':path'     => '/foo',
       ':protocol' => 'http/1.1',
       'bar'       => 'baz',
@@ -534,7 +534,7 @@ class H1PTest < MiniTest::Test
     client << msg
     reply = client.read
     assert_equal({
-      ':method' => 'get',
+      ':method' => 'GET',
       ':path' => '/foo',
       ':protocol' => 'http/1.1',
       'cookie' => 'abc=def',
@@ -560,7 +560,7 @@ class H1PTest < MiniTest::Test
 
     headers = parser.parse_headers
     assert_equal({
-      ':method' => 'get',
+      ':method' => 'GET',
       ':path' => '/foo',
       ':protocol' => 'http/1.1',
       'host' => 'bar',
@@ -572,7 +572,7 @@ class H1PTest < MiniTest::Test
     request = +"GET /bar HTTP/1.1\r\nHost: baz\r\n\r\n"
     headers = parser.parse_headers
     assert_equal({
-      ':method' => 'get',
+      ':method' => 'GET',
       ':path' => '/bar',
       ':protocol' => 'http/1.1',
       'host' => 'baz',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h1p
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-19 00:00:00.000000000 Z
+date: 2021-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -30,42 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: 13.0.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: 13.0.6
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.11.3
+        version: 5.14.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.11.3
-- !ruby/object:Gem::Dependency
-  name: minitest-reporters
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: 5.14.4
 description: 
 email: sharon@noteflakes.com
 executables: []
@@ -84,6 +70,7 @@ files:
 - Rakefile
 - TODO.md
 - benchmarks/bm_http1_parser.rb
+- examples/callable.rb
 - examples/http_server.rb
 - ext/h1p/extconf.rb
 - ext/h1p/h1p.c
@@ -118,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: H1P is a blocking HTTP/1 parser for Ruby