tree 0.2.1

data/README

@@ -0,0 +1,6 @@
+= Tree Implementation
+
+
+Hello 
+
+== Introduction

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc "Default Task"
+task :default => :gem
+
+PKG_VERSION = '0.2.1'
+PKG_FILES = FileList[
+                '[A-Z]*',
+                'lib/**/*.rb',
+                'test/**/*.rb'
+                ]
+
+spec = Gem::Specification.new do |s|
+    s.name = "tree"
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::RUBY
+    s.author = "Anupam Sengupta"
+    s.email = "anupamsg@gmail.com"
+    s.summary = "Ruby implementation of the Tree data structure."
+    
+    s.description = <<-END
+    Provides a generic tree data structure with ability to
+    store keyed node elements in the tree. The implementation
+    mixes in the Enumerable module.
+    END
+    
+    s.has_rdoc = true
+    s.extra_rdoc_files = ['README']
+    s.autorequire = "tree"
+    s.files = PKG_FILES.to_a
+    s.test_files = Dir.glob('test/test*.rb')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+end
+
+Rake::TestTask.new do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true
+end
+
+Rake::RDocTask.new do |rd|
+    rd.rdoc_files.include("README", "lib/**/*.rb")
+end
+
+
+

data/lib/tree.rb

@@ -0,0 +1,278 @@
+#
+# = tree.rb - Generic Tree implementation
+#
+# Provides a generic tree data structure with ability to
+# store keyed node elements in the tree. The implementation
+# mixes in the Enumerable module.
+#
+# Author:: Anupam Sengupta (anupamsg@gmail.com)
+#
+
+module Tree
+
+    # The Tree node class implementation. Mixes in the Enumerable
+    # module.
+    # == Example
+    #
+    # require 'tree'
+    #
+    # myTreeRoot = Tree::TreeNode.new("ROOT", "Root Content")
+    #
+    # myTreeRoot << Tree::TreeNode.new("CHILD1", "Child1 Content") << Tree::TreeNode.new("GRANDCHILD1", "GrandChild1 Content")
+    #
+    # myTreeRoot << Tree::TreeNode.new("CHILD2", "Child2 Content")
+    #
+    # myTreeRoot.printTree
+    #
+    # child1 = myTreeRoot["CHILD1"]
+    #
+    # grandChild1 = myTreeRoot["CHILD1"]["GRANDCHILD1"]
+    #
+    # siblingsOfChild1Array = child1.siblings
+    #
+    # immediateChildrenArray = myTreeRoot.children
+    #
+    # # Process all nodes
+    #
+    # myTreeRoot.each { |node| node.content.reverse }
+    #
+    # myTreeRoot.remove!(child1) # Remove the child
+    class TreeNode
+        include Enumerable
+
+        attr_reader :content, :name, :parent
+        attr_writer :content
+
+        @@fieldSep = '|'
+        @@recordSep = "\n"
+        
+        # Constructor which expects the name of the node
+        #
+        # name of the node is expected to be unique across the
+        # tree.
+        #
+        # The content can be of any type, and is defaulted to _nil_.
+        def initialize(name, content = nil)
+                
+                raise "Node name HAS to be provided" if name == nil
+                
+                @name = name
+                @content = content
+
+                self.setAsRoot!
+
+                @childrenHash = Hash.new
+                @children = []
+        end
+
+        # Print the string representation of this node.
+        def to_s
+                s = size()
+                "Node ID: #{@name} Content: #{@content} Parent: " +
+                        (isRoot?()  ? "ROOT" : "#{@parent.name}") +
+                        " Children: #{@children.length}" +
+                        " Total Nodes: #{s}"
+        end
+
+        # Protected method to set the parent node.
+        # This method should NOT be invoked by client code.
+        def parent=(parent)
+            @parent = parent
+        end
+
+        # Convenience synonym for Tree#add method. 
+        # This method allows a convenient method to add
+        # children hierarchies in the tree.
+        # E.g. root << child << grand_child
+        def <<(child)
+            add(child)
+        end
+
+        # Adds the specified child node to the receiver node.
+        # The child node's parent is set to be the receiver.
+        # The child is added as the last child in the current
+        # list of children for the receiver node.
+        def add(child)
+            raise "Child already added" if @childrenHash.has_key?(child.name)
+
+            @childrenHash[child.name]  = child
+            @children << child
+            child.parent = self
+            return child
+
+        end
+
+        # Removes the specified child node from the receiver node.
+        # The removed children nodes are orphaned but available
+        # if an alternate reference exists.
+        # Returns the child node.
+        def remove!(child)
+            @childrenHash.delete(child.name)
+            @children.delete(child)
+            child.setAsRoot! unless child == nil
+            return child
+        end
+
+        # Removes this node from its parent. If this is the root node,
+        # then does nothing.
+        def removeFromParent!
+            @parent.remove!(self) unless isRoot?
+        end
+        
+        # Removes all children from the receiver node.
+        def removeAll!
+            for child in @children
+                child.setAsRoot!
+            end
+            @childrenHash.clear
+            @children.clear
+            self
+        end
+
+        # Indicates whether this node has any associated content.
+        def hasContent?
+            @content != nil
+        end
+
+        # Private method which sets this node as a root node.
+        def setAsRoot!
+            @parent = nil
+        end
+
+        # Indicates whether this node is a root node. Note that
+        # orphaned children will also be reported as root nodes.
+        def isRoot?
+            @parent == nil
+        end
+
+        # Indicates whether this node has any immediate child nodes.
+        def hasChildren?
+            @children.length != 0
+        end
+
+        # Returns an array of all the immediate children.
+        # If a block is given, yields each child node to the block.
+        def children
+            if block_given?
+                @children.each {|child| yield child}
+            else
+                @children
+            end
+        end
+
+        # Returns every node (including the receiver node) from the
+        # tree to the specified block.
+        def each &block
+            yield self
+            children { |child| child.each(&block) }
+        end
+
+        # Returns the requested node from the set of immediate
+        # children.
+        # 
+        # If the key is _numeric_, then the in-sequence array of
+        # children is accessed (see Tree#children).
+        # If the key is not _numeric_, then it is assumed to be
+        # the *name* of the child node to be returned.
+        def [](key)
+            raise "Key needs to be provided" if key == nil
+            
+            if key.kind_of?(Integer)
+                @children[key]
+            else
+                @childrenHash[key]
+            end
+        end
+
+        # Returns the total number of nodes in this tree, rooted
+        # at the receiver node.
+        def size
+            @children.inject(1) {|sum, node| sum + node.size}
+        end
+
+        # Convenience synonym for Tree#size
+        def length
+            size()
+        end
+
+        # Pretty prints the tree starting with the receiver node.
+        def printTree(tab = 0)
+            puts((' ' * tab) + self.to_s)
+            children {|child| child.printTree(tab + 4)}
+        end
+
+        # Returns the root for this node.
+        def root
+            root = self
+            root = root.parent while !root.isRoot?
+            root
+        end
+
+        # Returns an array of siblings for this node.
+        # If a block is provided, yeilds each of the sibling
+        # nodes to the block.
+        def siblings
+            if block_given?
+                return nil if isRoot?
+                for sibling in parent.children
+		    yield sibling if sibling != self
+                end
+            else
+                siblings = []
+                parent.children {|sibling| siblings << sibling if sibling != self}
+                siblings
+            end
+        end
+
+        # Provides a comparision operation for the nodes. Comparision
+        # is based on the natural character-set ordering for the
+        # node names.
+        def <=>(other)
+            return +1 if other == nil
+            self.name <=> other.name
+        end
+
+        # Freezes all nodes in the tree
+        def freezeTree!
+            each {|node| node.freeze}
+        end
+        
+        # Creates a dump representation
+        def createDumpRep
+            strRep = String.new
+            strRep << @name << @@fieldSep << (isRoot? ? @name : @parent.name)
+            strRep << @@fieldSep << Marshal.dump(@content) << @@recordSep
+        end
+        
+        def _dump(depth)
+            strRep = String.new
+            each {|node| strRep << node.createDumpRep}
+            strRep
+        end
+        
+        def TreeNode.loadDumpRep(str)
+            nodeHash = Hash.new
+            rootNode = nil
+            str.split(@@recordSep).each do |line|
+                name, parent, contentStr = line.split(@@fieldSep)
+                content = Marshal.load(contentStr)
+                currentNode = Tree::TreeNode.new(name, content)
+                nodeHash[name] = currentNode
+                if name != parent  # Do for a child node
+                    nodeHash[parent].add(currentNode)
+                else
+                    rootNode = currentNode
+                end
+            end
+            rootNode
+        end
+        
+        def TreeNode._load(str)
+            loadDumpRep(str)
+        end
+        
+        protected :parent=, :setAsRoot!
+        private_class_method :loadDumpRep
+        
+    end
+end

data/test/person.rb

@@ -0,0 +1,13 @@
+class Person
+    attr_reader :first, :last
+    attr_writer :first, :last
+    def initialize(first, last)
+        @first = first
+        @last = last
+    end
+    
+    def to_s
+        "#@first, #@last"
+    end
+    
+end

data/test/testtree.rb

@@ -0,0 +1,259 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'tree'
+require 'person'
+
+# Test class for the Tree node.
+class TC_TreeTest < Test::Unit::TestCase
+
+    def setup
+        @root = Tree::TreeNode.new("ROOT", "Root Node")
+
+        @child1 = Tree::TreeNode.new("Child1", "Child Node 1")
+        @child2 = Tree::TreeNode.new("Child2", "Child Node 2")
+        @child3 = Tree::TreeNode.new("Child3", "Child Node 3")
+        @child4 = Tree::TreeNode.new("Child31", "Grand Child 1")
+
+    end
+
+    def loadChildren
+        @root << @child1
+        @root << @child2
+        @root << @child3 << @child4
+    end
+
+    def teardown
+        @root = nil
+    end
+
+    def test_root_setup
+        assert_not_nil(@root, "Root cannot be nil")
+        assert_nil(@root.parent, "Parent of root node should be nil")
+        assert_not_nil(@root.name, "Name should not be nil")
+        assert_equal("ROOT", @root.name, "Name should be 'ROOT'")
+        assert_equal("Root Node", @root.content, "Content should be 'Root Node'")
+        assert(@root.isRoot?, "Should identify as root")
+        assert(!@root.hasChildren?, "Cannot have any children")
+        assert_equal(1, @root.size, "Number of nodes should be one")
+
+        assert_raise(RuntimeError) { Tree::TreeNode.new(nil) }
+    end
+
+    def test_root
+        loadChildren
+
+        assert_same(@root, @root.root, "Root's root is self")
+        assert_same(@root, @child1.root, "Root should be ROOT")
+        assert_same(@root, @child4.root, "Root should be ROOT")
+    end
+
+    def test_siblings
+        loadChildren
+
+        siblings = []
+        @child1.siblings { |sibling| siblings << sibling}
+        assert_equal(2, siblings.length, "Should have two siblings")
+        assert(siblings.include?(@child2), "Should have 2nd child as sibling")
+        assert(siblings.include?(@child3), "Should have 3rd child as sibling")
+
+        siblings.clear
+        siblings = @child1.siblings
+        assert_equal(2, siblings.length, "Should have two siblings")
+
+        siblings.clear
+        @child4.siblings {|sibling| siblings << sibling}
+        assert(siblings.empty?, "Should not have any children")
+
+    end
+
+    def test_add
+        assert(!@root.hasChildren?, "Should not have any children")
+
+        @root.add(@child1)
+
+        @root << @child2
+
+        assert(@root.hasChildren?, "Should have children")
+        assert_equal(3, @root.size, "Should have three nodes")
+
+        @root << @child3 << @child4
+
+        assert_equal(5, @root.size, "Should have five nodes")
+        assert_equal(2, @child3.size, "Should have two nodes")
+
+        assert_raise(RuntimeError) { @root.add(Tree::TreeNode.new(@child1.name)) }
+
+    end
+
+    def test_remove
+        @root << @child1
+        @root << @child2
+
+        assert(@root.hasChildren?, "Should have children")
+        assert_equal(3, @root.size, "Should have three nodes")
+
+        @root.remove!(@child1)
+        assert_equal(2, @root.size, "Should have two nodes")
+        @root.remove!(@child2)
+
+        assert(!@root.hasChildren?, "Should have no children")
+        assert_equal(1, @root.size, "Should have one node")
+
+        @root << @child1
+        @root << @child2
+
+        assert(@root.hasChildren?, "Should have children")
+        assert_equal(3, @root.size, "Should have three nodes")
+
+        @root.removeAll!
+
+        assert(!@root.hasChildren?, "Should have no children")
+        assert_equal(1, @root.size, "Should have one node")
+
+    end
+
+    def test_removeAll
+        loadChildren
+        assert(@root.hasChildren?, "Should have children")
+        @root.removeAll!
+
+        assert(!@root.hasChildren?, "Should have no children")
+        assert_equal(1, @root.size, "Should have one node")
+    end
+
+    def test_removeFromParent
+        loadChildren
+        assert(@root.hasChildren?, "Should have children")
+
+        child1 = @root[0]
+        assert_not_nil(child1, "Child 1 should exist")
+        assert_same(@root, child1.root, "Child 1's root should be ROOT")
+        assert(@root.include?(child1), "root should have child1")
+        child1.removeFromParent!
+        assert_same(child1, child1.root, "Child 1's root should be self")
+        assert(!@root.include?(child1), "root should not have child1")
+
+        child1.removeFromParent!
+        assert_same(child1, child1.root, "Child 1's root should still be self")
+    end
+
+    def test_children
+        loadChildren
+
+        assert(@root.hasChildren?, "Should have children")
+        assert_equal(5, @root.size, "Should have four nodes")
+        assert(@child3.hasChildren?, "Should have children")
+
+        children = []
+        for child in @root.children
+            children << child
+        end
+
+        assert_equal(3, children.length, "Should have three direct children")
+        assert(!children.include?(@root), "Should not have root")
+        assert(children.include?(@child1), "Should have child 1")
+        assert(children.include?(@child2), "Should have child 2")
+        assert(children.include?(@child3), "Should have child 3")
+        assert(!children.include?(@child4), "Should not have child 4")
+
+        children.clear
+        children = @root.children
+        assert_equal(3, children.length, "Should have three children")
+
+    end
+
+    def test_find
+        loadChildren
+        foundNode = @root.find { |node| node == @child2}
+        assert_same(@child2, foundNode, "The node should be Child 2")
+
+        foundNode = @root.find { |node| node == @child4}
+        assert_same(@child4, foundNode, "The node should be Child 4")
+
+        foundNode = @root.find { |node| node.name == "Child31" }
+        assert_same(@child4, foundNode, "The node should be Child 4")
+        foundNode = @root.find { |node| node.name == "NOT PRESENT" }
+        assert_nil(foundNode, "The node should not be found")
+    end
+
+    def test_each
+        loadChildren
+        assert(@root.hasChildren?, "Should have children")
+        assert_equal(5, @root.size, "Should have five nodes")
+        assert(@child3.hasChildren?, "Should have children")
+
+        nodes = []
+        @root.each { |node| nodes << node }
+
+        assert_equal(5, nodes.length, "Should have FIVE NODES")
+        assert(nodes.include?(@root), "Should have root")
+        assert(nodes.include?(@child1), "Should have child 1")
+        assert(nodes.include?(@child2), "Should have child 2")
+        assert(nodes.include?(@child3), "Should have child 3")
+        assert(nodes.include?(@child4), "Should have child 4")
+    end
+
+    def test_parent
+        loadChildren
+        assert_nil(@root.parent, "Root's parent should be nil")
+        assert_equal(@root, @child1.parent, "Parent should be root")
+        assert_equal(@root, @child3.parent, "Parent should be root")
+        assert_equal(@child3, @child4.parent, "Parent should be child3")
+        assert_equal(@root, @child4.parent.parent, "Parent should be root")
+    end
+
+    def test_indexed_access
+        loadChildren
+        assert_equal(@child1, @root[0], "Should be the first child")
+        assert_equal(@child4, @root[2][0], "Should be the grandchild")
+        assert_nil(@root["TEST"], "Should be nil")
+        assert_raise(RuntimeError) { @root[nil] }
+    end
+
+    def test_printTree
+        loadChildren
+        #puts
+        #@root.printTree
+    end
+
+    def test_dump
+        loadChildren
+
+        pers = Person.new("John", "Doe")
+        #@root.content = pers
+
+        data = Marshal.dump(@root)
+
+        newRoot = Marshal.load(data)
+        assert(newRoot.isRoot?, "Must be a root node")
+        assert_equal("ROOT", newRoot.name, "Must identify as ROOT")
+        assert_equal("Root Node", newRoot.content, "Must have root's content")
+        #assert_equal(pers.first, newRoot.content.first, "Must be the same content")
+        assert_equal(@child4.name, newRoot['Child3']['Child31'].name, "Must be the grand child")
+    end
+
+    def test_collect
+        loadChildren
+        collectArray = @root.collect do |node|
+            node.content = "abc"
+            node
+        end
+        collectArray.each {|node| assert_equal("abc", node.content, "Should be 'abc'")}
+    end
+
+    def test_freezeTree
+        loadChildren
+        @root.content = "ABC"
+        assert_equal("ABC", @root.content, "Content should be 'ABC'")
+        @root.freezeTree!
+        assert_raise(TypeError) {@root.content = "123"}
+        assert_raise(TypeError) {@root[0].content = "123"}
+    end
+
+    def test_content
+        pers = Person.new("John", "Doe")
+        @root.content = pers
+        assert_same(pers, @root.content, "Content should be the same")
+    end
+end

metadata

@@ -0,0 +1,43 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: tree
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+date: 2005-12-29
+summary: Ruby implementation of the Tree data structure.
+require_paths: 
+  - lib
+email: anupamsg@gmail.com
+homepage: 
+rubyforge_project: 
+description: Provides a generic tree data structure with ability to store keyed node elements in the tree. The implementation mixes in the Enumerable module.
+autorequire: tree
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Anupam Sengupta
+files: 
+  - Rakefile
+  - README
+  - lib/tree.rb
+  - test/person.rb
+  - test/testtree.rb
+test_files: 
+  - test/testtree.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+executables: []
+extensions: []
+requirements: []
+dependencies: []