native_btree 0.1.0.alpha1 → 0.2.0

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,30 +1,28 @@
 #include <native_btree.h>
 
-VALUE btree_class;
-VALUE btree_module;
+VALUE rbtree_class;
+VALUE rbtree_module;
+
 
 void
 Init_native_btree()
 {
-  btree_module = rb_define_module("NativeBTree");
-  btree_class = rb_define_class_under(btree_module, "BTree", rb_cObject);
+  rbtree_module = rb_define_module(NATIVE_BTREE_MODULE);
+  rbtree_class = rb_define_class_under(rbtree_module, NATIVE_BTREE_CLASS, rb_cObject);
 
-  rb_define_singleton_method(btree_class, "new", btree_new, 0);
-  // rb_define_method(btree_class, "initialize", btree_init, 0);
-  rb_define_method(btree_class, "size", btree_size, 0);
-  rb_define_method(btree_class, "height", btree_height, 0);
-  rb_define_method(btree_class, "set", btree_set, 2);
-  rb_define_alias(btree_class, "[]=", "set");
-  rb_define_method(btree_class, "get", btree_get, 1);
-  rb_define_alias(btree_class, "[]", "get");
-  rb_define_method(btree_class, "delete", btree_delete, 1);
-  rb_define_method(btree_class, "clear", btree_clear, 0);
-  rb_define_method(btree_class, "has", btree_has, 1);
-  rb_define_method(btree_class, "each", btree_each, 0);
-  rb_define_method(btree_class, "<=>", btree_cmp, 1);
-  rb_define_method(btree_class, "eql?", btree_equal, 1);
-  rb_define_alias(btree_class, "==", "eql?");
-  // TODO: to_ary
-  // TODO: to_hash
-}
+  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.alpha1".freeze
+module NativeBtree
+  VERSION = "0.2.0".freeze
 end

data/lib/native_btree.rb

@@ -1,4 +1,5 @@
-module NativeBTree
+# Bindings to GLib-2.0 data structure BTree
+module NativeBtree
 end
 
 require "native_btree/version"

data/native_btree.gemspec

@@ -0,0 +1,33 @@
+require_relative "lib/native_btree/version"
+
+Gem::Specification.new do |s|
+  s.name = 'native_btree'
+  s.version = NativeBtree::VERSION
+
+  s.metadata = {
+    "bug_tracker_uri" => "https://github.com/unixs/ruby-native-btree/issues",
+    "changelog_uri" => "https://github.com/unixs/ruby-native-btree/blob/master/CHANGELOG.md",
+    "documentation_uri" => "https://github.com/unixs/ruby-native-btree/wiki",
+    "homepage_uri" => "https://github.com/unixs/ruby-native-btree",
+    "source_code_uri" => "https://github.com/unixs/ruby-native-btree",
+    "wiki_uri" => "https://github.com/unixs/ruby-native-btree/wiki",
+    "rubygems_mfa_required" => "true"
+  }
+
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Balanced binary tree from GLib.'
+  s.description = 'Ruby bindings to GTree balanced binary tree from GLib library.'
+  s.authors = ['Alexander Feodorov']
+  s.email = ['webmaster@unixcomp.org']
+  s.licenses = ['LGPL-3.0-or-later']
+  s.homepage = 'https://github.com/unixs/ruby-native-btree'
+  s.extensions = ["ext/#{s.name}/extconf_cmake.rb"]
+
+  s.files = Dir['{bin,ext,lib,spec}/**/*']
+  s.files += Dir['*.{md}']
+  s.files += %w[Rakefile Gemfile CMakeLists.txt native_btree.gemspec LICENSE]
+
+  s.executables = s.files.grep(%r{\Abin/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 2.6'
+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