native_btree 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 398bae312c489bfe71fdee2f82499005e655097606a5537c38cfb122980b9f48
-  data.tar.gz: 492df9b7fc0585e0615da770a6c3fd3e2d02323d33c1d3cfecae46b882b881a3
+  metadata.gz: 1dbf5cc77f1056fc6f84cf49496c233b9a3ecd9c62a0d82149cce9804a80edd7
+  data.tar.gz: eb1f55db08e767f443b02751258fb749ae991eb98e5426a8d5c81714c66ebd49
 SHA512:
-  metadata.gz: 634ac5f2eab6a8f9ebf9ed577d5cd2fcdca75fdb8e61f285b3e83e244204976bdef93981320ea101a621b2845cb9346099d61a94193eb5872d0f1480ad363f09
-  data.tar.gz: cf5f853401bdcab2d12088fe11c23cbde946e5a3542620d905e1acb59ede62522cbd293f65c7b10ca54f4a00737c9fe5485519c72358f185840fa8efbe81719b
+  metadata.gz: 7753f72aa3babc2151d74ae4bad29fb7c43e41cd7cf8b3bc9348e4b6e9be3c156d2ecc78fd2e689ca099e27df8bdee376550cbbc16b97ef15f15c431e8c5c093
+  data.tar.gz: d1992054500ad7207aea7186a0aa9bd3099cf013983c2596f5c2b5289ca5c8129f4ceeea4bf9ddf0777eb019b4dfc70be3b0feb571d741bb148af1f68de6e754

data/CHANGELOG.md

@@ -7,12 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+* delete_if()
+* each method refactoring for Enumerator return type
+
+## [0.3.0] - 2022-09-11
+
+### Added
+
+* to_proc()
+* empty?()
 * filter()
 * filter!()
-* each_key()
-* each_value()
 * select()
-* select!
+* select!()
 
 ## [0.2.1] - 2022-09-08
 

data/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(ruby-native-btree
 	LANGUAGES C
-	VERSION 0.2.1)
+	VERSION 0.3.0)
 
 include(CheckSymbolExists)
 

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

@@ -57,15 +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/ext/native_btree/CMakeLists.txt

@@ -26,6 +26,7 @@ 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(native_btree_interface
 	STATIC
@@ -34,7 +35,8 @@ add_library(native_btree_interface
 	$<TARGET_OBJECTS:comparator>
 	$<TARGET_OBJECTS:instance>
 	$<TARGET_OBJECTS:constructor>
-	$<TARGET_OBJECTS:rbtree_type>)
+	$<TARGET_OBJECTS:rbtree_type>
+	$<TARGET_OBJECTS:search>)
 
 target_link_libraries(${EXT_NAME}
 	PRIVATE

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

@@ -1,4 +1,5 @@
-#include <conversion.h>
+#include <common.h>
+
 
 static gboolean
 rbtree_to_h_callback(gpointer key, gpointer value, gpointer data)
@@ -52,3 +53,26 @@ rbtree_to_a(VALUE self)
 
   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,9 +1,50 @@
 #ifndef _NATIVE_BTREE_
 
-#include <common.h>
-#include <constructor.h>
-#include <instance.h>
-#include <iterators.h>
-#include <conversion.h>
+#include <ruby.h>
+
+VALUE
+rbtree_initialize(VALUE self);
+
+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);
+
+VALUE
+rbtree_clear(VALUE self);
+
+VALUE
+rbtree_is_include(VALUE self, VALUE key);
+
+VALUE
+rbtree_each(VALUE self);
+
+VALUE
+rbtree_to_h(VALUE self);
+
+VALUE
+rbtree_to_a(VALUE self);
+
+VALUE
+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,5 @@
-#include <instance.h>
+#include <common.h>
+
 
 #ifndef HAVE_GTREE_REMOVE_ALL
 
@@ -124,3 +125,14 @@ rbtree_is_include(VALUE self, VALUE key)
 
   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,28 +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);
-  rb_define_method(rbtree_class, "clear", rbtree_clear, 0);
-  rb_define_method(rbtree_class, "include?", rbtree_is_include, 1);
-  rb_define_method(rbtree_class, "to_h", rbtree_to_h, 0);
-  rb_define_method(rbtree_class, "to_a", rbtree_to_a, 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.2.1".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