rbtree3 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1c2ef2226948e71d0ba3350df1eb8a0887bf7494
-  data.tar.gz: 44be99d155c686c138be63a3185c74917349dbf1
+SHA256:
+  metadata.gz: 3234cdc1ff704f6a3d32707f6b0fb740c5a946d42012453b56f186a2231157fc
+  data.tar.gz: 97eeab5707ad178f92fd2261e0209fc37262e9e95f0d75b18f49da1963b2a49d
 SHA512:
-  metadata.gz: db4e2a47092cf4de049e7bd3c17b17d652674004fb12e1f6964c32694d328a2ab5aa821897ff5fff8f7edf1a9f27a21490c71d83cf62001a5c0a0a05923959f6
-  data.tar.gz: 21d7f3416a05cab89b2bc59d0fe290fa70b6409a8700dee50412c96f869f87b7dde263f2a44e60033ec2b98f424f894f501dec21a6090579a681427b64a369d4
+  metadata.gz: '0863e5d7883566ea6dd6da51e743d3606bdbc9f1dbce105e0f38bb2f60815bc4244691065bf4093cdd474d7b545b996dc25a3171ce114c471fa6108b7b21d2d5'
+  data.tar.gz: 745622af2491d5bdbcded3112c98e2183b1f3716c5a46204274fc0392ff2e5e79b863c03b7ff6f727f4207f13486d0ed82f81b508fad22d00c6b9a74ebb0948f

data/ChangeLog

@@ -1,3 +1,21 @@
+2020-01-21  Brian Hawley
+
+        * version 0.6.0 released.
+
+        * test.rb: improved 1.8.7 compatibility
+
+        * rbtree.c: made RBTREE(rbtree) do the type conversion, like RARRAY and
+        such do
+
+        * rbtree.c: Used Data_Make_Struct instead of doing the same thing that
+        it used to do, in order to be compatible with MJIT and compaction GC.
+
+        * rbtree.c: restored to_hash default preservation removed in 0.5.0 and
+        made it compatible with newer Rubies
+
+        * rbtree.c: made code compatible with Ruby 2.7 and fixed warnings about
+        deprecated taint mechanism
+
 2019-02-07  Kyrylo Silin
 
         * version 0.5.0 released.

data/rbtree.c

@@ -2,9 +2,17 @@
  * MIT License
  * Copyright (c) 2002-2004, 2007, 2009 OZAWA Takuma
  */
-#include <ruby/ruby.h>
+#include <ruby.h>
+#ifdef HAVE_RUBY_VERSION_H
 #include <ruby/version.h>
+#else
+#include <version.h>
+#endif
+#ifdef HAVE_RUBY_ST_H
 #include <ruby/st.h>
+#else
+#include <st.h>
+#endif
 #include <stdarg.h>
 #include "dict.h"
 
@@ -15,6 +23,19 @@
 #define RETURN_ENUMERATOR(obj, argc, argv) ((void)0)
 #endif
 
+#ifndef RHASH_SET_IFNONE
+#define RHASH_SET_IFNONE(h, ifnone) (RHASH_IFNONE(h) = ifnone)
+#endif
+
+#ifndef RB_BLOCK_CALL_FUNC_ARGLIST
+#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg) \
+    VALUE yielded_arg, VALUE callback_arg
+#endif
+
+#if !defined(RUBY_API_VERSION_CODE) || (RUBY_API_VERSION_CODE < 20700)
+#define HAVE_TAINT
+#endif
+
 VALUE RBTree;
 VALUE MultiRBTree;
 
@@ -29,10 +50,10 @@ typedef struct {
     int iter_lev;
 } rbtree_t;
 
-#define RBTREE(rbtree) DATA_PTR(rbtree)
-#define DICT(rbtree) ((rbtree_t*)RBTREE(rbtree))->dict
-#define IFNONE(rbtree) ((rbtree_t*)RBTREE(rbtree))->ifnone
-#define ITER_LEV(rbtree) ((rbtree_t*)RBTREE(rbtree))->iter_lev
+#define RBTREE(rbtree) ((rbtree_t*)DATA_PTR(rbtree))
+#define DICT(rbtree) RBTREE(rbtree)->dict
+#define IFNONE(rbtree) RBTREE(rbtree)->ifnone
+#define ITER_LEV(rbtree) RBTREE(rbtree)->iter_lev
 #define COMPARE(rbtree) DICT(rbtree)->dict_compare
 #define CONTEXT(rbtree) DICT(rbtree)->dict_context
 
@@ -90,6 +111,7 @@ rbtree_free_node(dnode_t* node, void* context)
     xfree(node);
 }
 
+NORETURN(static void rbtree_argc_error());
 static void
 rbtree_argc_error()
 {
@@ -121,17 +143,19 @@ rbtree_modify(VALUE self)
         rb_raise(rb_eTypeError, "can't modify rbtree in iteration");
     if (OBJ_FROZEN(self))
         rb_error_frozen("rbtree");
+#ifdef HAVE_TAINT
     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);
-    RBTREE(rbtree) = ALLOC(rbtree_t);
-    MEMZERO(RBTREE(rbtree), rbtree_t, 1);
+    rbtree_t* rbtree_ptr;
+    VALUE rbtree = Data_Make_Struct(klass, rbtree_t, rbtree_mark, rbtree_free,
+                                    rbtree_ptr);
 
     dict = dict_create(rbtree_cmp);
     dict_set_allocator(dict, rbtree_alloc_node, rbtree_free_node,
@@ -139,8 +163,8 @@ rbtree_alloc(VALUE klass)
     if (klass == MultiRBTree)
         dict_allow_dupes(dict);
 
-    DICT(rbtree) = dict;
-    IFNONE(rbtree) = Qnil;
+    rbtree_ptr->dict = dict;
+    rbtree_ptr->ifnone = Qnil;
     return rbtree;
 }
 
@@ -256,8 +280,9 @@ typedef struct {
 } insert_node_t;
 
 static VALUE
-insert_node_body(insert_node_t* arg)
+insert_node_body(VALUE arg_)
 {
+    insert_node_t* arg = (insert_node_t*)arg_;
     if (dict_insert(arg->dict, arg->node, arg->key))
         arg->ret = NODE_NOT_FOUND;
     else
@@ -266,8 +291,9 @@ insert_node_body(insert_node_t* arg)
 }
 
 static VALUE
-insert_node_ensure(insert_node_t* arg)
+insert_node_ensure(VALUE arg_)
 {
+    insert_node_t* arg = (insert_node_t*)arg_;
     dict_t* dict = arg->dict;
     dnode_t* node = arg->node;
     switch (arg->ret) {
@@ -468,8 +494,9 @@ 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;
@@ -770,8 +797,9 @@ typedef struct {
 } rbtree_delete_if_arg_t;
 
 static VALUE
-rbtree_delete_if_ensure(rbtree_delete_if_arg_t* arg)
+rbtree_delete_if_ensure(VALUE arg_)
 {
+    rbtree_delete_if_arg_t* arg = (rbtree_delete_if_arg_t*)arg_;
     dict_t* dict = DICT(arg->self);
     dnode_list_t* list = arg->list;
 
@@ -788,8 +816,9 @@ rbtree_delete_if_ensure(rbtree_delete_if_arg_t* arg)
 }
 
 static VALUE
-rbtree_delete_if_body(rbtree_delete_if_arg_t* arg)
+rbtree_delete_if_body(VALUE arg_)
 {
+    rbtree_delete_if_arg_t* arg = (rbtree_delete_if_arg_t*)arg_;
     VALUE self = arg->self;
     dict_t* dict = DICT(self);
     dnode_t* node;
@@ -1052,7 +1081,9 @@ rbtree_to_a(VALUE self)
 {
     VALUE ary = rb_ary_new();
     rbtree_for_each(self, to_a_i, (void*)ary);
+#ifdef HAVE_TAINT
     OBJ_INFECT(ary, self);
+#endif
     return ary;
 }
 
@@ -1076,9 +1107,12 @@ rbtree_to_hash(VALUE self)
 
     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);
+#ifdef HAVE_TAINT
     OBJ_INFECT(hash, self);
+#endif
     return hash;
 }
 
@@ -1144,13 +1178,17 @@ inspect_i(dnode_t* node, void* ret_)
 
     str = rb_inspect(GET_KEY(node));
     rb_str_append(ret, str);
+#ifdef HAVE_TAINT
     OBJ_INFECT(ret, str);
+#endif
 
     rb_str_cat2(ret, "=>");
 
     str = rb_inspect(GET_VAL(node));
     rb_str_append(ret, str);
+#ifdef HAVE_TAINT
     OBJ_INFECT(ret, str);
+#endif
 
     return EACH_NEXT;
 }
@@ -1169,15 +1207,21 @@ inspect_rbtree(VALUE self, VALUE ret)
     str = rb_inspect(IFNONE(self));
     rb_str_cat2(ret, ", default=");
     rb_str_append(ret, str);
+#ifdef HAVE_TAINT
     OBJ_INFECT(ret, str);
+#endif
 
     str = rb_inspect((VALUE)CONTEXT(self));
     rb_str_cat2(ret, ", cmp_proc=");
     rb_str_append(ret, str);
+#ifdef HAVE_TAINT
     OBJ_INFECT(ret, str);
+#endif
 
     rb_str_cat2(ret, ">");
+#ifdef HAVE_TAINT
     OBJ_INFECT(ret, self);
+#endif
     return ret;
 }
 
@@ -1252,8 +1296,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;
@@ -1452,8 +1497,9 @@ pp_object_group(VALUE arg_)
 }
 
 static VALUE
-pp_block(VALUE nil, pp_arg_t* arg)
+pp_block(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg_))
 {
+    pp_arg_t* arg = (pp_arg_t*)arg_;
     VALUE pp = arg->pp;
     VALUE rbtree = arg->rbtree;
 
@@ -1464,7 +1510,7 @@ pp_block(VALUE nil, pp_arg_t* arg)
     rb_funcall(pp, id_pp, 1, IFNONE(rbtree));
     rb_funcall(pp, id_comma_breakable, 0);
     rb_funcall(pp, id_text, 1, rb_str_new2("cmp_proc="));
-    rb_funcall(pp, id_pp, 1, CONTEXT(rbtree));
+    rb_funcall(pp, id_pp, 1, (VALUE)CONTEXT(rbtree));
     return pp;
 }
 

data/test.rb

@@ -517,7 +517,18 @@ class RBTreeTest < Test::Unit::TestCase
   def test_to_hash
     @rbtree.default = "e"
     hash = @rbtree.to_hash
-    assert_equal(@rbtree.to_a.flatten, hash.to_a.flatten)
+    hash_a = hash.to_a
+    hash_a.sort! if RUBY_VERSION < "1.9"  # Hash ordering isn't stable in < 1.9.
+    assert_equal(@rbtree.to_a.flatten, hash_a.flatten)
+    assert_equal("e", hash.default)
+
+    rbtree = RBTree.new { "e" }
+    hash = rbtree.to_hash
+    if (hash.respond_to?(:default_proc))
+      assert_equal(rbtree.default_proc, hash.default_proc)
+    else
+      assert_equal(rbtree.default_proc, hash.default)
+    end
   end
 
   def test_to_rbtree
@@ -534,7 +545,11 @@ 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)
+    if @rbtree.cmp_proc.respond_to?("source_location")
+      assert_equal(File.basename(__FILE__), @rbtree.cmp_proc.source_location[0])
+    else
+      assert_match(/#<Proc:\w+(@#{__FILE__}:\d+)?>/o, cmp_proc)
+    end
 
     rbtree = RBTree.new
     assert_match(re, rbtree.inspect)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbtree3
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Kyrylo Silin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-07 00:00:00.000000000 Z
+date: 2020-01-21 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.
@@ -47,7 +47,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '1.8'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -55,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: A RBTree is a sorted associative collection that is implemented with a Red-Black