dumb_down_viewer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 168cf3ff44970f98481dbfa56a9bad5ad019c67b
+  data.tar.gz: 75373160ed335cf58bea04caab40f91d3f36d79b
+SHA512:
+  metadata.gz: 5fa0f8ba7af6c70b32e10f99d8ec48cf287058b1efde59d2cf4c9742c3513d7cbcaa376275518023e613e01d290715e22b325ffe7f16a53fa4a4a35eacd16d42
+  data.tar.gz: 86a23ddc37f8de3b5dea366aa495b18b3257987d24571aceb60fc2377396b4aa766b6462363f4e9cd819efc54773fb2d78eb30877f6f67f983190a015aa9997a

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*~
+spec/data/mammalia/cannot_fly/elephant.txt 

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.13.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dumb_down_viewer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 HASHIMOTO, Naoki
+
+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.md

@@ -0,0 +1,112 @@
+# DumbDownViewer
+
+DumbDownViewer (ddv) is a recursive directory listing command with limited functionality.
+
+In some case, you can use ddv like "[tree](http://mama.indstate.edu/users/ice/tree/)" command, even though these commands are not compatible:
+
+Several options of "tree" are missing in ddv, but there are also some options that are available only in ddv (such as --copy-to).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dumb_down_viewer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dumb_down_viewer
+
+## Usage
+
+Suppose you have a directory `spec/data`
+
+    $ find spec/data
+    spec/data
+    spec/data/README
+    spec/data/index.html
+    spec/data/mammalia
+    spec/data/mammalia/can_fly
+    spec/data/mammalia/can_fly/bat.txt
+    spec/data/mammalia/index.html
+    spec/data/mammalia/cannot_fly
+    spec/data/mammalia/cannot_fly/elephant.txt
+    spec/data/aves
+    spec/data/aves/can_fly
+    spec/data/aves/can_fly/sparrow.txt
+    spec/data/aves/index.html
+    spec/data/aves/cannot_fly
+    spec/data/aves/cannot_fly/penguin.jpg
+    spec/data/aves/cannot_fly/penguin.txt
+    spec/data/aves/cannot_fly/ostrich.txt
+    spec/data/aves/cannot_fly/ostrich.jpg
+
+
+Then type at the command line (or replace `spec/data` with a directory name which is on your system):
+
+    $ ddv spec/data
+
+And you will get something like the following
+
+    [spec/data]
+    ├─ README
+    ├─ index.html
+    ├─ [aves]
+    │   ├─ index.html
+    │   ├─ [can_fly]
+    │   │   └─ sparrow.txt
+    │   └─ [cannot_fly]
+    │        ├─ ostrich.jpg
+    │        ├─ ostrich.txt
+    │        ├─ penguin.jpg
+    │        └─ penguin.txt
+    └─ [mammalia]
+         ├─ index.html
+         ├─ [can_fly]
+         │   └─ bat.txt
+         └─ [cannot_fly]
+              └─ elephant.txt
+
+### Options
+
+The following is the list of available options:
+
+|Short |Long |Description |
+|------|-----|------------|
+|-s [style_name] |--style [=style_name] |Choose the style of output other than default from ascii_art, list, zenkaku or tree |
+|-f [format_name] |--format [=format_name] |Choose the output format other than default from csv, tsv or tree_csv |
+|-d |--directories-only |List directories only |
+|-L [level] |- |Descend only level directories deep |
+|-P [pattern] |- |List only those files that match the given pattern |
+|-I [pattern] |- |Do not list files that match the given pattern |
+|-a |--all |Show all files including dot files |
+|- |--ignore-case |Ignore case when pattern matching |
+|-o [output_file] |--output [=output_file] |Output to file instead of stdout |
+|- |--filelimit [=number_of_files] |Do not descend dirs with more than the specified number of files in them |
+|- |--summary [=summary_type] |Add summary information about directories. Available summary_type: default |
+|-J |- |Print out a JSON representation |
+|-X |- |Print out an XML representation |
+|- |--report-total-count |Display file/directory count at the end of directory listing |
+|- |--copy-to [=dest_dir] |Copy the directory tree to dest_dir |
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nico-hn/DumbDownViewer.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dumb_down_viewer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dumb_down_viewer.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dumb_down_viewer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dumb_down_viewer"
+  spec.version       = DumbDownViewer::VERSION
+  spec.authors       = ["HASHIMOTO, Naoki"]
+  spec.email         = ["hashimoto.naoki@gmail.com"]
+
+  spec.summary       = %q{DumbDownViewer (ddv) is a recursive directory listing command with limited functionality.}
+  spec.description   = <<-DESCRIPTION
+DumbDownViewer (ddv) is a recursive directory listing command with limited functionality.
+In some case, you can use ddv like "tree" command (http://mama.indstate.edu/users/ice/tree/),
+even though these commands are not compatible: Several options of "tree" are missing in ddv,
+but there are also some options that are available only in ddv (such as --copy-to).
+  DESCRIPTION
+  spec.homepage      = "https://github.com/nico-hn/DumbDownViewer"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency "nokogiri", "~> 1.6"
+  spec.add_runtime_dependency "optparse_plus"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/exe/ddv

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "dumb_down_viewer"
+require "dumb_down_viewer/cli"
+
+DumbDownViewer::Cli.execute

data/lib/dumb_down_viewer/cli.rb

@@ -0,0 +1,206 @@
+require 'dumb_down_viewer'
+require 'dumb_down_viewer/tree_view_builder'
+require 'optparse_plus'
+
+module DumbDownViewer
+  module Cli
+    FORMATTER = {
+      default: DumbDownViewer::TreeViewBuilder::PlainTextFormat,
+      csv: DumbDownViewer::TreeViewBuilder::CSVFormat,
+      tsv: DumbDownViewer::TreeViewBuilder::CSVFormat,
+      tree_csv: DumbDownViewer::TreeViewBuilder::TreeCSVFormat
+    }
+
+    OPTIONS = <<YAML
+banner: "USAGE: #{File.basename($0)} [OPTION]... DIRECTORY"
+style:
+  short: "-s [style_name]"
+  long: "--style [=style_name]"
+  description: "Choose the style of output other than default from ascii_art, list, zenkaku or tree"
+format:
+  short: "-f [format_name]"
+  long: "--format [=format_name]"
+  description: Choose the output format other than default from csv, tsv, tree_csv
+directories:
+  short: "-d"
+  long: "--directories-only"
+  description: "List directories only"
+level:
+  short: "-L [level]"
+  description: "Descend only level directories deep"
+match:
+  short: "-P [pattern]"
+  description: "List only those files that match the pattern given"
+ignore_match:
+  short: "-I [pattern]"
+  description: "Do not list files that match the given pattern"
+show_all:
+  short: "-a"
+  long: "--all"
+  description: "Show all files including dot files"
+ignore_case:
+  long: "--ignore-case"
+  description: "Ignore case when pattern matching"
+output:
+  short: "-o [output_file]"
+  long: "--output [=output_file]"
+  description: "Output to file instead of stdout"
+file_limit:
+  long: "--filelimit [=number_of_files]"
+  description: "Do not descend dirs with more than the specified number of files in them"
+summary:
+  long: "--summary [=summary_type]"
+  description: "Add summary information about directories. Available summary_type: default"
+json:
+  short: "-J"
+  description: "Print out a JSON representation"
+xml:
+  short: "-X"
+  description: "Print out an XML representation"
+total_count:
+  long: "--report-total-count"
+  description: "Display file/directory count at the end of directory listing"
+copy_to:
+  long: "--copy-to [=dest_dir]"
+  description: "Copy the directory tree to dest_dir"
+YAML
+
+    def self.parse_command_line_options
+      options = { style: :default, format: :default }
+      OptionParser.new_with_yaml(OPTIONS) do |opt|
+        opt.version = DumbDownViewer::VERSION
+        opt.inherit_ruby_options("E") # -E --encoding
+
+        opt.on(:style) {|style| options[:style] = style.to_sym }
+        opt.on(:format) {|format| options[:format] = format.to_sym }
+        opt.on(:directories) {|directories| options[:directories] = true }
+        opt.on(:level) {|level| options[:level] = level.to_i }
+        opt.on(:match) {|pattern| options[:match] = pattern }
+        opt.on(:ignore_match) {|pattern| options[:ignore_match] = pattern }
+        opt.on(:show_all) { options[:show_all] = true }
+        opt.on(:ignore_case) { options[:ignore_case] = true }
+        opt.on(:output) {|output_file| options[:output] = output_file }
+        opt.on(:file_limit) {|number_of_files| options[:file_limit] = number_of_files.to_i }
+        opt.on(:summary) {|summary_type| options[:summary] = summary_type.to_sym }
+        opt.on(:json) { options[:json] = true }
+        opt.on(:xml) { options[:xml] = true }
+        opt.on(:total_count) { options[:total_count] = true }
+        opt.on(:copy_to) {|dest_dir| options[:copy_to] = dest_dir }
+        opt.parse!
+      end
+      options
+    end
+
+    def self.execute
+      options = parse_command_line_options
+      tree = DumbDownViewer.build_node_tree(ARGV[0])
+      prune_dot_files(tree) unless options[:show_all]
+      prune_dirs_with_more_than(tree, options[:file_limit]) if options[:file_limit]
+      prune_level(tree, options[:level]) if options[:level]
+      select_match(tree, options) if options[:match]
+      ignore_match(tree, options) if options[:ignore_match]
+      prune_files(tree) if options[:directories]
+      copy_to(tree, options) if options[:copy_to]
+      open_output(options[:output]) do |out|
+        out.print format_tree(tree, options)
+        out.puts total_count(tree) if options[:total_count]
+      end
+    end
+
+    def self.prune_dot_files(tree)
+      pruner = DumbDownViewer::TreePruner.create(false) {|node| node.name.start_with? '.' }
+      pruner.visit(tree, nil)
+    end
+
+    def self.prune_files(tree)
+      pruner = DumbDownViewer::TreePruner.create {|node| node.directory? }
+      pruner.visit(tree, nil)
+    end
+
+    def self.prune_level(tree, level)
+      pruner = DumbDownViewer::TreePruner.create {|node| node.depth <= level }
+      pruner.visit(tree, nil)
+    end
+
+    def self.select_match(tree, options)
+      pat = Regexp.compile(options[:match], options[:ignore_case])
+      pruner = DumbDownViewer::TreePruner.create {|node| node.directory? or pat =~ node.name }
+      pruner.visit(tree, nil)
+    end
+
+    def self.ignore_match(tree, options)
+      pat = Regexp.compile(options[:ignore_match], options[:ignore_case])
+      pruner = DumbDownViewer::TreePruner.create(false) {|node| not node.directory? and pat =~ node.name }
+      pruner.visit(tree, nil)
+    end
+
+    def self.prune_dirs_with_more_than(tree, number_of_files)
+      pruner = DumbDownViewer::TreePruner.create(false) do |node|
+        node.directory? and node.sub_nodes.size > number_of_files
+      end
+      if tree.sub_nodes.size > number_of_files
+        tree.directories.clear
+        tree.files.clear
+      end
+      pruner.visit(tree, nil)
+    end
+
+    def self.format_json(tree, options)
+      json = DumbDownViewer::JSONConverter.dump(tree)
+      json + $/
+    end
+
+    def self.format_xml(tree, options)
+      DumbDownViewer::XMLConverter.dump(tree)
+    end
+
+    def self.add_summary(tree, options)
+      if summary_type = options[:summary] and summary_type != :default
+        STDERR.puts "Unknown option #{summary_type} for --summary: default is used instead."
+      end
+      visitor = DumbDownViewer::FileCountSummary.new
+      tree.accept(visitor, nil)
+      DumbDownViewer::FileCountSummary::NodeFormat.new
+    end
+
+    def self.format_tree(tree, options)
+      if options[:file_limit] and tree.sub_nodes.empty?
+        ''
+      elsif options[:json]
+        format_json(tree, options)
+      elsif options[:xml]
+        format_xml(tree, options)
+      else
+        format_tree_with_builder(tree, options)
+      end
+    end
+
+    def self.format_tree_with_builder(tree, options)
+      style = options[:style]
+      col_sep = options[:format] == :tsv ? "\t" : ','
+      node_format = options[:summary] ? add_summary(tree, options) : nil
+      builder = TreeViewBuilder.create(tree)
+      formatter = FORMATTER[options[:format]].new(style, col_sep, node_format)
+      formatter.format_table(builder.tree_table)
+    end
+
+    def self.total_count(tree)
+      count = DumbDownViewer::TotalNodeCount.count(tree)
+      "#{$/}#{count[:directories]} directories, #{count[:files]} files"
+    end
+
+    def self.copy_to(tree, options)
+      DumbDownViewer::TreeDuplicator.duplicate(tree, options[:copy_to])
+    end
+
+    def self.open_output(filename)
+      if filename
+        open(File.expand_path(filename), "wb") do |out|
+          yield out
+        end
+      else
+        yield STDOUT
+      end
+    end
+  end
+end

data/lib/dumb_down_viewer/tree_view_builder.rb

@@ -0,0 +1,180 @@
+require 'dumb_down_viewer'
+require 'dumb_down_viewer/visitor'
+require 'csv'
+require 'yaml'
+
+module DumbDownViewer
+  class TreeViewBuilder < Visitor
+    attr_reader :tree_table
+
+    class PlainTextFormat
+      attr_accessor :line
+
+      LINE_PATTERNS = YAML.load(<<YAML_DATA)
+:default:
+  :spacer: '     '
+  :h_line: '── '
+  :v_line: '│   '
+  :branch: '├─ '
+  :corner: '└─ '
+:ascii_art:
+  :spacer: '    '
+  :h_line: '--- '
+  :v_line: '|   '
+  :branch: '|-- '
+  :corner: '`-- '
+:list:
+  :spacer: '   '
+  :h_line: '   '
+  :v_line: '   '
+  :branch: ' * '
+  :corner: ' * '
+:zenkaku:
+  :spacer: '　　 '
+  :h_line: '── '
+  :v_line: '│　 '
+  :branch: '├─ '
+  :corner: '└─ '
+:tree:
+  :spacer: '    '
+  :h_line: '─── '
+  :v_line: '│   '
+  :branch: '├── '
+  :corner: '└── '
+
+YAML_DATA
+
+      def initialize(line_pattern=:default, col_sep=nil, node_format=nil)
+        # col_sep is just for having common interface
+        @line = LINE_PATTERNS[line_pattern]
+        @node_format = node_format || NodeFormat.new
+      end
+
+      def format_table(tree_table)
+        t = tree_table.transpose
+        t.each_cons(2) do |fr, sr|
+          fr.each_with_index do |f, i|
+            next unless f.kind_of? Node
+            draw_lines(fr, sr, f, i)
+          end
+        end
+
+        draw_last_line(t[-1])
+        update_root_directory_name(tree_table[0][0], t)
+        table_to_output_format(t.transpose)
+      end
+
+      def draw_lines(fr, sr, f_node, i)
+        sub_count = f_node.sub_nodes.size
+        j = i
+        while sub_count > 0
+          j += 1
+          s_node = sr[j]
+          if s_node
+            fr[j] = sub_count == 1 ? @line[:corner] : @line[:branch]
+            sub_count -= 1
+          else
+            fr[j] = @line[:v_line]
+          end
+        end
+        fr[i] = @node_format[f_node]
+      end
+
+      def draw_last_line(line)
+        line.each_index do |i|
+          node = line[i]
+          line[i] = @node_format[node] if node.kind_of?(DirNode)
+        end
+      end
+
+      def fill_spaces(table)
+        table.map do |row|
+          (row.size - 1).downto(0) do |i|
+            row[i] = @line[:spacer] if row[i + 1] and row[i].nil?
+          end
+          row
+        end
+      end
+
+      def update_root_directory_name(root, table)
+        if root.directory and not root.directory.empty?
+          table[0][0] = "[#{File.join(root.directory, root.name)}]"
+        end
+      end
+
+      def table_to_output_format(table)
+        fill_spaces(table).map {|r| r.join }.join($/) + $/
+      end
+    end
+
+    class TreeCSVFormat < PlainTextFormat
+      def initialize(line_pattern=:default, col_sep=',', node_format=nil)
+        @line = LINE_PATTERNS[line_pattern]
+        @col_sep = col_sep
+        @node_format = node_format || NodeFormat.new
+      end
+
+      def table_to_output_format(table)
+        CSV.generate('', col_sep: @col_sep) do |csv|
+          table.each {|row| csv << row }
+        end
+      end
+    end
+
+    class CSVFormat
+      def initialize(line_pattern=nil, col_sep=',', node_format=nil)
+        @line_pattern = line_pattern
+        @col_sep = col_sep
+        @node_format = node_format || NodeFormat.new
+      end
+
+      def format_table(tree_table)
+        root = tree_table[0][0]
+        tree_table[0][0] = "#{File.join(root.directory, root.name)}"
+        CSV.generate('', col_sep: @col_sep) do |csv|
+          tree_table.each {|row| csv << row }
+        end
+      end
+    end
+
+    def format(formatter=PlainTextFormat.new)
+      formatter.format_table(@tree_table)
+    end
+
+    def setup(tree)
+      @tree_table = []
+      determine_depth(tree)
+      tree.accept(self, nil)
+    end
+
+    def determine_depth(tree) # update of test necessary
+      @tree_depth = 0
+      depth_checker = Visitor.new do |node, memo|
+        @tree_depth = node.depth > @tree_depth ? node.depth : @tree_depth
+      end
+      tree.accept(depth_checker, 0)
+    end
+
+    def new_table_row
+      Array.new(@tree_depth + 1)
+    end
+
+    def visit_dir_node(node, memo)
+      add_current_node_row(node)
+
+      [node.files, node.directories].each do |nodes|
+        nodes.sort_by {|n| n.name }.each {|n| n.accept(self, memo) }
+      end
+    end
+
+    def visit_file_node(node, memo)
+      add_current_node_row(node)
+    end
+
+    def add_current_node_row(node)
+      row = new_table_row
+      row[node.depth] = node
+      @tree_table.push row
+    end
+  end
+end

data/lib/dumb_down_viewer/version.rb

@@ -0,0 +1,3 @@
+module DumbDownViewer
+  VERSION = "0.1.0"
+end

data/lib/dumb_down_viewer/visitor.rb

@@ -0,0 +1,246 @@
+require 'dumb_down_viewer'
+require 'json'
+
+module DumbDownViewer
+  class Visitor
+    attr_accessor
+
+    def self.create(*args, &memo_update)
+      new(&memo_update).tap {|visitor| visitor.setup(*args) }
+    end
+
+    def initialize(&memo_update)
+      @memo_update = memo_update
+    end
+
+    def setup(*args)
+    end
+
+    def visit(node, memo)
+      memo = @memo_update.call(node, memo) if @memo_update
+
+      if node.kind_of? DirNode
+        visit_dir_node(node, memo)
+      else
+        visit_file_node(node, memo)
+      end
+    end
+
+    def visit_dir_node(node, memo)
+      visit_sub_nodes(node, memo)
+    end
+
+    def visit_file_node(node, memo)
+    end
+
+    def visit_sub_nodes(node, memo)
+      node.sub_nodes.each do |node|
+        node.accept(self, memo)
+      end
+    end
+  end
+
+  class NodeFormat
+    def [](node)
+      case node
+      when DumbDownViewer::DirNode
+        format_dir(node)
+      when DumbDownViewer::FileNode
+        format_file(node)
+      end
+    end
+
+    def format_dir(node)
+      "[#{node.name}]"
+    end
+
+    def format_file(node)
+      node.name
+    end
+  end
+
+  class TreePruner < Visitor
+    def setup(keep=true)
+      criteria = @memo_update
+      delete_method = keep ? :keep_if : :delete_if
+      @memo_update = proc do |node, memo|
+        unless node.kind_of? FileNode
+          [node.directories, node.files].each do |nodes|
+            nodes.send(delete_method) {|n| criteria.call(n) }
+          end
+        end
+      end
+    end
+  end
+
+  class FileCountSummary < Visitor
+    class NodeFormat < DumbDownViewer::NodeFormat
+      def format_dir(node)
+        report = "[#{node.name}]"
+        data = node.summary
+        counts = data.keys.map {|ext| file_count(data, ext) }.join(', ')
+        report << " => #{counts}" unless counts.empty?
+        report
+      end
+
+      def file_count(data, ext)
+        count = data[ext].size
+        unit = count == 1 ? 'file'.freeze : 'files'.freeze
+        ext = '(misc)'.freeze if ext.empty?
+        "#{ext}: #{count} #{unit}"
+      end
+    end
+
+    def visit_dir_node(node, memo)
+      node.summary = node.files.group_by {|file| file.extention }
+      visit_sub_nodes(node, memo)
+    end
+  end
+
+  TotalNodeCount = Visitor.create do |node, memo|
+    memo[node.class] += 1
+    memo
+  end
+
+  def TotalNodeCount.count(tree)
+    counter = Hash.new(0)
+    tree.accept(self, counter)
+    { directories: counter[DirNode] - 1, files: counter[FileNode] }
+  end
+
+  class JSONConverter
+    def self.dump(tree, with_path=false)
+      JSON.dump(new.visit(tree, with_path))
+    end
+
+    def visit(node, with_path=false)
+      case node
+      when DirNode
+        {
+          type: 'directory', name: name_value(node, with_path),
+          contents: node.sub_nodes.map {|n| n.accept(self, with_path) }
+        }
+      when FileNode
+        { type: 'file', name: name_value(node, with_path) }
+      end
+    end
+
+    private
+
+    def name_value(node, with_path)
+      if with_path
+        File.join(node.directory, node.name)
+      else
+        node.name
+      end
+    end
+  end
+
+  class XMLConverter
+    attr_reader :doc, :tree_root
+    XML_TEMPLATE = '<?xml version="1.0" encoding="UTF-8"?>'
+
+    def self.dump(tree, with_path=false)
+      visitor = new.tap do |v|
+        v.create_doc
+        v.visit(tree, with_path)
+      end
+
+      visitor.dump(tree, with_path)
+    end
+
+    def visit(node, with_path)
+      case node
+      when DirNode
+        create_dir_element(node, with_path).tap do |elm|
+          node.sub_nodes.each do |n|
+            n.accept(self, with_path).parent = elm
+          end
+        end
+      when FileNode
+        create_file_element(node, with_path)
+      end
+    end
+
+    def create_doc
+      @doc = Nokogiri::XML(XML_TEMPLATE).tap do |doc|
+        @tree_root = Nokogiri::XML::Node.new('tree'.freeze, doc)
+        @tree_root.parent = doc
+      end
+    end
+
+    def dump(tree, with_path)
+      file_regexp = /#{Regexp.escape("> <\/file>")}/
+      visit(tree, with_path).parent = @tree_root
+      @doc.to_xml.gsub(file_regexp, '></file>')
+    end
+
+    private
+
+    def create_dir_element(node, with_path)
+      Nokogiri::XML::Node.new('directory'.freeze, @doc).tap do |elm|
+        elm['name'.freeze] = name_value(node, with_path)
+      end
+    end
+
+    def create_file_element(node, with_path)
+      Nokogiri::XML::Node.new('file'.freeze, @doc).tap do |elm|
+        elm['name'.freeze] = name_value(node, with_path)
+        elm.content = ' '.freeze
+      end
+    end
+
+    def name_value(node, with_path)
+      if with_path
+        File.join(node.directory, node.name)
+      else
+        node.name
+      end
+    end
+  end
+
+  class TreeDuplicator < Visitor
+    class DuplicationError < StandardError; end
+
+    def self.duplicate(tree, dest_root)
+      duplicator = new
+      duplicator.setup(tree, dest_root)
+      tree.accept(duplicator, nil)
+    end
+
+    def setup(tree, dest_root)
+      orig_root = File.join(tree.directory, tree.name)
+      @dest_root, @orig_root = [dest_root, orig_root].map do |root|
+        root.sub(/\/\Z/, '')
+      end
+      @orig_root_re = /\A#{Regexp.escape(@orig_root)}/
+    end
+
+    def visit_dir_node(node, memo)
+      dest_dir = replace_root(File.join(node.directory, node.name))
+      check_entry_existence(dest_dir)
+      FileUtils.mkdir(File.expand_path(dest_dir))
+      visit_sub_nodes(node, memo)
+    end
+
+    def visit_file_node(node, memo)
+      orig_file = File.join(node.directory, node.name)
+      dest_file = replace_root(orig_file)
+      check_entry_existence(dest_file)
+      FileUtils.cp(File.expand_path(orig_file),
+                   File.expand_path(dest_file))
+    end
+
+    private
+
+    def replace_root(path)
+      path.sub(@orig_root_re, @dest_root)
+    end
+
+    def check_entry_existence(entry)
+      if File.exist?(File.expand_path(entry))
+        raise DuplicationError, "#{entry} already exists: #{@orig_root} is not copied."
+      end
+    end
+  end
+end

data/lib/dumb_down_viewer.rb

@@ -0,0 +1,86 @@
+require 'dumb_down_viewer/version'
+require 'fileutils'
+require 'find'
+require 'nokogiri'
+
+module DumbDownViewer
+  def self.collect_directories_and_files(path)
+    entries = Dir.entries(path) - ['.', '..']
+    entries.partition do |entry|
+      entry_path = File.expand_path(File.join(path, entry))
+      File.directory? entry_path
+    end
+  end
+
+  def self.build_node_tree(dir)
+    dirname, filename = File.split(dir)
+    DirNode.new(dirname, filename, 0).tap {|dir| dir.collect_entries }
+  end
+
+  class Node
+    attr_reader :sub_nodes, :directory, :name, :depth
+    attr_accessor :summary
+
+    def initialize(pwd, name, depth)
+      @directory = pwd
+      @name = name
+      @depth = depth
+      @name_with_path = pwd.empty? ? @name : File.join(pwd, name)
+      setup
+    end
+
+    def setup
+    end
+
+    def accept(visitor, memo)
+      visitor.visit(self, memo)
+    end
+
+    def to_s
+      @name
+    end
+
+    def directory?
+      kind_of? DirNode
+    end
+
+    def file?
+      kind_of? FileNode
+    end
+  end
+
+  class DirNode < Node
+    attr_reader :directories, :files
+
+    def sub_nodes
+      (@files + @directories).freeze
+    end
+
+    def collect_entries
+      dirs, files = DumbDownViewer.collect_directories_and_files(@name_with_path)
+      depth = @depth + 1
+      @directories = entry_nodes(dirs, DirNode, depth)
+      @directories.each {|dir| dir.collect_entries }
+      @files = entry_nodes(files, FileNode, depth)
+    end
+
+    def entry_nodes(nodes, node_class, depth)
+      nodes.map {|node| node_class.new(@name_with_path, node, depth) }
+    end
+  end
+
+  class FileNode < Node
+    attr_reader :extention
+    def setup
+      extract_extention
+      @sub_nodes = [].freeze
+    end
+
+    private
+
+    def extract_extention
+      m = /\.([^.]+)\Z/.match(@name)
+      @extention = m ? m[1] : ''
+    end
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: dumb_down_viewer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- HASHIMOTO, Naoki
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: optparse_plus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |
+  DumbDownViewer (ddv) is a recursive directory listing command with limited functionality.
+  In some case, you can use ddv like "tree" command (http://mama.indstate.edu/users/ice/tree/),
+  even though these commands are not compatible: Several options of "tree" are missing in ddv,
+  but there are also some options that are available only in ddv (such as --copy-to).
+email:
+- hashimoto.naoki@gmail.com
+executables:
+- ddv
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dumb_down_viewer.gemspec
+- exe/ddv
+- lib/dumb_down_viewer.rb
+- lib/dumb_down_viewer/cli.rb
+- lib/dumb_down_viewer/tree_view_builder.rb
+- lib/dumb_down_viewer/version.rb
+- lib/dumb_down_viewer/visitor.rb
+homepage: https://github.com/nico-hn/DumbDownViewer
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: DumbDownViewer (ddv) is a recursive directory listing command with limited
+  functionality.
+test_files: []