durb 0.1 → 0.2

data/History.txt

@@ -1,3 +1,12 @@
+=== 0.2 / 2009-02-13
+
+* Added help message.
+* Added machine readable output.
+* Added support for multiple paths.
+* Modified human-readable sizes to be shorter and easier on the eye.
+* Added more details and sanity to verbose mode.
+* Small fixes and cleanups.
+
 === 0.1 / 2009-02-11
 
 * First release

data/README.txt

@@ -4,7 +4,8 @@
 
 == DESCRIPTION:
 
-durb is a smarter du. It's a CLI ruby utility which intelligently displays disk usage under a directory or filesystem. durb hides unimportant directories to make it easier to find out where all your disk-space has gone.
+durb is a smarter du(1).
+It's a CLI ruby utility which intelligently displays disk usage under a directory or filesystem. durb hides unimportant directories to make it easier to find out where all your disk-space has gone.
 
 == FEATURES/PROBLEMS:
 

data/bin/durb

@@ -1,7 +1,25 @@
 #!/usr/bin/env ruby
+#
+# Copyright (c) 2009 Matteo Sasso
+#
+# This file is part of durb.
+#
+# durb is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# durb is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with durb.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'getoptlong'
 
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require 'human_readable'
 require 'text_output'
 require 'directory_node'
@@ -10,30 +28,97 @@ require 'reducer'
 
 include HumanReadable
 
-DEFAULT_SIZE = "100m"
+DEFAULT_THRESHOLD = "100m"
+FIELD_NAMES = %w(path self-size small-dirs_size aggregate-size big_dirs-size total-size)
+
+def string_to_sym(s)
+  s.sub('--', '').tr('-', '_').to_sym
+end
 
 opts = GetoptLong.new(
-  ["--size", "-s", GetoptLong::REQUIRED_ARGUMENT],
-  ["--width", "-w", GetoptLong::REQUIRED_ARGUMENT],
+  ["--threshold", "-t", GetoptLong::REQUIRED_ARGUMENT],
   ["--verbose", "-v", GetoptLong::NO_ARGUMENT],
-  ["--one-filesystem", "-x", GetoptLong::NO_ARGUMENT])
+  ["--parsable", "--parseable", "-p", GetoptLong::REQUIRED_ARGUMENT],
+  ["--help", "-h", GetoptLong::NO_ARGUMENT],
+  ["--version", GetoptLong::NO_ARGUMENT],
+  ["--cross-filesystems", "-x", GetoptLong::NO_ARGUMENT])
 
+$options = {}
 opts.each do |opt, arg|
-  case opt
-  when "--size"
-    $size = arg
-  when "--width"
-    $width = arg.to_i
-  when "--verbose"
-    $verbose = true
-  when "--one-filesystem"
-    $one_filesystem = true
+  $options[string_to_sym(opt)] = arg.empty? ? true : arg
+end
+if $options[:version]
+  puts <<END_VERSION
+durb v0.2
+Copyright (c) 2009 Matteo Sasso
+
+END_VERSION
+end
+if $options[:help]
+  puts <<END_HELP
+Synopsis:
+  durb shows where disk space is used. If no path is given, the current
+  directory is used. Disk usage of each path and its subdirectories is
+  calculated and displayed.
+
+Usage:
+  durb [OPTION]... [PATH]...
+
+Options:
+  -h, --help
+          Displays this text and exits.
+
+  -p, --parsable, --parseable=FIELDS
+          The output is optimized for usage in a script. FIELDS is a
+          comma-separated list of output fields to display. Available fields:
+              #{FIELD_NAMES.join(", ")}
+
+  -t, --threshold=SIZE
+          Sets the discrimination threshold. Directories above the size
+          specified are displayed, the others are aggregated.
+          SIZE can use one of the suffixes: k, m, g.
+          By default the threshold is #{DEFAULT_THRESHOLD}.
+
+  -x, --cross-filesystems
+          Descend directories even when they are on different filesystems.
+
+  -v, --verbose
+          By default durb only shows aggregate size for each directory shown.
+          This option enables a more complex report of the disk space used.
+
+END_HELP
+end
+
+exit if $options[:version] or $options[:help]
+
+if $options[:parsable]
+  raise ArgumentError, "--parsable and --verbose make no sens toghether" if $options[:verbose]
+  $options[:output_fields] = $options[:parsable].split(',')
+  $options[:output_fields].each do |f|
+    raise ArgumentError, ("Unknown field: %s" % f) if not FIELD_NAMES.include?(f)
   end
+  $options[:output_fields] = $options[:output_fields].map{|f| string_to_sym(f)}
+  $options[:no_header] = true
+  $options[:exact] = true
+  $options[:parsable] = true
 end
 
-$path = ARGV[0] ? File.expand_path(ARGV[0]) : File.expand_path(".")
-$size = DEFAULT_SIZE if not $size or $size == 0
+$paths = []
+ARGV.each do |p|
+  while File.symlink?(p)
+    p = File.readlink(p)
+  end
+  $paths << p
+end
+$paths = ["."] if $paths.empty?
+$paths = $paths.map{|p| File.expand_path(p)}
 
-tree = DirectoryInspector.new($path, {:one_filesystem => $one_filesystem}).run
-reduced_tree = Reducer.run(tree, text_to_size($size))
-TextOutput.new(reduced_tree, $stdout, {:width => $width, :verbose => $verbose}).print_all(text_to_size($size))
+$path = $paths.first
+$options[:threshold] ||= DEFAULT_THRESHOLD
+
+reduced_trees = []
+$paths.each do |p|
+  tree = DirectoryInspector.new(p).run
+  reduced_trees << Reducer.run(tree, text_to_size($options[:threshold]))
+end
+TextOutput.new(reduced_trees, $stdout).print_all(text_to_size($options[:threshold]))

data/lib/directory_inspector.rb

@@ -1,7 +1,24 @@
+# Copyright (c) 2009 Matteo Sasso
+#
+# This file is part of durb.
+#
+# durb is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# durb is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with durb.  If not, see <http://www.gnu.org/licenses/>.
+
 class DirectoryInspector
-  def initialize(path, options = {})
+  def initialize(path)
     @path = DirectoryNode.string_to_path(path)
-    @filesystem = options[:one_filesystem] ? File.stat(path).dev : nil
+    @filesystem = $options[:cross_filesystems] ? nil : File.stat(path).dev
   end
 
   def run
@@ -10,7 +27,7 @@ class DirectoryInspector
 
 protected
   def make_node(path)
-    size, files, subdirectories = inspect(path)
+    size, files, subdirectories = scan(path)
 
     dir = DirectoryNode.new(path, size, files)
     subdirectories.map{|p| make_node(p)}.select{|n| not n.nil?}.each do |n|
@@ -20,7 +37,7 @@ protected
     return dir
   end
 
-  def inspect(path)
+  def scan(path)
     path_string = DirectoryNode.path_to_string(path)
     size = files = 0
     subdirectories = []
@@ -30,11 +47,11 @@ protected
     rescue Errno::EACCES
       raise $!
     rescue Errno::ENOENT
-      return nil
+      raise $!
     end
     dir.each do |f|
-      next if [".", ".."].include?(f)
-      fname = path_string + f
+      next if f == ".."
+      fname = path_string + '/' + f
       begin
         st = File.lstat(fname)
       rescue Errno::EACCES
@@ -42,13 +59,16 @@ protected
       rescue Errno::ENOENT, Errno::ELOOP
         next
       end
-      next if st.symlink?
-      next if @filesystem and st.dev != @filesystem
-      if st.file?
+      if @filesystem and st.dev != @filesystem
+        $stderr.puts("SKIPPED: different filesystem for %s" % fname)
+        next
+      end
+      if st.file? or st.symlink?
         size += (512 * st.blocks)
         files += 1
+      elsif f == "."
+        size += (512 * st.blocks)
       elsif st.directory?
-        # Need to add directory size?
         subdirectories << path + [f]
       end
     end

data/lib/directory_node.rb

@@ -1,41 +1,79 @@
+# Copyright (c) 2009 Matteo Sasso
+#
+# This file is part of durb.
+#
+# durb is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# durb is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with durb.  If not, see <http://www.gnu.org/licenses/>.
+
 class DirectoryNode
   attr_reader :path, :subdirectories
-  attr_accessor :size, :files, :subsize, :subfiles, :significant
+  attr_accessor :size, :files, :big, :show
+  attr_accessor :s_subsize, :s_subfiles, :s_dirs
+  attr_accessor :i_subsize, :i_subfiles, :i_dirs, :i_rec_dirs
 
-  def initialize(path, size, files, significant = true)
+  def initialize(path, size, files)
     @path = path
     @size = size
     @files = files
-    @subsize = @subfiles = 0
-    @significant = significant
+    @s_subsize = @s_subfiles = @s_dirs = 0
+    @i_subsize = @i_subfiles = @i_dirs = @i_rec_dirs = 0
+    @big = true
+    @show = false
     @subdirectories = []
   end
 
   def add_subdirectory(d)
     @subdirectories << d
-    if d.significant
-      @subsize += d.size + d.subsize
-      @subfiles += d.files + d.subfiles
+    @s_subsize += d.s_subsize
+    @s_subfiles += d.s_subfiles
+    @s_dirs += d.s_dirs
+    if d.big
+      @s_subsize += d.size + d.i_subsize
+      @s_subfiles += d.files + d.i_subfiles
+      @s_dirs += 1 + d.i_dirs
+    else
+      @i_subsize += d.size + d.i_subsize
+      @i_subfiles += d.files + d.i_subfiles
+      @i_rec_dirs += 1 + d.i_dirs
+      @i_dirs += 1
     end
   end
 
-  def significant_subdirectories
-    @subdirectories.select{|n| n.significant}
-  end
-
-  def insignificant_subdirectories
-    @subdirectories.select{|n| not n.significant}
+  def shown_subdirs
+    @subdirectories.select{|n| n.show}
   end
 
   def path_string
     self.class.path_to_string(@path)
   end
 
+  def name
+    @path[-1]
+  end
+
   def self.path_to_string(path)
-    path.length == 0 ? '/' : ('/' + path.join('/') + '/')
+    path.length == 0 ? '/' : ('/' + path.join('/'))
   end
 
   def self.string_to_path(path_string)
     path_string == '/' ? [] : path_string.split('/').reject{|component| component.empty?}
   end
+
+  def inspect(indentation = 0)
+    ' ' * indentation +
+          "#<DirectoryNode:#{path_string} size=#{@size} " +
+          (@big ? "big " : "small ") + (@show ? "shown" : "hidden") +
+          (@subdirectories.empty? ? "" : ("\n" + @subdirectories.map{|d| d.inspect(indentation+2)}.join("\n"))) +
+          ">"
+  end
 end

data/lib/durb.rb

@@ -1,3 +1,3 @@
 class Durb
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/lib/human_readable.rb

@@ -1,3 +1,20 @@
+# Copyright (c) 2009 Matteo Sasso
+#
+# This file is part of durb.
+#
+# durb is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# durb is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with durb.  If not, see <http://www.gnu.org/licenses/>.
+
 module HumanReadable
   SUFFIXES = [' ', 'k', 'm', 'g', 't', 'p']
 
@@ -11,17 +28,16 @@ module HumanReadable
 
   def size_to_text(size)
     exp = 0
+    return size.to_s if size < 10000
     while size > 999
       size /= 1024.0
       exp += 1
     end
 
-    if size >= 100 or exp == 0
-      "%d%s" % [size.round, SUFFIXES[exp]]
-    elsif size >= 10
+    if size < 10
       "%.1f%s" % [size, SUFFIXES[exp]]
     else
-      "%.2f%s" % [size, SUFFIXES[exp]]
+      "%d%s" % [size.round, SUFFIXES[exp]]
     end
   end
 end

data/lib/reducer.rb

@@ -1,13 +1,27 @@
+# Copyright (c) 2009 Matteo Sasso
+#
+# This file is part of durb.
+#
+# durb is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# durb is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with durb.  If not, see <http://www.gnu.org/licenses/>.
+
 module Reducer
   def self.run(tree, threshold)
     rtree = DirectoryNode.new(tree.path, tree.size, tree.files)
 
     tree.subdirectories.each{|n| rtree.add_subdirectory(run(n, threshold))}
-    rtree.insignificant_subdirectories.each do |n|
-      rtree.size += n.size
-      rtree.files += n.files
-    end
-    rtree.significant = (rtree.size >= threshold or not rtree.significant_subdirectories.empty?)
+    rtree.big = ((rtree.size + rtree.i_subsize) >= threshold)
+    rtree.show = (rtree.big or not rtree.shown_subdirs.empty?)
 
     return rtree
   end

data/lib/text_output.rb

@@ -1,57 +1,112 @@
+# Copyright (c) 2009 Matteo Sasso
+#
+# This file is part of durb.
+#
+# durb is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# durb is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with durb.  If not, see <http://www.gnu.org/licenses/>.
+
 class TextOutput
-  def initialize(tree, output, options = {})
-    @width = calc_width(tree) + (options[:verbose] ? 23 : 11)
+  DEFAULT_WIDTH = 78
+
+  def initialize(trees, output)
+    trees_width = trees.map{|t| calc_width(t)}.max
+    @width = trees_width + ($options[:verbose] ? 47 : 9)
     @output = output
     if output.tty?
       begin
         tput = open("|tput cols")
         max_width = tput.gets.to_i
       rescue
-        max_width = 80
+        max_width = ENV["COLUMNS"]
+        max_width = max_width ? max_width.to_i : DEFAULT_WIDTH
       end
       @width = [max_width, @width].min
     end
-    @tree = tree
-    @options = options
+    @trees = trees
   end
 
   def print_all(size)
-    if @options[:verbose]
-      heading = "SELF    SUBS/#   "
-      puts((" " * (@width - heading.size - 2)) + heading)
+    if $options[:verbose] # and not $options[:no_header]
+      # The commented-out code is unneeded right now but may be necessary in the future
+      heading1 = "     SMALL DIRS  AGGREG  BIG DIRS         "
+      heading2 = "SIZE   SIZE/#     SIZE    SIZE/#     TOTAL"
+      puts((" " * (@width - heading1.size - 2)) + heading1)
+      puts((" " * (@width - heading2.size - 2)) + heading2)
+    end
+    @trees.each do |t|
+      print_tree(t, size)
     end
-    print_tree(@tree, size)
   end
 
   def print_tree(tree, size, indentation = 0)
     print_node(tree, size, indentation)
-    tree.significant_subdirectories.each do |n|
+    tree.shown_subdirs.each do |n|
       print_tree(n, size, indentation + 2)
     end
   end
 
   def print_node(node, size, indentation)
-    if $verbose
-      subsize_text = size_to_text(node.subsize)
-      if node.subsize == 0 and node.size == 0
-        size_text = nil; raise "can this happen?"
-      elsif node.subsize == 0
-        size_text = "%5s             " % size_to_text(node.size)
-      elsif node.size == 0
-        size_text = "        %5s/%-4d" % [size_to_text(node.subsize), node.subdirectories.size]
+    if $options[:parsable]
+      @output.puts($options[:output_fields].map do |f|
+        case f
+        when :path
+          if $options[:output_fields].size == 1
+            node.path_string
+          else
+            node.path_string.gsub(":", "\\:")
+          end
+        when :self_size
+          node.size
+        when :small_dirs_size
+          node.i_subsize
+        when :aggregate_size
+          node.i_subsize + node.size
+        when :big_dirs_size
+          node.s_subsize
+        when :total_size
+          node.s_subsize + node.i_subsize + node.size
+        end
+      end.join(':'))
+    else
+      if $options[:verbose]
+        size_and_isize = (node.size > 0 and node.i_subsize > 0)
+        tsize_and_ssize = (node.size + node.i_subsize > 0 and node.s_subsize > 0)
+        size_text = "%4s %1s %9s %1s %4s %1s %9s %1s %4s" % \
+              [
+                (node.size > 0) ? size_to_text(node.size) : nil,
+                size_and_isize ? "+" : nil,
+                (node.i_subsize > 0) ? "%4s/%-4s" % \
+                      [size_to_text(node.i_subsize), size_to_text(node.i_dirs)] : nil,
+                size_and_isize ? "=" : nil,
+                (node.size + node.i_subsize > 0) ? size_to_text(node.size + node.i_subsize) : nil,
+                tsize_and_ssize ? "+" : nil,
+                (node.s_subsize > 0) ? "%4s/%-4s" % \
+                      [size_to_text(node.s_subsize), size_to_text(node.s_dirs)] : nil,
+                tsize_and_ssize ? "=" : nil,
+                (node.size + node.i_subsize + node.s_subsize > 0) ?
+                size_to_text(node.size + node.i_subsize + node.s_subsize) : nil,
+              ]
       else
-        size_text = "%5s + %5s/%-4d" % [size_to_text(node.size), size_to_text(node.subsize), node.subdirectories.size]
+        total_size = node.size + node.i_subsize
+        size_text = total_size < size ? nil : size_to_text(total_size)
       end
-    else
-      total_size = node.size #+ node.subsize
-      size_text = total_size < size ? nil : size_to_text(total_size)
+      align((' ' * indentation) + (indentation == 0 ? node.path_string : node.name), size_text)
     end
-    align((' ' * indentation) + node.path_string, size_text)
   end
 
   def calc_width(tree, indentation = 0)
-    (tree.significant_subdirectories.map{|n| calc_width(n, indentation + 2)} +
-          [tree.path_string.size + indentation]).max
+    (tree.shown_subdirs.map{|n| calc_width(n, indentation + 2)} +
+          [(indentation == 0) ? tree.path_string.size : indentation + tree.name.size]).max
   end
 
   def align(left, right)
@@ -62,6 +117,10 @@ class TextOutput
       size = 0
     end
     @output.print left, ' '
+    if size < 4
+      @output.print " " * size
+      size = 0
+    end
     if not right.empty?
       y = 0
       while size > 0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: durb
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - Matteo Sasso
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-11 00:00:00 +01:00
+date: 2009-02-22 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.8.3
     version: 
-description: durb is a smarter du. It's a CLI ruby utility which intelligently displays disk usage under a directory or filesystem. durb hides unimportant directories to make it easier to find out where all your disk-space has gone.
+description: durb is a smarter du(1). It's a CLI ruby utility which intelligently displays disk usage under a directory or filesystem. durb hides unimportant directories to make it easier to find out where all your disk-space has gone.
 email: 
 - matteo.sasso@gmail.com
 executables: 
@@ -71,6 +71,6 @@ rubyforge_project: durb
 rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
-summary: durb is a smarter du
+summary: durb is a smarter du(1)
 test_files: 
 - test/test_durb.rb