treevisitor 0.2.3 → 0.2.4

data/lib/treevisitor/basic_tree_node_visitor.rb

@@ -1,44 +0,0 @@
-# -*- 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_node( tree_node )
-    end
-
-    #
-    # called when the tree node is not accessible or an exception is raise when the node is accessed
-    #
-    def cannot_enter_node( tree_node, error)
-    end
-
-    # alias :enter_tree_node :enter_node
-
-    #
-    # called on tree node at end of the visit i.e. oll subtree are visited
-    #
-    def exit_node( tree_node )
-    end
-
-    # alias :exit_tree_node :exit_node
-
-    #
-    # called when visit leaf node
-    #
-    def visit_leaf( leaf_node )
-    end
-
-    #
-    # called when the leaf node is not accessible or an exception is raise when the node is accessed
-    #
-    def cannot_visit_leaf( tree_node, error)
-    end
-  end
-
-end

data/lib/treevisitor/cli/cli_tree.rb

@@ -1,106 +0,0 @@
-# -*- coding: utf-8 -*-
-module TreeVisitor
-  #
-  #
-  #
-  class CliTree
-
-    def self.run
-      self.new.parse_args(ARGV)
-    end
-
-    def parse_args(argv)
-
-      options     = {:verbose => true, :force => false, :algo => 'build-dir'}
-
-      opts        = OptionParser.new
-      opts.banner = "Usage: tree.rb [options] [directory]"
-      opts.separator "list contents of directories in a tree-like format"
-      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
-      end
-
-      opts.on("--version", "Show the version") do
-        puts "tree.rb version #{TreeVisitor::VERSION}"
-        return 0
-      end
-
-      opts.on("-a", "All file are listed") do |v|
-        options[:all_files] = true
-      end
-
-      opts.on("-d", "List directories only") do |v|
-        options[:only_directories] = true
-      end
-
-      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
-
-      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
-
-      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
-        dirname = Dir.pwd
-      else
-        dirname = rest[0]
-      end
-
-      dirname = File.expand_path(dirname)
-
-      dtw     = DirTreeWalker.new(dirname)
-      unless options[:all_files]
-        dtw.ignore(/^\.[^.]+/) # ignore all file starting with "."
-      end
-
-      dtw.visit_file = !options[:only_directories]
-
-      case options[:algo]
-        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
-
-  end
-end

data/lib/treevisitor/directory_walker.rb

@@ -1,300 +0,0 @@
-# -*- 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
-    #   @option options [String] :ignore_dir
-    #   @option options [String] :ignore_file
-    #   @option options [String] :match
-    #
-    #
-    # @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
-
-      if options and options[:ignore_dir]
-        unless options[:ignore_dir].respond_to?(:at)
-          options[:ignore_dir] = [options[:ignore_dir]]
-        end
-        options[:ignore_dir].each { |p| ignore_dir(p) }
-      end
-
-      if options and options[:ignore_file]
-        unless options[:ignore_file].respond_to?(:at)
-          options[:ignore_file] = [options[:ignore_file]]
-        end
-        options[:ignore_file].each { |p| ignore_file(p) }
-      end
-
-      if options and options[:match]
-        unless options[:match].respond_to?(:at)
-          options[:match] = [options[:match]]
-        end
-        options[:match].each { |p| match(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_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)
-      # return if ignore_dir?( dirname )
-
-      begin
-        entries = Dir.entries(dirname).sort
-      rescue Errno::EACCES => e
-        $stderr.puts e
-        @visitor.cannot_enter_node(dirname, e)
-        return
-      rescue  Errno::EPERM => e
-        $stderr.puts e
-        @visitor.cannot_enter_node(dirname, e)
-        return
-      end
-
-
-      @visitor.enter_node(dirname)
-        entries.each { |basename|
-          begin
-          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(pathname)
-            end
-          end
-          rescue Errno::EACCES => e
-            $stderr.puts e
-          rescue  Errno::EPERM
-            $stderr.puts e
-          end
-        }
-
-      @visitor.exit_node(dirname)
-    end
-  end
-end