birch 0.0.1

data/ext/birch/birch.c

@@ -0,0 +1,354 @@
+#include <ruby.h>
+
+/*
+ * Initialize the node with its value and id.
+ * Setup containers for the children, features
+ * and dependencies of this node.
+ */
+static VALUE birch_initialize(VALUE self, VALUE value, VALUE id)
+{
+	VALUE parent;
+  VALUE children;
+	VALUE children_hash;
+	VALUE features;
+	VALUE edges;
+	
+	parent = Qnil;
+  children = rb_ary_new();
+	children_hash = rb_hash_new();
+	features = rb_hash_new();
+	edges = rb_ary_new();
+	
+	rb_iv_set(self, "@value", value);
+	rb_iv_set(self, "@id", id);
+
+  rb_iv_set(self, "@parent", parent);
+	rb_iv_set(self, "@children", children);
+	rb_iv_set(self, "@children_hash", children_hash);
+	rb_iv_set(self, "@features", features);
+	rb_iv_set(self, "@edges", edges);
+	
+  return self;
+}
+
+/* Return the root of the tree. */
+static VALUE birch_root(VALUE self) {
+	
+	VALUE ancestor;
+	VALUE parent;
+	VALUE tmp;
+	
+	parent = rb_iv_get(ancestor, "@parent");
+	
+	if (parent == Qnil) {
+		return self;
+	} else {
+		ancestor = parent;
+		while (ancestor != Qnil) {
+			tmp = rb_iv_get(ancestor, "@parent");
+			if (tmp == Qnil) {
+				return ancestor;
+			} else {
+				ancestor = tmp;
+			}
+		}
+		return Qnil;
+	}
+}
+
+/* Add a child to this node. */
+static VALUE birch_add(VALUE self, VALUE child) {
+	
+	VALUE children;
+	VALUE children_hash;
+	
+	VALUE child_id;
+	
+  children = rb_iv_get(self, "@children");
+	child_id = rb_funcall(child, rb_intern("id"), 0);
+	children_hash = rb_iv_get(self, "@children_hash");
+	
+  rb_funcall(children, rb_intern("push"), 1, child);
+	
+	rb_funcall(
+		children_hash, 
+		rb_intern("store"), 
+		2, child_id, child
+	);
+	
+	rb_iv_set(child, "@parent", self);
+	
+	return child;
+	
+}
+
+/* Return the feature with the supplied name. */
+static VALUE birch_get(VALUE self, VALUE feature) {
+	if (feature == rb_intern("id")) {
+		return rb_iv_get(self, "@id");
+	} else if (feature == rb_intern("value")) {
+		return rb_iv_get(self, "@value");
+	} else {
+		return rb_hash_aref(rb_iv_get(self, "@features"), feature);
+	}
+}
+
+/* Set the feature to the supplied value. */
+static VALUE birch_set(VALUE self, VALUE feature, VALUE value) {
+  return rb_hash_aset(rb_iv_get(self, "@features"), feature, value);
+}
+
+/* Unset a feature. */
+static VALUE birch_unset(VALUE self, VALUE feature) {
+	return rb_hash_delete(
+		rb_iv_get(self, "@features"), 
+		feature
+	);
+}
+
+/* Return the total number of nodes in the subtree */
+static VALUE birch_size(VALUE self) {
+	
+
+	VALUE children;
+	int sum;
+	long len;
+	long i;
+	
+	children = rb_iv_get(self, "@children");
+	len = RARRAY_LEN(children);
+	sum = 0;
+	
+	for (i=0; i<len; i++) {
+		sum += rb_funcall(
+			RARRAY_PTR(children)[i], 
+			rb_intern("size"), 0
+		);
+	}
+	
+	return INT2NUM(sum);
+	
+}
+
+/* Iterate over each children of the node. */
+static VALUE birch_each(VALUE self) {
+
+	long i;
+	VALUE children;
+	children = rb_iv_get(self, "@children");
+	
+	RETURN_ENUMERATOR(children, 0, 0);
+	
+	for (i=0; i<RARRAY_LEN(children); i++) {
+		rb_yield(RARRAY_PTR(children)[i]);
+	}
+	 
+	return children;
+	
+}
+
+static VALUE birch_find(VALUE self, VALUE id) {
+	
+	VALUE children_hash;
+	VALUE children;
+	VALUE result;
+	long i;
+	
+	children_hash = rb_iv_get(self, "@children_hash");
+	result = rb_hash_aref(children_hash, id);
+	
+	if (result == Qnil) {
+		children = rb_iv_get(self, "@children");
+		for (i=0; i < RARRAY_LEN(children); i++) {
+			result = rb_funcall(
+				RARRAY_PTR(children)[i], 
+				rb_intern("find"), 1, id
+			);
+			if (result != Qnil) { return result; }
+		}
+		return Qnil;
+	} else { return result; }
+	
+}
+
+/* Boolean - is this node's subtree empty? */
+static VALUE birch_is_leaf(VALUE self) {
+	if (RARRAY_LEN(rb_iv_get(self, "@children")) == 0) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+/* Boolean - is this node parent-less? */
+static VALUE birch_is_root(VALUE self) {
+	if (rb_iv_get(self, "@parent") == Qnil) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+/* Boolean - does this node have children */
+static VALUE birch_has_children(VALUE self) {
+	if (RARRAY_LEN(rb_iv_get(self, "@children")) == 0) {
+		return Qfalse;
+	} else {
+		return Qtrue;
+	}
+}
+
+/* Boolean - does the node have a parent? */
+static VALUE birch_has_parent(VALUE self) {
+  if (rb_iv_get(self, "@parent") == Qnil) {
+		return Qfalse;
+	} else {
+		return Qtrue;
+	}
+}
+
+/* Boolean - does the node have edges? */
+static VALUE birch_has_edges(VALUE self) {
+	if (RARRAY_LEN(rb_iv_get(self, "@edges")) == 0) {
+		return Qfalse;
+	} else {
+		return Qtrue;
+	}
+}
+
+/* Boolean - does the node have feature? */
+static VALUE birch_has_feature(VALUE self, VALUE feature) {
+	VALUE features;
+	features = rb_iv_get(self, "@features");
+  if (rb_hash_aref(features, feature) == Qnil) {
+		return Qfalse;
+	} else {
+		return Qtrue;
+	}
+}
+
+static VALUE birch_link(VALUE self, VALUE edge) {
+	
+	VALUE edges;
+	edges = rb_iv_get(self, "@edges");
+	
+	rb_funcall(
+		edges, rb_intern("push"), 1, edge
+	);
+	
+}
+
+/* Remove from parent and set as root */
+static VALUE birch_set_as_root(VALUE self) {
+	
+	// Set the parent to be nil.
+	rb_iv_set(self, "@parent", Qnil);
+	
+	// Return self.
+	return self;
+	
+}
+
+/* Removes a node by ID and returns it */
+static VALUE birch_remove(VALUE self, VALUE id) {
+	
+	VALUE val;
+	
+	// Delete the node from the hash and retrieve it.
+	val = rb_hash_delete(
+		rb_iv_get(self, "@children_hash"), id
+	);
+	
+	// Raise an exception if the value can't be found.
+	if (val == Qundef) { 
+		rb_raise(rb_eArgError, 
+		"Given ID is not a children of this node.");
+		return Qnil;
+	}
+	
+	// Delete the node from the children array.
+	rb_funcall(
+		rb_iv_get(self, "@children"), 
+		rb_intern("delete"), 1, val
+	);
+	
+	// Set the node as a root (set its parent to nil).
+	rb_funcall(
+		val, rb_intern("set_as_root!"), 0
+	);
+		
+	return val;
+
+}
+
+/* Remove all children and set them as root. */
+static VALUE birch_remove_all(VALUE self) {
+
+	VALUE children;
+	long i;
+	long children_len;
+	
+	children = rb_iv_get(self, "@children");
+	
+	for (i = 0; i < children_len; i++) {
+		rb_funcall(
+			RARRAY_PTR(children)[i], 
+			rb_intern("set_as_root!"), 0
+		);
+	}
+	
+	rb_iv_set(self, "@children", rb_ary_new());
+	rb_iv_set(self, "@children_hash", rb_hash_new());
+	
+	return self;
+}
+
+/* This class is a node for an N-ary tree data structure
+ * with a unique identifier, text value, children, features
+ * (annotations) and dependencies.
+ *
+ * This class was partly based on the 'rubytree' gem.
+ * RubyTree is licensed under the BSD license and can
+ * be found at http://rubytree.rubyforge.org/rdoc/.
+ */
+void Init_birch(void) {
+
+	VALUE module = rb_define_module("Birch");
+  VALUE klass = rb_define_class_under(module, "Tree", rb_cObject);
+	
+	// Attribute accessors
+	rb_attr(klass, rb_intern("id"), 1, 1, 1);
+	rb_attr(klass, rb_intern("value"), 1, 1, 1);
+	
+	// Attribute readers
+	rb_attr(klass, rb_intern("parent"), 1, 0, 0);
+	rb_attr(klass, rb_intern("children"), 1, 0, 0);
+	rb_attr(klass, rb_intern("features"), 1, 0, 0);
+	rb_attr(klass, rb_intern("edges"), 1, 0, 0);
+	
+	// Methods
+	rb_define_method(klass, "initialize", birch_initialize, 2);
+	rb_define_method(klass, "root", birch_root, 0);
+	rb_define_method(klass, "<<", birch_add, 1);
+	rb_define_method(klass, "add", birch_add, 1);
+	rb_define_method(klass, "[]", birch_get, 1);
+	rb_define_method(klass, "get", birch_get, 1);
+	rb_define_method(klass, "[]=", birch_set, 2); 
+  rb_define_method(klass, "set", birch_set, 2); 
+	rb_define_method(klass, "unset", birch_unset, 1); 
+	rb_define_method(klass, "size", birch_size, 0);
+	rb_define_method(klass, "each", birch_each, 0);
+	rb_define_method(klass, "find", birch_find, 1);
+	rb_define_method(klass, "is_leaf?", birch_is_leaf, 0);
+	rb_define_method(klass, "is_root?", birch_is_root, 0);
+	rb_define_method(klass, "has_parent?", birch_has_parent, 0);
+	rb_define_method(klass, "has_children?", birch_has_children, 0);
+	rb_define_method(klass, "has_edges?", birch_has_edges, 0);
+	rb_define_method(klass, "has_feature?", birch_has_feature, 1);
+	rb_define_method(klass, "has?", birch_has_feature, 1);
+	rb_define_method(klass, "link", birch_link, 1);
+	rb_define_method(klass, "set_as_root!", birch_set_as_root, 0);
+	rb_define_method(klass, "remove", birch_remove, 1);
+	rb_define_method(klass, "remove_all!", birch_remove_all, 0); 
+	
+}

data/ext/birch/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('birch/birch')

data/lib/birch.rb

@@ -0,0 +1 @@
+require 'birch/birch'

data/lib/birch/version.rb

@@ -0,0 +1,3 @@
+class Birch
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: birch
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Louis Mullie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-04 00:00:00.000000000 Z
+dependencies: []
+description: ! ' '
+email:
+- louis.mullie@gmail.com
+executables: []
+extensions:
+- ext/birch/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/birch/version.rb
+- lib/birch.rb
+- ext/birch/birch.c
+- ext/birch/extconf.rb
+homepage: https://github.com/louismullie/birch
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Birch is a generic tree implementation for Ruby, in C.
+test_files: []