rakpak 1.0.0

data/lib/rakpak/plan.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require_relative "formats"
+
+module Rakpak
+  # Turns a set of tagged paths plus the wizard's answers into one concrete
+  # command. Nothing here shells out; commands are spawned without a shell,
+  # so spaces and quotes in filenames are never a hazard.
+  #
+  # Three shapes of output, one file each:
+  #   :both   tar, then compress            name.tar.gz, name.tar.zst, ...
+  #   :tar    plain tar, no compression     name.tar
+  #   :zip    compression only              name.zip, or name.txt.gz for one file
+  class Plan
+    TARGETS = %i[both tar zip].freeze
+
+    attr_reader :paths
+    attr_accessor :outdir, :basename, :target
+    attr_accessor :tar_codec, :tar_level, :tar_flags, :compressor, :comp_level, :zip_flags
+
+    def initialize(paths:, outdir:, basename: "archive", target: :both)
+      @paths = self.class.prune(paths)
+      @outdir = outdir
+      @basename = basename
+      @target = target
+      # gzip is the one every system can read; anything else is opt-in.
+      @tar_codec = TAR_CODECS.find { |c| c.id == :gzip && c.available? } || tar_codec_fallback
+      @tar_level = @tar_codec.default
+      @tar_flags = Rakpak.tar_flags
+      @compressor = COMPRESSORS.find { |c| c.container? && c.available? } || COMPRESSORS.first
+      @comp_level = @compressor.default
+      @zip_flags = Rakpak.zip_flags
+    end
+
+    # Drop anything already covered by another selection: tagging ~/docs and
+    # then ~/docs/notes would otherwise store notes twice, silently.
+    def self.prune(paths)
+      # Sorting by path components puts every descendant right after its
+      # ancestor ("a/b" before "a-x"), so one pass with a stack of accepted
+      # ancestors is enough, however many paths there are.
+      sorted = paths.map { |p| File.expand_path(p) }.uniq.sort_by { |p| p.split("/") }
+      kept = []
+      stack = []
+      sorted.each do |p|
+        stack.pop while stack.any? && !inside?(p, stack.last)
+        next if stack.any?
+
+        kept << p
+        stack << p
+      end
+      kept
+    end
+
+    def self.inside?(path, dir)
+      path.start_with?(dir == "/" ? "/" : "#{dir}/")
+    end
+
+    # "none" needs no tool so it is always available; it is the last
+    # resort, not the first pick, when gzip is missing.
+    def tar_codec_fallback
+      TAR_CODECS.find { |c| c.bin && c.available? } || Rakpak.tar_codec(:none)
+    end
+
+    # One format's knobs behind a uniform face, so the option form does not
+    # need to know whether it is editing tar or compressor settings. Picking
+    # a codec resets the level to that codec's default.
+    class Side
+      attr_reader :options, :flags
+
+      def initialize(plan, options:, codec:, level:, flags:, choices:)
+        @plan = plan
+        @options = options
+        @codec_attr = codec
+        @level_attr = level
+        @flags = flags
+        @choices = choices
+      end
+
+      def codec = @plan.public_send(@codec_attr)
+      def level = @plan.public_send(@level_attr)
+      def level=(v)
+        @plan.public_send("#{@level_attr}=", v)
+      end
+
+      # [label, id, enabled, why] rows for the form's choice list.
+      def choices = @plan.public_send(@choices)
+
+      def codec=(id)
+        c = @options.find { |o| o.id == id } or raise ArgumentError, "unknown codec #{id}"
+        @plan.public_send("#{@codec_attr}=", c)
+        self.level = c.default
+      end
+    end
+
+    def tar
+      Side.new(self, options: TAR_CODECS, codec: :tar_codec, level: :tar_level,
+                     flags: @tar_flags, choices: :tar_choices)
+    end
+
+    def compress
+      Side.new(self, options: COMPRESSORS, codec: :compressor, level: :comp_level,
+                     flags: @zip_flags, choices: :compress_choices)
+    end
+
+    # "both" means compressed, so "none" is not on offer there.
+    def tar_choices
+      TAR_CODECS.reject { |c| c.id == :none }.map { |c| [c.label, c.id, c.available?, c.why_not] }
+    end
+
+    # Single-file compressors only make sense for exactly one file; zip can
+    # take anything.
+    def compress_choices
+      COMPRESSORS.map do |c|
+        ok = c.available? && (c.container? || single_file?)
+        why = c.why_not || "compresses one file only; choose both for folders"
+        [c.label, c.id, ok, ok ? nil : why]
+      end
+    end
+
+    def single_file? = @paths.size == 1 && File.file?(@paths.first)
+
+    # True when the output is a bare compressed file (notes.txt.gz), where
+    # the original name should be kept whole.
+    def single_compress? = @target == :zip && !@compressor.container?
+
+    # Deepest directory containing every tagged path. Members are stored
+    # relative to it, so the archive has a sane shape no matter how far
+    # apart the selections were.
+    def base
+      @base ||= begin
+        dirs = @paths.map { |p| File.dirname(p) }
+        common = dirs.first.to_s.split("/")
+        dirs.each do |d|
+          parts = d.split("/")
+          i = 0
+          i += 1 while i < common.size && i < parts.size && common[i] == parts[i]
+          common = common[0...i]
+        end
+        c = common.join("/")
+        c.empty? ? "/" : c
+      end
+    end
+
+    def members
+      @paths.map do |p|
+        rel = p.delete_prefix(base == "/" ? "/" : "#{base}/")
+        rel.empty? ? File.basename(p) : rel
+      end
+    end
+
+    def ext
+      case @target
+      when :both then @tar_codec.ext
+      when :tar then ".tar"
+      else @compressor.container? ? ".zip" : @compressor.single_ext
+      end
+    end
+
+    def output = File.join(@outdir, ensure_ext(@basename, ext))
+    def outputs = [output]
+
+    # Extensions a user might type that we would otherwise double up.
+    ARCHIVE_EXTS = (TAR_CODECS.map(&:ext) + TAR_CODECS.map(&:single_ext) + %w[.tgz .tbz2 .txz .zip])
+                   .reject(&:empty?).uniq.sort_by { |e| -e.length }.freeze
+
+    def ensure_ext(name, ext)
+      return name if name.downcase.end_with?(ext)
+      # backup.tar gzipped on its own is backup.tar.gz; the name is the
+      # point, so nothing is stripped from it.
+      return "#{name}#{ext}" if single_compress?
+
+      # Strip a competing archive extension the user may have typed.
+      typed = ARCHIVE_EXTS.find { |e| name.downcase.end_with?(e) }
+      stripped = typed ? name[0...-typed.length] : name
+      stripped = name if stripped.empty?
+      "#{stripped}#{ext}"
+    end
+
+    def tar_argv
+      argv = ["tar", "-c"]
+      if @target == :both && (filter = @tar_codec.filter(@tar_level))
+        argv += ["--use-compress-program", filter]
+      end
+      @tar_flags.each { |f| argv.concat(f.args) if f.on }
+      argv += ["-f", output, "-C", base, "--"]
+      argv + members
+    end
+
+    def zip_argv
+      argv = ["zip", "-r"]
+      argv << (zip_verbose? ? "-v" : "-q")
+      argv << "-Z" << @compressor.flag if @compressor.flag != "deflate"
+      argv << "-#{@comp_level.clamp(0, 9)}" if @compressor.levels && @comp_level
+      argv << "-D" unless flag_on?(@zip_flags, :dirs)
+      @zip_flags.each do |f|
+        next if %i[verbose dirs].include?(f.id)
+
+        argv.concat(f.args) if f.on
+      end
+      argv << output
+      argv + members.map { |m| dashsafe(m) }
+    end
+
+    # gzip and friends read one file and write to stdout; the job redirects
+    # that into the output path.
+    def single_argv
+      @compressor.argv(@comp_level) + [dashsafe(members.first)]
+    end
+
+    def dashsafe(name) = name.start_with?("-") ? "./#{name}" : name
+
+    def zip_verbose? = flag_on?(@zip_flags, :verbose)
+    def tar_verbose? = flag_on?(@tar_flags, :verbose)
+
+    def flag_on?(list, id)
+      f = list.find { |x| x.id == id }
+      f ? f.on : false
+    end
+
+    # [label, argv, expects_verbose_output, stdout_path]
+    def steps
+      case @target
+      when :both, :tar then [["tar", tar_argv, tar_verbose?, nil]]
+      else
+        if @compressor.container?
+          [["zip", zip_argv, zip_verbose?, nil]]
+        else
+          [[@compressor.label, single_argv, false, output]]
+        end
+      end
+    end
+
+    # Display form of the command. Execution never goes through a shell, so
+    # this is for the reader's benefit; quote only what needs it.
+    def self.show_arg(arg)
+      arg.match?(%r{\A[\w@%+=:,./-]+\z}) ? arg : "'#{arg.gsub("'", %q('"'"'))}'"
+    end
+
+    def self.show_cmd(argv, stdout = nil)
+      cmd = argv.map { |a| show_arg(a) }.join(" ")
+      stdout ? "#{cmd} > #{show_arg(stdout)}" : cmd
+    end
+
+    def preview
+      steps.map { |(label, argv, _, stdout)| [label, Plan.show_cmd(argv, stdout)] }
+    end
+
+    # Problems worth blocking on, checked right before the run.
+    def problems
+      errs = []
+      errs << "nothing selected" if @paths.empty?
+      errs << "destination is not a folder: #{@outdir}" unless File.directory?(@outdir)
+      errs << "destination is not writable: #{@outdir}" if File.directory?(@outdir) && !File.writable?(@outdir)
+      case @target
+      when :both
+        errs << "tar is not installed" unless Tools.available?("tar")
+        errs << @tar_codec.why_not if @tar_codec.why_not
+        errs << "no compressor installed; choose tarball" if @tar_codec.id == :none
+      when :tar
+        errs << "tar is not installed" unless Tools.available?("tar")
+      else
+        errs << @compressor.why_not if @compressor.why_not
+        if !@compressor.container? && !single_file?
+          errs << "#{@compressor.label} compresses one file only; choose both for folders"
+        end
+      end
+      errs.compact.uniq
+    end
+
+    # Non-blocking things the confirm screen should say out loud.
+    def warnings
+      warn = []
+      o = output
+      warn << "#{File.basename(o)} already exists and will be replaced" if File.exist?(o)
+      if @paths.any? { |p| Plan.inside?(o, p) }
+        warn << "output sits inside a selected folder, so it may archive itself"
+      end
+      warn
+    end
+  end
+end

data/lib/rakpak/screen.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "text"
+require_relative "theme"
+
+module Rakpak
+  # A character grid. Everything draws into cells, so modals overlay the
+  # browser cleanly and the whole frame ships in one write.
+  class Screen
+    attr_reader :w, :h
+
+    def initialize(w, h)
+      resize(w, h)
+    end
+
+    def resize(w, h)
+      @w = [w, 20].max
+      @h = [h, 6].max
+      @ch = Array.new(@w * @h, " ")
+      @st = Array.new(@w * @h, nil)
+    end
+
+    def clear(style = nil)
+      @ch.fill(" ")
+      @st.fill(style)
+    end
+
+    # Writes `text` at (x, y). Returns the column just past the text.
+    def put(x, y, text, style = nil)
+      return x if y.negative? || y >= @h
+
+      row = y * @w
+      cx = x
+      printable(text).each_grapheme_cluster do |g|
+        cw = Text.gw(g)
+        break if cx >= @w
+
+        if cx >= 0 && cw.positive?
+          clear_halves(row + cx)
+          clear_halves(row + cx + 1) if cw == 2 && cx + 1 < @w
+          @ch[row + cx] = g
+          @st[row + cx] = style
+          if cw == 2 && cx + 1 < @w
+            @ch[row + cx + 1] = ""
+            @st[row + cx + 1] = style
+          end
+        end
+        cx += cw
+      end
+      cx
+    end
+
+    # A double-width glyph owns two cells: itself and an empty marker after
+    # it. Writing over either half must blank the other, or the row renders
+    # one column too wide and the terminal wraps it.
+    def clear_halves(idx)
+      col = idx % @w
+      @ch[idx - 1] = " " if @ch[idx] == "" && col.positive? && Text.gw(@ch[idx - 1]) == 2
+      @ch[idx + 1] = " " if col < @w - 1 && @ch[idx + 1] == "" && Text.gw(@ch[idx]) == 2
+    end
+
+    # Last line of defence: a single binary byte reaching @ch would make the
+    # whole frame fail to concatenate and take the app down mid-render.
+    def printable(text)
+      str = text.to_s
+      str = str.dup.force_encoding(Encoding::UTF_8) unless str.encoding == Encoding::UTF_8
+      str.valid_encoding? ? str : str.scrub("·")
+    end
+
+    def fill(x, y, w, h, char = " ", style = nil)
+      h.times do |dy|
+        yy = y + dy
+        next if yy.negative? || yy >= @h
+
+        row = yy * @w
+        w.times do |dx|
+          xx = x + dx
+          next if xx.negative? || xx >= @w
+
+          clear_halves(row + xx)
+          @ch[row + xx] = char
+          @st[row + xx] = style
+        end
+      end
+    end
+
+    def hline(x, y, w, style = nil, char = "─")
+      fill(x, y, w, 1, char, style)
+    end
+
+    def vline(x, y, h, style = nil, char = "│")
+      fill(x, y, 1, h, char, style)
+    end
+
+    def box(x, y, w, h, style = nil, fill_style = nil)
+      return if w < 2 || h < 2
+
+      fill(x, y, w, h, " ", fill_style) if fill_style
+      put(x, y, "╭#{'─' * (w - 2)}╮", style)
+      put(x, y + h - 1, "╰#{'─' * (w - 2)}╯", style)
+      (1...(h - 1)).each do |dy|
+        put(x, y + dy, "│", style)
+        put(x + w - 1, y + dy, "│", style)
+      end
+    end
+
+    # Flatten everything to a faint monochrome so a modal reads as the
+    # foreground layer.
+    def veil(style = Theme::FAINT)
+      @st.fill(style)
+    end
+
+    def render
+      out = +"\e[H"
+      cur = :none
+      @h.times do |y|
+        row = y * @w
+        @w.times do |x|
+          st = @st[row + x]
+          if st != cur
+            out << Theme::RESET
+            out << st if st
+            cur = st
+          end
+          out << @ch[row + x]
+        end
+        out << Theme::RESET
+        cur = nil
+        out << "\r\n" unless y == @h - 1
+      end
+      out << Theme::RESET
+      out
+    end
+  end
+end

data/lib/rakpak/sizer.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Rakpak
+  # Walks tagged directories on a worker thread so the UI can show a real
+  # byte total and file count without ever blocking on a huge tree.
+  class Sizer
+    Result = Struct.new(:bytes, :files, :partial)
+
+    BUDGET = 4.0 # seconds per path before we report a partial figure
+
+    def initialize
+      @cache = {}
+      @queue = Queue.new
+      @lock = Mutex.new
+      @pending = {}
+      @worker = Thread.new { loop { work(*@queue.pop) } }
+      @worker.abort_on_exception = false
+    end
+
+    # nil means "still counting".
+    def [](path)
+      @lock.synchronize { @cache[path] }
+    end
+
+    def request(path)
+      token = nil
+      @lock.synchronize do
+        return if @cache.key?(path) || @pending[path]
+
+        token = Object.new
+        @pending[path] = token
+      end
+      @queue << [path, token]
+    end
+
+    def total(paths)
+      known = paths.map { |p| self[p] }
+      bytes = known.compact.sum { |r| r.bytes }
+      files = known.compact.sum { |r| r.files }
+      Result.new(bytes, files, known.any?(&:nil?) || known.compact.any?(&:partial))
+    end
+
+    # Drops the figure, and any measurement in flight for it.
+    def forget(path)
+      @lock.synchronize do
+        @cache.delete(path)
+        @pending.delete(path)
+      end
+    end
+
+    def invalidate!
+      @lock.synchronize do
+        @cache.clear
+        @pending.clear
+      end
+    end
+
+    private
+
+    def work(path, token)
+      res = measure(path)
+      @lock.synchronize do
+        # Forgotten, invalidated, or re-requested while we were walking:
+        # only the walk that the current request started may answer it.
+        next unless @pending[path].equal?(token)
+
+        @pending.delete(path)
+        @cache[path] = res
+      end
+    rescue StandardError
+      @lock.synchronize { @pending.delete(path) if @pending[path].equal?(token) }
+    end
+
+    def measure(path)
+      st = File.lstat(path)
+      return Result.new(st.size, 1, false) unless st.directory?
+
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + BUDGET
+      bytes = 0
+      files = 1 # the folder itself is an archive member
+      partial = false
+      stack = [path]
+      until stack.empty?
+        if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+          partial = true
+          break
+        end
+        dir = stack.pop
+        begin
+          Dir.children(dir).each do |name|
+            child = File.join(dir, name)
+            s = begin
+              File.lstat(child)
+            rescue StandardError
+              next
+            end
+            if s.directory?
+              stack << child
+              files += 1 # tar and zip both record directory entries
+            else
+              bytes += s.size
+              files += 1
+            end
+          end
+        rescue StandardError
+          next
+        end
+      end
+      Result.new(bytes, files, partial)
+    rescue StandardError
+      Result.new(0, 0, true)
+    end
+  end
+end

data/lib/rakpak/term.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Rakpak
+  # Raw-mode terminal control and key decoding.
+  module Term
+    ARROWS = { "A" => :up, "B" => :down, "C" => :right, "D" => :left,
+               "H" => :home, "F" => :end }.freeze
+
+    TILDE = { "1" => :home, "3" => :delete, "4" => :end,
+              "5" => :pgup, "6" => :pgdn, "7" => :home, "8" => :end }.freeze
+
+    class << self
+      attr_accessor :resized
+    end
+    self.resized = false
+
+    module_function
+
+    def size
+      h, w = $stdout.winsize
+      [w.to_i.positive? ? w : 80, h.to_i.positive? ? h : 24]
+    rescue StandardError
+      [80, 24]
+    end
+
+    def start
+      @stty = `stty -g 2>/dev/null`.chomp
+      $stdin.raw!
+      $stdout.write("\e[?1049h\e[?25l\e[2J")
+      $stdout.flush
+      trap("WINCH") { Term.resized = true }
+    end
+
+    def stop
+      $stdout.write("\e[?25h\e[?1049l")
+      $stdout.flush
+      if @stty && !@stty.empty?
+        system("stty", @stty, out: File::NULL, err: File::NULL)
+      else
+        begin
+          $stdin.cooked!
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    def flush_frame(str)
+      $stdout.write(str)
+      $stdout.flush
+    end
+
+    # Blocks up to `timeout` seconds. Returns a key symbol, a printable
+    # String, or nil on timeout.
+    def wait_key(timeout = nil)
+      return nil unless IO.select([$stdin], nil, nil, timeout)
+
+      read_key
+    end
+
+    def read_key
+      c = getc_raw
+      return nil if c.nil?
+
+      c = complete_utf8(c)
+      return nil if c.nil?
+
+      case c
+      when "\e"  then read_escape
+      when "\r", "\n" then :enter
+      when "\t"  then :tab
+      when "\x7f", "\b" then :backspace
+      when " "   then :space
+      when "\x00".."\x1f" then :"ctrl_#{(c.ord + 96).chr}"
+      else c
+      end
+    end
+
+    # Under a C locale getc yields one byte at a time, and under UTF-8 a
+    # stray byte arrives as a one-byte invalid string. Gather the rest of
+    # the sequence when there is one; if the result is still not valid
+    # text, the key is dropped rather than raised on later.
+    def complete_utf8(c)
+      s = c.dup.force_encoding(Encoding::UTF_8)
+      return s if s.valid_encoding?
+
+      lead = s.getbyte(0)
+      need = if lead.between?(0xC2, 0xDF) then 1
+             elsif lead.between?(0xE0, 0xEF) then 2
+             elsif lead.between?(0xF0, 0xF4) then 3
+             else 0
+             end
+      need.times do
+        more = getc_raw(ESC_WINDOW)
+        break if more.nil?
+
+        s = (s.b + more.b).force_encoding(Encoding::UTF_8)
+      end
+      s.valid_encoding? ? s : nil
+    end
+
+    def getc_raw(timeout = nil)
+      return nil if timeout && !IO.select([$stdin], nil, nil, timeout)
+
+      $stdin.getc
+    rescue IOError, Errno::EINTR
+      nil
+    end
+
+    # An arrow key arrives as several bytes. Over a slow link they can be
+    # split across reads, so allow a generous window before concluding the
+    # user pressed a bare Esc. The delay is only ever paid on a real Esc.
+    ESC_WINDOW = 0.05
+
+    def read_escape
+      seq = +""
+      12.times do
+        ch = getc_raw(ESC_WINDOW)
+        break if ch.nil?
+
+        seq << ch
+        break if seq.match?(/\A\[[0-9;]*[A-Za-z~]\z/) || seq.match?(/\AO[A-Za-z]\z/)
+      end
+      return :esc if seq.empty?
+
+      body = seq[1..] || ""
+      if seq.start_with?("O")
+        ARROWS[body] || :esc
+      elsif seq.start_with?("[")
+        if (m = body.match(/\A([0-9;]*)([A-Za-z~])\z/))
+          num, fin = m[1], m[2]
+          return ARROWS[fin] if ARROWS.key?(fin)
+          return TILDE[num.split(";").first.to_s] || :esc if fin == "~"
+
+          :esc
+        else
+          :esc
+        end
+      else
+        # Alt-<char>: the whole sequence is the character.
+        :"alt_#{seq}"
+      end
+    end
+  end
+end