native_btree 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 467637c8963d9da6b70984356470bddfaa7d1b6b3952091e76730852bde71bac
-  data.tar.gz: a1842e6875ae3dbd94855a50cc38e35369a623518a502694df1d7f223ebe481b
+  metadata.gz: 4744529a22fe3d5cd3eb53cf258fa5440346df593e6d268d7af3d2e4b197addf
+  data.tar.gz: 887db38cf3c3c23cd72984f6ec2bbdfce1ebce57e547c5cc2d96c81184a36833
 SHA512:
-  metadata.gz: c14e828145463b99a5edd19b0c830fcba54a86872380e32acee447ce302daea5a9300771f8b4ee68c90c2807e2fd9d595bb9f71ac15c7e9d2f261f95790f9767
-  data.tar.gz: b2d449bfd707dabec594f0847312956cbf6c80543497027611c04eb81215b620dfd4efdbda8427f4628ddd8e500742fdb3d7e12f9664ba963387a1556c40bb74
+  metadata.gz: f46367c894c10a0ca5db645470228f08edafabe9010a5115d9c92008688eec29f9a0973ba462138483912a2bebe52660eb17828298ea69ebd1709d4811cfb470
+  data.tar.gz: 9a342ae22e6ced29b02aa24917f1307fc0a0721885667185266eaa1b23f73fd37c90918126dd1ac6aa24cee08a3c838c25a951e3a84ea5f23cb93e2532d9549d

data/CHANGELOG.md

@@ -7,8 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-* delete_if()
-* each method refactoring for Enumerator return type
+* #compact
+* #compact!
+* #>
+* #>=
+* #<
+* #<=
+
+## [0.6.0] - 2022-10-28
+
+### Added
+
+* inspect
+* to_s
+* delete_if
+* first, min
+* last, max
+
+### Changed
+
+* Refactoring
+* Performance improvements for #==
+
+## [0.5.0] - 2022-10-04
+
+### Added
+
+* ==()
+* each like methods without a block returns Enumerator
+* reverse_each
+
+### Changed
+
+* Refactoring
+
+## [0.4.1] - 2022-09-30
+
+### Changed
+
+* Fix - Failed building on Apple M1 CPU
 
 ## [0.4.0] - 2022-09-16
 

data/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(ruby-native-btree
 	LANGUAGES C
-	VERSION 0.4.1)
+	VERSION 0.6.0)
 
 include(CheckSymbolExists)
 include(CheckCCompilerFlag)

data/README.md

@@ -99,15 +99,18 @@ Implemented methods:
 
 * `[]= (alias: set)`
 * `[] (alias: get)`
+* `==`
 * `delete`
 * `size`
 * `height`
-* `each` (NB! block is required) (NB! block is required)
+* `each`
 * `include?`
 * `clear`
 * `to_h`
 * `to_a`
 * `to_proc`
+* `to_s`
+* `inspect`
 * `filter` (alias: select)
 * `filter!` (alias: select!)
 * `each_value`
@@ -115,5 +118,7 @@ Implemented methods:
 * `search_before` (GLib version >= 2.68) - Select keys <= first arg, ret new Btree
 * `search_after` (GLib version >= 2.68) - Select keys >= first arg, ret new Btree
 * `empty?`
+* `reverse_each`
+* `delete_if`
 
 You can mix in the `Enumerable` module if additional methods are needed.

data/ext/native_btree/CMakeLists.txt

@@ -38,6 +38,7 @@ add_library(iterators OBJECT iterators.c)
 add_library(conversion OBJECT conversion.c)
 add_library(search OBJECT search.c)
 add_library(glib_module OBJECT glib_module.c)
+add_library(utils OBJECT utils.c)
 
 
 set(LIB_OBJECTS)
@@ -53,6 +54,9 @@ list(APPEND LIB_OBJECTS
 
 if(HAS_GTREE_NODE)
 	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:additional_iterators>)
+	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:compare_trees>)
+else()
+	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:utils>)
 endif()
 
 add_library(native_btree_interface

data/ext/native_btree/conversion.c

@@ -76,3 +76,14 @@ rbtree_to_proc(VALUE self)
 {
   return rb_proc_new(to_proc_proc, self);
 }
+
+
+VALUE
+rbtree_to_s(VALUE self)
+{
+  VALUE h = rbtree_to_h(self);
+
+  VALUE str = rb_sprintf("#<NativeBtree::Btree:%"PRIsVALUE">", h);
+
+  return str;
+}

data/ext/native_btree/glib2_68/CMakeLists.txt

@@ -1,3 +1,4 @@
 # set(CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE  ON)
 
 add_library(additional_iterators OBJECT additional_iterators.c)
+add_library(compare_trees OBJECT compare_trees.c)

data/ext/native_btree/glib2_68/compare_trees.c

@@ -0,0 +1,54 @@
+#include <compare_trees.h>
+
+static inline gboolean
+rbtree_compare_trees_nodes(GTreeNode *a, GTreeNode *b)
+{
+  gboolean result = TRUE;
+
+  VALUE key_a = (VALUE) g_tree_node_key(a);
+  VALUE val_a = (VALUE) g_tree_node_value(a);
+  VALUE key_b = (VALUE) g_tree_node_key(b);
+  VALUE val_b = (VALUE) g_tree_node_value(b);
+
+  VALUE key_result = rb_funcall(key_a, rb_intern("=="), 1, key_b);
+
+  if (!RTEST(key_result)) {
+    return FALSE;
+  }
+
+  VALUE val_result = rb_funcall(val_a, rb_intern("=="), 1, val_b);
+
+  if (!RTEST(val_result)) {
+    return FALSE;
+  }
+
+  return result;
+}
+
+/**
+ * Compare two trees
+ *
+ * This function assumes that the number of nodes is same (already checked)
+ */
+gboolean
+rbtree_compare_trees(const RBTree *a, const RBTree *b)
+{
+
+  GTreeNode *a_node = g_tree_node_first(a->gtree);
+  GTreeNode *b_node = g_tree_node_first(b->gtree);
+
+  gboolean result = FALSE;
+
+  while (a_node && b_node) {
+    result = rbtree_compare_trees_nodes(a_node, b_node);
+
+    if (!result) {
+      break;
+    }
+
+    a_node = g_tree_node_next(a_node);
+    b_node = g_tree_node_next(b_node);
+  }
+
+  return result;
+}

data/ext/native_btree/include/compare_trees.h

@@ -0,0 +1,4 @@
+#include <common.h>
+
+gboolean
+rbtree_compare_trees(const RBTree *a, const RBTree *b);

data/ext/native_btree/include/iterators.h

@@ -1,13 +1,20 @@
 #include <common.h>
 
+#ifndef _NATIVE_BTREE_ITERATORS_
+#define _NATIVE_BTREE_ITERATORS_
+
 typedef struct {
   const VALUE block;
   const RBTree *tree;
+  glong counter;
+  gushort flags;
   gconstpointer something;
-} RBTreeSearchData;
+} RBTreeSearchContext;
 
 #ifdef HAS_GTREE_NODE
 
 typedef GTreeNode *(RBTreeStepFunction) (GTreeNode *node);
 
 #endif
+
+#endif // _NATIVE_BTREE_ITERATORS_

data/ext/native_btree/include/native_btree.h

@@ -83,4 +83,19 @@ rbtree_keys(VALUE self);
 VALUE
 rbtree_values(VALUE self);
 
+VALUE
+rbtree_equal(VALUE self, VALUE btree);
+
+VALUE
+rbtree_reverse_each(VALUE self);
+
+VALUE
+rbtree_first(VALUE self);
+
+VALUE
+rbtree_last(VALUE self);
+
+VALUE
+rbtree_to_s(VALUE self);
+
 #endif // _NATIVE_BTREE_

data/ext/native_btree/include/utils.h

@@ -0,0 +1,10 @@
+#include <common.h>
+
+
+#ifndef _NATIVE_BTREE_UTILS_
+#define _NATIVE_BTREE_UTILS_
+
+GPtrArray*
+rbtree_to_ptr_array(const RBTree *rbtree);
+
+#endif //_NATIVE_BTREE_UTILS_

data/ext/native_btree/instance.c

@@ -1,5 +1,11 @@
 #include <common.h>
 
+#ifdef HAS_GTREE_NODE
+  #include <compare_trees.h>
+#else
+  #include <utils.h>
+  #include <iterators.h>
+#endif
 
 #ifndef HAS_GTREE_REMOVE_ALL
 
@@ -15,6 +21,96 @@ rbtree_remove_node(gpointer key, gpointer val, gpointer data) {
 #endif
 
 
+#ifndef HAS_GTREE_NODE
+
+static gint
+rbtree_first_cb(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+
+  context->something = (gconstpointer) b;
+  context->counter = 0;
+
+  return TRUE;
+}
+
+
+static gint
+rbtree_last_cb(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+
+  context->something = (gconstpointer) b;
+  context->counter += 1;
+
+  return FALSE;
+}
+
+
+static gint
+legacy_compare_visitor(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+
+  GPtrArray *flat_tree = (GPtrArray *) context->something;
+  VALUE key = (VALUE) a;
+  VALUE val = (VALUE) b;
+  VALUE is_eq = Qfalse;
+
+  VALUE key2 = (VALUE) g_ptr_array_index(flat_tree, context->counter);
+  VALUE val2 = (VALUE) g_ptr_array_index(flat_tree, context->counter + 1);
+
+  is_eq = rb_funcall(key, rb_intern("=="), 1, key2);
+
+  if (!RTEST(is_eq)) {
+    context->flags = 1;
+    return TRUE;
+  }
+
+  is_eq = rb_funcall(val, rb_intern("=="), 1, val2);
+
+  if (!RTEST(is_eq)) {
+    context->flags = 1;
+    return TRUE;
+  }
+
+  (context->counter) += 2;
+
+  return FALSE;
+}
+
+
+static inline gboolean
+legacy_rbtree_compare(const RBTree *a, const RBTree *b)
+{
+  gboolean result = TRUE;
+
+  GPtrArray *second = rbtree_to_ptr_array(b);
+
+  // assumes that the size of arrays is same (checked before)
+
+  RBTreeSearchContext context = {
+    Qnil,
+    NULL,
+    0,
+    0,
+    (gconstpointer) second
+  };
+
+  g_tree_foreach(a->gtree, legacy_compare_visitor, &context);
+
+  if (context.flags) {
+    result = FALSE;
+  }
+
+  g_ptr_array_free(second, TRUE);
+
+  return result;
+}
+
+#endif
+
+
 VALUE
 rbtree_set(VALUE self, VALUE key, VALUE value)
 {
@@ -63,9 +159,7 @@ rbtree_delete(VALUE self, VALUE key)
   }
   else {
     if (rb_block_given_p()) {
-      VALUE block = rb_block_proc();
-
-      return rb_funcall(block, rb_intern("call"), 1, key);
+      return rb_yield(key);
     }
 
     return Qnil;
@@ -136,3 +230,104 @@ rbtree_is_empty(VALUE self)
 
   return size > 0 ? Qfalse : Qtrue;
 }
+
+
+VALUE
+rbtree_equal(VALUE self, VALUE second)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+  EXTRACT_RBTREE(second, rbtree2);
+
+  gint self_size = g_tree_nnodes(rbtree->gtree);
+  gint second_size = g_tree_nnodes(rbtree2->gtree);
+
+  VALUE result = Qfalse;
+
+  if (self_size != second_size) {
+    goto ret;
+  }
+
+  if (self_size == 0) {
+    result = Qtrue;
+    goto ret;
+  }
+
+#ifdef HAS_GTREE_NODE
+  if (rbtree_compare_trees(rbtree, rbtree2)) {
+    result = Qtrue;
+  }
+#else
+  if (legacy_rbtree_compare(rbtree, rbtree2)) {
+    result = Qtrue;
+  }
+#endif
+
+  ret:
+  return result;
+}
+
+
+VALUE
+rbtree_first(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+#ifdef HAS_GTREE_NODE
+  GTreeNode *node = g_tree_node_first(rbtree->gtree);
+
+  if (!node) {
+    return Qnil;
+  }
+
+  return (VALUE) g_tree_node_value(node);
+#else
+  RBTreeSearchContext context = {
+    Qnil,
+    NULL,
+    1,
+    0,
+    NULL
+  };
+
+  g_tree_foreach(rbtree->gtree, rbtree_first_cb, &context);
+
+  if (context.counter) {
+    return Qnil;
+  }
+
+  return (VALUE) context.something;
+#endif
+}
+
+
+VALUE
+rbtree_last(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+#ifdef HAS_GTREE_NODE
+  GTreeNode *node = g_tree_node_last(rbtree->gtree);
+
+  if (!node) {
+    return Qnil;
+  }
+
+  return (VALUE) g_tree_node_value(node);
+#else
+  RBTreeSearchContext context = {
+    Qnil,
+    NULL,
+    0,
+    0,
+    NULL
+  };
+
+  g_tree_foreach(rbtree->gtree, rbtree_last_cb, &context);
+
+  if (!context.counter) {
+    return Qnil;
+  }
+
+  return (VALUE) context.something;
+#endif
+}

data/ext/native_btree/iterators.c

@@ -1,5 +1,9 @@
 #include <common.h>
+#include <iterators.h>
 
+#ifndef HAS_GTREE_NODE
+  #include <utils.h>
+#endif
 
 static gboolean
 foraech_callbac(gpointer a, gpointer b, gpointer data)
@@ -38,14 +42,22 @@ foraech_value_callbac(gpointer a, gpointer b, gpointer data)
 }
 
 
+static VALUE
+rbtree_enum_length(VALUE rbtree, VALUE args, VALUE eobj)
+{
+  return rbtree_size(rbtree);
+}
+
+
 VALUE
 rbtree_each(VALUE self)
 {
-  rb_need_block();
-  VALUE block = rb_block_proc();
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
 
   EXTRACT_RBTREE_SELF(rbtree);
 
+  VALUE block = rb_block_proc();
+
   g_tree_foreach(rbtree->gtree, foraech_callbac, (gpointer) block);
 
   return self;
@@ -55,11 +67,12 @@ rbtree_each(VALUE self)
 VALUE
 rbtree_each_key(VALUE self)
 {
-  rb_need_block();
-  VALUE block = rb_block_proc();
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
 
   EXTRACT_RBTREE_SELF(rbtree);
 
+  VALUE block = rb_block_proc();
+
   g_tree_foreach(rbtree->gtree, foraech_key_callbac, (gpointer) block);
 
   return self;
@@ -69,12 +82,100 @@ rbtree_each_key(VALUE self)
 VALUE
 rbtree_each_value(VALUE self)
 {
-  rb_need_block();
-  VALUE block = rb_block_proc();
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
 
   EXTRACT_RBTREE_SELF(rbtree);
 
+  VALUE block = rb_block_proc();
+
   g_tree_foreach(rbtree->gtree, foraech_value_callbac, (gpointer) block);
 
   return self;
 }
+
+
+VALUE
+rbtree_reverse_each(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
+
+#ifdef HAS_GTREE_NODE
+  GTreeNode *current = g_tree_node_last(rbtree->gtree);
+
+  VALUE key, val;
+  while (current) {
+    key = (VALUE) g_tree_node_key(current);
+    val = (VALUE) g_tree_node_value(current);
+
+    rb_yield_values(2, val, key);
+
+    current = g_tree_node_previous(current);
+  }
+#else
+  GPtrArray *buff = rbtree_to_ptr_array(rbtree);
+
+  VALUE key, val;
+  for (glong i = buff->len - 1; i > 0; i--) {
+    val = (VALUE) g_ptr_array_index(buff, i);
+    key = (VALUE) g_ptr_array_index(buff, --i);
+
+    rb_yield_values(2, val, key);
+  }
+
+  g_ptr_array_free(buff, TRUE);
+#endif
+
+  return self;
+}
+
+
+static gint
+rbtree_delete_if_cb(gpointer k, gpointer v, gpointer data)
+{
+  VALUE key = (VALUE) k;
+  VALUE value = (VALUE) v;
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
+  VALUE block = (VALUE) context->block;
+  GPtrArray *result = (GPtrArray *) context->something;
+
+  VALUE to_delete = rb_funcall(block, rb_intern("call"), 2, key, value);
+
+  if (RTEST(to_delete)) {
+    g_ptr_array_add(result, (gpointer) key);
+  }
+
+  return FALSE;
+}
+
+
+VALUE
+rbtree_delete_if(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  GPtrArray *to_delete = g_ptr_array_new();
+
+  RETURN_SIZED_ENUMERATOR(self, 0, 0, rbtree_enum_length);
+
+  VALUE block = rb_block_proc();
+
+  RBTreeSearchContext context = {
+    block,
+    NULL,
+    0,
+    0,
+    to_delete
+  };
+
+  g_tree_foreach(rbtree->gtree, rbtree_delete_if_cb, &context);
+
+  for (guint i = 0; i < to_delete->len; i++) {
+    g_tree_remove(rbtree->gtree, g_ptr_array_index(to_delete, i));
+  }
+
+  g_ptr_array_free(to_delete, TRUE);
+
+  return self;
+}

data/ext/native_btree/native_btree.c

@@ -55,6 +55,15 @@ Init_native_btree()
   rb_define_method(native_btree_class, "filter!", rbtree_filter_bang, 0);
   rb_define_alias(native_btree_class, "select!", "filter!");
   rb_define_method(native_btree_class, "empty?", rbtree_is_empty, 0);
+  rb_define_method(native_btree_class, "==", rbtree_equal, 1);
+  rb_define_method(native_btree_class, "reverse_each", rbtree_reverse_each, 0);
+  rb_define_method(native_btree_class, "first", rbtree_first, 0);
+  rb_define_alias(native_btree_class, "min", "first");
+  rb_define_method(native_btree_class, "last", rbtree_last, 0);
+  rb_define_alias(native_btree_class, "max", "last");
+  rb_define_method(native_btree_class, "delete_if", rbtree_delete_if, 0);
+  rb_define_method(native_btree_class, "to_s", rbtree_to_s, 0);
+  rb_define_alias(native_btree_class, "inspect", "to_s");
 
 #ifdef HAS_GTREE_NODE
   rb_define_method(native_btree_class, "select_before", rbtree_select_before, 1);

data/ext/native_btree/search.c

@@ -4,7 +4,7 @@
 static gboolean
 filter_callback(gpointer a, gpointer b, gpointer data)
 {
-  RBTreeSearchData *context = (RBTreeSearchData *) data;
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
 
   VALUE compare_result = rb_funcall(
     context->block,
@@ -24,7 +24,7 @@ filter_callback(gpointer a, gpointer b, gpointer data)
 static gboolean
 filter_bang_callback(gpointer a, gpointer b, gpointer data)
 {
-  RBTreeSearchData *context = (RBTreeSearchData *) data;
+  RBTreeSearchContext *context = (RBTreeSearchContext *) data;
   GPtrArray *to_remove = (GPtrArray *) context->something;
 
   VALUE compare_result = rb_funcall(
@@ -55,9 +55,11 @@ rbtree_filter(VALUE self)
 
   EXTRACT_RBTREE(new_tree, new_rbtree);
 
-  RBTreeSearchData data = {
+  RBTreeSearchContext data = {
     block,
     new_rbtree,
+    0,
+    0,
     NULL
   };
 
@@ -76,9 +78,11 @@ rbtree_filter_bang(VALUE self)
 
   GPtrArray *to_remove = g_ptr_array_new();
 
-  RBTreeSearchData data = {
+  RBTreeSearchContext data = {
     block,
     NULL,
+    0,
+    0,
     (gconstpointer) to_remove
   };
 

data/ext/native_btree/utils.c

@@ -0,0 +1,26 @@
+#include <utils.h>
+
+
+static gint
+to_ptr_array_cb(gpointer a, gpointer b, gpointer data)
+{
+  GPtrArray *buff = (GPtrArray *) data;
+
+  g_ptr_array_add(buff, a);
+  g_ptr_array_add(buff, b);
+
+  return FALSE;
+}
+
+
+GPtrArray*
+rbtree_to_ptr_array(const RBTree *rbtree)
+{
+  gint tree_size = g_tree_nnodes(rbtree->gtree);
+
+  GPtrArray *buff = g_ptr_array_sized_new(tree_size * 2);
+
+  g_tree_foreach(rbtree->gtree, to_ptr_array_cb, (gpointer) buff);
+
+  return buff;
+}

data/lib/native_btree/version.rb

@@ -1,3 +1,3 @@
 module NativeBtree
-  VERSION = "0.4.1".freeze
+  VERSION = "0.6.0".freeze
 end

data/spec/debug.rb

@@ -1,8 +1,12 @@
 # rubocop:disable all
 
 require_relative "../lib/native_btree/native_btree"
+require 'benchmark'
+
+NativeBtree::Btree.include(Enumerable)
 
 tree = NativeBtree::Btree.new() {|a, b| a - b }
+tree2 = NativeBtree::Btree.new() {|a, b| a - b }
 
 GC.start
 
@@ -17,8 +21,6 @@ GC.start
 block = ->(key) { "#{key} is not found" }
 puts tree.delete(77, &block)
 
-tree2 = tree.filter!() { true }
-
 puts tree.to_h
 
 pr = tree.to_proc
@@ -27,15 +29,12 @@ puts pr
 
 
 tree.clear
-tree[1] = 15
-tree[2] = 22
-tree[3] = 33
-tree[4] = 44
-tree[5] = 55
-tree[6] = 66
-tree[7] = 77
-
-puts tree.select_after(4).to_h
+(1..1000000).each do |i|
+  tree[i] = i+2
+  tree2[i] = i+2
+end
+
+puts tree == tree2
 
 GC.start
 

data/spec/native_btree_conversion_spec.rb

@@ -65,6 +65,37 @@ RSpec.describe NativeBtree do
           expect(pr.call(12)).to be_nil
         end
       end
+
+      describe "#to_s" do
+        it 'respond to' do
+          expect(tree).to respond_to(:to_s)
+        end
+
+        it 'return correct str for empty' do
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{}>')
+        end
+
+        it 'return correct str' do
+          tree[10] = "20"
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{10=>"20"}>')
+        end
+      end
+
+      describe "#inspect" do
+        it 'respond to' do
+          expect(tree).to respond_to(:inspect)
+        end
+
+        it 'return correct str for empty' do
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{}>')
+        end
+
+        it 'return correct str' do
+          tree[10] = "20"
+          tree[30] = "40"
+          expect(tree.to_s).to eq('#<NativeBtree::Btree:{10=>"20", 30=>"40"}>')
+        end
+      end
     end
   end
 end

data/spec/native_btree_instance_spec.rb

@@ -186,5 +186,134 @@ RSpec.describe NativeBtree do
         expect(tree.empty?).to be true
       end
     end
+
+    describe '#== method' do
+      let(:tree2) do
+        described_class.new do |a, b|
+          a - b
+        end
+      end
+
+      it 'respond to' do
+        expect(tree).to respond_to(:==)
+      end
+
+      it 'return true if eql' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[7] = 77
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).to eq tree2
+      end
+
+      it 'return false if not eql' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[7] = 77
+        tree[8] = 88
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).not_to eq tree2
+      end
+
+      it 'return true if are empty trees' do
+        expect(tree).to eq tree2
+      end
+
+      it 'return false if one key is not eq' do
+        tree[5] = 11
+        tree[2] = 22
+        tree[7] = 77
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).not_to eq tree2
+      end
+
+      it 'return false if one value is not eq' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[7] = 7
+
+        tree2[7] = 77
+        tree2[2] = 22
+        tree2[1] = 11
+
+        expect(tree).not_to eq tree2
+      end
+
+      it 'return false if any tree is empty' do
+        tree[1] = 11
+        tree[2] = 22
+
+        expect(tree).not_to eq tree2
+      end
+    end
+
+    describe '#last method' do
+      it 'respond to' do
+        expect(tree).to respond_to(:last)
+      end
+
+      it 'return correct value' do
+        tree[1] = 10
+        tree[10] = 20
+        tree[20] = 30
+
+        expect(tree.last).to eq(30)
+      end
+
+      it 'return nil if empty' do
+        expect(tree.last).to be_nil
+      end
+    end
+
+    describe '#first method' do
+      it 'respond to' do
+        expect(tree).to respond_to(:first)
+      end
+
+      it 'return correct value' do
+        tree[1] = 10
+        tree[10] = 20
+        tree[20] = 30
+
+        expect(tree.first).to eq(10)
+      end
+
+      it 'return nil if empty' do
+        expect(tree.first).to be_nil
+      end
+    end
+
+    describe '#delete_if method' do
+      it 'respond to' do
+        expect(tree).to respond_to(:delete_if)
+      end
+
+      it 'return self' do
+        expect(tree.delete_if { |_, _| false }).to be tree
+      end
+
+      it 'return expected result' do
+        tree[1] = 10
+        tree[10] = 20
+        tree[20] = 30
+
+        tree.delete_if { |_, v| v < 30 }
+
+        expect(tree.to_a).to eq([[20, 30]])
+      end
+    end
+
   end
 end

data/spec/native_btree_iterators_spec.rb

@@ -45,6 +45,28 @@ RSpec.describe NativeBtree do
 
         expect(result).to eq(check)
       end
+
+      it 'return Enumerator without block' do
+        expect(tree.each).to be_kind_of(Enumerator)
+      end
+
+      it 'enumerator return correct values' do
+        tree[16] = 16
+        tree[0] = 0
+        tree[5] = 5
+        tree[-4] = -4
+        tree[7] = 7
+
+        check = [[-4, -4], [0, 0], [5, 5], [7, 7], [16, 16]]
+        result = []
+        enum = tree.each
+
+        loop do
+          result.push enum.next
+        end
+
+        expect(result).to eq(check)
+      end
     end
 
     describe "#each_key method" do
@@ -86,5 +108,43 @@ RSpec.describe NativeBtree do
         expect(result).to eq(check)
       end
     end
+
+    describe "#reverse_each method" do
+      it "respond to" do
+        expect(tree).to respond_to(:reverse_each)
+      end
+
+      it 'yield in to block value first' do
+        tree[2] = 22
+
+        value = nil
+        tree.reverse_each { |v| value = v }
+
+        expect(value).to be 22
+      end
+
+      it 'yield in to block key second' do
+        tree[2] = 22
+
+        key = nil
+        tree.reverse_each { |_v, k| key = k }
+
+        expect(key).to be 2
+      end
+
+      it 'yield ordered keys in reverse order' do
+        tree[16] = 16
+        tree[0] = 0
+        tree[5] = 5
+        tree[-4] = -4
+        tree[7] = 7
+
+        check = [16, 7, 5, 0, -4]
+        result = []
+        tree.reverse_each { |value| result << value }
+
+        expect(result).to eq(check)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: native_btree
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Alexander Feodorov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-30 00:00:00.000000000 Z
+date: 2022-10-27 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings to GTree balanced binary tree from GLib library.
 email:
@@ -31,18 +31,22 @@ files:
 - ext/native_btree/extconf_cmake.rb
 - ext/native_btree/glib2_68/CMakeLists.txt
 - ext/native_btree/glib2_68/additional_iterators.c
+- ext/native_btree/glib2_68/compare_trees.c
 - ext/native_btree/glib_module.c
 - ext/native_btree/include/common.h
 - ext/native_btree/include/comparator.h
+- ext/native_btree/include/compare_trees.h
 - ext/native_btree/include/glib_module.h
 - ext/native_btree/include/iterators.h
 - ext/native_btree/include/native_btree.h
 - ext/native_btree/include/rbtree_type.h
+- ext/native_btree/include/utils.h
 - ext/native_btree/instance.c
 - ext/native_btree/iterators.c
 - ext/native_btree/native_btree.c
 - ext/native_btree/rbtree_type.c
 - ext/native_btree/search.c
+- ext/native_btree/utils.c
 - lib/native_btree.rb
 - lib/native_btree/native_btree.bundle
 - lib/native_btree/version.rb