gf-treevisitor 0.0.8 → 0.0.10

data/lib/treevisitor/dir_tree_walker.rb

@@ -1,116 +1,116 @@
-require 'treevisitor/visitors/block_tree_node_visitor'
-
-class DirTreeWalker
-
-  def initialize( dirname )
-    @dirname = dirname
-    unless File.directory?( dirname )
-      raise "#{dirname} is not a directory!"
-    end
-
-    @visitor = nil
-
-    #
-    # pattern
-    #
-    @ignore_dir_patterns = []
-    @ignore_file_patterns = []
-
-    @inspect_file_patterns = []
-
-    #
-    # options
-    #
-
-    @visit_leaf = true
-  end
-
-  ##########################################################################
-  # Pattern
-  #
-  def add_ignore_pattern(pattern)
-    @ignore_dir_patterns << pattern
-    @ignore_file_patterns << pattern
-  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
-
-  ##########################################################################
-  # Options
-  
-  attr_accessor :visit_leaf
-
-  ##########################################################################
-
-
-  def ignore_dir?( dirname )
-    include?( @ignore_dir_patterns, File.basename( dirname ) )
-  end
-
-  def ignore_file?( filename )
-    include?( @ignore_file_patterns, File.basename( filename ) )
-  end
-
-  def inspect_file?( filename )
-    return true if @inspect_file_patterns.empty?
-    include?( @inspect_file_patterns, File.basename( filename ) )
-  end
-
-  def run( treeNodeVisitor )
-    @visitor = treeNodeVisitor
-    process_directory( File.expand_path( @dirname ) )
-  end
-
-  private
-
-  def include?(patterns, basename)
-    # return false if the patters.empty?
-    patterns.find{ |pattern|
-      if pattern.respond_to?(:match) # or if pattern.kind_of? Regexp
-        pattern.match( basename )
-      else
-        basename == pattern
-      end
-    }
-  end
-
-  #
-  # recurse on other directories
-  #
-  # def process_directory( parentNode, dirname )
-  def process_directory( dirname )
-    @visitor.enter_treeNode( dirname )
-    # return if ignore_dir?( dirname )
-
-    Dir.entries( dirname ).each { |basename|
-      next if basename == "." or basename == ".."  # ignore always "." and ".."
-      pathname = File.join( dirname, basename )
-
-      if File.directory?( pathname )
-        # directory
-        process_directory( pathname ) unless ignore_dir?( basename )
-      else
-        if @visit_leaf
-          if inspect_file?( basename ) && ! ignore_file?( basename )
-            @visitor.visit_leafNode( pathname )
-          end
-        end
-      end
-    }
-    @visitor.exit_treeNode( dirname )
-  end
-end
+require 'treevisitor/visitors/block_tree_node_visitor'
+
+class DirTreeWalker
+
+  def initialize( dirname )
+    @dirname = dirname
+    unless File.directory?( dirname )
+      raise "#{dirname} is not a directory!"
+    end
+
+    @visitor = nil
+
+    #
+    # pattern
+    #
+    @ignore_dir_patterns = []
+    @ignore_file_patterns = []
+
+    @inspect_file_patterns = []
+
+    #
+    # options
+    #
+
+    @visit_leaf = true
+  end
+
+  ##########################################################################
+  # Pattern
+  #
+  def add_ignore_pattern(pattern)
+    @ignore_dir_patterns << pattern
+    @ignore_file_patterns << pattern
+  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
+
+  ##########################################################################
+  # Options
+  
+  attr_accessor :visit_leaf
+
+  ##########################################################################
+
+
+  def ignore_dir?( dirname )
+    include?( @ignore_dir_patterns, File.basename( dirname ) )
+  end
+
+  def ignore_file?( filename )
+    include?( @ignore_file_patterns, File.basename( filename ) )
+  end
+
+  def inspect_file?( filename )
+    return true if @inspect_file_patterns.empty?
+    include?( @inspect_file_patterns, File.basename( filename ) )
+  end
+
+  def run( treeNodeVisitor )
+    @visitor = treeNodeVisitor
+    process_directory( File.expand_path( @dirname ) )
+  end
+
+  private
+
+  def include?(patterns, basename)
+    # return false if the patters.empty?
+    patterns.find{ |pattern|
+      if pattern.respond_to?(:match) # or if pattern.kind_of? Regexp
+        pattern.match( basename )
+      else
+        basename == pattern
+      end
+    }
+  end
+
+  #
+  # recurse on other directories
+  #
+  # def process_directory( parentNode, dirname )
+  def process_directory( dirname )
+    @visitor.enter_tree_node( dirname )
+    # return if ignore_dir?( dirname )
+
+    Dir.entries( dirname ).each { |basename|
+      next if basename == "." or basename == ".."  # ignore always "." and ".."
+      pathname = File.join( dirname, basename )
+
+      if File.directory?( pathname )
+        # directory
+        process_directory( pathname ) unless ignore_dir?( basename )
+      else
+        if @visit_leaf
+          if inspect_file?( basename ) && ! ignore_file?( basename )
+            @visitor.visit_leaf_node( pathname )
+          end
+        end
+      end
+    }
+    @visitor.exit_tree_node( dirname )
+  end
+end

data/lib/treevisitor/leaf_node.rb

@@ -1,27 +1,31 @@
-# 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
+# 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 root?
+    false
+  end
+
+  def accept( visitor )
+    visitor.visit_leaf_node( self )
+  end
+
+  def to_str
+    name.to_str
+  end
+
+end

data/lib/treevisitor/tree_node.rb

@@ -1,134 +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
+# 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_tree_node( self )
+    @leaves.each{ |l|
+      l.accept( visitor )
+    }
+    @childs.each { |tn|
+      tn.accept( visitor )
+    }
+    visitor.exit_tree_node( 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

@@ -1,31 +1,31 @@
-# 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
-
-
-
-
-
-
-
-
-  
+# rubygems
+require 'rubygems'
+require 'abstract'
+
+#
+# Classe astratta per visitare un TreeNode
+#
+class TreeNodeVisitor
+
+  def enter_tree_node( treeNode )
+    not_implemented
+  end
+
+  def exit_tree_node( treeNode )
+    not_implemented
+  end
+
+  def visit_leaf_node( leafNode )
+    not_implemented
+  end
+
+end
+
+
+
+
+
+
+
+
+  

data/lib/treevisitor/visitors/block_tree_node_visitor.rb

@@ -1,8 +1,7 @@
 require 'treevisitor/tree_node_visitor.rb'
 
 #
-# Utilizzo della classa astratta DirTreeProcessor
-# per chimare un blocco su tutti i TreeNode
+# It call a block when visit a tree_node or leaf_node
 #
 class BlockTreeNodeVisitor < TreeNodeVisitor
 
@@ -10,14 +9,14 @@ class BlockTreeNodeVisitor < TreeNodeVisitor
     @block = action
   end
 
-  def enter_treeNode( treeNode )
+  def enter_tree_node( treeNode )
     @block.call( treeNode )
   end
 
-  def exit_treeNode( treeNode )
+  def exit_tree_node( treeNode )
   end
 
-  def visit_leafNode( leafNode )
+  def visit_leaf_node( leafNode )
     @block.call( leafNode )
   end