minitar-cli 0.6

data/lib/minitar/cli/command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# The base for commands in Minitar::CLI. This will be replaced in a future
+# version by one of the better-executed CLI application frameworks like GLI,
+# after Ruby 1.8 and 1.9 support have been dropped.
+class Minitar::CLI::Command
+  @children = []
+
+  attr_reader :commander
+  attr_reader :ioe
+
+  class << self
+    attr_reader :children
+
+    def inherited(subclass)
+      children << subclass
+    end
+  end
+
+  module CatchMinitarErrors # :nodoc:
+    def call(args, opts)
+      run(args, opts)
+    rescue Archive::Tar::Minitar::Error => error
+      ioe[:error] << "#{error}\n"
+      5
+    end
+  end
+
+  def initialize(commander)
+    @commander = commander
+    @ioe = commander.ioe
+  end
+
+  def name
+    raise Minitar::CLI::AbstractCommandError
+  end
+
+  def call(_args, _opts = {})
+    raise Minitar::CLI::AbstractCommandError
+  end
+  alias [] call
+
+  def help
+    raise Minitar::CLI::AbstractCommandError
+  end
+end

data/lib/minitar/cli/command/create.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Tarball creation command. This will be replaced in a future version by one of
+# the better-executed CLI application frameworks like GLI, after Ruby 1.8 and
+# 1.9 support have been dropped.
+class Minitar::CLI::Command::Create < Minitar::CLI::Command
+  def name
+    'create'
+  end
+
+  def altname
+    'cr'
+  end
+
+  HELP = <<-EOH.freeze
+    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
+
+  include CatchMinitarErrors
+
+  def run(args, opts = {})
+    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"
+      commander.command('help').call(%w(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 until ioe[:input].eof?
+      files = files.split(/\r\n|\n|\r/)
+      args.delete('--')
+    end
+
+    files << argv.to_a
+    files.flatten!
+
+    watcher, finisher =
+      if opts[:verbose]
+        verbose
+      elsif opts[:progress]
+        progress
+      else
+        silent
+      end
+
+    Archive::Tar::Minitar.pack(files, output, &watcher)
+    finisher.call
+    0
+  ensure
+    output.close if output && !output.closed?
+  end
+
+  def help
+    HELP
+  end
+
+  private
+
+  def verbose
+    [
+      lambda { |action, name, _stats|
+        opts[:output] << "#{name}\n" if action == :dir || action == :file_done
+      },
+      lambda { opts[:output] << "\n" }
+    ]
+  end
+
+  def progress
+    require 'powerbar'
+    progress = PowerBar.new(:msg => opts[:name], :total => 1)
+    [
+      lambda { |action, name, stats|
+        progress_info = {}
+
+        case action
+        when :file_start, :dir
+          progress_info[:msg] = File.basename(name)
+
+          if action == :dir
+            progress_info[:total] = progress.total + 1
+            progress_info[:done] = progress.done + 1
+          else
+            progress_info[:total] = progress.total + stats[:size]
+          end
+        when :file_progress
+          progress_info[:done] = progress.done + stats[:currinc]
+        end
+
+        progress.show(progress_info)
+      },
+      lambda {
+        progress.show(:msg => opts[:name])
+        progress.close(true)
+      }
+    ]
+  end
+
+  def silent
+    [ lambda { |_, _, _| }, lambda {} ]
+  end
+end

data/lib/minitar/cli/command/extract.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# Tarball extraction command. This will be replaced in a future version by one
+# of the better-executed CLI application frameworks like GLI, after Ruby 1.8
+# and 1.9 support have been dropped.
+class Minitar::CLI::Command::Extract < Minitar::CLI::Command
+  def name
+    'extract'
+  end
+
+  def altname
+    'ex'
+  end
+
+  HELP = <<-EOH.freeze
+    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
+
+  include CatchMinitarErrors
+
+  def run(args, opts = {})
+    argv    = []
+    output  = nil
+    dest    = '.'
+    files   = []
+
+    while (arg = args.shift)
+      case arg
+      when '--uncompress', '-z'
+        opts[:uncompress] = true
+      when '--pipe'
+        output = ioe[:output]
+        ioe[:output] = ioe[:error]
+      when '--output', '-o'
+        dest = args.shift
+      else
+        argv << arg
+      end
+    end
+
+    if argv.empty?
+      ioe[:output] << "Not enough arguments.\n\n"
+      commander.command('help').call(%w(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!
+
+    watcher, finisher =
+      if opts[:verbose]
+        verbose
+      elsif opts[:progress]
+        progress
+      else
+        silent
+      end
+
+    if output.nil?
+      Archive::Tar::Minitar.unpack(input, dest, files, &watcher)
+      finisher.call
+    else
+      Archive::Tar::Minitar::Input.each_entry(input) do |entry|
+        next unless files.empty? || files.include?(entry.full_name)
+
+        stats = {
+          :mode     => entry.mode,
+          :mtime    => entry.mtime,
+          :size     => entry.size,
+          :gid      => entry.gid,
+          :uid      => entry.uid,
+          :current  => 0,
+          :currinc  => 0,
+          :entry    => entry
+        }
+
+        if entry.directory?
+          watcher.call(:dir, dest, stats)
+        else
+          watcher.call(:file_start, destfile, stats)
+          loop do
+            data = entry.read(4096)
+            break unless data
+            stats[:currinc] = output.write(data)
+            stats[:current] += stats[:currinc]
+
+            watcher.call(:file_progress, name, stats)
+          end
+          watcher.call(:file_done, name, stats)
+        end
+      end
+    end
+
+    0
+  end
+
+  def help
+    HELP
+  end
+
+  private
+
+  def verbose
+    [
+      lambda { |action, name, _stats|
+        ioe[:output] << "#{name}\n" if action == :dir or action == :file_done
+      },
+      lambda { ioe[:output] << "\n" }
+    ]
+  end
+
+  def progress
+    require 'powerbar'
+    progress = PowerBar.new(:msg => opts[:name], :total => 1)
+    [
+      lambda { |action, name, stats|
+        progress_info = {}
+
+        case action
+        when :file_start, :dir
+          progress_info[:msg] = File.basename(name)
+          if action == :dir
+            progress_info[:total] = progress.total + 1
+            progress_info[:done] = progress.done + 1
+          else
+            progress_info[:total] = progress.total + stats[:entry].size
+          end
+        when :file_progress
+          progress_info[:done] = progress.done + stats[:currinc]
+        end
+
+        progress.show(progress_info)
+      },
+      lambda {
+        progress.show(:msg => opts[:name])
+        progress.close(true)
+      }
+    ]
+  end
+
+  def silent
+    [ lambda { |_, _, _| }, lambda {} ]
+  end
+end

data/lib/minitar/cli/command/help.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Help command. This will be replaced in a future version by one of the
+# better-executed CLI application frameworks like GLI, after Ruby 1.8 and 1.9
+# support have been dropped.
+class Minitar::CLI::Command::Help < Minitar::CLI::Command
+  def name
+    'help'
+  end
+
+  COMMANDS = <<-EOS.freeze
+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.
+
+  EOS
+
+  BASIC = <<-EOS.freeze
+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')
+EOS
+
+  def call(args, _opts = {})
+    help_on = args.shift
+
+    if commander.command?(help_on)
+      ioe[:output] << commander[help_on].help
+    elsif help_on == 'commands'
+      ioe[:output] << COMMANDS
+    else
+      unless help_on.nil? or help_on.empty?
+        ioe[:output] << "Unknown command: #{help_on}\n"
+      end
+      ioe[:output] << help
+    end
+
+    0
+  end
+
+  def help
+    BASIC
+  end
+end

data/lib/minitar/cli/command/list.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# Tarball list command. This will be replaced in a future version by one of the
+# better-executed CLI application frameworks like GLI, after Ruby 1.8 and 1.9
+# support have been dropped.
+class Minitar::CLI::Command::List < Minitar::CLI::Command
+  def name
+    'list'
+  end
+
+  def altname
+    'ls'
+  end
+
+  HELP = <<-EOH.freeze
+    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
+
+  def modestr(mode)
+    s = String.new('---')
+    s[0] = 'r' if (mode & 4) == 4
+    s[1] = 'w' if (mode & 2) == 2
+    s[2] = 'x' if (mode & 1) == 1
+    s
+  end
+
+  include CatchMinitarErrors
+
+  def run(args, opts = {})
+    argv    = []
+    output  = nil
+    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.empty?
+      ioe[:output] << "Not enough arguments.\n\n"
+      commander.command('help').call(%w(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].to_sym
+    opts[:field] = :full_name if opts[:field] == :name
+
+    output = []
+
+    today = Time.now
+    oneyear = Time.mktime(today.year - 1, today.month, today.day)
+
+    Archive::Tar::Minitar::Input.each_entry(input) do |entry|
+      next unless files.empty? || files.include?(entry.full_name)
+
+      value = format % fields.map { |ff|
+        case ff
+        when 'permissions'
+          s = String.new(entry.directory? ? 'd' : '-')
+          s << modestr(entry.mode / 0o100)
+          s << modestr(entry.mode / 0o010)
+          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
+      }
+
+      if opts[:sort]
+        output << [ entry.send(opts[:field]), value ]
+      else
+        ioe[:output] << value << "\n"
+      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
+  end
+end