rakpak 1.0.0 → 1.2.0

data/lib/rakpak/unpack.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "formats"
+require_relative "plan"
+
+module Rakpak
+  class Unpack
+    # `codec` is a TAR_CODECS id, so packing's binary probing decides readability.
+    Shape = Struct.new(:ext, :kind, :codec, keyword_init: true) do
+      def tool = kind == :zip ? "unzip" : "tar"
+
+      def bin = codec && Rakpak.tar_codec(codec)&.bin
+    end
+
+    # Longest extension first, so notes.tar.gz never reads as a bare .gz.
+    SHAPES = [
+      Shape.new(ext: ".tar",     kind: :tar),
+      Shape.new(ext: ".tar.gz",  kind: :tar, codec: :gzip),
+      Shape.new(ext: ".tar.zst", kind: :tar, codec: :zstd),
+      Shape.new(ext: ".tar.xz",  kind: :tar, codec: :xz),
+      Shape.new(ext: ".tar.bz2", kind: :tar, codec: :bzip2),
+      Shape.new(ext: ".tar.lz4", kind: :tar, codec: :lz4),
+      Shape.new(ext: ".tar.br",  kind: :tar, codec: :brotli),
+      Shape.new(ext: ".tgz",     kind: :tar, codec: :gzip),
+      Shape.new(ext: ".tzst",    kind: :tar, codec: :zstd),
+      Shape.new(ext: ".txz",     kind: :tar, codec: :xz),
+      Shape.new(ext: ".tbz2",    kind: :tar, codec: :bzip2),
+      Shape.new(ext: ".tbz",     kind: :tar, codec: :bzip2),
+      Shape.new(ext: ".zip",     kind: :zip),
+      Shape.new(ext: ".gz",      kind: :single, codec: :gzip),
+      Shape.new(ext: ".zst",     kind: :single, codec: :zstd),
+      Shape.new(ext: ".xz",      kind: :single, codec: :xz),
+      Shape.new(ext: ".bz2",     kind: :single, codec: :bzip2),
+      Shape.new(ext: ".lz4",     kind: :single, codec: :lz4),
+      Shape.new(ext: ".br",      kind: :single, codec: :brotli)
+    ].sort_by { |s| -s.ext.length }.freeze
+
+    def self.format(path)
+      name = File.basename(path.to_s).downcase
+      SHAPES.find { |s| name.end_with?(s.ext) && name.length > s.ext.length }
+    end
+
+    def self.archive?(path) = !format(path).nil?
+
+    # A name reducing to "", "." or ".." would resolve to the parent, so keep the whole basename.
+    def self.strip_ext(path)
+      name = File.basename(path.to_s)
+      shape = format(path)
+      stripped = shape ? name[0...-shape.ext.length] : name
+      ["", ".", ".."].include?(stripped) ? name : stripped
+    end
+
+    def self.default_subdir(path)
+      format(path)&.kind == :single ? nil : strip_ext(path)
+    end
+
+    def self.member_name(path) = strip_ext(path)
+
+    attr_reader :archive, :shape
+    attr_accessor :dest
+
+    def initialize(archive:, dest:)
+      @archive = File.expand_path(archive)
+      @dest = File.expand_path(dest)
+      @shape = Unpack.format(@archive)
+    end
+
+    def kind = @shape&.kind
+    def single? = kind == :single
+
+    # Job chdirs here, so it must exist before the first step runs.
+    def base = @dest
+
+    def outputs = [single? ? File.join(@dest, Unpack.member_name(@archive)) : @dest]
+    def output = outputs.first
+    def clobbers_output? = single?
+
+    # Output is opened before the archive is read, so write here and rename over on success.
+    def scratch = File.join(@dest, ".#{Unpack.member_name(@archive)}.part")
+
+    def prepare
+      @made = []
+      dir = @dest
+      until File.directory?(dir) || dir == "/"
+        @made << dir
+        dir = File.dirname(dir)
+      end
+      FileUtils.mkdir_p(@dest)
+    end
+
+    def commit
+      File.rename(scratch, output) if single? && File.exist?(scratch)
+    end
+
+    # Remove only folders we created that stayed empty.
+    def rollback
+      (@made || []).each do |dir|
+        Dir.rmdir(dir) if File.directory?(dir) && Dir.empty?(dir)
+      rescue StandardError
+        nil
+      end
+    end
+
+    # Counting members would mean decompressing the whole archive first.
+    def total_members(_sizer) = nil
+
+    def gerund = "unpacking"
+
+    def outcome
+      return "#{File.basename(output)} #{Text.bytes(file_size(output))}" if single?
+
+      "unpacked into #{File.basename(@dest)}/"
+    end
+
+    def report_note = single? ? Text.bytes(file_size(output)) : "unpacked"
+
+    def file_size(path)
+      File.size(path)
+    rescue StandardError
+      nil
+    end
+
+    def tar_argv
+      argv = ["tar", "-x", "-v"]
+      # GNU tar appends -d when reading (brotli refuses a repeated -d); bsdtar runs the string as given.
+      argv += ["--use-compress-program", Tools.tar_flavor == :bsd ? "#{@shape.bin} -d" : @shape.bin] if @shape.bin
+      argv + ["-f", @archive, "-C", @dest]
+    end
+
+    def zip_argv = ["unzip", "-o", @archive, "-d", @dest]
+
+    def single_argv = [@shape.bin, "-dc", @archive]
+
+    # [label, argv, expects_verbose_output, stdout_path]
+    def steps
+      case kind
+      when :tar then [["tar", tar_argv, true, nil]]
+      when :zip then [["unzip", zip_argv, true, nil]]
+      when :single then [[@shape.bin, single_argv, false, scratch]]
+      else []
+      end
+    end
+
+    def preview
+      steps.map { |(label, argv, _, stdout)| [label, Plan.show_cmd(argv, stdout)] }
+    end
+
+    def missing?(bin) = !Tools.available?(bin)
+
+    # GNU tar and bsdtar can hand the stream to a compressor; busybox cannot.
+    def tar_pipes? = Tools.tar_pipes?
+
+    def tools = [@shape&.kind == :single ? nil : @shape&.tool, @shape&.bin].compact
+
+    def problems
+      return ["not an archive rakpak knows how to open: #{File.basename(@archive)}"] if @shape.nil?
+
+      errs = []
+      if !File.exist?(@archive) then errs << "no such file: #{@archive}"
+      elsif !File.file?(@archive) then errs << "not a file: #{@archive}"
+      elsif !File.readable?(@archive) then errs << "not readable: #{@archive}"
+      end
+      tools.each { |bin| errs << "#{bin} not installed" if missing?(bin) }
+      if kind == :tar && @shape.bin && !tar_pipes?
+        errs << "this tar cannot pipe through #{@shape.bin}"
+      end
+      # mkdir_p would raise EEXIST partway through the run; say it up front.
+      errs << "not a folder: #{@dest}" if File.exist?(@dest) && !File.directory?(@dest)
+      # tar needs to list the folder to avoid clobbering.
+      if File.directory?(@dest) && !File.readable?(@dest)
+        errs << "destination is not readable: #{@dest}"
+      end
+      parent = existing_parent(@dest)
+      errs << "destination is not writable: #{parent}" unless File.writable?(parent)
+      errs.uniq
+    end
+
+    def existing_parent(dir)
+      dir = File.dirname(dir) until File.directory?(dir) || dir == "/"
+      dir
+    end
+
+    def warnings
+      warn = []
+      if single?
+        warn << "#{Unpack.member_name(@archive)} already exists and will be replaced" if File.exist?(output)
+      elsif File.directory?(@dest) && !empty_dir?(@dest)
+        warn << "#{File.basename(@dest)} already has files in it; matching names will be replaced"
+      end
+      warn
+    end
+
+    # Must not raise: the confirm screen calls this while drawing.
+    def empty_dir?(dir)
+      Dir.children(dir).empty?
+    rescue StandardError
+      true
+    end
+  end
+end

data/lib/rakpak/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rakpak
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/lib/rakpak.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "rakpak/version"
+require_relative "rakpak/unpack"
 require_relative "rakpak/app"
 
 module Rakpak
@@ -9,36 +10,36 @@ module Rakpak
 
     usage: rakpak [folder]
            rakpak -p path [path ...]
+           rakpak -d archive [archive ...]
 
       folder         start browsing there (default: your home folder)
       -p, --pack     tag the given files or folders and go straight to the
                      archive prompts, starting with the kind of compression
+      -d, --depack   unpack the archives here and now, no browsing: each one
+                     into a folder of its own name in the current folder
       -h, --help     this text
       -v, --version  print the version
 
       space      tag / untag       p    pack what is tagged
-      h l ← →   navigate           /    filter      .  hidden
-      enter      enter folder       T    review tags
-      ?          all keys           q    quit
+      h l ← →   navigate           u    unpack what the cursor is on
+      enter      enter folder       /    filter      .  hidden
+      ?          all keys           T    review tags       q  quit
   USAGE
 
-  Options = Struct.new(:dir, :pack, :action, keyword_init: true)
+  Options = Struct.new(:dir, :pack, :unpack, :action, keyword_init: true)
 
-  # A folder as a person would type it: ~, ~/x, $HOME/x, ${HOME}/x, or an
-  # absolute or relative path.
   def self.expand_dir(text)
     text = text.to_s.strip
     text = text.gsub(/\$\{(\w+)\}|\$(\w+)/) { ENV.fetch(::Regexp.last_match(1) || ::Regexp.last_match(2), "") }
     text = "~" if text.empty?
     File.expand_path(text)
   rescue ArgumentError
-    text # ~nosuchuser and the like; the caller reports it is not a folder
+    text
   end
 
-  # Returns Options. `action` is :browse, :help or :version. Raises
-  # ArgumentError on anything it does not understand.
   def self.parse(argv)
     pack_mode = false
+    depack_mode = false
     positional = []
     rest = argv.dup
     until rest.empty?
@@ -47,12 +48,28 @@ module Rakpak
       when "-h", "--help" then return Options.new(action: :help)
       when "-v", "--version" then return Options.new(action: :version)
       when "-p", "--pack" then pack_mode = true
+      when "-d", "--depack", "--unpack" then depack_mode = true
       when "--" then positional.concat(rest) && rest.clear
       when /\A-./ then raise ArgumentError, "unknown option: #{arg}"
       else positional << arg
       end
     end
 
+    raise ArgumentError, "-p and -d do different things; pick one" if pack_mode && depack_mode
+
+    if depack_mode
+      raise ArgumentError, "-d needs at least one archive" if positional.empty?
+
+      paths = positional.map { |p| File.expand_path(p) }
+      paths.each do |p|
+        raise ArgumentError, "no such file: #{p}" unless File.exist?(p)
+        unless File.file?(p) && Unpack.archive?(p)
+          raise ArgumentError, "not an archive rakpak knows how to open: #{File.basename(p)}"
+        end
+      end
+      return Options.new(action: :unpack, unpack: paths, pack: [])
+    end
+
     if pack_mode
       raise ArgumentError, "-p needs at least one path" if positional.empty?
 
@@ -60,20 +77,70 @@ module Rakpak
       paths.each do |p|
         raise ArgumentError, "no such file or folder: #{p}" unless File.exist?(p) || File.symlink?(p)
       end
-      # Open the browser on the folder holding the first target, with that
-      # target under the cursor, so the archive lands next to it.
-      Options.new(action: :browse, dir: File.dirname(paths.first), pack: paths)
+      Options.new(action: :browse, dir: File.dirname(paths.first), pack: paths, unpack: [])
     else
       raise ArgumentError, "expected one folder, got #{positional.size}" if positional.size > 1
 
       dir = File.expand_path(positional.first || Dir.home)
       raise ArgumentError, "not a folder: #{dir}" unless File.directory?(dir)
 
-      Options.new(action: :browse, dir: dir, pack: [])
+      Options.new(action: :browse, dir: dir, pack: [], unpack: [])
+    end
+  end
+
+  def self.unpack_all(archives, dir: Dir.pwd, out: $stdout)
+    status = 0
+    archives.each do |archive|
+      sub = Unpack.default_subdir(archive)
+      plan = Unpack.new(archive: archive, dest: sub ? File.join(dir, sub) : dir)
+      problems = plan.problems
+      if problems.any?
+        problems.each { |m| warn "rakpak: #{m}" }
+        status = 1
+        next
+      end
+      out.puts "#{Text.plain(File.basename(archive))} → #{Text.plain(Text.tilde(plan.dest))}"
+      plan.warnings.each { |w| out.puts "  #{w}" }
+      # The job writes to stderr; flush so the streams stay in order.
+      out.flush
+      status = 1 unless run_headless(plan, out)
+    end
+    status
+  rescue Interrupt
+    130
+  end
+
+  # The extractor runs in its own process group, so ctrl-c never reaches it;
+  # catching Interrupt here is what stops tar carrying on without us.
+  def self.run_headless(plan, out)
+    job = Job.new(plan).start
+    live = out.respond_to?(:tty?) && out.tty?
+    begin
+      while job.running?
+        job.wait(0.1)
+        next unless live
+
+        out.print "\r  #{job.file_count} entries · #{Text.duration(job.elapsed)}\e[K"
+        out.flush
+      end
+    rescue Interrupt
+      out.print "\r\e[K" if live
+      job.cancel
+      job.wait(5)
+      warn "rakpak: cancelled"
+      raise
+    end
+    out.print "\r\e[K" if live
+    unless job.ok?
+      warn "rakpak: #{job.error}"
+      # Member names come from inside the archive; defang before printing.
+      job.tail(4).each { |line| warn "  #{Text.plain(line)}" unless line.start_with?("▸") }
+      return false
     end
+    out.puts "  #{job.file_count} entries · #{Text.duration(job.elapsed)} · #{plan.report_note}"
+    true
   end
 
-  # Exit status.
   def self.start(argv = ARGV)
     begin
       opts = parse(argv)
@@ -89,6 +156,8 @@ module Rakpak
     when :version
       puts "rakpak #{VERSION}"
       return 0
+    when :unpack
+      return unpack_all(opts.unpack)
     end
     unless $stdout.tty? && $stdin.tty?
       warn "rakpak: needs an interactive terminal"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rakpak
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ryan Wilson
@@ -11,7 +11,8 @@ date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A terminal file browser for building archives. Walk around, tag files
   and folders wherever they live, then pack them into one compressed tarball, plain
-  tarball or zip. No dependencies beyond Ruby and the archive tools on your machine.
+  tarball or zip. Unpacks them again too, from the browser or straight from the command
+  line. No dependencies beyond Ruby and the archive tools on your machine.
 email:
 - ryan@ryanwilson.io
 executables:
@@ -36,14 +37,15 @@ files:
 - lib/rakpak/term.rb
 - lib/rakpak/text.rb
 - lib/rakpak/theme.rb
+- lib/rakpak/unpack.rb
 - lib/rakpak/version.rb
-homepage: https://github.com/rywils/rakpak
+homepage: https://github.com/eof0/rakpak
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/rywils/rakpak
-  source_code_uri: https://github.com/rywils/rakpak
-  bug_tracker_uri: https://github.com/rywils/rakpak/issues
+  homepage_uri: https://github.com/eof0/rakpak
+  source_code_uri: https://github.com/eof0/rakpak
+  bug_tracker_uri: https://github.com/eof0/rakpak/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -61,6 +63,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Tag files anywhere on your filesystem and archive them all at once from the
-  terminal.
+summary: Tag files anywhere on your filesystem, archive them all at once, and unpack
+  again, from the terminal.
 test_files: []