gf-tree_visitor 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 gf
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,28 @@
+= ralbum_commmon
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* utilizza la libreria abstract di kwartz
+* gui: dipende da fxruby e/o wxruby
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== Copyright
+
+Copyright (c) 2009 gf. See LICENSE for details.

data/bin/dirtree.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#
+# Piccolo wrapper per richiamare il programma
+# clidirtree
+#
+
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), ".." ) )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+
+require "tree_visitor/cli/cli_dir_tree"
+
+CliDirTree.run
+exit

data/lib/tree_visitor/abs_node.rb

@@ -0,0 +1,116 @@
+# rubygems
+require "rubygems"
+require "abstract"
+
+#
+# Nodo Astratto
+#   Gerarchia delle classi
+#
+#   AbsNode ha un nome, un parent
+#    |      definisce un path
+#    |
+#    |- LeafNode
+#    |
+#    |- TreeNode
+# 
+#
+class AbsNode
+
+  attr_reader :parent
+  attr_reader :name
+  
+  # solo TreeNode puo' scrivere vedi funzione add_leaf
+  attr_accessor :prev
+  attr_accessor :next
+  
+
+  def initialize( name )
+    @parent = nil
+    @name = name
+    @prefix_path = nil
+    invalidate
+  end
+  
+  #
+  # invalidate cached info
+  #
+  def invalidate
+    @path = nil
+    @path_from_root = nil
+    @depth = nil    
+  end
+  
+  def prefix_path
+    if not @parent.nil?
+      raise "Not root!!"
+    end
+    @prefix_path
+  end
+  
+  def prefix_path=( prefix )
+    if not @parent.nil?
+      raise "Not root!!"
+    end
+    if prefix != @prefix_path
+      @prefix_path = prefix
+      invalidate
+    end
+  end
+
+  def root
+    if root?
+      self
+    else
+      parent.root
+    end
+  end
+  
+  def path
+    return @path unless @path.nil?
+    if @parent.nil?
+      if @prefix_path
+        @path = @prefix_path + @name
+      else
+        @path = @name
+      end
+    else
+      @path = File.join( @parent.path, @name )
+    end
+    @path
+  end
+  
+  def path_from_root
+    return @path_from_root unless @path_from_root.nil?
+    if @parent.nil?
+      if @prefix_path
+        @path_from_root = @prefix_path
+      else
+        @path_from_root = ""
+      end
+    else
+      @path_from_root = File.join( @parent.path_from_root, @name )
+    end
+    @path_from_root
+  end
+
+  def depth
+    return @depth unless @depth.nil?
+    if @parent.nil?
+      @depth = 1
+    else
+      @depth = @parent.depth + 1
+    end
+    @depth
+  end
+  
+  def accept( visitor )
+    not_implemented
+  end
+
+  protected
+
+  def parent=( parent )
+    @parent = parent
+  end
+
+end

data/lib/tree_visitor/build_dir_tree_visitor.rb

@@ -0,0 +1,58 @@
+# common
+require 'tree_visitor/tree_node'
+require 'tree_visitor/dir_tree_walker'
+require 'tree_visitor/tree_node_visitor'
+
+#
+# costruisce una albero TreeNode a partire dalla struttura
+# della directory, simile a clona
+# Clona un TreeNode
+#
+class BuildDirTreeVisitor < TreeNodeVisitor
+  
+  attr_reader :root
+  
+  def initialize
+    super
+    @root = nil
+    @stack = []
+  end
+  
+  def enter_treeNode( pathname )
+    if @stack.empty?
+      treeNode = TreeNode.new( File.basename( pathname ) )
+      @root = treeNode
+    else
+      treeNode = TreeNode.new( File.basename( pathname ), @stack.last )
+    end
+    @stack.push( treeNode )
+  end
+
+  def exit_treeNode( pathname )
+    @stack.pop
+  end
+
+  def visit_leafNode( pathname )
+    leafNode = LeafNode.new( File.basename(pathname), @stack.last )
+  end
+
+end
+
+#
+# Utilizzo della classa astratta DirTreeProcessor
+# per stampare i nodi di un TreeNode
+#
+class PrintDirTreeVisitor < TreeNodeVisitor
+
+  def enter_treeNode( pathname )
+    puts pathname
+  end
+
+  def exit_treeNode( treeNode )
+  end
+
+  def visit_leafNode( pathname )
+    puts pathname
+  end
+
+end

data/lib/tree_visitor/cli/cli_dir_tree.rb

@@ -0,0 +1,84 @@
+# stdlib
+require 'optparse'
+
+# common
+require 'tree_visitor/dir_tree_walker'
+require 'tree_visitor/build_dir_tree_visitor'
+
+#
+#
+#
+class CliDirTree
+
+  def self.run
+    self.new.parse_args( ARGV )
+  end
+
+  def parse_args( argv )
+
+    options = { :verbose => true, :force => false, :algo => 'build' }
+
+    opts = OptionParser.new
+    opts.banner = "Usage: example.rb [options]"
+    
+    opts.separator ""
+    opts.separator "programma per testare la classe DirProcessor"
+    opts.separator "Inserire il nome della directory da cui costuire il tree"
+    
+    opts.separator ""
+    opts.separator "opzioni: "
+    
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      options[:verbose] = v
+    end
+
+    opts.on("-q", "--quiet", "quiet mode as --no-verbose") do |v|
+      options[:verbose] = false
+    end
+    
+    opts.on("-h", "--help", "Show this message") do
+      puts opts
+      exit
+    end
+
+
+    algos = %w[build visit]
+    algo_aliases = { "b" => "build", "v" => "visit" }
+
+    algo_list = (algo_aliases.keys + algos).join(',')
+    opts.on("-a", "--algo ALGO", algos, algo_aliases, "Select algo","  (#{algo_list})") do |algo|
+      options[:algo] = algo
+    end
+
+    rest = opts.parse(argv)
+
+    # p options
+    # p ARGV
+
+    if rest.length < 1
+      puts opts
+      return 1
+    end
+
+    dirname = rest[0]
+    dirname = File.expand_path( dirname )
+
+    puts "reading : #{dirname}"
+
+    dtw = DirTreeWalker.new( dirname )
+    dtw.add_ignore_dir( ".svn" )
+    dtw.add_ignore_dir( "catalog_data" )
+
+    case options[:algo]
+    when 'build'
+      visitor = BuildDirTreeVisitor.new
+      dtw.run( visitor )
+      puts visitor.root.to_str
+    when 'visit'  
+      visitor = PrintDirTreeVisitor.new
+      dtw.run( visitor )
+    end
+
+  end
+
+end

data/lib/tree_visitor/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/tree_visitor/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/tree_visitor/leaf_node.rb

@@ -0,0 +1,27 @@
+# common
+require "tree_visitor/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/tree_visitor/tree_node.rb

@@ -0,0 +1,134 @@
+# common
+require 'tree_visitor/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/tree_visitor/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  
+  

data/lib/tree_visitor/utility/md5.rb

@@ -0,0 +1,17 @@
+# stdlib
+require 'md5'
+
+#
+# calcola md5 di file grandi, copiata da usenet
+#
+class MD5
+  def self.file(file)
+    File.open(file, "rb") do |f|
+      res = self.new
+      while (data = f.read(4096))
+        res << data
+      end
+      res
+    end
+  end
+end

data/lib/tree_visitor/utility/numeric.rb

@@ -0,0 +1,17 @@
+class Numeric
+  #
+  # ritorna una stringa con le migliaia serparate da <separator>
+  # es.: 100000 -> 1.000.000
+  #
+  #
+  # copiata da http://wiki.rubygarden.org/Ruby/page/show/FixNumFormat
+  #
+  def with_separator( separator = ',', length = 3 )
+    splitter = Regexp.compile "(\\d{#{length}})"
+    before, after = self.to_s.split('.')
+    before = before.reverse.gsub splitter, '\1' + separator
+    str = "#{ before.chomp( separator ).reverse }"
+    str += ".#{ after }" if after
+    return str
+  end
+end

data/lib/tree_visitor/visitor/print_node_visitor2.rb

@@ -0,0 +1,35 @@
+class PrintTreeNodeVisitor2 < TreeNodeVisitor
+
+  def initialize( *args )
+    super( *args )
+    @depth = 0
+  end
+
+  def visit_leafNode( leafNode )
+    str = ""
+    (0...@depth-1).step {
+      str << " |-"
+    }
+    str << " |  "
+    puts str + leafNode.to_s
+  end
+
+  def enter_treeNode( treeNode )
+
+    str = ""
+    (0...@depth).step {
+      str << " |-"
+    }
+
+    if @depth == 0
+      puts str + treeNode.to_s
+    else
+      puts str + treeNode.to_s
+    end
+    @depth += 1
+  end
+
+  def exit_treeNode( treeNode )
+    @depth -= 1
+  end
+end

data/lib/tree_visitor.rb

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

data/test/tree_visitor/tc_dir_processor.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", ".." ) )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+$:.unshift( File.join($COMMON_HOME, "test" ) )
+
+$TEST_DATA = File.join( $COMMON_HOME, "test", "tree_visitor", "test_data" )
+
+require 'tree_visitor/dir_processor'
+
+class TCDirProcessor < Test::Unit::TestCase
+  def test_simple
+    dp = DirProcessor.new($TEST_DATA) { |f| puts f }
+    dp.run
+  end
+end

data/test/tree_visitor/tc_dir_tree_walker.rb

@@ -0,0 +1,37 @@
+# stdlib
+require 'test/unit'
+
+# common
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", ".." ) )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+$:.unshift( File.join($COMMON_HOME, "test" ) )
+$TEST_DATA = File.join( $COMMON_HOME, "test", "tree_visitor", "test_data" )
+
+require 'tree_visitor/dir_tree_walker.rb'
+require 'tree_visitor/tree_node_visitor.rb'
+
+class TCDirTreeWalker < Test::Unit::TestCase
+
+  def test_simple  
+    dir_tree_walker = DirTreeWalker.new( $TEST_DATA )
+    dir_tree_walker.add_ignore_dir( ".svn" )
+
+    accumulator = []
+    visitor = BlockTreeNodeVisitor.new { |pathname| accumulator << File.basename( pathname ) }
+    dir_tree_walker.run( visitor )
+    assert_equal( 7, accumulator.length )
+    assert_equal( %w{ test_data dir.1 dir.1.2 file.1.2.1 file.1.1 dir.2 file.2.1 }, accumulator )
+  end
+
+  def test_ignore_dir
+    dtp = DirTreeWalker.new( "." )
+
+    dtp.add_ignore_dir(".xvpics")
+    dtp.add_ignore_dir(".thumbnails")
+    dtp.add_ignore_dir("catalog_data")
+
+    assert( dtp.ignore_dir?( ".thumbnails" ) )
+    assert( ! dtp.ignore_dir?( "pippo" ) )
+  end
+
+end

data/test/tree_visitor/tc_tree_node.rb

@@ -0,0 +1,135 @@
+# stdlib
+require 'test/unit'
+
+# common
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", ".." ) )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+$:.unshift( File.join($COMMON_HOME, "test" ) )
+
+require 'tree_visitor/tree_node.rb'
+
+class TCTreeNode < Test::Unit::TestCase
+
+  def test_simple_build
+    ta = TreeNode.new( "a" )
+    assert( ta.root? )
+    ln1 = LeafNode.new("1", ta)
+    assert_equal( ta, ln1.parent )
+    ln2 = LeafNode.new("2", ta)
+    tb = TreeNode.new( "b", ta )
+    ln3 = LeafNode.new( "3", tb )
+    assert_equal( tb, ln3.parent )
+    
+    # test depth
+    assert_equal( 2, tb.depth )
+    assert_equal( 3, ln3.depth )
+    
+    # test nr_nodes
+    assert_equal( 1, tb.nr_nodes )
+    assert_equal( 4, ta.nr_nodes )
+
+    # puts ta.to_str
+  end
+
+  def test_add_methods
+    ta = TreeNode.new( "a" )
+    assert( ta.root? )
+    
+    ln1 = LeafNode.new("1")
+    ta.add_leaf( ln1 )
+    assert_equal( ta, ln1.parent )
+
+    ln2 = LeafNode.new("2", ta)
+    ta.add_leaf( ln2 )
+
+    tb = TreeNode.new( "b", ta )
+    ln3 = LeafNode.new( "3", tb )
+    tb.add_leaf( ln3 )
+    assert_equal( tb, ln3.parent )
+
+    ta.add_child( tb )
+    # puts ta.to_str
+  end
+  
+  def test_next_prev
+    ta = TreeNode.new( "a" )
+    
+    ln1 = LeafNode.new("1", ta)
+    assert_nil( ln1.next )
+    assert_nil( ln1.prev )
+    
+    ln2 = LeafNode.new("2", ta)
+    assert_equal( ln1, ln2.prev )
+    assert_nil( ln2.next )
+    
+    ln3 = LeafNode.new("3", ta)
+    assert_equal( ln3, ln2.next )
+  end
+  
+  def test_nr_methods
+    ta = TreeNode.new( "a" )
+      ln1 = LeafNode.new("1", ta)
+      ln2 = LeafNode.new("2", ta)
+      tb = TreeNode.new( "b", ta )
+        ln3 = LeafNode.new( "3", tb )
+    
+    assert_equal( 4, ta.nr_nodes )
+    assert_equal( 3, ta.nr_leaves )
+    assert_equal( 1, ta.nr_childs )
+    
+    assert_equal( 1, tb.nr_nodes )
+    assert_equal( 1, tb.nr_leaves )
+    assert_equal( 0, tb.nr_childs )
+  end
+  
+  def test_prefix_path
+    ta = TreeNode.new( "a" )
+      ln1 = LeafNode.new("1", ta)
+      ln2 = LeafNode.new("2", ta)
+      tb = TreeNode.new( "b", ta )
+        ln3 = LeafNode.new( "3", tb )
+
+    assert_equal( "a",   ta.path  ) 
+    assert_equal( "a/b", tb.path )
+    
+    ta.prefix_path= "<root>/"
+    
+    assert_equal( "<root>/a",   ta.path  ) 
+    assert_equal( "<root>/a/b", tb.path )
+  end
+
+  def test_invalidate
+    ta = TreeNode.new( "a" )
+      ln1 = LeafNode.new("1", ta)
+      ln2 = LeafNode.new("2", ta)
+      tb = TreeNode.new( "b", ta )
+        ln3 = LeafNode.new( "3", tb )
+        
+    #@path = nil
+    #@path_from_root = nil
+    #@depth = nil    
+
+    
+    assert_equal( "a/b", tb.path )
+    assert_equal( "/b",  tb.path_from_root )
+    assert_equal( 2, tb.depth )
+    
+    r = TreeNode.new( "r" )
+    r.add_child( ta )
+    assert_equal( "r/a/b", tb.path )
+    assert_equal( "/a/b", tb.path_from_root )
+    assert_equal( 3, tb.depth )
+  end
+  
+  def test_find
+    ta = TreeNode.new( "a" )
+      ln1 = LeafNode.new("1", ta)
+      ln2 = LeafNode.new("2", ta)
+      tb = TreeNode.new( "b", ta )
+        ln3 = LeafNode.new( "3", tb )
+
+    assert_equal(ln3, ta.find( "3"))
+    assert_equal(tb, ta.find( "b"))
+    assert_nil( ta.find("not existent"))
+  end
+end

data/test/tree_visitor/tc_tree_node_visitor.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", ".." ) )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+$:.unshift( File.join($COMMON_HOME, "test" ) )
+
+require 'tree_visitor/tree_node.rb'
+require 'tree_visitor/tree_node_visitor.rb'
+
+class TCTreeNodeVisitor < Test::Unit::TestCase
+
+  def setup
+    ta = TreeNode.new( "a", nil )
+    LeafNode.new("1", ta )
+    LeafNode.new("2", ta )
+    
+    tb = TreeNode.new( "b", ta )
+    LeafNode.new( "3", tb ) 
+    
+    @tree = ta
+  end
+
+  def test_blocktreenodevisitor
+    accumulator = []
+    visitor = BlockTreeNodeVisitor.new { |node| accumulator << node.name}
+    @tree.accept( visitor )
+    assert_equal( 5, accumulator.length )
+    assert_equal( %w{ a 1 2 b 3 }, accumulator )
+  end
+  
+  def test_depthtreenodevisitor
+    visitor = DepthTreeNodeVisitor.new
+    @tree.accept( visitor )
+    assert_equal( 0, visitor.depth )
+    
+    visitor = CloneTreeNodeVisitor.new
+    @tree.accept( visitor )
+    assert_equal(@tree.nr_nodes, visitor.clonedRoot.nr_nodes )
+  end
+  
+  def test_callback_tree_node_visitor
+    accumulator = []
+    visitor = CallbackTreeNodeVisitor.new
+    visitor.onEnterTreeNode{ |treeNode| accumulator << treeNode.name }
+    visitor.onVisitLeafNode{ |leafNode| accumulator << leafNode.name }
+    @tree.accept( visitor )
+    assert_equal( 5, accumulator.length )
+    assert_equal( %w{ a 1 2 b 3 }, accumulator )
+  end
+  
+  def test_callback_tree_node_visitor2
+    visitor = CallbackTreeNodeVisitor2.new
+    visitor.onEnterTreeNode{ |treeNode, newParentNode| 
+      TreeNode.new("n" + treeNode.name, newParentNode) 
+    }
+    visitor.onVisitLeafNode{ |leafNode, newParentNode| 
+      LeafNode.new( "n" + leafNode.name, newParentNode )
+    }
+    @tree.accept( visitor )
+    newRoot = visitor.root
+    assert_equal( "n" + @tree.name, newRoot.name)
+    
+    accumulator = []
+    visitor = BlockTreeNodeVisitor.new { |node| accumulator << node.name}
+    newRoot.accept( visitor )
+    assert_equal( 5, accumulator.length )
+    assert_equal( %w{ na n1 n2 nb n3 }, accumulator )
+  end
+
+end

data/test/tree_visitor/utility/tc_md5.rb

@@ -0,0 +1,20 @@
+# stdlib
+require 'test/unit'
+
+# common
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", "..", ".." ) )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+$:.unshift( File.join($COMMON_HOME, "test" ) )
+$TEST_FILE = File.join( $COMMON_HOME, "lib", "tree_visitor.rb" )
+
+
+require 'tree_visitor/utility/md5.rb'
+
+class TCMD5 < Test::Unit::TestCase
+
+  def test_simple_build
+    file_name = File.join( $TEST_FILE )
+    MD5.file( file_name )
+  end
+
+end

data/test/tree_visitor/utility/tc_numeric.rb

@@ -0,0 +1,21 @@
+# stdlib
+require 'test/unit'
+
+# common
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", "..", ".." ) )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+$:.unshift( File.join($COMMON_HOME, "test" ) )
+$TEST_FILE = File.join( $COMMON_HOME, "lib", "tree_visitor.rb" )
+
+
+require 'tree_visitor/utility/numeric.rb'
+
+class TCNumeric < Test::Unit::TestCase
+
+  def test_simple
+    assert_equal "10", 10.with_separator
+    assert_equal "10.0", 10.0.with_separator
+    assert_equal "1,000,000", 1000000.with_separator
+  end
+
+end

data/test/ts_tree_visitor.rb

@@ -0,0 +1,16 @@
+# stdlib
+require "test/unit"
+
+# common
+$COMMON_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..") )
+$:.unshift( File.join($COMMON_HOME, "lib" ) )
+$:.unshift( File.join($COMMON_HOME, "test" ) )
+
+require "tree_visitor"
+
+require "tree_visitor/utility/tc_md5"
+
+require "tree_visitor/tc_dir_processor"
+require "tree_visitor/tc_dir_tree_walker"
+require "tree_visitor/tc_tree_node"
+require "tree_visitor/tc_tree_node_visitor"

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: gf-tree_visitor
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- gf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-22 00:00:00 -07:00
+default_executable: dirtree.rb
+dependencies: []
+
+description: 
+email: giovanni.ferro@gmail.com
+executables: 
+- dirtree.rb
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- lib/tree_visitor.rb
+- lib/tree_visitor/abs_node.rb
+- lib/tree_visitor/build_dir_tree_visitor.rb
+- lib/tree_visitor/cli/cli_dir_tree.rb
+- lib/tree_visitor/dir_processor.rb
+- lib/tree_visitor/dir_tree_walker.rb
+- lib/tree_visitor/leaf_node.rb
+- lib/tree_visitor/tree_node.rb
+- lib/tree_visitor/tree_node_visitor.rb
+- lib/tree_visitor/utility/md5.rb
+- lib/tree_visitor/utility/numeric.rb
+- lib/tree_visitor/visitor/print_node_visitor2.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/gf/tree_visitor
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- test/ts_tree_visitor.rb
+- test/tree_visitor/tc_dir_processor.rb
+- test/tree_visitor/tc_dir_tree_walker.rb
+- test/tree_visitor/tc_tree_node.rb
+- test/tree_visitor/tc_tree_node_visitor.rb
+- test/tree_visitor/utility/tc_md5.rb
+- test/tree_visitor/utility/tc_numeric.rb