monotonic_grouper 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6700d9d08b4725c4ca545f6c918459875746f9d51a1c1c4cd6ef803de32ab079
-  data.tar.gz: e2e9664581ccc2e83a4222734639bc601a61359b921b661b2a6d0e85179ce2eb
+  metadata.gz: 7e62903ce3c859e0afe9812bcd66fb9125e92f730b8bb8bd0b368c6ace2ab385
+  data.tar.gz: c0a730777117df24089ccfbb799c152a54822ca1be1b9f7f84e27699d83d4fce
 SHA512:
-  metadata.gz: f78de87f34643af21eb231ef785232ad68151d70dc169ad79ad2d59532507a040181730855a10c72788a189b3507aab24fbdec354908ced9fbf8f8c3d6878275
-  data.tar.gz: 68487ada476bf918ed24909a885c1d5cd10c18ce9c3ffb0adf93971548c3294b81ad312e04050fcdd2ef4bca8a982be61b7638294d2a8002888ce28ad46c887c
+  metadata.gz: ad1a76ec922ef77511a8b7ed5ecc9fbd5325411c9e5cfec491ae0ba651026486e550f0242125c5ddb0d5f4d05b8b1b23ae608efe7d86f1f0a8860981783a7c4c
+  data.tar.gz: ddfeddfebb196f6140631ebc492c83704191e75399f2a8586c1a1990d6829213c368796b0fcabe189753a4b187e22ed02d46f6f3b99e41609ae8099acc6e73eb

data/README.md

@@ -9,6 +9,19 @@ Fast C extension for grouping monotonic sequences in Ruby arrays. Groups consecu
 - 📅 **Multiple Types**: Integers, Dates, Characters, and more
 - 🎯 **Configurable**: Adjustable minimum range size
 - 💎 **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)
+
+### Bug Fixes
+- **Critical**: Fixed first element being incorrectly skipped in all processing paths
+- Fixed loop initialization bug that caused incorrect grouping results
+
+### Performance Improvements
+- **2x faster Date processing**: Optimized by caching Julian Day Numbers (only 1 Ruby call per iteration instead of 2)
+- Faster array access using `RARRAY_AREF` macro
+- Better memory preallocation
+- Improved Date subclass handling (DateTime, custom Date classes)
 
 ## Installation
 

data/ext/monotonic_grouper/monotonic_grouper.c

@@ -1,12 +1,15 @@
 #include <ruby.h>
+#include <ruby/encoding.h>
 
 #ifndef RB_BIGNUM_TYPE_P
 #define RB_BIGNUM_TYPE_P(obj) (RB_TYPE_P((obj), T_BIGNUM))
 #endif
 
 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)
@@ -41,6 +44,23 @@ add_group_to_result_integer(VALUE result, VALUE group_start, VALUE group_end, lo
     }
 }
 
+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)
 {
@@ -61,8 +81,8 @@ add_group_to_result_generic(VALUE result, VALUE group_start, VALUE group_end, lo
 static VALUE
 process_integer_array(VALUE self, long len, long min_range_size)
 {
-    VALUE result = rb_ary_new2(len / 2);
-    VALUE first_elem = rb_ary_entry(self, 0);
+    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;
@@ -70,7 +90,7 @@ process_integer_array(VALUE self, long len, long min_range_size)
     long i;
 
     for (i = 1; i < len; i++) {
-        VALUE curr_value = rb_ary_entry(self, i);
+        VALUE curr_value = RARRAY_AREF(self, i);
 
         if (!FIXNUM_P(curr_value) && !RB_BIGNUM_TYPE_P(curr_value)) {
             rb_raise(rb_eTypeError, "All elements must be of the same type");
@@ -94,10 +114,49 @@ process_integer_array(VALUE self, long len, long min_range_size)
     return result;
 }
 
+static VALUE
+process_date_array(VALUE self, long len, long min_range_size, VALUE first_elem)
+{
+    VALUE result = rb_ary_new_capa(len);
+    VALUE group_start = first_elem;
+    VALUE group_end = 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));
+
+    for (i = 1; i < len; i++) {
+        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));
+        
+        if (curr_jd == prev_jd + 1) {
+            group_end = curr_value;
+            current_size++;
+        } else {
+            add_group_to_result_date(result, group_start, group_end, current_size, min_range_size);
+            group_start = curr_value;
+            group_end = curr_value;
+            current_size = 1;
+        }
+
+        prev_jd = curr_jd;
+    }
+
+    add_group_to_result_date(result, group_start, group_end, current_size, min_range_size);
+
+    return result;
+}
+
 static VALUE
 process_generic_array(VALUE self, long len, long min_range_size, VALUE first_elem)
 {
-    VALUE result = rb_ary_new2(len / 2);
+    VALUE result = rb_ary_new_capa(len);
     VALUE group_start = first_elem;
     VALUE group_end = first_elem;
     VALUE prev_value = first_elem;
@@ -106,7 +165,7 @@ process_generic_array(VALUE self, long len, long min_range_size, VALUE first_ele
     long i;
 
     for (i = 1; i < len; i++) {
-        VALUE curr_value = rb_ary_entry(self, i);
+        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");
         }
@@ -136,6 +195,7 @@ 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);
@@ -150,12 +210,20 @@ rb_array_group_monotonic(int argc, VALUE *argv, VALUE self)
         return rb_ary_new();
     }
 
-    first_elem = rb_ary_entry(self, 0);
+    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);
     }
 
+    /* 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");
     }
@@ -163,11 +231,30 @@ 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)
+{
+    return rb_const_get(obj, rb_intern("Date"));
+}
+
 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_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.1"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monotonic_grouper
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Roman Hajdarov