rage-iodine 5.6.0 → 5.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ffa46cab7e0fb7fc7550dd142f42b0850287fee60cc0d72b7f52757f52720f7
-  data.tar.gz: c51b8ad9e316c21ed06e6803dcfb5af7bf70fc3eee84a0fd179b2730d2572473
+  metadata.gz: 7e2925f48b74a97ff3431fc421ebd451c1f8d4befd701ac454ceb0bb8ed2ae82
+  data.tar.gz: 6c101cf70146f67794adc91ca9eee8cfade412b27bbed04d2c9937e378f25fa8
 SHA512:
-  metadata.gz: fa99ee4e7abb10b55b6f14aeeaef6bf03e85cf8aff9b33a66f7b4f64097c5ef824e0c3de6663caf00f5404b2d08b663debb60c796a0a44490138a96ac92a832c
-  data.tar.gz: ca2a4ac6f633955b202dccf09661cb7799ae92e16078ef3776c1648e18e2b1ab620f470f4b99b3c75b7d0e8f9b064fad180fd5c9b32ab6ae0ddd60c9d601b58d
+  metadata.gz: bcfba0ed6461dad2478e3f35b1dc2246046d872b6159bac5f93651f7ce3fa74ef2ee86e90727e930bb48514a7266844d9eb616af253f2aef30d92646b65fe06b
+  data.tar.gz: 2c1fa87406f4f249551addeb72d59231684552bdc5fde2ed55539851afe9b14349497f7cc8e0dfa1969f71668e24b93d1cc591cc5a2e3d560e2b4abd67e56c7b

data/.github/workflows/release.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - master
+      - release/*
     paths:
       - lib/iodine/version.rb
 

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.5.8.0 (2026-10-09)
+
+**Update**: Encode parameters as UTF-8
+
+#### Change log v.5.7.0 (2026-10-04)
+
+**Update**: Refactor parameters parsing
+
 #### Change log v.5.6.0 (2026-09-06)
 
 **Update**: TCP Socket Listen: Accept Queue

data/ext/iodine/http.c

@@ -68,6 +68,7 @@ static VALUE cUploadedFile;
 static ID create_id;
 static ID path_id;
 static rb_encoding *IodineBinaryEncoding;
+static rb_encoding *IodineUTF8Encoding;
 
 /* *****************************************************************************
 Small Helpers
@@ -1842,8 +1843,8 @@ typedef struct {
 
 #define http_mime_parser2fio(parser) ((http_fio_mime_s *)(parser))
 
-/** Parse a parameter key and add it to the `params` hash. Check `parse_nested_query_internal` for reference. */
-static void add_to_params(VALUE params, char *key, size_t key_len, VALUE value) {
+/** Parse a decoded parameter key and add it to the `params` hash. */
+void http_add_to_params(VALUE params, char *key, size_t key_len, VALUE value) {
   char *pos = NULL;
   if (key_len > 1) {
     pos = memchr(key + 1, '[', key_len - 1);
@@ -1925,7 +1926,7 @@ static void add_to_params(VALUE params, char *key, size_t key_len, VALUE value)
           if (RB_TYPE_P(nested_val, T_HASH)) {
             char *n_pos_start = k_pos + 1, *n_pos_end = k_pos + 1;
 
-            while (nested_val != Qnil && *n_pos_start == '[' && *(n_pos_start + 1) != ']' && *n_pos_end != '&' && *n_pos_end != '=' && n_pos_end < end) {
+            while (nested_val != Qnil && n_pos_end < end && *n_pos_start == '[' && *(n_pos_start + 1) != ']') {
               n_pos_end++;
 
               if (*n_pos_end == ']') {
@@ -2010,8 +2011,8 @@ static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
                                      size_t value_len) {
   // for regular values - just add them to params
   if (!filename_len) {
-    VALUE r_value = rb_enc_str_new(value, value_len, IodineBinaryEncoding);
-    add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
+    VALUE r_value = rb_enc_str_new(value, value_len, IodineUTF8Encoding);
+    http_add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
     return;
   }
 
@@ -2024,7 +2025,7 @@ static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
   close(file);
 
   VALUE r_value = build_file_value(r_tempfile, filename, filename_len, mimetype, mimetype_len);
-  add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
+  http_add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
 }
 
 /** Called when the data didn't fit in the buffer. Data will be streamed. */
@@ -2073,7 +2074,7 @@ static void http_mime_parser_on_partial_end(http_mime_parser_s *parser) {
 
   // for a file - add to params and close the fd
   if (fio_parser->partial_fd) {
-    add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), fio_parser->partial_tempfile);
+    http_add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), fio_parser->partial_tempfile);
     close(fio_parser->partial_fd);
 
     fio_parser->partial_name = Qnil;
@@ -2085,8 +2086,8 @@ static void http_mime_parser_on_partial_end(http_mime_parser_s *parser) {
 
   FIOBJ slice = fiobj_data_slice(fio_parser->h->body, fio_parser->partial_offset, fio_parser->partial_length);
   fio_str_info_s s_slice = fiobj_obj2cstr(slice);
-  VALUE r_value = rb_enc_str_new(s_slice.data, s_slice.len, IodineBinaryEncoding);
-  add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), r_value);
+  VALUE r_value = rb_enc_str_new(s_slice.data, s_slice.len, IodineUTF8Encoding);
+  http_add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), r_value);
 
   fio_parser->partial_name = Qnil;
   fio_parser->partial_length = 0;
@@ -2701,6 +2702,7 @@ void http_init(void) {
   path_id = rb_intern("path");
 
   IodineBinaryEncoding = rb_enc_find("binary");
+  IodineUTF8Encoding = rb_enc_find("UTF-8");
 }
 
 /* *****************************************************************************

data/ext/iodine/http.h

@@ -781,6 +781,9 @@ HTTP GET and POST parsing helpers
  */
 VALUE http_parse_multipart(http_s *h, char *content_type, size_t content_type_len);
 
+/** Adds a decoded parameter key and Ruby value to a nested parameters hash. */
+void http_add_to_params(VALUE params, char *key, size_t key_len, VALUE value);
+
 /**
  * Parses the query part of an HTTP request/response. Uses `http_add2hash`.
  *

data/ext/iodine/iodine_helpers.c

@@ -210,7 +210,7 @@ static VALUE iodine_rfc2109(VALUE self, VALUE rtm) {
 }
 
 /**
-Convert query string into a Ruby object in (almost always) one pass with no recursion.
+Convert query string into a Ruby object without recursion.
 
 
         Iodine::Rack::Utils.parse_nested_query("a=1&b[]=2&c[d]=3") # => { "a" => "1", "b" => ["2"], "c" => { "d" => "3" } }
@@ -240,182 +240,68 @@ Convert query string into a Ruby object in (almost always) one pass with no recu
                         Rack:    64257.9 i/s - 16.94x  slower
 
 */
+static VALUE build_query_component(char *str, size_t len,
+                                    uint8_t should_decode) {
+  VALUE result = rb_enc_str_new(str, len, IodineUTF8Encoding);
+  if (should_decode) {
+    url_decode_inplace(Qnil, result);
+  }
+  return result;
+}
+
 static VALUE parse_nested_query_internal(char *str, size_t len) {
-  uint8_t should_decode = 0;
   VALUE params = rb_hash_new();
-
-  char *pos = str, *k_pos = str, *v_pos = str;
-  const char *end = str + len;
+  char *pos = str;
+  char *end = str + len;
 
   while (pos < end) {
-    k_pos++;
-
-    if (*k_pos == '=') { // plain param
-      v_pos = k_pos + 1;
-      while (*v_pos != '&' && v_pos < end) {
-        if (*v_pos == '%' || *v_pos == '+') {
-          should_decode = 1;
-        }
-        v_pos++;
-      }
-
-      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos)), v = rb_str_new(k_pos + 1, v_pos - k_pos - 1);
-      if (should_decode) {
-        rb_hash_aset(params, k, url_decode_inplace(Qnil, v));
-        should_decode = 0;
-      } else {
-        rb_hash_aset(params, k, v);
-      }
-      pos = k_pos = v_pos + 1;
-
-    } else if (*k_pos == '[') { // things are about to get rough now
-      VALUE arr = Qnil, hsh = Qnil, hsh_key = Qnil;
-      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos)), v;
-      pos = k_pos;
-      uint8_t depth = 0;
-
-      while (*pos != '=' && pos < end) {
-        if (depth++ == PARAMS_MAX_DEPTH) {
-          rb_raise(rb_eRuntimeError, "Params too deep");
-        }
-
-        if (*pos == '[' && *(pos + 1) == ']') { // array
-          if (arr != Qnil) {
-            VALUE tmp = rb_ary_new();
-            rb_ary_push(arr, tmp);
-            arr = tmp;
-          } else if (hsh != Qnil) {
-            arr = rb_hash_aref(hsh, hsh_key);
-            if (arr == Qnil) {
-              arr = rb_ary_new();
-              rb_hash_aset(hsh, hsh_key, arr);
-            } else {
-              Check_Type(arr, T_ARRAY);
-            }
-            hsh = hsh_key = Qnil;
-          } else {
-            VALUE tmp = rb_hash_aref(params, k);
-            if (tmp != Qnil) {
-              Check_Type(tmp, T_ARRAY);
-              arr = tmp;
-            } else {
-              arr = rb_ary_new();
-              rb_hash_aset(params, k, arr);
-            }
-          }
-
-          pos += 2;
-
-        } else if (*pos == '[' && *(pos + 1) != ']') { // hash
-          if (pos + 2 < end) {
-            k_pos = memchr(pos + 2, ']', end - pos - 2);
-          } else {
-            k_pos = NULL;
-          }
-
-          if (!k_pos) {
-            rb_raise(rb_eRuntimeError, "Bad params");
-          }
-
-          VALUE prev_hsh_key = hsh_key;
-          hsh_key = ID2SYM(rb_intern2(pos + 1, k_pos - pos - 1));
-
-          if (hsh != Qnil) {
-            VALUE existing = rb_hash_aref(hsh, prev_hsh_key);
-            if (existing != Qnil) {
-              Check_Type(existing, T_HASH);
-              hsh = existing;
-            } else {
-              VALUE tmp = rb_hash_new();
-              rb_hash_aset(hsh, prev_hsh_key, tmp);
-              hsh = tmp;
-            }
-          } else if (arr != Qnil) {
-            VALUE nested_val = Qnil;
-            if (RARRAY_LEN(arr) != 0) {
-              VALUE tmp = rb_ary_entry(arr, -1);
-              Check_Type(tmp, T_HASH);
-              nested_val = rb_hash_aref(tmp, hsh_key);
-            }
-
-            // handle Rails' smart key grouping;
-            //   "users[][data][id]=11&users[][data][name]=ross&users[][data][id]=22&users[][data][name]=chandler"
-            // should result in:
-            //   { users: [{ data: { id: "11", name: "ross" } }, { data: { id: "22", name: "chandler" } }] }
-            if (RB_TYPE_P(nested_val, T_HASH)) {
-              char *n_pos_start = k_pos + 1, *n_pos_end = k_pos + 1;
-
-              while (nested_val != Qnil && *n_pos_start == '[' && *(n_pos_start + 1) != ']' && *n_pos_end != '&' && *n_pos_end != '=' && n_pos_end < end) {
-                n_pos_end++;
-
-                if (*n_pos_end == ']') {
-                  VALUE nested_key = ID2SYM(rb_intern2(n_pos_start + 1, n_pos_end - n_pos_start - 1));
-                  Check_Type(nested_val, T_HASH);
-                  nested_val = rb_hash_aref(nested_val, nested_key);
-                  n_pos_start = ++n_pos_end;
-                }
-              }
-            }
-
-            // use a new hash if there's none under this key or the existing one already has such key
-            if (RARRAY_LEN(arr) == 0 || nested_val != Qnil) {
-              hsh = rb_hash_new();
-              rb_ary_push(arr, hsh);
-            } else {
-              hsh = rb_ary_entry(arr, -1);
-              if (hsh != Qnil) {
-                Check_Type(hsh, T_HASH);
-              }
-            }
-
-            arr = Qnil;
-          } else {
-            VALUE tmp = rb_hash_aref(params, k);
-            if (tmp != Qnil) {
-              Check_Type(tmp, T_HASH);
-              hsh = tmp;
-            } else {
-              hsh = rb_hash_new();
-              rb_hash_aset(params, k, hsh);
-            }
-          }
-
-          pos = k_pos + 1;
-
+    char *pair_end = pos;
+    char *separator = NULL;
+    uint8_t key_should_decode = 0;
+    uint8_t value_should_decode = 0;
+
+    while (pair_end < end && *pair_end != '&') {
+      if (!separator && *pair_end == '=') {
+        separator = pair_end;
+      } else if (*pair_end == '%' || *pair_end == '+') {
+        if (separator) {
+          value_should_decode = 1;
         } else {
-          pos++;
+          key_should_decode = 1;
         }
       }
+      pair_end++;
+    }
 
-      //
-      // write the final object into `params`
-      //
-
-      for (v_pos = pos + 1; *v_pos != '&' && v_pos < end; v_pos++) {
-        if (*v_pos == '%' || *v_pos == '+') {
-          should_decode = 1;
-        }
-      }
+    char *key_end = separator ? separator : pair_end;
+    VALUE key = Qnil;
+    char *key_data = pos;
+    size_t key_len = key_end - pos;
 
-      v = rb_str_new(pos + 1, v_pos - pos - 1);
-      if (should_decode) {
-        url_decode_inplace(Qnil, v);
-        should_decode = 0;
-      }
+    if (key_should_decode) {
+      key = build_query_component(pos, key_len, 1);
+      key_data = RSTRING_PTR(key);
+      key_len = RSTRING_LEN(key);
+    }
 
-      if (arr != Qnil) {
-        rb_ary_push(arr, v);
-      } else {
-        rb_hash_aset(hsh, hsh_key, v);
-      }
+    VALUE value;
+    if (separator) {
+      value = build_query_component(separator + 1,
+                                     pair_end - separator - 1,
+                                     value_should_decode);
+    } else if (key_len > 1 && memchr(key_data + 1, '[', key_len - 1)) {
+      value = rb_enc_str_new(NULL, 0, IodineUTF8Encoding);
+    } else {
+      value = Qnil;
+    }
 
-      pos = k_pos = v_pos + 1;
+    http_add_to_params(params, key_data, key_len, value);
+    RB_GC_GUARD(key);
 
-    } else if (*k_pos == '&' || k_pos >= end) {
-      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos));
-      rb_hash_aset(params, k, Qnil);
-      pos = k_pos + 1;
+    if (pair_end == end) {
+      break;
     }
+    pos = pair_end + 1;
   }
 
   return params;
@@ -425,21 +311,26 @@ static VALUE parse_nested_query_internal(char *str, size_t len) {
 Convert query string into a Ruby object.
 */
 static VALUE parse_nested_query(VALUE self, VALUE r_str) {
-  return parse_nested_query_internal(RSTRING_PTR(r_str), RSTRING_LEN(r_str));
   (void)self;
+  Check_Type(r_str, T_STRING);
+  VALUE result =
+      parse_nested_query_internal(RSTRING_PTR(r_str), RSTRING_LEN(r_str));
+  RB_GC_GUARD(r_str);
+  return result;
 }
 
 /**
 Convert urlencoded body into a Ruby object.
 */
 static VALUE parse_urlencoded_nested_query(VALUE self, VALUE r_str) {
-  ssize_t len = http_decode_url(RSTRING_PTR(r_str), RSTRING_PTR(r_str), RSTRING_LEN(r_str));
-  if (len < 0) {
-    rb_raise(rb_eRuntimeError, "Invalid encoding");
-  }
-  
-  return parse_nested_query_internal(RSTRING_PTR(r_str), len);
   (void)self;
+  Check_Type(r_str, T_STRING);
+  char *str = RSTRING_PTR(r_str);
+  size_t len = RSTRING_LEN(r_str);
+
+  VALUE result = parse_nested_query_internal(str, len);
+  RB_GC_GUARD(r_str);
+  return result;
 }
 
 /**

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.6.0'.freeze
+  VERSION = '5.8.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 5.6.0
+  version: 5.8.0
 platform: ruby
 authors:
 - Boaz Segev