native_btree 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08e62bb88bd973ac257570f1b769323dea7ccedf9c0c2d80f5e99ba7eb2f33ff'
-  data.tar.gz: d8d2cfac5c388216c45b1c17e225a2982871dd94c871414623f73222cd8e6f81
+  metadata.gz: 48b0e894826a65be636d9e13813c6d084c69a306d0778caf3fc709511dc5d2f5
+  data.tar.gz: 18f2f200813df0762181ebb4e7d3cc32c1cd8ae337ab9a35547d9265fa91eaeb
 SHA512:
-  metadata.gz: 5ef4b7687b447e1b36c32e0252bb71f90005e0cfa729a1ddfd6f62f0b4e6b0c11ef29e3703563459de551fa3ae0577c537cd8d09f1a04fa34745d2abf53ab541
-  data.tar.gz: 99d89673be28500e83030d0d300f758ff0857d0be0d9026dd39d72fe7b35ac58bdc44ba5fd567145ace04676ada29dd6a4afe895e47c99b23de530f53cf72951
+  metadata.gz: 4c574719cc0366f86f8459e5e17c59739dab7886ae2cfe56450ed8696906fe4c13be6e90265756a195d04548a627018540c8d119e143d19e0b5cab378c166448
+  data.tar.gz: 8239197687c68a713da92c7d108b41acfe83c30dcbee888e7363e0842b2f6bdc7af30e584e96a5438c08bb5bd306399f986cb31d0dad86d2cf17c9ee65820638

data/CHANGELOG.md

@@ -7,10 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-* delete_if()
+* #compact
+* #compact!
+* #>
+* #>=
+* #<
+* #<=
+
+## [0.6.1] - 2023-05-05
+
+### Added
+
+* api docs
+
+## [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

data/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(ruby-native-btree
 	LANGUAGES C
-	VERSION 0.5.0)
+	VERSION 0.6.1)
 
 include(CheckSymbolExists)
 include(CheckCCompilerFlag)
@@ -22,7 +22,7 @@ if(HAVE_CC_MARCH_NATIVE)
 	string(APPEND CMAKE_C_FLAGS " -march=native")
 endif()
 
-set(CMAKE_C_FLAGS_DEBUG "-O0 -ggdb3 -Wall -Wextra -Wno-unused-parameter")
+set(CMAKE_C_FLAGS_DEBUG "-O0 -ggdb3 -Wall -Wextra -Wno-unused-parameter --coverage")
 set(CMAKE_C_FLAGS_RELEASE "-O3 -fomit-frame-pointer")
 
 # Force -fPIC

data/README.md

@@ -1,6 +1,7 @@
 # GLib Balanced binary tree (GTree) bindings for Ruby
 
 [![Ruby](https://github.com/unixs/ruby-native-btree/actions/workflows/main.yml/badge.svg)](https://github.com/unixs/ruby-native-btree/actions/workflows/main.yml)
+[![codecov](https://codecov.io/gh/unixs/ruby-native-btree/branch/master/graph/badge.svg?token=10JIVX89NG)](https://codecov.io/gh/unixs/ruby-native-btree)
 [![Gem Version](https://badge.fury.io/rb/native_btree.svg)](https://badge.fury.io/rb/native_btree)
 [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
 
@@ -87,35 +88,11 @@ tree.to_a
 #]
 ```
 
-## API ref
+## API
 
-You must provide your own comparator for keys in `new` class method block.
+* You must provide your own comparator for keys in `new` class method block.
+* You can mix in the `Enumerable` module if additional methods are needed.
 
 ### API methods
 
-In general this class behave same as Hash
-
-Implemented methods:
-
-* `[]= (alias: set)`
-* `[] (alias: get)`
-* `==`
-* `delete`
-* `size`
-* `height`
-* `each` (NB! block is required) (NB! block is required)
-* `include?`
-* `clear`
-* `to_h`
-* `to_a`
-* `to_proc`
-* `filter` (alias: select)
-* `filter!` (alias: select!)
-* `each_value`
-* `each_key`
-* `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`
-
-You can mix in the `Enumerable` module if additional methods are needed.
+[YARD documentation](https://rubydoc.info/gems/native_btree)

data/Rakefile

@@ -37,7 +37,7 @@ namespace :cmake do
     sh "cmake --build #{BUILD_DIR}"
   end
 
-  desc "`Rebuild ext CMake project"
+  desc "Rebuild ext CMake project"
   task rebuild: %i[cmake:configure] do
     sh "cmake --build #{BUILD_DIR} --clean-first"
   end

data/ext/native_btree/constructor.c

@@ -27,6 +27,14 @@ init_rbtree(RBTree *rbtree, gushort flags)
   rbtree->flags = flags;
 }
 
+/**
+ * Constructor
+ *
+ * Accepts block as "comparator" function.
+ * This function will recive two keys for comparison.
+ *
+ * @return [Btree] new instance
+ */
 VALUE
 rbtree_initialize(int argc, VALUE* argv, VALUE self)
 {

data/ext/native_btree/conversion.c

@@ -26,7 +26,11 @@ rbtree_to_a_callback(gpointer key, gpointer value, gpointer data)
   return FALSE;
 }
 
-
+/**
+ * Converts tree to Hash
+ *
+ * @return [Hash] result
+ */
 VALUE
 rbtree_to_h(VALUE self)
 {
@@ -39,7 +43,13 @@ rbtree_to_h(VALUE self)
   return hash;
 }
 
-
+/**
+ * Converts tree to array
+ *
+ * Coverts tree to array of arrays with key and value
+ *
+ * @return [Array] result
+ */
 VALUE
 rbtree_to_a(VALUE self)
 {
@@ -70,9 +80,30 @@ to_proc_proc(RB_BLOCK_CALL_FUNC_ARGLIST(key, callback_arg))
   return value;
 }
 
-
+/**
+ * Returns a Proc object that maps a key to its value
+ *
+ * @return [Proc] block
+ */
 VALUE
 rbtree_to_proc(VALUE self)
 {
   return rb_proc_new(to_proc_proc, self);
 }
+
+/**
+ * Converts tree to string.
+ *
+ * Under hood will convert tree to Hash.
+ *
+ * @return [String] result
+ */
+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/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

@@ -89,4 +89,13 @@ 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/instance.c

@@ -4,6 +4,7 @@
   #include <compare_trees.h>
 #else
   #include <utils.h>
+  #include <iterators.h>
 #endif
 
 #ifndef HAS_GTREE_REMOVE_ALL
@@ -20,6 +21,104 @@ 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
+
+/**
+ * Adds key/value pair in to tree.
+ *
+ * Key/value will be replaced if key already exists.
+ *
+ * @param key [Object]
+ * @param value [Object]
+ * @return [Btree] self
+ */
 VALUE
 rbtree_set(VALUE self, VALUE key, VALUE value)
 {
@@ -30,7 +129,14 @@ rbtree_set(VALUE self, VALUE key, VALUE value)
   return self;
 }
 
-
+/**
+ * Gets value by key from tree.
+ *
+ * * Returns +nil+ if key does not exist.
+ *
+ * @param key [Object]
+ * @return [Object] result
+ */
 VALUE
 rbtree_get(VALUE self, VALUE key)
 {
@@ -47,7 +153,16 @@ rbtree_get(VALUE self, VALUE key)
   return result;
 }
 
-
+/**
+ * Deletes key/value pair from tree.
+ *
+ * * Returns value if key exists
+ * * Returns +nil+ if key does not exists
+ * * Returns result of block if block was given
+ *
+ * @param key [Object] Key
+ * @return [Object] result
+ */
 VALUE
 rbtree_delete(VALUE self, VALUE key)
 {
@@ -75,7 +190,11 @@ rbtree_delete(VALUE self, VALUE key)
   }
 }
 
-
+/**
+ * Returns tree height
+ *
+ * @return [Integer] maximum nodes in path from root to leaf
+ */
 VALUE
 rbtree_height(VALUE self)
 {
@@ -87,7 +206,11 @@ rbtree_height(VALUE self)
   return result;
 }
 
-
+/**
+ * Returns number of nodes
+ *
+ * @return [Integer] number of nodes
+ */
 VALUE
 rbtree_size(VALUE self)
 {
@@ -99,7 +222,11 @@ rbtree_size(VALUE self)
   return result;
 }
 
-
+/**
+ * Remove all nodes from tree.
+ *
+ * @return [Btree] self
+ */
 VALUE
 rbtree_clear(VALUE self)
 {
@@ -115,6 +242,12 @@ rbtree_clear(VALUE self)
 }
 
 
+/**
+ * Checks that the given key is in the tree.
+ *
+ * @param key [Object]
+ * @return [Boolean] result
+ */
 VALUE
 rbtree_is_include(VALUE self, VALUE key)
 {
@@ -129,7 +262,11 @@ rbtree_is_include(VALUE self, VALUE key)
   return Qtrue;
 }
 
-
+/**
+ * Checks that self tree is empty.
+ *
+ * @return [Boolean] result
+ */
 VALUE
 rbtree_is_empty(VALUE self)
 {
@@ -140,54 +277,18 @@ rbtree_is_empty(VALUE self)
   return size > 0 ? Qfalse : Qtrue;
 }
 
-
-#ifndef HAS_GTREE_NODE
-
-static inline gboolean
-legacy_rbtree_compare(const RBTree *a, const RBTree *b)
-{
-  gboolean result = FALSE;
-
-  GPtrArray *first = rbtree_to_ptr_array(a);
-  GPtrArray *second = rbtree_to_ptr_array(b);
-
-  // assumes that the size of arrays is same (checked before)
-
-  VALUE key, val, key2, val2, is_eq;
-
-  for (guint i = 0; i < first->len; i += 2) {
-    key = (VALUE) g_ptr_array_index(first, i);
-    val = (VALUE) g_ptr_array_index(first, i + 1);
-
-    key2 = (VALUE) g_ptr_array_index(second, i);
-    val2 = (VALUE) g_ptr_array_index(second, i + 1);
-
-    is_eq = rb_funcall(key, rb_intern("=="), 1, key2);
-
-    if (!RTEST(is_eq)) {
-      goto fail;
-    }
-
-    is_eq = rb_funcall(val, rb_intern("=="), 1, val2);
-
-    if (!RTEST(is_eq)) {
-      goto fail;
-    }
-  }
-
-  result = TRUE;
-
-  fail:
-
-  g_ptr_array_free(first, TRUE);
-  g_ptr_array_free(second, TRUE);
-
-  return result;
-}
-
-#endif
-
-
+/**
+ * Checks if two trees are equal.
+ *
+ * Compares with +==+ method all keys and values from trees by order.
+ *
+ * * Returns +false+ if number of keys are not equal.
+ * * Returns +false+ if one keys or one values pair are not equal.
+ * * Returns +true+ if all keys and values are equal.
+ *
+ * @param second [Btree]
+ * @return [Boolean] result
+ */
 VALUE
 rbtree_equal(VALUE self, VALUE second)
 {
@@ -221,3 +322,77 @@ rbtree_equal(VALUE self, VALUE second)
   ret:
   return result;
 }
+
+/**
+ * Returns value from smallest key
+ *
+ * @return [Object] 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
+}
+
+/**
+ * Returns value from largest key
+ *
+ * @return [Object] result
+ */
+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,4 +1,5 @@
 #include <common.h>
+#include <iterators.h>
 
 #ifndef HAS_GTREE_NODE
   #include <utils.h>
@@ -47,7 +48,11 @@ rbtree_enum_length(VALUE rbtree, VALUE args, VALUE eobj)
   return rbtree_size(rbtree);
 }
 
-
+/**
+ * Execute block for each key/value pairs
+ *
+ * @return [Btree] self
+ */
 VALUE
 rbtree_each(VALUE self)
 {
@@ -62,7 +67,11 @@ rbtree_each(VALUE self)
   return self;
 }
 
-
+/**
+ * Execute block for each key
+ *
+ * @return [Btree] self
+ */
 VALUE
 rbtree_each_key(VALUE self)
 {
@@ -77,7 +86,11 @@ rbtree_each_key(VALUE self)
   return self;
 }
 
-
+/**
+ * Execute block for each value
+ *
+ * @return [Btree] self
+ */
 VALUE
 rbtree_each_value(VALUE self)
 {
@@ -92,7 +105,11 @@ rbtree_each_value(VALUE self)
   return self;
 }
 
-
+/**
+ * Execute block for each key/value pairs in reverse order
+ *
+ * @return [Btree] self
+ */
 VALUE
 rbtree_reverse_each(VALUE self)
 {
@@ -128,3 +145,60 @@ rbtree_reverse_each(VALUE self)
 
   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;
+}
+
+/**
+ * Deletes key/value pair from tree by result of block.
+ *
+ * Will execute block for each key/value pairs
+ * and delete them if block returns +true+
+ *
+ * @return [Btree] self
+ */
+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

@@ -2,29 +2,25 @@
 #include <rbtree_type.h>
 #include <glib_module.h>
 
-#define NATIVE_BTREE_MODULE "NativeBtree"
-#define NATIVE_BTREE_CLASS "Btree"
-#define NATIVE_BTREE_CONST_INT_COMPARATOR "INT_COMPARATOR"
-
-
 VALUE native_btree_class;
 VALUE native_btree_module;
 
 void
 Init_native_btree()
 {
-  native_btree_module = rb_define_module(NATIVE_BTREE_MODULE);
-  native_btree_class = rb_define_class_under(
-    native_btree_module,
-    NATIVE_BTREE_CLASS,
-    rb_cObject
-  );
+  native_btree_module = rb_define_module("NativeBtree");
+  native_btree_class = rb_define_class_under(native_btree_module, "Btree", rb_cObject);
 
   VALUE int_comparator = USHORT2NUM(RBTREE_FLAG_INT_COMPARATOR);
   OBJ_FREEZE(int_comparator);
+
+  /**
+   * Represents native comparator for integer keys
+   * @note Can be replaced with specific class in future releases
+   */
   rb_define_const(
     native_btree_class,
-    NATIVE_BTREE_CONST_INT_COMPARATOR,
+    "INT_COMPARATOR",
     int_comparator
   );
 
@@ -57,6 +53,13 @@ Init_native_btree()
   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(
@@ -43,6 +43,13 @@ filter_bang_callback(gpointer a, gpointer b, gpointer data)
   return FALSE;
 }
 
+/**
+ * Filters btree by block call
+ *
+ * If block returns true, key/value will include in result tree
+ *
+ * @return [Btree] result
+ */
 VALUE
 rbtree_filter(VALUE self)
 {
@@ -55,9 +62,11 @@ rbtree_filter(VALUE self)
 
   EXTRACT_RBTREE(new_tree, new_rbtree);
 
-  RBTreeSearchData data = {
+  RBTreeSearchContext data = {
     block,
     new_rbtree,
+    0,
+    0,
     NULL
   };
 
@@ -66,6 +75,13 @@ rbtree_filter(VALUE self)
   return new_tree;
 }
 
+/**
+ * Filters btree by block call
+ *
+ * Same as #filter but returns changed self.
+ *
+ * @return [Btree] result
+ */
 VALUE
 rbtree_filter_bang(VALUE self)
 {
@@ -76,9 +92,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/lib/native_btree/btree.rb

@@ -0,0 +1,6 @@
+module NativeBtree
+  # Main Btree class
+  class Btree # rubocop:disable Lint/EmptyClass
+    # all methods defined in native module
+  end
+end

data/lib/native_btree/version.rb

@@ -1,3 +1,4 @@
 module NativeBtree
-  VERSION = "0.5.0".freeze
+  # gem version
+  VERSION = "0.6.1".freeze
 end

data/lib/native_btree.rb

@@ -1,4 +1,6 @@
-# Bindings to GLib-2.0 data structure BTree
+# Bindings to GLib-2.0 BTree data structure
+#
+# gem root namespace
 module NativeBtree
 end
 

data/spec/debug.rb

@@ -1,6 +1,7 @@
 # rubocop:disable all
 
 require_relative "../lib/native_btree/native_btree"
+require 'benchmark'
 
 NativeBtree::Btree.include(Enumerable)
 

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

@@ -258,5 +258,62 @@ RSpec.describe NativeBtree do
         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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: native_btree
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Alexander Feodorov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-03 00:00:00.000000000 Z
+date: 2023-05-05 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings to GTree balanced binary tree from GLib library.
 email:
@@ -48,6 +48,7 @@ files:
 - ext/native_btree/search.c
 - ext/native_btree/utils.c
 - lib/native_btree.rb
+- lib/native_btree/btree.rb
 - lib/native_btree/native_btree.bundle
 - lib/native_btree/version.rb
 - native_btree.gemspec