durb 0.1

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.1 / 2009-02-11
+
+* First release
+

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/durb
+lib/directory_inspector.rb
+lib/directory_node.rb
+lib/durb.rb
+lib/human_readable.rb
+lib/reducer.rb
+lib/text_output.rb

data/README.txt

@@ -0,0 +1,40 @@
+= durb
+
+* http://durb.rubyforge.org
+
+== 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.
+
+== FEATURES/PROBLEMS:
+
+* Slow
+
+== SYNOPSIS:
+
+  durb [-s size] [directory]
+
+== REQUIREMENTS:
+
+* None
+
+== INSTALL:
+
+* sudo gem install
+
+== LICENSE:
+
+Copyright (c) 2009 Matteo Sasso
+
+This program 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.
+                
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,11 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/durb.rb'
+
+Hoe.new('durb', Durb::VERSION) do |p|
+  p.developer('Matteo Sasso', 'matteo.sasso@gmail.com')
+end
+
+# vim: syntax=Ruby

data/bin/durb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'getoptlong'
+
+require 'human_readable'
+require 'text_output'
+require 'directory_node'
+require 'directory_inspector'
+require 'reducer'
+
+include HumanReadable
+
+DEFAULT_SIZE = "100m"
+
+opts = GetoptLong.new(
+  ["--size", "-s", GetoptLong::REQUIRED_ARGUMENT],
+  ["--width", "-w", GetoptLong::REQUIRED_ARGUMENT],
+  ["--verbose", "-v", GetoptLong::NO_ARGUMENT],
+  ["--one-filesystem", "-x", GetoptLong::NO_ARGUMENT])
+
+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
+  end
+end
+
+$path = ARGV[0] ? File.expand_path(ARGV[0]) : File.expand_path(".")
+$size = DEFAULT_SIZE if not $size or $size == 0
+
+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))

data/lib/directory_inspector.rb

@@ -0,0 +1,58 @@
+class DirectoryInspector
+  def initialize(path, options = {})
+    @path = DirectoryNode.string_to_path(path)
+    @filesystem = options[:one_filesystem] ? File.stat(path).dev : nil
+  end
+
+  def run
+    make_node(@path)
+  end
+
+protected
+  def make_node(path)
+    size, files, subdirectories = inspect(path)
+
+    dir = DirectoryNode.new(path, size, files)
+    subdirectories.map{|p| make_node(p)}.select{|n| not n.nil?}.each do |n|
+      dir.add_subdirectory(n)
+    end
+
+    return dir
+  end
+
+  def inspect(path)
+    path_string = DirectoryNode.path_to_string(path)
+    size = files = 0
+    subdirectories = []
+
+    begin
+      dir = Dir.new(path_string)
+    rescue Errno::EACCES
+      raise $!
+    rescue Errno::ENOENT
+      return nil
+    end
+    dir.each do |f|
+      next if [".", ".."].include?(f)
+      fname = path_string + f
+      begin
+        st = File.lstat(fname)
+      rescue Errno::EACCES
+        raise $!
+      rescue Errno::ENOENT, Errno::ELOOP
+        next
+      end
+      next if st.symlink?
+      next if @filesystem and st.dev != @filesystem
+      if st.file?
+        size += (512 * st.blocks)
+        files += 1
+      elsif st.directory?
+        # Need to add directory size?
+        subdirectories << path + [f]
+      end
+    end
+
+    return size, files, subdirectories
+  end
+end

data/lib/directory_node.rb

@@ -0,0 +1,41 @@
+class DirectoryNode
+  attr_reader :path, :subdirectories
+  attr_accessor :size, :files, :subsize, :subfiles, :significant
+
+  def initialize(path, size, files, significant = true)
+    @path = path
+    @size = size
+    @files = files
+    @subsize = @subfiles = 0
+    @significant = significant
+    @subdirectories = []
+  end
+
+  def add_subdirectory(d)
+    @subdirectories << d
+    if d.significant
+      @subsize += d.size + d.subsize
+      @subfiles += d.files + d.subfiles
+    end
+  end
+
+  def significant_subdirectories
+    @subdirectories.select{|n| n.significant}
+  end
+
+  def insignificant_subdirectories
+    @subdirectories.select{|n| not n.significant}
+  end
+
+  def path_string
+    self.class.path_to_string(@path)
+  end
+
+  def self.path_to_string(path)
+    path.length == 0 ? '/' : ('/' + path.join('/') + '/')
+  end
+
+  def self.string_to_path(path_string)
+    path_string == '/' ? [] : path_string.split('/').reject{|component| component.empty?}
+  end
+end

data/lib/durb.rb

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

data/lib/human_readable.rb

@@ -0,0 +1,27 @@
+module HumanReadable
+  SUFFIXES = [' ', 'k', 'm', 'g', 't', 'p']
+
+  def text_to_size(text)
+    number, multiplier = text.match(/^(\d+)(\D)?$/)[1..-1]
+    exp = multiplier ? SUFFIXES.index(multiplier) : 0
+    raise ArgumentError, "Unknown suffix: %s" % multiplier if not exp
+
+    return number.to_i * 1024**exp
+  end
+
+  def size_to_text(size)
+    exp = 0
+    while size > 999
+      size /= 1024.0
+      exp += 1
+    end
+
+    if size >= 100 or exp == 0
+      "%d%s" % [size.round, SUFFIXES[exp]]
+    elsif size >= 10
+      "%.1f%s" % [size, SUFFIXES[exp]]
+    else
+      "%.2f%s" % [size, SUFFIXES[exp]]
+    end
+  end
+end

data/lib/reducer.rb

@@ -0,0 +1,14 @@
+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?)
+
+    return rtree
+  end
+end

data/lib/text_output.rb

@@ -0,0 +1,76 @@
+class TextOutput
+  def initialize(tree, output, options = {})
+    @width = calc_width(tree) + (options[:verbose] ? 23 : 11)
+    @output = output
+    if output.tty?
+      begin
+        tput = open("|tput cols")
+        max_width = tput.gets.to_i
+      rescue
+        max_width = 80
+      end
+      @width = [max_width, @width].min
+    end
+    @tree = tree
+    @options = options
+  end
+
+  def print_all(size)
+    if @options[:verbose]
+      heading = "SELF    SUBS/#   "
+      puts((" " * (@width - heading.size - 2)) + heading)
+    end
+    print_tree(@tree, size)
+  end
+
+  def print_tree(tree, size, indentation = 0)
+    print_node(tree, size, indentation)
+    tree.significant_subdirectories.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]
+      else
+        size_text = "%5s + %5s/%-4d" % [size_to_text(node.size), size_to_text(node.subsize), node.subdirectories.size]
+      end
+    else
+      total_size = node.size #+ node.subsize
+      size_text = total_size < size ? nil : size_to_text(total_size)
+    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
+  end
+
+  def align(left, right)
+    right = "" if not right
+    size = @width - (left.size + right.size + 4)
+    if size <= 0
+      left = left[0..(size-4)] + '...'
+      size = 0
+    end
+    @output.print left, ' '
+    if not right.empty?
+      y = 0
+      while size > 0
+        @output.print(((y + left.size) % 2 == 0) ? '.' : ' ')
+        size -= 1
+        y += 1
+      end
+      @output.print ' ', right
+    end
+    @output.print "\n"
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: durb
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Matteo Sasso
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !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.
+email: 
+- matteo.sasso@gmail.com
+executables: 
+- durb
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/durb
+- lib/directory_inspector.rb
+- lib/directory_node.rb
+- lib/durb.rb
+- lib/human_readable.rb
+- lib/reducer.rb
+- lib/text_output.rb
+has_rdoc: true
+homepage: http://durb.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: durb
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: durb is a smarter du
+test_files: 
+- test/test_durb.rb