rage-iodine 5.7.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e296131738e4dd072f1708da46957d66d78634792bd92f7162bdf3e49b222421
-  data.tar.gz: cbe8892dad5781565df04fce249acdcda2a050d3ccbb30218c41202704deee9a
+  metadata.gz: 1595ec4d4f155fbc845b37ad096018a2a4bfa4f884c0ef96b7112d268fe86e89
+  data.tar.gz: 3185d0901b132a329509238b5188dcd29de1d4145a018adda6b3f9f215e008cf
 SHA512:
-  metadata.gz: bcdc806d2ef25fd4ed32d12cf6348220de5a242d26f69e3b97375e2dd988397d348c1e0ca8f86328fec0eac065081d880f9842b56a9c5e7f4086cb07af69b2b6
-  data.tar.gz: 65c3066177011062277f25a685644063e416b84ebba6f8d90080ac37be01eda37ade06a1a20721b2293e950253052bdac8e49e5484932857a2265c9c80293d37
+  metadata.gz: 4bbaa335fcd6202ac41a6449a5d8a38302c786b69348b66af733520e83c27bf4529c8a0e90dc7db5f19f8755aadfaf0c71edeb07fea904664b2cbf573da573f0
+  data.tar.gz: 991187eeb695f2128f83859e1025d62d580a1e41fc672822aaf7c8e5130edf15c83721e263a30799311766627fbd132393b50987486d137004f7ae439d11d0b8

data/.github/workflows/release.yml

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

data/CHANGELOG.md

@@ -6,9 +6,9 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
-#### Change log v.5.7.0 (2026-10-04)
+#### Change log v.6.0.0 (2026-09-06)
 
-**Update**: Refactor parameters parsing
+**Update**: Update scheduler `read`/`write` hooks
 
 #### Change log v.5.6.0 (2026-09-06)
 

data/ext/iodine/fio.c

@@ -3687,12 +3687,12 @@ retry_int:
 }
 
 /**
- * This is a complete copy of `fio_read` except that it doesn't attempt to force close the
- * socker on error.
+ * Performs a single read operation using the connection's read hook.
  *
- * The method is currently used by the fiber scheduler.
+ * The return value and errno match the underlying read operation. The socket
+ * isn't closed on error.
  */
-ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count) {
+ssize_t fio_read_once(intptr_t uuid, void *buffer, size_t count) {
   if (!uuid_is_valid(uuid) || !uuid_data(uuid).open) {
     errno = EBADF;
     return -1;
@@ -3704,22 +3704,36 @@ ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count) {
       uuid_data(uuid).rw_hooks->read;
   void *udata = uuid_data(uuid).rw_udata;
   fio_unlock(&uuid_data(uuid).sock_lock);
-  int old_errno = errno;
-  ssize_t ret;
-retry_int:
-  ret = rw_read(uuid, udata, buffer, count);
+  ssize_t ret = rw_read(uuid, udata, buffer, count);
   if (ret > 0) {
     fio_touch(uuid);
-    return ret;
   }
-  if (ret < 0 && errno == EINTR)
-    goto retry_int;
-  if (ret < 0 &&
-      (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOTCONN)) {
-    errno = old_errno;
+  return ret;
+}
+
+/**
+ * Performs a single write operation using the connection's write hook.
+ *
+ * The return value and errno match the underlying write operation. The socket
+ * isn't closed on error and no data is queued for the reactor.
+ */
+ssize_t fio_write_once(intptr_t uuid, const void *buffer, size_t count) {
+  if (!uuid_is_valid(uuid) || !uuid_data(uuid).open) {
+    errno = EBADF;
+    return -1;
+  }
+  if (count == 0)
     return 0;
+  fio_lock(&uuid_data(uuid).sock_lock);
+  ssize_t (*rw_write)(intptr_t, void *, const void *, size_t) =
+      uuid_data(uuid).rw_hooks->write;
+  void *udata = uuid_data(uuid).rw_udata;
+  fio_unlock(&uuid_data(uuid).sock_lock);
+  ssize_t ret = rw_write(uuid, udata, buffer, count);
+  if (ret > 0) {
+    fio_touch(uuid);
   }
-  return -1;
+  return ret;
 }
 
 /**

data/ext/iodine/fio.h

@@ -1198,12 +1198,20 @@ size_t fio_local_addr(char *dest, size_t limit);
 ssize_t fio_read(intptr_t uuid, void *buffer, size_t count);
 
 /**
- * This is a complete copy of `fio_read` except that it doesn't attempt to force close the
- * socker on error.
+ * Performs a single read operation using the connection's read hook.
  *
- * The method is currently used by the fiber scheduler.
+ * The return value and errno match the underlying read operation. The socket
+ * isn't closed on error.
  */
-ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count);
+ssize_t fio_read_once(intptr_t uuid, void *buffer, size_t count);
+
+/**
+ * Performs a single write operation using the connection's write hook.
+ *
+ * The return value and errno match the underlying write operation. The socket
+ * isn't closed on error and no data is queued for the reactor.
+ */
+ssize_t fio_write_once(intptr_t uuid, const void *buffer, size_t count);
 
 /** The following structure is used for `fio_write2_fn` function arguments. */
 typedef struct {

data/ext/iodine/http.c

@@ -1842,8 +1842,8 @@ typedef struct {
 
 #define http_mime_parser2fio(parser) ((http_fio_mime_s *)(parser))
 
-/** 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) {
+/** 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) {
   char *pos = NULL;
   if (key_len > 1) {
     pos = memchr(key + 1, '[', key_len - 1);
@@ -1925,7 +1925,7 @@ void http_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_end < end && *n_pos_start == '[' && *(n_pos_start + 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 == ']') {
@@ -2011,7 +2011,7 @@ static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
   // for regular values - just add them to params
   if (!filename_len) {
     VALUE r_value = rb_enc_str_new(value, value_len, IodineBinaryEncoding);
-    http_add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
+    add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
     return;
   }
 
@@ -2024,7 +2024,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);
-  http_add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
+  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 +2073,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) {
-    http_add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), fio_parser->partial_tempfile);
+    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;
@@ -2086,7 +2086,7 @@ 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);
-  http_add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), r_value);
+  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;

data/ext/iodine/http.h

@@ -781,9 +781,6 @@ 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 without recursion.
+Convert query string into a Ruby object in (almost always) one pass with no recursion.
 
 
         Iodine::Rack::Utils.parse_nested_query("a=1&b[]=2&c[d]=3") # => { "a" => "1", "b" => ["2"], "c" => { "d" => "3" } }
@@ -240,68 +240,182 @@ Convert query string into a Ruby object without recursion.
                         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_str_new(str, len);
-  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;
-  char *end = str + len;
+
+  char *pos = str, *k_pos = str, *v_pos = str;
+  const char *end = str + len;
 
   while (pos < end) {
-    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;
+    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;
+
         } else {
-          key_should_decode = 1;
+          pos++;
         }
       }
-      pair_end++;
-    }
 
-    char *key_end = separator ? separator : pair_end;
-    VALUE key = Qnil;
-    char *key_data = pos;
-    size_t key_len = key_end - pos;
+      //
+      // write the final object into `params`
+      //
 
-    if (key_should_decode) {
-      key = build_query_component(pos, key_len, 1);
-      key_data = RSTRING_PTR(key);
-      key_len = RSTRING_LEN(key);
-    }
+      for (v_pos = pos + 1; *v_pos != '&' && v_pos < end; v_pos++) {
+        if (*v_pos == '%' || *v_pos == '+') {
+          should_decode = 1;
+        }
+      }
 
-    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_str_new(NULL, 0);
-    } else {
-      value = Qnil;
-    }
+      v = rb_str_new(pos + 1, v_pos - pos - 1);
+      if (should_decode) {
+        url_decode_inplace(Qnil, v);
+        should_decode = 0;
+      }
 
-    http_add_to_params(params, key_data, key_len, value);
-    RB_GC_GUARD(key);
+      if (arr != Qnil) {
+        rb_ary_push(arr, v);
+      } else {
+        rb_hash_aset(hsh, hsh_key, v);
+      }
+
+      pos = k_pos = v_pos + 1;
 
-    if (pair_end == end) {
-      break;
+    } 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;
     }
-    pos = pair_end + 1;
   }
 
   return params;
@@ -311,26 +425,21 @@ 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/ext/iodine/scheduler.c

@@ -1,6 +1,8 @@
 #include "iodine.h"
 #include "iodine_store.h"
 #include "ruby.h"
+#include "ruby/fiber/scheduler.h"
+#include "ruby/io/buffer.h"
 
 #include <errno.h>
 #include <stddef.h>
@@ -10,7 +12,7 @@
 
 #include "fio.h"
 
-#define IO_MAX_READ 8192
+#define IO_MAX_READ 65536
 
 static ID call_id;
 static uint8_t ATTACH_ON_READ_READY_CALLBACK;
@@ -151,51 +153,104 @@ static VALUE iodine_scheduler_attach(VALUE self, VALUE r_fd, VALUE r_waittype, V
   (void)self;
 }
 
-static VALUE iodine_scheduler_write(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
+static VALUE iodine_scheduler_write_async(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
   Check_Type(r_fd, T_FIXNUM);
   int fd = FIX2INT(r_fd);
 
-  Check_Type(r_buffer, T_STRING);
-  char *buffer = RSTRING_PTR(r_buffer);
+  const void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_reading(r_buffer, &buffer, &buffer_length);
 
   Check_Type(r_length, T_FIXNUM);
-  int length = FIX2INT(r_length);
+  size_t length = NUM2SIZET(r_length);
 
   Check_Type(r_offset, T_FIXNUM);
-  int offset = FIX2INT(r_offset);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
+  if (!length) {
+    return r_length;
+  }
 
   void *cpy = fio_malloc(length);
-  memcpy(cpy, buffer, length);
-  fio_write2(fio_fd2uuid(fd), .data.buffer = cpy, .length = length, .offset = offset, .after.dealloc = fio_free);
+  memcpy(cpy, (const char *)buffer + offset, length);
+  fio_write2(fio_fd2uuid(fd), .data.buffer = cpy, .length = length, .after.dealloc = fio_free);
 
   return r_length;
 
   (void)self;
 }
 
-static VALUE iodine_scheduler_read(VALUE self, VALUE r_fd, VALUE r_length, VALUE r_offset) {
+static VALUE iodine_scheduler_write(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
   Check_Type(r_fd, T_FIXNUM);
   int fd = FIX2INT(r_fd);
 
+  const void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_reading(r_buffer, &buffer, &buffer_length);
+
   Check_Type(r_length, T_FIXNUM);
-  int length = FIX2INT(r_length);
+  size_t length = NUM2SIZET(r_length);
 
-  if (length == 0) {
-    length = IO_MAX_READ;
+  Check_Type(r_offset, T_FIXNUM);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
+  if (!length) {
+    return rb_fiber_scheduler_io_result(0, 0);
   }
 
-  intptr_t uuid = fio_fd2uuid(fd);
-  char buffer[length];
+  ssize_t result = fio_write_once(fio_fd2uuid(fd), (const char *)buffer + offset, length);
+  int error = result < 0 ? errno : 0;
+  return rb_fiber_scheduler_io_result(result, error);
+
+  (void)self;
+}
+
+static VALUE iodine_scheduler_read(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
+  Check_Type(r_fd, T_FIXNUM);
+  int fd = FIX2INT(r_fd);
+
+  void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_writing(r_buffer, &buffer, &buffer_length);
+
+  Check_Type(r_length, T_FIXNUM);
+  size_t length = NUM2SIZET(r_length);
+
+  Check_Type(r_offset, T_FIXNUM);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
 
-  ssize_t len = fio_read_unsafe(uuid, &buffer, length);
-  if (len == -1) {
-    return Qnil;
+  #if RUBY_FIBER_SCHEDULER_VERSION >= 4
+    if (length > IO_MAX_READ) {
+      length = IO_MAX_READ;
+    }
+  #else
+    if (length == 0) {
+      length = buffer_length - offset;
+      if (length > IO_MAX_READ) {
+        length = IO_MAX_READ;
+      }
+    }
+  #endif
+
+  if (!length) {
+    return rb_fiber_scheduler_io_result(0, 0);
   }
 
-  return rb_str_new(buffer, len);
+  ssize_t result = fio_read_once(fio_fd2uuid(fd), (char *)buffer + offset, length);
+  int error = result < 0 ? errno : 0;
+  return rb_fiber_scheduler_io_result(result, error);
 
   (void)self;
-  (void)r_offset;
 }
 
 static VALUE iodine_scheduler_close(VALUE self) {
@@ -219,8 +274,9 @@ void iodine_scheduler_initialize(void) {
   VALUE SchedulerModule = rb_define_module_under(IodineModule, "Scheduler");
 
   rb_define_module_function(SchedulerModule, "attach", iodine_scheduler_attach, 3);
+  rb_define_module_function(SchedulerModule, "write_async", iodine_scheduler_write_async, 4);
   rb_define_module_function(SchedulerModule, "write", iodine_scheduler_write, 4);
-  rb_define_module_function(SchedulerModule, "read", iodine_scheduler_read, 3);
+  rb_define_module_function(SchedulerModule, "read", iodine_scheduler_read, 4);
   rb_define_module_function(SchedulerModule, "close", iodine_scheduler_close, 0);
 
   VALUE cIO = rb_const_get(rb_cObject, rb_intern2("IO", 2));

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.7.0'.freeze
+  VERSION = '6.0.0'.freeze
 end

metadata

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