dirtree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2547ddc3ecb80bf7083207cbca639f543c304b6
+  data.tar.gz: 12d42cd27343ad8eebaa262ca9b82181a6bb71fd
+SHA512:
+  metadata.gz: 494cc0241accc14941175013b3c7a493d71b79a88a3b1ce87a5fd634477d97cc926bd8c079d74ae0cb9bcc6dadedbe22568fabae9e8c1752df25feff3dc833a5
+  data.tar.gz: 229f45fdfaf9860d6554393501f9c4c6a318bee3f1bcc2f593c4b43d322fa532edaf21e7abccd63b2a3a5b60402f1882bf2df6cb4ebc2f39df63f34793af71a6

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Emad Elsaid
+
+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,47 @@
+# Dirtree
+
+Dirtree visualizes an list of file paths into a tree graph, printed as HTML page, it can be useful in visualizing a whole project you're working on to start cleanup or organizing your code or spotting large directories or unneeded files.
+
+## Installation
+
+
+    $ gem install dirtree
+
+## Usage
+
+    Usage: dirtree [options]... [file]...
+        -v, --version                    Print version
+        -h, --help                       Show this help text
+        -o, --output=File.html           Specify a path to write output, if not specified output will be printed to STDOUT
+
+
+### Visualize current directory recursively
+
+    $ dirtree -o output.html **/* *
+
+### Visualize files from git ls
+
+    $ git ls-files | dirtree -o output.html
+
+### Dirtree prints to standard output if no --output option specified so you can redirect it
+
+    $ git ls-files | dirtree > output.html
+
+### visualize only files that include specific word
+
+    $ git ls-files | grep keyword | dirtree > output.html
+
+### works with find
+
+visulaize all files that ends with `rb`
+
+    $ find ~ -name *rb | dirtree > output.html
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/blazeeboy/dirtree.
+
+## 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 @@
+require 'bundler/gem_tasks'

data/dirtree.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dirtree/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dirtree'
+  spec.version       = Dirtree::VERSION
+  spec.authors       = ['Emad Elsaid']
+  spec.email         = ['blazeeboy@gmail.com']
+
+  spec.summary       = 'display list of file paths as an interactive tree'
+  spec.description   = 'display list of file paths as an interactive tree'
+  spec.homepage      = 'https://www.github.com/blazeeboy/dirtree'
+  spec.license       = 'MIT'
+
+  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_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/exe/dirtree

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require 'dirtree'
+require 'optparse'
+require 'json'
+require 'erb'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = 'Usage: dirtree [options]... [file]...'
+
+  opts.on('-v', '--version', 'Print version') do
+    puts "Dirtree version #{Dirtree::VERSION}"
+    exit
+  end
+
+  opts.on('-h', '--help', 'Show this help text') do
+    puts opts
+    exit
+  end
+
+  opts.on('-oFile.html', '--output=File.html', 'Specify a path to write output, if not specified output will be printed to STDOUT') do |value|
+    options[:output] = value
+  end
+end.parse!
+
+files = ARGV.empty? ? STDIN.read.lines : ARGV
+files.map!(&:strip)
+
+root = Dirtree::Node.new('/')
+files.each { |file| root.insert(file.split('/')) }
+templates_dir = File.join(File.dirname(__FILE__), '..', 'templates')
+template_file = File.join(templates_dir, 'tree.html.erb')
+template = File.read(File.expand_path(template_file))
+
+tree = root.as_json
+result = ERB.new(template).result binding
+
+if options.key?(:output)
+  File.write(options[:output], result)
+else
+  puts result
+end

data/lib/dirtree.rb

@@ -0,0 +1,2 @@
+require 'dirtree/version'
+require 'dirtree/node'

data/lib/dirtree/node.rb

@@ -0,0 +1,34 @@
+module Dirtree
+  # tree node, it has a name and children of the same type
+  class Node
+    attr_reader :name, :children
+
+    def initialize(name)
+      @name = name
+      @children = []
+    end
+
+    # insert a node by its path, path is an array of names (Strings)
+    def insert(path)
+      return if path.empty?
+
+      child_name = path.first
+      grandchildren = path[1..-1]
+
+      child = @children.find { |current| current.name == child_name }
+      unless child
+        child = Node.new(child_name)
+        @children << child
+      end
+
+      child.insert(grandchildren)
+    end
+
+    def as_json
+      {
+        name: name,
+        children: children.map(&:as_json)
+      }
+    end
+  end
+end

data/lib/dirtree/version.rb

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

data/templates/tree.html.erb

@@ -0,0 +1,366 @@
+<!DOCTYPE html>
+<html>
+<meta charset="utf-8">
+<style type="text/css">
+
+ html, body {
+   padding: 0px;
+   margin: 0px;
+   width: 100%;
+   height: 100%;
+   overflow: hidden;
+ }
+
+ .node {
+   cursor: pointer;
+ }
+
+ .overlay{
+   background-color:#EEE;
+ }
+
+ .node circle {
+   fill: #fff;
+   stroke: steelblue;
+   stroke-width: 1.5px;
+ }
+
+ .node text {
+   font-size:10px;
+   font-family:sans-serif;
+ }
+
+ .link {
+   fill: none;
+   stroke: #ccc;
+   stroke-width: 1.5px;
+ }
+</style>
+<body>
+  <div id="tree-container"></div>
+<script src="http://code.jquery.com/jquery-1.10.2.min.js"></script>
+<script src="http://d3js.org/d3.v3.min.js"></script>
+<script>
+  /*Copyright (c) 2013-2016, Rob Schmuecker
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+  * The name Rob Schmuecker may not be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.*/
+
+ treeData = <%= tree.to_json %>;
+
+ // Calculate total nodes, max label length
+ var maxLabelLength = 0;
+ // panning variables
+ var panSpeed = 200;
+ // Misc. variables
+ var i = 0;
+ var duration = 750;
+ var root;
+
+ // size of the diagram
+ var viewerWidth = $(document).width();
+ var viewerHeight = $(document).height();
+
+ var tree = d3.layout.tree()
+              .size([viewerHeight, viewerWidth]);
+
+ // define a d3 diagonal projection for use by the node paths later on.
+ var diagonal = d3.svg.diagonal()
+                  .projection(function(d) {
+                    return [d.y, d.x];
+                  });
+
+ // A recursive helper function for performing some setup by walking through all nodes
+ function visit(parent, visitFn, childrenFn) {
+   if (!parent) return;
+
+   visitFn(parent);
+
+   var children = childrenFn(parent);
+   if (children) {
+     var count = children.length;
+     for (var i = 0; i < count; i++) {
+       visit(children[i], visitFn, childrenFn);
+     }
+   }
+ }
+
+ // Call visit function to establish maxLabelLength
+ visit(treeData, function(d) {
+   maxLabelLength = Math.max(d.name.length, maxLabelLength);
+
+ }, function(d) {
+   return d.children && d.children.length > 0 ? d.children : null;
+ });
+
+ function pan(domNode, direction) {
+   var speed = panSpeed;
+   if (panTimer) {
+     clearTimeout(panTimer);
+     translateCoords = d3.transform(svgGroup.attr("transform"));
+     if (direction == 'left' || direction == 'right') {
+       translateX = direction == 'left' ? translateCoords.translate[0] + speed : translateCoords.translate[0] - speed;
+       translateY = translateCoords.translate[1];
+     } else if (direction == 'up' || direction == 'down') {
+       translateX = translateCoords.translate[0];
+       translateY = direction == 'up' ? translateCoords.translate[1] + speed : translateCoords.translate[1] - speed;
+     }
+     scaleX = translateCoords.scale[0];
+     scaleY = translateCoords.scale[1];
+     scale = zoomListener.scale();
+     svgGroup.transition().attr("transform", "translate(" + translateX + "," + translateY + ")scale(" + scale + ")");
+     d3.select(domNode).select('g.node').attr("transform", "translate(" + translateX + "," + translateY + ")");
+     zoomListener.scale(zoomListener.scale());
+     zoomListener.translate([translateX, translateY]);
+     panTimer = setTimeout(function() {
+       pan(domNode, speed, direction);
+     }, 50);
+   }
+ }
+
+ // Define the zoom function for the zoomable tree
+ function zoom() {
+   svgGroup.attr("transform", "translate(" + d3.event.translate + ")scale(" + d3.event.scale + ")");
+ }
+
+
+ // define the zoomListener which calls the zoom function on the "zoom" event constrained within the scaleExtents
+ var zoomListener = d3.behavior.zoom().scaleExtent([0.1, 3]).on("zoom", zoom);
+
+ // define the baseSvg, attaching a class for styling and the zoomListener
+ var baseSvg = d3.select("#tree-container").append("svg")
+                 .attr("width", viewerWidth)
+                 .attr("height", viewerHeight)
+                 .attr("class", "overlay")
+                 .call(zoomListener);
+
+ // Function to center node when clicked/dropped so node doesn't get lost when collapsing/moving with large amount of children.
+
+ function centerNode(source) {
+   scale = zoomListener.scale();
+   x = -source.y0;
+   y = -source.x0;
+   x = x * scale + viewerWidth / 2;
+   y = y * scale + viewerHeight / 2;
+   d3.select('g').transition()
+     .duration(duration)
+     .attr("transform", "translate(" + x + "," + y + ")scale(" + scale + ")");
+   zoomListener.scale(scale);
+   zoomListener.translate([x, y]);
+ }
+
+ // Toggle children function
+
+ function toggleChildren(d) {
+   if (d.children) {
+     d._children = d.children;
+     d.children = null;
+   } else if (d._children) {
+     d.children = d._children;
+     d._children = null;
+   }
+   return d;
+ }
+
+ // Toggle children on click.
+ function click(d) {
+   if (d3.event.defaultPrevented) return; // click suppressed
+   d = toggleChildren(d);
+   update(d);
+   centerNode(d);
+ }
+
+ function update(source) {
+   // Compute the new height, function counts total children of root node and sets tree height accordingly.
+   // This prevents the layout looking squashed when new nodes are made visible or looking sparse when nodes are removed
+   // This makes the layout more consistent.
+   var levelWidth = [1];
+   var childCount = function(level, n) {
+
+     if (n.children && n.children.length > 0) {
+       if (levelWidth.length <= level + 1) levelWidth.push(0);
+
+       levelWidth[level + 1] += n.children.length;
+       n.children.forEach(function(d) {
+         childCount(level + 1, d);
+       });
+     }
+   };
+   childCount(0, root);
+   var newHeight = d3.max(levelWidth) * 25; // 25 pixels per line
+   tree = tree.size([newHeight, viewerWidth]);
+
+   // Compute the new tree layout.
+   var nodes = tree.nodes(root).reverse(),
+       links = tree.links(nodes);
+
+   // Set widths between levels based on maxLabelLength.
+   nodes.forEach(function(d) {
+     d.y = (d.depth * (maxLabelLength * 10)); //maxLabelLength * 10px
+     // alternatively to keep a fixed scale one can set a fixed depth per level
+     // Normalize for fixed-depth by commenting out below line
+     // d.y = (d.depth * 500); //500px per level.
+   });
+
+   // Update the nodes…
+   node = svgGroup.selectAll("g.node")
+                  .data(nodes, function(d) {
+                    return d.id || (d.id = ++i);
+                  });
+
+   // Enter any new nodes at the parent's previous position.
+   var nodeEnter = node.enter().append("g")
+                       .attr("class", "node")
+                       .attr("transform", function(d) {
+                         return "translate(" + source.y0 + "," + source.x0 + ")";
+                       })
+                       .on('click', click);
+
+   nodeEnter.append("circle")
+            .attr('class', 'nodeCircle')
+            .attr("r", 0)
+            .style("fill", function(d) {
+              return d._children ? "lightsteelblue" : "#fff";
+            });
+
+   nodeEnter.append("text")
+            .attr("x", function(d) {
+              return d.children || d._children ? -10 : 10;
+            })
+            .attr("dy", ".35em")
+            .attr('class', 'nodeText')
+            .attr("text-anchor", function(d) {
+              return d.children || d._children ? "end" : "start";
+            })
+            .text(function(d) {
+              return d.name;
+            })
+            .style("fill-opacity", 0);
+
+   // Update the text to reflect whether node has children or not.
+   node.select('text')
+       .attr("x", function(d) {
+         return d.children || d._children ? -10 : 10;
+       })
+       .attr("text-anchor", function(d) {
+         return d.children || d._children ? "end" : "start";
+       })
+       .text(function(d) {
+         return d.name;
+       });
+
+   // Change the circle fill depending on whether it has children and is collapsed
+   node.select("circle.nodeCircle")
+       .attr("r", 4.5)
+       .style("fill", function(d) {
+         return d._children ? "lightsteelblue" : "#fff";
+       });
+
+   // Transition nodes to their new position.
+   var nodeUpdate = node.transition()
+                        .duration(duration)
+                        .attr("transform", function(d) {
+                          return "translate(" + d.y + "," + d.x + ")";
+                        });
+
+   // Fade the text in
+   nodeUpdate.select("text")
+             .style("fill-opacity", 1);
+
+   // Transition exiting nodes to the parent's new position.
+   var nodeExit = node.exit().transition()
+                      .duration(duration)
+                      .attr("transform", function(d) {
+                        return "translate(" + source.y + "," + source.x + ")";
+                      })
+                      .remove();
+
+   nodeExit.select("circle")
+           .attr("r", 0);
+
+   nodeExit.select("text")
+           .style("fill-opacity", 0);
+
+   // Update the links…
+   var link = svgGroup.selectAll("path.link")
+                      .data(links, function(d) {
+                        return d.target.id;
+                      });
+
+   // Enter any new links at the parent's previous position.
+   link.enter().insert("path", "g")
+       .attr("class", "link")
+       .attr("d", function(d) {
+         var o = {
+           x: source.x0,
+           y: source.y0
+         };
+         return diagonal({
+           source: o,
+           target: o
+         });
+       });
+
+   // Transition links to their new position.
+   link.transition()
+       .duration(duration)
+       .attr("d", diagonal);
+
+   // Transition exiting nodes to the parent's new position.
+   link.exit().transition()
+       .duration(duration)
+       .attr("d", function(d) {
+         var o = {
+           x: source.x,
+           y: source.y
+         };
+         return diagonal({
+           source: o,
+           target: o
+         });
+       })
+       .remove();
+
+   // Stash the old positions for transition.
+   nodes.forEach(function(d) {
+     d.x0 = d.x;
+     d.y0 = d.y;
+   });
+ }
+
+ // Append a group which holds all nodes and which the zoom Listener can act upon.
+ var svgGroup = baseSvg.append("g");
+
+ // Define the root
+ root = treeData;
+ root.x0 = viewerHeight / 2;
+ root.y0 = 0;
+
+ // Layout the tree initially and center on the root node.
+ update(root);
+ centerNode(root);
+</script>
+</body>
+</html>

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: dirtree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Emad Elsaid
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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'
+description: display list of file paths as an interactive tree
+email:
+- blazeeboy@gmail.com
+executables:
+- dirtree
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dirtree.gemspec
+- exe/dirtree
+- lib/dirtree.rb
+- lib/dirtree/node.rb
+- lib/dirtree/version.rb
+- templates/tree.html.erb
+homepage: https://www.github.com/blazeeboy/dirtree
+licenses:
+- MIT
+metadata: {}
+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.6.12
+signing_key: 
+specification_version: 4
+summary: display list of file paths as an interactive tree
+test_files: []