gf-treevisitor 0.0.6

data/lib/treevisitor/dir_processor.rb

@@ -0,0 +1,40 @@
+require 'pathname'
+
+class DirProcessor
+
+  def initialize( dirname, &action )
+    @dirname = dirname
+    @processors = {}
+    @default_processor = action
+  end
+
+  def add_processor( re, &action )
+    @processors[ re ] = action
+  end
+
+  def run()
+    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

data/lib/treevisitor/dir_tree_walker.rb

@@ -0,0 +1,99 @@
+class DirTreeWalker
+
+  def initialize( dirname )
+    @dirname = dirname
+    unless File.directory?( dirname )
+      raise "#{dirname} is not a directory!"
+    end
+
+    @visitor = nil
+    @ignore_dir_patterns = []
+    @inspect_file_patterns = []
+    @ignore_file_patterns = []
+  end
+
+  def add_ignore_dir( pattern )
+    @ignore_dir_patterns << pattern
+  end
+
+  def add_ignore_file( pattern )
+    @ignore_file_patterns << pattern
+  end
+
+  #
+  # quali file bisogna prendere in considerazione
+  # inspect opposto di ignore :-)
+  #
+  def add_inspect_file( pattern )
+    @inspect_file_patterns << pattern
+  end
+
+  def ignore_dir?( dirname )
+    basename = File.basename( dirname )
+    @ignore_dir_patterns.find{ |pattern|
+      basename == pattern
+    }
+  end
+
+  def ignore_file?( filename )
+    basename = File.basename( filename )
+    @ignore_file_patterns.find{ |pattern|
+      if pattern.kind_of? Regexp
+        pattern =~ basename
+      else
+        pattern == basename
+      end
+    }
+  end
+
+  def inspect_file?( filename )
+    return true if @inspect_file_patterns.empty?
+    basename = File.basename( filename )
+    @inspect_file_patterns.find{ |pattern|
+      if pattern.kind_of? Regexp
+        pattern =~ basename
+      else
+        pattern == basename
+      end
+    }
+  end
+
+  def run( treeNodeVisitor )
+    @visitor = treeNodeVisitor
+    process_directory( File.expand_path( @dirname ) )
+  end
+
+  private
+
+  #
+  # recurse on other directories
+  #
+  # def process_directory( parentNode, dirname )
+  def process_directory( dirname )
+    return if ignore_dir?( dirname )
+
+    @visitor.enter_treeNode( dirname )
+
+    Dir.entries( dirname ).each { |basename|
+      next if basename == "." or basename == ".."
+      pathname = File.join( dirname, basename )
+
+      if File.directory?( pathname )
+
+        # directory
+        if ! ignore_dir?( basename )
+          process_directory( pathname )
+        end
+
+      else
+
+        # file
+        if inspect_file?( basename ) && ! ignore_file?( basename )
+          @visitor.visit_leafNode( pathname )
+        end
+
+      end
+    }
+    @visitor.exit_treeNode( dirname )
+  end
+end

data/lib/treevisitor/leaf_node.rb

@@ -0,0 +1,27 @@
+# common
+require "treevisitor/abs_node"
+
+#
+# Deriva da AbsNode
+# 
+# definisce un metodo to_str
+#
+#
+class LeafNode < AbsNode
+
+  def initialize( name, parent = nil )
+    super( name )
+    if parent
+      parent.add_leaf( self ) 
+    end
+  end
+
+  def accept( visitor )
+    visitor.visit_leafNode( self )
+  end
+
+  def to_str
+    name.to_str
+  end
+
+end

data/lib/treevisitor/tree_node.rb

@@ -0,0 +1,134 @@
+# common
+require 'treevisitor/leaf_node'
+
+#
+# Un treeNode e' come un AbsNode
+# in piu' ha la possibilita' di contenere
+# altri treeNode e LeafNode
+#
+# TreeNode @childs -1---n-> TreeNode
+#          @leaves -1---n-> LeafNode
+#
+class TreeNode < AbsNode
+  
+  attr_reader :leaves
+  attr_reader :childs
+
+  def initialize( name, parent = nil )
+    @leaves = []
+    @childs = []
+    super( name )
+    if parent
+      parent.add_child( self )
+    end
+  end
+
+  def root?
+    @parent.nil?
+  end
+  
+  #
+  # invalidate cached info
+  #
+  def invalidate
+    super
+    @childs.each{ |c| c.invalidate }
+    @leaves.each{ |l| l.invalidate }
+  end
+  
+  def nr_nodes
+    nr = @leaves.length + @childs.length
+    @childs.inject( nr ) { |nr,c| nr + c.nr_nodes }
+  end
+  
+  def nr_leaves
+    @leaves.length + @childs.inject(0) { |sum, child| sum + child.nr_leaves }
+  end
+
+  def nr_childs
+    @childs.length + @childs.inject(0) { |sum, child| sum + child.nr_childs }
+  end
+        
+  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
+      leaf.next = nil
+    end
+    leaf.invalidate
+    @leaves << leaf
+  end
+
+  def add_child( treeNode )
+    return if treeNode.parent == self
+    if not treeNode.parent.nil?
+      treeNode.remove_from_parent()
+    end  
+    treeNode.invalidate
+    treeNode.parent = self
+    @childs << treeNode
+  end
+  
+  def find( name )
+    if self.name == name
+      return self
+    end
+    
+    leaf = @leaves.find { |l| l.name == name }
+    if leaf
+      return leaf
+    end
+    
+    @childs.each {|c| 
+      node = c.find(name)
+      return node if node
+    }
+    nil
+  end
+
+  def accept( visitor )
+    visitor.enter_treeNode( self )
+    @leaves.each{ |l|
+      l.accept( visitor )
+    }
+    @childs.each { |tn|
+      tn.accept( visitor )
+    }
+    visitor.exit_treeNode( self )
+  end
+
+  def to_str( depth = 0 )
+    str = ""
+    (0...depth).step {
+      str << " |-"
+    }
+
+    str << @name
+    str << "\n"
+
+    if ! @leaves.empty?
+      @leaves.each{ |l|
+        (0...depth-1).step {
+          str << " |-"
+        }
+        if @childs.empty?
+          str << " |    "
+        else
+          str << " |  | "
+        end
+        str << l.to_str
+        str << "\n"
+      }
+    end
+
+    @childs.each { |tn|
+      str << tn.to_str( depth + 1 )
+    }
+    str
+  end
+end

data/lib/treevisitor/tree_node_visitor.rb

@@ -0,0 +1,251 @@
+# rubygems
+require 'rubygems'
+require 'abstract'
+
+#
+# Classe astratta per visitare un TreeNode
+#
+class TreeNodeVisitor
+
+  def enter_treeNode( treeNode )
+    not_implemented
+  end
+
+  def exit_treeNode( treeNode )
+    not_implemented
+  end
+
+  def visit_leafNode( leafNode )
+    not_implemented
+  end
+
+end
+
+#
+# Utilizzo della classa astratta DirTreeProcessor
+# per chimare un blocco su tutti i TreeNode
+#
+class BlockTreeNodeVisitor
+  
+  def initialize( &action )
+    @block = action
+  end
+ 
+  def enter_treeNode( treeNode )
+    @block.call( treeNode )
+  end
+ 
+  def exit_treeNode( treeNode )
+  end
+  
+  def visit_leafNode( leafNode )
+    @block.call( leafNode )
+  end
+  
+end
+
+#
+# Utilizzo della classa astratta DirTreeProcessor
+# per stampare i nodi di un TreeNode
+#
+class FlatPrintTreeNodeVisitor < TreeNodeVisitor
+
+  def enter_treeNode( treeNode )
+    puts treeNode.name
+  end
+
+  def exit_treeNode( treeNode )
+  end
+
+  def visit_leafNode( leafNode )
+    puts leafNode.name
+  end
+
+end
+
+
+class PrintTreeNodeVisitor < TreeNodeVisitor
+
+  def initialize( *args )
+    super( *args )
+    @depth = 0
+  end
+
+  def visit_leafNode( leafNode )
+    str = ""
+    (0...@depth-1).step {
+      str << " |-"
+    }
+    str << " |  "
+    puts str + leafNode.name.to_s
+  end
+
+  def enter_treeNode( treeNode )
+
+    str = ""
+    (0...@depth).step {
+      str << " |-"
+    }
+
+    if @depth == 0
+      puts str + treeNode.name.to_s
+    else
+      puts str + treeNode.name.to_s
+    end
+    @depth += 1
+  end
+
+  def exit_treeNode( treeNode )
+    @depth -= 1
+  end
+end
+
+
+#
+#
+#
+class DepthTreeNodeVisitor < TreeNodeVisitor
+
+  attr_reader :depth
+  
+  def initialize
+    super
+    @depth = 0
+  end
+  
+  def enter_treeNode( treeNode )
+    @depth += 1
+  end
+
+  def exit_treeNode( treeNode )
+    @depth -= 1
+  end
+
+  def visit_leafNode( leafNode )
+  end
+
+end
+
+#
+# Esempio
+# Clona un TreeNode
+#
+class CloneTreeNodeVisitor < TreeNodeVisitor
+  
+  attr_reader :clonedRoot
+  
+  def initialize
+    super
+    @clonedRoot = nil
+    @stack = []
+  end
+  
+  def enter_treeNode( treeNode )
+    if @stack.empty?
+      clonedTreeNode = TreeNode.new( treeNode.name )
+      @clonedRoot = clonedTreeNode
+    else
+      clonedTreeNode = TreeNode.new( treeNode.name, @stack.last )
+    end
+    @stack.push( clonedTreeNode )
+  end
+
+  def exit_treeNode( treeNode )
+    @stack.pop
+  end
+
+  def visit_leafNode( leafNode )
+    clonedLeafNode = LeafNode.new( leafNode.name, @stack.last )
+  end
+
+end
+
+#
+# CallbackTreeNodeVisitor
+#
+class CallbackTreeNodeVisitor < TreeNodeVisitor
+  
+  def initialize( root = nil )
+    super()
+    @stack = []
+    @root = root
+    @stack.push( root ) if root
+    @action_enterTreeNode = nil
+    @action_visitLeafNode = nil
+  end
+  
+  def onEnterTreeNode( &action )
+    @action_enterTreeNode = action
+  end
+  
+  def onVisitLeafNode( &action )
+    @action_visitLeafNode = action
+  end
+
+  def enter_treeNode( treeNode )
+    parentNode = if @stack.empty? 
+                   nil
+                 else
+                   @stack.last
+                 end
+    @root = treeNode if @stack.empty?
+    @stack.push( treeNode ) 
+    @action_enterTreeNode.call( treeNode ) if @action_enterTreeNode
+  end
+
+  def exit_treeNode( treeNode )
+    @stack.pop
+  end
+
+  def visit_leafNode( leafNode )
+    parentNode = @stack.last
+    @action_visitLeafNode.call( leafNode ) if @action_visitLeafNode
+  end
+    
+end  
+  
+
+#
+# CallbackTreeNodeVisitor
+#
+class CallbackTreeNodeVisitor2 < TreeNodeVisitor
+  
+  attr_reader :root
+  
+  def initialize( root = nil )
+    super()
+    @stack = []
+    @root = root
+    @stack.push( root ) if root
+  end
+  
+  def onEnterTreeNode( &action )
+    @action_enterTreeNode = action
+  end
+  
+  def onVisitLeafNode( &action )
+    @action_visitLeafNode = action
+  end
+
+  def enter_treeNode( treeNode )
+    newParentNode = if @stack.empty? 
+                      nil
+                    else
+                      @stack.last
+                    end
+    newTreeNode = @action_enterTreeNode.call( treeNode, newParentNode )
+    @root = newTreeNode if @stack.empty?
+    @stack.push( newTreeNode ) 
+  end
+
+  def exit_treeNode( treeNode )
+    @stack.pop
+  end
+
+  def visit_leafNode( leafNode )
+    newParentNode = @stack.last
+    @action_visitLeafNode.call( leafNode, newParentNode )
+  end
+    
+end  
+