native_btree 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dbf5cc77f1056fc6f84cf49496c233b9a3ecd9c62a0d82149cce9804a80edd7
-  data.tar.gz: eb1f55db08e767f443b02751258fb749ae991eb98e5426a8d5c81714c66ebd49
+  metadata.gz: '05598705616620516787d5fd639f883270684c2d3981b1c04056bffd8f2b1849'
+  data.tar.gz: 1dcd3be4d1838e5b01bf7e38b2ca746004903550366f93e91922821feb3229ad
 SHA512:
-  metadata.gz: 7753f72aa3babc2151d74ae4bad29fb7c43e41cd7cf8b3bc9348e4b6e9be3c156d2ecc78fd2e689ca099e27df8bdee376550cbbc16b97ef15f15c431e8c5c093
-  data.tar.gz: d1992054500ad7207aea7186a0aa9bd3099cf013983c2596f5c2b5289ca5c8129f4ceeea4bf9ddf0777eb019b4dfc70be3b0feb571d741bb148af1f68de6e754
+  metadata.gz: 98aa96b9820e879f94cc1f6682f9eb82f2139c7a81dd92f955db24167f9f8b384a80221b10ade4de7718c5fb56f94eea1f19fbb4360dc25c639bf1b4fd682230
+  data.tar.gz: f9410012b8ce525b4816377b8c8998e4ded903fca874e268a1a613a4759a5bf62051e4b55dec4259c15be5a301b1bb23978b0198b0e66d28c83e4f5f7954af1f

data/CHANGELOG.md

@@ -10,6 +10,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * delete_if()
 * each method refactoring for Enumerator return type
 
+## [0.4.0] - 2022-09-16
+
+### Added
+
+* Native integer comparator
+* search_before()
+* search_after()
+* empty?()
+
+### Changed
+
+* Bugfixes
+
 ## [0.3.0] - 2022-09-11
 
 ### Added

data/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(ruby-native-btree
 	LANGUAGES C
-	VERSION 0.3.0)
+	VERSION 0.4.0)
 
 include(CheckSymbolExists)
 
@@ -12,8 +12,8 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_EXTENSIONS ON)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 
-set(CMAKE_C_FLAGS_DEBUG " -O0 -ggdb3 -Wall -Wextra -Wpedantic -Wno-unused-parameter")
-set(CMAKE_C_FLAGS_RELEASE "-O3")
+set(CMAKE_C_FLAGS_DEBUG " -O0 -ggdb3 -Wall -Wextra -Wno-unused-parameter")
+set(CMAKE_C_FLAGS_RELEASE "-O3 -fomit-frame-pointer")
 set(CMAKE_C_FLAGS "-pipe -march=native")
 
 # Force -fPIC

data/README.md

@@ -11,7 +11,7 @@ In most cases it will behave same as Hash, but keys will be ordered by passed co
 
 ## Requirements
 
-* **CMake** build tool version **>= 3.14.0**
+* **CMake** build tool version **>= 3.5.0**, >= 3.14.0 will be cool.
 * `pkg-config` tool
 * **GLib** library
   * On Ubuntu run:
@@ -29,6 +29,7 @@ In most cases it will behave same as Hash, but keys will be ordered by passed co
 
 ## Basic usage
 
+### Example
 ```ruby
 require 'native_btree'
 
@@ -53,6 +54,39 @@ tree.height
 # 2
 ```
 
+### Native int comparator
+Will behave like an array with negative indexes)
+```ruby
+# Pass comparator for keys as block
+tree = NativeBtree::Btree.new(NativeBtree::Btree::INT_COMPARATOR)
+
+tree[-2] = 22
+tree[-1] = 1
+tree[0] = 100
+tree[5] = 55
+
+tree.to_a
+
+#[
+#    [0] [
+#        [0] -2,
+#        [1] 22
+#    ],
+#    [1] [
+#        [0] -1,
+#        [1] 1
+#    ],
+#    [2] [
+#        [0] 0,
+#        [1] 100
+#    ],
+#    [3] [
+#        [0] 5,
+#        [1] 55
+#    ]
+#]
+```
+
 ## API ref
 
 You must provide your own comparator for keys in `new` class method block.
@@ -68,7 +102,7 @@ Implemented methods:
 * `delete`
 * `size`
 * `height`
-* `each` (NB! block is required)
+* `each` (NB! block is required) (NB! block is required)
 * `include?`
 * `clear`
 * `to_h`
@@ -76,5 +110,10 @@ Implemented methods:
 * `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?`
 
 You can mix in the `Enumerable` module if additional methods are needed.

data/ext/native_btree/CMakeLists.txt

@@ -9,12 +9,22 @@ include_directories(include ${GLIB2_INCLUDE_DIRS})
 
 list(APPEND CMAKE_REQUIRED_LIBRARIES ${GLIB2_LDFLAGS})
 list(APPEND CMAKE_REQUIRED_INCLUDES ${GLIB2_INCLUDE_DIRS})
-check_symbol_exists(g_tree_remove_all "glib.h" HAVE_GTREE_REMOVE_ALL)
+check_symbol_exists(g_tree_remove_all "glib.h" HAS_GTREE_REMOVE_ALL)
+check_symbol_exists(g_tree_lookup_node "glib.h" HAS_GTREE_NODE)
 
-if(HAVE_GTREE_REMOVE_ALL)
-	add_compile_definitions(HAVE_GTREE_REMOVE_ALL)
+if(HAS_GTREE_REMOVE_ALL)
+	add_compile_definitions(HAS_GTREE_REMOVE_ALL)
 endif()
 
+if(HAS_GTREE_NODE)
+	add_compile_definitions(HAS_GTREE_NODE)
+	add_subdirectory("glib2_68")
+else()
+	message(WARNING
+		"Available GLib is not support direct node access.
+		Version < 2.68.
+		Additional iterators will not compile.")
+endif()
 
 add_library(${EXT_NAME}
 	SHARED
@@ -27,19 +37,29 @@ add_library(comparator OBJECT comparator.c)
 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(native_btree_interface
-	STATIC
+
+set(LIB_OBJECTS)
+list(APPEND LIB_OBJECTS
 	$<TARGET_OBJECTS:conversion>
 	$<TARGET_OBJECTS:iterators>
 	$<TARGET_OBJECTS:comparator>
 	$<TARGET_OBJECTS:instance>
 	$<TARGET_OBJECTS:constructor>
 	$<TARGET_OBJECTS:rbtree_type>
-	$<TARGET_OBJECTS:search>)
+	$<TARGET_OBJECTS:search>
+	$<TARGET_OBJECTS:glib_module>)
+
+if(HAS_GTREE_NODE)
+	list(APPEND LIB_OBJECTS $<TARGET_OBJECTS:additional_iterators>)
+endif()
+
+add_library(native_btree_interface
+	STATIC
+	${LIB_OBJECTS})
 
 target_link_libraries(${EXT_NAME}
 	PRIVATE
 	native_btree_interface
 	${GLIB2_LDFLAGS})
-

data/ext/native_btree/comparator.c

@@ -11,3 +11,12 @@ rbtree_native_comparator(gconstpointer a, gconstpointer b, gpointer data)
 
   return compare_result;
 }
+
+gint
+rbtree_int_comparator(gconstpointer ra, gconstpointer rb, gpointer data)
+{
+  gint a = NUM2INT((VALUE) ra);
+  gint b = NUM2INT((VALUE) rb);
+
+  return a - b;
+}

data/ext/native_btree/constructor.c

@@ -1,18 +1,46 @@
 #include <comparator.h>
 #include <rbtree_type.h>
+#include <stdbool.h>
 
-VALUE
-rbtree_initialize(VALUE self)
+inline static void
+init_rbtree(RBTree *rbtree, gushort flags)
 {
-  EXTRACT_RBTREE_SELF(rbtree);
+  bool flag_int_comparator = flags & RBTREE_FLAG_INT_COMPARATOR;
+  VALUE comparator = Qnil;
+  // NOTE: Possible segfault
+  GCompareDataFunc native_comparator = NULL;
+
+  if (flag_int_comparator) {
+    native_comparator = rbtree_int_comparator;
+  }
+  else {
+    rb_need_block();
+    comparator = rb_block_proc();
+    native_comparator = rbtree_native_comparator;
+  }
 
   rbtree->gtree = g_tree_new_with_data(
-    rbtree_native_comparator,
+    native_comparator,
     rbtree
   );
+  rbtree->comparator = comparator;
+  rbtree->flags = flags;
+}
+
+VALUE
+rbtree_initialize(int argc, VALUE* argv, VALUE self)
+{
+  rb_check_arity(argc, 0, 1);
+
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gushort flags = 0;
+
+  if (argc > 0) {
+    flags = NUM2USHORT(argv[0]);
+  }
 
-  rb_need_block();
-  rbtree->comparator = rb_block_proc();
+  init_rbtree((RBTree *) rbtree, flags);
 
   return self;
 }

data/ext/native_btree/glib2_68/CMakeLists.txt

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

data/ext/native_btree/glib2_68/additional_iterators.c

@@ -0,0 +1,84 @@
+#include <native_btree.h>
+#include <iterators.h>
+
+static void
+rbtree_gtree_foreach(GTreeNode *node, RBTreeStepFunction step_func, GTraverseFunc callback, gpointer data)
+{
+  while (node) {
+    callback(
+      g_tree_node_key(node),
+      g_tree_node_value(node),
+      data
+    );
+
+    node = step_func(node);
+  }
+}
+
+
+static int
+rbtree_traverse_insert(gpointer key, gpointer value, gpointer tree)
+{
+  g_tree_insert(tree, key, value);
+
+  return FALSE;
+}
+
+
+VALUE
+rbtree_select_before(VALUE self, VALUE target)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE new_tree = rbtree_clone_wrap(rbtree);
+
+  EXTRACT_RBTREE(new_tree, new_rbtree);
+
+  GTreeNode *target_node = g_tree_upper_bound(
+    rbtree->gtree,
+    (gconstpointer) target
+  );
+
+  target_node = g_tree_node_previous(target_node);
+
+  if (!target_node) {
+    return new_tree;
+  }
+
+  rbtree_gtree_foreach(
+    target_node,
+    g_tree_node_previous,
+    rbtree_traverse_insert,
+    (gpointer) new_rbtree->gtree
+  );
+
+  return new_tree;
+}
+
+
+VALUE
+rbtree_select_after(VALUE self, VALUE target)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE new_tree = rbtree_clone_wrap(rbtree);
+  EXTRACT_RBTREE(new_tree, new_rbtree);
+
+  GTreeNode *target_node = g_tree_lower_bound(
+    rbtree->gtree,
+    (gconstpointer) target
+  );
+
+  if (!target_node) {
+    return new_tree;
+  }
+
+  rbtree_gtree_foreach(
+    target_node,
+    g_tree_node_next,
+    rbtree_traverse_insert,
+    (gpointer) new_rbtree->gtree
+  );
+
+  return new_tree;
+}

data/ext/native_btree/glib_module.c

@@ -0,0 +1,45 @@
+#include <stdbool.h>
+#include <common.h>
+#include <glib_module.h>
+
+#define NATIVE_BTREE_GLIB_SUBMODULE "Glib"
+#define GLIB_MODULE_MAJOR_VERSION "MAJOR_VERSION"
+#define GLIB_MODULE_MINOR_VERSION "MINOR_VERSION"
+#define GLIB_MODULE_MICRO_VERSION "MICRO_VERSION"
+
+VALUE rbtree_glib_module;
+
+void
+rbtree_attach_module_glib()
+{
+  static bool initialized = FALSE;
+
+  if (initialized) {
+    return;
+  }
+
+  rbtree_glib_module = rb_define_module_under(
+    native_btree_module,
+    NATIVE_BTREE_GLIB_SUBMODULE
+  );
+
+  rb_define_const(
+    rbtree_glib_module,
+    GLIB_MODULE_MAJOR_VERSION,
+    INT2NUM(GLIB_MAJOR_VERSION)
+  );
+
+  rb_define_const(
+    rbtree_glib_module,
+    GLIB_MODULE_MINOR_VERSION,
+    INT2NUM(GLIB_MINOR_VERSION)
+  );
+
+  rb_define_const(
+    rbtree_glib_module,
+    GLIB_MODULE_MICRO_VERSION,
+    INT2NUM(GLIB_MICRO_VERSION)
+  );
+
+  initialized = TRUE;
+}

data/ext/native_btree/include/common.h

@@ -8,7 +8,7 @@
 #define _NATIVE_BTREE_COMMON_
 
 #define EXTRACT_RBTREE(from, to)                                               \
-  RBTree *to;                                                                  \
+  const RBTree *to;                                                            \
   TypedData_Get_Struct(from, RBTree, &rbtree_type, to)
 
 #define EXTRACT_RBTREE_SELF(to) EXTRACT_RBTREE(self, to)

data/ext/native_btree/include/comparator.h

@@ -2,3 +2,6 @@
 
 gint
 rbtree_native_comparator(gconstpointer a, gconstpointer b, gpointer data);
+
+gint
+rbtree_int_comparator(gconstpointer a, gconstpointer b, gpointer data);

data/ext/native_btree/include/glib_module.h

@@ -0,0 +1,6 @@
+#include <ruby.h>
+
+extern VALUE rbtree_glib_module;
+
+void
+rbtree_attach_module_glib();

data/ext/native_btree/include/iterators.h

@@ -1,7 +1,13 @@
 #include <common.h>
 
 typedef struct {
-  VALUE block;
-  RBTree *tree;
+  const VALUE block;
+  const RBTree *tree;
   gconstpointer something;
 } RBTreeSearchData;
+
+#ifdef HAS_GTREE_NODE
+
+typedef GTreeNode *(RBTreeStepFunction) (GTreeNode *node);
+
+#endif

data/ext/native_btree/include/native_btree.h

@@ -3,7 +3,7 @@
 #include <ruby.h>
 
 VALUE
-rbtree_initialize(VALUE self);
+rbtree_initialize(int argc, VALUE *argv, VALUE self);
 
 VALUE
 rbtree_set(VALUE self, VALUE key, VALUE value);
@@ -29,6 +29,12 @@ rbtree_is_include(VALUE self, VALUE key);
 VALUE
 rbtree_each(VALUE self);
 
+VALUE
+rbtree_each_key(VALUE self);
+
+VALUE
+rbtree_each_value(VALUE self);
+
 VALUE
 rbtree_to_h(VALUE self);
 
@@ -47,4 +53,34 @@ rbtree_filter_bang(VALUE self);
 VALUE
 rbtree_is_empty(VALUE self);
 
+VALUE
+rbtree_select_before(VALUE self, VALUE target);
+
+VALUE
+rbtree_select_after(VALUE self, VALUE target);
+
+VALUE
+rbtree_select_between(VALUE self, VALUE from, VALUE to);
+
+VALUE
+rbtree_flatten(VALUE self);
+
+VALUE
+rbtree_delete_if(VALUE self);
+
+VALUE
+rbtree_has_key(VALUE self, VALUE key);
+
+VALUE
+rbtree_has_value(VALUE self, VALUE value);
+
+VALUE
+rbtree_eql(VALUE self, VALUE tree);
+
+VALUE
+rbtree_keys(VALUE self);
+
+VALUE
+rbtree_values(VALUE self);
+
 #endif // _NATIVE_BTREE_

data/ext/native_btree/include/rbtree_type.h

@@ -4,19 +4,26 @@
 #include <common.h>
 
 #define RBTREE_NATIVE_TYPE_NAME "native_btree"
+#define RBTREE_FLAG_INT_COMPARATOR 0b10000000
 
 extern const rb_data_type_t rbtree_type;
 
+typedef struct _RBTree RBTree;
+
 VALUE
 rbtree_alloc(VALUE self);
 
+VALUE
+rbtree_clone_wrap(const RBTree *orig);
+
 /**
  * Internal native instance
  */
-typedef struct _RBTree
+struct _RBTree
 {
   GTree *gtree;
   VALUE comparator;
-} RBTree;
+  gushort flags;
+};
 
 #endif //_RBTREE_TYPE_

data/ext/native_btree/instance.c

@@ -1,7 +1,7 @@
 #include <common.h>
 
 
-#ifndef HAVE_GTREE_REMOVE_ALL
+#ifndef HAS_GTREE_REMOVE_ALL
 
 static gboolean
 rbtree_remove_node(gpointer key, gpointer val, gpointer data) {
@@ -102,7 +102,7 @@ rbtree_clear(VALUE self)
 {
   EXTRACT_RBTREE_SELF(rbtree);
 
-  #ifdef HAVE_GTREE_REMOVE_ALL
+  #ifdef HAS_GTREE_REMOVE_ALL
     g_tree_remove_all(rbtree->gtree);
   #else
     g_tree_foreach(rbtree->gtree, rbtree_remove_node, (gpointer) rbtree);

data/ext/native_btree/iterators.c

@@ -1,5 +1,6 @@
 #include <common.h>
 
+
 static gboolean
 foraech_callbac(gpointer a, gpointer b, gpointer data)
 {
@@ -12,6 +13,31 @@ foraech_callbac(gpointer a, gpointer b, gpointer data)
   return FALSE;
 }
 
+
+static gboolean
+foraech_key_callbac(gpointer a, gpointer b, gpointer data)
+{
+  VALUE key = (VALUE) a;
+  VALUE block = (VALUE) data;
+
+  rb_funcall(block, rb_intern("call"), 1, key);
+
+  return FALSE;
+}
+
+
+static gboolean
+foraech_value_callbac(gpointer a, gpointer b, gpointer data)
+{
+  VALUE value = (VALUE) b;
+  VALUE block = (VALUE) data;
+
+  rb_funcall(block, rb_intern("call"), 1, value);
+
+  return FALSE;
+}
+
+
 VALUE
 rbtree_each(VALUE self)
 {
@@ -24,3 +50,31 @@ rbtree_each(VALUE self)
 
   return self;
 }
+
+
+VALUE
+rbtree_each_key(VALUE self)
+{
+  rb_need_block();
+  VALUE block = rb_block_proc();
+
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  g_tree_foreach(rbtree->gtree, foraech_key_callbac, (gpointer) block);
+
+  return self;
+}
+
+
+VALUE
+rbtree_each_value(VALUE self)
+{
+  rb_need_block();
+  VALUE block = rb_block_proc();
+
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  g_tree_foreach(rbtree->gtree, foraech_value_callbac, (gpointer) block);
+
+  return self;
+}

data/ext/native_btree/native_btree.c

@@ -1,14 +1,15 @@
 #include <native_btree.h>
 #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()
 {
@@ -19,10 +20,20 @@ Init_native_btree()
     rb_cObject
   );
 
+  VALUE int_comparator = USHORT2NUM(RBTREE_FLAG_INT_COMPARATOR);
+  OBJ_FREEZE(int_comparator);
+  rb_define_const(
+    native_btree_class,
+    NATIVE_BTREE_CONST_INT_COMPARATOR,
+    int_comparator
+  );
+
+  rbtree_attach_module_glib();
+
   // rb_include_module(native_btree_class, rb_mEnumerable);
 
   rb_define_alloc_func(native_btree_class, rbtree_alloc);
-  rb_define_method(native_btree_class, "initialize", rbtree_initialize, 0);
+  rb_define_method(native_btree_class, "initialize", rbtree_initialize, -1);
 
   rb_define_method(native_btree_class, "[]=", rbtree_set, 2);
   rb_define_alias(native_btree_class, "set", "[]=");
@@ -30,6 +41,8 @@ Init_native_btree()
   rb_define_alias(native_btree_class, "get", "[]");
   rb_define_method(native_btree_class, "delete", rbtree_delete, 1);
   rb_define_method(native_btree_class, "each", rbtree_each, 0);
+  rb_define_method(native_btree_class, "each_key", rbtree_each_key, 0);
+  rb_define_method(native_btree_class, "each_value", rbtree_each_value, 0);
   rb_define_method(native_btree_class, "size", rbtree_size, 0);
   rb_define_method(native_btree_class, "height", rbtree_height, 0);
   rb_define_method(native_btree_class, "clear", rbtree_clear, 0);
@@ -42,4 +55,9 @@ 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);
+
+#ifdef HAS_GTREE_NODE
+  rb_define_method(native_btree_class, "select_before", rbtree_select_before, 1);
+  rb_define_method(native_btree_class, "select_after", rbtree_select_after, 1);
+#endif
 }

data/ext/native_btree/rbtree_type.c

@@ -8,7 +8,10 @@ rbtree_type_free(gpointer data)
 {
   RBTree *rbtree = (RBTree *) data;
 
-  g_tree_destroy(rbtree->gtree);
+  if (rbtree->gtree) {
+    g_tree_destroy(rbtree->gtree);
+  }
+
   g_free(data);
 }
 
@@ -26,9 +29,11 @@ rbtree_mark_callback(gpointer key, gpointer value, gpointer data)
 static void
 rbtree_type_mark(gpointer data)
 {
-  RBTree *rbtree = (RBTree *)data;
+  RBTree *rbtree = (RBTree *) data;
 
-  rb_gc_mark(rbtree->comparator);
+  if (!NIL_P(rbtree->comparator)) {
+    rb_gc_mark(rbtree->comparator);
+  }
 
   g_tree_foreach(rbtree->gtree, rbtree_mark_callback, NULL);
 }
@@ -98,5 +103,26 @@ rbtree_alloc(VALUE self)
 {
   RBTree *rbtree = g_new(RBTree, 1);
 
+  rbtree->gtree = NULL;
+  rbtree->comparator = Qnil;
+  rbtree->flags = 0;
+
   return TypedData_Wrap_Struct(self, &rbtree_type, rbtree);
 }
+
+
+VALUE
+rbtree_clone_wrap(const RBTree *orig)
+{
+  const VALUE rflags = USHORT2NUM(orig->flags);
+
+  VALUE new_tree = rb_funcall_with_block(
+    native_btree_class,
+    rb_intern("new"),
+    orig->flags ? 1 : 0,
+    orig->flags ? &rflags : NULL,
+    orig->comparator
+  );
+
+  return new_tree;
+}

data/ext/native_btree/search.c

@@ -1,6 +1,5 @@
 #include <iterators.h>
 
-VALUE native_btree_class;
 
 static gboolean
 filter_callback(gpointer a, gpointer b, gpointer data)
@@ -52,13 +51,7 @@ rbtree_filter(VALUE self)
 
   VALUE block = rb_block_proc();
 
-  VALUE new_tree = rb_funcall_with_block(
-    native_btree_class,
-    rb_intern("new"),
-    0,
-    NULL,
-    rbtree->comparator
-  );
+  VALUE new_tree = rbtree_clone_wrap(rbtree);
 
   EXTRACT_RBTREE(new_tree, new_rbtree);
 

data/lib/native_btree/version.rb

@@ -1,3 +1,3 @@
 module NativeBtree
-  VERSION = "0.3.0".freeze
+  VERSION = "0.4.0".freeze
 end

data/spec/debug.rb

@@ -2,7 +2,7 @@
 
 require_relative "../lib/native_btree/native_btree"
 
-tree = NativeBtree::Btree.new { |a, b|  a - b }
+tree = NativeBtree::Btree.new() {|a, b| a - b }
 
 GC.start
 
@@ -24,10 +24,19 @@ puts tree.to_h
 pr = tree.to_proc
 
 puts pr
-puts pr.call(10)
-puts pr.call(16)
 
 
+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
+
 GC.start
 
 puts "exit 0"

data/spec/native_btree_class_spec.rb

@@ -19,6 +19,22 @@ RSpec.describe NativeBtree do
       it "raise error if block is not given" do
         expect { described_class.new() }.to raise_error(LocalJumpError)
       end
+
+      it 'return new btree with int comparator' do
+        expect(described_class.new(described_class::INT_COMPARATOR))
+          .to be_kind_of(described_class)
+      end
+
+    end
+
+    describe "constants" do
+      it 'has const INT_COMPARATOR' do
+        expect(described_class.const_defined?(:INT_COMPARATOR)).to be true
+      end
+
+      it 'const INT_COMPARATOR is 1' do
+        expect(described_class::INT_COMPARATOR).to be 128
+      end
     end
   end
 end

data/spec/native_btree_int_instance_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+RSpec.describe NativeBtree do
+
+  describe NativeBtree::Btree do
+    let(:tree) do
+      described_class.new(described_class::INT_COMPARATOR)
+    end
+
+    describe "#[]= method" do
+
+      it "respond to" do
+        expect(tree).to respond_to('[]=')
+      end
+
+      it 'set key/value pair' do
+        tree[2] = 22
+        expect(tree[2]).to be 22
+      end
+
+      it "pass key arg and value" do
+        expect(tree[:key] = 10).to be 10
+      end
+
+      it "Raise ArgumentError if key was not passed" do
+        expect { tree[] = 1 }.to raise_error(ArgumentError)
+      end
+
+      it 'Call comparator while set value' do
+        comparator = spy('comparator')
+        def comparator.to_proc
+          proc do |a, b|
+            comparator.call()
+            a - b
+          end
+        end
+
+        btree = described_class.new(&comparator)
+        btree[1] = 1
+        btree[2] = 2
+        expect(comparator).to have_received(:call)
+      end
+
+      it 'has a set alias' do
+        expect(tree).to respond_to('set')
+      end
+    end
+
+    describe "#[] method" do
+      it "respond to" do
+        expect(tree).to respond_to('[]')
+      end
+
+      it 'return expected value if found' do
+        tree[3] = 'a'
+        tree[4] = 'b'
+        expect(tree[3]).to be 'a'
+      end
+
+      it 'return nil if not found' do
+        tree[1] = '1'
+        tree[5] = '5'
+        expect(tree[2]).to be_nil
+      end
+
+      it 'has a get alias' do
+        expect(tree).to respond_to('get')
+      end
+    end
+
+    describe "#height method" do
+      it "respond to" do
+        expect(tree).to respond_to(:height)
+      end
+
+      it 'return tree height with items' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[3] = 33
+        tree[4] = 44
+        expect(tree.height).to be 3
+      end
+
+      it 'return 0 if empty tree' do
+        expect(tree.height).to be 0
+      end
+    end
+
+    describe "#size method" do
+      it "respond to" do
+        expect(tree).to respond_to(:size)
+      end
+
+      it 'return count of nodes' do
+        tree[1] = 1
+        tree[2] = 2
+        tree[3] = 3
+        expect(tree.size).to be 3
+      end
+
+      it 'return 0 if empty tree' do
+        expect(tree.size).to be 0
+      end
+
+    end
+
+    describe "#delete method" do
+      it "respond to" do
+        expect(tree).to respond_to(:delete)
+      end
+
+      it 'delete key value pair' do
+        tree[2] = 22
+        tree[3] = 33
+        tree.delete(3)
+        expect(tree[3]).to be_nil
+      end
+
+      it "return nil if not found" do
+        tree[3] = 33
+        expect(tree.delete(4)).to be_nil
+      end
+
+      it "return value if key is found" do
+        tree[2] = 22
+        tree[3] = 33
+        expect(tree.delete(2)).to be 22
+      end
+
+      it "call block with key if not found" do
+        tree[2] = 22
+        block = ->(key) { "#{key} is not found" }
+        expect(tree.delete(7, &block)).to be == "7 is not found"
+      end
+    end
+
+    describe "#clear method" do
+      it "respond to" do
+        expect(tree).to respond_to(:clear)
+      end
+
+      it 'clear tree' do
+        tree[1] = 11
+        tree[2] = 22
+        tree[3] = 33
+        expect(tree.size).to be 3
+        tree.clear()
+        expect(tree.size).to be 0
+      end
+
+      it 'return self' do
+        tree[1] = 11
+        expect(tree.clear()).to be tree
+      end
+    end
+
+    describe "#include? method" do
+      it "respond to" do
+        expect(tree).to respond_to(:include?)
+      end
+
+      it 'return true is key exists' do
+        tree[3] = 33
+        expect(tree.include?(3)).to be true
+      end
+
+      it 'return false if key not exists' do
+        tree[3] = 33
+        expect(tree.include?(4)).to be false
+      end
+    end
+
+    describe "#empty? method" do
+      it 'respond to' do
+        expect(tree).to respond_to(:empty?)
+      end
+
+      it 'return false if nodes exists' do
+        tree[3] = 33
+        expect(tree.empty?).to be false
+      end
+
+      it 'return true if nodes not exists' do
+        expect(tree.empty?).to be true
+      end
+    end
+  end
+end

data/spec/native_btree_iterators_spec.rb

@@ -48,14 +48,42 @@ RSpec.describe NativeBtree do
     end
 
     describe "#each_key method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:each_key)).to be true
+      it "respond to" do
+        expect(tree).to respond_to(:each_key)
+      end
+
+      it 'yield ordered keys' do
+        tree[16] = 160
+        tree[0] = 0
+        tree[5] = 50
+        tree[-4] = -40
+        tree[7] = 70
+
+        check = [-4, 0, 5, 7, 16]
+        result = []
+        tree.each_key { |key| result << key }
+
+        expect(result).to eq(check)
       end
     end
 
     describe "#each_value method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:each_value)).to be true
+      it "respond to" do
+        expect(tree).to respond_to(:each_value)
+      end
+
+      it 'yield values by ordered keys' do
+        tree[16] = 160
+        tree[0] = 0
+        tree[5] = 50
+        tree[-4] = -40
+        tree[7] = 70
+
+        check = [-40, 0, 50, 70, 160]
+        result = []
+        tree.each_value { |value| result << value }
+
+        expect(result).to eq(check)
       end
     end
   end

data/spec/native_btree_module_spec.rb

@@ -12,4 +12,24 @@ RSpec.describe NativeBtree do
   it "Btree is class" do
     expect(described_class::Btree.class).to be Class
   end
+
+  it "Has Glib contstant" do
+    expect(described_class.const_defined?(:Glib)).to be true
+  end
+
+  it "Glib is module" do
+    expect(described_class::Glib.class).to be Module
+  end
+
+  it "Has MAJOR_VERSION contstant" do
+    expect(described_class::Glib.const_defined?(:MAJOR_VERSION)).to be true
+  end
+
+  it "Has MINOR_VERSION contstant" do
+    expect(described_class::Glib.const_defined?(:MINOR_VERSION)).to be true
+  end
+
+  it "Has MICRO_VERSION contstant" do
+    expect(described_class::Glib.const_defined?(:MICRO_VERSION)).to be true
+  end
 end

data/spec/native_btree_search_spec.rb

@@ -54,6 +54,17 @@ RSpec.describe NativeBtree do
         expect(tree.equal?(result)).to be false
       end
 
+      it 'construct correct tree with int comparator' do
+        tree = described_class.new(described_class::INT_COMPARATOR)
+
+        tree[1] = 11
+        tree[5] = 90
+        tree[2] = 32
+        tree[100] = 15
+        tree[46] = 8
+
+        expect(tree.filter { |v| v > 20 }.to_a).to match_array([[2, 32], [5, 90]])
+      end
     end
 
     describe "#filter! method" do
@@ -88,7 +99,8 @@ RSpec.describe NativeBtree do
         tree[100] = 15
         tree[46] = 8
 
-        expect(tree.filter! { |v| v > 20 }.to_a).to match_array([[2, 32], [5, 90]])
+        expect(tree.filter! { |v| v > 20 }.to_a)
+          .to match_array([[2, 32], [5, 90]])
       end
 
       it 'filter tree by keys' do
@@ -98,7 +110,8 @@ RSpec.describe NativeBtree do
         tree[100] = 15
         tree[46] = 8
 
-        expect(tree.filter! { |_v, k| k > 20 }.to_a).to match_array([[46, 8], [100, 15]])
+        expect(tree.filter! { |_v, k| k > 20 }.to_a)
+          .to match_array([[46, 8], [100, 15]])
       end
 
     end
@@ -114,5 +127,84 @@ RSpec.describe NativeBtree do
         expect(tree).to respond_to(:select!)
       end
     end
+
+    if NativeBtree::Glib::MAJOR_VERSION == 2 &&
+       NativeBtree::Glib::MINOR_VERSION >= 68
+
+      describe "select_before method" do
+        it 'respond_to' do
+          expect(tree).to respond_to(:select_before)
+        end
+
+        it 'return expected collection' do
+          tree[1] = 11
+          tree[2] = 32
+          tree[5] = 90
+          tree[46] = 8
+          tree[100] = 15
+
+          expect(tree.select_before(5).to_a)
+            .to match_array([[1, 11], [2, 32], [5, 90]])
+        end
+
+        it 'return correct tree if one target' do
+          tree[100] = 15
+          tree[46] = 8
+          tree[5] = 90
+
+          expect(tree.select_before(5).to_a)
+            .to match_array([[5, 90]])
+        end
+
+        it 'return empty tree if no targets' do
+          tree[100] = 15
+          tree[46] = 8
+
+          expect(tree.select_before(5).to_a)
+            .to match_array([])
+        end
+      end
+
+      describe "select_after" do
+        it "respond to" do
+          expect(tree).to respond_to(:select_after)
+        end
+
+        it 'return expected collection' do
+          tree[1] = 11
+          tree[5] = 90
+          tree[2] = 32
+          tree[100] = 15
+          tree[46] = 8
+
+          expect(tree.select_after(5).to_a)
+            .to match_array([[5, 90], [46, 8], [100, 15]])
+        end
+
+        it 'return correct tree if one target' do
+          tree[3] = 15
+          tree[4] = 8
+          tree[5] = 90
+
+          expect(tree.select_after(5).to_a)
+            .to match_array([[5, 90]])
+        end
+
+        it 'return empty tree if no targets' do
+          tree[1] = 11
+          tree[2] = 32
+
+          expect(tree.select_after(5).to_a)
+            .to match_array([])
+        end
+      end
+
+      describe "select_between" do
+        xit "respond to" do
+          expect(tree).to respond_to(:select_between)
+        end
+      end
+
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: native_btree
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Alexander Feodorov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-11 00:00:00.000000000 Z
+date: 2022-09-15 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings to GTree balanced binary tree from GLib library.
 email:
@@ -29,8 +29,12 @@ files:
 - ext/native_btree/constructor.c
 - ext/native_btree/conversion.c
 - ext/native_btree/extconf_cmake.rb
+- ext/native_btree/glib2_68/CMakeLists.txt
+- ext/native_btree/glib2_68/additional_iterators.c
+- ext/native_btree/glib_module.c
 - ext/native_btree/include/common.h
 - ext/native_btree/include/comparator.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
@@ -47,6 +51,7 @@ files:
 - spec/native_btree_class_spec.rb
 - spec/native_btree_conversion_spec.rb
 - spec/native_btree_instance_spec.rb
+- spec/native_btree_int_instance_spec.rb
 - spec/native_btree_iterators_spec.rb
 - spec/native_btree_module_spec.rb
 - spec/native_btree_search_spec.rb