native_btree 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a71b1e34d117e61eb4ef28533f3d4371447b942e81bbfaa23b85af4fc81210ad
-  data.tar.gz: 45b6b186bb06e9a58d5a26871f8ebb97dce6f3bffeeccb02169ea43dca972f86
+  metadata.gz: 1dbf5cc77f1056fc6f84cf49496c233b9a3ecd9c62a0d82149cce9804a80edd7
+  data.tar.gz: eb1f55db08e767f443b02751258fb749ae991eb98e5426a8d5c81714c66ebd49
 SHA512:
-  metadata.gz: 3bea00617a86a99ad538d31825538ff2547748b30e377e55dcfa98134a25777a0cf33466405395c99836e9bba337f2177ec2d033efc7a4cca17fbe615c087d82
-  data.tar.gz: 1d9ab5a418e9a9ad1e865ff31c1b126b738f2f546b35278fe483df1e357f8fccf427f9234fdc9ce031075d61956b28600af669aa7187d8b2d7f06a6146ff252d
+  metadata.gz: 7753f72aa3babc2151d74ae4bad29fb7c43e41cd7cf8b3bc9348e4b6e9be3c156d2ecc78fd2e689ca099e27df8bdee376550cbbc16b97ef15f15c431e8c5c093
+  data.tar.gz: d1992054500ad7207aea7186a0aa9bd3099cf013983c2596f5c2b5289ca5c8129f4ceeea4bf9ddf0777eb019b4dfc70be3b0feb571d741bb148af1f68de6e754

data/CHANGELOG.md

@@ -1,5 +1,41 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
 ## [Unreleased]
 
-## [0.1.0.alpha1] - 2022-08-20
+* delete_if()
+* each method refactoring for Enumerator return type
+
+## [0.3.0] - 2022-09-11
+
+### Added
+
+* to_proc()
+* empty?()
+* filter()
+* filter!()
+* select()
+* select!()
+
+## [0.2.1] - 2022-09-08
+
+### Changed
+
+* Legacy CMake versions support
+
+## [0.2.0] - 2022-09-07
+
+### Changed
+
+* Small refactoring
+
+### Added
 
-- Initial release
+* to_a()
+* to_h()
+* clear()
+* include?()

data/CMakeLists.txt

@@ -1,9 +1,10 @@
-cmake_minimum_required(VERSION 3.14.0 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.5)
 
 project(ruby-native-btree
 	LANGUAGES C
-	VERSION 0.1.0
-  	HOMEPAGE_URL https://github.com/unixs/ruby-native-btree)
+	VERSION 0.3.0)
+
+include(CheckSymbolExists)
 
 set(REQUIRED_RUBY_VERSION 2.6.0)
 
@@ -35,9 +36,17 @@ find_package(PkgConfig REQUIRED)
 
 # Find Ruby
 find_package(Ruby ${REQUIRED_RUBY_VERSION} REQUIRED)
-include_directories(${Ruby_INCLUDE_DIRS})
-link_libraries(${Ruby_LIBRARIES})
-message("Ruby_INCLUDE_DIRS: ${Ruby_INCLUDE_DIRS}")
+
+if(CMAKE_VERSION VERSION_GREATER "3.17.100")
+	include_directories(${Ruby_INCLUDE_DIRS})
+	link_libraries(${Ruby_LIBRARIES})
+	message(STATUS "Ruby_INCLUDE_DIRS: ${Ruby_INCLUDE_DIRS}")
+else()
+	message(WARNING "Old CMake. Legacy FindRuby macro is used.")
+	include_directories(${RUBY_INCLUDE_DIRS})
+	link_libraries(${RUBY_LIBRARIES})
+	message(STATUS "RUBY_INCLUDE_DIRS: ${RUBY_INCLUDE_DIRS}")
+endif()
 
 message(STATUS "Find Ruby deps.")
 

data/Gemfile

@@ -9,10 +9,13 @@ group :development do
   gem 'awesome_print', '~> 1.9'
   gem 'debase', '~> 0.2', platforms: [:mri_26, :mri_27]
   gem 'pry', '~> 0.14'
+  gem 'ruby-debug-ide', '~> 0.7'
+  gem 'solargraph', '~> 0.46'
+end
+
+group :test do
+  gem 'rspec', '~> 3.11.0'
   gem 'rubocop', '~> 1.35.0'
   gem 'rubocop-rake', '~> 0.6.0'
   gem 'rubocop-rspec', '~> 2.12.1'
-  gem 'rspec', '~> 3.11.0'
-  gem 'ruby-debug-ide', '~> 0.7'
-  gem 'solargraph', '~> 0.46'
 end

data/README.md

@@ -1,12 +1,33 @@
 # 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)
+[![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)
+
 
 [GTree - balanced binary tree from GLib library](https://docs.gtk.org/glib/struct.Tree.html)
 
 In most cases it will behave same as Hash, but keys will be ordered by passed comparator.
 
-## Basic usage:
+## Requirements
+
+* **CMake** build tool version **>= 3.14.0**
+* `pkg-config` tool
+* **GLib** library
+  * On Ubuntu run:
+  ```bash
+  sudo apt-get install pkg-config cmake libglib2.0-dev
+  ```
+  * On MacOS run:
+  ```
+  brew install pkg-config cmake glib
+  ```
+  * On FreeBSD use pkg or ports.
+  * On windows use Google. I don't really know how it can work at this moment... But i think it's possible
+
+**Check CMake tool version!**
+
+## Basic usage
 
 ```ruby
 require 'native_btree'
@@ -36,11 +57,24 @@ tree.height
 
 You must provide your own comparator for keys in `new` class method block.
 
-### Methods
+### API methods
+
+In general this class behave same as Hash
+
+Implemented methods:
 
 * `[]= (alias: set)`
 * `[] (alias: get)`
 * `delete`
 * `size`
 * `height`
-* `each`
+* `each` (NB! block is required)
+* `include?`
+* `clear`
+* `to_h`
+* `to_a`
+* `to_proc`
+* `filter` (alias: select)
+* `filter!` (alias: select!)
+
+You can mix in the `Enumerable` module if additional methods are needed.

data/Rakefile

@@ -28,7 +28,8 @@ namespace :cmake do
 
   desc "Configure ext CMake project"
   task :configure do
-    sh "cmake -S . -B #{BUILD_DIR}"
+    sh "mkdir #{BUILD_DIR} || true"
+    sh "cd #{BUILD_DIR} && cmake .."
   end
 
   desc "Build ext CMake project"

data/ext/native_btree/CMakeLists.txt

@@ -7,22 +7,39 @@ pkg_check_modules(GLIB2 REQUIRED glib-2.0)
 
 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)
+
+if(HAVE_GTREE_REMOVE_ALL)
+	add_compile_definitions(HAVE_GTREE_REMOVE_ALL)
+endif()
+
+
+add_library(${EXT_NAME}
+	SHARED
+	native_btree.c)
+
 add_library(rbtree_type OBJECT rbtree_type.c)
 add_library(constructor OBJECT constructor.c)
 add_library(instance OBJECT instance.c)
 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(${EXT_NAME}
-	SHARED
-	native_btree.c)
+add_library(native_btree_interface
+	STATIC
+	$<TARGET_OBJECTS:conversion>
+	$<TARGET_OBJECTS:iterators>
+	$<TARGET_OBJECTS:comparator>
+	$<TARGET_OBJECTS:instance>
+	$<TARGET_OBJECTS:constructor>
+	$<TARGET_OBJECTS:rbtree_type>
+	$<TARGET_OBJECTS:search>)
 
 target_link_libraries(${EXT_NAME}
 	PRIVATE
-	iterators
-	rbtree_type
-	constructor
-	instance
-	comparator
+	native_btree_interface
 	${GLIB2_LDFLAGS})
-	#set_target_properties(${EXT_NAME} PROPERTIES BUNDLE TRUE)
+

data/ext/native_btree/constructor.c

@@ -1,4 +1,3 @@
-#include <constructor.h>
 #include <comparator.h>
 #include <rbtree_type.h>
 

data/ext/native_btree/conversion.c

@@ -0,0 +1,78 @@
+#include <common.h>
+
+
+static gboolean
+rbtree_to_h_callback(gpointer key, gpointer value, gpointer data)
+{
+  VALUE hash = (VALUE) data;
+
+  rb_hash_aset(hash, (VALUE) key, (VALUE) value);
+
+  return FALSE;
+}
+
+
+static gboolean
+rbtree_to_a_callback(gpointer key, gpointer value, gpointer data)
+{
+  VALUE array = (VALUE) data;
+  VALUE array2 = rb_ary_new2(2);
+
+  rb_ary_push(array2, (VALUE) key);
+  rb_ary_push(array2, (VALUE) value);
+
+  rb_ary_push(array, array2);
+
+  return FALSE;
+}
+
+
+VALUE
+rbtree_to_h(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE hash = rb_hash_new();
+
+  g_tree_foreach(rbtree->gtree, rbtree_to_h_callback, (gpointer) hash);
+
+  return hash;
+}
+
+
+VALUE
+rbtree_to_a(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gint tree_size = g_tree_nnodes(rbtree->gtree);
+
+  VALUE array = rb_ary_new2(tree_size);
+
+  g_tree_foreach(rbtree->gtree, rbtree_to_a_callback, (gpointer) array);
+
+  return array;
+}
+
+
+static VALUE
+to_proc_proc(RB_BLOCK_CALL_FUNC_ARGLIST(key, callback_arg))
+{
+  rb_check_arity(argc, 1, 1);
+  EXTRACT_RBTREE(callback_arg, rbtree);
+
+  VALUE value = (VALUE) g_tree_lookup(rbtree->gtree, (gconstpointer) key);
+
+  if (!value) {
+    return Qnil;
+  }
+
+  return value;
+}
+
+
+VALUE
+rbtree_to_proc(VALUE self)
+{
+  return rb_proc_new(to_proc_proc, self);
+}

data/ext/native_btree/include/common.h

@@ -1,21 +1,19 @@
 #include <ruby.h>
 #include <glib.h>
+#include <rbtree_type.h>
+#include <native_btree.h>
+
 
 #ifndef _NATIVE_BTREE_COMMON_
 #define _NATIVE_BTREE_COMMON_
 
-#include <rbtree_type.h>
-
-#define NATIVE_BTREE_MODULE "NativeBtree"
-#define NATIVE_BTREE_CLASS "Btree"
-
 #define EXTRACT_RBTREE(from, to)                                               \
   RBTree *to;                                                                  \
-  TypedData_Get_Struct(from, RBTree, &rbtree_type, rbtree)
+  TypedData_Get_Struct(from, RBTree, &rbtree_type, to)
 
 #define EXTRACT_RBTREE_SELF(to) EXTRACT_RBTREE(self, to)
 
-extern VALUE rbtree_class;
-extern VALUE rbtree_module;
+extern VALUE native_btree_class;
+extern VALUE native_btree_module;
 
 #endif //_NATIVE_BTREE_COMMON_

data/ext/native_btree/include/iterators.h

@@ -1,5 +1,7 @@
 #include <common.h>
 
-
-VALUE
-rbtree_each(VALUE self);
+typedef struct {
+  VALUE block;
+  RBTree *tree;
+  gconstpointer something;
+} RBTreeSearchData;

data/ext/native_btree/include/native_btree.h

@@ -1,46 +1,50 @@
 #ifndef _NATIVE_BTREE_
 
-#include <common.h>
-#include <constructor.h>
-#include <instance.h>
-#include <iterators.h>
+#include <ruby.h>
 
-/*
 VALUE
-btree_new(VALUE klass);
+rbtree_initialize(VALUE self);
 
 VALUE
-btree_init(VALUE self);
+rbtree_set(VALUE self, VALUE key, VALUE value);
 
 VALUE
-btree_size(VALUE self);
+rbtree_get(VALUE self, VALUE key);
 
 VALUE
-btree_height(VALUE self);
+rbtree_delete(VALUE self, VALUE key);
 
 VALUE
-btree_set(VALUE self, VALUE key, VALUE value);
+rbtree_size(VALUE self);
 
 VALUE
-btree_get(VALUE self, VALUE key);
+rbtree_height(VALUE self);
 
 VALUE
-btree_delete(VALUE self, VALUE key);
+rbtree_clear(VALUE self);
 
 VALUE
-btree_clear(VALUE self);
+rbtree_is_include(VALUE self, VALUE key);
 
 VALUE
-btree_has(VALUE self, VALUE key);
+rbtree_each(VALUE self);
 
 VALUE
-btree_each(VALUE self);
+rbtree_to_h(VALUE self);
 
 VALUE
-btree_cmp(VALUE self, VALUE tree2);
+rbtree_to_a(VALUE self);
 
 VALUE
-btree_equal(VALUE self, VALUE tree2);
-*/
+rbtree_to_proc(VALUE self);
+
+VALUE
+rbtree_filter(VALUE self);
+
+VALUE
+rbtree_filter_bang(VALUE self);
+
+VALUE
+rbtree_is_empty(VALUE self);
 
 #endif // _NATIVE_BTREE_

data/ext/native_btree/include/rbtree_type.h

@@ -3,7 +3,7 @@
 
 #include <common.h>
 
-#define NATIVE_TYPE_NAME "native_btree"
+#define RBTREE_NATIVE_TYPE_NAME "native_btree"
 
 extern const rb_data_type_t rbtree_type;
 

data/ext/native_btree/instance.c

@@ -1,4 +1,18 @@
-#include <instance.h>
+#include <common.h>
+
+
+#ifndef HAVE_GTREE_REMOVE_ALL
+
+static gboolean
+rbtree_remove_node(gpointer key, gpointer val, gpointer data) {
+  RBTree *rbtree = (RBTree *) data;
+
+  g_tree_remove(rbtree->gtree, key);
+
+  return FALSE;
+}
+
+#endif
 
 
 VALUE
@@ -81,3 +95,44 @@ rbtree_size(VALUE self)
 
   return result;
 }
+
+
+VALUE
+rbtree_clear(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  #ifdef HAVE_GTREE_REMOVE_ALL
+    g_tree_remove_all(rbtree->gtree);
+  #else
+    g_tree_foreach(rbtree->gtree, rbtree_remove_node, (gpointer) rbtree);
+  #endif
+
+  return self;
+}
+
+
+VALUE
+rbtree_is_include(VALUE self, VALUE key)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gpointer exists = g_tree_lookup(rbtree->gtree, (gconstpointer) key);
+
+  if (exists == NULL) {
+    return Qfalse;
+  }
+
+  return Qtrue;
+}
+
+
+VALUE
+rbtree_is_empty(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gint size = g_tree_nnodes(rbtree->gtree);
+
+  return size > 0 ? Qfalse : Qtrue;
+}

data/ext/native_btree/iterators.c

@@ -1,4 +1,4 @@
-#include <iterators.h>
+#include <common.h>
 
 static gboolean
 foraech_callbac(gpointer a, gpointer b, gpointer data)

data/ext/native_btree/native_btree.c

@@ -1,29 +1,45 @@
 #include <native_btree.h>
+#include <rbtree_type.h>
 
-VALUE rbtree_class;
-VALUE rbtree_module;
+#define NATIVE_BTREE_MODULE "NativeBtree"
+#define NATIVE_BTREE_CLASS "Btree"
+
+
+VALUE native_btree_class;
+VALUE native_btree_module;
 
 
 void
 Init_native_btree()
 {
-  rbtree_module = rb_define_module(NATIVE_BTREE_MODULE);
-  rbtree_class = rb_define_class_under(rbtree_module, NATIVE_BTREE_CLASS, rb_cObject);
-
-  rb_define_alloc_func(rbtree_class, rbtree_alloc);
-  rb_define_method(rbtree_class, "initialize", rbtree_initialize, 0);
-
-  rb_define_method(rbtree_class, "[]=", rbtree_set, 2);
-  rb_define_alias(rbtree_class, "set", "[]=");
-
-  rb_define_method(rbtree_class, "[]", rbtree_get, 1);
-  rb_define_alias(rbtree_class, "get", "[]");
-
-  rb_define_method(rbtree_class, "delete", rbtree_delete, 1);
-
-  rb_define_method(rbtree_class, "each", rbtree_each, 0);
-
-  rb_define_method(rbtree_class, "size", rbtree_size, 0);
-  rb_define_method(rbtree_class, "height", rbtree_height, 0);
+  native_btree_module = rb_define_module(NATIVE_BTREE_MODULE);
+  native_btree_class = rb_define_class_under(
+    native_btree_module,
+    NATIVE_BTREE_CLASS,
+    rb_cObject
+  );
+
+  // 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, "[]=", rbtree_set, 2);
+  rb_define_alias(native_btree_class, "set", "[]=");
+  rb_define_method(native_btree_class, "[]", rbtree_get, 1);
+  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, "size", rbtree_size, 0);
+  rb_define_method(native_btree_class, "height", rbtree_height, 0);
+  rb_define_method(native_btree_class, "clear", rbtree_clear, 0);
+  rb_define_method(native_btree_class, "include?", rbtree_is_include, 1);
+  rb_define_method(native_btree_class, "to_h", rbtree_to_h, 0);
+  rb_define_method(native_btree_class, "to_a", rbtree_to_a, 0);
+  rb_define_method(native_btree_class, "to_proc", rbtree_to_proc, 0);
+  rb_define_method(native_btree_class, "filter", rbtree_filter, 0);
+  rb_define_alias(native_btree_class, "select", "filter");
+  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);
 }
-

data/ext/native_btree/rbtree_type.c

@@ -4,7 +4,7 @@ const rb_data_type_t rbtree_type;
 
 
 static void
-rbtree_free(gpointer data)
+rbtree_type_free(gpointer data)
 {
   RBTree *rbtree = (RBTree *) data;
 
@@ -24,7 +24,7 @@ rbtree_mark_callback(gpointer key, gpointer value, gpointer data)
 
 
 static void
-rbtree_mark(gpointer data)
+rbtree_type_mark(gpointer data)
 {
   RBTree *rbtree = (RBTree *)data;
 
@@ -61,7 +61,7 @@ struct _GTreeNode
 */
 
 static size_t
-rbtree_size(gconstpointer data)
+rbtree_type_size(gconstpointer data)
 {
   RBTree *rbtree = (RBTree *) data;
 
@@ -82,11 +82,11 @@ rbtree_size(gconstpointer data)
 
 
 const rb_data_type_t rbtree_type = {
-  .wrap_struct_name = NATIVE_TYPE_NAME,
+  .wrap_struct_name = RBTREE_NATIVE_TYPE_NAME,
   .function = {
-    .dmark = rbtree_mark,
-    .dfree = rbtree_free,
-    .dsize = rbtree_size,
+    .dmark = rbtree_type_mark,
+    .dfree = rbtree_type_free,
+    .dsize = rbtree_type_size,
   },
   .data = NULL,
   .flags = RUBY_TYPED_FREE_IMMEDIATELY,

data/ext/native_btree/search.c

@@ -0,0 +1,101 @@
+#include <iterators.h>
+
+VALUE native_btree_class;
+
+static gboolean
+filter_callback(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchData *context = (RBTreeSearchData *) data;
+
+  VALUE compare_result = rb_funcall(
+    context->block,
+    rb_intern("call"),
+    2,
+    (VALUE) b,
+    (VALUE) a
+  );
+
+  if (RTEST(compare_result)) {
+    g_tree_insert(context->tree->gtree, a, b);
+  }
+
+  return FALSE;
+}
+
+static gboolean
+filter_bang_callback(gpointer a, gpointer b, gpointer data)
+{
+  RBTreeSearchData *context = (RBTreeSearchData *) data;
+  GPtrArray *to_remove = (GPtrArray *) context->something;
+
+  VALUE compare_result = rb_funcall(
+    context->block,
+    rb_intern("call"),
+    2,
+    (VALUE) b,
+    (VALUE) a
+  );
+
+  if (!RTEST(compare_result)) {
+    // Add to remove
+    g_ptr_array_add(to_remove, a);
+  }
+
+  return FALSE;
+}
+
+VALUE
+rbtree_filter(VALUE self)
+{
+  rb_need_block();
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE block = rb_block_proc();
+
+  VALUE new_tree = rb_funcall_with_block(
+    native_btree_class,
+    rb_intern("new"),
+    0,
+    NULL,
+    rbtree->comparator
+  );
+
+  EXTRACT_RBTREE(new_tree, new_rbtree);
+
+  RBTreeSearchData data = {
+    block,
+    new_rbtree,
+    NULL
+  };
+
+  g_tree_foreach(rbtree->gtree, filter_callback, &data);
+
+  return new_tree;
+}
+
+VALUE
+rbtree_filter_bang(VALUE self)
+{
+  rb_need_block();
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE block = rb_block_proc();
+
+  GPtrArray *to_remove = g_ptr_array_new();
+
+  RBTreeSearchData data = {
+    block,
+    NULL,
+    (gconstpointer) to_remove
+  };
+
+  g_tree_foreach(rbtree->gtree, filter_bang_callback, &data);
+
+  for (size_t i = 0; i < to_remove->len; i++) {
+    g_tree_remove(rbtree->gtree, g_ptr_array_index(to_remove, i));
+  }
+
+  g_ptr_array_free(to_remove, TRUE);
+
+  return self;
+}

data/lib/native_btree/version.rb

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

data/spec/debug.rb

@@ -2,7 +2,7 @@
 
 require_relative "../lib/native_btree/native_btree"
 
-tree = NativeBtree::Btree.new
+tree = NativeBtree::Btree.new { |a, b|  a - b }
 
 GC.start
 
@@ -17,7 +17,16 @@ GC.start
 block = ->(key) { "#{key} is not found" }
 puts tree.delete(77, &block)
 
-tree = null
+tree2 = tree.filter!() { true }
+
+puts tree.to_h
+
+pr = tree.to_proc
+
+puts pr
+puts pr.call(10)
+puts pr.call(16)
+
 
 GC.start
 

data/spec/native_btree_conversion_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe NativeBtree do
+
+  describe NativeBtree::Btree do
+    let(:tree) do
+      described_class.new do |a, b|
+        a - b
+      end
+    end
+
+    describe "to_ methods" do
+      describe "#to_a" do
+        it "respond to" do
+          expect(tree).to respond_to(:to_a)
+        end
+
+        it 'return Array' do
+          expect(tree.to_a).to be_kind_of(Array)
+        end
+
+        it 'has similar items' do
+          tree[2] = 22
+          tree[1] = 11
+          expect(tree.to_a()[0][1]).to be 11
+        end
+      end
+
+      describe "#to_h" do
+        it "respond to" do
+          expect(tree).to respond_to(:to_h)
+        end
+
+        it "return Hash" do
+          expect(tree.to_h).to be_kind_of(Hash)
+        end
+
+        it 'has similar keys' do
+          tree[2] = 22
+          tree[1] = 11
+          expect(tree.to_h()[1]).to be 11
+        end
+      end
+
+      describe '#to_proc' do
+        it 'respond to' do
+          expect(tree).to respond_to(:to_proc)
+        end
+
+        it 'return Proc' do
+          expect(tree.to_proc).to be_kind_of(Proc)
+        end
+
+        it 'return value for key' do
+          tree[2] = 22
+          tree[1] = 11
+          pr = tree.to_proc
+          expect(pr.call(1)).to be 11
+        end
+
+        it 'return null for non existent key' do
+          tree[2] = 22
+          tree[1] = 11
+          pr = tree.to_proc
+          expect(pr.call(12)).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/native_btree_instance_spec.rb

@@ -137,102 +137,53 @@ RSpec.describe NativeBtree do
     end
 
     describe "#clear method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:clear)).to be true
+      it "respond to" do
+        expect(tree).to respond_to(:clear)
       end
-    end
 
-    describe "#filter method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:filter)).to be true
+      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
-    end
 
-    describe "#filter! method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:filter!)).to be true
+      it 'return self' do
+        tree[1] = 11
+        expect(tree.clear()).to be tree
       end
     end
 
     describe "#include? method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:include?)).to be true
-      end
-    end
-
-    describe "to_ methods" do
-      describe "#to_a" do
-        xit "respond to" do
-          expect(described_cless.respond_to?(:to_a)).to be true
-        end
-      end
-
-      describe "#to_h" do
-        xit "respond to" do
-          expect(described_cless.respond_to?(:to_h)).to be true
-        end
-      end
-    end
-
-    describe "#each method" do
       it "respond to" do
-        expect(tree).to respond_to(:each)
+        expect(tree).to respond_to(:include?)
       end
 
-      it 'yield in to block value first' do
-        tree[2] = 22
-
-        value = nil
-        tree.each { |v| value = v }
-
-        expect(value).to be 22
-      end
-
-      it 'yield in to block key second' do
-        tree[2] = 22
-
-        key = nil
-        tree.each { |_v, k| key = k }
-
-        expect(key).to be 2
-      end
-
-      it 'yield ordered keys' do
-        tree[16] = 16
-        tree[0] = 0
-        tree[5] = 5
-        tree[-4] = -4
-        tree[7] = 7
-
-        check = [-4, 0, 5, 7, 16]
-        result = []
-        tree.each { |value| result << value }
-
-        expect(result).to eq(check)
+      it 'return true is key exists' do
+        tree[3] = 33
+        expect(tree.include?(3)).to be true
       end
-    end
 
-    describe "#each_key method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:each_key)).to be true
+      it 'return false if key not exists' do
+        tree[3] = 33
+        expect(tree.include?(4)).to be false
       end
     end
 
-    describe "#each_value method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:each_value)).to be true
+    describe "#empty? method" do
+      it 'respond to' do
+        expect(tree).to respond_to(:empty?)
       end
-    end
 
-    describe "#select method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:select)).to be true
+      it 'return false if nodes exists' do
+        tree[3] = 33
+        expect(tree.empty?).to be false
       end
-    end
 
-    describe "#select! method" do
-      xit "respond to" do
-        expect(described_cless.respond_to?(:select!)).to be true
+      it 'return true if nodes not exists' do
+        expect(tree.empty?).to be true
       end
     end
   end

data/spec/native_btree_iterators_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe NativeBtree do
+
+  describe NativeBtree::Btree do
+    let(:tree) do
+      described_class.new do |a, b|
+        a - b
+      end
+    end
+
+    describe "#each method" do
+      it "respond to" do
+        expect(tree).to respond_to(:each)
+      end
+
+      it 'yield in to block value first' do
+        tree[2] = 22
+
+        value = nil
+        tree.each { |v| value = v }
+
+        expect(value).to be 22
+      end
+
+      it 'yield in to block key second' do
+        tree[2] = 22
+
+        key = nil
+        tree.each { |_v, k| key = k }
+
+        expect(key).to be 2
+      end
+
+      it 'yield ordered keys' do
+        tree[16] = 16
+        tree[0] = 0
+        tree[5] = 5
+        tree[-4] = -4
+        tree[7] = 7
+
+        check = [-4, 0, 5, 7, 16]
+        result = []
+        tree.each { |value| result << value }
+
+        expect(result).to eq(check)
+      end
+    end
+
+    describe "#each_key method" do
+      xit "respond to" do
+        expect(described_cless.respond_to?(:each_key)).to be true
+      end
+    end
+
+    describe "#each_value method" do
+      xit "respond to" do
+        expect(described_cless.respond_to?(:each_value)).to be true
+      end
+    end
+  end
+end

data/spec/native_btree_search_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+RSpec.describe NativeBtree do
+
+  describe NativeBtree::Btree do
+    let(:tree) do
+      described_class.new do |a, b|
+        a - b
+      end
+    end
+
+    describe "#filter method" do
+      it "respond to" do
+        expect(tree).to respond_to(:filter)
+      end
+
+      it 'raise error if block not given' do
+        expect { tree.filter() }.to raise_error(LocalJumpError)
+      end
+
+      it 'return Btree instance' do
+        expect(tree.filter() { nil }).to be_kind_of(described_class)
+      end
+
+      it 'filter tree by values' do
+        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
+
+      it 'filter tree by keys' do
+        tree[1] = 11
+        tree[5] = 90
+        tree[2] = 32
+        tree[100] = 15
+        tree[46] = 8
+
+        expect(tree.filter { |_v, k| k > 20 }.to_a).to match_array([[46, 8], [100, 15]])
+      end
+
+      it 'return new object' do
+        tree[1] = 11
+        tree[5] = 90
+        tree[2] = 32
+        tree[100] = 15
+        tree[46] = 8
+
+        result = tree.filter { |_v, k| k > 20 }
+
+        expect(tree.equal?(result)).to be false
+      end
+
+    end
+
+    describe "#filter! method" do
+      it "respond to" do
+        expect(tree).to respond_to(:filter!)
+      end
+
+      it 'raise error if block not given' do
+        expect { tree.filter!() }.to raise_error(LocalJumpError)
+      end
+
+      it 'return Btree instance' do
+        expect(tree.filter!() { nil }).to be_kind_of(described_class)
+      end
+
+      it 'return origin tree' do
+        tree[1] = 11
+        tree[5] = 90
+        tree[2] = 32
+        tree[100] = 15
+        tree[46] = 8
+
+        result = tree.filter! { |_v, k| k > 20 }
+
+        expect(tree.equal?(result)).to be true
+      end
+
+      it 'filter tree by values' do
+        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
+
+      it 'filter tree by keys' do
+        tree[1] = 11
+        tree[5] = 90
+        tree[2] = 32
+        tree[100] = 15
+        tree[46] = 8
+
+        expect(tree.filter! { |_v, k| k > 20 }.to_a).to match_array([[46, 8], [100, 15]])
+      end
+
+    end
+
+    describe "#select method" do
+      it "respond to" do
+        expect(tree).to respond_to(:select)
+      end
+    end
+
+    describe "#select! method" do
+      it "respond to" do
+        expect(tree).to respond_to(:select!)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: native_btree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexander Feodorov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-05 00:00:00.000000000 Z
+date: 2022-09-11 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings to GTree balanced binary tree from GLib library.
 email:
@@ -27,12 +27,10 @@ files:
 - ext/native_btree/CMakeLists.txt
 - ext/native_btree/comparator.c
 - ext/native_btree/constructor.c
+- ext/native_btree/conversion.c
 - ext/native_btree/extconf_cmake.rb
-- ext/native_btree/include/btree.h
 - ext/native_btree/include/common.h
 - ext/native_btree/include/comparator.h
-- ext/native_btree/include/constructor.h
-- ext/native_btree/include/instance.h
 - ext/native_btree/include/iterators.h
 - ext/native_btree/include/native_btree.h
 - ext/native_btree/include/rbtree_type.h
@@ -40,15 +38,18 @@ files:
 - ext/native_btree/iterators.c
 - ext/native_btree/native_btree.c
 - ext/native_btree/rbtree_type.c
+- ext/native_btree/search.c
 - lib/native_btree.rb
 - lib/native_btree/native_btree.bundle
-- lib/native_btree/native_btree.so
 - lib/native_btree/version.rb
 - native_btree.gemspec
 - spec/debug.rb
 - spec/native_btree_class_spec.rb
+- spec/native_btree_conversion_spec.rb
 - spec/native_btree_instance_spec.rb
+- spec/native_btree_iterators_spec.rb
 - spec/native_btree_module_spec.rb
+- spec/native_btree_search_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/unixs/ruby-native-btree
 licenses:

data/ext/native_btree/include/btree.h

@@ -1,63 +0,0 @@
-#include <string>
-#include <ruby.h>
-#include <glib.h>
-
-using namespace std;
-
-class BTree {
-  public:
-    BTree(VALUE comparator);
-    ~BTree();
-
-    // get
-    VALUE const &operator[](VALUE key) const;
-    // set
-    void operator[](VALUE key);
-
-    gint
-    height();
-
-    gint
-    size();
-
-    bool
-    del(VALUE key);
-
-    void
-    clear();
-
-    bool
-    has(VALUE key);
-
-    void
-    mark();
-
-    void
-    set(VALUE key, VALUE value);
-
-    VALUE
-    get(VALUE key);
-
-    void
-    each(VALUE block);
-
-    void
-    each(GTraverseFunc func, gpointer data);
-
-  private:
-    GTree *tree;
-    VALUE comparator;
-
-    void
-    markMyRValues();
-
-    static gint
-    nativeComparator(gconstpointer keyA, gconstpointer keyB, gpointer tree);
-
-    static gint
-    markRValue(gpointer key, gpointer value, gpointer not_used);
-
-    static gboolean
-    traverseFunc(gpointer k, gpointer v, gpointer data);
-};
-

data/ext/native_btree/include/constructor.h

@@ -1,11 +0,0 @@
-#include <common.h>
-
-#ifndef _NATIVE_BTREE_CONSTRUCTOR_
-#define _NATIVE_BTREE_CONSTRUCTOR_
-
-
-
-VALUE rbtree_alloc(VALUE self);
-VALUE rbtree_initialize(VALUE self);
-
-#endif //_NATIVE_BTREE_COMMON_H_

data/ext/native_btree/include/instance.h

@@ -1,16 +0,0 @@
-#include <common.h>
-
-VALUE
-rbtree_set(VALUE self, VALUE key, VALUE value);
-
-VALUE
-rbtree_get(VALUE self, VALUE key);
-
-VALUE
-rbtree_delete(VALUE self, VALUE key);
-
-VALUE
-rbtree_size(VALUE self);
-
-VALUE
-rbtree_height(VALUE self);