tree.rb 0.3.0

data/lib/treevisitor/abs_node.rb

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+
+  #
+  # @abstract Subclass to implement a concrete Node (Leaf or Tree).
+  #
+  # Abstract Node
+  #   Class hierarchy
+  #
+  #   AbsNode has a name, a parent
+  #    ^      and define a path i.e. concatenation ancestor names
+  #    |
+  #    |-- LeafNode
+  #    |
+  #    `-- TreeNode
+  #
+  #  Object diagram
+  #
+  #           TreeNode (parent: nil)
+  #             |
+  #             |--->[ LeafNode, LeafNode, LeafNode ]
+  #             |
+  #             |--->[ TreeNode, TreeNode ]
+  #                         |
+  #                         |--> [LeafNode]
+  #                         |
+  #                         `--> [TreeNode, TreeNode]
+  class AbsNode
+
+    class << self
+      attr_accessor :path_separator
+    end
+    self.path_separator = File::SEPARATOR
+
+    attr_reader :parent
+    attr_reader :content
+
+    attr_accessor :prev
+    attr_accessor :next
+
+    #
+    # Create a new AbsNode
+    #
+    # @param content of node
+    #
+    def initialize(content)
+      @parent      = nil
+      @content     = content
+      @prefix_path = nil
+      invalidate
+    end
+
+    #
+    # invalidate cached path info
+    #
+    def invalidate
+      @path             = nil
+      @path_with_prefix = nil
+      @depth            = nil
+      @root             = nil
+    end
+
+    #
+    # Root node could have assigned a path
+    #
+    def prefix_path
+      raise "Not root!!" unless @parent.nil?
+      @prefix_path
+    end
+
+    def prefix_path=(prefix)
+      raise "Not root!!" unless @parent.nil?
+      if prefix != @prefix_path
+        @prefix_path = prefix
+        if prefix and prefix !~ /\/$/
+          @prefix_path += AbsNode::path_separator
+        end
+        invalidate
+      end
+    end
+
+    #
+    # Return the root of this node
+    #
+    # @return AbsNode
+    #
+    def root
+      return @root if @root
+      @root = parent.nil? ? self : parent.root
+    end
+
+    #
+    # @return [String] path to this node
+    #
+    def path
+      return @path unless @path.nil?
+      if @parent.nil?
+        @path = @content
+      else
+        @path = @parent.path + AbsNode::path_separator + @content
+      end
+      @path
+    end
+
+    #
+    # @return [String] path to this node with prefix
+    #
+    def path_with_prefix
+      return @path_with_prefix if @path_with_prefix
+      if root.prefix_path
+        @path_with_prefix = root.prefix_path + path
+      else
+        @path_with_prefix = path
+      end
+    end
+
+    #
+    # @return [FixNum] depth of this node
+    #
+    def depth
+      return @depth unless @depth.nil?
+      @depth = @parent.nil? ? 1 : @parent.depth + 1
+      @depth
+    end
+
+    #
+    # Accept a node visitor
+    #
+    def accept(visitor)
+      not_implemented
+    end
+
+    def to_s
+      @content.to_s
+    end
+
+    protected
+
+    def parent=(parent)
+      @parent = parent
+    end
+
+  end
+end

data/lib/treevisitor/basic_tree_node_visitor.rb

@@ -0,0 +1,44 @@
+# -*- 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

@@ -0,0 +1,121 @@
+# -*- 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'
+          # TODO: capture CTRL^C
+          # http://ruby-doc.org/core-1.9.3/Kernel.html#method-i-trap
+          Kernel.trap('INT') { put "User interrupted exit"; exit; }
+          
+          visitor = BuildDirTreeVisitor.new
+          dtw.run(visitor)
+          
+          # colors also in windows
+          if $stdout.isatty
+            puts visitor.root.to_str('', true)  #use color
+          else
+            puts visitor.root.to_str
+          end
+          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

@@ -0,0 +1,300 @@
+# -*- 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

data/lib/treevisitor/leaf_node.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+module TreeVisitor
+
+  #
+  # Represent a LeafNode
+  #
+  class LeafNode < AbsNode
+
+    #
+    # @param [Object] content of node
+    #
+    def initialize( content, parent = nil )
+      super( content )
+      parent.add_leaf(self) if parent
+    end
+
+    #
+    # @return false because a leaf_node cannot be a root
+    #
+    def root?
+      false
+    end
+
+    #
+    # @return [TreeNodeVisitor] the visitor
+    #
+    def accept( visitor )
+      visitor.visit_leaf( self )
+      visitor
+    end
+
+  end
+end