rbtree 0.4.1 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 42305188c5448bb5c684e198069f323816d32d5a
-  data.tar.gz: f1d5608adf7f2c1d142048d5abbe499d11cc83a6
+SHA256:
+  metadata.gz: d5bc8dc390afc34242d6cd951136f2d86c9a0bafc809ed93d39d0fdf6c8ea9c0
+  data.tar.gz: '059f888a97995d9bc64edcdafb504817b570e07df03c3385e5c5fe3e8bbc8f72'
 SHA512:
-  metadata.gz: 892207ef1dc38a23044b15480bcd57a4ab722cc944131f1d56d1878aa668b539d0c10f6a0cdd6c52b7d3255e17c14fb466ed898a3bc56fbe0e15472da912a888
-  data.tar.gz: c2a3503fcc68622ab775d421843b25d07afa7f1702e870ad57a600f3c06b904179c86d62bc6dd3d6c86e5948af09f95e37998de35fb7c8e48e00c4478fae9e15
+  metadata.gz: 9a27e36148fab48e03777b3151dc70ee69262da497263bf83cc25c3b9c6b8c7080857cd75c0d2ac8b3837f511d8a448565f1ae64b1da7740dd26b6ec4fca955a
+  data.tar.gz: 9f682a9ce24a0cd3ff101d91cc145fbed066de4788cbb5b25abecfc1604c0e0065d1dc5d35d0f35d10df911bde971ab9f18edafd84030ae5309ce578be6cbc35

data/README

@@ -57,18 +57,14 @@ Run the following command.
   $ sudo gem install rbtree
 
 == Changes
-=== 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
 
@@ -78,9 +74,3 @@ dict.c and dict.h are modified copies that are originally in Kazlib
 1.20 written by Kaz Kylheku. Its license is similar to the MIT
 license. See dict.c and dict.h for the details. The web page of Kazlib
 is at http://www.kylheku.com/~kaz/kazlib.html.
-
-== Contact
-
-Run the following command.
-
-  $ ruby -e "puts 'YnVybmluZ2Rvd250aGVvcGVyYUB5YWhvby5jby5qcA==\n'.unpack('m')"

data/dict.c

@@ -14,12 +14,12 @@
  * into proprietary software; there is no requirement for such software to
  * contain a copyright notice related to this source.
  *
- * $Id: dict.c,v 1.15 2005/10/06 05:16:35 kuma Exp $
- * $Name:  $
+ * $Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $
+ * $Name: kazlib_1_20 $
  */
 
 /*
- * Modified for Ruby/RBTree by OZAWA Takuma.
+ * Modified for Ruby/RBTree.
  */
 
 #include <stdlib.h>
@@ -29,7 +29,7 @@
 #include "dict.h"
 
 #ifdef KAZLIB_RCSID
-static const char rcsid[] = "$Id: dict.c,v 1.15 2005/10/06 05:16:35 kuma Exp $";
+static const char rcsid[] = "$Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $";
 #endif
 
 /*
@@ -1190,3 +1190,308 @@ void dict_merge(dict_t *dest, dict_t *source)
     dict_clear(source);
     dict_load_end(&load);
 }
+
+#ifdef KAZLIB_TEST_MAIN
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+typedef char input_t[256];
+
+static int tokenize(char *string, ...)
+{
+    char **tokptr; 
+    va_list arglist;
+    int tokcount = 0;
+
+    va_start(arglist, string);
+    tokptr = va_arg(arglist, char **);
+    while (tokptr) {
+	while (*string && isspace((unsigned char) *string))
+	    string++;
+	if (!*string)
+	    break;
+	*tokptr = string;
+	while (*string && !isspace((unsigned char) *string))
+	    string++;
+	tokptr = va_arg(arglist, char **);
+	tokcount++;
+	if (!*string)
+	    break;
+	*string++ = 0;
+    }
+    va_end(arglist);
+
+    return tokcount;
+}
+
+static int comparef(const void *key1, const void *key2)
+{
+    return strcmp(key1, key2);
+}
+
+static char *dupstring(char *str)
+{
+    int sz = strlen(str) + 1;
+    char *new = malloc(sz);
+    if (new)
+	memcpy(new, str, sz);
+    return new;
+}
+
+static dnode_t *new_node(void *c)
+{
+    static dnode_t few[5];
+    static int count;
+
+    if (count < 5)
+	return few + count++;
+
+    return NULL;
+}
+
+static void del_node(dnode_t *n, void *c)
+{
+}
+
+static int prompt = 0;
+
+static void construct(dict_t *d)
+{
+    input_t in;
+    int done = 0;
+    dict_load_t dl;
+    dnode_t *dn;
+    char *tok1, *tok2, *val;
+    const char *key;
+    char *help = 
+	"p                      turn prompt on\n"
+	"q                      finish construction\n"
+	"a <key> <val>          add new entry\n";
+
+    if (!dict_isempty(d))
+	puts("warning: dictionary not empty!");
+
+    dict_load_begin(&dl, d);
+
+    while (!done) {
+	if (prompt)
+	    putchar('>');
+	fflush(stdout);
+
+	if (!fgets(in, sizeof(input_t), stdin))
+	    break;
+
+	switch (in[0]) {
+	    case '?':
+		puts(help);
+		break;
+	    case 'p':
+		prompt = 1;
+		break;
+	    case 'q':
+		done = 1;
+		break;
+	    case 'a':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		}
+		key = dupstring(tok1);
+		val = dupstring(tok2);
+		dn = dnode_create(val);
+
+		if (!key || !val || !dn) {
+		    puts("out of memory");
+		    free((void *) key);
+		    free(val);
+		    if (dn)
+			dnode_destroy(dn);
+		}
+
+		dict_load_next(&dl, dn, key);
+		break;
+	    default:
+		putchar('?');
+		putchar('\n');
+		break;
+	}
+    }
+
+    dict_load_end(&dl);
+}
+
+int main(void)
+{
+    input_t in;
+    dict_t darray[10];
+    dict_t *d = &darray[0];
+    dnode_t *dn;
+    int i;
+    char *tok1, *tok2, *val;
+    const char *key;
+
+    char *help =
+	"a <key> <val>          add value to dictionary\n"
+	"d <key>                delete value from dictionary\n"
+	"l <key>                lookup value in dictionary\n"
+	"( <key>                lookup lower bound\n"
+	") <key>                lookup upper bound\n"
+	"# <num>                switch to alternate dictionary (0-9)\n"
+	"j <num> <num>          merge two dictionaries\n"
+	"f                      free the whole dictionary\n"
+	"k                      allow duplicate keys\n"
+	"c                      show number of entries\n"
+	"t                      dump whole dictionary in sort order\n"
+	"m                      make dictionary out of sorted items\n"
+	"p                      turn prompt on\n"
+	"s                      switch to non-functioning allocator\n"
+	"q                      quit";
+
+    for (i = 0; i < sizeof darray / sizeof *darray; i++)
+	dict_init(&darray[i], DICTCOUNT_T_MAX, comparef);
+
+    for (;;) {
+	if (prompt)
+	    putchar('>');
+	fflush(stdout);
+
+	if (!fgets(in, sizeof(input_t), stdin))
+	    break;
+
+	switch(in[0]) {
+	    case '?':
+		puts(help);
+		break;
+	    case 'a':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		}
+		key = dupstring(tok1);
+		val = dupstring(tok2);
+
+		if (!key || !val) {
+		    puts("out of memory");
+		    free((void *) key);
+		    free(val);
+		}
+
+		if (!dict_alloc_insert(d, key, val)) {
+		    puts("dict_alloc_insert failed");
+		    free((void *) key);
+		    free(val);
+		    break;
+		}
+		break;
+	    case 'd':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		}
+		dn = dict_lookup(d, tok1);
+		if (!dn) {
+		    puts("dict_lookup failed");
+		    break;
+		}
+		val = dnode_get(dn);
+		key = dnode_getkey(dn);
+		dict_delete_free(d, dn);
+
+		free(val);
+		free((void *) key);
+		break;
+	    case 'f':
+		dict_free(d);
+		break;
+	    case 'l':
+	    case '(':
+	    case ')':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		}
+		dn = 0;
+		switch (in[0]) {
+		case 'l':
+		    dn = dict_lookup(d, tok1);
+		    break;
+		case '(':
+		    dn = dict_lower_bound(d, tok1);
+		    break;
+		case ')':
+		    dn = dict_upper_bound(d, tok1);
+		    break;
+		}
+		if (!dn) {
+		    puts("lookup failed");
+		    break;
+		}
+		val = dnode_get(dn);
+		puts(val);
+		break;
+	    case 'm':
+		construct(d);
+		break;
+	    case 'k':
+		dict_allow_dupes(d);
+		break;
+	    case 'c':
+		printf("%lu\n", (unsigned long) dict_count(d));
+		break;
+	    case 't':
+		for (dn = dict_first(d); dn; dn = dict_next(d, dn)) {
+		    printf("%s\t%s\n", (char *) dnode_getkey(dn),
+			    (char *) dnode_get(dn));
+		}
+		break;
+	    case 'q':
+		exit(0);
+		break;
+	    case '\0':
+		break;
+	    case 'p':
+		prompt = 1;
+		break;
+	    case 's':
+		dict_set_allocator(d, new_node, del_node, NULL);
+		break;
+	    case '#':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		} else {
+		    int dictnum = atoi(tok1);
+		    if (dictnum < 0 || dictnum > 9) {
+			puts("invalid number");
+			break;
+		    }
+		    d = &darray[dictnum];
+		}
+		break;
+	    case 'j':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		} else {
+		    int dict1 = atoi(tok1), dict2 = atoi(tok2);
+		    if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) {
+			puts("invalid number");
+			break;
+		    }
+		    dict_merge(&darray[dict1], &darray[dict2]);
+		}
+		break;
+	    default:
+		putchar('?');
+		putchar('\n');
+		break;
+	}
+    }
+
+    return 0;
+}
+
+#endif

data/dict.h

@@ -14,12 +14,12 @@
  * into proprietary software; there is no requirement for such software to
  * contain a copyright notice related to this source.
  *
- * $Id: dict.h,v 1.9 2005/10/06 05:16:35 kuma Exp $
- * $Name:  $
+ * $Id: dict.h,v 1.22.2.6 2000/11/13 01:36:44 kaz Exp $
+ * $Name: kazlib_1_20 $
  */
 
 /*
- * Modified for Ruby/RBTree by OZAWA Takuma.
+ * Modified for Ruby/RBTree.
  */
 
 #ifndef DICT_H

data/extconf.rb

@@ -5,10 +5,13 @@ if enable_config('debug')
 else
   $defs << '-DNDEBUG'
 end
-have_header('ruby/st.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

@@ -23,11 +23,12 @@
 #endif
 #endif
 
-#ifndef RHASH_TBL
-#define RHASH_TBL(h) RHASH(h)->tbl
+#ifndef RARRAY_AREF
+#define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
 #endif
-#ifndef RHASH_IFNONE
-#define RHASH_IFNONE(h) RHASH(h)->ifnone
+
+#ifndef RHASH_SET_IFNONE
+#define RHASH_SET_IFNONE(h, v) (RHASH(h)->ifnone = (v))
 #endif
 
 VALUE RBTree;
@@ -100,15 +101,17 @@ rbtree_free_node(dnode_t* node, void* context)
 }
 
 static void
-rbtree_argc_error(const int argc, const int min, const int max)
-{
-    const char* message = "wrong number of arguments";
-    if (min == max) {
-        rb_raise(rb_eArgError, "%s (%d for %d)", message, argc, min);
-    } else if (max == INT_MAX) {
-        rb_raise(rb_eArgError, "%s (%d for %d+)", message, argc, -min - 1);
-    } else {
-        rb_raise(rb_eArgError, "%s (%d for %d..%d)", message, argc, min, max);
+rbtree_check_argument_count(const int argc, const int min, const int max)
+{
+    if (argc < min || argc > max) {
+        static const char* const  message = "wrong number of arguments";
+        if (min == max) {
+            rb_raise(rb_eArgError, "%s (%d for %d)", message, argc, min);
+        } else if (max == INT_MAX) {
+            rb_raise(rb_eArgError, "%s (%d for %d+)", message, argc, -min - 1);
+        } else {
+            rb_raise(rb_eArgError, "%s (%d for %d..%d)", message, argc, min, max);
+        }
     }
 }
 
@@ -173,25 +176,27 @@ 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
 rbtree_alloc(VALUE klass)
 {
     dict_t* dict;
-    VALUE rbtree = Data_Wrap_Struct(klass, rbtree_mark, rbtree_free, 0);
+    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;
@@ -221,45 +226,45 @@ 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);
             for (i = 0; i < RARRAY_LEN(temp); i++) {
-                VALUE v = rb_check_array_type(RARRAY_PTR(temp)[i]);
+                VALUE v = rb_check_array_type(RARRAY_AREF(temp, i));
                 if (NIL_P(v)) {
                     rb_warn("wrong element type %s at %ld (expected Array)",
-                            rb_obj_classname(RARRAY_PTR(temp)[i]), i);
+                            rb_obj_classname(RARRAY_AREF(temp, i)), i);
                     continue;
                 }
                 switch(RARRAY_LEN(v)) {
                 case 1:
-                    rbtree_aset(rbtree, RARRAY_PTR(v)[0], Qnil);
+                    rbtree_aset(rbtree, RARRAY_AREF(v, 0), Qnil);
                     break;
                 case 2:
-                    rbtree_aset(rbtree, RARRAY_PTR(v)[0], RARRAY_PTR(v)[1]);
+                    rbtree_aset(rbtree, RARRAY_AREF(v, 0), RARRAY_AREF(v, 1));
                     break;
                 default:
                     rb_warn("invalid number of elements (%ld for 1..2)",
@@ -269,7 +274,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));
 
@@ -289,17 +294,14 @@ rbtree_initialize(int argc, VALUE* argv, VALUE self)
 
     if (rb_block_given_p()) {
         VALUE proc;
-        if (argc > 0) {
-            rbtree_argc_error(argc, 0, 0);
-        }
+        rbtree_check_argument_count(argc, 0, 0);
         proc = rb_block_proc();
         rbtree_check_proc_arity(proc, 2);
         IFNONE(self) = proc;
         FL_SET(self, RBTREE_PROC_DEFAULT);
     } else {
-        if (argc > 1) {
-            rbtree_argc_error(argc, 1, 1);
-        } else if (argc == 1) {
+        rbtree_check_argument_count(argc, 0, 1);
+        if (argc == 1) {
             IFNONE(self) = argv[0];
         }
     }
@@ -325,7 +327,7 @@ insert_node_body(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;
@@ -343,7 +345,7 @@ insert_node_ensure(rbtree_insert_arg_t* arg)
 {
     dict_t* dict = arg->dict;
     dnode_t* node = arg->node;
-    
+
     switch (arg->result) {
     case InsertionSucceeded:
         break;
@@ -366,7 +368,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;
@@ -418,12 +420,9 @@ rbtree_fetch(int argc, VALUE* argv, VALUE self)
 {
     dnode_t* node;
 
-    if (argc == 0 || argc > 2) {
-        rbtree_argc_error(argc, 1, 2);
-    } else if (argc == 2) {
-        if (rb_block_given_p()) {
-            rb_warn("block supersedes default value argument");
-        }
+    rbtree_check_argument_count(argc, 1, 2);
+    if (argc == 2 && rb_block_given_p()) {
+        rb_warn("block supersedes default value argument");
     }
 
     node = dict_lookup(DICT(self), TO_KEY(argv[0]));
@@ -464,9 +463,7 @@ rbtree_empty_p(VALUE self)
 VALUE
 rbtree_default(int argc, VALUE* argv, VALUE self)
 {
-    if (argc > 1) {
-        rbtree_argc_error(argc, 0, 1);
-    }
+    rbtree_check_argument_count(argc, 0, 1);
     if (FL_TEST(self, RBTREE_PROC_DEFAULT)) {
         if (argc == 0) {
             return Qnil;
@@ -506,14 +503,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,
@@ -533,16 +530,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;
         }
     }
@@ -562,7 +559,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)
@@ -604,7 +601,7 @@ rbtree_each_body(rbtree_each_arg_t* arg)
     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;
@@ -612,12 +609,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;
     }
@@ -752,7 +749,11 @@ static void
 copy_dict(VALUE src, VALUE dest, dict_comp_t cmp_func, VALUE cmp_proc)
 {
     VALUE temp = rbtree_alloc(CLASS_OF(dest));
+#ifdef HAVE_RB_OBJ_HIDE
+    rb_obj_hide(temp);
+#else
     RBASIC(temp)->klass = 0;
+#endif
     DICT(temp)->dict_compare = cmp_func;
     CMP_PROC(temp) = cmp_proc;
 
@@ -763,6 +764,7 @@ copy_dict(VALUE src, VALUE dest, dict_comp_t cmp_func, VALUE cmp_proc)
         DICT(dest) = t;
     }
     rbtree_free(RBTREE(temp));
+    RBTREE(temp) = NULL;
     rb_gc_force_recycle(temp);
 
     DICT(dest)->dict_context = RBTREE(dest);
@@ -776,7 +778,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 +786,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 +805,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;
@@ -840,9 +842,8 @@ VALUE
 rbtree_index(VALUE self, VALUE value)
 {
     VALUE klass = rb_obj_is_kind_of(self, RBTree) ? RBTree : MultiRBTree;
-    volatile VALUE class_name = rb_class_name(klass);
-    rb_warn("%s#index is deprecated; use %s#key",
-            RSTRING_PTR(class_name), RSTRING_PTR(class_name));
+    const char* classname = rb_class2name(klass);
+    rb_warn("%s#index is deprecated; use %s#key", classname, classname);
     return rbtree_key(self, value);
 }
 
@@ -938,7 +939,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;
@@ -975,7 +976,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);
@@ -991,14 +992,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;
-    
+
 }
 
 /*********************************************************************/
@@ -1014,7 +1015,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);
     }
@@ -1025,7 +1026,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;
@@ -1064,7 +1065,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
@@ -1146,7 +1147,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
@@ -1163,6 +1164,14 @@ rbtree_merge(VALUE self, VALUE other)
     return rbtree_update(rb_obj_dup(self), other);
 }
 
+static each_return_t
+to_flat_ary_i(dnode_t* node, void* ary)
+{
+    rb_ary_push((VALUE)ary, GET_KEY(node));
+    rb_ary_push((VALUE)ary, GET_VAL(node));
+    return EACH_NEXT;
+}
+
 /*
  *
  */
@@ -1170,15 +1179,17 @@ VALUE
 rbtree_flatten(int argc, VALUE* argv, VALUE self)
 {
     VALUE ary;
-    VALUE level;
-    
-    ary = rbtree_to_a(self);
-    if (argc == 0) {
-        argc = 1;
-        level = INT2FIX(1);
-        argv = &level;
+
+    rbtree_check_argument_count(argc, 0, 1);
+    ary = rb_ary_new2(dict_count(DICT(self)) * 2);
+    rbtree_for_each(self, to_flat_ary_i, (void*)ary);
+    if (argc == 1) {
+        const int level = NUM2INT(argv[0]) - 1;
+        if (level > 0) {
+            argv[0] = INT2FIX(level);
+            rb_funcall2(ary, id_flatten_bang, argc, argv);
+        }
     }
-    rb_funcall2(ary, id_flatten_bang, argc, argv);
     return ary;
 }
 
@@ -1286,10 +1297,10 @@ 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_IFNONE(hash) = IFNONE(self);
+    RHASH_SET_IFNONE(hash, IFNONE(self));
     if (FL_TEST(self, RBTREE_PROC_DEFAULT))
         FL_SET(hash, HASH_PROC_DEFAULT);
     OBJ_INFECT(hash, self);
@@ -1308,10 +1319,10 @@ rbtree_to_rbtree(VALUE self)
 static VALUE
 rbtree_begin_inspect(VALUE self)
 {
-    volatile VALUE class_name = rb_class_name(CLASS_OF(self));
-    VALUE str = rb_str_new(NULL, RSTRING_LEN(class_name) + 4);
-    sprintf(RSTRING_PTR(str), "#<%s: ", RSTRING_PTR(class_name));
-    return str;
+    VALUE result = rb_str_new2("#<");
+    rb_str_cat2(result, rb_obj_classname(self));
+    rb_str_cat2(result, ": ");
+    return result;
 }
 
 static each_return_t
@@ -1342,7 +1353,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);
@@ -1353,7 +1364,7 @@ inspect_rbtree(VALUE self, VALUE result)
     rb_str_cat2(result, ", default=");
     rb_str_append(result, str);
     OBJ_INFECT(result, str);
-    
+
     str = rb_inspect(CMP_PROC(self));
     rb_str_cat2(result, ", cmp_proc=");
     rb_str_append(result, str);
@@ -1480,24 +1491,24 @@ rbtree_bound_body(rbtree_bound_arg_t* arg)
 static VALUE
 rbtree_bound_size(VALUE self, VALUE args)
 {
-    VALUE key1 = RARRAY_PTR(args)[0];
-    VALUE key2 = RARRAY_PTR(args)[RARRAY_LEN(args) - 1];
+    VALUE key1 = RARRAY_AREF(args, 0);
+    VALUE key2 = RARRAY_AREF(args, RARRAY_LEN(args) - 1);
     dnode_t* lower_node = dict_lower_bound(DICT(self), TO_KEY(key1));
     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;
@@ -1524,7 +1535,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 # => []
  */
@@ -1535,17 +1546,15 @@ rbtree_bound(int argc, VALUE* argv, VALUE self)
     dnode_t* lower_node;
     dnode_t* upper_node;
     VALUE result;
-    
-    if (argc == 0 || argc > 2) {
-        rbtree_argc_error(argc, 1, 2);
-    }
-    
+
+    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),
@@ -1570,7 +1579,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
@@ -1620,7 +1629,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]
  */
@@ -1629,21 +1638,20 @@ 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()) {
-        if (argc != 0) {
-            rbtree_argc_error(argc, 0, 0);
-        }
+        rbtree_check_argument_count(argc, 0, 0);
         cmp_func = rbtree_user_cmp;
         cmp_proc = rb_block_proc();
         rbtree_check_proc_arity(cmp_proc, 2);
     } else {
+        rbtree_check_argument_count(argc, 0, 1);
         if (argc == 0) {
             cmp_func = DICT(self)->dict_compare;
             cmp_proc = CMP_PROC(self);
-        } else if (argc == 1) {
+        } else {
             if (NIL_P(argv[0])) {
                 cmp_func = rbtree_cmp;
                 cmp_proc = Qnil;
@@ -1658,8 +1666,6 @@ rbtree_readjust(int argc, VALUE* argv, VALUE self)
                 cmp_proc = proc;
                 rbtree_check_proc_arity(cmp_proc, 2);
             }
-        } else {
-            rbtree_argc_error(argc, 0, 1);
         }
     }
 
@@ -1724,7 +1730,7 @@ pp_pair(VALUE nil, pp_pair_arg_t* pair_arg)
     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);
@@ -1741,21 +1747,21 @@ 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);
     return EACH_NEXT;
 }
@@ -1779,13 +1785,13 @@ pp_rbtree(VALUE nil, pp_rbtree_arg_t* rbtree_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);
     rb_funcall(pp, id_comma_breakable, 0);
@@ -1828,14 +1834,6 @@ rbtree_pretty_print_cycle(VALUE self, VALUE pp)
 
 /*********************************************************************/
 
-static each_return_t
-to_flat_ary_i(dnode_t* node, void* ary)
-{
-    rb_ary_push((VALUE)ary, GET_KEY(node));
-    rb_ary_push((VALUE)ary, GET_VAL(node));
-    return EACH_NEXT;
-}
-
 /* :nodoc:
  *
  */
@@ -1844,19 +1842,22 @@ 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
     rb_ary_clear(ary);
-    rb_gc_force_recycle(ary);
+#endif
     return result;
 }
 
@@ -1868,16 +1869,18 @@ rbtree_s_load(VALUE klass, VALUE str)
 {
     VALUE rbtree = rbtree_alloc(klass);
     VALUE ary = rb_marshal_load(str);
-    VALUE* ptr = RARRAY_PTR(ary);
     long len = RARRAY_LEN(ary) - 1;
     long i;
-    
+
     for (i = 0; i < len; i += 2)
-        rbtree_aset(rbtree, ptr[i], ptr[i + 1]);
-    IFNONE(rbtree) = ptr[len];
-    
+        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
     rb_ary_clear(ary);
-    rb_gc_force_recycle(ary);
+#endif
     return rbtree;
 }
 
@@ -1894,7 +1897,13 @@ rbtree_s_load(VALUE klass, VALUE str)
  */
 void Init_rbtree()
 {
-    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);
@@ -1974,7 +1983,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

@@ -11,6 +11,10 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree = RBTree[*%w(b B d D a A c C)]
   end
   
+  def have_enumerator?
+    defined?(Enumerable::Enumerator) or defined?(Enumerator)
+  end
+  
   def test_new
     assert_nothing_raised {
       RBTree.new
@@ -250,12 +254,6 @@ class RBTreeTest < Test::Unit::TestCase
       b[1] = b
       assert_equal(a, b)
     end
-    
-    # a = RBTree.new
-    # a[1] = a
-    # b = RBTree.new
-    # b[1] = a
-    # assert_not_equal(a, b)
   end
   
   def test_fetch
@@ -304,7 +302,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.each
       assert_equal(%w(a A b B c C d D), enumerator.to_a.flatten)
     end
@@ -329,7 +327,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.each_key
       assert_equal(%w(a b c d), enumerator.to_a.flatten)
     end
@@ -354,7 +352,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.each_value
       assert_equal(%w(A B C D), enumerator.to_a.flatten)
     end
@@ -428,7 +426,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(0, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.delete_if.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], rbtree)
@@ -440,7 +438,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(a A b B)], @rbtree)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.keep_if.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(a A b B)], rbtree)
@@ -456,7 +454,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(c C d D)], result)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.reject!.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], rbtree)
@@ -472,7 +470,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(RBTree[*%w(c C d D)], result)
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       result = @rbtree.reject.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], result)
     end
@@ -487,7 +485,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(a A b B)], result)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.select!.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(a A b B)], rbtree)
@@ -503,7 +501,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(RBTree[*%w(a A b B)], result)
     assert_raises(ArgumentError) { @rbtree.select("c") }
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       result = @rbtree.select.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(a A b B)], result)
     end
@@ -554,13 +552,13 @@ class RBTreeTest < Test::Unit::TestCase
       rbtree[["a"]] = ["A"]
       rbtree[[["b"]]] = [["B"]]
       assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten)
-      assert_equal([[["a"], ["A"]], [[["b"]], [["B"]]]], rbtree.flatten(0))
+      assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(0))
       assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(1))
       assert_equal(["a", "A", ["b"], ["B"]], rbtree.flatten(2))
       assert_equal(["a", "A", "b", "B"], rbtree.flatten(3))
       
       assert_raises(TypeError) { @rbtree.flatten("e") }
-      assert_raises(ArgumentError) { @rbtree.flatten(2, 2) } 
+      assert_raises(ArgumentError) { @rbtree.flatten(1, 2) } 
     end
   end
 
@@ -622,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))
@@ -669,7 +667,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal([], rbtree.bound("Y", "Z").to_a)
     assert_equal([], rbtree.bound("f", "g").to_a)
     assert_equal([], rbtree.bound("f", "Z").to_a)
-  
+    
     if defined?(Enumerator) and Enumerator.method_defined?(:size)
       assert_equal(2, rbtree.bound("a", "c").size)
       assert_equal(1, rbtree.bound("a").size)
@@ -821,7 +819,7 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree.reverse_each { |key, val| result.push([key, val]) }
     assert_equal(%w(d D c C b B a A), result.flatten)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.reverse_each
       assert_equal(%w(d D c C b B a A), enumerator.to_a.flatten)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbtree
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.5
 platform: ruby
 authors:
 - OZAWA Takuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-29 00:00:00.000000000 Z
+date: 2022-02-02 00:00:00.000000000 Z
 dependencies: []
 description: |
   A RBTree is a sorted associative collection that is implemented with a
@@ -38,29 +38,27 @@ licenses:
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --title
+- "--title"
 - Ruby/RBTree
-- --main
+- "--main"
 - README
-- --exclude
-- \A(?!README|rbtree\.c).*\z
+- "--exclude"
+- "\\A(?!README|rbtree\\.c).*\\z"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.8.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rbtree
-rubygems_version: 2.0.0
+rubygems_version: 3.4.0.dev
 signing_key: 
 specification_version: 4
 summary: A sorted associative collection.
-test_files:
-- test.rb
+test_files: []