rakpak 1.0.0

data/lib/rakpak/text.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Rakpak
+  # Grapheme-aware width math. Just enough Unicode to keep columns honest.
+  module Text
+    WIDE = [
+      0x1100..0x115F, 0x2E80..0x303E, 0x3041..0x33FF, 0x3400..0x4DBF,
+      0x4E00..0x9FFF, 0xA000..0xA4CF, 0xAC00..0xD7A3, 0xF900..0xFAFF,
+      0xFE10..0xFE19, 0xFE30..0xFE6F, 0xFF00..0xFF60, 0xFFE0..0xFFE6,
+      0x1F300..0x1F64F, 0x1F900..0x1F9FF, 0x20000..0x2FFFD
+    ].freeze
+
+    ZERO = [0x0300..0x036F, 0x200B..0x200F, 0xFE00..0xFE0F, 0xFEFF..0xFEFF].freeze
+
+    module_function
+
+    # Display width of a single grapheme cluster.
+    def gw(cluster)
+      cp = cluster.ord
+      return 1 if cp >= 0x20 && cp < 0x7F # the common case, checked first
+      # C0, DEL and the C1 controls: a UTF-8 terminal executes U+009B as
+      # CSI, so these must never reach the frame.
+      return 0 if cp < 0x20 || cp == 0x7F || (cp >= 0x80 && cp <= 0x9F)
+      return 0 if ZERO.any? { |r| r.cover?(cp) }
+      return 2 if WIDE.any? { |r| r.cover?(cp) }
+
+      1
+    rescue StandardError
+      1
+    end
+
+    def width(str)
+      w = 0
+      str.each_grapheme_cluster { |g| w += gw(g) }
+      w
+    end
+
+    # Truncate to `max` columns, appending an ellipsis when something was cut.
+    def fit(str, max)
+      return "" if max <= 0
+      return str if width(str) <= max
+
+      out = +""
+      used = 0
+      str.each_grapheme_cluster do |g|
+        cw = gw(g)
+        break if used + cw > max - 1
+
+        out << g
+        used += cw
+      end
+      out << "…"
+    end
+
+    # Keep the tail of a path visible instead of the head.
+    def fit_left(str, max)
+      return "" if max <= 0
+      return str if width(str) <= max
+
+      clusters = str.grapheme_clusters
+      out = []
+      used = 0
+      clusters.reverse_each do |g|
+        cw = gw(g)
+        break if used + cw > max - 1
+
+        out.unshift(g)
+        used += cw
+      end
+      "…#{out.join}"
+    end
+
+    def pad(str, max)
+      w = width(str)
+      w >= max ? str : str + (" " * (max - w))
+    end
+
+    # Greedy wrap on spaces, with a hanging indent for continuations.
+    def wrap(str, max, indent = 0)
+      return [str] if max <= indent + 4 || width(str) <= max
+
+      lead = str[/\A[ \t]*/]
+      pad = " " * indent
+      out = []
+      line = +""
+      words = str[lead.length..].to_s.split(" ").flat_map do |word|
+        # A path with no spaces can still be wider than the panel; break it.
+        limit = max - indent
+        next word if width(word) <= limit || limit < 8
+
+        word.grapheme_clusters.each_slice(limit).map(&:join)
+      end
+      words.each do |word|
+        candidate = line.empty? ? word : "#{line} #{word}"
+        if width(out.empty? ? lead + candidate : pad + candidate) <= max
+          line = candidate
+        else
+          out << (out.empty? ? lead + line : pad + line)
+          line = word
+        end
+      end
+      out << (out.empty? ? lead + line : pad + line) unless line.empty?
+      out
+    end
+
+    # /home/me/x → ~/x. Only a real prefix counts: /home/me2 is left alone.
+    def tilde(path)
+      home = Dir.home
+      return path if home.nil? || home.empty? || home == "/"
+      return "~" if path == home
+
+      path.start_with?("#{home}/") ? "~#{path[home.length..]}" : path
+    end
+
+    # For text that goes to the terminal without passing through Screen:
+    # control and C1 bytes could otherwise be executed as escape sequences.
+    def plain(str)
+      str.to_s.dup.force_encoding(Encoding::UTF_8).scrub("?").gsub(/[\u0000-\u001f\u007f-\u009f]/, "?")
+    end
+
+    HUMAN = %w[B K M G T P].freeze
+
+    def bytes(n)
+      return "-" if n.nil?
+
+      f = n.to_f
+      i = 0
+      while f >= 1024 && i < HUMAN.size - 1
+        f /= 1024
+        i += 1
+      end
+      i.zero? ? "#{n}B" : format("%.1f%s", f, HUMAN[i])
+    end
+
+    def duration(secs)
+      s = secs.to_i
+      return format("%d:%02d:%02d", s / 3600, (s % 3600) / 60, s % 60) if s >= 3600
+
+      format("%d:%02d", s / 60, s % 60)
+    end
+  end
+end

data/lib/rakpak/theme.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rakpak
+  # SGR fragments. Every style is emitted after a reset, so they compose by
+  # concatenation without needing to be self-contained.
+  module Theme
+    RESET     = "\e[0m"
+
+    NORMAL    = "\e[38;5;252m"
+    DIM       = "\e[38;5;243m"
+    FAINT     = "\e[38;5;239m"
+    BORDER    = "\e[38;5;238m"
+
+    ACCENT    = "\e[38;5;39m"
+    TITLE     = "\e[1;38;5;39m"
+    DIR       = "\e[1;38;5;75m"
+    EXEC      = "\e[38;5;114m"
+    LINK      = "\e[38;5;141m"
+    TAG       = "\e[38;5;215m"
+
+    OK        = "\e[38;5;114m"
+    WARN      = "\e[38;5;215m"
+    ERR       = "\e[38;5;203m"
+
+    SEL_BG    = "\e[48;5;236m"
+    CUR_BG    = "\e[48;5;24m"
+    HEAD      = "\e[48;5;236m\e[38;5;250m"
+    MODAL_BG  = "\e[48;5;234m"
+
+    KEY       = "\e[1;38;5;215m"
+  end
+end

data/lib/rakpak/version.rb

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

data/lib/rakpak.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "rakpak/version"
+require_relative "rakpak/app"
+
+module Rakpak
+  USAGE = <<~USAGE
+    rakpak: tag files anywhere, archive them once.
+
+    usage: rakpak [folder]
+           rakpak -p path [path ...]
+
+      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
+      -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
+  USAGE
+
+  Options = Struct.new(:dir, :pack, :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
+  end
+
+  # Returns Options. `action` is :browse, :help or :version. Raises
+  # ArgumentError on anything it does not understand.
+  def self.parse(argv)
+    pack_mode = false
+    positional = []
+    rest = argv.dup
+    until rest.empty?
+      arg = rest.shift
+      case arg
+      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 "--" then positional.concat(rest) && rest.clear
+      when /\A-./ then raise ArgumentError, "unknown option: #{arg}"
+      else positional << arg
+      end
+    end
+
+    if pack_mode
+      raise ArgumentError, "-p needs at least one path" if positional.empty?
+
+      paths = positional.map { |p| File.expand_path(p) }
+      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)
+    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: [])
+    end
+  end
+
+  # Exit status.
+  def self.start(argv = ARGV)
+    begin
+      opts = parse(argv)
+    rescue ArgumentError => e
+      warn "rakpak: #{e.message}"
+      warn "try: rakpak --help"
+      return 2
+    end
+    case opts.action
+    when :help
+      puts USAGE
+      return 0
+    when :version
+      puts "rakpak #{VERSION}"
+      return 0
+    end
+    unless $stdout.tty? && $stdin.tty?
+      warn "rakpak: needs an interactive terminal"
+      return 1
+    end
+    App.new(opts.dir, pack: opts.pack).run
+    0
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: rakpak
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ryan Wilson
+bindir: bin
+cert_chain: []
+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.
+email:
+- ryan@ryanwilson.io
+executables:
+- rakpak
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/rakpak
+- lib/rakpak.rb
+- lib/rakpak/app.rb
+- lib/rakpak/browser.rb
+- lib/rakpak/dir_cache.rb
+- lib/rakpak/entry.rb
+- lib/rakpak/formats.rb
+- lib/rakpak/job.rb
+- lib/rakpak/modal.rb
+- lib/rakpak/plan.rb
+- lib/rakpak/screen.rb
+- lib/rakpak/sizer.rb
+- lib/rakpak/term.rb
+- lib/rakpak/text.rb
+- lib/rakpak/theme.rb
+- lib/rakpak/version.rb
+homepage: https://github.com/rywils/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
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+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.
+test_files: []