native_btree 0.1.0.alpha2 → 0.2.1

data/ext/native_btree/include/rbtree_type.h

@@ -0,0 +1,22 @@
+#ifndef _RBTREE_TYPE_
+#define _RBTREE_TYPE_
+
+#include <common.h>
+
+#define NATIVE_TYPE_NAME "native_btree"
+
+extern const rb_data_type_t rbtree_type;
+
+VALUE
+rbtree_alloc(VALUE self);
+
+/**
+ * Internal native instance
+ */
+typedef struct _RBTree
+{
+  GTree *gtree;
+  VALUE comparator;
+} RBTree;
+
+#endif //_RBTREE_TYPE_

data/ext/native_btree/instance.c

@@ -0,0 +1,126 @@
+#include <instance.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
+rbtree_set(VALUE self, VALUE key, VALUE value)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  g_tree_replace(rbtree->gtree, (gpointer) key, (gpointer) value);
+
+  return self;
+}
+
+
+VALUE
+rbtree_get(VALUE self, VALUE key)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gpointer found = g_tree_lookup(rbtree->gtree, (gpointer) key);
+
+  if (found == NULL) {
+    return Qnil;
+  }
+
+  VALUE result = (VALUE) found;
+
+  return result;
+}
+
+
+VALUE
+rbtree_delete(VALUE self, VALUE key)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  VALUE found_key, found_value;
+  gboolean found = g_tree_lookup_extended(
+    rbtree->gtree,
+    (gconstpointer) key,
+    (gpointer *) &found_key,
+    (gpointer *) &found_value
+  );
+
+  if (found) {
+    g_tree_remove(rbtree->gtree, (gconstpointer) key);
+
+    return found_value;
+  }
+  else {
+    if (rb_block_given_p()) {
+      VALUE block = rb_block_proc();
+
+      return rb_funcall(block, rb_intern("call"), 1, key);
+    }
+
+    return Qnil;
+  }
+}
+
+
+VALUE
+rbtree_height(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gint size = g_tree_height(rbtree->gtree);
+  VALUE result = INT2NUM(size);
+
+  return result;
+}
+
+
+VALUE
+rbtree_size(VALUE self)
+{
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  gint size = g_tree_nnodes(rbtree->gtree);
+  VALUE result = INT2NUM(size);
+
+  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;
+}

data/ext/native_btree/iterators.c

@@ -0,0 +1,26 @@
+#include <iterators.h>
+
+static gboolean
+foraech_callbac(gpointer a, gpointer b, gpointer data)
+{
+  VALUE key = (VALUE) a;
+  VALUE value = (VALUE) b;
+  VALUE block = (VALUE) data;
+
+  rb_funcall(block, rb_intern("call"), 2, value, key);
+
+  return FALSE;
+}
+
+VALUE
+rbtree_each(VALUE self)
+{
+  rb_need_block();
+  VALUE block = rb_block_proc();
+
+  EXTRACT_RBTREE_SELF(rbtree);
+
+  g_tree_foreach(rbtree->gtree, foraech_callbac, (gpointer) block);
+
+  return self;
+}

data/ext/native_btree/native_btree.c

@@ -1,27 +1,28 @@
-#include <ruby.h>
-
 #include <native_btree.h>
 
-VALUE btree_class;
-VALUE btree_module;
-VALUE btree_class_from;
-
-VALUE
-btree_from(VALUE klass);
-
-VALUE
-btree_from(VALUE klass)
-{
-  VALUE result = INT2NUM(10);
+VALUE rbtree_class;
+VALUE rbtree_module;
 
-  return result;
-}
 
 void
 Init_native_btree()
 {
-  btree_module = rb_define_module(NATIVE_BTREE);
-  btree_class = rb_define_class_under(btree_module, NATIVE_BTREE_CLASS, rb_cObject);
-  rb_define_singleton_method(btree_class, "from", btree_from, 0);
-}
+  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);
+}

data/ext/native_btree/rbtree_type.c

@@ -0,0 +1,102 @@
+#include <rbtree_type.h>
+
+const rb_data_type_t rbtree_type;
+
+
+static void
+rbtree_free(gpointer data)
+{
+  RBTree *rbtree = (RBTree *) data;
+
+  g_tree_destroy(rbtree->gtree);
+  g_free(data);
+}
+
+
+static gboolean
+rbtree_mark_callback(gpointer key, gpointer value, gpointer data)
+{
+  rb_gc_mark((VALUE) key);
+  rb_gc_mark((VALUE) value);
+
+  return FALSE;
+}
+
+
+static void
+rbtree_mark(gpointer data)
+{
+  RBTree *rbtree = (RBTree *)data;
+
+  rb_gc_mark(rbtree->comparator);
+
+  g_tree_foreach(rbtree->gtree, rbtree_mark_callback, NULL);
+}
+
+/*
+
+https://github.com/GNOME/glib/blob/main/glib/gtree.c#L80
+
+struct _GTree
+{
+  GTreeNode *root;
+  GCompareDataFunc key_compare;
+  GDestroyNotify key_destroy_func;
+  GDestroyNotify value_destroy_func;
+  gpointer key_compare_data;
+  guint nnodes;
+  gint ref_count;
+};
+
+struct _GTreeNode
+{
+  gpointer key;
+  gpointer value;
+  GTreeNode *left;
+  GTreeNode *right;
+  gint8 balance;
+  guint8 left_child;
+  guint8 right_child;
+};
+*/
+
+static size_t
+rbtree_size(gconstpointer data)
+{
+  RBTree *rbtree = (RBTree *) data;
+
+  gint gtree_size = g_tree_nnodes(rbtree->gtree);
+
+  // struct _GTreeNode
+  size_t node_size = sizeof(gpointer) * 4 +
+                     sizeof(gint8) +
+                     sizeof(guint8) * 2;
+
+  // struct _GTree
+  size_t gtree_root_size = sizeof(gpointer) * 5 +
+                           sizeof(gint8) +
+                           sizeof(guint8) * 2;
+
+  return sizeof(RBTree) + node_size * gtree_size + gtree_root_size;
+}
+
+
+const rb_data_type_t rbtree_type = {
+  .wrap_struct_name = NATIVE_TYPE_NAME,
+  .function = {
+    .dmark = rbtree_mark,
+    .dfree = rbtree_free,
+    .dsize = rbtree_size,
+  },
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+
+VALUE
+rbtree_alloc(VALUE self)
+{
+  RBTree *rbtree = g_new(RBTree, 1);
+
+  return TypedData_Wrap_Struct(self, &rbtree_type, rbtree);
+}

data/lib/native_btree/version.rb

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

data/native_btree.gemspec

@@ -27,20 +27,7 @@ Gem::Specification.new do |s|
   s.files += Dir['*.{md}']
   s.files += %w[Rakefile Gemfile CMakeLists.txt native_btree.gemspec LICENSE]
 
-  s.bindir = "bin"
   s.executables = s.files.grep(%r{\Abin/}) { |f| File.basename(f) }
   s.require_paths = ["lib"]
   s.required_ruby_version = '>= 2.6'
-
-  s.add_dependency 'rubocop', '~> 1.35.0'
-  s.add_dependency 'rubocop-rake', '~> 0.6.0'
-  s.add_dependency 'rubocop-rspec', '~> 2.12.1'
-  s.add_dependency 'rake', '~> 13.0.6'
-  s.add_dependency 'rspec', '~> 3.11.0'
-
-  s.add_development_dependency 'awesome_print', '~> 1.9'
-  s.add_development_dependency 'debase', '~> 0.2'
-  s.add_development_dependency 'pry', '~> 0.14'
-  s.add_development_dependency 'ruby-debug-ide', '~> 0.7'
-  s.add_development_dependency 'solargraph', '~> 0.46'
 end

data/spec/debug.rb

@@ -0,0 +1,24 @@
+# rubocop:disable all
+
+require_relative "../lib/native_btree/native_btree"
+
+tree = NativeBtree::Btree.new
+
+GC.start
+
+tree[3] = {a: 'value 3'}
+tree[1] = {a: 'value 1'}
+tree[2] = {a: 'value 2'}
+tree[16] = {a: 'value 16'}
+tree[0] = {a: 'value 0'}
+
+GC.start
+
+block = ->(key) { "#{key} is not found" }
+puts tree.delete(77, &block)
+
+tree = null
+
+GC.start
+
+puts "exit 0"

data/spec/native_btree_class_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe NativeBtree do
+  it "has a version number" do
+    expect(NativeBtree::VERSION).not_to be_nil
+  end
+
+  describe NativeBtree::Btree do
+
+    describe "initialize class method" do
+      it 'respond to new' do
+        expect(described_class).to respond_to('new').with(0).arguments
+      end
+
+      it "return new btree instance" do
+        expect(described_class.new { nil }).to be_kind_of(described_class)
+      end
+
+      it "raise error if block is not given" do
+        expect { described_class.new() }.to raise_error(LocalJumpError)
+      end
+    end
+  end
+end

data/spec/native_btree_instance_spec.rb

@@ -0,0 +1,283 @@
+# 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 "#[]= 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 "#filter method" do
+      xit "respond to" do
+        expect(described_cless.respond_to?(:filter)).to be true
+      end
+    end
+
+    describe "#filter! method" do
+      xit "respond to" do
+        expect(described_cless.respond_to?(:filter!)).to be true
+      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 "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
+    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
+
+    describe "#select method" do
+      xit "respond to" do
+        expect(described_cless.respond_to?(:select)).to be true
+      end
+    end
+
+    describe "#select! method" do
+      xit "respond to" do
+        expect(described_cless.respond_to?(:select!)).to be true
+      end
+    end
+  end
+end

data/spec/native_btree_module_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe NativeBtree do
+  it "has a version number" do
+    expect(described_class.const_defined?(:VERSION)).to be true
+  end
+
+  it "Has Btree contstant" do
+    expect(described_class.const_defined?(:Btree)).to be true
+  end
+
+  it "Btree is class" do
+    expect(described_class::Btree.class).to be Class
+  end
+end