h1p 0.5 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53aadd6f6c4ae112ff844b68e8325fe334d51dd0a09bb11cc54d017190e97677
-  data.tar.gz: e9f6d504813d74c050a46b4e973e9fbc227dd790c02395a0073b62f43a7393da
+  metadata.gz: 90f7937fd6bcefdd1627c208bf73054fb3fb03a855666c7247f04aac4398d280
+  data.tar.gz: ab6a866b843beaf92137b991048db9af006f4cb5e510e211dc6ba6652bbc84a2
 SHA512:
-  metadata.gz: 3ac98c2d7e702f8cf5f9052e78e9abe486ee3ba0814c4c16fe222acdccfb5338ac9d5c9b4a5d1da2178fca65472693c94a4997cc86de05db70f13c90f1bc767e
-  data.tar.gz: 73ce78e3435eb40f3e6d46ee8eef803284e8da99f32d610dbd723c3661548a74ed454ae70e1ec02dcfbdb70aa346059fb7713eab19de3e6e6e65a4ca859926c7
+  metadata.gz: 101e6e13aeed0cf2250dbe962c0c9c9edc5bf69e6ff2a59ee0d02018992c9b76dcaa4be3ddb44bbcb2272e355278a0b717c51050a2786cc95c00fbdb23bc40fa
+  data.tar.gz: 2d3130c067d51f173873d6181b76999dd897c241dcafc5fa3f69ec0837404b2fd7e292cadc2fbf9e27003e3dfd933dc394799abf03f12187d6c80e4f2dab83d6

data/.github/workflows/test.yml

@@ -8,17 +8,18 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        ruby: [2.6, 2.7, 3.0]
+        ruby: [2.7, 3.0, 3.1, 3.2]
 
     name: >-
       ${{matrix.os}}, ${{matrix.ruby}}
 
     runs-on: ${{matrix.os}}
     steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-ruby@v1
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{matrix.ruby}}
+        bundler-cache: true
     - name: Install dependencies
       run: |
         gem install bundler

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.6 2023-01-05
+
+- Add documentation
+- Implement `H1P.send_body_chunk`
+- Implement `H1P.send_chunked_response`
+- Implement `H1P.send_response`
+
 ## 0.5 2022-03-19
 
 - Implement `Parser#splice_body_to` (#3)

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    h1p (0.5)
+    h1p (0.6)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.14.4)
+    minitest (5.17.0)
     rake (13.0.6)
-    rake-compiler (1.1.1)
+    rake-compiler (1.2.1)
       rake
 
 PLATFORMS
@@ -16,9 +16,9 @@ PLATFORMS
 
 DEPENDENCIES
   h1p!
-  minitest (~> 5.14.4)
+  minitest (~> 5.17.0)
   rake (~> 13.0.6)
-  rake-compiler (= 1.1.1)
+  rake-compiler (= 1.2.1)
 
 BUNDLED WITH
    2.2.26

data/README.md

@@ -1,4 +1,4 @@
-# H1P - a blocking HTTP/1 parser for Ruby
+# H1P - HTTP/1 tools for Ruby
 
 [![Gem Version](https://badge.fury.io/rb/h1p.svg)](http://rubygems.org/gems/h1p)
 [![H1P Test](https://github.com/digital-fabric/h1p/workflows/Tests/badge.svg)](https://github.com/digital-fabric/h1p/actions?query=workflow%3ATests)
@@ -14,9 +14,8 @@ 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.
+In addition to parsing, H1P offers APIs for formatting and writing HTTP/1
+requests and responses.
 
 ## Features
 
@@ -29,6 +28,8 @@ The H1P was originally written as part of
 - Support for **splicing** request/response bodies (when used with
   [Polyphony](https://github.com/digital-fabric/polyphony))
 - Track total incoming traffic
+- Write HTTP requests and responses to any IO instance, with support for chunked
+  transfer encoding.
 
 ## Installing
 
@@ -221,7 +222,54 @@ as they conform to one of two alternative interfaces:
   #=> {":method"=>"get", ":path"=>"/foo", ":protocol"=>"http/1.1", ":rx"=>21}
   ```
 
-## Design
+## Writing HTTP requests and responses
+
+H1P implements optimized methods for writing HTTP requests and responses to
+arbitrary IO instances. To write a response with or without a body, use
+`H1P.send_response(io, headers, body = nil)`:
+
+```ruby
+H1P.send_response(socket, { 'Some-Header' => 'header value'}, 'foobar')
+#=> "HTTP/1.1 200 OK\r\nSome-Header: header value\r\n\r\nfoobar"
+
+# The :protocol pseudo header sets the protocol in the status line:
+H1P.send_response(socket, { ':protocol' => 'HTTP/0.9' })
+#=> "HTTP/0.9 200 OK\r\n\r\n"
+
+# The :status pseudo header sets the response status:
+H1P.send_response(socket, { ':status' => '418 I\'m a teapot' })
+#=> "HTTP/1.1 418 I'm a teapot\r\n\r\n"
+```
+
+To send responses using chunked transfer encoding use
+`H1P.send_chunked_response(io, header, body = nil)`:
+
+```ruby
+H1P.send_chunked_response(socket, {}, "foobar")
+#=> "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n6\r\nfoobar\r\n0\r\n\r\n"
+```
+
+You can also call `H1P.send_chunked_response` with a block that provides the
+next chunk to send. The last chunk is signalled by returning `nil` from the
+block:
+
+```ruby
+IO.open('/path/to/file') do |f|
+  H1P.send_chunked_response(socket, {}) { f.read(CHUNK_SIZE) }
+end
+```
+
+To send individual chunks use `H1P.send_body_chunk`:
+
+```ruby
+H1P.send_body_chunk(socket, 'foo')
+#=> "3\r\nfoo\r\n"
+
+H1P.send_body_chunk(socket, nil)
+#=> "0\r\n\r\n"
+```
+
+## Parser Design
 
 The H1P parser design is based on the following principles:
 

data/ext/h1p/h1p.c

@@ -1,4 +1,3 @@
-#include "ruby.h"
 #include "h1p.h"
 
 // Security-related limits are defined in limits.rb and injected as
@@ -27,11 +26,15 @@ ID ID_read_method;
 ID ID_read;
 ID ID_readpartial;
 ID ID_to_i;
+ID ID_to_s;
 ID ID_upcase;
+ID ID_write;
 ID ID_write_method;
 
 static VALUE cError;
 
+VALUE eArgumentError;
+
 VALUE NUM_max_headers_read_length;
 VALUE NUM_buffer_start;
 VALUE NUM_buffer_end;
@@ -39,13 +42,20 @@ VALUE NUM_buffer_end;
 VALUE STR_pseudo_method;
 VALUE STR_pseudo_path;
 VALUE STR_pseudo_protocol;
+VALUE STR_pseudo_protocol_default;
 VALUE STR_pseudo_rx;
 VALUE STR_pseudo_status;
+VALUE STR_pseudo_status_default;
 VALUE STR_pseudo_status_message;
 
 VALUE STR_chunked;
 VALUE STR_content_length;
+VALUE STR_content_length_capitalized;
 VALUE STR_transfer_encoding;
+VALUE STR_transfer_encoding_capitalized;
+
+VALUE STR_CRLF;
+VALUE STR_EMPTY_CHUNK;
 
 VALUE SYM_backend_read;
 VALUE SYM_backend_recv;
@@ -125,7 +135,7 @@ static VALUE Parser_allocate(VALUE klass) {
 #define GetParser(obj, parser) \
   TypedData_Get_Struct((obj), Parser_t, &Parser_type, (parser))
 
-static inline VALUE Polyphony() {
+static inline VALUE Polyphony(void) {
   static VALUE mPolyphony = Qnil;
   if (mPolyphony == Qnil) {
     mPolyphony = rb_const_get(rb_cObject, rb_intern("Polyphony"));
@@ -166,6 +176,12 @@ enum parser_mode parse_parser_mode(VALUE mode) {
   rb_raise(rb_eRuntimeError, "Invalid parser mode specified");
 }
 
+/* call-seq:
+ *   parser.initialize(io, mode)
+ *
+ * Initializes a new parser with the given IO instance and mode. Mode is either
+ * `:server` or `:client`.
+ */
 VALUE Parser_initialize(VALUE self, VALUE io, VALUE mode) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -706,6 +722,19 @@ eof:
   return 0;
 }
 
+/* call-seq: parser.parse_headers -> headers
+ *
+ * Parses headers from the associated IO instance, returning a hash mapping
+ * header keys to their respective values. Header keys are downcased and dashes
+ * are converted to underscores. The returned headers will also include the
+ * following pseudo-headers:
+ * 
+ * - `':protocol'` - the protocol as specified in the query line / status line
+ * - `':path'` - the query path (for HTTP requests)
+ * - `':method'` - the HTTP method (for HTTP requests)
+ * - `':status'` - the HTTP status (for HTTP responses)
+ * - `':rx'` - the total number of bytes read by the parser
+ */
 VALUE Parser_parse_headers(VALUE self) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -1016,7 +1045,6 @@ void splice_body_with_content_length(Parser_t *parser, VALUE dest, enum write_me
     parser->current_request_rx += spliced;
     parser->body_left -= spliced;
   }
-done:
   rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
   return;
 eof:
@@ -1056,14 +1084,29 @@ static inline VALUE read_body(VALUE self, int read_entire_body, int buffered_onl
     return read_body_with_content_length(parser, read_entire_body, buffered_only);
 }
 
+/* call-seq: parser.read_body -> body
+ *
+ * Reads an HTTP request/response body from the associated IO instance.
+ */
 VALUE Parser_read_body(VALUE self) {
   return read_body(self, 1, 0);
 }
 
+/* call-seq: parser.read_body_chunk(buffered_only) -> chunk
+ *
+ * Reads a single body chunk (useful for chunked transfer encoding). If
+ * `buffered_only` is true, will only read from the underlying buffer, without
+ * reading from the associated IO instance.
+ */
 VALUE Parser_read_body_chunk(VALUE self, VALUE buffered_only) {
   return read_body(self, 0, buffered_only == Qtrue);
 }
 
+/* call-seq: parser.splice_body_to(dest)
+ *
+ * Splices the HTTP request/response body from the associated IO instance to
+ * `dest`.
+ */
 VALUE Parser_splice_body_to(VALUE self, VALUE dest) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -1080,6 +1123,11 @@ VALUE Parser_splice_body_to(VALUE self, VALUE dest) {
   return self;
 }
 
+/* call-seq: parser.complete?
+ *
+ * Returns true if a complete HTTP request/response has been read from the
+ * associated IO instance.
+ */
 VALUE Parser_complete_p(VALUE self) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -1090,7 +1138,212 @@ VALUE Parser_complete_p(VALUE self) {
   return parser->request_completed ? Qtrue : Qfalse;
 }
 
-void Init_H1P() {
+typedef struct send_response_ctx {
+  VALUE io;
+  VALUE buffer;
+  char *buffer_ptr;
+  unsigned int buffer_len;
+  unsigned int total_written;
+} send_response_ctx;
+
+#define MAX_RESPONSE_BUFFER_SIZE 65536
+
+void send_response_flush_buffer(send_response_ctx *ctx) {
+  if (!ctx->buffer_len) return;
+
+  rb_str_set_len(ctx->buffer, ctx->buffer_len);
+  VALUE written = rb_funcall(ctx->io, ID_write, 1, ctx->buffer);
+  ctx->total_written += NUM2INT(written);
+  
+  rb_str_set_len(ctx->buffer, 0);
+  ctx->buffer_len = 0;
+}
+
+void send_response_write_status_line(send_response_ctx *ctx, VALUE protocol, VALUE status) {
+  char *ptr = ctx->buffer_ptr;
+
+  unsigned int partlen = RSTRING_LEN(protocol);
+  memcpy(ptr, RSTRING_PTR(protocol), partlen);
+  ctx->buffer_len += partlen;
+  ptr[ctx->buffer_len] = ' ';
+  ctx->buffer_len++;
+
+  ptr += ctx->buffer_len;
+  partlen = RSTRING_LEN(status);
+  memcpy(ptr, RSTRING_PTR(status), partlen);
+  ptr[partlen] = '\r';
+  ptr[partlen + 1] = '\n';
+  ctx->buffer_len += partlen + 2;
+}
+
+int send_response_write_header(VALUE key, VALUE val, VALUE arg) {
+  if (TYPE(key) != T_STRING) key = rb_funcall(key, ID_to_s, 0);
+  char *keyptr = RSTRING_PTR(key);
+  if (RSTRING_LEN(key) < 1 || keyptr[0] == ':') return 0;
+
+  if (TYPE(val) != T_STRING) val = rb_funcall(val, ID_to_s, 0);
+  unsigned int keylen = RSTRING_LEN(key);
+  char *valptr = RSTRING_PTR(val);
+  unsigned int vallen = RSTRING_LEN(val);
+  send_response_ctx *ctx = (send_response_ctx *)arg;
+
+  if (ctx->buffer_len + keylen + vallen > (MAX_RESPONSE_BUFFER_SIZE - 8))
+    send_response_flush_buffer(ctx);
+  
+  char *ptr = ctx->buffer_ptr + ctx->buffer_len;
+  memcpy(ptr, keyptr, keylen);
+  ptr[keylen] = ':';
+  ptr[keylen + 1] = ' ';
+  ptr += keylen + 2;
+
+  memcpy(ptr, valptr, vallen);
+  ptr[vallen] = '\r';
+  ptr[vallen + 1] = '\n';
+  ctx->buffer_len += keylen + vallen + 4;
+
+  RB_GC_GUARD(key);
+  RB_GC_GUARD(val);
+  
+  return 0; // ST_CONTINUE
+}
+
+/* call-seq: H1P.send_response(io, headers, body = nil) -> total_written
+ *
+ * Sends an HTTP response with the given headers and body.
+ */
+VALUE H1P_send_response(int argc,VALUE *argv, VALUE self) {
+  if (argc < 2)
+    rb_raise(eArgumentError, "(wrong number of arguments (expected 2 or more))");
+
+  VALUE io = argv[0];
+  VALUE headers = argv[1];
+  VALUE body = argc >= 3 ? argv[2] : Qnil;
+  VALUE buffer = rb_str_new_literal("");
+  rb_str_modify_expand(buffer, MAX_RESPONSE_BUFFER_SIZE);
+  send_response_ctx ctx = {io, buffer, RSTRING_PTR(buffer), 0, 0};
+
+  char *bodyptr = 0;
+  unsigned int bodylen = 0;
+
+  VALUE protocol = rb_hash_aref(headers, STR_pseudo_protocol);
+  if (protocol == Qnil) protocol = STR_pseudo_protocol_default;
+  VALUE status = rb_hash_aref(headers, STR_pseudo_status);
+  if (status == Qnil) status = STR_pseudo_status_default;
+  send_response_write_status_line(&ctx, protocol, status);
+
+  if (body != Qnil) {
+    if (TYPE(body) != T_STRING) body = rb_funcall(body, ID_to_s, 0);
+
+    bodyptr = RSTRING_PTR(body);
+    bodylen = RSTRING_LEN(body);
+    rb_hash_aset(headers, STR_content_length_capitalized, INT2FIX(bodylen));
+  }
+
+  rb_hash_foreach(headers, send_response_write_header, (VALUE)&ctx);
+
+  char *endptr = ctx.buffer_ptr + ctx.buffer_len;
+  endptr[0] = '\r';
+  endptr[1] = '\n';
+  ctx.buffer_len += 2;
+
+  if (body != Qnil) {
+    while (bodylen > 0) {
+      unsigned int chunklen = bodylen;
+      if (chunklen > MAX_RESPONSE_BUFFER_SIZE) chunklen = MAX_RESPONSE_BUFFER_SIZE;
+      
+      if (ctx.buffer_len + chunklen > MAX_RESPONSE_BUFFER_SIZE)
+        send_response_flush_buffer(&ctx);
+
+      memcpy(ctx.buffer_ptr + ctx.buffer_len, bodyptr, chunklen);
+      ctx.buffer_len += chunklen;
+      bodyptr += chunklen;
+      bodylen -= chunklen;
+    }
+    RB_GC_GUARD(body);
+  }
+
+  send_response_flush_buffer(&ctx);
+
+  RB_GC_GUARD(buffer);
+
+  return INT2FIX(ctx.total_written);
+}
+
+/* call-seq: H1P.send_body_chunk(io, chunk) -> total_written
+ *
+ * Sends a body chunk using chunked transfer encoding.
+ */
+VALUE H1P_send_body_chunk(VALUE self, VALUE io, VALUE chunk) {
+  if (chunk != Qnil) {
+    if (TYPE(chunk) != T_STRING) chunk = rb_funcall(chunk, ID_to_s, 0);
+
+    VALUE len_string = rb_str_new_literal("");
+    rb_str_modify_expand(len_string, 16);
+    int len_string_len = sprintf(RSTRING_PTR(len_string), "%lx\r\n", RSTRING_LEN(chunk));
+    rb_str_set_len(len_string,len_string_len);
+
+    VALUE total_written = rb_funcall(io, ID_write, 3, len_string, chunk, STR_CRLF);
+
+    RB_GC_GUARD(len_string);
+    RB_GC_GUARD(chunk);
+    return total_written;
+  }
+  else {
+    return rb_funcall(io, ID_write, 1, STR_EMPTY_CHUNK);
+  }
+}
+
+/* call-seq: H1P.send_chunked_response(io, headers, body = nil) -> total_written
+ *
+ * Sends an HTTP response with the given headers and body using chunked transfer
+ * encoding.
+ */
+VALUE H1P_send_chunked_response(VALUE self, VALUE io, VALUE headers) {
+  VALUE buffer = rb_str_new_literal("");
+  rb_str_modify_expand(buffer, MAX_RESPONSE_BUFFER_SIZE);
+  send_response_ctx ctx = {io, buffer, RSTRING_PTR(buffer), 0, 0};
+
+  VALUE protocol = rb_hash_aref(headers, STR_pseudo_protocol);
+  if (protocol == Qnil) protocol = STR_pseudo_protocol_default;
+  VALUE status = rb_hash_aref(headers, STR_pseudo_status);
+  if (status == Qnil) status = STR_pseudo_status_default;
+  send_response_write_status_line(&ctx, protocol, status);
+
+  rb_hash_aset(headers, STR_transfer_encoding_capitalized, STR_chunked);
+  rb_hash_foreach(headers, send_response_write_header, (VALUE)&ctx);
+
+  ctx.buffer_ptr[ctx.buffer_len] = '\r';
+  ctx.buffer_ptr[ctx.buffer_len + 1] = '\n';
+  ctx.buffer_len += 2;
+  send_response_flush_buffer(&ctx);
+
+  VALUE len_string = rb_str_new_literal("");
+  rb_str_modify_expand(len_string, 16);
+  while (1) {
+    VALUE chunk = rb_yield(Qnil);
+    if (chunk == Qnil) {
+      VALUE written = rb_funcall(io, ID_write, 1, STR_EMPTY_CHUNK);
+      ctx.total_written += NUM2INT(written);
+      break;
+    }
+    else {
+      if (TYPE(chunk) != T_STRING) chunk = rb_funcall(chunk, ID_to_s, 0);
+
+      int len_string_len = sprintf(RSTRING_PTR(len_string), "%lx\r\n", RSTRING_LEN(chunk));
+      rb_str_set_len(len_string,len_string_len);
+      VALUE written = rb_funcall(io, ID_write, 3, len_string, chunk, STR_CRLF);
+      ctx.total_written += NUM2INT(written);
+    }
+    RB_GC_GUARD(chunk);
+  }
+
+  RB_GC_GUARD(len_string);
+  RB_GC_GUARD(buffer);
+
+  return INT2FIX(ctx.total_written);
+}
+
+void Init_H1P(void) {
   VALUE mH1P;
   VALUE cParser;
 
@@ -1102,7 +1355,6 @@ void Init_H1P() {
   cError = rb_define_class_under(mH1P, "Error", rb_eRuntimeError);
   rb_gc_register_mark_object(cError);
 
-  // backend methods
   rb_define_method(cParser, "initialize", Parser_initialize, 2);
   rb_define_method(cParser, "parse_headers", Parser_parse_headers, 0);
   rb_define_method(cParser, "read_body", Parser_read_body, 0);
@@ -1110,6 +1362,10 @@ void Init_H1P() {
   rb_define_method(cParser, "splice_body_to", Parser_splice_body_to, 1);
   rb_define_method(cParser, "complete?", Parser_complete_p, 0);
 
+  rb_define_singleton_method(mH1P, "send_response", H1P_send_response, -1);
+  rb_define_singleton_method(mH1P, "send_body_chunk", H1P_send_body_chunk, 2);
+  rb_define_singleton_method(mH1P, "send_chunked_response", H1P_send_chunked_response, 2);
+
   ID_arity                  = rb_intern("arity");
   ID_backend_read           = rb_intern("backend_read");
   ID_backend_recv           = rb_intern("backend_recv");
@@ -1124,23 +1380,32 @@ void Init_H1P() {
   ID_read                   = rb_intern("read");
   ID_readpartial            = rb_intern("readpartial");
   ID_to_i                   = rb_intern("to_i");
+  ID_to_s                   = rb_intern("to_s");
   ID_upcase                 = rb_intern("upcase");
+  ID_write                  = rb_intern("write");
   ID_write_method           = rb_intern("__write_method__");
 
   NUM_max_headers_read_length = INT2FIX(MAX_HEADERS_READ_LENGTH);
   NUM_buffer_start = INT2FIX(0);
   NUM_buffer_end = INT2FIX(-1);
 
-  GLOBAL_STR(STR_pseudo_method,         ":method");
-  GLOBAL_STR(STR_pseudo_path,           ":path");
-  GLOBAL_STR(STR_pseudo_protocol,       ":protocol");
-  GLOBAL_STR(STR_pseudo_rx,             ":rx");
-  GLOBAL_STR(STR_pseudo_status,         ":status");
-  GLOBAL_STR(STR_pseudo_status_message, ":status_message");
+  GLOBAL_STR(STR_pseudo_method,               ":method");
+  GLOBAL_STR(STR_pseudo_path,                 ":path");
+  GLOBAL_STR(STR_pseudo_protocol,             ":protocol");
+  GLOBAL_STR(STR_pseudo_protocol_default,     "HTTP/1.1");
+  GLOBAL_STR(STR_pseudo_rx,                   ":rx");
+  GLOBAL_STR(STR_pseudo_status,               ":status");
+  GLOBAL_STR(STR_pseudo_status_default,       "200 OK");
+  GLOBAL_STR(STR_pseudo_status_message,       ":status_message");
+
+  GLOBAL_STR(STR_chunked,                       "chunked");
+  GLOBAL_STR(STR_content_length,                "content-length");
+  GLOBAL_STR(STR_content_length_capitalized,    "Content-Length");
+  GLOBAL_STR(STR_transfer_encoding,             "transfer-encoding");
+  GLOBAL_STR(STR_transfer_encoding_capitalized, "Transfer-Encoding");
 
-  GLOBAL_STR(STR_chunked,               "chunked");
-  GLOBAL_STR(STR_content_length,        "content-length");
-  GLOBAL_STR(STR_transfer_encoding,     "transfer-encoding");
+  GLOBAL_STR(STR_CRLF,                        "\r\n");
+  GLOBAL_STR(STR_EMPTY_CHUNK,                 "0\r\n\r\n");
 
   SYM_backend_read  = ID2SYM(ID_backend_read);
   SYM_backend_recv  = ID2SYM(ID_backend_recv);
@@ -1153,8 +1418,10 @@ void Init_H1P() {
   SYM_server = ID2SYM(rb_intern("server"));
 
   rb_global_variable(&mH1P);
+
+  eArgumentError = rb_const_get(rb_cObject, rb_intern("ArgumentError"));
 }
 
-void Init_h1p_ext() {
+void Init_h1p_ext(void) {
   Init_H1P();
 }

data/h1p.gemspec

@@ -16,9 +16,9 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.md"]
   s.extensions = ["ext/h1p/extconf.rb"]
   s.require_paths = ["lib"]
-  s.required_ruby_version = '>= 2.6'
+  s.required_ruby_version = '>= 2.7'
 
-  s.add_development_dependency  'rake-compiler',        '1.1.1'
+  s.add_development_dependency  'rake-compiler',        '1.2.1'
   s.add_development_dependency  'rake',               '~>13.0.6'
-  s.add_development_dependency  'minitest',           '~>5.14.4'
+  s.add_development_dependency  'minitest',           '~>5.17.0'
 end

data/lib/h1p/version.rb

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

data/test/helper.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-
 require 'fileutils'
-
 require 'minitest/autorun'
 
 module Minitest::Assertions

data/test/test_h1p.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'h1p'
+
+class SendResponseTest < MiniTest::Test
+  def test_send_response_status_line
+    i, o = IO.pipe
+    H1P.send_response(o, { ':status' => '418 I\'m a teapot' })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 418 I'm a teapot\r\n\r\n", response
+
+    i, o = IO.pipe
+    count = H1P.send_response(o, { ':protocol' => 'HTTP/1.0' })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.0 200 OK\r\n\r\n", response
+    assert_equal "HTTP/1.0 200 OK\r\n\r\n".bytesize, count
+  end
+
+  def test_send_response_string_headers
+    i, o = IO.pipe
+    H1P.send_response(o, { 'Foo' => 'Bar', 'Content-Length' => '123' })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nFoo: Bar\r\nContent-Length: 123\r\n\r\n", response
+  end
+
+  def test_send_response_non_string_headers
+    i, o = IO.pipe
+    H1P.send_response(o, { :Foo => 'Bar', 'Content-Length' => 123 })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nFoo: Bar\r\nContent-Length: 123\r\n\r\n", response
+  end
+
+  def test_send_response_with_body
+    i, o = IO.pipe
+    H1P.send_response(o, {}, "foobar")
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\nfoobar", response
+  end
+
+  def test_send_response_with_big_body
+    i, o = IO.pipe
+    body = "abcdefg" * 10000
+    Thread.new { H1P.send_response(o, {}, body); o.close }
+
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}", response
+  end
+
+  def test_send_response_with_big_body
+    i, o = IO.pipe
+    body = "abcdefg" * 10000
+    Thread.new { H1P.send_response(o, {}, body); o.close }
+
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}", response
+  end
+end
+
+class SendBodyChunkTest < MiniTest::Test
+  def test_send_body_chunk
+    i, o = IO.pipe
+    len1 = H1P.send_body_chunk(o, 'foo')
+    assert_equal 8, len1
+    len2 = H1P.send_body_chunk(o, :barbazbarbaz)
+    assert_equal 17, len2
+    len3 = H1P.send_body_chunk(o, 1234)
+    assert_equal 9, len3
+    len4 = H1P.send_body_chunk(o, nil)
+    assert_equal 5, len4
+    o.close
+    response = i.read
+    assert_equal "3\r\nfoo\r\nc\r\nbarbazbarbaz\r\n4\r\n1234\r\n0\r\n\r\n", response
+  end
+
+  def test_send_body_chunk_big
+    i, o = IO.pipe
+
+    chunk = 'foobar1' * 20000
+    len = nil
+
+    Thread.new do
+      len = H1P.send_body_chunk(o, chunk)
+      o.close
+    end
+    
+    response = i.read
+    assert_equal "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n", response
+    assert_equal chunk.bytesize + chunk.bytesize.to_s(16).bytesize + 4, len
+  end
+end
+
+class SendChunkedResponseTest < MiniTest::Test
+  def test_send_chunked_response
+    isrc, osrc = IO.pipe
+    osrc << 'foobarbaz'
+    osrc.close
+
+    i, o = IO.pipe
+    len = H1P.send_chunked_response(o, { 'Foo' => 'bar' }) do
+      isrc.read(3)
+    end
+    o.close
+
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nFoo: bar\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nfoo\r\n3\r\nbar\r\n3\r\nbaz\r\n0\r\n\r\n", response
+    assert_equal len, response.bytesize
+  end
+end

data/test/test_h1p_server.rb

@@ -6,7 +6,7 @@ require 'socket'
 require_relative '../ext/h1p/limits'
 require 'securerandom'
 
-class H1PRequestTest < MiniTest::Test
+class H1PServerTest < MiniTest::Test
   Error = H1P::Error
 
   def setup

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h1p
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '0.6'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-22 00:00:00.000000000 Z
+date: 2023-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.2.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.14.4
+        version: 5.17.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.14.4
+        version: 5.17.0
 description: 
 email: sharon@noteflakes.com
 executables: []
@@ -82,6 +82,7 @@ files:
 - lib/h1p/version.rb
 - test/helper.rb
 - test/run.rb
+- test/test_h1p.rb
 - test/test_h1p_client.rb
 - test/test_h1p_server.rb
 homepage: http://github.com/digital-fabric/h1p
@@ -101,14 +102,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.1
 signing_key: 
 specification_version: 4
 summary: H1P is a blocking HTTP/1 parser for Ruby