facets 1.7.46 → 1.8.0

data/setup.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
-#
+# Setup and install.
+
 # setup.rb
 #
 # Copyright (c) 2000-2005 Minero Aoki
@@ -8,7 +9,6 @@
 # This program is free software.
 # You can distribute/modify this program under the terms of
 # the GNU LGPL, Lesser General Public License version 2.1.
-#
 
 unless Enumerable.method_defined?(:map)   # Ruby 1.4.6
   module Enumerable

data/test/special/main_as_module.rb

@@ -0,0 +1,14 @@
+# require 'facets/more/main_as_module.rb'
+
+$toplevel = self
+
+module Test
+
+  def self.included( base )
+    p base == (class << $toplevel; self; end)
+  end
+
+end
+
+include Test
+

data/work/README

@@ -0,0 +1,42 @@
+= Important
+
+Facets is a GENERAL PURPOSE library. It is vital that is stay that way!
+
+Under no circumstances should something be added to Facets specific to
+a particular use case or application. While a lib might serve the needs
+of such, the lib itself must have general applicability. Although not a
+sure test in either "direction", a good rule of thumb for such a 
+condition is whether a lib has an external dependency --it should not.
+
+= The Work Folder
+
+This directory contains alpha code and is generally considered
+expiremental. It is provided as a means for common development
+and potential inspiration.
+
+Some of these, or variations there-of, will eventually become
+part of the main lib, many will not.
+
+Notice this development directory reflects the main lib directory
+in structure with the exception of an extra folder called 'reference'.
+This folder holds material gathered from outside sources that have
+not sifted through yet, but could yield some useful code in the future.
+
+The directores break down like so:
+
+  core / 
+    work on core extensions
+
+  more/
+    work on more additions
+
+  pore/
+    stuff from outside world that might be useful
+    or have useful bits.
+
+  yore/
+    stuff that either used to be in Facets but was
+    removed or was considered for inclusion but
+    wasn't and kept temporarily for reference.
+    Basically, these are on the verge of the trashcan.
+

data/work/TODO

@@ -0,0 +1,73 @@
+
+= Facets' To Do List
+
+IT IS ALWAYS A GOOD IDEA TO WRITE A TEST!
+AND ITS ALWAYS A FINE THING TO IMPROVE DOCUMENTATION!
+
+* Move methods to facets/method and link back to facet/ but prefer library alias
+  instead. (Rolls)
+
+* hash/invert: What about letting Hash#invert take a block that specifies
+  what to do when a collision occurs?
+
+* hash/at_rand: allow for a _number_ of values, keys and pairs to be returned.
+
+* > Yep. Gone. But I may replace with a version that deletes only the first 
+  > matching element. Thoughts?
+  If you don't want to do that I would rather add an option hash to .delete and
+  use :once => true or something similar. (More expressive)
+
+* numeric/bound_by: Numeric includes Comparable. Maybe drop this, but 
+  might it be reasonable for Numeric but no other comparables?
+
+* nil/[]: Why should nil respond to [], but not to .each? I don't think 
+  nil should be treated as a container.
+  nil/length: See above.
+
+* nil/method_missing: I'm not so sure about this. There is a lot of 
+  libraries depending on nil raising exceptions on failed method access. I 
+  also think that this could make programming errors very hard to find.
+
+* fileutils/head&tail: Hm, I think the block forms ought to be equivalent to 
+  tail -f and so on. Then the block forms should also return all lines by default
+  instead of only the first 10.
+
+* fileutils/which: Should probably be based on fileutils/where_is as they have 
+  lots of common code. The two methods should probably also use RUBY_PLATFORM instead
+  of checking for ALT_SEPARATOR.
+
+* module/memoize: Should the main memoize method be defined as it is? 
+  (see bottom of file).
+
+* kernel/demo: It can be implemented as demo "1+1"  using Binding.of_caller. 
+  Using only the block is possibly with SCRIPT_LINES__ or File access and is quite ugly.
+
+* hash/weave: Document how does it compare to Hash#merge?
+
+* Perhaps work on alernative require mechinism. Currently there is none.
+  Here some pseudo docs for it:
+
+    and an alternative interface to requiring the extension methods.
+    With the Facets module you can require a facet method like so:
+
+      Facets.require Time, :stamp
+
+    One of the advantages of this approach is that Facets' can search the class hierarchy
+    for a method. For example if you wanted to use #each_permutation on an Array.
+
+      Facets.require 'array/each_permutation'
+
+    Even though #each_permutation is a method of Enumerable this will still work
+    because Enumerable is a superclass of Array.
+
+    Also it allows for the use operators without special recourse.
+    For instance, the Proc compostion operator can be require simply.
+
+      Facets.require 'proc/*'
+
+    If you're wondering why you have to specify the Facets module in #use,
+    it is becuase #use is a generalized method. Anyone can easily take advantage
+    of this functionality by utilizing Facets' Module-Package system (package.rb).
+    See the API Documentation for further details of putting this to use in your
+    programs.
+

data/work/bin/minitar

@@ -0,0 +1,3 @@
+#! /usr/bin/ruby1.8
+
+load 'ratchets/command/minitar.rb'

data/work/bin/minitar.rb

@@ -0,0 +1,814 @@
+#!/usr/bin/env ruby
+#--
+# Archive::Tar::Baby 0.5.1
+#   Copyright � 2004 Mauricio Julio Fern�ndez Pradier and Austin Ziegler
+#   This is free software with ABSOLUTELY NO WARRANTY.
+#
+# This program is based on and incorporates parts of RPA::Package from
+# rpa-base (lib/rpa/package.rb and lib/rpa/util.rb) by Mauricio and has been
+# adapted to be more generic by Austin.
+#
+# This file contains an adaptation of Ruby/ProgressBar by Satoru
+# Takabayashi <satoru@namazu.org>, copyright � 2001 - 2004.
+#
+# It is licensed under the GNU General Public Licence or Ruby's licence.
+#
+# $Id: command.rb,v 1.4 2004/09/22 17:47:43 austin Exp $
+#++
+
+require 'zlib'
+
+# TODO: add
+# TODO: delete ???
+
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+
+module Archive::Tar::Minitar::Command
+  class ProgressBar
+    VERSION = "0.8"
+
+    attr_accessor :total
+    attr_accessor :title
+
+    def initialize (title, total, out = STDERR)
+      @title = title
+      @total = total
+      @out = out
+      @bar_width = 80
+      @bar_mark = "o"
+      @current = 0
+      @previous = 0
+      @is_finished = false
+      @start_time = Time.now
+      @previous_time = @start_time
+      @title_width = 14
+      @format = "%-#{@title_width}s %3d%% %s %s"
+      @format_arguments = [:title, :percentage, :bar, :stat]
+      show
+    end
+
+  private
+    def convert_bytes (bytes)
+      if bytes < 1024
+        sprintf("%6dB", bytes)
+      elsif bytes < 1024 * 1000 # 1000kb
+        sprintf("%5.1fKB", bytes.to_f / 1024)
+      elsif bytes < 1024 * 1024 * 1000  # 1000mb
+        sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+      else
+        sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+      end
+    end
+
+    def transfer_rate
+      bytes_per_second = @current.to_f / (Time.now - @start_time)
+      sprintf("%s/s", convert_bytes(bytes_per_second))
+    end
+
+    def bytes
+      convert_bytes(@current)
+    end
+
+    def format_time (t)
+      t = t.to_i
+      sec = t % 60
+      min  = (t / 60) % 60
+      hour = t / 3600
+      sprintf("%02d:%02d:%02d", hour, min, sec);
+    end
+
+    # ETA stands for Estimated Time of Arrival.
+    def eta
+      if @current == 0
+        "ETA:  --:--:--"
+      else
+      elapsed = Time.now - @start_time
+      eta = elapsed * @total / @current - elapsed;
+      sprintf("ETA:  %s", format_time(eta))
+      end
+    end
+
+    def elapsed
+      elapsed = Time.now - @start_time
+      sprintf("Time: %s", format_time(elapsed))
+    end
+
+    def stat
+      if @is_finished then elapsed else eta end
+    end
+
+    def stat_for_file_transfer
+      if @is_finished then 
+        sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+      else 
+        sprintf("%s %s %s", bytes, transfer_rate, eta)
+      end
+    end
+
+    def eol
+      if @is_finished then "\n" else "\r" end
+    end
+
+    def bar
+      len = percentage * @bar_width / 100
+      sprintf("|%s%s|", @bar_mark * len, " " *  (@bar_width - len))
+    end
+
+    def percentage(value = nil)
+      if @total.zero?
+        100
+      else
+        (value || @current) * 100 / @total
+      end
+    end
+
+    def title
+      @title[0,(@title_width - 1)] + ":"
+    end
+
+    def get_width
+      # FIXME: I don't know how portable it is.
+      default_width = 80
+        #   begin
+        #     tiocgwinsz = 0x5413
+        #     data = [0, 0, 0, 0].pack("SSSS")
+        #     if @out.ioctl(tiocgwinsz, data) >= 0 then
+        #       rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        #       if cols >= 0 then cols else default_width end
+        #     else
+        #       default_width
+        #     end
+        #   rescue Exception
+        #     default_width
+        #   end
+    end
+
+    def show
+      arguments = @format_arguments.map {|method| send(method) }
+      line = sprintf(@format, *arguments)
+
+      width = get_width
+      if line.length == width - 1 
+        @out.print(line + eol)
+      elsif line.length >= width
+        @bar_width = [@bar_width - (line.length - width + 1), 0].max
+        if @bar_width == 0 then @out.print(line + eol) else show end
+      else # line.length < width - 1
+        @bar_width += width - line.length + 1
+        show
+      end
+      @previous_time = Time.now
+    end
+
+    def show_progress
+      if @total.zero?
+        cur_percentage = 100
+        prev_percentage = 0
+      else
+        cur_percentage  = (@current  * 100 / @total).to_i
+        prev_percentage = (@previous * 100 / @total).to_i
+      end
+
+      if cur_percentage > prev_percentage || 
+        Time.now - @previous_time >= 1 ||
+        @is_finished
+        show
+      end
+    end
+
+  public
+      def file_transfer_mode
+      @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]  
+    end
+
+    def format= (format)
+      @format = format
+    end
+
+    def format_arguments= (arguments)
+      @format_arguments = arguments
+    end
+
+    def finish
+      @current = @total
+      @is_finished = true
+      show_progress
+    end
+
+    def halt
+      @is_finished = true
+      show_progress
+    end
+
+    def set (count)
+      if count < 0 || count > @total
+        raise "invalid count: #{count} (total: #{@total})"
+      end
+      @current = count
+      show_progress
+      @previous = @current
+    end
+
+    def inc (step = 1)
+      @current += step
+      @current = @total if @current > @total
+      show_progress
+      @previous = @current
+    end
+
+    def inspect
+      "(ProgressBar: #{@current}/#{@total})"
+    end
+  end
+
+  class CommandPattern
+    class AbstractCommandError < Exception; end
+    class UnknownCommandError < RuntimeError; end
+    class CommandAlreadyExists < RuntimeError; end
+
+    class << self
+      def add(command)
+        command = command.new if command.kind_of?(Class)
+
+        @commands ||= {}
+        if @commands.has_key?(command.name)
+          raise CommandAlreadyExists
+        else
+          @commands[command.name] = command
+        end
+
+        if command.respond_to?(:altname)
+          unless @commands.has_key?(command.altname)
+            @commands[command.altname] = command
+          end
+        end
+      end
+
+      def <<(command)
+        add(command)
+      end
+
+      attr_accessor :default
+      def default=(command) #:nodoc:
+        if command.kind_of?(CommandPattern)
+        @default = command
+        elsif command.kind_of?(Class)
+          @default = command.new
+        elsif @commands.has_key?(command)
+          @default = @commands[command]
+        else
+          raise UnknownCommandError
+        end
+      end
+
+      def command?(command)
+        @commands.has_key?(command)
+      end
+
+      def command(command)
+        if command?(command)
+          @commands[command]
+        else
+          @default
+        end
+      end
+
+      def [](cmd)
+        self.command(cmd)
+      end
+
+      def default_ioe(ioe = {})
+        ioe[:input]   ||= $stdin
+        ioe[:output]  ||= $stdout
+        ioe[:error]   ||= $stderr
+        ioe
+      end
+    end
+
+    def [](args, opts = {}, ioe = {})
+      call(args, opts, ioe)
+    end
+
+    def name
+      raise AbstractCommandError
+    end
+
+    def call(args, opts = {}, ioe = {})
+      raise AbstractCommandError
+    end
+
+    def help
+      raise AbstractCommandError
+    end
+  end
+
+  class CommandHelp < CommandPattern
+    def name
+      "help"
+    end
+
+    def call(args, opts = {}, ioe = {})
+      ioe = CommandPattern.default_ioe(ioe)
+
+      help_on = args.shift
+
+      if CommandPattern.command?(help_on)
+        ioe[:output] << CommandPattern[help_on].help
+      elsif help_on == "commands"
+        ioe[:output] << <<-EOH
+The commands known to minitar are:
+
+    minitar create          Creates a new tarfile.
+    minitar extract         Extracts files from a tarfile.
+    minitar list            Lists files in the tarfile.
+
+All commands accept the options --verbose and --progress, which are
+mutually exclusive. In "minitar list", --progress means the same as
+--verbose.
+
+  --verbose, -V     Performs the requested command verbosely.
+  --progress, -P    Shows a progress bar, if appropriate, for the action
+                    being performed.
+
+        EOH
+      else
+        ioe[:output] << "Unknown command: #{help_on}\n" unless help_on.nil? or help_on.empty?
+        ioe[:output] << self.help
+      end
+
+      0
+    end
+
+    def help
+      help = <<-EOH
+This is a basic help message containing pointers to more information on
+how to use this command-line tool. Try:
+
+    minitar help commands       list all 'minitar' commands
+    minitar help <COMMAND>      show help on <COMMAND>
+                                  (e.g., 'minitar help create')
+      EOH
+    end
+#   minitar add             Adds a file to an existing tarfile.
+#   minitar delete          Deletes a file from an existing tarfile.
+  end
+
+  class CommandCreate < CommandPattern
+    def name
+      "create"
+    end
+
+    def altname
+      "cr"
+    end
+
+    def call(args, opts = {}, ioe = {})
+      argv    = []
+
+      while (arg = args.shift)
+        case arg
+        when '--compress', '-z'
+          opts[:compress] = true
+        else
+          argv << arg
+        end
+      end
+
+      if argv.size < 2
+        ioe[:output] << "Not enough arguments.\n\n"
+        CommandPattern["help"][["create"]]
+        return 255
+      end
+
+      output = argv.shift
+      if '-' == output
+        opts[:name] = "STDOUT"
+        output = ioe[:output]
+        opts[:output] = ioe[:error]
+      else
+        opts[:name] = output
+        output = File.open(output, "wb")
+        opts[:output] = ioe[:output]
+      end
+
+      if opts[:name] =~ /\.tar\.gz$|\.tgz$/ or opts[:compress]
+        output = Zlib::GzipWriter.new(output)
+      end
+
+      files = []
+      if argv.include?("--")
+          # Read stdin for the list of files.
+        files = ""
+        files << ioe[:input].read while not ioe[:input].eof?
+        files = files.split(/\r\n|\n|\r/)
+        args.delete("--")
+      end
+
+      files << argv.to_a
+      files.flatten!
+
+      if opts[:verbose]
+        watcher = lambda do |action, name, stats|
+          opts[:output] << "#{name}\n" if action == :dir or action == :file_done
+        end
+        finisher = lambda { opts[:output] << "\n" }
+      elsif opts[:progress]
+        progress = ProgressBar.new(opts[:name], 1)
+        watcher = lambda do |action, name, stats|
+          case action
+          when :file_start, :dir
+            progress.title = File.basename(name)
+            if action == :dir
+              progress.total += 1
+              progress.inc
+            else
+              progress.total += stats[:size]
+            end
+          when :file_progress
+            progress.inc(stats[:currinc])
+          end
+        end
+        finisher = lambda do
+          progress.title = opts[:name]
+          progress.finish
+        end
+      else
+        watcher = nil
+        finisher = lambda { }
+      end
+
+      Archive::Tar::Minitar.pack(files, output, &watcher)
+      finisher.call
+      0
+    ensure
+      output.close if output and not output.closed?
+    end
+
+    def help
+      help = <<-EOH
+    minitar create [OPTIONS] <tarfile|-> <file|directory|-->+
+
+Creates a new tarfile. If the tarfile is named .tar.gz or .tgz, then it
+will be compressed automatically. If the tarfile is "-", then it will be
+output to standard output (stdout) so that minitar may be piped.
+
+The files or directories that will be packed into the tarfile are
+specified after the name of the tarfile itself. Directories will be
+processed recursively. If the token "--" is found in the list of files
+to be packed, additional filenames will be read from standard input
+(stdin). If any file is not found, the packaging will be halted.
+
+create Options:
+    --compress, -z  Compresses the tarfile with gzip.
+
+      EOH
+    end
+  end
+
+  class CommandExtract < CommandPattern
+    def name
+      "extract"
+    end
+
+    def altname
+      "ex"
+    end
+
+    def call(args, opts = {}, ioe = {})
+      argv    = []
+      output  = nil
+      dest    = "."
+      files   = []
+
+      while (arg = args.shift)
+        case arg
+        when '--uncompress', '-z'
+          opts[:uncompress] = true
+        when '--pipe'
+          opts[:output] = ioe[:error]
+          output = ioe[:output]
+        when '--output', '-o'
+          dest = args.shift
+        else
+          argv << arg
+        end
+      end
+
+      if argv.size < 1
+        ioe[:output] << "Not enough arguments.\n\n"
+        CommandPattern["help"][["extract"]]
+        return 255
+      end
+
+      input = argv.shift
+      if '-' == input
+        opts[:name] = "STDIN"
+        input = ioe[:input]
+      else
+        opts[:name] = input
+        input = File.open(input, "rb")
+      end
+
+      if opts[:name] =~ /\.tar\.gz$|\.tgz$/ or opts[:uncompress]
+        input = Zlib::GzipReader.new(input)
+      end
+
+      files << argv.to_a
+      files.flatten!
+
+      if opts[:verbose]
+        watcher = lambda do |action, name, stats|
+          opts[:output] << "#{name}\n" if action == :dir or action == :file_done
+        end
+        finisher = lambda { opts[:output] << "\n" }
+      elsif opts[:progress]
+        progress = ProgressBar.new(opts[:name], 1)
+        watcher = lambda do |action, name, stats|
+          case action
+          when :file_start, :dir
+            progress.title = File.basename(name)
+            if action == :dir
+              progress.total += 1
+              progress.inc
+            else
+              progress.total += stats[:entry].size
+            end
+          when :file_progress
+            progress.inc(stats[:currinc])
+          end
+        end
+        finisher = lambda do
+          progress.title = opts[:name]
+          progress.finish
+        end
+      else
+        watcher = nil
+        finisher = lambda { }
+      end
+
+      if output.nil?
+        Archive::Tar::Minitar.unpack(input, dest, files, &watcher)
+        finisher.call
+      else
+        Archive::Tar::Minitar::Input.open(input) do |inp|
+          inp.each do |entry|
+            stats = {
+              :mode     => entry.mode,
+              :mtime    => entry.mtime,
+              :size     => entry.size,
+              :gid      => entry.gid,
+              :uid      => entry.uid,
+              :current  => 0,
+              :currinc  => 0,
+              :entry    => entry
+            }
+
+            if files.empty? or files.include?(entry.full_name)
+              if entry.directory?
+                puts "Directory: #{entry.full_name}"
+                watcher[:dir, dest, stats] unless watcher.nil?
+              else
+                puts "File: #{entry.full_name}"
+                watcher[:file_start, destfile, stats] unless watcher.nil?
+                loop do
+                  data = entry.read(4096)
+                  break unless data
+                  stats[:currinc] = output.write(data)
+                  stats[:current] += stats[:currinc]
+
+                  watcher[:file_progress, name, stats] unless watcher.nil?
+                end
+                watcher[:file_done, name, stats] unless watcher.nil?
+              end
+            end
+          end
+        end
+      end
+
+      0
+    end
+
+    def help
+      help = <<-EOH
+    minitar extract [OPTIONS] <tarfile|-> [<file>+]
+
+Extracts files from an existing tarfile. If the tarfile is named .tar.gz
+or .tgz, then it will be uncompressed automatically. If the tarfile is
+"-", then it will be read from standard input (stdin) so that minitar
+may be piped.
+
+The files or directories that will be extracted from the tarfile are
+specified after the name of the tarfile itself. Directories will be
+processed recursively. Files must be specified in full. A file
+"foo/bar/baz.txt" cannot simply be specified by specifying "baz.txt".
+Any file not found will simply be skipped and an error will be reported.
+
+extract Options:
+    --uncompress, -z  Uncompresses the tarfile with gzip.
+    --pipe            Emits the extracted files to STDOUT for piping.
+    --output, -o      Extracts the files to the specified directory.
+
+      EOH
+    end
+  end
+
+  class CommandList < CommandPattern
+    def name
+      "list"
+    end
+
+    def altname
+      "ls"
+    end
+
+    def modestr(mode)
+      s = "---"
+      s[0] = ?r if (mode & 4) == 4
+      s[1] = ?w if (mode & 2) == 2
+      s[2] = ?x if (mode & 1) == 1
+      s
+    end
+
+    def call(args, opts = {}, ioe = {})
+      argv    = []
+      output  = nil
+      dest    = "."
+      files   = []
+      opts[:field] = "name"
+
+      while (arg = args.shift)
+        case arg
+        when '--sort', '-S'
+          opts[:sort]   = true
+          opts[:field]  = args.shift
+        when '--reverse', '-R'
+          opts[:reverse] = true
+          opts[:sort]    = true
+        when '--uncompress', '-z'
+          opts[:uncompress] = true
+        when '-l'
+          opts[:verbose] = true
+        else
+          argv << arg
+        end
+      end
+
+      if argv.size < 1
+        ioe[:output] << "Not enough arguments.\n\n"
+        CommandPattern["help"][["list"]]
+        return 255
+      end
+
+      input = argv.shift
+      if '-' == input
+        opts[:name] = "STDIN"
+        input = ioe[:input]
+      else
+        opts[:name] = input
+        input = File.open(input, "rb")
+      end
+
+      if opts[:name] =~ /\.tar\.gz$|\.tgz$/ or opts[:uncompress]
+        input = Zlib::GzipReader.new(input)
+      end
+
+      files << argv.to_a
+      files.flatten!
+
+      if opts[:verbose] or opts[:progress]
+        format  = "%10s %4d %8s %8s %8d %12s %s"
+        datefmt = "%b %d  %Y"
+        timefmt = "%b %d %H:%M"
+        fields  = %w(permissions inodes user group size date fullname)
+      else
+        format  = "%s"
+        fields  = %w(fullname)
+      end
+
+      opts[:field] = opts[:field].intern
+      opts[:field] = :full_name if opts[:field] == :name
+
+      output = []
+
+      Archive::Tar::Minitar::Input.open(input) do |inp|
+        today = Time.now
+        oneyear = Time.mktime(today.year - 1, today.month, today.day)
+        inp.each do |entry|
+          value = format % fields.map do |ff|
+            case ff
+            when "permissions"
+              s = entry.directory? ? "d" : "-"
+              s << modestr(entry.mode / 0100)
+              s << modestr(entry.mode / 0010)
+              s << modestr(entry.mode)
+            when "inodes"
+              entry.size / 512
+            when "user"
+              entry.uname || entry.uid || 0
+            when "group"
+              entry.gname || entry.gid || 0
+            when "size"
+              entry.size
+            when "date"
+              if Time.at(entry.mtime) > (oneyear)
+                Time.at(entry.mtime).strftime(timefmt)
+              else
+                Time.at(entry.mtime).strftime(datefmt)
+              end
+            when "fullname"
+              entry.full_name
+            end
+          end
+
+          if opts[:sort]
+            output << [entry.send(opts[:field]), value]
+          else
+            ioe[:output] << value << "\n"
+          end
+
+        end
+      end
+
+      if opts[:sort]
+        output = output.sort { |a, b| a[0] <=> b[0] }
+        if opts[:reverse]
+          output.reverse_each { |oo| ioe[:output] << oo[1] << "\n" }
+        else
+          output.each { |oo| ioe[:output] << oo[1] << "\n" }
+        end
+      end
+
+      0
+    end
+
+    def help
+      help = <<-EOH
+    minitar list [OPTIONS] <tarfile|-> [<file>+]
+
+Lists files in an existing tarfile. If the tarfile is named .tar.gz or
+.tgz, then it will be uncompressed automatically. If the tarfile is "-",
+then it will be read from standard input (stdin) so that minitar may be
+piped.
+
+If --verbose or --progress is specified, then the file list will be
+similar to that produced by the Unix command "ls -l".
+
+list Options:
+    --uncompress, -z      Uncompresses the tarfile with gzip.
+    --sort [<FIELD>], -S  Sorts the list of files by the specified
+                          field. The sort defaults to the filename.
+    --reverse, -R         Reverses the sort.
+    -l                    Lists the files in detail.
+
+Sort Fields:
+  name, mtime, size
+
+      EOH
+    end
+  end
+
+  CommandPattern << CommandHelp
+  CommandPattern << CommandCreate
+  CommandPattern << CommandExtract
+  CommandPattern << CommandList
+# CommandPattern << CommandAdd
+# CommandPattern << CommandDelete
+
+  def self.run(argv, input = $stdin, output = $stdout, error = $stderr)
+    ioe = {
+      :input  => input,
+      :output => output,
+      :error  => error,
+    }
+    opts = { }
+
+    if argv.include?("--version")
+      output << <<-EOB
+minitar #{Archive::Tar::Minitar::VERSION}
+  Copyright 2004 Mauricio Julio Fern�ndez Pradier and Austin Ziegler
+  This is free software with ABSOLUTELY NO WARRANTY.
+
+  see http://rubyforge.org/projects/ruwiki for more information
+      EOB
+    end
+
+    if argv.include?("--verbose") or argv.include?("-V")
+      opts[:verbose]  = true
+      argv.delete("--verbose")
+      argv.delete("-V")
+    end
+
+    if argv.include?("--progress") or argv.include?("-P")
+      opts[:progress] = true
+      opts[:verbose]  = false
+      argv.delete("--progress")
+      argv.delete("-P")
+    end
+
+    command = CommandPattern[(argv.shift or "").downcase]
+    command ||= CommandPattern["help"]
+    return command[argv, opts, ioe]
+  end
+end