monotonic_grouper 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e62903ce3c859e0afe9812bcd66fb9125e92f730b8bb8bd0b368c6ace2ab385
-  data.tar.gz: c0a730777117df24089ccfbb799c152a54822ca1be1b9f7f84e27699d83d4fce
+  metadata.gz: a150a2735dc99df4715193f8075ad6a739723c170a25bc9ae61d628e50a8661f
+  data.tar.gz: eaa156e8d8f882969a5f9b07f54e4353c996a7adaf22181061e7ff80d0e7309e
 SHA512:
-  metadata.gz: ad1a76ec922ef77511a8b7ed5ecc9fbd5325411c9e5cfec491ae0ba651026486e550f0242125c5ddb0d5f4d05b8b1b23ae608efe7d86f1f0a8860981783a7c4c
-  data.tar.gz: ddfeddfebb196f6140631ebc492c83704191e75399f2a8586c1a1990d6829213c368796b0fcabe189753a4b187e22ed02d46f6f3b99e41609ae8099acc6e73eb
+  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,200 +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;
-}
+#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 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 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 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);
-        }
-    }
-}
-
-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_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;
 
-        if (!FIXNUM_P(curr_value) && !RB_BIGNUM_TYPE_P(curr_value)) {
+    for (p = ptr + 1; p < end_ptr; p++) {
+        VALUE raw = *p;
+
+        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;
-    
-    /* Cache the jd of the previous element to avoid double rb_funcall */
     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");
@@ -211,19 +231,15 @@ rb_array_group_monotonic(int argc, VALUE *argv, VALUE self)
     }
 
     first_elem = RARRAY_AREF(self, 0);
-    first_class = CLASS_OF(first_elem);
 
-    /* Fast path for integers */
-    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);
     }
 
-    /* Fast path for Date objects - use rb_obj_is_kind_of for safer checking */
     if (rb_cDate != Qnil && rb_obj_is_kind_of(first_elem, rb_cDate)) {
         return process_date_array(self, len, min_range_size, first_elem);
     }
 
-    /* Generic path for other Comparable types */
     if (!rb_respond_to(first_elem, id_succ)) {
         rb_raise(rb_eTypeError, "Elements must respond to :succ method");
     }
@@ -231,30 +247,20 @@ 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");
-    
-    /* Try to get Date class if it's loaded - use rb_protect to handle NameError */
     rb_cDate = rb_protect(get_date_class, rb_cObject, &state);
     if (state != 0) {
-        /* Date class not found, will use generic path */
         rb_cDate = Qnil;
-        rb_set_errinfo(Qnil); /* Clear the error */
+        rb_set_errinfo(Qnil);
     }
-    
+
     rb_define_method(rb_cArray, "group_monotonic", rb_array_group_monotonic, -1);
 }

data/lib/monotonic_grouper/version.rb

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

data/lib/monotonic_grouper.rb

@@ -1,4 +1,4 @@
-require 'monotonic_grouper/version'
+require_relative 'monotonic_grouper/version'
 
 # Load the compiled extension (.so on Linux, .bundle on macOS)
 begin
@@ -14,37 +14,3 @@ rescue LoadError
     raise LoadError, "Could not find compiled extension"
   end
 end
-
-module FastBloomFilter
-  class Filter
-    def add_all(items)
-      items.each { |item| add(item.to_s) }
-      self
-    end
-
-    def count_possible_matches(items)
-      items.count { |item| include?(item.to_s) }
-    end
-
-    def inspect
-      s = stats
-      total_kb = (s[:total_bytes] / 1024.0).round(2)
-      fill_pct = (s[:fill_ratio] * 100).round(2)
-
-      "#<FastBloomFilter::Filter v2 layers=#{s[:num_layers]} " \
-      "count=#{s[:total_count]} size=#{total_kb}KB fill=#{fill_pct}%>"
-    end
-
-    def to_s
-      inspect
-    end
-  end
-
-  def self.for_emails(error_rate: 0.001, initial_capacity: 10_000)
-    Filter.new(error_rate: error_rate, initial_capacity: initial_capacity)
-  end
-
-  def self.for_urls(error_rate: 0.01, initial_capacity: 10_000)
-    Filter.new(error_rate: error_rate, initial_capacity: initial_capacity)
-  end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monotonic_grouper
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  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