albizia 0.0.1

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+group :development, :test do
+  gem 'rake'
+  gem 'shoulda'
+  gem 'rspec'
+  gem 'rspec-core'
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'rb-fsevent', require: false
+end

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', version: 2, cli: '--drb --color --format doc' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,5 @@
+[![Build Status](https://secure.travis-ci.org/pjambet/albizia.png)](http://travis-ci.org/pjambet/albizia)
+albizia
+=======
+
+basic tree implementation

data/lib/albizia.rb

@@ -0,0 +1,2 @@
+require "albizia/node"
+require "albizia/rb_node"

data/lib/albizia/node.rb

@@ -0,0 +1,209 @@
+
+module Albizia
+  class Node
+
+    attr_accessor :left_child, :right_child, :value, :parent
+
+    def initialize(v=nil)
+      @value = v
+      @parent = nil
+    end
+
+    def empty?
+      leaf? && @value.nil?
+    end
+
+    # A leaf node has no children
+    def leaf?
+      @left_child.nil? && @right_child.nil?
+    end
+
+    # A root has no parent
+    def root?
+      @parent.nil?
+    end
+
+    # Return the root element of the tree
+    def root
+      root? ? self : @parent.root
+    end
+
+    # The depth of a node n is the length of the path from the root to the node.
+    # The set of all nodes at a given depth is sometimes called a level of the
+    # tree. The root node is at depth zero.
+    def depth
+      root? ? 0 : 1 + parent.depth
+    end
+
+    # The height of a tree is the length of the path from the root to the
+    # deepest node in the tree. A (rooted) tree with only one node (the root)
+    # has a height of zero.
+    #
+    # Available options :
+    #   initial : this will mark the current node as a root.
+    #
+    def height(opts={})
+      if empty?
+        -1
+      elsif (root? && leaf?) || (opts[:initial] && leaf?)
+        0
+      elsif leaf?
+        1
+      else
+        current_height = (root? || opts[:initial]) ? 0 : 1
+        if @left_child.nil? && @right_child != nil
+          current_height + @right_child.height
+        elsif @left_child != nil && @right_child.nil?
+          current_height + @left_child.height
+        elsif @left_child != nil && @right_child != nil
+          current_height + [@left_child.height, @right_child.height].max
+        else
+          raise "Unhandled depth case"
+        end
+      end
+    end
+
+    def >(other)
+      @value > other.value
+    end
+
+    def <(other)
+      @value < other.value
+    end
+
+    def <=>(other)
+      if @value < other.value
+        -1
+      elsif @value == other.value
+        0
+      else
+        1
+      end
+    end
+
+    # Siblings are nodes that share the same parent node.
+    def siblings
+    end
+
+    # All nodes above current node
+    def ancestors
+    end
+
+    # The size of a node is the number of descendants it has including itself.
+    def size
+      if leaf?
+        1
+      elsif @left_child.nil?
+        1 + @right_child.size
+      elsif @right_child.nil?
+        1 + @left_child.size
+      else
+        1 + @left_child.size + @right_child.size
+      end
+    end
+
+    # A tree is full if every nodes except leaves has 2 children
+    def full?
+    end
+
+    def balanced?
+    end
+
+    def degenerated?
+    end
+
+    # Return the highest value in the tree
+    def max
+      if @right_child.nil?
+        if empty?
+          nil
+        else
+          self
+        end
+      else
+        @right_child.max
+      end
+    end
+
+    # Return the lowest value in the tree
+    def min
+      if @left_child.nil?
+        if empty?
+          nil
+        else
+          self
+        end
+      else
+        @left_child.min
+      end
+    end
+
+    # Add a node with value equals to v in the tree
+    def add(v)
+      if empty?
+        @value = v
+      elsif v > @value
+        if(@right_child.nil?)
+          node = Node.new(v).tap { |n| n.parent = self }
+          @right_child = node
+          # return node
+        else
+          @right_child.add(v)
+        end
+      else
+        if @left_child.nil?
+          node = Node.new(v).tap { |n| n.parent = self }
+          @left_child = node
+          # return node
+        else
+          @left_child.add(v)
+        end
+      end
+    end
+    alias_method :<<, :add
+
+    # Traverse the tree and returns the list of elements
+    # For the following tree :
+    #
+    #     5
+    #   /  \
+    # 2     10
+    #     / \
+    #    6  12
+    #
+    # It return [2, 5, 6, 10, 12]
+    #
+    def to_a
+
+    end
+
+    # Traverse the tree and return elements in a hash:
+    # For the following tree :
+    #
+    #     5
+    #   /  \
+    # 2     10
+    #     / \
+    #    6  12
+    #
+    # It returns { :"5" => { :"2" => nil, :"10" => { :"6" => nil, :"12" => nil } } }
+    #
+    def to_hash
+
+    end
+
+    # Draw the tree in the console
+    # example :
+    #
+    #     5
+    #   /  \
+    # 2     10
+    #     / \
+    #    6  12
+    #
+    def draw
+
+    end
+
+  end #class
+end #module

data/lib/albizia/rb_node.rb

@@ -0,0 +1,5 @@
+module Albizia
+  class RBNode
+
+  end
+end

data/lib/albizia/tree.rb

@@ -0,0 +1,16 @@
+module Albizia
+  class Tree
+
+    attr_accessor :root
+
+    def initialize
+    end
+
+    def add
+    end
+
+    def delete
+    end
+
+  end
+end

data/spec/albizia/node_spec.rb

@@ -0,0 +1,367 @@
+require "spec_helper"
+
+module Albizia
+  describe Node do
+    describe "#init" do
+      context "Without params" do
+        subject { Node.new }
+
+        it { should be_empty }
+
+        it "should have a height of -1" do
+          subject.height.should == -1
+        end
+      end
+
+      context "With an integer param" do
+        subject { Node.new(@v) }
+        before(:each) { @v = 0 }
+
+        it { should_not be_empty }
+        it { should be_root }
+        it { should be_leaf }
+
+        it "should have length equals to 0" do
+          subject.height.should == 0
+        end
+
+        it "should have the assigned value" do
+          subject.value.should == @v
+        end
+      end
+    end
+
+    describe "#add" do
+      context "To an empty tree" do
+        subject { Node.new }
+        before(:each) { subject.add(5) }
+
+        it "should be inserted at the root" do
+          subject.value.should == 5
+          subject.parent.should be_nil
+        end
+
+        it { should be_leaf }
+
+        it "should have a height of 0" do
+          subject.height.should == 0
+        end
+      end
+
+      context "To an almost empty tree" do
+        subject { Node.new(5) }
+
+        context "A greater value than root's value" do
+          before(:each) do
+            subject.add(10)
+          end
+
+          it { should be_root }
+          it { should_not be_leaf }
+
+          it "should be inserted on the right" do
+            subject.right_child.should_not be_empty
+            subject.right_child.value.should == 10
+            subject.left_child.should be_nil
+          end
+
+          it "should have a height of 1" do
+            subject.should_not be_empty
+            subject.right_child.should_not be_nil
+            subject.right_child.should be_leaf
+            subject.left_child.should be_nil
+
+            subject.height.should == 1
+          end
+        end
+
+        context "A lower value than root's value" do
+          before(:each) do
+            subject.add(1)
+          end
+
+          it { should_not be_leaf }
+
+          it "should be inserted on the left" do
+            subject.left_child.should_not be_empty
+            subject.left_child.value.should == 1
+            subject.right_child.should be_nil
+          end
+
+          it "should have a height of 1" do
+            subject.height.should == 1
+          end
+        end
+
+      end
+
+      context "To a non empty tree" do
+        subject { Node.new(5) }
+        before(:each) do
+          subject.add(3)
+          subject.add(7)
+        end
+
+        context "A greater value than root's value" do
+          context "A greater value than the current max value" do
+            before(:each) do
+              subject.add(8)
+            end
+
+            it "should be inserted on the right of the current right'est' node" do
+              subject.right_child.right_child.value.should == 8
+            end
+            it "should be the max" do
+              subject.max.value.should == 8
+            end
+            it "should be a leaf" do
+              subject.right_child.right_child.should be_leaf
+            end
+            it "should have a height of 2" do
+              subject.height.should == 2
+            end
+          end
+
+          context "A lower value than the current max value but greater than root's" do
+            before(:each) do
+              subject.add(6)
+            end
+
+            it "should be inserted on the left of the current right'est' node" do
+              subject.right_child.left_child.value.should == 6
+            end
+            it "should be a leaf" do
+              subject.right_child.left_child.should be_leaf
+            end
+            it "should have a height of 2" do
+              subject.height.should == 2
+            end
+          end
+
+        end
+
+        context "A lower value than root's value" do
+          context "A lower value than current min" do
+            before(:each) do
+              subject.add(1)
+            end
+            it "should be inserted on the left of the current left'est' node " do
+              subject.left_child.left_child.value.should == 1
+            end
+
+            it "should be a leaf" do
+              subject.left_child.left_child.should be_leaf
+            end
+
+            it "should be the min" do
+              subject.min.value.should == 1
+            end
+
+            it "should have a height of 2" do
+              subject.height.should == 2
+            end
+          end
+
+          context "A greater value than current min but still lower than root's " do
+            before(:each) do
+              subject.add(4)
+            end
+            it "should be inserted on the right of the current left'est' node" do
+              subject.left_child.right_child.value.should == 4
+            end
+            it "should be a leaf" do
+              subject.left_child.right_child.should be_leaf
+            end
+            it "should have a height of 2" do
+              subject.height.should == 2
+            end
+          end
+        end
+
+      end
+    end
+
+    describe "#root" do
+      subject { Node.new 10 }
+
+      context "Empty tree" do
+        it "should return self" do
+          subject.root.should == subject
+        end
+      end
+
+      context "Tree with one element" do
+        before(:each) do
+          subject.parent = Node.new(20)
+        end
+
+        it "should return subject's parent" do
+          subject.root.should == subject.parent
+        end
+      end
+
+      context "Tree with more than one element" do
+
+        it "should return the same root for each descendant" do
+          5.times.map do |i|
+            node = subject.add(i)
+            node.root.should == subject
+          end
+        end
+      end
+
+    end
+    describe "#depth" do
+      context "Empty tree" do
+        subject { Node.new }
+
+        it "should have a depth of 0" do
+          subject.depth.should == 0
+        end
+
+      end
+
+      context "Not empty tree" do
+        subject do
+          parent = Node.new(10)
+          Node.new(4).tap {|n| n.parent = parent }
+        end
+
+        it "should have a depth of 1" do
+          subject.depth.should == 1
+        end
+
+        it "should have a depth of 2" do
+          subject.parent.parent = Node.new(20)
+          subject.depth.should == 2
+        end
+
+        it "should still have a depth of 2 after adding a child" do
+          subject.parent.parent = Node.new(20)
+          subject.add(2)
+          subject.depth.should == 2
+        end
+      end
+    end
+
+    describe "#height" do
+      context "Empty tree" do
+        subject { Node.new }
+
+        it "should have a height of -1" do
+          subject.height.should == -1
+        end
+      end
+
+      context "Tree with one element" do
+        subject { Node.new 10 }
+
+        it "should have a height of 0" do
+          subject.height.should == 0
+        end
+      end
+
+      context "Tree with more than one element" do
+        subject { Node.new(10).tap { |n| n.add 4 } }
+
+        context "Tree's root" do
+          it "should have a height of 1 after initialization" do
+            subject.height.should == 1
+          end
+
+          it "should have a height of 1 after adding a new element at the same depth" do
+            subject.add 15
+            subject.height.should == 1
+          end
+
+          it "should have a height of 2 after adding a child on the right" do
+            subject.add 15
+            subject.add 20
+            subject.height.should == 2
+          end
+        end
+
+        context "Nodes in a tree ('initial' option)" do
+
+          it "should return a height of 2 for the parent of a leaf's parent" do
+            subject.add 15
+            node = subject.add 20
+            subject.add 25
+            subject.add 30
+
+            node.should_not be_leaf
+            node.height(initial: true).should == 2
+          end
+
+          it "should return a height of 1 for the parent of a leaf" do
+            subject.add 15
+            node = subject.add 20
+            subject.add 30
+
+            node.should_not be_leaf
+            node.height(initial: true).should == 1
+          end
+
+          it "should return a height of 0 for a leaf" do
+            subject.add 15
+            subject.add 20
+            node = subject.add 30
+
+            node.should be_leaf
+            node.height(initial: true).should == 0
+          end
+        end
+      end
+
+    end
+
+    describe "#find" do
+      context "A value which is not present in the tree" do
+        it "should raise an Exception"
+      end
+
+      context "The minimum value of the tree" do
+        it "should return the correct value"
+      end
+
+      context "The maximum value of the tree" do
+        it "should return the correct value"
+      end
+
+      context "A value which is lower than the root's value" do
+        it "should return the correct value"
+      end
+
+      context "A value which is greater than the root" do
+        it "should return the correct value"
+      end
+    end
+
+    describe "#delete" do
+      context "The root value" do
+        it "should delete the value"
+      end
+
+      context "A value which is not present in the tree" do
+        it "should raise an Exception"
+      end
+
+      context "The minimum value of the tree" do
+        it "should delete the value"
+      end
+
+      context "The maximum value of the tree" do
+        it "should delete the value"
+      end
+
+      context "A value which is lower than the root's value" do
+        it "should delete the value"
+      end
+
+      context "A value which is greater than the root" do
+        it "should delete the value"
+      end
+    end
+
+  end
+end

data/spec/albizia/rb_node_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+module Albizia
+  describe RBNode do
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "albizia"

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: albizia
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Pierre Jambet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-29 00:00:00.000000000 Z
+dependencies: []
+description: A simple gem implementing different kind of tree structures
+email: pierre.jambet@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/albizia/node.rb
+- lib/albizia/rb_node.rb
+- lib/albizia/tree.rb
+- lib/albizia.rb
+- spec/albizia/node_spec.rb
+- spec/albizia/rb_node_spec.rb
+- spec/spec_helper.rb
+- Gemfile
+- Guardfile
+- Rakefile
+- README.md
+homepage: http://pjambet.github.com/albizia/
+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: Albzia is a basic tree implemention
+test_files: []