treevisitor 0.1.5 → 0.1.6

data/examples/protovis/treevisitor.js

@@ -0,0 +1,33 @@
+var treevisitor = {
+  "lib": {
+    "tree_visitor.rb": 45,
+    "treevisitor": {
+      "abs_node.rb": 2858,
+      "basic_tree_node_visitor.rb": 578,
+      "cli": {
+        "cli_tree.rb": 2760
+      },
+      "directory_walker.rb": 5049,
+      "leaf_node.rb": 526,
+      "tree_node.rb": 5665,
+      "tree_node_visitor.rb": 1263,
+      "util": {
+        "dir_processor.rb": 928
+      },
+      "visitors": {
+        "block_tree_node_visitor.rb": 386,
+        "build_dir_tree_visitor.rb": 1167,
+        "callback_tree_node_visitor.rb": 1029,
+        "callback_tree_node_visitor2.rb": 1652,
+        "clone_tree_node_visitor.rb": 837,
+        "depth_tree_node_visitor.rb": 427,
+        "directory_to_hash_visitor.rb": 639,
+        "flat_print_tree_node_visitors.rb": 341,
+        "print_dir_tree_visitor.rb": 387,
+        "print_tree_node_visitor.rb": 707
+      }
+    },
+    "treevisitor.rb": 976,
+    "treevisitor_cli.rb": 87
+  }
+};

data/lib/treevisitor/basic_tree_node_visitor.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+  #
+  # Callback methods used to visit a tree
+  # Are empty so it is possible to define only a subset when deriving subclass
+  #
+  class BasicTreeNodeVisitor
+
+    #
+    # called on tree node at start of the visit i.e. we start to visit the subtree
+    #
+    def enter_tree_node( tree_node )
+    end
+
+    #
+    # called on tree node at end of the visit i.e. oll subtree are visited
+    #
+    def exit_tree_node( tree_node )
+    end
+
+    #
+    # called when visit leaf node
+    #
+    def visit_leaf_node( leaf_node )
+    end
+
+  end
+
+end

data/lib/treevisitor/cli/cli_tree.rb

@@ -6,23 +6,22 @@ module TreeVisitor
   class CliTree
 
     def self.run
-      self.new.parse_args( ARGV )
+      self.new.parse_args(ARGV)
     end
 
-    def parse_args( argv )
+    def parse_args(argv)
 
-      options = { :verbose => true, :force => false, :algo => 'build' }
+      options     = {:verbose => true, :force => false, :algo => 'build-dir'}
 
-      opts = OptionParser.new
+      opts        = OptionParser.new
       opts.banner = "Usage: tree.rb [options] [directory]"
-    
-      opts.separator ""
       opts.separator "list contents of directories in a tree-like format"
-      opts.separator "this is a clone of tree unix command written in ruby"
-    
+      opts.separator "this is a almost :-) a clone of tree unix command written in ruby"
+      opts.separator "Code https://github.com/tokiro/treevisitor. Feedback to tokiro.oyama@gmail.com"
+
       opts.separator ""
       opts.separator "options: "
-    
+
       opts.on("-h", "--help", "Show this message") do
         puts opts
         return 0
@@ -48,49 +47,58 @@ module TreeVisitor
       opts.on("-q", "--quiet", "quiet mode as --no-verbose") do |v|
         options[:verbose] = false
       end
-    
-      algos = %w[build visit]
-      algo_aliases = { "b" => "build", "v" => "visit" }
 
-      algo_list = (algo_aliases.keys + algos).join(',')
-      opts.on("--algo ALGO", algos, algo_aliases, "Select algo","  (#{algo_list})") do |algo|
+      algos        = %w[build-dir print-dir json yaml]
+      algo_aliases = {"b" => "build-dir", "v" => "print-dir", "j" => "json", "y" => "yaml"}
+
+      algo_list    = (algo_aliases.keys + algos).join(',')
+      opts.on("-f", "--format ALGO", algos, algo_aliases, "select an algo", "  (#{algo_list})") do |algo|
         options[:algo] = algo
       end
 
-      rest = opts.parse(argv)
-
-      # p options
-      # p ARGV
+      begin
+        rest = opts.parse(argv)
+      rescue OptionParser::InvalidOption => e
+        $stderr.puts e.to_s
+        $stderr.puts "try -h for help"
+        return false
+      end
 
       if rest.length < 1
-        puts opts
-        return 1
+        dirname = Dir.pwd
+      else
+        dirname = rest[0]
       end
 
-      dirname = rest[0]
-      dirname = File.expand_path( dirname )
+      dirname = File.expand_path(dirname)
 
-      # puts "reading : #{dirname}"
-
-      dtw = DirTreeWalker.new( dirname )
+      dtw     = DirTreeWalker.new(dirname)
       unless options[:all_files]
-        # TODO: la regex e' corretta ed un file che inizia con ".."??
         dtw.ignore(/^\.[^.]+/) # ignore all file starting with "."
       end
 
       dtw.visit_file = !options[:only_directories]
 
       case options[:algo]
-      when 'build'
-        visitor = BuildDirTreeVisitor.new
-        dtw.run( visitor )
-        puts visitor.root.to_str
-        puts
-        puts "#{visitor.nr_directories} directories, #{visitor.nr_files} files"
-      when 'visit'
-        visitor = PrintDirTreeVisitor.new
-        dtw.run( visitor )
+        when 'build-dir'
+          visitor = BuildDirTreeVisitor.new
+          dtw.run(visitor)
+          puts visitor.root.to_str
+          puts
+          puts "#{visitor.nr_directories} directories, #{visitor.nr_files} files"
+        when 'print-dir'
+          visitor = PrintDirTreeVisitor.new
+          dtw.run(visitor)
+        when 'json'
+          root = dtw.run(DirectoryToHashVisitor.new(dirname)).root
+          puts JSON.pretty_generate(root)
+        when 'yaml'
+          root = dtw.run(DirectoryToHashVisitor.new(dirname)).root
+          puts root.to_yaml
+        else
+          puts "unknown algo #{options[:algo]} specified"
       end
+
       0
     end
 

data/lib/treevisitor/directory_walker.rb

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+
+  #
+  # Visit a file system directory
+  #
+  class DirTreeWalker
+
+    # Build a tree walker.
+    # Visit a director starting from dirname
+    # if dirname is missing, must be supplied when invoking run
+    #
+    # @yield [a, b, c] TreeNodeVisitor
+    # @yieldparam [optional, types, ...] argname description
+    # @yieldreturn [optional, types, ...] description
+    #
+    # @overload initialize(dirname)
+    #   @param [String] dirname the root of the tree (top level directory)
+    # 
+    # @overload initialize(dirname,options)
+    #   @param [Hash] options
+    #   @option options [String,Regex, Array<String,Regexp>] :ignore list of ignore pattern
+    #
+    #
+    # @example Print the contents of tmp directory
+    #   DirTreeWalker.new("/tmp") do
+    #     on_visit_leaf_node { |pathname| puts pathname }
+    #   end.run
+    #
+    def initialize(dirname = nil, options = nil)
+      #
+      # arg detection
+      #
+      if dirname and dirname.respond_to?(:key?)
+        options = dirname
+        dirname = nil
+      end
+
+      if dirname
+        @dirname = dirname
+        unless File.directory?(dirname)
+          raise "#{dirname} is not a directory!"
+        end
+      end
+
+      @visitor              = nil
+
+      #
+      # pattern
+      #
+      @ignore_dir_patterns  = []
+      @ignore_file_patterns = []
+      @match_file_patterns  = []
+
+      if options and options[:ignore]
+        unless options[:ignore].respond_to?(:at)
+          options[:ignore] = [options[:ignore]]
+        end
+        options[:ignore].each { |p| ignore(p) }
+      end
+
+      #
+      # options
+      #
+      @visit_file = true
+    end
+
+    ##########################################################################
+    # Pattern
+
+    #
+    # Ignore a node (leaf/Tree) matching pattern
+    # @param [RegEx] pattern
+    #
+    def ignore(pattern)
+      @ignore_dir_patterns << pattern
+      @ignore_file_patterns << pattern
+      self
+    end
+
+    #
+    # Ignore a directory (Tree) matching pattern
+    # @param [RegEx] pattern
+    #
+    def ignore_dir(pattern)
+      @ignore_dir_patterns << pattern
+      self
+    end
+
+    #
+    # Ignore a file (Leaf) matching pattern
+    # @param [RegEx] pattern
+    #
+    def ignore_file(pattern)
+      @ignore_file_patterns << pattern
+      self
+    end
+
+    #
+    # Just the opposite of ignore
+    # directory/file matching pattern will be visited
+    #
+    # @param [RegEx] pattern
+    #
+    def match(pattern)
+      @match_file_patterns << pattern
+      self
+    end
+
+    ##########################################################################
+    # Options
+
+    #
+    # it is true to visit file
+    #
+    attr_accessor :visit_file
+
+    ##########################################################################
+
+    #
+    # Test directory ignore pattern
+    #
+    # @param [String] directory name
+    # @return [boolean] if dirname match almost one pattern
+    #
+    def ignore_dir?(dirname)
+      _include?(@ignore_dir_patterns, File.basename(dirname))
+    end
+
+    #
+    # Test file ignore pattern
+    #
+    # @param [String] file name
+    # @return [boolean] if filename match almost one pattern
+    #
+    def ignore_file?(filename)
+      _include?(@ignore_file_patterns, File.basename(filename))
+    end
+
+    #
+    # Test common ignore pattern
+    #
+    # @param [String] file name
+    # @return [boolean] if filename match almost one pattern
+    #
+    def match?(filename)
+      return true if @match_file_patterns.empty?
+      _include?(@match_file_patterns, File.basename(filename))
+    end
+
+    #
+    # Run the visitor through the directory tree
+    #
+    # @overload run
+    #
+    # @overload run(dirname)
+    #   @param [String] dirname
+    #   @yield define TreeNodeVisitor
+    #
+    # @overload run(tree_node_visitor)
+    #   @param [TreeNodeVisitor]
+    #   @yield define TreeNodeVisitor
+    #
+    # @overload run(dirname, tree_node_visitor)
+    #   @param [String] dirname
+    #   @param [TreeNodeVisitor]
+    #   @yield define TreeNodeVisitor
+    #
+    # @return [TreeNodeVisitor] the visitor
+    #
+    # @example Print the contents of tmp directory
+    #   w = DirTreeWalker.new
+    #   w.run("/tmp") do
+    #     on_visit_leaf_node { |pathname| puts pathname }
+    #   end.run
+    #
+    def run(dirname = nil, tree_node_visitor = nil, &block)
+
+      #
+      # args detection
+      #
+      if dirname and dirname.respond_to?(:enter_tree_node)
+        tree_node_visitor = dirname
+        dirname           = nil
+      end
+
+      #
+      # check dirname
+      #
+      if @dirname.nil? and dirname.nil?
+        raise "missing starting directory"
+      end
+      @dirname = dirname if dirname
+
+      #
+      # check visitor
+      #
+      if tree_node_visitor and block
+        raise "cannot use block and parameter together"
+      end
+
+      if tree_node_visitor
+        @visitor = tree_node_visitor
+      end
+
+      if block
+        @visitor = TreeNodeVisitor.new(&block)
+      end
+
+      unless @visitor
+        raise "missing visitor"
+      end
+
+      #
+      # finally starts to process
+      #
+      process_directory(File.expand_path(@dirname))
+      @visitor
+    end
+
+    private
+
+    def _include?(patterns, basename)
+      # return false if the patters.empty?
+      patterns.find { |pattern|
+        if pattern.kind_of? Regexp
+          pattern.match(basename)
+        else
+          basename == pattern
+        end
+      }
+    end
+
+    #
+    # recurse on other directories
+    #
+    def process_directory(dirname)
+      @visitor.enter_tree_node(dirname)
+      # return if ignore_dir?( dirname )
+
+      begin
+        Dir.entries(dirname).sort.each { |basename|
+          next if basename == "." or basename == ".." # ignore always "." and ".."
+          pathname = File.join(dirname, basename)
+
+          if File.directory?(pathname)
+            process_directory(pathname) unless ignore_dir?(basename)
+          else
+            if !!@visit_file && match?(basename) && !ignore_file?(basename)
+              @visitor.visit_leaf_node(pathname)
+            end
+          end
+        }
+      rescue Errno::EACCES => e
+        $stderr.puts e
+      end
+      @visitor.exit_tree_node(dirname)
+    end
+  end
+end

data/lib/treevisitor/tree_node_visitor.rb

@@ -1,27 +1,55 @@
 # -*- coding: utf-8 -*-
 module TreeVisitor
   #
-  # Callback methods used to visit a tree
-  # Are empty so it is possible to define only a subset
+  # More complex TreeNodeVisitor
   #
   class TreeNodeVisitor
 
+    def initialize(&block)
+      @on_enter_tree_node_blocks = []
+      @on_exit_tree_node_blocks = []
+      @on_visit_leaf_node_blocks = []
+      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_tree_node( tree_node )
+    def enter_tree_node(tree_node)
+      @on_enter_tree_node_blocks.each{ |b| b.call(tree_node) }
     end
 
     #
     # called on tree node at end of the visit i.e. oll subtree are visited
     #
-    def exit_tree_node( tree_node )
+    def exit_tree_node(tree_node)
+      @on_exit_tree_node_blocks.each{ |b| b.call(tree_node) }
     end
 
     #
     # called when visit leaf node
     #
-    def visit_leaf_node( leaf_node )
+    def visit_leaf_node(leaf_node)
+      @on_visit_leaf_node_blocks.each{ |b| b.call(leaf_node) }
+    end
+
+    private
+
+    def on_enter_tree_node(&block)
+      raise "block missing" unless block
+      @on_enter_tree_node_blocks << block
+    end
+
+    def on_exit_tree_node(&block)
+      raise "block missing" unless block
+      @on_exit_tree_node_blocks << block
+    end
+
+    def on_visit_leaf_node(&block)
+      raise "block missing" unless block
+      @on_visit_leaf_node_blocks << block
     end
 
   end

data/lib/treevisitor/visitors/block_tree_node_visitor.rb

@@ -3,7 +3,7 @@ module TreeVisitor
   #
   # It calls a block when visit a tree_node or leaf_node
   #
-  class BlockTreeNodeVisitor < TreeNodeVisitor
+  class BlockTreeNodeVisitor < BasicTreeNodeVisitor
 
     def initialize( &action )
       @block = action

data/lib/treevisitor/visitors/build_dir_tree_visitor.rb

@@ -4,7 +4,7 @@ module TreeVisitor
   # Builds a TreeNode from a filesystem directory
   # It similar to CloneTreeNodeVisitor
   #
-  class BuildDirTreeVisitor < TreeNodeVisitor
+  class BuildDirTreeVisitor < BasicTreeNodeVisitor
   
     attr_reader :root
 

data/lib/treevisitor/visitors/callback_tree_node_visitor.rb

@@ -5,10 +5,9 @@ module TreeVisitor
   # The block are defined from on_enter_X methods
   # The blocks take as argument only the node
   #
-  class CallbackTreeNodeVisitor < TreeNodeVisitor
+  class CallbackTreeNodeVisitor < BasicTreeNodeVisitor
 
     def initialize
-      super()
       @root = nil
       @stack = []
       @action_enter_tree_node = nil

data/lib/treevisitor/visitors/callback_tree_node_visitor2.rb

@@ -5,7 +5,7 @@ module TreeVisitor
   # The block are defined from on_enter_X methods
   # The blocks take as argument the node and the parent_node
   #
-  class CallbackTreeNodeVisitor2 < TreeNodeVisitor
+  class CallbackTreeNodeVisitor2 < BasicTreeNodeVisitor
 
     attr_reader :root
 

data/lib/treevisitor/visitors/clone_tree_node_visitor.rb

@@ -4,7 +4,7 @@ module TreeVisitor
   # Clone a tree_node, nodes are duplicated.
   # Node content are not duplicated!
   #
-  class CloneTreeNodeVisitor < TreeNodeVisitor
+  class CloneTreeNodeVisitor < BasicTreeNodeVisitor
 
     #
     # Contains the cloned tree node after the visit

data/lib/treevisitor/visitors/depth_tree_node_visitor.rb

@@ -3,7 +3,7 @@ module TreeVisitor
   #
   # Simple visitor: show how calculate the depth of a tree
   #
-  class DepthTreeNodeVisitor < TreeNodeVisitor
+  class DepthTreeNodeVisitor < BasicTreeNodeVisitor
 
     attr_reader :depth
 

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_tree_node(pathname)
+      subnode                        = {}
+      @node[File.basename(pathname)] = subnode
+      @stack.push(@node)
+      @node = subnode
+    end
+
+    def exit_tree_node(pathname)
+      @node = @stack.pop
+    end
+
+    def visit_leaf_node(pathname)
+      @node[File.basename(pathname)] = File.stat(pathname).size
+    end
+
+  end
+end

data/lib/treevisitor/visitors/flat_print_tree_node_visitors.rb

@@ -3,7 +3,7 @@ module TreeVisitor
   #
   # Print for every node the name
   #
-  class FlatPrintTreeNodeVisitor < TreeNodeVisitor
+  class FlatPrintTreeNodeVisitor < BasicTreeNodeVisitor
 
     def enter_tree_node( tree_node )
       puts tree_node.name

data/lib/treevisitor/visitors/print_dir_tree_visitor.rb

@@ -4,7 +4,7 @@ module TreeVisitor
   # Visitor for DirTreeWalker
   # Prints the node at enter
   # TODO: join this con PrintTreeNodeVisitor
-  class PrintDirTreeVisitor < TreeNodeVisitor
+  class PrintDirTreeVisitor < BasicTreeNodeVisitor
 
     def enter_tree_node( pathname )
       puts pathname

data/lib/treevisitor/visitors/print_tree_node_visitor.rb

@@ -3,7 +3,7 @@ module TreeVisitor
   #
   # Prints TreeNode names indenting according to depth
   #
-  class PrintTreeNodeVisitor < TreeNodeVisitor
+  class PrintTreeNodeVisitor < BasicTreeNodeVisitor
 
     def initialize
       @depth = 0

data/lib/treevisitor.rb

@@ -1,10 +1,21 @@
 # -*- coding: utf-8 -*-
-# rubygems
-require "rubygems"
-require "abstract"
+
+#
+# std lib
+#
 require 'pathname'
 require 'yaml'
 
+#
+# rubygems
+#
+require 'rubygems'
+require 'json'
+
+#
+# treevisitor
+#
+
 module TreeVisitor
   def self.version
     cwd = Pathname(__FILE__).dirname.expand_path.to_s
@@ -18,13 +29,18 @@ end
 
 require "treevisitor/abs_node"
 require 'treevisitor/leaf_node'
-require 'treevisitor/tree_node_visitor.rb'
-
 require 'treevisitor/tree_node'
-require 'treevisitor/dir_tree_walker'
+require 'treevisitor/basic_tree_node_visitor'
 require 'treevisitor/tree_node_visitor'
-require 'treevisitor/dir_processor'
 
-require 'treevisitor/visitors/block_tree_node_visitor.rb'
+require 'treevisitor/directory_walker'
+
+#
+# visitors
+#
+require 'treevisitor/visitors/block_tree_node_visitor'
 require 'treevisitor/visitors/build_dir_tree_visitor'
 require 'treevisitor/visitors/print_dir_tree_visitor'
+require 'treevisitor/visitors/directory_to_hash_visitor'
+
+require 'treevisitor/util/dir_processor'