tree.rb 0.3.0

data/lib/treevisitor/tree_node.rb

@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # TreeNode can contains other TreeNode (children)
+  # and can contains LeafNode (leaves)
+  #
+  # TreeNode @children -1---n-> TreeNode
+  #          @leaves   -1---n-> LeafNode
+  #
+  # define dsl to create Tree
+  # 
+  # @example
+  #   tree = TreeNode.create do
+  #     node "root" do
+  #       leaf "l1"
+  #       node "sub" do
+  #         leaf "l3"
+  #       end
+  #       node "wo leaves"
+  #     end
+  class TreeNode < AbsNode
+
+    class << self
+
+      # DSL create a root node
+      #
+      # tree = TreeNode.create do ... end
+      #
+      # @param [Class] class1  Subclass of TreeNode default TreeNode
+      # @param [Class] class2  Subclass of LeafNode default LeafNode
+      # @param [Object] block
+      def create(class1 = TreeNode, class2 = LeafNode, &block)
+        if class1.ancestors.include?(TreeNode) and class2.ancestors.include?(LeafNode)
+          @tree_node_class = class1
+          @leaf_node_class = class2
+        elsif class1.ancestors.include?(LeafNode) and class2 == LeafNode
+          @tree_node_class = self
+          @leaf_node_class = class1
+        end
+
+        if @tree_node_class.nil? || @leaf_node_class.nil?
+          raise "Must be specified class derived from TreeNode and LeafNode"
+        end
+
+        @scope_stack = []
+        class_eval(&block)
+      end
+
+      private
+
+      # DSL node add a child to the surrounding node
+      # TreeNode.create do 
+      #   node "..." 
+      # end
+      def node(*args, &block)
+        parent_node = @scope_stack.length > 0 ? @scope_stack[-1] : nil
+        args << parent_node
+        tree_node = @tree_node_class.new(*args)
+        @scope_stack.push tree_node
+        if block
+          if block.arity == 0 || block.arity == -1
+            class_eval(&block)
+          elsif block.arity == 1
+            new_block = Proc.new { block.call(tree_node) }
+            class_eval(&new_block)
+          else
+            raise "block take too much arguments #{block.arity}"
+          end
+        end
+        @scope_stack.pop
+      end
+
+      # DSL node add a leaf to the surround node
+      # TreeNode.create do 
+      #   leaf "..." 
+      # end
+      def leaf(*args, &block)
+        tree_node = @scope_stack[-1]
+        args << tree_node
+        leaf_node = @leaf_node_class.new(*args)
+        if block
+          if block.arity == 0 || block.arity == -1
+            class_eval(&block)
+          elsif block.arity == 1
+            new_block = Proc.new { block.call(leaf_node) }
+            class_eval(&new_block)
+          else
+            raise "block take too much arguments #{block.arity}"
+          end
+        end
+        leaf_node
+      end
+    end  # end class << self
+
+    # leaves of this node
+    attr_reader :leaves
+
+    # children i.e. other tree node
+    attr_reader :children
+
+    #
+    # @param [Object] content of this node
+    # @param [Object] parent of this node. If parent is nil, it is a root
+    def initialize(content, parent = nil)
+      @leaves   = []
+      @children = []
+      super(content)
+      parent.add_child(self) if parent
+    end
+
+    #
+    # Test if is a root
+    #
+    # @return [Boolean] true if this node is a root
+    def root?
+      @parent.nil?
+    end
+
+    #
+    # invalidate cached info
+    # invalidate propagates form parent to children and leaves
+    #
+    def invalidate
+      super
+      @children.each { |c| c.invalidate }
+      @leaves.each { |l| l.invalidate }
+    end
+
+    #
+    # @return [FixNum] total number of nodes
+    #
+    def nr_nodes
+      nr = @leaves.length + @children.length
+      @children.inject(nr) { |sum, c| sum + c.nr_nodes }
+    end
+
+    #
+    # @return [FixNum] total number of leaves
+    #
+    def nr_leaves
+      @leaves.length + @children.inject(0) { |sum, child| sum + child.nr_leaves }
+    end
+
+    #
+    # @return [FixNum] total number of children
+    #
+    def nr_children
+      @children.length + @children.inject(0) { |sum, child| sum + child.nr_children }
+    end
+
+    #
+    # Add a Leaf
+    # @param [LeafNode]
+    #
+    # @return self
+    #
+    def add_leaf(leaf)
+      return if leaf.parent == self
+      if not leaf.parent.nil?
+        leaf.remove_from_parent
+      end
+      leaf.parent = self
+      if @leaves.length > 0
+        @leaves.last.next = leaf
+        leaf.prev         = @leaves.last
+      else
+        leaf.prev = nil
+      end
+      leaf.next = nil
+      leaf.invalidate
+      @leaves << leaf
+      self
+    end
+
+    #
+    # Add a Tree
+    # @param [LeafNode]
+    #
+    # @return self
+    #
+    def add_child(tree_node)
+      return if tree_node.parent == self
+      if not tree_node.parent.nil?
+        tree_node.remove_from_parent
+      else
+        tree_node.prefix_path = nil
+      end
+      tree_node.invalidate
+      tree_node.parent = self
+      if @children.length > 0
+        @children.last.next = tree_node
+        tree_node.prev      = @children.last
+      else
+        tree_node.prev = nil
+      end
+      tree_node.next = nil
+      @children << tree_node
+      self
+    end
+
+    #
+    # Find a node down the hierarchy with content
+    # @param [Object,Regexp] content of searched node
+    # @return [Object, nil] nil if not found
+    #
+    def find(content = nil, &block)
+      if content and block_given?
+        raise "TreeNode::find - passed content AND block"
+      end
+
+      if content
+        if content.class == Regexp
+          block = proc { |l| l.content =~ content }
+        else
+          block = proc { |l| l.content == content }
+        end
+      end
+      return self if block.call(self)
+
+      leaf = @leaves.find { |l| block.call(l) }
+      return leaf if leaf
+
+      @children.each do |child|
+        node = child.find &block
+        return node if node
+      end
+      nil
+    end
+
+    #
+    # return the visitor
+    #
+    def accept(visitor)
+      visitor.enter_node(self)
+      @leaves.each do |leaf|
+        leaf.accept(visitor)
+      end
+      @children.each do |child|
+        child.accept(visitor)
+      end
+      visitor.exit_node(self)
+      visitor
+    end
+
+    #
+    # Format the content of tree
+    #
+    def to_str(prefix= "", tty_color = false)
+      str = ""
+
+      # print node itself
+      if root?
+        if tty_color
+          str << ANSI.red{ to_s } << "\n"
+        else
+          str << to_s << "\n"
+        end
+      else
+        str << prefix
+        if self.next
+          str << '|-- '
+        else
+          str << '`-- '
+        end
+        if tty_color
+          str << ANSI.red{ to_s } << "\n"
+        else
+          str << to_s << "\n"
+        end
+        prefix += self.next ? "|   " : "    "
+      end
+
+      # print leaves
+      @leaves.each do |leaf|
+        str << prefix
+        if !leaf.next.nil? or !@children.empty?
+          str << '|-- '
+        else
+          str << '`-- '
+        end
+        if tty_color
+          str << ANSI.green{ leaf.to_s } << "\n" 
+        else
+          str << leaf.to_s << "\n" 
+        end
+      end
+
+      # print children
+      @children.each do |child|
+        str << child.to_str(prefix, tty_color)
+      end
+      str
+    end
+
+  end
+end

data/lib/treevisitor/tree_node_visitor.rb

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+
+  #
+  # More complex TreeNodeVisitor, define a simple dsl
+  # @example
+  #   TreeNodeVisitor.new do
+  #     on_enter_node do |node|
+  #       puts "hello #{node}"
+  #     end
+  #     on_exit_node do |node|
+  #       puts "bye #{node}"
+  #     end
+  #     on_leaf do |leaf|
+  #       puts "how you do #{leaf}"
+  #     end
+  #   end
+  #
+  class TreeNodeVisitor
+
+    # @param [Object] delegate
+    def initialize(delegate = nil, &block)
+      @on_enter_tree_node_blocks = []
+      @on_exit_tree_node_blocks  = []
+      @on_visit_leaf_node_blocks = []
+      @stack                     = []
+      @root                      = nil
+      @delegate                  = delegate
+      if block
+        instance_eval(&block)
+      end
+    end
+
+    #
+    # called on tree node at start of the visit i.e. we start to visit the subtree
+    #
+    def enter_node(tree_node)
+      parent = @stack.last
+      if @delegate
+        @delegate.enter_node(tree_node) if @delegate.respond_to? :enter_node
+      else
+        @on_enter_tree_node_blocks.each do |b|
+          if b.arity == 1
+            b.call(tree_node)
+          elsif b.arity == 2
+            b.call(tree_node, parent)
+          end
+        end
+      end
+      @root = tree_node if @stack.empty?
+      @stack.push(tree_node)
+    end
+
+    #
+    # called on tree node at end of the visit i.e. oll subtree are visited
+    #
+    def exit_node(tree_node)
+      parent = @stack.last
+      if @delegate
+        @delegate.exit_node(tree_node) if @delegate.respond_to? :exit_node
+      else
+        @on_exit_tree_node_blocks.each do |b|
+          if b.arity == 1
+            b.call(tree_node)
+          elsif b.arity == 2
+            b.call(tree_node, parent)
+          end
+        end
+      end
+      @stack.pop
+    end
+
+    #
+    # called when visit leaf node
+    #
+    def visit_leaf(leaf_node)
+      parent = @stack.last
+      if @delegate
+        @delegate.visit_leaf(leaf_node) if @delegate.respond_to? :visit_leaf
+      else
+        @on_visit_leaf_node_blocks.each do |b|
+          if b.arity == 1
+            b.call(leaf_node)
+          elsif b.arity == 2
+            b.call(leaf_node, parent)
+          end
+        end
+      end
+    end
+
+    #
+    # add a block to be called when entering into a tree_node
+    #
+    def on_enter_node(&block)
+      raise "already defined a delegate" if @delegate
+      raise "block missing" unless block
+      @on_enter_tree_node_blocks << block
+    end
+
+    #
+    # add a block to be called when exiting from a TreeNode
+    #
+    def on_exit_node(&block)
+      raise "already defined a delegate" if @delegate
+      raise "block missing" unless block
+      @on_exit_tree_node_blocks << block
+    end
+
+    #
+    # add a block to be called when visiting a leaf node
+    #
+    def on_leaf(&block)
+      raise "already defined a delegate" if @delegate
+      raise "block missing" unless block
+      @on_visit_leaf_node_blocks << block
+    end
+
+  end
+
+end

data/lib/treevisitor/util/dir_processor.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+
+  #
+  # Visit a directory tree
+  # not TreeNode related
+  #
+  class DirProcessor
+
+    def initialize( &action )
+      @processors = {}
+      @default_processor = action
+    end
+
+    def add_processor( re, &action )
+      @processors[ re ] = action
+    end
+
+    def process( dirname )
+      @dirname = dirname
+      old_dirname = Dir.pwd
+      Dir.chdir( @dirname )
+      Dir["**/*"].each { |f|
+        pn = Pathname.new( f ).expand_path
+        # puts "#{self.class.name}#loadfromdir #{f}"
+        next if pn.directory?
+        process_file( pn )
+      }
+      Dir.chdir( old_dirname )
+      self
+    end
+
+    private
+  
+    def process_file( pn )
+      # puts "file: #{f}"
+      pair = @processors.find { |re,action| re =~ pn.to_s }
+      unless pair.nil?
+        pair[1].call( pn )
+      else
+        @default_processor.call( pn ) if @default_processor
+      end
+    end
+
+  end
+end

data/lib/treevisitor/version.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  VERSION="0.3.0"
+end

data/lib/treevisitor/visitors/block_tree_node_visitor.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # It calls a block when visit a tree_node or leaf_node
+  #
+  class BlockTreeNodeVisitor < BasicTreeNodeVisitor
+
+    def initialize( &action )
+      @block = action
+    end
+
+    def enter_node( tree_node )
+      @block.call( tree_node )
+    end
+
+    def visit_leaf( leaf_node )
+      @block.call( leaf_node )
+    end
+
+  end
+end

data/lib/treevisitor/visitors/build_dir_tree_visitor.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # Builds a TreeNode from a filesystem directory
+  # It similar to CloneTreeNodeVisitor
+  #
+  class BuildDirTreeVisitor # < BasicTreeNodeVisitor
+
+    attr_reader :root
+
+    #
+    # Number of visited directory (aka nr_nodes - nr_leaf)
+    #
+    attr_reader :nr_directories
+
+
+    #
+    # Number of visited directory (nr_leaves)
+    # @see AbsNode#nr_leaves
+    #
+    attr_reader :nr_files
+
+    def initialize
+      super
+      @root = nil
+      @stack = []
+      @nr_directories = 0
+      @nr_files = 0
+    end
+
+    def enter_node( pathname )
+      if @stack.empty?
+        tree_node = TreeNode.new( File.basename( pathname ) )
+        @root = tree_node
+      else
+        tree_node = TreeNode.new( File.basename( pathname ), @stack.last )
+      end
+      @nr_directories += 1
+      @stack.push( tree_node )
+    end
+
+    def cannot_enter_node(pathname, error)
+
+    end
+
+    def exit_node( pathname )
+      @stack.pop
+    end
+
+    def visit_leaf( pathname )
+      @nr_files  += 1
+      # connect the leaf_node created to the last tree_node on the stack
+      LeafNode.new( File.basename(pathname), @stack.last )
+    end
+
+  end
+end # end module TreeVisitor

data/lib/treevisitor/visitors/callback_tree_node_visitor2.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # Executes a block when enter in a node
+  # The block are defined from on_enter_X methods
+  # The blocks take as argument the node and the parent_node
+  #
+  class CallbackTreeNodeVisitor2
+
+    attr_reader :root
+
+    def initialize(delegate = nil)
+      super()
+      @stack    = []
+      @root     = nil
+      @delegate = delegate
+    end
+
+    def on_enter_node(&block)
+      raise "already defined a delegate" if @delegate
+      @action_enter_tree_node = block
+    end
+
+    def on_visit_leaf(&block)
+      raise "already defined a delegate" if @delegate
+      @action_visit_leaf_node = block
+    end
+
+    def enter_node(src_tree_node)
+      dst_parent_node = @stack.empty? ? nil : @stack.last
+      dst_tree_node = @action_enter_tree_node.call(src_tree_node, dst_parent_node) if @action_enter_tree_node
+      dst_tree_node = @delegate.enter_node(src_tree_node, dst_parent_node) if @delegate and @delegate.respond_to? :enter_node
+      @root = dst_tree_node if @stack.empty?
+      @stack.push(dst_tree_node)
+    end
+
+    def exit_node(src_tree_node)
+      @stack.pop
+    end
+
+    def visit_leaf(src_leaf_node)
+      parent_node = @stack.last
+      @action_visit_leaf_node.call(src_leaf_node, parent_node) if @action_visit_leaf_node
+      @delegate.visit_leaf(src_leaf_node, parent_node) if @delegate and @delegate.respond_to? :visit_leaf
+    end
+  end
+
+end

data/lib/treevisitor/visitors/clone_tree_node_visitor.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # Clone a tree_node, nodes are duplicated.
+  # Node content are not duplicated!
+  #
+  class CloneTreeNodeVisitor # < BasicTreeNodeVisitor
+
+    #
+    # Contains the cloned tree node after the visit
+    #
+    attr_reader :cloned_root
+
+    def initialize
+      super
+      @cloned_root = nil
+      @stack = []
+    end
+
+    def enter_node( tree_node )
+      if @stack.empty?
+        cloned_tree_node = TreeNode.new( tree_node.content )
+        @cloned_root = cloned_tree_node
+      else
+        cloned_tree_node = TreeNode.new( tree_node.content, @stack.last )
+      end
+      @stack.push( cloned_tree_node )
+    end
+
+    def exit_node( tree_node )
+      @stack.pop
+    end
+
+    def visit_leaf( leaf_node )
+      LeafNode.new( leaf_node.content, @stack.last )
+    end
+
+  end
+end

data/lib/treevisitor/visitors/depth_tree_node_visitor.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # Simple visitor: show how calculate the depth of a tree
+  #
+  class DepthTreeNodeVisitor # < BasicTreeNodeVisitor
+
+    attr_reader :depth
+
+    def initialize
+      super
+      @depth = 0
+    end
+
+    def enter_node( tree_node )
+      @depth += 1
+    end
+
+    def exit_node( tree_node )
+      @depth -= 1
+    end
+
+    def visit_leaf( leaf_node )
+    end
+
+  end
+end

data/lib/treevisitor/visitors/directory_to_hash_visitor.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+module TreeVisitor
+  #
+  # Build hash with directory structure
+  #
+  class DirectoryToHashVisitor # < TreeVisitor::BasicTreeNodeVisitor
+
+    attr_reader :root
+
+    def initialize(pathname)
+      @stack = []
+      @node = {}
+      @root = @node
+    end
+
+    def enter_node(pathname)
+      subnode                        = {}
+      @node[File.basename(pathname)] = subnode
+      @stack.push(@node)
+      @node = subnode
+    end
+
+    def exit_node(pathname)
+      @node = @stack.pop
+    end
+
+    def visit_leaf(pathname)
+      @node[File.basename(pathname)] = File.stat(pathname).size
+    end
+
+  end
+end

data/lib/treevisitor/visitors/flat_print_tree_node_visitors.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # Print for every node the name
+  #
+  class FlatPrintTreeNodeVisitor # < BasicTreeNodeVisitor
+
+    def enter_node( tree_node )
+      puts tree_node.name
+    end
+
+    def exit_node( tree_node )
+    end
+
+    def visit_leaf( leaf_node )
+      puts leaf_node.name
+    end
+
+  end
+end