tms 1.2.0 → 1.3.0

data/README.markdown

@@ -4,7 +4,7 @@ Time Machine Status
 
 View avaliable Time Machine backups and show changes
 
-Name and idea from [fernlightning.com](http://www.fernlightning.com/doku.php?id=software:misc:tms)
+Name from [fernlightning.com](http://www.fernlightning.com/doku.php?id=software:misc:tms)
 
 ## Copyright
 

data/Rakefile

@@ -1,4 +1,4 @@
-require 'rubygems'
+# require 'rubygems'
 require 'rake'
 require 'jeweler'
 require 'rake/gem_ghost_task'
@@ -9,7 +9,7 @@ name = 'tms'
 Jeweler::Tasks.new do |gem|
   gem.name = name
   gem.summary = %Q{Time Machine Status}
-  gem.description = %Q{View avaliable Time Machine backups and show diff}
+  gem.description = %Q{View avaliable Time Machine backups and show their diff}
   gem.homepage = "http://github.com/toy/#{name}"
   gem.license = 'MIT'
   gem.authors = ['Boba Fat']

data/VERSION

@@ -1 +1 @@
-1.2.0
+1.3.0

data/bin/tms

@@ -1,46 +1,68 @@
 #!/usr/bin/env ruby
 
-begin
-  require 'tms'
-rescue LoadError
-  require 'rubygems'
-  require 'tms'
-end
-
+require 'tms'
 require 'optparse'
 
 def option_parser
-  OptionParser.new do |op|
+  @option_parser ||= OptionParser.new do |op|
     op.banner = <<-BANNER
+    #{op.program_name}, version #{Tms.version}
+
     Usege:
-      List:                #{op.program_name} [options]
-      Diff:                #{op.program_name} [options] id|nxxx id|nxxx
-      Diff with previous:  #{op.program_name} [options] id|nxxx
+      List: #{op.program_name} [options]
+      Diff: #{op.program_name} [options] id|nXXX [id|nXXX]
       BANNER
 
-    op.on('-d', '--directory DIRECTORY', 'Use backup directory') do |dir|
-      Tms::Backup.backups_dir = dir
+    op.on('-d', '--directory DIRECTORY', 'Use backup directory') do |backups_dir|
+      Tms::Backup.backups_dir = backups_dir
     end
 
-    op.on('-f', '--filter DIRECTORY', 'Show diff starting from directory') do |dir|
-      Tms::Backup.filter_dir = dir
+    op.on('-f', '--filter DIRECTORY', 'Show diff starting from directory', '  (can be used multiple times)') do |filter_dir|
+      Tms::Backup.add_filter_dir(filter_dir)
     end
 
-    op.on('-p', '--[no-]progress', 'Show backups in progress') do |show_in_progress|
+    op.on('-i', '--[no-]in-progress', 'Show backups in progress',
+                                      '  (note: some directories will be',
+                                      '   empty in unfinished backups)') do |show_in_progress|
       Tms::Backup.show_in_progress = show_in_progress
     end
 
     op.on('-l', '--[no-]long', 'Show more info about backup in list') do |show_all_columns|
       Tms::Backup.show_all_columns = show_all_columns
     end
+
+    op.on('--[no-]color', 'Use color', '  (true by default if stdout is a tty)') do |colorize|
+      Tms::Backup.colorize = colorize
+    end
+
+    op.on('--[no-]progress', 'Show progress when counting folder size', '  (true by default if stderr is a tty)') do |show_progress|
+      Tms::Backup.show_progress = show_progress
+    end
+
+    op.on('--[no-]decimal', 'Use base 10 size') do |use_decimal|
+      Tms::Space.base10 = use_decimal
+    end
+
+    op.on_tail('-h', '--help', 'Show this message') do
+      puts op.help
+      exit
+    end
+
+    op.on_tail('--version', 'Show version') do
+      puts Tms.version
+      exit
+    end
   end
 end
 
-options, ids = ARGV.partition{ |arg| arg =~ /^--?\D/ }
+ids, options = ARGV.partition{ |arg| arg =~ /^[\-n]?\d+$/ }
 begin
   option_parser.parse!(options)
-rescue OptionParser::InvalidOption => e
-  abort e
+rescue OptionParser::ParseError => e
+  abort "#{e.to_s}\n#{option_parser.help}"
+end
+unless options.empty?
+  abort "Unknown arguments: #{options.join(' ')}"
 end
 
 case ids.length

data/ext/tms/tms.c

@@ -1,10 +1,11 @@
 #include "ruby.h"
 #include <CoreServices/CoreServices.h>
+#include <SystemConfiguration/SystemConfiguration.h>>
 
 static VALUE backup_volume(VALUE self){
 	OSStatus status = pathTooLongErr;
 	char *path;
-	size_t pathLength = 256;
+	size_t pathLength;
 
 	CFDataRef aliasData;
 	AliasHandle alias;
@@ -15,7 +16,7 @@ static VALUE backup_volume(VALUE self){
 	if (aliasData) {
 		if (noErr == PtrToHand(CFDataGetBytePtr(aliasData), (Handle *)&alias, CFDataGetLength(aliasData))) {
 			if (noErr == FSResolveAlias(NULL, alias, &fs, &wasChanged)) {
-				path = malloc(pathLength);
+				path = malloc(pathLength = 256);
 				while (noErr != (status = FSRefMakePath(&fs, (UInt8*)path, pathLength))) {
 					if (pathTooLongErr == status) {
 						pathLength += 256;
@@ -35,7 +36,30 @@ static VALUE backup_volume(VALUE self){
 	}
 }
 
+static VALUE computer_name(VALUE self){
+	char *name;
+	size_t nameLength;
+
+	CFStringEncoding encoding;
+	CFStringRef cfName;
+
+	if (cfName = SCDynamicStoreCopyComputerName(NULL, &encoding)) {
+		name = malloc(nameLength = 256);
+		while (!CFStringGetCString(cfName, name, nameLength, encoding)) {
+			nameLength += 256;
+			name = reallocf(name, nameLength);
+		}
+
+		CFRelease(cfName);
+
+		return rb_str_new2(name);
+	} else {
+		return Qnil;
+	}
+}
+
 void Init_tms() {
 	VALUE cTms = rb_define_module("Tms");
 	rb_define_singleton_method(cTms, "backup_volume", backup_volume, 0);
+	rb_define_singleton_method(cTms, "computer_name", computer_name, 0);
 }

data/lib/tms.rb

@@ -1,10 +1,18 @@
+require 'tms/path'
+require 'tms/backup'
+require 'tms/table'
+
 module Tms
   class << self
+    def version
+      File.read(File.join(File.dirname(__FILE__), '../VERSION')).strip
+    end
+
     def list
       backups = Backup.list
       Table.new do |t|
-        t.col '', :red
-        t.col '', :blue
+        t.col '', Backup.colorize? && :red
+        t.col '', Backup.colorize? && :blue
         t.col 'num'
         t.col 'name'
         if Backup.show_all_columns
@@ -53,7 +61,7 @@ module Tms
       end
       backup_a = Backup.list[a_id] or abort("No backup #{a}")
       backup_b = Backup.list[b_id] or abort("No backup #{b}")
-      Backup.diff(backup_a, backup_b)
+      Comparison.new(backup_a, backup_b).run
     end
 
   private
@@ -88,9 +96,3 @@ module Tms
     end
   end
 end
-
-require 'tms.so'
-require 'tms/backup'
-require 'tms/space'
-require 'tms/table'
-require 'tms/pathname'

data/lib/tms/backup.rb

@@ -1,135 +1,116 @@
-require 'colored'
 require 'xattr'
+require 'tms.so'
+require 'tms/comparison'
+require 'tms/better_attr_accessor'
 
-class Tms::Backup
-  class << self
-    def backups_dir
-      @backups_dir ||= begin
-        backup_volume = Tms.backup_volume
-        abort 'backup volume not avaliable' if backup_volume.nil?
+module Tms
+  class Backup
+    class << self
+      extend BetterAttrAccessor
 
-        computer_name = `scutil --get ComputerName`.strip
-        abort 'can\'t get computer name' unless $?.success?
+      def backup_volume
+        Tms.backup_volume or abort('backup volume not avaliable')
+      end
 
-        backups_dir = Pathname(backup_volume) + 'Backups.backupdb' + computer_name
-        abort "ops! backups dir is not a dir" unless backups_dir.directory?
+      def computer_name
+        Tms.computer_name or abort('can\'t get computer name')
+      end
 
-        backups_dir
+      def backups_dir
+        unless @backups_dir
+          self.backups_dir = Path.new(backup_volume) / 'Backups.backupdb' / computer_name
+        end
+        @backups_dir
+      end
+      def backups_dir=(backups_dir)
+        backups_dir = Path.new(backups_dir)
+        abort %{backups dir «#{backups_dir}» is not a dir} unless backups_dir.directory?
+        @backups_dir = backups_dir
       end
-    end
-    def backups_dir=(dir)
-      @backups_dir = Pathname(dir)
-    end
 
-    attr_accessor :filter_dir
-    attr_accessor :show_in_progress
-    attr_accessor :show_all_columns
-
-    def list
-      @list ||= begin
-        backups_dir.children.map do |path|
-          case path.basename.to_s
-          when /^\d{4}-\d{2}-\d{2}-\d{6}$/
-            new(path)
-          when /^\d{4}-\d{2}-\d{2}-\d{6}\.inProgress$/
-            if show_in_progress
-              path.children.select(&:directory?).each do |path_in_progress|
-                new(path_in_progress, true)
-              end
-            end
-          end
-        end.flatten.compact.sort
+      def filter_dirs
+        @filter_dirs ||= []
+      end
+      def filter_dirs?
+        !filter_dirs.empty?
+      end
+      def add_filter_dir(filter_dir)
+        filter_dirs << File.expand_path(filter_dir)
       end
-    end
 
-    def diff(a, b)
-      total = 0
-      if filter_dir
-        root_dir = (a.path.children + b.path.children).select(&:directory?).select{ |child| Pathname(File.join(child, filter_dir)).exist? }.map(&:basename).uniq
-        root_dir = File.join(root_dir, filter_dir)
-        total += compare(a.path + root_dir, b.path + root_dir, Pathname('/') + root_dir)
-      else
-        (a.path.children(false) | b.path.children(false)).reject{ |child| child.to_s[0, 1] == '.' }.sort.each do |path|
-          total += compare(a.path + path, b.path + path, Pathname('/') + path)
-        end
+      better_attr_accessor :show_in_progress
+      better_attr_accessor :show_all_columns
+      better_attr_accessor :colorize
+      better_attr_accessor :show_progress
+
+      def colorize?
+        !colorize.nil? ? colorize : $stdout.tty?
       end
-      puts "#{'Total:'.bold} #{Tms::Space.space(total, :color => true)}"
-    end
 
-  private
+      def show_progress?
+        !show_progress.nil? ? show_progress : $stderr.tty?
+      end
 
-    def compare(a, b, path)
-      case
-      when !a.exist?
-        puts "#{'  █'.green} #{b.colored_size(:recursive => true)} #{path}#{b.postfix}"
-        b.count_size || 0
-      when !b.exist?
-        puts "#{'█  '.blue} #{a.colored_size(:recursive => true)} #{path}#{a.postfix}"
-        0
-      when a.ftype != b.ftype
-        puts "#{'!!!'.red.bold} #{a.colored_size(:recursive => true)} #{path} (#{a.ftype}=>#{b.ftype})"
-        b.count_size || 0
-      when a.lino != b.lino
-        if a.readable? && b.readable?
-          puts "#{'█≠█'.yellow} #{a.colored_size} #{path}#{a.postfix}" unless a.symlink? && a.readlink == b.readlink
-          if a.real_directory?
-            total = 0
-            (a.children(false) | b.children(false)).sort.each do |child|
-              total += compare(a + child, b + child, path + child)
+      def list
+        @list ||= begin
+          backups_dir.children.map do |path|
+            case path.basename.to_s
+            when /^\d{4}-\d{2}-\d{2}-\d{6}$/
+              new(path)
+            when /^\d{4}-\d{2}-\d{2}-\d{6}\.inProgress$/
+              if show_in_progress?
+                path.children.select(&:directory?).map do |path_in_progress|
+                  new(path_in_progress, true)
+                end
+              end
             end
-            total
-          else
-            b.size
-          end
-        else
-          puts "??? #{path}#{a.postfix}".red.bold
-          0
+          end.flatten.compact.sort
         end
-      else
-        0
       end
     end
-  end
 
-  attr_reader :path, :in_progress
-  def initialize(path, in_progress = false)
-    @path = path
-    @in_progress = in_progress
-  end
+    extend BetterAttrAccessor
 
-  def name
-    @name ||= in_progress ? "#{path.dirname.basename}/#{path.basename}" : path.basename.to_s
-  end
+    better_attr_reader :path, :in_progress
+    def initialize(path, in_progress = false)
+      @path = path
+      @in_progress = in_progress
+    end
 
-  def started_at
-    @start_date ||= Time.at(xattr.get('com.apple.backupd.SnapshotStartDate').to_i / 1_000_000.0)
-  end
-  def finished_at
-    @finished_at ||= Time.at(xattr.get('com.apple.backupd.SnapshotCompletionDate').to_i / 1_000_000.0)
-  end
-  def completed_in
-    finished_at - started_at
-  end
-  {
-    :state   => 'com.apple.backupd.SnapshotState',
-    :type    => 'com.apple.backupd.SnapshotType',
-    :version => 'com.apple.backup.SnapshotVersion',
-    :number  => 'com.apple.backup.SnapshotNumber',
-  }.each do |name, attr|
-    class_eval <<-src
-      def #{name}
-        @#{name} ||= xattr.get('#{attr}').to_i rescue '-'
-      end
-    src
-  end
+    def name
+      @name ||= in_progress? ? "#{path.dirname.basename}/#{path.basename}" : path.basename.to_s
+    end
 
-  def <=>(other)
-    name <=> other.name
-  end
+    def started_at
+      @start_date ||= Time.at(xattr.get('com.apple.backupd.SnapshotStartDate').to_i / 1_000_000.0)
+    end
+    def finished_at
+      @finished_at ||= Time.at(xattr.get('com.apple.backupd.SnapshotCompletionDate').to_i / 1_000_000.0)
+    end
+    def completed_in
+      finished_at - started_at
+    end
+    {
+      :state   => 'com.apple.backupd.SnapshotState',
+      :type    => 'com.apple.backupd.SnapshotType',
+      :version => 'com.apple.backup.SnapshotVersion',
+      :number  => 'com.apple.backup.SnapshotNumber',
+    }.each do |name, attr|
+      class_eval <<-src
+        def #{name}
+          @#{name} ||= xattr.get('#{attr}').to_i rescue '-'
+        end
+      src
+    end
 
-private
+    def <=>(other)
+      name <=> other.name
+    end
+
+  private
 
-  def xattr
-    @xattr ||= Xattr.new(path)
+    def xattr
+      @xattr ||= Xattr.new(path)
+    end
   end
 end

data/lib/tms/better_attr_accessor.rb

@@ -0,0 +1,20 @@
+module BetterAttrAccessor
+  def better_attr_reader(*names)
+    names.each do |name|
+      attr_reader name
+      # leaves nil and false as is, returns true for everything else
+      class_eval <<-RUBY
+        def #{name}?
+          @#{name} && true
+        end
+      RUBY
+    end
+  end
+
+  def better_attr_accessor(*names)
+    better_attr_reader *names
+    names.each do |name|
+      attr_writer name
+    end
+  end
+end

data/lib/tms/comparison.rb

@@ -0,0 +1,110 @@
+require 'tms/space'
+
+module Tms
+  class Comparison
+    attr_reader :backup_a, :backup_b, :total
+    def initialize(backup_a, backup_b)
+      @backup_a, @backup_b = backup_a, backup_b
+    end
+
+    def run
+      @total = 0
+      begin
+        root_dirs = (backup_a.path.children(false) | backup_b.path.children(false)).sort
+        root_dirs.reject!{ |root_dir| root_dir.path[0, 1] == '.' }
+        root_dirs.each do |root_dir|
+          dirs = Backup.filter_dirs? ? Backup.filter_dirs.map{ |filter_dir| root_dir / filter_dir } : [root_dir]
+          dirs.each do |dir|
+            compare(backup_a.path / dir, backup_b.path / dir, Path.new('/', dir))
+          end
+        end
+      rescue Interrupt
+        puts
+        puts 'Interrupted'
+      end
+      line "#{colorize 'Total:', :total} #{space(total)}"
+    end
+
+  private
+
+    def compare(a, b, path)
+      case
+      when !a.exist?
+        count_space b, path, colorize('  █', :right), "#{path}#{b.postfix}", :recursive => true
+      when !b.exist?
+        count_space a, path, colorize('█  ', :left), "#{path}#{a.postfix}", :recursive => true, :no_total => true
+      when a.ftype != b.ftype
+        count_space b, path, colorize('█≠█', :diff_type), "#{path}#{b.postfix} (#{a.ftype}=>#{b.ftype})", :recursive => true
+      when a.lstat.ino != b.lstat.ino
+        if a.readable_real? && b.readable_real?
+          count_space b, path, colorize('█≠█', :diff), "#{path}#{b.postfix}" unless b.symlink? && a.readlink == b.readlink
+          if b.directory? && !b.symlink?
+            (a.children(false) | b.children(false)).sort.each do |child|
+              compare(a / child, b / child, path / child)
+            end
+          end
+        else
+          line colorize("??? #{Space::NOT_COUNTED_SPACE} #{path}#{a.postfix}", :unreadable)
+        end
+      else
+        progress do
+          path
+        end
+      end
+    end
+
+    COLORS = {
+      :total => {:extra => :bold},
+      :right => {:foreground => :green},
+      :left => {:foreground => :blue},
+      :diff_type => {:foreground => :red, :extra => :bold},
+      :diff => {:foreground => :yellow},
+      :unreadable => {:foreground => :red, :extra => :bold},
+    }
+    CLEAR_LINE = "\e[K"
+
+    def line(s)
+      $stdout.puts "#{s}#{CLEAR_LINE}"
+    end
+
+    def progress
+      if Tms::Backup.show_progress?
+        @last_progress ||= Time.now
+        if (now = Time.now) > @last_progress + 0.1
+          $stderr.print "#{yield}#{CLEAR_LINE}\r"
+          @last_progress = now
+        end
+      end
+    end
+
+    def space(size)
+      Tms::Space.space(size, :color => Tms::Backup.colorize?)
+    end
+
+    def colorize(s, type)
+      if Tms::Backup.colorize?
+        Colored.colorize(s, COLORS[type])
+      else
+        s
+      end
+    end
+
+    def count_space(backup_path, path, prefix, postfix, options = {})
+      sub_total = 0
+      if options[:recursive]
+        backup_path.find do |sub_path|
+          sub_total += sub_path.size_if_real_file
+          progress do
+            "#{prefix} #{space sub_total} #{path / sub_path.to_s[backup_path.to_s.length..-1].to_s}"
+          end
+        end
+      else
+        sub_total = backup_path.size_if_real_file
+      end
+      line "#{prefix} #{space sub_total} #{postfix}"
+      unless options[:no_total]
+        @total += sub_total
+      end
+    end
+  end
+end

data/lib/tms/path.rb

@@ -0,0 +1,118 @@
+require 'find'
+
+module Tms
+  # cleaned up Pathname
+  class Path
+    attr_reader :path
+    def initialize(*parts)
+      @path = File.join(*parts)
+    end
+
+    def /(other)
+      self.class.new(@path, other)
+    end
+
+    def hash
+      @path.hash
+    end
+
+    def ==(other)
+      return false unless Path === other
+      other.to_s == @path
+    end
+    alias_method :===, :==
+    alias_method :eql?, :==
+
+    def <=>(other)
+      return nil unless Path === other
+      @path <=> other.to_s
+    end
+
+    def basename(*args)
+      self.class.new(File.basename(@path, *args))
+    end
+
+    def dirname(*args)
+      self.class.new(File.dirname(@path))
+    end
+
+    def readlink
+      self.class.new(File.readlink(@path))
+    end
+
+    def ftype
+      File.ftype(@path)
+    end
+
+    def lstat
+      File.lstat(@path)
+    end
+
+    def size
+      File.size(@path)
+    end
+
+    def size_if_real_file
+      file? && !symlink? ? File.size(@path) : 0
+    end
+
+    def exist?
+      File.exist?(@path)
+    end
+
+    def file?
+      File.file?(@path)
+    end
+
+    def directory?
+      File.directory?(@path)
+    end
+
+    def symlink?
+      File.symlink?(@path)
+    end
+
+    def readable_real?
+      File.readable_real?(@path)
+    end
+
+    def children(with_directory = true)
+      with_directory = false if @path == '.'
+      result = []
+      Dir.foreach(@path) do |e|
+        next if e == '.' || e == '..'
+        if with_directory
+          result << self.class.new(File.join(@path, e))
+        else
+          result << self.class.new(e)
+        end
+      end
+      result
+    end
+
+    def find(&block)
+      if @path == '.'
+        Find.find(@path){ |f| yield self.class.new(f.sub(/^.\//, '')) }
+      else
+        Find.find(@path){ |f| yield self.class.new(f) }
+      end
+    end
+
+    def to_s
+      @path.dup
+    end
+    alias_method :to_str, :to_s
+    alias_method :to_path, :to_s
+
+    def postfix
+      case
+      when symlink?
+        '@'
+      when directory?
+        '/'
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/tms/space.rb

@@ -1,41 +1,50 @@
 require 'colored'
 
-module Tms::Space
-  SIZE_SYMBOLS = %w[B K M G T P E Z Y].freeze
-  COLORS = [].tap do |colors|
-    [:white, :black, :yellow, :red].each do |color|
-      colors << {:foreground => color}
-      colors << {:foreground => color, :extra => :bold}
-    end
-    colors << {:foreground => :yellow, :extra => :reversed}
-    colors << {:foreground => :red, :extra => :reversed}
-  end.freeze
+module Tms
+  module Space
+    SIZE_SYMBOLS = %w[B K M G T P E Z Y].freeze
+    COLORS = [].tap do |colors|
+      [:white, :black, :yellow, :red].each do |color|
+        colors << {:foreground => color}
+        colors << {:foreground => color, :extra => :bold}
+      end
+      colors << {:foreground => :yellow, :extra => :reversed}
+      colors << {:foreground => :red, :extra => :reversed}
+    end.freeze
+    PRECISION = 1
+    LENGTH = 4 + PRECISION + 1
+    COEF = 1 / Math.log(10)
 
-  def space(size, options = {})
-    precision = [options[:precision].to_i, 1].max || 2
-    length = 4 + precision + (options[:can_be_negative] ? 1 : 0)
+    EMPTY_SPACE = ' ' * LENGTH
+    NOT_COUNTED_SPACE = '!' * LENGTH
 
-    number = size.to_i
-    degree = 0
-    while number.abs >= 1000 && degree < SIZE_SYMBOLS.length - 1
-      degree += 1
-      number /= 1024.0
-    end
+    class << self
+      attr_writer :base10
+      def denominator
+        @denominator ||= @base10 ? 1000.0 : 1024.0
+      end
+
+      def space(size, options = {})
+        case size
+        when false
+          NOT_COUNTED_SPACE.bold.red
+        when 0
+          EMPTY_SPACE
+        else
+          number, degree = size, 0
+          while number.abs >= 1000 && degree < SIZE_SYMBOLS.length - 1
+            number /= denominator
+            degree += 1
+          end
 
-    space = "#{(degree == 0 ? number.to_s : "%.#{precision}f" % number).rjust(length)}#{number == 0 ? ' ' : SIZE_SYMBOLS[degree]}"
-    if options[:color]
-      unless ''.respond_to?(:red)
-        require 'toy/fast_gem'
-        fast_gem 'colored'
+          space = "#{degree == 0 ? number.to_s : "%.#{PRECISION}f" % number}#{SIZE_SYMBOLS[degree]}".rjust(LENGTH)
+          if options[:color]
+            color = [[Math.log(size) * COEF, 1].max.to_i, COLORS.length].min - 1
+            space = Colored.colorize(space, COLORS[color])
+          end
+          space
+        end
       end
-      step = options[:color].is_a?(Hash) && options[:color][:step] || 10
-      start = options[:color].is_a?(Hash) && options[:color][:start] || 1
-      coef = 10.0 / (step * Math.log(10))
-      color = [[Math.log(size) * coef - start, 0].max.to_i, COLORS.length - 1].min rescue 0
-      Colored.colorize(space, COLORS[color])
-    else
-      space
     end
   end
-  self.extend self
 end

data/lib/tms/table.rb

@@ -1,39 +1,41 @@
 require 'colored'
 
-class Tms::Table
-  attr_accessor :cols, :rows
+module Tms
+  class Table
+    attr_accessor :cols, :rows
 
-  def initialize(&block)
-    @cols, @rows = [], []
-    yield self if block_given?
-  end
-
-  ADJUST = {:left => :ljust, :right => :rjust, :center => :center}
-  def col(name, color = nil, adjust = nil)
-    @cols << {:name => name, :color => color, :adjust => ADJUST[adjust]}
-  end
+    def initialize(&block)
+      @cols, @rows = [], []
+      yield self if block_given?
+    end
 
-  def <<(row)
-    @rows << row
-  end
+    ADJUST = {:left => :ljust, :right => :rjust, :center => :center}
+    def col(name, color = nil, adjust = nil)
+      @cols << {:name => name, :color => color, :adjust => ADJUST[adjust]}
+    end
 
-  def lines
-    @cols.each_with_index do |col, i|
-      col[:width] = ([col[:name]] + @rows.map{ |row| row[i] }).map(&:to_s).map(&:length).max
+    def <<(row)
+      @rows << row
     end
 
-    ([@cols.map{ |col| col[:name] }] + @rows).each_with_index.map do |line, i|
-      line.zip(@cols).map do |val, col|
-        width, color, adjust = col.values_at(:width, :color, :adjust)
-        adjust ||= val.is_a?(Integer) ? :rjust : :ljust
-        val_s = val.to_s.send(adjust, width)
-        val_s = Colored.colorize(val_s, :foreground => color) if color
-        val_s
-      end.join(' ')
+    def lines
+      @cols.each_with_index do |col, i|
+        col[:width] = ([col[:name]] + @rows.map{ |row| row[i] }).map(&:to_s).map(&:length).max
+      end
+
+      ([@cols.map{ |col| col[:name] }] + @rows).each_with_index.map do |line, i|
+        line.zip(@cols).map do |val, col|
+          width, color, adjust = col.values_at(:width, :color, :adjust)
+          adjust ||= val.is_a?(Integer) ? :rjust : :ljust
+          val_s = val.to_s.send(adjust, width)
+          val_s = Colored.colorize(val_s, :foreground => color) if color
+          val_s
+        end.join(' ')
+      end
     end
-  end
 
-  def print
-    puts lines
+    def print
+      puts lines
+    end
   end
 end

data/tms.gemspec

@@ -5,13 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tms}
-  s.version = "1.2.0"
+  s.version = "1.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Boba Fat"]
-  s.date = %q{2010-12-06}
+  s.date = %q{2010-12-11}
   s.default_executable = %q{tms}
-  s.description = %q{View avaliable Time Machine backups and show diff}
+  s.description = %q{View avaliable Time Machine backups and show their diff}
   s.executables = ["tms"]
   s.extensions = ["ext/tms/extconf.rb"]
   s.extra_rdoc_files = [
@@ -28,7 +28,9 @@ Gem::Specification.new do |s|
     "ext/tms/tms.c",
     "lib/tms.rb",
     "lib/tms/backup.rb",
-    "lib/tms/pathname.rb",
+    "lib/tms/better_attr_accessor.rb",
+    "lib/tms/comparison.rb",
+    "lib/tms/path.rb",
     "lib/tms/space.rb",
     "lib/tms/table.rb",
     "tms.gemspec"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tms
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 27
   prerelease: false
   segments: 
   - 1
-  - 2
+  - 3
   - 0
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Boba Fat
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-06 00:00:00 +03:00
+date: 2010-12-11 00:00:00 +03:00
 default_executable: tms
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -90,7 +90,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id005
-description: View avaliable Time Machine backups and show diff
+description: View avaliable Time Machine backups and show their diff
 email: 
 executables: 
 - tms
@@ -109,7 +109,9 @@ files:
 - ext/tms/tms.c
 - lib/tms.rb
 - lib/tms/backup.rb
-- lib/tms/pathname.rb
+- lib/tms/better_attr_accessor.rb
+- lib/tms/comparison.rb
+- lib/tms/path.rb
 - lib/tms/space.rb
 - lib/tms/table.rb
 - tms.gemspec

data/lib/tms/pathname.rb

@@ -1,49 +0,0 @@
-require 'pathname'
-
-class Pathname
-  def real_directory?
-    directory? && !symlink?
-  end
-
-  def lino
-    @ino ||= lstat.ino
-  end
-
-  def postfix
-    case
-    when symlink?
-      '@'
-    when directory?
-      '/'
-    else
-      ''
-    end
-  end
-
-  def count_size(options = {})
-    if @count_size.nil?
-      if exist?
-        if directory?
-          @counted_size = 0
-          find{ |path| @counted_size += path.size rescue nil } if options[:recursive]
-        else
-          @counted_size = size
-        end
-      else
-        @counted_size = false
-      end
-    end
-    @counted_size
-  end
-
-  def colored_size(options = {})
-    case size = count_size(options)
-    when false
-      '!!!!!!'
-    when 0
-      '      '
-    else
-      Tms::Space.space(size, :color => true)
-    end
-  end
-end