fast_curl 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 279ce69cb40c48246c4e6276260a928f4e03ae86e691f876492ba25a39eb00c7
-  data.tar.gz: 577583ed2fde2e2653f1e27f22caca08846fd32bb49524a59f44e5b3ba3acee9
+  metadata.gz: 00f4a847ee360180fa617212693206970a8e7af85ef02e6370d37cb62d2b384e
+  data.tar.gz: f5633dc59f41b4b31efa6e07eb32bc6a85b146e85126fa68b24b742294df5e8b
 SHA512:
-  metadata.gz: 3e0edb04a304a46adaab5368289d2332672fcd7654506c6449cde10ea5b5620cc4ba71549f60fccb0308d2ef67c8dc4e4e54304efa8c84dfc1631f360f89cdc8
-  data.tar.gz: 54693fc0a4189cf60e48f35b92d4f82ba1971b170cf54b610ed27378b5c296c50fa88798b4d0ac135ca3734b1cce7abf0b5214ed60e18aa90f0f158d8f708199
+  metadata.gz: b7f2e299c89da40d0a546e8545310430a46f0cca8abafff53e46953871c4c205d8fc53c16e33e65b9ff3a22c951d212f41f562476977200de84136ce0342cacc
+  data.tar.gz: a5fa06d7e44c0846de3cccd3c955a136fd7ee05e01611f05b940bf174cbd356315d23418ebc40ea77d94667c928ae3f2c7087c227df0ea7a39c0b3a27f52da77

data/README.md

@@ -12,7 +12,9 @@ Ultra-fast parallel HTTP client for Ruby. C extension built on libcurl `curl_mul
 
 ## Installation
 
-**Requirements**: Ruby >= 3.0 (for Fiber scheduler support)
+**Requirements**: Ruby >= 3.1, libcurl
+
+> **Why Ruby 3.1?** The C extension uses `rb_fiber_scheduler_current`, `rb_fiber_scheduler_block` and `rb_fiber_scheduler_unblock` to properly yield control to the Fiber Scheduler during I/O. These APIs are stable starting from Ruby 3.1. Without them, there is no correct way for a C extension to cooperate with the scheduler — earlier approaches (`rb_thread_schedule`) hold the GVL and block other fibers.
 
 ```ruby
 gem 'fast_curl'
@@ -142,19 +144,54 @@ end
 
 ## Performance
 
-Benchmark results (`bundle exec ruby benchmark/local_bench.rb`):
+Benchmarks against `httpbin.org`, 5 iterations with 1 warmup, median times.
+Run yourself: `bundle exec ruby benchmark/local_bench.rb`.
+
+Each request hits `/delay/1` (server-side 1-second delay), so sequential baseline
+grows linearly while parallel clients stay near ~1s plus network overhead.
+
+### Time to completion (lower is better)
+
+| Scenario                        | Net::HTTP sequential | fast_curl (thread) | fast_curl (fiber/Async) | Async::HTTP::Internet |
+|---------------------------------|---------------------:|-------------------:|------------------------:|----------------------:|
+| 4 requests × 1s, conn=4         |                8.27s |              2.36s |                   2.13s |                 2.56s |
+| 10 requests × 1s, conn=10       |               20.92s |              3.49s |                   5.23s |                 3.83s |
+| 20 requests × 1s, conn=5        |               42.56s |              2.94s |                   2.90s |                12.14s |
+| 200 requests × 1s, conn=20      |                   —  |             22.19s |                  21.77s |                23.59s |
+
+### Speedup vs Net::HTTP (median)
+
+| Scenario                          | fast_curl (thread) | fast_curl (fiber) | Async::HTTP |
+|-----------------------------------|-------------------:|------------------:|------------:|
+| 4 requests × 1s                   |           **3.5x** |              3.9x |        3.2x |
+| 10 requests × 1s                  |           **6.0x** |              4.0x |        5.5x |
+| 20 requests × 1s (queued, conn=5) |          **14.5x** |             14.7x |        3.5x |
+
+### Memory & allocations per request batch (lower is better)
+
+| Scenario                        | fast_curl (thread) allocated | fast_curl (fiber) allocated | Async::HTTP allocated |
+|---------------------------------|-----------------------------:|----------------------------:|----------------------:|
+| 4 requests × 1s                 |                 **278 obj**  |                     350 obj |             2,433 obj |
+| 10 requests × 1s                |                 **490 obj**  |                     756 obj |             4,763 obj |
+| 20 requests × 1s, conn=5        |                 **621 obj**  |                     750 obj |             8,536 obj |
+| 200 requests × 1s, conn=20      |               **5,188 obj**  |                   5,642 obj |            78,203 obj |
+
+Ruby heap delta stays near zero across all scenarios for fast_curl — most allocation
+happens in C, not on the Ruby heap.
+
+### Error handling
+
+| Scenario                                                     |  Time |
+|--------------------------------------------------------------|------:|
+| 4 mixed requests (404, 500, DNS fail, 30s delay), timeout=2s | 4.02s |
+
+Bounded by `timeout=2s` rather than by the slow request.
 
-| Method | 4 parallel | 10 parallel | 20 parallel | 200 parallel |
-|--------|------------|-------------|--------------|---------------|
-| Net::HTTP sequential | 7.93s (+2.1 MB) | 24.20s (+0.3 MB) | 48.58s (+1.2 MB) | - |
-| fast_curl (thread) | 2.09s (+0.7 MB) | 3.73s (+0.9 MB) | 3.76s (+0.0 MB) | 5.88s (+2.3 MB) |
-| fast_curl (fiber) | 1.96s (+0.4 MB) | 4.86s (+0.0 MB) | 3.71s (+0.2 MB) | 9.60s (+1.6 MB) |
-| Async::HTTP | 2.54s (+0.3 MB) | 4.27s (+0.4 MB) | 9.16s (+0.5 MB) | 22.44s (+10.7 MB) |
+### Notes on the numbers
 
-Additional scenarios:
-- Stream execute (5 requests): 5.99s (+0.0 MB)
-- First execute (first 1 of 5): 2.40s (+0.0 MB)
-- Error handling (timeout=2s): 2.01s (+0.0 MB)
+- **Net::HTTP sequential** is the proof-of-parallelism baseline — it confirms fast_curl and Async are actually running concurrently, not that they "beat" a different library. 4×1s sequentially = 4s, parallel = ~1s + overhead.
+- **Variance is high against remote endpoints** (httpbin.org). For stable numbers, use `--local` which spawns a WEBrick server on 127.0.0.1.
+- **fast_curl (thread) vs (fiber)**: same underlying C code, different scheduling. "thread" is the default; "fiber" kicks in automatically when called inside `Async do ... end`.
 
 ## License
 

data/ext/fast_curl/extconf.rb

@@ -6,6 +6,7 @@ abort "curl/curl.h is required" unless have_header("curl/curl.h")
 have_header("ruby/thread.h")
 have_header("ruby/fiber/scheduler.h")
 
+have_func("curl_multi_wakeup", "curl/curl.h")
 have_func("rb_fiber_scheduler_current", "ruby.h")
 have_func("rb_io_wait", "ruby.h")
 

data/ext/fast_curl/fast_curl.c

@@ -12,6 +12,7 @@
 #define MAX_REDIRECTS         5
 #define MAX_TIMEOUT           300
 #define MAX_RETRIES           10
+#define MAX_REQUESTS          10000
 #define DEFAULT_RETRIES       1
 #define DEFAULT_RETRY_DELAY   0
 #define INITIAL_BUF_CAP       8192
@@ -26,31 +27,12 @@ static const CURLcode DEFAULT_RETRYABLE_CURLE[] = {
 #define DEFAULT_RETRYABLE_CURLE_COUNT \
     (int)(sizeof(DEFAULT_RETRYABLE_CURLE) / sizeof(DEFAULT_RETRYABLE_CURLE[0]))
 
-static ID id_status;
-static ID id_headers;
-static ID id_body;
-static ID id_error_code;
-static ID id_url;
-static ID id_method;
-static ID id_timeout;
-static ID id_connections;
-static ID id_count;
-static ID id_keys;
-static ID id_retries;
-static ID id_retry_delay;
-static ID id_retry_codes;
-static VALUE sym_status;
-static VALUE sym_headers;
-static VALUE sym_body;
-static VALUE sym_error_code;
-static VALUE sym_url;
-static VALUE sym_method;
-static VALUE sym_timeout;
-static VALUE sym_connections;
-static VALUE sym_count;
-static VALUE sym_retries;
-static VALUE sym_retry_delay;
-static VALUE sym_retry_codes;
+static ID id_status, id_headers, id_body, id_error_code, id_url, id_method;
+static ID id_timeout, id_connections, id_count, id_keys;
+static ID id_retries, id_retry_delay, id_retry_codes;
+static VALUE sym_status, sym_headers, sym_body, sym_error_code, sym_url, sym_method;
+static VALUE sym_timeout, sym_connections, sym_count;
+static VALUE sym_retries, sym_retry_delay, sym_retry_codes;
 
 typedef struct {
     char *data;
@@ -82,26 +64,20 @@ static inline void buffer_reset(buffer_t *buf) {
 static size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
     buffer_t *buf = (buffer_t *)userdata;
     size_t total = size * nmemb;
-
-    if (buf->len + total > buf->max_size) {
+    if (buf->len + total > buf->max_size)
         return 0;
-    }
-
     if (buf->len + total >= buf->cap) {
         size_t new_cap = (buf->cap == 0) ? INITIAL_BUF_CAP : buf->cap;
         while (new_cap <= buf->len + total)
             new_cap *= 2;
-
         if (new_cap > buf->max_size)
             new_cap = buf->max_size;
-
         char *new_data = realloc(buf->data, new_cap);
         if (!new_data)
             return 0;
         buf->data = new_data;
         buf->cap = new_cap;
     }
-
     memcpy(buf->data + buf->len, ptr, total);
     buf->len += total;
     return total;
@@ -142,33 +118,27 @@ static void header_list_reset(header_list_t *h) {
 static size_t header_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
     header_list_t *h = (header_list_t *)userdata;
     size_t total = size * nmemb;
-
     if (total <= 2)
         return total;
-
     if (h->count >= h->cap) {
         int new_cap = (h->cap == 0) ? INITIAL_HEADER_CAP : h->cap * 2;
-        header_entry_t *new_entries = realloc(h->entries, sizeof(header_entry_t) * new_cap);
-        if (!new_entries)
+        header_entry_t *ne = realloc(h->entries, sizeof(header_entry_t) * new_cap);
+        if (!ne)
             return 0;
-        h->entries = new_entries;
+        h->entries = ne;
         h->cap = new_cap;
     }
-
     size_t stripped = total;
     while (stripped > 0 && (ptr[stripped - 1] == '\r' || ptr[stripped - 1] == '\n'))
         stripped--;
-
     char *entry = malloc(stripped + 1);
     if (!entry)
         return 0;
     memcpy(entry, ptr, stripped);
     entry[stripped] = '\0';
-
     h->entries[h->count].str = entry;
     h->entries[h->count].len = stripped;
     h->count++;
-
     return size * nmemb;
 }
 
@@ -234,6 +204,7 @@ typedef struct {
     int still_running;
     long timeout_ms;
     int max_connections;
+    volatile int cancelled;
 } multi_session_t;
 
 typedef struct {
@@ -243,85 +214,124 @@ typedef struct {
     int retry_http_count;
 } retry_config_t;
 
+static int contains_header_injection(const char *str, long len) {
+    for (long i = 0; i < len; i++) {
+        if (str[i] == '\r' || str[i] == '\n' || str[i] == '\0')
+            return 1;
+    }
+    return 0;
+}
+
+#ifdef HAVE_RB_FIBER_SCHEDULER_CURRENT
+static VALUE current_fiber_scheduler(void) {
+    VALUE sched = rb_fiber_scheduler_current();
+    if (sched == Qnil || sched == Qfalse)
+        return Qnil;
+    return sched;
+}
+#else
+static VALUE current_fiber_scheduler(void) {
+    return Qnil;
+}
+#endif
+
+typedef struct {
+    void *(*func)(void *);
+    void *arg;
+    VALUE scheduler;
+    VALUE blocker;
+    VALUE fiber;
+} fiber_worker_ctx_t;
+
+static void *fiber_worker_nogvl(void *arg) {
+    fiber_worker_ctx_t *c = (fiber_worker_ctx_t *)arg;
+    c->func(c->arg);
+    return NULL;
+}
+
+static VALUE fiber_worker_thread(void *arg) {
+    fiber_worker_ctx_t *c = (fiber_worker_ctx_t *)arg;
+    rb_thread_call_without_gvl(fiber_worker_nogvl, c, RUBY_UBF_PROCESS, NULL);
+    rb_fiber_scheduler_unblock(c->scheduler, c->blocker, c->fiber);
+    return Qnil;
+}
+
+static void run_via_fiber_worker(VALUE scheduler, void *(*func)(void *), void *arg) {
+    fiber_worker_ctx_t ctx = {
+        .func = func,
+        .arg = arg,
+        .scheduler = scheduler,
+        .blocker = rb_obj_alloc(rb_cObject),
+        .fiber = rb_fiber_current(),
+    };
+    VALUE th = rb_thread_create(fiber_worker_thread, &ctx);
+    rb_fiber_scheduler_block(scheduler, ctx.blocker, Qnil);
+    rb_funcall(th, rb_intern("join"), 0);
+}
+
 static VALUE build_response(request_ctx_t *ctx) {
     long status = 0;
     curl_easy_getinfo(ctx->easy, CURLINFO_RESPONSE_CODE, &status);
-
     VALUE headers_hash = rb_hash_new();
     for (int i = 0; i < ctx->headers.count; i++) {
         const char *hdr = ctx->headers.entries[i].str;
         size_t hdr_len = ctx->headers.entries[i].len;
-
         const char *colon = memchr(hdr, ':', hdr_len);
         if (!colon)
             continue;
-
         VALUE key = rb_str_new(hdr, colon - hdr);
-
-        const char *val_start = colon + 1;
-        const char *val_end = hdr + hdr_len;
-
-        while (val_start < val_end && (*val_start == ' ' || *val_start == '\t'))
-            val_start++;
-
-        while (val_end > val_start && (*(val_end - 1) == ' ' || *(val_end - 1) == '\t'))
-            val_end--;
-
-        VALUE val = rb_str_new(val_start, val_end - val_start);
+        const char *vs = colon + 1, *ve = hdr + hdr_len;
+        while (vs < ve && (*vs == ' ' || *vs == '\t'))
+            vs++;
+        while (ve > vs && (*(ve - 1) == ' ' || *(ve - 1) == '\t'))
+            ve--;
+        VALUE val = rb_str_new(vs, ve - vs);
         rb_hash_aset(headers_hash, key, val);
     }
-
     VALUE body_str =
         ctx->body.data ? rb_str_new(ctx->body.data, ctx->body.len) : rb_str_new_cstr("");
-
     VALUE result = rb_hash_new();
     rb_hash_aset(result, sym_status, LONG2NUM(status));
     rb_hash_aset(result, sym_headers, headers_hash);
     rb_hash_aset(result, sym_body, body_str);
-
     return result;
 }
 
 static VALUE build_error_response(const char *message) {
-    VALUE result = rb_hash_new();
-    rb_hash_aset(result, sym_status, INT2NUM(0));
-    rb_hash_aset(result, sym_headers, Qnil);
-    rb_hash_aset(result, sym_body, rb_str_new_cstr(message));
-    return result;
+    VALUE r = rb_hash_new();
+    rb_hash_aset(r, sym_status, INT2NUM(0));
+    rb_hash_aset(r, sym_headers, Qnil);
+    rb_hash_aset(r, sym_body, rb_str_new_cstr(message));
+    return r;
 }
 
 static VALUE build_error_response_with_code(const char *message, int error_code) {
-    VALUE result = rb_hash_new();
-    rb_hash_aset(result, sym_status, INT2NUM(0));
-    rb_hash_aset(result, sym_headers, Qnil);
-    rb_hash_aset(result, sym_body, rb_str_new_cstr(message));
-    rb_hash_aset(result, sym_error_code, INT2NUM(error_code));
-    return result;
+    VALUE r = rb_hash_new();
+    rb_hash_aset(r, sym_status, INT2NUM(0));
+    rb_hash_aset(r, sym_headers, Qnil);
+    rb_hash_aset(r, sym_body, rb_str_new_cstr(message));
+    rb_hash_aset(r, sym_error_code, INT2NUM(error_code));
+    return r;
 }
 
 static int is_valid_url(const char *url) {
     if (!url)
         return 0;
-
-    size_t url_len = strlen(url);
-
-    if (url_len < 8 || url_len > 2048)
+    size_t len = strlen(url);
+    if (len < 8 || len > 2048)
         return 0;
-
     if (strncmp(url, "https://", 8) == 0)
         return 1;
-    if (url_len >= 7 && strncmp(url, "http://", 7) == 0)
+    if (len >= 7 && strncmp(url, "http://", 7) == 0)
         return 1;
-
     return 0;
 }
 
-#define CURL_SETOPT_CHECK(handle, option, value)                \
-    do {                                                        \
-        CURLcode res = curl_easy_setopt(handle, option, value); \
-        if (res != CURLE_OK) {                                  \
-            return res;                                         \
-        }                                                       \
+#define CURL_SETOPT_CHECK(handle, option, value)               \
+    do {                                                       \
+        CURLcode _r = curl_easy_setopt(handle, option, value); \
+        if (_r != CURLE_OK)                                    \
+            return _r;                                         \
     } while (0)
 
 static CURLcode setup_basic_options(CURL *easy, const char *url_str, long timeout_sec,
@@ -338,14 +348,12 @@ static CURLcode setup_basic_options(CURL *easy, const char *url_str, long timeou
     CURL_SETOPT_CHECK(easy, CURLOPT_ACCEPT_ENCODING, "");
     CURL_SETOPT_CHECK(easy, CURLOPT_PRIVATE, (char *)ctx);
     CURL_SETOPT_CHECK(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
-
     return CURLE_OK;
 }
 
 static CURLcode setup_security_options(CURL *easy) {
     CURL_SETOPT_CHECK(easy, CURLOPT_SSL_VERIFYPEER, 1L);
     CURL_SETOPT_CHECK(easy, CURLOPT_SSL_VERIFYHOST, 2L);
-
 #ifdef CURLOPT_PROTOCOLS_STR
     CURL_SETOPT_CHECK(easy, CURLOPT_PROTOCOLS_STR, "http,https");
     CURL_SETOPT_CHECK(easy, CURLOPT_REDIR_PROTOCOLS_STR, "http,https");
@@ -353,7 +361,6 @@ static CURLcode setup_security_options(CURL *easy) {
     CURL_SETOPT_CHECK(easy, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
     CURL_SETOPT_CHECK(easy, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
 #endif
-
     return CURLE_OK;
 }
 
@@ -377,43 +384,42 @@ static CURLcode setup_method_and_body(CURL *easy, VALUE method, VALUE body) {
         CURL_SETOPT_CHECK(easy, CURLOPT_POSTFIELDSIZE, RSTRING_LEN(body));
         CURL_SETOPT_CHECK(easy, CURLOPT_COPYPOSTFIELDS, StringValuePtr(body));
     }
-
     return CURLE_OK;
 }
 
 static int header_iter_cb(VALUE key, VALUE val, VALUE arg) {
     request_ctx_t *ctx = (request_ctx_t *)arg;
-
     VALUE key_str = rb_String(key);
     const char *k = RSTRING_PTR(key_str);
     long klen = RSTRING_LEN(key_str);
 
+    if (contains_header_injection(k, klen))
+        return ST_CONTINUE;
+
     if (NIL_P(val) || RSTRING_LEN(rb_String(val)) == 0) {
-        char stack_buf[HEADER_LINE_BUF_SIZE];
-        char *buf = stack_buf;
+        char sbuf[HEADER_LINE_BUF_SIZE];
+        char *buf = sbuf;
         long need = klen + 2;
-
         if (need > HEADER_LINE_BUF_SIZE)
             buf = malloc(need);
         if (!buf)
             return ST_CONTINUE;
-
         memcpy(buf, k, klen);
         buf[klen] = ';';
         buf[klen + 1] = '\0';
-
         ctx->req_headers = curl_slist_append(ctx->req_headers, buf);
-
-        if (buf != stack_buf)
+        if (buf != sbuf)
             free(buf);
     } else {
         VALUE val_str = rb_String(val);
         const char *v = RSTRING_PTR(val_str);
         long vlen = RSTRING_LEN(val_str);
-        char stack_buf[HEADER_LINE_BUF_SIZE];
-        char *buf = stack_buf;
-        long need = klen + 2 + vlen + 1;
 
+        if (contains_header_injection(v, vlen))
+            return ST_CONTINUE;
+        char sbuf[HEADER_LINE_BUF_SIZE];
+        char *buf = sbuf;
+        long need = klen + 2 + vlen + 1;
         if (need > HEADER_LINE_BUF_SIZE)
             buf = malloc(need);
         if (!buf)
@@ -424,13 +430,10 @@ static int header_iter_cb(VALUE key, VALUE val, VALUE arg) {
         buf[klen + 1] = ' ';
         memcpy(buf + klen + 2, v, vlen);
         buf[klen + 2 + vlen] = '\0';
-
         ctx->req_headers = curl_slist_append(ctx->req_headers, buf);
-
-        if (buf != stack_buf)
+        if (buf != sbuf)
             free(buf);
     }
-
     return ST_CONTINUE;
 }
 
@@ -439,33 +442,25 @@ static int setup_easy_handle(request_ctx_t *ctx, VALUE request, long timeout_sec
     VALUE method = rb_hash_aref(request, sym_method);
     VALUE headers = rb_hash_aref(request, sym_headers);
     VALUE body = rb_hash_aref(request, sym_body);
-
     if (NIL_P(url))
         return 0;
-
     const char *url_str = StringValueCStr(url);
-
-    if (!is_valid_url(url_str)) {
+    if (!is_valid_url(url_str))
         rb_raise(rb_eArgError, "Invalid URL: %s", url_str);
-    }
 
     CURLcode res;
-
     res = setup_basic_options(ctx->easy, url_str, timeout_sec, ctx);
     if (res != CURLE_OK)
         return 0;
-
     res = setup_security_options(ctx->easy);
     if (res != CURLE_OK)
         return 0;
-
     res = setup_method_and_body(ctx->easy, method, body);
     if (res != CURLE_OK)
         return 0;
 
     if (!NIL_P(headers) && rb_obj_is_kind_of(headers, rb_cHash)) {
         rb_hash_foreach(headers, header_iter_cb, (VALUE)ctx);
-
         if (ctx->req_headers) {
             res = curl_easy_setopt(ctx->easy, CURLOPT_HTTPHEADER, ctx->req_headers);
             if (res != CURLE_OK)
@@ -473,46 +468,29 @@ static int setup_easy_handle(request_ctx_t *ctx, VALUE request, long timeout_sec
         }
     }
 
+    RB_GC_GUARD(url);
+    RB_GC_GUARD(method);
+    RB_GC_GUARD(headers);
+    RB_GC_GUARD(body);
+    RB_GC_GUARD(request);
     return 1;
 }
 
-static void *perform_without_gvl(void *arg) {
-    multi_session_t *session = (multi_session_t *)arg;
-
-    while (session->still_running > 0) {
-        CURLMcode mc = curl_multi_perform(session->multi, &session->still_running);
-        if (mc != CURLM_OK)
-            break;
-
-        if (session->still_running > 0) {
-            int numfds = 0;
-            mc = curl_multi_poll(session->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
-            if (mc != CURLM_OK)
-                break;
-        }
-    }
-
-    return NULL;
-}
-
 static void *poll_without_gvl(void *arg) {
-    multi_session_t *session = (multi_session_t *)arg;
+    multi_session_t *s = (multi_session_t *)arg;
+    if (s->cancelled)
+        return NULL;
     int numfds = 0;
-    curl_multi_poll(session->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
-    curl_multi_perform(session->multi, &session->still_running);
+    curl_multi_poll(s->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
+    curl_multi_perform(s->multi, &s->still_running);
     return NULL;
 }
 
 static void unblock_perform(void *arg) {
-    (void)arg;
-}
-
-static int has_fiber_scheduler(void) {
-#ifdef HAVE_RB_FIBER_SCHEDULER_CURRENT
-    VALUE scheduler = rb_fiber_scheduler_current();
-    return scheduler != Qnil && scheduler != Qfalse;
-#else
-    return 0;
+    multi_session_t *s = (multi_session_t *)arg;
+    s->cancelled = 1;
+#ifdef HAVE_CURL_MULTI_WAKEUP
+    curl_multi_wakeup(s->multi);
 #endif
 }
 
@@ -526,97 +504,73 @@ typedef struct {
 static int process_completed(multi_session_t *session, completion_ctx_t *cctx) {
     CURLMsg *msg;
     int msgs_left;
-
     while ((msg = curl_multi_info_read(session->multi, &msgs_left))) {
         if (msg->msg != CURLMSG_DONE)
             continue;
-
         request_ctx_t *ctx = NULL;
         curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char **)&ctx);
         if (!ctx || ctx->done)
             continue;
         ctx->done = 1;
         ctx->curl_result = msg->data.result;
-        if (msg->data.result == CURLE_OK) {
+        if (msg->data.result == CURLE_OK)
             curl_easy_getinfo(ctx->easy, CURLINFO_RESPONSE_CODE, &ctx->http_status);
-        }
-
         if (cctx->stream) {
-            VALUE response;
-            if (msg->data.result == CURLE_OK) {
-                response = build_response(ctx);
-            } else {
-                response = build_error_response_with_code(curl_easy_strerror(msg->data.result),
-                                                          (int)msg->data.result);
-            }
+            VALUE response = (msg->data.result == CURLE_OK)
+                                 ? build_response(ctx)
+                                 : build_error_response_with_code(
+                                       curl_easy_strerror(msg->data.result), (int)msg->data.result);
             VALUE pair = rb_ary_new_from_args(2, INT2NUM(ctx->index), response);
             rb_yield(pair);
             cctx->completed++;
         } else {
             cctx->completed++;
         }
-
         if (cctx->target > 0 && cctx->completed >= cctx->target)
             return 1;
     }
-
     return 0;
 }
 
 static void run_multi_loop(multi_session_t *session, completion_ctx_t *cctx) {
-    if (has_fiber_scheduler()) {
-        for (;;) {
-            CURLMcode mc = curl_multi_perform(session->multi, &session->still_running);
-            if (mc != CURLM_OK)
+    VALUE scheduler = current_fiber_scheduler();
+
+    if (scheduler != Qnil) {
+        curl_multi_perform(session->multi, &session->still_running);
+        while (session->still_running > 0) {
+            if (session->cancelled)
                 break;
+            run_via_fiber_worker(scheduler, poll_without_gvl, session);
             if (process_completed(session, cctx))
                 break;
-            if (session->still_running == 0)
-                break;
-
-            int numfds = 0;
-            curl_multi_poll(session->multi, NULL, 0, FIBER_POLL_TIMEOUT_MS, &numfds);
-            rb_thread_schedule();
         }
         process_completed(session, cctx);
     } else {
-        if (cctx->stream || cctx->target > 0) {
-            curl_multi_perform(session->multi, &session->still_running);
-            while (session->still_running > 0) {
-                rb_thread_call_without_gvl(poll_without_gvl, session, unblock_perform, session);
-                if (process_completed(session, cctx))
-                    break;
-            }
-            process_completed(session, cctx);
-        } else {
-            session->still_running = 1;
-            curl_multi_perform(session->multi, &session->still_running);
-            rb_thread_call_without_gvl(perform_without_gvl, session, unblock_perform, session);
-            process_completed(session, cctx);
+        curl_multi_perform(session->multi, &session->still_running);
+        while (session->still_running > 0) {
+            if (session->cancelled)
+                break;
+            rb_thread_call_without_gvl(poll_without_gvl, session, unblock_perform, session);
+            if (process_completed(session, cctx))
+                break;
         }
+        process_completed(session, cctx);
     }
 }
 
 static int is_default_retryable_curle(CURLcode code) {
-    for (int i = 0; i < DEFAULT_RETRYABLE_CURLE_COUNT; i++) {
+    for (int i = 0; i < DEFAULT_RETRYABLE_CURLE_COUNT; i++)
         if (DEFAULT_RETRYABLE_CURLE[i] == code)
             return 1;
-    }
     return 0;
 }
 
-static int should_retry(request_ctx_t *ctx, retry_config_t *retry_cfg) {
-    if (ctx->curl_result != CURLE_OK) {
+static int should_retry(request_ctx_t *ctx, retry_config_t *rc) {
+    if (ctx->curl_result != CURLE_OK)
         return is_default_retryable_curle(ctx->curl_result);
-    }
-
-    if (retry_cfg->retry_http_count > 0) {
-        for (int i = 0; i < retry_cfg->retry_http_count; i++) {
-            if (retry_cfg->retry_http_codes[i] == (int)ctx->http_status)
-                return 1;
-        }
-    }
-
+    for (int i = 0; i < rc->retry_http_count; i++)
+        if (rc->retry_http_codes[i] == (int)ctx->http_status)
+            return 1;
     return 0;
 }
 
@@ -626,29 +580,28 @@ typedef struct {
 
 static void *sleep_without_gvl(void *arg) {
     sleep_arg_t *sa = (sleep_arg_t *)arg;
-    struct timespec ts;
-    ts.tv_sec = sa->delay_ms / 1000;
-    ts.tv_nsec = (sa->delay_ms % 1000) * 1000000L;
+    struct timespec ts = {.tv_sec = sa->delay_ms / 1000,
+                          .tv_nsec = (sa->delay_ms % 1000) * 1000000L};
     nanosleep(&ts, NULL);
     return NULL;
 }
 
+/* FIX #2: Fiber path releases GVL via run_via_fiber_worker */
 static void retry_delay_sleep(long delay_ms) {
     if (delay_ms <= 0)
         return;
-
-    if (has_fiber_scheduler()) {
+    VALUE scheduler = current_fiber_scheduler();
+    if (scheduler != Qnil) {
         long remaining = delay_ms;
         while (remaining > 0) {
             long chunk = remaining > FIBER_POLL_TIMEOUT_MS ? FIBER_POLL_TIMEOUT_MS : remaining;
             sleep_arg_t sa = {.delay_ms = chunk};
-            sleep_without_gvl(&sa);
-            rb_thread_schedule();
+            run_via_fiber_worker(scheduler, sleep_without_gvl, &sa);
             remaining -= chunk;
         }
     } else {
         sleep_arg_t sa = {.delay_ms = delay_ms};
-        rb_thread_call_without_gvl(sleep_without_gvl, &sa, unblock_perform, NULL);
+        rb_thread_call_without_gvl(sleep_without_gvl, &sa, (rb_unblock_function_t *)0, NULL);
     }
 }
 
@@ -659,50 +612,45 @@ static void parse_options(VALUE options, long *timeout, int *max_conn, retry_con
     retry_cfg->retry_delay_ms = DEFAULT_RETRY_DELAY;
     retry_cfg->retry_http_codes = NULL;
     retry_cfg->retry_http_count = 0;
-
     if (NIL_P(options) || !rb_obj_is_kind_of(options, rb_cHash))
         return;
 
     VALUE t = rb_hash_aref(options, sym_timeout);
     if (!NIL_P(t)) {
-        long timeout_val = NUM2LONG(t);
-        if (timeout_val > MAX_TIMEOUT)
-            timeout_val = MAX_TIMEOUT;
-        else if (timeout_val <= 0)
-            timeout_val = 30;
-        *timeout = timeout_val;
+        long v = NUM2LONG(t);
+        if (v > MAX_TIMEOUT)
+            v = MAX_TIMEOUT;
+        else if (v <= 0)
+            v = 30;
+        *timeout = v;
     }
-
     VALUE c = rb_hash_aref(options, sym_connections);
     if (!NIL_P(c)) {
-        int conn_val = NUM2INT(c);
-        if (conn_val > 100)
-            conn_val = 100;
-        else if (conn_val <= 0)
-            conn_val = 20;
-        *max_conn = conn_val;
+        int v = NUM2INT(c);
+        if (v > 100)
+            v = 100;
+        else if (v <= 0)
+            v = 20;
+        *max_conn = v;
     }
-
     VALUE r = rb_hash_aref(options, sym_retries);
     if (!NIL_P(r)) {
-        int retries_val = NUM2INT(r);
-        if (retries_val < 0)
-            retries_val = 0;
-        if (retries_val > MAX_RETRIES)
-            retries_val = MAX_RETRIES;
-        retry_cfg->max_retries = retries_val;
+        int v = NUM2INT(r);
+        if (v < 0)
+            v = 0;
+        if (v > MAX_RETRIES)
+            v = MAX_RETRIES;
+        retry_cfg->max_retries = v;
     }
-
     VALUE rd = rb_hash_aref(options, sym_retry_delay);
     if (!NIL_P(rd)) {
-        long delay_val = NUM2LONG(rd);
-        if (delay_val < 0)
-            delay_val = 0;
-        if (delay_val > 30000)
-            delay_val = 30000;
-        retry_cfg->retry_delay_ms = delay_val;
+        long v = NUM2LONG(rd);
+        if (v < 0)
+            v = 0;
+        if (v > 30000)
+            v = 30000;
+        retry_cfg->retry_delay_ms = v;
     }
-
     VALUE rc = rb_hash_aref(options, sym_retry_codes);
     if (!NIL_P(rc) && rb_obj_is_kind_of(rc, rb_cArray)) {
         int len = (int)RARRAY_LEN(rc);
@@ -710,211 +658,240 @@ static void parse_options(VALUE options, long *timeout, int *max_conn, retry_con
             retry_cfg->retry_http_codes = malloc(sizeof(int) * len);
             if (retry_cfg->retry_http_codes) {
                 retry_cfg->retry_http_count = len;
-                for (int i = 0; i < len; i++) {
+                for (int i = 0; i < len; i++)
                     retry_cfg->retry_http_codes[i] = NUM2INT(rb_ary_entry(rc, i));
-                }
             }
         }
     }
 }
 
-static VALUE internal_execute(VALUE requests, VALUE options, int target, int stream) {
-    Check_Type(requests, T_ARRAY);
-    int count = (int)RARRAY_LEN(requests);
-    if (count == 0)
-        return rb_ary_new();
-
-    long timeout_sec;
-    int max_conn;
-    retry_config_t retry_cfg;
-    parse_options(options, &timeout_sec, &max_conn, &retry_cfg);
-
-    /* Disable retries for stream and first_execute modes */
-    if (stream || target > 0) {
-        if (retry_cfg.max_retries > 0 && stream)
-            rb_warn(
-                "FastCurl: retries are not supported in stream_execute, ignoring retries option");
-        if (retry_cfg.max_retries > 0 && target > 0)
-            rb_warn(
-                "FastCurl: retries are not supported in first_execute, ignoring retries option");
-        retry_cfg.max_retries = 0;
+typedef struct {
+    multi_session_t *session;
+    int *invalid;
+    retry_config_t *retry_cfg;
+} cleanup_ctx_t;
+
+static VALUE cleanup_session(VALUE arg) {
+    cleanup_ctx_t *ctx = (cleanup_ctx_t *)arg;
+    if (ctx->session->requests) {
+        for (int i = 0; i < ctx->session->count; i++) {
+            if (ctx->session->requests[i].easy)
+                curl_multi_remove_handle(ctx->session->multi, ctx->session->requests[i].easy);
+            request_ctx_free(&ctx->session->requests[i]);
+        }
+        free(ctx->session->requests);
+        ctx->session->requests = NULL;
     }
-
-    multi_session_t session;
-    session.multi = curl_multi_init();
-    session.count = count;
-    session.timeout_ms = timeout_sec * 1000;
-    session.max_connections = max_conn;
-
-    curl_multi_setopt(session.multi, CURLMOPT_MAXCONNECTS, (long)max_conn);
-    curl_multi_setopt(session.multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long)max_conn);
-#ifdef CURLPIPE_MULTIPLEX
-    curl_multi_setopt(session.multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
-#endif
-
-    session.requests = calloc(count, sizeof(request_ctx_t));
-    if (!session.requests) {
-        curl_multi_cleanup(session.multi);
-        if (retry_cfg.retry_http_codes)
-            free(retry_cfg.retry_http_codes);
-        rb_raise(rb_eNoMemError, "failed to allocate request contexts");
+    if (ctx->invalid) {
+        free(ctx->invalid);
+        ctx->invalid = NULL;
     }
-
-    int *invalid = calloc(count, sizeof(int));
-    if (!invalid) {
-        free(session.requests);
-        curl_multi_cleanup(session.multi);
-        if (retry_cfg.retry_http_codes)
-            free(retry_cfg.retry_http_codes);
-        rb_raise(rb_eNoMemError, "failed to allocate tracking array");
+    if (ctx->session->multi) {
+        curl_multi_cleanup(ctx->session->multi);
+        ctx->session->multi = NULL;
+    }
+    if (ctx->retry_cfg && ctx->retry_cfg->retry_http_codes) {
+        free(ctx->retry_cfg->retry_http_codes);
+        ctx->retry_cfg->retry_http_codes = NULL;
     }
+    return Qnil;
+}
+
+typedef struct {
+    VALUE requests;
+    VALUE options;
+    int target;
+    int stream;
+    multi_session_t *session;
+    int *invalid;
+    retry_config_t *retry_cfg;
+    long timeout_sec;
+} execute_args_t;
+
+static VALUE internal_execute_body(VALUE arg) {
+    execute_args_t *ea = (execute_args_t *)arg;
+    VALUE requests = ea->requests;
+    multi_session_t *session = ea->session;
+    int *invalid = ea->invalid;
+    retry_config_t *retry_cfg = ea->retry_cfg;
+    long timeout_sec = ea->timeout_sec;
+    int count = session->count, target = ea->target, stream = ea->stream;
 
     int valid_requests = 0;
     for (int i = 0; i < count; i++) {
         VALUE req = rb_ary_entry(requests, i);
-        request_ctx_init(&session.requests[i], i);
-
-        if (!setup_easy_handle(&session.requests[i], req, timeout_sec)) {
-            session.requests[i].done = 1;
+        request_ctx_init(&session->requests[i], i);
+        if (!setup_easy_handle(&session->requests[i], req, timeout_sec)) {
+            session->requests[i].done = 1;
             invalid[i] = 1;
             continue;
         }
-
-        CURLMcode mc = curl_multi_add_handle(session.multi, session.requests[i].easy);
+        CURLMcode mc = curl_multi_add_handle(session->multi, session->requests[i].easy);
         if (mc != CURLM_OK) {
-            session.requests[i].done = 1;
+            session->requests[i].done = 1;
             invalid[i] = 1;
             continue;
         }
-
         valid_requests++;
     }
-
     if (valid_requests == 0)
-        session.still_running = 0;
+        session->still_running = 0;
 
     completion_ctx_t cctx;
     cctx.results = stream ? Qnil : rb_ary_new2(count);
     cctx.completed = 0;
     cctx.target = target;
     cctx.stream = stream;
-
     if (!stream) {
         for (int i = 0; i < count; i++)
             rb_ary_store(cctx.results, i, Qnil);
     }
 
-    run_multi_loop(&session, &cctx);
+    run_multi_loop(session, &cctx);
 
-    /* === Retry loop (execute mode only) === */
-    if (!stream && retry_cfg.max_retries > 0) {
+    if (!stream && retry_cfg->max_retries > 0) {
         int prev_all_failed = 0;
-
-        for (int attempt = 0; attempt < retry_cfg.max_retries; attempt++) {
+        for (int attempt = 0; attempt < retry_cfg->max_retries; attempt++) {
             int retry_count = 0;
-            int *retry_indices = malloc(sizeof(int) * count);
-            if (!retry_indices)
+            int *ri = malloc(sizeof(int) * count);
+            if (!ri)
                 break;
-
             for (int i = 0; i < count; i++) {
-                if (invalid[i])
+                if (invalid[i] || !session->requests[i].done)
                     continue;
-                if (!session.requests[i].done)
-                    continue;
-                if (should_retry(&session.requests[i], &retry_cfg)) {
-                    retry_indices[retry_count++] = i;
-                }
+                if (should_retry(&session->requests[i], retry_cfg))
+                    ri[retry_count++] = i;
             }
-
             if (retry_count == 0) {
-                free(retry_indices);
+                free(ri);
                 break;
             }
-
             int done_count = 0;
-            for (int i = 0; i < count; i++) {
-                if (!invalid[i] && session.requests[i].done)
+            for (int i = 0; i < count; i++)
+                if (!invalid[i] && session->requests[i].done)
                     done_count++;
-            }
-
-            int all_failed_this_round = (retry_count == done_count);
-
-            if (all_failed_this_round && prev_all_failed) {
-                free(retry_indices);
+            int all_failed = (retry_count == done_count);
+            if (all_failed && prev_all_failed) {
+                free(ri);
                 break;
             }
-
-            prev_all_failed = all_failed_this_round;
-
-            retry_delay_sleep(retry_cfg.retry_delay_ms);
-
+            prev_all_failed = all_failed;
+            retry_delay_sleep(retry_cfg->retry_delay_ms);
             for (int r = 0; r < retry_count; r++) {
-                int idx = retry_indices[r];
-                request_ctx_t *ctx = &session.requests[idx];
-
-                curl_multi_remove_handle(session.multi, ctx->easy);
-
-                if (!request_ctx_reset_for_retry(ctx)) {
-                    ctx->done = 1;
+                int idx = ri[r];
+                request_ctx_t *rc = &session->requests[idx];
+                curl_multi_remove_handle(session->multi, rc->easy);
+                if (!request_ctx_reset_for_retry(rc)) {
+                    rc->done = 1;
                     invalid[idx] = 1;
                     continue;
                 }
-
                 VALUE req = rb_ary_entry(requests, idx);
-                if (!setup_easy_handle(ctx, req, timeout_sec)) {
-                    ctx->done = 1;
+                if (!setup_easy_handle(rc, req, timeout_sec)) {
+                    rc->done = 1;
                     invalid[idx] = 1;
                     continue;
                 }
-
-                CURLMcode mc = curl_multi_add_handle(session.multi, ctx->easy);
+                CURLMcode mc = curl_multi_add_handle(session->multi, rc->easy);
                 if (mc != CURLM_OK) {
-                    ctx->done = 1;
+                    rc->done = 1;
                     invalid[idx] = 1;
                 }
             }
-
-            free(retry_indices);
-
+            free(ri);
             cctx.completed = 0;
-            run_multi_loop(&session, &cctx);
+            run_multi_loop(session, &cctx);
         }
     }
 
     if (!stream) {
         for (int i = 0; i < count; i++) {
-            request_ctx_t *ctx = &session.requests[i];
-
-            if (invalid[i]) {
-                VALUE error_response = build_error_response("Invalid request configuration");
-                VALUE pair = rb_ary_new_from_args(2, INT2NUM(i), error_response);
-                rb_ary_store(cctx.results, i, pair);
-                continue;
-            }
-
+            request_ctx_t *rc = &session->requests[i];
             VALUE response;
-            if (ctx->curl_result == CURLE_OK) {
-                response = build_response(ctx);
+            if (invalid[i]) {
+                response = build_error_response("Invalid request configuration");
+            } else if (rc->curl_result == CURLE_OK) {
+                response = build_response(rc);
             } else {
-                response = build_error_response_with_code(curl_easy_strerror(ctx->curl_result),
-                                                          (int)ctx->curl_result);
+                response = build_error_response_with_code(curl_easy_strerror(rc->curl_result),
+                                                          (int)rc->curl_result);
             }
-            VALUE pair = rb_ary_new_from_args(2, INT2NUM(i), response);
-            rb_ary_store(cctx.results, i, pair);
+            rb_ary_store(cctx.results, i, rb_ary_new_from_args(2, INT2NUM(i), response));
         }
     }
+    return stream ? Qnil : cctx.results;
+}
 
-    for (int i = 0; i < count; i++) {
-        curl_multi_remove_handle(session.multi, session.requests[i].easy);
-        request_ctx_free(&session.requests[i]);
+static VALUE internal_execute(VALUE requests, VALUE options, int target, int stream) {
+    Check_Type(requests, T_ARRAY);
+
+    long count_long = RARRAY_LEN(requests);
+    if (count_long == 0)
+        return rb_ary_new();
+    if (count_long > MAX_REQUESTS)
+        rb_raise(rb_eArgError, "too many requests (%ld), maximum is %d", count_long, MAX_REQUESTS);
+    if (count_long > INT_MAX)
+        rb_raise(rb_eArgError, "request count overflows int");
+    int count = (int)count_long;
+
+    long timeout_sec;
+    int max_conn;
+    retry_config_t retry_cfg;
+    parse_options(options, &timeout_sec, &max_conn, &retry_cfg);
+
+    if (stream || target > 0) {
+        if (retry_cfg.max_retries > 0 && stream)
+            rb_warn("FastCurl: retries are not supported in stream_execute, ignoring "
+                    "retries option");
+        if (retry_cfg.max_retries > 0 && target > 0)
+            rb_warn("FastCurl: retries are not supported in first_execute, ignoring "
+                    "retries option");
+        retry_cfg.max_retries = 0;
     }
-    free(session.requests);
-    free(invalid);
-    curl_multi_cleanup(session.multi);
-    if (retry_cfg.retry_http_codes)
-        free(retry_cfg.retry_http_codes);
 
-    return stream ? Qnil : cctx.results;
+    multi_session_t session;
+    session.multi = curl_multi_init();
+    session.count = count;
+    session.timeout_ms = timeout_sec * 1000;
+    session.max_connections = max_conn;
+    session.cancelled = 0;
+    session.requests = NULL;
+
+    curl_multi_setopt(session.multi, CURLMOPT_MAXCONNECTS, (long)max_conn);
+    curl_multi_setopt(session.multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long)max_conn);
+#ifdef CURLPIPE_MULTIPLEX
+    curl_multi_setopt(session.multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+#endif
+
+    session.requests = calloc(count, sizeof(request_ctx_t));
+    if (!session.requests) {
+        curl_multi_cleanup(session.multi);
+        if (retry_cfg.retry_http_codes)
+            free(retry_cfg.retry_http_codes);
+        rb_raise(rb_eNoMemError, "failed to allocate request contexts");
+    }
+
+    int *invalid = calloc(count, sizeof(int));
+    if (!invalid) {
+        free(session.requests);
+        curl_multi_cleanup(session.multi);
+        if (retry_cfg.retry_http_codes)
+            free(retry_cfg.retry_http_codes);
+        rb_raise(rb_eNoMemError, "failed to allocate tracking array");
+    }
+
+    cleanup_ctx_t cleanup = {.session = &session, .invalid = invalid, .retry_cfg = &retry_cfg};
+    execute_args_t ea = {
+        .requests = requests,
+        .options = options,
+        .target = target,
+        .stream = stream,
+        .session = &session,
+        .invalid = invalid,
+        .retry_cfg = &retry_cfg,
+        .timeout_sec = timeout_sec,
+    };
+    return rb_ensure(internal_execute_body, (VALUE)&ea, cleanup_session, (VALUE)&cleanup);
 }
 
 static VALUE rb_fast_curl_execute(int argc, VALUE *argv, VALUE self) {
@@ -926,24 +903,20 @@ static VALUE rb_fast_curl_execute(int argc, VALUE *argv, VALUE self) {
 static VALUE rb_fast_curl_first_execute(int argc, VALUE *argv, VALUE self) {
     VALUE requests, options;
     rb_scan_args(argc, argv, "1:", &requests, &options);
-
     int count = 1;
     if (!NIL_P(options)) {
         VALUE c = rb_hash_aref(options, sym_count);
         if (!NIL_P(c))
             count = NUM2INT(c);
     }
-
     return internal_execute(requests, options, count, 0);
 }
 
 static VALUE rb_fast_curl_stream_execute(int argc, VALUE *argv, VALUE self) {
     VALUE requests, options;
     rb_scan_args(argc, argv, "1:", &requests, &options);
-
     if (!rb_block_given_p())
         rb_raise(rb_eArgError, "stream_execute requires a block");
-
     return internal_execute(requests, options, -1, 1);
 }
 

data/lib/fast_curl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastCurl
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_curl
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - roman-haidarov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-25 00:00:00.000000000 Z
+date: 2026-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -123,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="