monotonic_grouper 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 819f3771c8e8b3153fece915aa61a2fdf43704303a32da8df659956e73e0c96c
-  data.tar.gz: fe9f394e978b8891707820596796b5afb8fdf582d8161c53d35a6ba26e9f1705
+  metadata.gz: a150a2735dc99df4715193f8075ad6a739723c170a25bc9ae61d628e50a8661f
+  data.tar.gz: eaa156e8d8f882969a5f9b07f54e4353c996a7adaf22181061e7ff80d0e7309e
 SHA512:
-  metadata.gz: 8857b22b3eb7c359024e2d51553f1cac2eed3fccdacfff17683ff7b562af4e2bb4c0815e4ee43b613ecfc98daeb4bd473d456d8a2fe5aacff37e2a63ee34655c
-  data.tar.gz: 3c631ea4f2e72fc3142ec3acf16a94b8f1b7bdbf78170b6e4b84fb1de44e59dec79e2cdcc4060b5a1edc0430ca919d0be73ff0b0b1e3073f351d0b6504ac343a
+  metadata.gz: 884a86506cff344b18254dbbaccb73ac5311ea98031995a6ada6e2b299e93c03170b0b2e3e513bfdd878a36769441fc043c390e41985011fa1db04cb86995f72
+  data.tar.gz: f2675721e13770fafbd540b82ad6d5b9f33efd1ede32e080b26450d2b5088177b831d985e52bd24aa9f9dbcfdb9ae2ac37df74b0755c756de2a9bdd7a148ba6c

data/README.md

@@ -11,14 +11,15 @@ Fast C extension for grouping monotonic sequences in Ruby arrays. Groups consecu
 - 💎 **Ruby-friendly**: Seamless integration as Array method
 - 🚀 **Optimized Date Processing**: Special fast path for Date objects with cached Julian Day calculations
 
-## Recent Updates (v1.0.2)
+## Recent Updates (v1.0.3 - Stable)
 
-### Bug Fixes
-- **Critical**: Fixed first element being incorrectly skipped in all processing paths
-- Fixed loop initialization bug that caused incorrect grouping results
+### Bug Fixes (v1.0.3)
+- **Critical**: Fixed `group_monotonic` method not being available on Array class in external applications
+- Properly encapsulated the method in Array class through C extension
 
-### Performance Improvements
-- **2x faster Date processing**: Optimized by caching Julian Day Numbers (only 1 Ruby call per iteration instead of 2)
+### Previous Updates (v1.0.2)
+- **Critical**: Fixed first element being incorrectly skipped in all processing paths
+- **2x faster Date processing**: Optimized by caching Julian Day Numbers
 - Faster array access using `RARRAY_AREF` macro
 - Better memory preallocation
 - Improved Date subclass handling (DateTime, custom Date classes)
@@ -42,15 +43,15 @@ require 'monotonic_grouper'
 
 # Basic integer usage
 [1, 2, 3, 4, 5, 10, 11, 12].group_monotonic(3)
-# => [2..5, 10..12]
+# => [1..5, 10..12]
 
 # With singles (sequences shorter than min_range_size)
 [1, 2, 3, 4, 7, 9, 10, 11, 12].group_monotonic(3)
-# => [2..4, 7, 9, 10..12]
+# => [1..4, 7, 9, 10..12]
 
 # Custom minimum range size
 [1, 2, 3, 5, 6, 8].group_monotonic(2)
-# => [2..3, 5..6, 8]
+# => [1..3, 5..6, 8]
 
 # Works with Dates
 require 'date'
@@ -63,12 +64,12 @@ dates = [
   Date.new(2024, 1, 7)
 ]
 dates.group_monotonic(3)
-# => [Date.new(2024, 1, 2)..Date.new(2024, 1, 3), 
+# => [Date.new(2024, 1, 1)..Date.new(2024, 1, 3), 
 #     Date.new(2024, 1, 5)..Date.new(2024, 1, 7)]
 
 # Works with characters
 ['a', 'b', 'c', 'd', 'f', 'g', 'h'].group_monotonic(3)
-# => ['b'..'d', 'f'..'h']
+# => ['a'..'d', 'f'..'h']
 ```
 
 ## API

data/ext/monotonic_grouper/monotonic_grouper.c

@@ -5,198 +5,220 @@
 #define RB_BIGNUM_TYPE_P(obj) (RB_TYPE_P((obj), T_BIGNUM))
 #endif
 
+static inline void seal_array_len(VALUE ary, VALUE *buf, long pos) {
+    if (pos == 0)
+        return;
+    rb_ary_store(ary, pos - 1, buf[pos - 1]);
+}
+
 static VALUE rb_mMonotonicGrouper;
 static VALUE rb_cDate;
 static ID id_succ;
-static ID id_eq;
 static ID id_jd;
 
-static inline int
-is_next_integer(VALUE a, VALUE b)
-{
-    if (FIXNUM_P(a) && FIXNUM_P(b)) {
-        long av = FIX2LONG(a);
-        long bv = FIX2LONG(b);
-        return bv == av + 1;
-    }
-    return 0;
-}
-
-static inline int
-is_next_in_sequence_generic(VALUE a, VALUE b)
-{
-    VALUE succ_a = rb_funcall(a, id_succ, 0);
-    return RTEST(rb_funcall(b, id_eq, 1, succ_a));
-}
-
-static void
-add_group_to_result_integer(VALUE result, VALUE group_start, VALUE group_end, long size, long min_range_size)
-{
-    if (size >= min_range_size) {
-        VALUE range = rb_range_new(group_start, group_end, 0);
-        rb_ary_push(result, range);
-    } else {
-        long j;
-        long start_val = FIX2LONG(group_start);
-        for (j = 0; j < size; j++) {
-            rb_ary_push(result, LONG2FIX(start_val + j));
-        }
-    }
-}
-
-static void
-add_group_to_result_date(VALUE result, VALUE group_start, VALUE group_end, long size, long min_range_size)
-{
-    if (size >= min_range_size) {
-        VALUE range = rb_range_new(group_start, group_end, 0);
-        rb_ary_push(result, range);
-    } else {
-        long j;
-        VALUE curr = group_start;
-        rb_ary_push(result, curr);
-        for (j = 1; j < size; j++) {
-            curr = rb_funcall(curr, id_succ, 0);
-            rb_ary_push(result, curr);
-        }
-    }
-}
+#define CHECK_ARRAY_MUTATION(ary, expected_len)                                \
+    do {                                                                       \
+        if (RARRAY_LEN(ary) != (expected_len)) {                               \
+            rb_raise(rb_eRuntimeError, "array was modified during iteration"); \
+        }                                                                      \
+    } while (0)
 
-static void
-add_group_to_result_generic(VALUE result, VALUE group_start, VALUE group_end, long size, long min_range_size)
-{
-    if (size >= min_range_size) {
-        VALUE range = rb_range_new(group_start, group_end, 0);
-        rb_ary_push(result, range);
-    } else {
-        long j;
-        VALUE curr = group_start;
-        rb_ary_push(result, curr);
-        for (j = 1; j < size; j++) {
-            curr = rb_funcall(curr, id_succ, 0);
-            rb_ary_push(result, curr);
-        }
-    }
-}
+static VALUE process_fixnum_array(VALUE self, long len, long min_range_size) {
+    const VALUE *ptr = RARRAY_CONST_PTR(self);
+    const VALUE *end_ptr = ptr + len;
 
-static VALUE
-process_integer_array(VALUE self, long len, long min_range_size)
-{
     VALUE result = rb_ary_new_capa(len);
-    VALUE first_elem = RARRAY_AREF(self, 0);
-    VALUE group_start = first_elem;
-    VALUE group_end = first_elem;
-    VALUE prev_value = first_elem;
-    long current_size = 1;
-    long i;
+    VALUE *out = RARRAY_PTR(result);
+    long pos = 0;
 
-    for (i = 1; i < len; i++) {
-        VALUE curr_value = RARRAY_AREF(self, i);
+    long group_start = FIX2LONG(*ptr);
+    long prev = group_start;
+    const VALUE *p;
+
+    for (p = ptr + 1; p < end_ptr; p++) {
+        VALUE raw = *p;
 
-        if (!FIXNUM_P(curr_value) && !RB_BIGNUM_TYPE_P(curr_value)) {
+        if (!FIXNUM_P(raw)) {
             rb_raise(rb_eTypeError, "All elements must be of the same type");
         }
 
-        if (is_next_integer(prev_value, curr_value)) {
-            group_end = curr_value;
-            current_size++;
+        long curr = FIX2LONG(raw);
+
+        if (curr == prev + 1) {
+            prev = curr;
         } else {
-            add_group_to_result_integer(result, group_start, group_end, current_size, min_range_size);
-            group_start = curr_value;
-            group_end = curr_value;
-            current_size = 1;
+            long size = prev - group_start + 1;
+            if (size >= min_range_size) {
+                out[pos++] = rb_range_new(LONG2FIX(group_start), LONG2FIX(prev), 0);
+            } else {
+                long v;
+                for (v = group_start; v <= prev; v++) {
+                    out[pos++] = LONG2FIX(v);
+                }
+            }
+            group_start = curr;
+            prev = curr;
         }
-
-        prev_value = curr_value;
     }
 
-    add_group_to_result_integer(result, group_start, group_end, current_size, min_range_size);
+    {
+        long size = prev - group_start + 1;
+        if (size >= min_range_size) {
+            out[pos++] = rb_range_new(LONG2FIX(group_start), LONG2FIX(prev), 0);
+        } else {
+            long v;
+            for (v = group_start; v <= prev; v++) {
+                out[pos++] = LONG2FIX(v);
+            }
+        }
+    }
 
+    seal_array_len(result, out, pos);
     return result;
 }
 
-static VALUE
-process_date_array(VALUE self, long len, long min_range_size, VALUE first_elem)
-{
+static VALUE process_date_array(VALUE self, long len, long min_range_size, VALUE first_elem) {
     VALUE result = rb_ary_new_capa(len);
+    VALUE *out = RARRAY_PTR(result);
+    long pos = 0;
+
     VALUE group_start = first_elem;
-    VALUE group_end = first_elem;
+    VALUE prev_value = first_elem;
     VALUE first_class = CLASS_OF(first_elem);
-    long current_size = 1;
-    long i;
     long prev_jd = NUM2LONG(rb_funcall(first_elem, id_jd, 0));
+    long group_start_jd = prev_jd;
+    long i;
 
     for (i = 1; i < len; i++) {
+        CHECK_ARRAY_MUTATION(self, len);
+
         VALUE curr_value = RARRAY_AREF(self, i);
+
         if (CLASS_OF(curr_value) != first_class) {
             rb_raise(rb_eTypeError, "All elements must be of the same type");
         }
 
         long curr_jd = NUM2LONG(rb_funcall(curr_value, id_jd, 0));
+        CHECK_ARRAY_MUTATION(self, len);
 
         if (curr_jd == prev_jd + 1) {
-            group_end = curr_value;
-            current_size++;
+            prev_value = curr_value;
+            prev_jd = curr_jd;
         } else {
-            add_group_to_result_date(result, group_start, group_end, current_size, min_range_size);
+            long size = prev_jd - group_start_jd + 1;
+            if (size >= min_range_size) {
+                out[pos++] = rb_range_new(group_start, prev_value, 0);
+            } else {
+                VALUE curr = group_start;
+                out[pos++] = curr;
+                long j;
+                for (j = 1; j < size; j++) {
+                    curr = rb_funcall(curr, id_succ, 0);
+                    CHECK_ARRAY_MUTATION(self, len);
+                    out[pos++] = curr;
+                }
+            }
             group_start = curr_value;
-            group_end = curr_value;
-            current_size = 1;
+            group_start_jd = curr_jd;
+            prev_value = curr_value;
+            prev_jd = curr_jd;
         }
-
-        prev_jd = curr_jd;
     }
 
-    add_group_to_result_date(result, group_start, group_end, current_size, min_range_size);
+    {
+        long size = prev_jd - group_start_jd + 1;
+        if (size >= min_range_size) {
+            out[pos++] = rb_range_new(group_start, prev_value, 0);
+        } else {
+            VALUE curr = group_start;
+            out[pos++] = curr;
+            long j;
+            for (j = 1; j < size; j++) {
+                curr = rb_funcall(curr, id_succ, 0);
+                CHECK_ARRAY_MUTATION(self, len);
+                out[pos++] = curr;
+            }
+        }
+    }
 
+    seal_array_len(result, out, pos);
     return result;
 }
 
-static VALUE
-process_generic_array(VALUE self, long len, long min_range_size, VALUE first_elem)
-{
+static VALUE process_generic_array(VALUE self, long len, long min_range_size, VALUE first_elem) {
     VALUE result = rb_ary_new_capa(len);
+    VALUE *out = RARRAY_PTR(result);
+    long pos = 0;
+
     VALUE group_start = first_elem;
-    VALUE group_end = first_elem;
     VALUE prev_value = first_elem;
     VALUE first_class = CLASS_OF(first_elem);
     long current_size = 1;
     long i;
 
     for (i = 1; i < len; i++) {
+        CHECK_ARRAY_MUTATION(self, len);
+
         VALUE curr_value = RARRAY_AREF(self, i);
+
         if (CLASS_OF(curr_value) != first_class) {
             rb_raise(rb_eTypeError, "All elements must be of the same type");
         }
 
-        if (is_next_in_sequence_generic(prev_value, curr_value)) {
-            group_end = curr_value;
+        VALUE succ_prev = rb_funcall(prev_value, id_succ, 0);
+        CHECK_ARRAY_MUTATION(self, len);
+
+        if (RTEST(rb_equal(curr_value, succ_prev))) {
             current_size++;
         } else {
-            add_group_to_result_generic(result, group_start, group_end, current_size, min_range_size);
+            if (current_size >= min_range_size) {
+                out[pos++] = rb_range_new(group_start, prev_value, 0);
+            } else {
+                VALUE curr = group_start;
+                out[pos++] = curr;
+                long j;
+                for (j = 1; j < current_size; j++) {
+                    curr = rb_funcall(curr, id_succ, 0);
+                    CHECK_ARRAY_MUTATION(self, len);
+                    out[pos++] = curr;
+                }
+            }
             group_start = curr_value;
-            group_end = curr_value;
             current_size = 1;
         }
 
         prev_value = curr_value;
     }
 
-    add_group_to_result_generic(result, group_start, group_end, current_size, min_range_size);
+    if (current_size >= min_range_size) {
+        out[pos++] = rb_range_new(group_start, prev_value, 0);
+    } else {
+        VALUE curr = group_start;
+        out[pos++] = curr;
+        long j;
+        for (j = 1; j < current_size; j++) {
+            curr = rb_funcall(curr, id_succ, 0);
+            CHECK_ARRAY_MUTATION(self, len);
+            out[pos++] = curr;
+        }
+    }
 
+    seal_array_len(result, out, pos);
     return result;
 }
 
-static VALUE
-rb_array_group_monotonic(int argc, VALUE *argv, VALUE self)
-{
-    VALUE min_range_size_val;
+static VALUE rb_array_group_monotonic(int argc, VALUE *argv, VALUE self) {
     long min_range_size;
     long len;
     VALUE first_elem;
-    VALUE first_class;
 
-    rb_scan_args(argc, argv, "01", &min_range_size_val);
-    min_range_size = NIL_P(min_range_size_val) ? 3 : NUM2LONG(min_range_size_val);
+    if (argc == 0) {
+        min_range_size = 3;
+    } else if (argc == 1) {
+        min_range_size = NUM2LONG(argv[0]);
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 0..1)", argc);
+    }
 
     if (min_range_size < 1) {
         rb_raise(rb_eArgError, "min_range_size must be at least 1");
@@ -209,10 +231,9 @@ rb_array_group_monotonic(int argc, VALUE *argv, VALUE self)
     }
 
     first_elem = RARRAY_AREF(self, 0);
-    first_class = CLASS_OF(first_elem);
 
-    if (FIXNUM_P(first_elem) || RB_BIGNUM_TYPE_P(first_elem)) {
-        return process_integer_array(self, len, min_range_size);
+    if (FIXNUM_P(first_elem)) {
+        return process_fixnum_array(self, len, min_range_size);
     }
 
     if (rb_cDate != Qnil && rb_obj_is_kind_of(first_elem, rb_cDate)) {
@@ -226,18 +247,13 @@ rb_array_group_monotonic(int argc, VALUE *argv, VALUE self)
     return process_generic_array(self, len, min_range_size, first_elem);
 }
 
-static VALUE
-get_date_class(VALUE obj)
-{
+static VALUE get_date_class(VALUE obj) {
     return rb_const_get(obj, rb_intern("Date"));
 }
 
-void
-Init_monotonic_grouper(void)
-{
+void Init_monotonic_grouper(void) {
     int state = 0;
     id_succ = rb_intern("succ");
-    id_eq = rb_intern("==");
     id_jd = rb_intern("jd");
     rb_mMonotonicGrouper = rb_define_module("MonotonicGrouper");
     rb_cDate = rb_protect(get_date_class, rb_cObject, &state);

data/lib/monotonic_grouper/version.rb

@@ -1,3 +1,3 @@
 module MonotonicGrouper
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monotonic_grouper
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Roman Hajdarov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-13 00:00:00.000000000 Z
+date: 2026-03-23 00:00:00.000000000 Z
 dependencies: []
 description: Groups consecutive monotonic sequences in arrays into ranges. Supports
   any Comparable type with succ method.
@@ -44,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.3.27
 signing_key:
 specification_version: 4
 summary: Fast C extension for grouping monotonic sequences