rbtree 0.4.2 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 35a51532a317785f995191b86990fd197d3a08d7
-  data.tar.gz: fc58dc292ed9763c6b8731ca2998c6affe591007
+SHA256:
+  metadata.gz: a5ec1fb39918d82821706cea18cb63b25fd4d20a989579664f7b95774f43881f
+  data.tar.gz: 3795d33cbbf811cdfd7b92664eca4156760c8d3bb36fa28a9854720279c6c1dd
 SHA512:
-  metadata.gz: 75b7c55bd29b9341ae5969742855aa15893af18574d7c5ff734ea8e52b3e25f1ccb290c72bb27b58ae8e61db533b2d04b15cab80ff3e64239aee02f63591be35
-  data.tar.gz: d1b1c0def86af19fd6b6a2bdcf7e2147b3f0e1ea340276d283884ee50b7fe3bd91c5f55e7495dcda3652fd9443b55d930044ce007ab707dc196cca3f45834011
+  metadata.gz: 3df17e8770de0b0e7396b454905ca5a1d1de24d2dc006de0283a29c9a0805b772442f510dd9ce66bbe590499128d5375da4e61ae7e8396abed455833204af79d
+  data.tar.gz: ba6402624a047e104e2ddb70a37b19f1d01c2ce7b88752f19c9396fd197c8b58c8e3e3daa21974038b1a44676ee2af40c220dfc1fd300ad6796590fecdca5e30

data/README

@@ -57,21 +57,17 @@ Run the following command.
   $ sudo gem install rbtree
 
 == Changes
-=== 0.4.2
-* Fixed build failure with Ruby 2.1.0.
+=== 0.4.6
+* Make it work with clang 15.
 
-=== 0.4.1
-* Fixed a crash that could be triggered when GC happened.
+=== 0.4.5
+* Support Ruby 3.2.0-dev (development branch).
 
-=== 0.4.0
+=== 0.4.4
+* Remove the rb_safe_level warning on Ruby 2.7.
 
-* Fixed build failure with Ruby 2.0.0.
-* \#bound now returns an enumerator if no block is given.
-* \#select now returns a new MultiRBTree / RBTree.
-* Fixed a bug where \#reject could return nil.
-* \#to_s is now equivalent to \#inspect.
-* \#each now passes a two elements array as an argument to the given block.
-* Added new methods: \#default_proc=, \#flatten, \#keep_if, \#key, \#select! and \#to_h.
+=== 0.4.3
+* Quick bug fixes for Ruby 3.
 
 == License
 

data/extconf.rb

@@ -5,11 +5,14 @@ if enable_config('debug')
 else
   $defs << '-DNDEBUG'
 end
+have_header('ruby/version.h')
 have_func('rb_exec_recursive', 'ruby.h')
 have_func('rb_exec_recursive_paired', 'ruby.h')
 have_func('rb_proc_lambda_p', 'ruby.h')
 have_func('rb_ary_resize', 'ruby.h')
 have_func('rb_obj_hide', 'ruby.h')
+have_func('rb_safe_level', 'ruby.h')
+have_func('rb_cData', 'ruby.h')
 if Hash.method_defined?(:flatten)
   $defs << '-DHAVE_HASH_FLATTEN'
 end

data/rbtree.c

@@ -3,6 +3,9 @@
  * Copyright (c) 2002-2013 OZAWA Takuma
  */
 #include <ruby.h>
+#ifdef HAVE_RUBY_VERSION_H
+#include <ruby/version.h>
+#endif
 #ifdef HAVE_RUBY_ST_H
 #include <ruby/st.h>
 #else
@@ -134,22 +137,24 @@ static int
 rbtree_cmp(const void* key1, const void* key2, void* context)
 {
     VALUE result;
-    if (TYPE(key1) == T_STRING && TYPE(key2) == T_STRING)
+    if (TYPE((VALUE)key1) == T_STRING && TYPE((VALUE)key2) == T_STRING)
         return rb_str_cmp((VALUE)key1, (VALUE)key2);
     result = rb_funcall2((VALUE)key1, id_cmp, 1, (VALUE*)&key2);
     return rb_cmpint(result, (VALUE)key1, (VALUE)key2);
 }
 
 static VALUE
-rbtree_user_cmp_ensure(rbtree_t* rbtree)
+rbtree_user_cmp_ensure(VALUE arg)
 {
+    rbtree_t* rbtree = (rbtree_t*)arg;
     rbtree->iter_lev--;
     return Qnil;
 }
 
 static VALUE
-rbtree_user_cmp_body(VALUE* args)
+rbtree_user_cmp_body(VALUE arg)
 {
+    VALUE *args = (VALUE*)arg;
     rbtree_t* rbtree = (rbtree_t*)args[2];
     rbtree->iter_lev++;
     return rb_funcall2(rbtree->cmp_proc, id_call, 2, args);
@@ -176,8 +181,10 @@ rbtree_modify(VALUE self)
     if (ITER_LEV(self) > 0)
         rb_raise(rb_eTypeError, "can't modify rbtree during iteration");
     rb_check_frozen(self);
+#if defined(HAVE_RB_SAFE_LEVEL) && !defined(RUBY_SAFE_LEVEL_MAX)
     if (!OBJ_TAINTED(self) && rb_safe_level() >= 4)
         rb_raise(rb_eSecurityError, "Insecure: can't modify rbtree");
+#endif
 }
 
 static VALUE
@@ -187,14 +194,14 @@ rbtree_alloc(VALUE klass)
     VALUE rbtree = Data_Wrap_Struct(klass, rbtree_mark, rbtree_free, NULL);
     RBTREE(rbtree) = ALLOC(rbtree_t);
     MEMZERO(RBTREE(rbtree), rbtree_t, 1);
-    
+
     dict = ALLOC(dict_t);
     dict_init(dict, rbtree_cmp);
     dict_set_allocator(dict, rbtree_alloc_node, rbtree_free_node,
                        RBTREE(rbtree));
     if (!RTEST(rb_class_inherited_p(klass, RBTree)))
         dict_allow_dupes(dict);
-    
+
     DICT(rbtree) = dict;
     IFNONE(rbtree) = Qnil;
     CMP_PROC(rbtree) = Qnil;
@@ -224,29 +231,29 @@ rbtree_s_create(int argc, VALUE* argv, VALUE klass)
 {
     long i;
     VALUE rbtree;
-    
+
     if (argc == 1) {
         VALUE temp;
-        
+
         if (rb_obj_is_kind_of(argv[0], klass)) {
             rbtree = rbtree_alloc(klass);
             rbtree_update(rbtree, argv[0]);
             return rbtree;
         }
-        
+
         if (RTEST(rb_class_inherited_p(klass, RBTree)) &&
             (rb_obj_is_kind_of(argv[0], MultiRBTree) && !rb_obj_is_kind_of(argv[0], RBTree))) {
-            
+
             rb_raise(rb_eTypeError, "wrong argument type MultiRBTree (expected RBTree)");
         }
-        
+
         temp = rb_check_convert_type(argv[0], T_HASH, "Hash", "to_hash");
         if (!NIL_P(temp)) {
             rbtree = rbtree_alloc(klass);
             rb_hash_foreach(temp, hash_to_rbtree_i, rbtree);
             return rbtree;
         }
-        
+
         temp = rb_check_array_type(argv[0]);
         if (!NIL_P(temp)) {
             rbtree = rbtree_alloc(klass);
@@ -272,7 +279,7 @@ rbtree_s_create(int argc, VALUE* argv, VALUE klass)
             return rbtree;
         }
     }
-    
+
     if (argc % 2 != 0)
         rb_raise(rb_eArgError, "odd number of arguments for %s", rb_class2name(klass));
 
@@ -321,11 +328,12 @@ typedef struct {
 } rbtree_insert_arg_t;
 
 static VALUE
-insert_node_body(rbtree_insert_arg_t* arg)
+insert_node_body(VALUE arg_)
 {
+    rbtree_insert_arg_t* arg = (rbtree_insert_arg_t*)arg_;
     dict_t* dict = arg->dict;
     dnode_t* node = arg->node;
-    
+
     if (dict_insert(dict, node, dnode_getkey(node))) {
         if (TYPE(GET_KEY(node)) == T_STRING) {
             arg->result = KeyAllocationFailed;
@@ -339,11 +347,12 @@ insert_node_body(rbtree_insert_arg_t* arg)
 }
 
 static VALUE
-insert_node_ensure(rbtree_insert_arg_t* arg)
+insert_node_ensure(VALUE arg_)
 {
+    rbtree_insert_arg_t* arg = (rbtree_insert_arg_t*)arg_;
     dict_t* dict = arg->dict;
     dnode_t* node = arg->node;
-    
+
     switch (arg->result) {
     case InsertionSucceeded:
         break;
@@ -366,7 +375,7 @@ rbtree_insert(VALUE self, VALUE key, VALUE value)
 
     dnode_init(node, TO_VAL(value));
     node->dict_key = TO_KEY(key);
-    
+
     arg.dict = dict;
     arg.node = node;
     arg.result = NoNodeInserted;
@@ -501,14 +510,14 @@ VALUE
 rbtree_set_default_proc(VALUE self, VALUE proc)
 {
     VALUE temp;
-    
+
     rbtree_modify(self);
     if (NIL_P(proc)) {
         IFNONE(self) = Qnil;
         FL_UNSET(self, RBTREE_PROC_DEFAULT);
         return Qnil;
     }
-    
+
     temp = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc");
     if (NIL_P(temp)) {
         rb_raise(rb_eTypeError,
@@ -528,16 +537,16 @@ rbtree_recursive_equal(VALUE self, VALUE other, int recursive)
     dict_t* dict2 = DICT(other);
     dnode_t* node1;
     dnode_t* node2;
-    
+
     if (recursive)
         return Qtrue;
     for (node1 = dict_first(dict1), node2 = dict_first(dict2);
          node1 != NULL && node2 != NULL;
          node1 = dict_next(dict1, node1), node2 = dict_next(dict2, node2)) {
-        
+
         if (!rb_equal(GET_KEY(node1), GET_KEY(node2)) ||
             !rb_equal(GET_VAL(node1), GET_VAL(node2))) {
-            
+
             return Qfalse;
         }
     }
@@ -557,7 +566,7 @@ rbtree_equal(VALUE self, VALUE other)
     if (dict_count(DICT(self)) != dict_count(DICT(other)) ||
         DICT(self)->dict_compare != DICT(other)->dict_compare ||
         CMP_PROC(self) != CMP_PROC(other)) {
-        
+
         return Qfalse;
     }
 #if defined(HAVE_RB_EXEC_RECURSIVE_PAIRED)
@@ -592,14 +601,15 @@ rbtree_each_ensure(VALUE self)
 }
 
 static VALUE
-rbtree_each_body(rbtree_each_arg_t* arg)
+rbtree_each_body(VALUE arg_)
 {
+    rbtree_each_arg_t* arg = (rbtree_each_arg_t*)arg_;
     VALUE self = arg->self;
     dict_t* dict = DICT(self);
     dnode_t* node;
     dnode_t* first_node;
     dnode_t* (*next_func)(dict_t*, dnode_t*);
-    
+
     if (arg->reverse) {
         first_node = dict_last(dict);
         next_func = dict_prev;
@@ -607,12 +617,12 @@ rbtree_each_body(rbtree_each_arg_t* arg)
         first_node = dict_first(dict);
         next_func = dict_next;
     }
-    
+
     ITER_LEV(self)++;
     for (node = first_node;
          node != NULL;
          node = next_func(dict, node)) {
-        
+
         if (arg->func(node, arg->arg) == EACH_STOP)
             break;
     }
@@ -763,7 +773,11 @@ copy_dict(VALUE src, VALUE dest, dict_comp_t cmp_func, VALUE cmp_proc)
     }
     rbtree_free(RBTREE(temp));
     RBTREE(temp) = NULL;
+#if defined(RUBY_API_VERSION_CODE) && RUBY_API_VERSION_CODE >= 30100
+    /* do nothing */
+#else
     rb_gc_force_recycle(temp);
+#endif
 
     DICT(dest)->dict_context = RBTREE(dest);
     CMP_PROC(dest) = cmp_proc;
@@ -776,7 +790,7 @@ VALUE
 rbtree_initialize_copy(VALUE self, VALUE other)
 {
     rbtree_modify(self);
-    
+
     if (self == other)
         return self;
     if (!rb_obj_is_kind_of(other, CLASS_OF(self))) {
@@ -784,9 +798,9 @@ rbtree_initialize_copy(VALUE self, VALUE other)
                  rb_obj_classname(other),
                  rb_obj_classname(self));
     }
-    
+
     copy_dict(other, self, DICT(other)->dict_compare, CMP_PROC(other));
-    
+
     IFNONE(self) = IFNONE(other);
     if (FL_TEST(other, RBTREE_PROC_DEFAULT))
         FL_SET(self, RBTREE_PROC_DEFAULT);
@@ -803,7 +817,7 @@ rbtree_values_at(int argc, VALUE* argv, VALUE self)
 {
     long i;
     VALUE ary = rb_ary_new2(argc);
-    
+
     for (i = 0; i < argc; i++)
         rb_ary_push(ary, rbtree_aref(self, argv[i]));
     return ary;
@@ -890,8 +904,9 @@ typedef struct {
 } rbtree_remove_if_arg_t;
 
 static VALUE
-rbtree_remove_if_ensure(rbtree_remove_if_arg_t* arg)
+rbtree_remove_if_ensure(VALUE arg_)
 {
+    rbtree_remove_if_arg_t* arg = (rbtree_remove_if_arg_t*)arg_;
     dict_t* dict = DICT(arg->self);
     dnode_list_t* list = arg->list;
 
@@ -908,8 +923,9 @@ rbtree_remove_if_ensure(rbtree_remove_if_arg_t* arg)
 }
 
 static VALUE
-rbtree_remove_if_body(rbtree_remove_if_arg_t* arg)
+rbtree_remove_if_body(VALUE arg_)
 {
+    rbtree_remove_if_arg_t* arg = (rbtree_remove_if_arg_t*)arg_;
     VALUE self = arg->self;
     dict_t* dict = DICT(self);
     dnode_t* node;
@@ -937,7 +953,7 @@ static VALUE
 rbtree_remove_if(VALUE self, const int if_true)
 {
     rbtree_remove_if_arg_t arg;
-    
+
     RETURN_SIZED_ENUMERATOR(self, 0, NULL, rbtree_size);
     rbtree_modify(self);
     arg.self = self;
@@ -974,7 +990,7 @@ VALUE
 rbtree_reject_bang(VALUE self)
 {
     dictcount_t count;
-    
+
     RETURN_SIZED_ENUMERATOR(self, 0, NULL, rbtree_size);
     count = dict_count(DICT(self));
     rbtree_delete_if(self);
@@ -990,14 +1006,14 @@ VALUE
 rbtree_select_bang(VALUE self)
 {
     dictcount_t count;
-    
+
     RETURN_SIZED_ENUMERATOR(self, 0, NULL, rbtree_size);
     count = dict_count(DICT(self));
     rbtree_keep_if(self);
     if (count == dict_count(DICT(self)))
         return Qnil;
     return self;
-    
+
 }
 
 /*********************************************************************/
@@ -1013,7 +1029,7 @@ select_i(dnode_t* node, void* arg_)
     VALUE key = GET_KEY(node);
     VALUE value = GET_VAL(node);
     rbtree_select_if_arg_t* arg = arg_;
-    
+
     if (RTEST(rb_yield_values(2, key, value)) == arg->if_true) {
         rbtree_aset(arg->result, key, value);
     }
@@ -1024,7 +1040,7 @@ static VALUE
 rbtree_select_if(VALUE self, const int if_true)
 {
     rbtree_select_if_arg_t arg;
-    
+
     RETURN_SIZED_ENUMERATOR(self, 0, NULL, rbtree_size);
     arg.result = rbtree_alloc(CLASS_OF(self));
     arg.if_true = if_true;
@@ -1063,7 +1079,7 @@ rbtree_shift_pop(VALUE self, const int shift)
 
     if (dict_isempty(dict))
         return rb_funcall(self, id_default, 1, Qnil);
-    
+
     if (shift)
         node = dict_last(dict);
     else
@@ -1145,7 +1161,7 @@ rbtree_update(VALUE self, VALUE other)
                  rb_obj_classname(other),
                  rb_obj_classname(self));
     }
-    
+
     if (rb_block_given_p())
         rbtree_for_each(other, update_block_i, (void*)self);
     else
@@ -1267,6 +1283,13 @@ to_a_i(dnode_t* node, void* ary)
     return EACH_NEXT;
 }
 
+
+#if defined(RUBY_API_VERSION_CODE) && RUBY_API_VERSION_CODE >= 30100
+#  define RBTREE_OBJ_INFECT(obj1, obj2)
+#else
+#  define RBTREE_OBJ_INFECT(obj1, obj2) OBJ_INFECT(obj1, obj2)
+#endif
+
 /*
  *
  */
@@ -1275,7 +1298,7 @@ rbtree_to_a(VALUE self)
 {
     VALUE ary = rb_ary_new2(dict_count(DICT(self)));
     rbtree_for_each(self, to_a_i, (void*)ary);
-    OBJ_INFECT(ary, self);
+    RBTREE_OBJ_INFECT(ary, self);
     return ary;
 }
 
@@ -1295,13 +1318,13 @@ rbtree_to_hash(VALUE self)
     VALUE hash;
     if (!rb_obj_is_kind_of(self, RBTree))
         rb_raise(rb_eTypeError, "can't convert MultiRBTree to Hash");
-    
+
     hash = rb_hash_new();
     rbtree_for_each(self, to_hash_i, (void*)hash);
     RHASH_SET_IFNONE(hash, IFNONE(self));
     if (FL_TEST(self, RBTREE_PROC_DEFAULT))
         FL_SET(hash, HASH_PROC_DEFAULT);
-    OBJ_INFECT(hash, self);
+    RBTREE_OBJ_INFECT(hash, self);
     return hash;
 }
 
@@ -1336,13 +1359,13 @@ inspect_i(dnode_t* node, void* result_)
 
     str = rb_inspect(GET_KEY(node));
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
+    RBTREE_OBJ_INFECT(result, str);
 
     rb_str_cat2(result, "=>");
 
     str = rb_inspect(GET_VAL(node));
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
+    RBTREE_OBJ_INFECT(result, str);
 
     return EACH_NEXT;
 }
@@ -1351,7 +1374,7 @@ static VALUE
 inspect_rbtree(VALUE self, VALUE result)
 {
     VALUE str;
-    
+
     rb_str_cat2(result, "{");
     RSTRING_PTR(result)[0] = '-';
     rbtree_for_each(self, inspect_i, (void*)result);
@@ -1361,15 +1384,15 @@ inspect_rbtree(VALUE self, VALUE result)
     str = rb_inspect(IFNONE(self));
     rb_str_cat2(result, ", default=");
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
-    
+    RBTREE_OBJ_INFECT(result, str);
+
     str = rb_inspect(CMP_PROC(self));
     rb_str_cat2(result, ", cmp_proc=");
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
+    RBTREE_OBJ_INFECT(result, str);
 
     rb_str_cat2(result, ">");
-    OBJ_INFECT(result, self);
+    RBTREE_OBJ_INFECT(result, self);
     return result;
 }
 
@@ -1460,8 +1483,9 @@ typedef struct {
 } rbtree_bound_arg_t;
 
 static VALUE
-rbtree_bound_body(rbtree_bound_arg_t* arg)
+rbtree_bound_body(VALUE arg_)
 {
+    rbtree_bound_arg_t* arg = (rbtree_bound_arg_t*)arg_;
     VALUE self = arg->self;
     dict_t* dict = DICT(self);
     dnode_t* lower_node = arg->lower_node;
@@ -1495,18 +1519,18 @@ rbtree_bound_size(VALUE self, VALUE args)
     dnode_t* upper_node = dict_upper_bound(DICT(self), TO_KEY(key2));
     dictcount_t count = 0;
     dnode_t* node;
-    
+
     if (lower_node == NULL || upper_node == NULL ||
         DICT(self)->dict_compare(dnode_getkey(lower_node),
                                  dnode_getkey(upper_node),
                                  DICT(self)->dict_context) > 0) {
         return INT2FIX(0);
     }
-    
+
     for (node = lower_node;
          node != NULL;
          node = dict_next(DICT(self), node)) {
-        
+
         count++;
         if (node == upper_node) {
             break;
@@ -1533,7 +1557,7 @@ rbtree_bound_size(VALUE self, VALUE args)
  *   mrbtree = MultiRBTree["az", 10, "ba", 20, "ba", 30, "bz", 40]
  *   mrbtree.bound("ba").to_a # => [["ba", 20], ["ba", 30]]
  *   mrbtree.bound("b", "c").to_a # => [["ba", 20], ["ba", 30], ["bz", 40]]
- *   
+ *
  *   # the lower bound ("ba") exceeds the upper bound ("az")
  *   mrbtree.bound("b").to_a # => []
  */
@@ -1544,15 +1568,15 @@ rbtree_bound(int argc, VALUE* argv, VALUE self)
     dnode_t* lower_node;
     dnode_t* upper_node;
     VALUE result;
-    
+
     rbtree_check_argument_count(argc, 1, 2);
-    
+
     RETURN_SIZED_ENUMERATOR(self, argc, argv, rbtree_bound_size);
-    
+
     lower_node = dict_lower_bound(dict, TO_KEY(argv[0]));
     upper_node = dict_upper_bound(dict, TO_KEY(argv[argc - 1]));
     result = rb_block_given_p() ? self : rb_ary_new();
-    
+
     if (lower_node == NULL || upper_node == NULL ||
         DICT(self)->dict_compare(dnode_getkey(lower_node),
                                  dnode_getkey(upper_node),
@@ -1577,7 +1601,7 @@ rbtree_first_last(VALUE self, const int first)
 
     if (dict_isempty(dict))
         return rb_funcall(self, id_default, 1, Qnil);
-    
+
     if (first)
         node = dict_first(dict);
     else
@@ -1627,7 +1651,7 @@ rbtree_last(VALUE self)
  *   rbtree = RBTree["a", 10, "b", 20]
  *   rbtree.readjust {|a, b| b <=> a }
  *   rbtree.first # => ["b", 20]
- *   
+ *
  *   rbtree.readjust(nil)
  *   rbtree.first # => ["a", 10]
  */
@@ -1636,7 +1660,7 @@ rbtree_readjust(int argc, VALUE* argv, VALUE self)
 {
     dict_comp_t cmp_func = NULL;
     VALUE cmp_proc = Qnil;
-    
+
     rbtree_modify(self);
 
     if (rb_block_given_p()) {
@@ -1699,12 +1723,28 @@ static ID id_object_group;
 static ID id_pp;
 static ID id_text;
 
+#if defined(RUBY_VERSION_MAJOR) && RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8
+#define RUBY_1_8
+#endif
+
+#ifdef RUBY_1_8
 static VALUE
 pp_group(VALUE args_)
 {
     VALUE* args = (VALUE*)args_;
     return rb_funcall(args[0], id_group, 3, args[1], args[2], args[3]);
 }
+#endif
+
+static VALUE
+call_group_with_block(VALUE *group_args, VALUE (*blk)(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg)), VALUE data)
+{
+#ifdef RUBY_1_8
+    return rb_iterate(pp_group, (VALUE)&group_args, blk, data);
+#else
+    return rb_block_call(group_args[0], id_group, 3, group_args + 1, blk, data);
+#endif
+}
 
 typedef struct {
     VALUE pp;
@@ -1712,26 +1752,28 @@ typedef struct {
 } pp_pair_arg_t;
 
 static VALUE
-pp_value(VALUE nil, pp_pair_arg_t* pair_arg)
+pp_value(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_pair_arg_t* pair_arg = (pp_pair_arg_t*)arg;
     VALUE pp = pair_arg->pp;
     rb_funcall(pp, id_breakable, 1, rb_str_new(NULL, 0));
     return rb_funcall(pp, id_pp, 1, GET_VAL(pair_arg->node));
 }
 
 static VALUE
-pp_pair(VALUE nil, pp_pair_arg_t* pair_arg)
+pp_pair(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_pair_arg_t* pair_arg = (pp_pair_arg_t*)arg;
     VALUE pp = pair_arg->pp;
     VALUE group_args[4];
     group_args[0] = pp;
     group_args[1] = INT2FIX(1);
     group_args[2] = rb_str_new(NULL, 0);
     group_args[3] = rb_str_new(NULL, 0);
-    
+
     rb_funcall(pp, id_pp, 1, GET_KEY(pair_arg->node));
     rb_funcall(pp, id_text, 1, rb_str_new2("=>"));
-    return rb_iterate(pp_group, (VALUE)&group_args, pp_value, (VALUE)pair_arg);
+    return call_group_with_block(group_args, pp_value, (VALUE)pair_arg);
 }
 
 typedef struct {
@@ -1745,22 +1787,22 @@ pp_each_pair_i(dnode_t* node, void* each_pair_arg_)
     pp_each_pair_arg_t* each_pair_arg = (pp_each_pair_arg_t*)each_pair_arg_;
     VALUE group_args[4];
     pp_pair_arg_t pair_arg;
-    
+
     if (each_pair_arg->first) {
         each_pair_arg->first = 0;
     } else {
         rb_funcall(each_pair_arg->pp, id_comma_breakable, 0);
     }
-    
+
     group_args[0] = each_pair_arg->pp;
     group_args[1] = INT2FIX(0);
     group_args[2] = rb_str_new(NULL, 0);
     group_args[3] = rb_str_new(NULL, 0);
-    
+
     pair_arg.pp = each_pair_arg->pp;
     pair_arg.node = node;
-    
-    rb_iterate(pp_group, (VALUE)&group_args, pp_pair, (VALUE)&pair_arg);
+
+    call_group_with_block(group_args, pp_pair, (VALUE)&pair_arg);
     return EACH_NEXT;
 }
 
@@ -1770,8 +1812,9 @@ typedef struct {
 } pp_rbtree_arg_t;
 
 static VALUE
-pp_each_pair(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
+pp_each_pair(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_rbtree_arg_t* rbtree_arg = (pp_rbtree_arg_t*)arg;
     pp_each_pair_arg_t each_pair_arg;
     each_pair_arg.pp = rbtree_arg->pp;
     each_pair_arg.first = 1;
@@ -1779,19 +1822,20 @@ pp_each_pair(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
 }
 
 static VALUE
-pp_rbtree(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
+pp_rbtree(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_rbtree_arg_t* rbtree_arg = (pp_rbtree_arg_t*)arg;
     VALUE pp = rbtree_arg->pp;
     VALUE rbtree = rbtree_arg->rbtree;
-    
+
     VALUE group_args[4];
     group_args[0] = pp;
     group_args[1] = INT2FIX(1);
     group_args[2] = rb_str_new2("{");
     group_args[3] = rb_str_new2("}");
-    
+
     rb_funcall(pp, id_text, 1, rb_str_new2(": "));
-    rb_iterate(pp_group, (VALUE)&group_args, pp_each_pair, (VALUE)rbtree_arg);
+    call_group_with_block(group_args, pp_each_pair, (VALUE)rbtree_arg);
     rb_funcall(pp, id_comma_breakable, 0);
     rb_funcall(pp, id_text, 1, rb_str_new2("default="));
     rb_funcall(pp, id_pp, 1, IFNONE(rbtree));
@@ -1800,12 +1844,14 @@ pp_rbtree(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
     return rb_funcall(pp, id_pp, 1, CMP_PROC(rbtree));
 }
 
+#ifdef RUBY_1_8
 static VALUE
 pp_rbtree_group(VALUE arg_)
 {
     pp_rbtree_arg_t* arg = (pp_rbtree_arg_t*)arg_;
     return rb_funcall(arg->pp, id_object_group, 1, arg->rbtree);
 }
+#endif
 
 /*********************************************************************/
 
@@ -1818,7 +1864,11 @@ rbtree_pretty_print(VALUE self, VALUE pp)
     pp_rbtree_arg_t arg;
     arg.rbtree = self;
     arg.pp = pp;
+#ifdef RUBY_1_8
     return rb_iterate(pp_rbtree_group, (VALUE)&arg, pp_rbtree, (VALUE)&arg);
+#else
+    return rb_block_call(arg.pp, id_object_group, 1, &self, pp_rbtree, (VALUE)&arg);
+#endif
 }
 
 /* :nodoc:
@@ -1840,17 +1890,17 @@ rbtree_dump(VALUE self, VALUE limit)
 {
     VALUE ary;
     VALUE result;
-    
+
     if (FL_TEST(self, RBTREE_PROC_DEFAULT))
         rb_raise(rb_eTypeError, "can't dump rbtree with default proc");
     if (CMP_PROC(self) != Qnil)
         rb_raise(rb_eTypeError, "can't dump rbtree with comparison proc");
-    
+
     ary = rb_ary_new2(dict_count(DICT(self)) * 2 + 1);
     rbtree_for_each(self, to_flat_ary_i, (void*)ary);
     rb_ary_push(ary, IFNONE(self));
 
-    result = rb_marshal_dump(ary, limit);
+    result = rb_marshal_dump(ary, Qnil);
 #ifdef HAVE_RB_ARY_RESIZE
     rb_ary_resize(ary, 0);
 #else
@@ -1869,11 +1919,11 @@ rbtree_s_load(VALUE klass, VALUE str)
     VALUE ary = rb_marshal_load(str);
     long len = RARRAY_LEN(ary) - 1;
     long i;
-    
+
     for (i = 0; i < len; i += 2)
         rbtree_aset(rbtree, RARRAY_AREF(ary, i), RARRAY_AREF(ary, i + 1));
     IFNONE(rbtree) = RARRAY_AREF(ary, len);
-    
+
 #ifdef HAVE_RB_ARY_RESIZE
     rb_ary_resize(ary, 0);
 #else
@@ -1893,9 +1943,15 @@ rbtree_s_load(VALUE klass, VALUE str)
  * A sorted associative collection that cannot contain duplicate
  * keys. RBTree is a subclass of MultiRBTree.
  */
-void Init_rbtree()
+void Init_rbtree(void)
 {
-    MultiRBTree = rb_define_class("MultiRBTree", rb_cData);
+    MultiRBTree = rb_define_class("MultiRBTree",
+#ifdef HAVE_RB_CDATA
+        rb_cData
+#else
+        rb_cObject
+#endif
+    );
     RBTree = rb_define_class("RBTree", MultiRBTree);
 
     rb_include_module(MultiRBTree, rb_mEnumerable);
@@ -1975,7 +2031,7 @@ void Init_rbtree()
 
     rb_define_method(MultiRBTree, "_dump", rbtree_dump, 1);
     rb_define_singleton_method(MultiRBTree, "_load", rbtree_s_load, 1);
-    
+
     id_cmp = rb_intern("<=>");
     id_call = rb_intern("call");
     id_default = rb_intern("default");

data/test.rb

@@ -620,7 +620,7 @@ class RBTreeTest < Test::Unit::TestCase
       tree, default, cmp_proc = match.to_a[1..-1]
       assert_equal(%({"a"=>"A", "b"=>"B", "c"=>"C", "d"=>"D"}), tree)
       assert_equal(%("e"), default)
-      assert_match(/#<Proc:\w+(@#{__FILE__}:\d+)?>/o, cmp_proc)
+      assert_match(/#<Proc:\w+([@ ]#{__FILE__}:\d+)?>/o, cmp_proc)
       
       rbtree = RBTree.new
       assert_match(re, rbtree.send(method))

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: rbtree
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.6
 platform: ruby
 authors:
 - OZAWA Takuma
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-12-26 00:00:00.000000000 Z
+date: 2022-12-10 00:00:00.000000000 Z
 dependencies: []
 description: |
   A RBTree is a sorted associative collection that is implemented with a
   Red-Black Tree. It maps keys to values like a Hash, but maintains its
   elements in ascending key order. The interface is the almost identical
   to that of Hash.
-email: 
+email:
 executables: []
 extensions:
 - extconf.rb
@@ -36,7 +36,7 @@ homepage: http://rbtree.rubyforge.org/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--title"
 - Ruby/RBTree
@@ -57,10 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rbtree
-rubygems_version: 2.2.0
-signing_key: 
+rubygems_version: 3.4.0.dev
+signing_key:
 specification_version: 4
 summary: A sorted associative collection.
-test_files:
-- test.rb
+test_files: []