puma-http1 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 833fbce5f9dc90feed1f860e3fa34424fdcd2ba444e5663c3f575f096164c278
+  data.tar.gz: 241a9909f7898a5ddbde2706833d85544ce65de1a0c4af92940720507f7d3b60
+SHA512:
+  metadata.gz: d167920f38c3c0c156e5cd82450f19ef2c040e87582cb34e6561e548eb8577e9313a32805cd52629c0d1c6be10212b0958a8f267e130d70fc97928e2278478ce
+  data.tar.gz: 53a5d316e0b4e49e68f2907bcdf088c84d1d9c21bd76b988c8f8b3833217901a60ccc20caed03681b05bfe2b0af76bcfdc82877f82b57e9f89c5c2a9f752496d

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [Unreleased]
+
+## [0.0.1] - 2026-09-26
+
+The first release, an early version of a reference implementation for Puma's proposed `http_parser` option.
+
+- Add `Puma::HTTP1::Parser`, a Ruby port of the HTTP parser in Puma's `puma_http11` C extension, for Puma's proposed `http_parser` option
+- Add an example app that runs Puma with `Puma::HTTP1::Parser`, with and without `puma_http11`
+- Add `script/benchmark`, comparing parsing time with `Puma::HttpParser`
+- Add `script/benchmark-server`, comparing requests per second with ApacheBench, and the results of a run on Ruby 4.0.7
+- Add `script/test-puma-suite`, running Puma's own tests with `Puma::HTTP1::Parser`, and run it in CI
+- Write the tests in minitest, like Puma's own test suite

data/LICENSE.md

@@ -0,0 +1,32 @@
+# BSD 3-Clause License
+
+Copyright (c) 2026, Shane Becker.
+
+Ported from Puma, Copyright (c) 2019, Evan Phoenix. Some code by Zed Shaw, (c) 2005.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,103 @@
+# puma-http1
+
+An HTTP/1.x parser for [Puma](https://github.com/puma/puma), written in Ruby.
+
+`Puma::HTTP1::Parser` is a drop-in for `Puma::HttpParser`, the parser in Puma’s `puma_http11` C extension. It follows the same Ragel grammar state for state, fills the same env keys, enforces the same length limits, and raises the same errors with the same messages. The tests run every request through both parsers and expect the same result.
+
+[`script/test-puma-suite`](script/test-puma-suite) also runs Puma’s own tests with `Puma::HTTP1::Parser` in place of `Puma::HttpParser`. The only failures are two tests that check the header names in Puma’s “Bad headers” error message, explained [below](#differences-from-pumahttpparser). It skips Puma’s integration tests, which start Puma as a separate process and so always use the C parser. CI runs it on every push.
+
+With it, Puma can run where its C extension can't be built or loaded.
+
+## Status
+
+This is an early reference implementation for a proposed `http_parser` option in Puma. That option isn't in a Puma release yet, so this gem needs Puma from the `pluggable-http-parser` branch of [veganstraightedge/puma](https://github.com/veganstraightedge/puma/tree/pluggable-http-parser).
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'puma',       github: 'veganstraightedge/puma', branch: 'pluggable-http-parser'
+gem 'puma-http1'
+```
+
+## Usage
+
+Require the gem and pass the parser class to Puma’s `http_parser` option.
+
+```ruby
+# config/puma.rb
+require 'puma/http1'
+
+http_parser Puma::HTTP1::Parser
+```
+
+Puma’s [HTTP parser documentation](https://github.com/veganstraightedge/puma/blob/pluggable-http-parser/docs/http_parser.md) describes the interface a parser has to follow.
+
+The gem is named `puma-http1`, and the module `Puma::HTTP1`, rather than `Puma::HTTP`, because `Puma::Const::HTTP` already exists. Puma’s code refers to it without the `Const::` prefix, so a `Puma::HTTP` module would be found first and break Puma.
+
+### Without the C extension
+
+When Puma’s `puma_http11` extension can't be loaded, Puma still starts, as long as `http_parser` is set. SSL isn't available then, because Puma’s SSL support is in the same extension.
+
+The [example app](example) runs both ways:
+
+```sh
+$ script/example
+=== With puma_http11 installed ===
+HTTP parser: Puma::HTTP1::Parser
+puma_http11: loaded
+...
+
+=== With puma_http11 hidden ===
+HTTP parser: Puma::HTTP1::Parser
+puma_http11: not loaded
+...
+```
+
+## Differences from Puma::HttpParser
+
+The C parser upcases header names inside the request buffer as it parses. This parser leaves the buffer alone. So when Puma reports a request with bad headers, the error message shows the header names as the client sent them. Puma’s Java parser, used on JRuby, also leaves the buffer alone, so this parser matches JRuby here.
+
+## Performance
+
+It’s slower than the C parser. On an Apple M1 with Ruby 4.0.7, from [`script/benchmark`](script/benchmark):
+
+| request                 | Puma::HttpParser | Puma::HTTP1::Parser | Puma::HTTP1::Parser with YJIT |
+| :---------------------- | ---------------: | ------------------: | ----------------------------: |
+| minimal GET             |             0.46 |                3.19 |                          2.79 |
+| browser GET, 13 headers |             2.81 |               17.18 |                         16.20 |
+| API POST, 7 headers     |             1.56 |               10.53 |                          9.92 |
+
+All values are microseconds per parse. Smaller is better.
+
+That’s roughly 2 to 14 µs more per request. A hello world app, with keep-alive and 4 threads, serves this many requests per second, from [`script/benchmark-server`](script/benchmark-server) using [ApacheBench](https://httpd.apache.org/docs/current/programs/ab.html):
+
+| request   | JIT  | Puma::HttpParser | Puma::HTTP1::Parser |  gap |
+| :-------- | :--- | ---------------: | ------------------: | ---: |
+| minimal   | none |           26,815 |              23,009 | -14% |
+| 9 headers | none |           25,145 |              18,500 | -26% |
+| minimal   | YJIT |           30,234 |              26,998 | -11% |
+| 9 headers | YJIT |           28,270 |              22,323 | -21% |
+
+All values are requests per second, except the gap, which is how much slower `Puma::HTTP1::Parser` is. Larger is better for requests per second. Smaller is better for the gap.
+
+In an app doing real work per request, the difference should be a small fraction of the total.
+
+The complete output of these runs, with every sample, the commits measured, and the machine's load, is in [benchmarks/2026-09-26-ruby-4.0.7.md](benchmarks/2026-09-26-ruby-4.0.7.md).
+
+## Development
+
+```sh
+script/setup             # install dependencies, for the gem and the example app
+script/test              # run the tests and RuboCop
+script/test-puma-suite   # run Puma's own tests with Puma::HTTP1::Parser
+script/example           # run the example app with and without puma_http11
+script/server            # run the example app on port 9292
+script/benchmark         # compare parsing time with Puma::HttpParser
+script/benchmark-server  # compare requests per second, with ApacheBench
+script/console           # start IRB with the gem loaded
+```
+
+## License
+
+BSD 3-Clause, the same as Puma. The parser is ported from Puma’s C extension, so the license keeps Puma’s copyright notice. See [LICENSE.md](LICENSE.md).

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |task|
+  task.libs << "test"
+  task.test_files = FileList["test/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/puma/http1/parser.rb

@@ -0,0 +1,565 @@
+# frozen_string_literal: true
+
+module Puma
+  # Puma defines this too. Defining it here, with the same superclass, lets
+  # the parser run without Puma loaded.
+  class HttpParserError < StandardError; end
+
+  module HTTP1
+    # Ruby port of the HTTP parser in Puma's `puma_http11` C extension
+    # (`ext/puma_http11` in Puma).
+    #
+    # It is a streaming state machine that mirrors the Ragel grammar in
+    # `ext/puma_http11/http11_parser_common.rl`, one state per grammar element.
+    # `execute` may be called repeatedly with a growing buffer and the byte
+    # offset returned by the previous call; the parser resumes where it left off.
+    #
+    # Behavior matches the C extension byte for byte, with one deliberate
+    # exception: the C extension upcases header names inside the caller's
+    # buffer as a side effect of parsing. This implementation never modifies
+    # the buffer.
+    class Parser
+      TAB = 9
+      LF = 10
+      CR = 13
+      SPACE = 32
+      HASH = 35
+      STAR = 42
+      DOT = 46
+      SLASH = 47
+      COLON = 58
+      QUESTION = 63
+
+      # Byte lookup tables (index 0..255) for the character classes in the grammar.
+      CONTROL_BYTES = (0..31).to_a << 127
+      URI_EXCLUDED_BYTES = CONTROL_BYTES + " \"#<>".bytes
+
+      # uchar | reserved
+      URI_BYTE = Array.new(256) { !URI_EXCLUDED_BYTES.include?(it) }.freeze
+      # pchar | "/"
+      PATH_BYTE = URI_BYTE.each_with_index.map { |allowed, byte| allowed && byte != QUESTION }.freeze
+      # alpha | digit | "+" | "-" | "."
+      SCHEME_BYTE = Array.new(256) do
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.".bytes.include?(it)
+      end.freeze
+      # upper | digit | safe
+      METHOD_BYTE = Array.new(256) { "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$-_.".bytes.include?(it) }.freeze
+      DIGIT_BYTE = Array.new(256) { "0123456789".bytes.include?(it) }.freeze
+      TSPECIAL_BYTES = "()<>@,;:\\\"/[]?={} \t".bytes
+      # token = ascii -- (CTL | tspecials)
+      FIELD_NAME_BYTE = Array.new(256) do
+        it < 128 && !CONTROL_BYTES.include?(it) && !TSPECIAL_BYTES.include?(it)
+      end.freeze
+      # (any -- CTL) | "\t"
+      FIELD_VALUE_BYTE = Array.new(256) { it == TAB || !CONTROL_BYTES.include?(it) }.freeze
+
+      # The first byte that ends a run of each class above, so that a run can be
+      # skipped with one String#index call instead of a Ruby loop over each byte.
+      # Each must agree with its table; test/test_parser.rb checks that.
+      METHOD_RUN_END = /[^A-Z0-9$\-_.]/n
+      SCHEME_RUN_END = /[^A-Za-z0-9+\-.]/n
+      URI_RUN_END = /[\x00-\x20"#<>\x7f]/n
+      PATH_RUN_END = /[\x00-\x20"#<>?\x7f]/n
+      FIELD_NAME_RUN_END = /[^!#$%&'*+\-.0-9A-Z^_`a-z|~]/n
+      FIELD_VALUE_RUN_END = /[\x00-\x08\x0a-\x1f\x7f]/n
+
+      # A complete header line, using the same byte classes as FIELD_NAME_BYTE
+      # and FIELD_VALUE_BYTE, so that a whole line can be handled in one match.
+      # Lines that don't match, because they are incomplete or invalid, take the
+      # byte by byte path through the states below.
+      HEADER_LINE = /\G([!#$%&'*+\-.0-9A-Z^_`a-z|~]+): *([^\x00-\x08\x0a-\x1f\x7f]*)\r\n/n
+
+      METHOD_MAX_LENGTH = 20
+      PROTOCOL_PREFIX = "HTTP/"
+      HTTP_PREFIX = "HTTP_"
+
+      # Env keys for the headers we expect to receive, so that parsing them
+      # allocates no key strings. CONTENT_LENGTH and CONTENT_TYPE have no HTTP_
+      # prefix, following the CGI convention.
+      COMMON_FIELDS = {
+        "ACCEPT" => "HTTP_ACCEPT",
+        "ACCEPT_CHARSET" => "HTTP_ACCEPT_CHARSET",
+        "ACCEPT_ENCODING" => "HTTP_ACCEPT_ENCODING",
+        "ACCEPT_LANGUAGE" => "HTTP_ACCEPT_LANGUAGE",
+        "ALLOW" => "HTTP_ALLOW",
+        "AUTHORIZATION" => "HTTP_AUTHORIZATION",
+        "CACHE_CONTROL" => "HTTP_CACHE_CONTROL",
+        "CONNECTION" => "HTTP_CONNECTION",
+        "CONTENT_ENCODING" => "HTTP_CONTENT_ENCODING",
+        "CONTENT_LENGTH" => "CONTENT_LENGTH",
+        "CONTENT_TYPE" => "CONTENT_TYPE",
+        "COOKIE" => "HTTP_COOKIE",
+        "DATE" => "HTTP_DATE",
+        "EXPECT" => "HTTP_EXPECT",
+        "FROM" => "HTTP_FROM",
+        "HOST" => "HTTP_HOST",
+        "IF_MATCH" => "HTTP_IF_MATCH",
+        "IF_MODIFIED_SINCE" => "HTTP_IF_MODIFIED_SINCE",
+        "IF_NONE_MATCH" => "HTTP_IF_NONE_MATCH",
+        "IF_RANGE" => "HTTP_IF_RANGE",
+        "IF_UNMODIFIED_SINCE" => "HTTP_IF_UNMODIFIED_SINCE",
+        "KEEP_ALIVE" => "HTTP_KEEP_ALIVE",
+        "MAX_FORWARDS" => "HTTP_MAX_FORWARDS",
+        "PRAGMA" => "HTTP_PRAGMA",
+        "PROXY_AUTHORIZATION" => "HTTP_PROXY_AUTHORIZATION",
+        "RANGE" => "HTTP_RANGE",
+        "REFERER" => "HTTP_REFERER",
+        "TE" => "HTTP_TE",
+        "TRAILER" => "HTTP_TRAILER",
+        "TRANSFER_ENCODING" => "HTTP_TRANSFER_ENCODING",
+        "UPGRADE" => "HTTP_UPGRADE",
+        "USER_AGENT" => "HTTP_USER_AGENT",
+        "VIA" => "HTTP_VIA",
+        "WARNING" => "HTTP_WARNING",
+        "X_FORWARDED_FOR" => "HTTP_X_FORWARDED_FOR",
+        "X_REAL_IP" => "HTTP_X_REAL_IP"
+      }.freeze
+
+      REQUEST_METHOD = "REQUEST_METHOD"
+      REQUEST_URI = "REQUEST_URI"
+      FRAGMENT = "FRAGMENT"
+      QUERY_STRING = "QUERY_STRING"
+      SERVER_PROTOCOL = "SERVER_PROTOCOL"
+      REQUEST_PATH = "REQUEST_PATH"
+
+      INVALID_FORMAT_MESSAGE = "Invalid HTTP format, parsing fails. " \
+                               "Are you trying to open an SSL connection to a non-SSL Puma?"
+
+      # Maximum allowed lengths of the request elements, and their error messages.
+      # The messages spell the limits exactly as the C extension does, where they
+      # come from the macro text, e.g. "(1024 * 12)". Tests assert on them.
+      MAX_FIELD_NAME_LENGTH = 256
+      MAX_FIELD_NAME_LENGTH_ERR = "HTTP element FIELD_NAME is longer than the 256 allowed length (was %d)"
+      MAX_FIELD_VALUE_LENGTH = 80 * 1024
+      MAX_FIELD_VALUE_LENGTH_ERR = "HTTP element FIELD_VALUE is longer than the 80 * 1024 allowed length (was %d)"
+      MAX_REQUEST_URI_LENGTH = 1024 * 12
+      MAX_REQUEST_URI_LENGTH_ERR = "HTTP element REQUEST_URI is longer than the (1024 * 12) allowed length (was %d)"
+      MAX_FRAGMENT_LENGTH = 1024
+      MAX_FRAGMENT_LENGTH_ERR = "HTTP element FRAGMENT is longer than the 1024 allowed length (was %d)"
+      MAX_REQUEST_PATH_LENGTH = 8192
+      MAX_REQUEST_PATH_LENGTH_ERR = "HTTP element REQUEST_PATH is longer than the (8192) allowed length (was %d)"
+      MAX_QUERY_STRING_LENGTH = 1024 * 10
+      MAX_QUERY_STRING_LENGTH_ERR = "HTTP element QUERY_STRING is longer than the (1024 * 10) allowed length (was %d)"
+      MAX_HEADER_LENGTH = 1024 * (80 + 32)
+      MAX_HEADER_LENGTH_ERR = "HTTP element HEADER is longer than the (1024 * (80 + 32)) allowed length (was %d)"
+
+      def initialize
+        reset
+      end
+
+      # Resets the parser to its initial state so that it can be reused
+      # rather than making new ones.
+      def reset
+        @state = :method
+        @nread = 0
+        @mark = 0
+        @query_start = 0
+        @field_start = 0
+        @field_len = 0
+        @body_start = 0
+        @body = nil
+        @env = nil
+        nil
+      end
+
+      # Finishes a parser early. You should call reset after finish.
+      # The name comes from Puma::HttpParser.
+      def finish # rubocop:disable Naming/PredicateMethod
+        finished?
+      end
+
+      def error?
+        @state == :error
+      end
+
+      def finished?
+        @state == :done
+      end
+
+      # The amount of data processed so far during this processing cycle.
+      # It is 0 after initialize or reset and is incremented by each execute.
+      attr_reader :nread
+
+      # If the request included a body, returns it.
+      attr_reader :body
+
+      # Takes a Hash and a String of data, parses the String of data filling in
+      # the Hash, returning an Integer to indicate how much of the data has been
+      # read. Raises HttpParserError when the data is not valid HTTP.
+      #
+      # The third argument allows for parsing a partial request and then
+      # continuing the parsing from that position. It needs all of the original
+      # data as well, so you have to append to the data buffer as you read.
+      def execute(env, data, start)
+        raise HttpParserError, "Requested start is after data buffer end." if start >= data.bytesize
+
+        @env = env
+        # Operate on bytes, like the C extension does.
+        @data = data.encoding == Encoding::BINARY ? data : data.b
+        stopped_at = run(start, @data.bytesize)
+        @nread += stopped_at - start
+
+        validate_max_length(@nread, MAX_HEADER_LENGTH, MAX_HEADER_LENGTH_ERR)
+        raise HttpParserError, INVALID_FORMAT_MESSAGE if error?
+
+        @nread
+      end
+
+      private
+
+      # Runs the state machine over @data from position `from` up to `to`.
+      # Returns the position it stopped at: `to` when more data is needed,
+      # one past the final LF when done, or the offending byte on error.
+      def run(from, to)
+        state = @state
+        position = from
+
+        while position < to
+          byte = @data.getbyte(position)
+
+          case state
+          when :method
+            if METHOD_BYTE[byte]
+              position = [end_of_run(METHOD_RUN_END, position), @mark + METHOD_MAX_LENGTH].min
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            if byte == SPACE && position > @mark
+              request_method(position)
+              state = :uri_start
+            else
+              state = :error
+              break
+            end
+          when :uri_start
+            @mark = position
+            if byte == SLASH then state = :path
+            elsif byte == STAR then state = :uri_star
+            elsif byte == COLON then state = :absolute_uri
+            elsif SCHEME_BYTE[byte] then state = :scheme
+            else
+              state = :error
+              break
+            end
+          when :uri_star
+            if byte == SPACE
+              request_uri(position)
+              state = :protocol_start
+            elsif byte == HASH
+              request_uri(position)
+              state = :fragment_start
+            else
+              state = :error
+              break
+            end
+          when :scheme
+            if SCHEME_BYTE[byte]
+              position = end_of_run(SCHEME_RUN_END, position)
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            if byte == COLON
+              state = :absolute_uri
+            else
+              state = :error
+              break
+            end
+          when :absolute_uri
+            if URI_BYTE[byte]
+              position = end_of_run(URI_RUN_END, position)
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            if byte == SPACE
+              request_uri(position)
+              state = :protocol_start
+            elsif byte == HASH
+              request_uri(position)
+              state = :fragment_start
+            else
+              state = :error
+              break
+            end
+          when :path
+            if PATH_BYTE[byte]
+              position = end_of_run(PATH_RUN_END, position)
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            case byte
+            when QUESTION
+              request_path(position)
+              @query_start = position + 1
+              state = :query
+            when SPACE
+              request_path(position)
+              request_uri(position)
+              state = :protocol_start
+            when HASH
+              request_path(position)
+              request_uri(position)
+              state = :fragment_start
+            else
+              state = :error
+              break
+            end
+          when :query
+            if URI_BYTE[byte]
+              position = end_of_run(URI_RUN_END, position)
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            if byte == SPACE
+              query_string(position)
+              request_uri(position)
+              state = :protocol_start
+            elsif byte == HASH
+              query_string(position)
+              request_uri(position)
+              state = :fragment_start
+            else
+              state = :error
+              break
+            end
+          when :fragment_start
+            @mark = position
+            if URI_BYTE[byte]
+              state = :fragment
+            elsif byte == SPACE
+              fragment(position)
+              state = :protocol_start
+            else
+              state = :error
+              break
+            end
+          when :fragment
+            if URI_BYTE[byte]
+              position = end_of_run(URI_RUN_END, position)
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            if byte == SPACE
+              fragment(position)
+              state = :protocol_start
+            else
+              state = :error
+              break
+            end
+          when :protocol_start
+            @mark = position
+            if byte == PROTOCOL_PREFIX.getbyte(0)
+              state = :protocol_prefix
+            else
+              state = :error
+              break
+            end
+          when :protocol_prefix
+            if byte == PROTOCOL_PREFIX.getbyte(position - @mark)
+              state = :protocol_major if position - @mark == PROTOCOL_PREFIX.bytesize - 1
+            else
+              state = :error
+              break
+            end
+          when :protocol_major
+            if DIGIT_BYTE[byte]
+              state = :protocol_major_digits
+            else
+              state = :error
+              break
+            end
+          when :protocol_major_digits
+            if DIGIT_BYTE[byte]
+              # continue
+            elsif byte == DOT
+              state = :protocol_minor
+            else
+              state = :error
+              break
+            end
+          when :protocol_minor
+            if DIGIT_BYTE[byte]
+              state = :protocol_minor_digits
+            else
+              state = :error
+              break
+            end
+          when :protocol_minor_digits
+            if DIGIT_BYTE[byte]
+              # continue
+            elsif byte == CR
+              server_protocol(position)
+              state = :request_line_lf
+            else
+              state = :error
+              break
+            end
+          when :header_lf, :request_line_lf
+            if byte == LF
+              state = :header_line
+            else
+              state = :error
+              break
+            end
+          when :header_line
+            if byte == CR
+              state = :final_lf
+            elsif FIELD_NAME_BYTE[byte]
+              if (line = HEADER_LINE.match(@data, position))
+                @field_start = position
+                @field_len = line.end(1) - position
+                @mark = line.begin(2)
+                http_field(line.end(2))
+                position = line.end(0)
+                next
+              end
+              @field_start = position
+              state = :field_name
+            else
+              state = :error
+              break
+            end
+          when :field_name
+            if FIELD_NAME_BYTE[byte]
+              position = end_of_run(FIELD_NAME_RUN_END, position)
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            if byte == COLON
+              @field_len = position - @field_start
+              state = :field_value_start
+            else
+              state = :error
+              break
+            end
+          when :field_value_start
+            if byte == SPACE
+              # leading spaces are not part of the value
+            elsif FIELD_VALUE_BYTE[byte]
+              @mark = position
+              state = :field_value
+            elsif byte == CR
+              @mark = position
+              http_field(position)
+              state = :header_lf
+            else
+              state = :error
+              break
+            end
+          when :field_value
+            if FIELD_VALUE_BYTE[byte]
+              position = end_of_run(FIELD_VALUE_RUN_END, position)
+              break if position == to
+
+              byte = @data.getbyte(position)
+            end
+            if byte == CR
+              http_field(position)
+              state = :header_lf
+            else
+              state = :error
+              break
+            end
+          when :final_lf
+            if byte == LF
+              header_done(position)
+              state = :done
+              position += 1
+            else
+              state = :error
+            end
+            break
+          when :done
+            state = :error
+            break
+          else
+            break
+          end
+
+          position += 1
+        end
+
+        @state = state
+        position
+      end
+
+      # The byte at `position` is known to be in the run. Returns the position of
+      # the first byte after the run, or the end of the data.
+      def end_of_run(run_end, position)
+        @data.index(run_end, position + 1) || @data.bytesize
+      end
+
+      def validate_max_length(length, max_length, message)
+        raise HttpParserError, format(message, length) if length > max_length
+      end
+
+      def http_field(position)
+        value_length = position - @mark
+        validate_max_length(@field_len, MAX_FIELD_NAME_LENGTH, MAX_FIELD_NAME_LENGTH_ERR)
+        validate_max_length(value_length, MAX_FIELD_VALUE_LENGTH, MAX_FIELD_VALUE_LENGTH_ERR)
+
+        # Upcase, "-" becomes "_", and "_" becomes "," so that a header with
+        # underscores cannot impersonate one with dashes.
+        name = @data.byteslice(@field_start, @field_len)
+        name.upcase!
+        name.tr!("-_", "_,")
+        key = COMMON_FIELDS[name] || -"#{HTTP_PREFIX}#{name}"
+
+        value = @data.byteslice(@mark, value_length)
+        # Only spaces and tabs can be present; the grammar rejects other control bytes.
+        value.strip!
+
+        existing = @env[key]
+        if existing.nil?
+          @env[key] = value
+        else
+          # duplicate headers are normalized to comma-separated values
+          existing << ", " << value
+        end
+      end
+
+      def request_method(position)
+        @env[REQUEST_METHOD] = @data.byteslice(@mark, position - @mark)
+      end
+
+      def request_uri(position)
+        length = position - @mark
+        validate_max_length(length, MAX_REQUEST_URI_LENGTH, MAX_REQUEST_URI_LENGTH_ERR)
+        @env[REQUEST_URI] = @data.byteslice(@mark, length)
+      end
+
+      def fragment(position)
+        length = position - @mark
+        validate_max_length(length, MAX_FRAGMENT_LENGTH, MAX_FRAGMENT_LENGTH_ERR)
+        @env[FRAGMENT] = @data.byteslice(@mark, length)
+      end
+
+      def request_path(position)
+        length = position - @mark
+        validate_max_length(length, MAX_REQUEST_PATH_LENGTH, MAX_REQUEST_PATH_LENGTH_ERR)
+        @env[REQUEST_PATH] = @data.byteslice(@mark, length)
+      end
+
+      def query_string(position)
+        length = position - @query_start
+        validate_max_length(length, MAX_QUERY_STRING_LENGTH, MAX_QUERY_STRING_LENGTH_ERR)
+        @env[QUERY_STRING] = @data.byteslice(@query_start, length)
+      end
+
+      def server_protocol(position)
+        @env[SERVER_PROTOCOL] = @data.byteslice(@mark, position - @mark)
+      end
+
+      def header_done(position)
+        @body_start = position + 1
+        @body = @data.byteslice(@body_start, @data.bytesize - @body_start)
+      end
+    end
+  end
+end

data/lib/puma/http1/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Puma
+  module HTTP1
+    VERSION = "0.0.1"
+  end
+end

data/lib/puma/http1.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "http1/version"
+require_relative "http1/parser"
+
+module Puma
+  # An HTTP/1.x parser for Puma, written in Ruby. Use it with Puma's
+  # `http_parser` option:
+  #
+  #   require "puma/http1"
+  #   http_parser Puma::HTTP1::Parser
+  #
+  # It's named HTTP1, not HTTP, because Puma::Const::HTTP exists, and Puma's
+  # code refers to it without the Const:: prefix. A Puma::HTTP module would be
+  # found first and break Puma.
+  module HTTP1
+  end
+end

data/sig/puma/http1.rbs

@@ -0,0 +1,6 @@
+module Puma
+  module HTTP1
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: puma-http1
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shane Becker
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A drop-in for the HTTP parser in Puma's puma_http11 C extension, for
+  use with Puma's http_parser option.
+email:
+- veganstraightedge@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/puma/http1.rb
+- lib/puma/http1/parser.rb
+- lib/puma/http1/version.rb
+- sig/puma/http1.rbs
+homepage: https://github.com/veganstraightedge/puma-http1
+licenses:
+- BSD-3-Clause
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/veganstraightedge/puma-http1
+  source_code_uri: https://github.com/veganstraightedge/puma-http1
+  changelog_uri: https://github.com/veganstraightedge/puma-http1/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.21
+specification_version: 4
+summary: An HTTP parser for Puma, written in Ruby.
+test_files: []