ruborg 0.8.1 → 0.9.3

data/lib/ruborg/progress.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Ruborg
+  # Terminal progress display: named stages, inline progress bar, and spinner.
+  # Writes to $stderr so stdout remains clean for --json or piped output.
+  # Degrades to plain text lines when output is not a TTY (piped / redirected).
+  class Progress
+    SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+    BAR_WIDTH = 28
+    LINE_WIDTH = 80
+
+    def initialize(output: $stderr)
+      @output = output
+      @tty = output.respond_to?(:isatty) && output.isatty
+      @spinner_thread = nil
+    end
+
+    # Print a numbered stage header: "[2/3] Label"
+    def stage(index, total, label)
+      stop_spin
+      clear_line if @tty
+      @output.puts "[#{index}/#{total}] #{label}"
+    end
+
+    # Start a spinner on the current line for an indeterminate operation.
+    # Call stop_spin (or done) to halt it.
+    def spin(label)
+      stop_spin
+      return unless @tty
+
+      frame = 0
+      @spinner_thread = Thread.new do
+        loop do
+          @output.print "\r  #{SPINNER_FRAMES[frame % SPINNER_FRAMES.size]}  #{label}"
+          frame += 1
+          sleep 0.1
+        end
+      end
+    end
+
+    # Stop the spinner and erase its line.
+    def stop_spin
+      return unless @spinner_thread
+
+      @spinner_thread.kill
+      @spinner_thread.join(0.2)
+      @spinner_thread = nil
+      clear_line if @tty
+    end
+
+    # Redraw an inline progress bar. Call once per item in a loop.
+    # label is truncated to fit the terminal line.
+    def bar(current, total, label = "")
+      return unless @tty
+
+      pct = total.positive? ? (current.to_f / total) : 0
+      filled = (BAR_WIDTH * pct).round
+      bar_str = filled.positive? ? "#{"=" * (filled - 1)}>" : ""
+      bar_str = bar_str.ljust(BAR_WIDTH)
+      short_label = truncate_left(label.to_s, 28)
+      @output.print "\r  [#{bar_str}]  #{current}/#{total}  #{short_label.ljust(28)}"
+    end
+
+    # Halt any in-progress display and print a completion line.
+    def done(label = nil)
+      stop_spin
+      clear_line if @tty
+      @output.puts "  ✓ #{label}" if label
+    end
+
+    private
+
+    def clear_line
+      @output.print "\r#{" " * LINE_WIDTH}\r"
+    end
+
+    def truncate_left(str, max)
+      str.length > max ? "...#{str[-(max - 3)..]}" : str
+    end
+  end
+end

data/lib/ruborg/repository.rb

@@ -6,11 +6,13 @@ module Ruborg
   class Repository
     attr_reader :path, :borg_path
 
-    def initialize(path, passphrase: nil, borg_options: {}, borg_path: nil, logger: nil)
+    def initialize(path, passphrase: nil, borg_options: {}, borg_path: nil, lock_wait: nil, logger: nil)
+      @original_path = path
       @path = validate_repo_path(path)
       @passphrase = passphrase
       @borg_options = borg_options
       @borg_path = validate_borg_path(borg_path || "borg")
+      @lock_wait = lock_wait&.to_i
       @logger = logger
     end
 
@@ -18,6 +20,37 @@ module Ruborg
       File.directory?(@path) && File.exist?(File.join(@path, "config"))
     end
 
+    MINIMUM_BORG_VERSION = "1.4.0"
+
+    def locked?
+      File.exist?(File.join(@path, "lock.exclusive")) ||
+        File.exist?(File.join(@path, "lock.roster"))
+    end
+
+    def break_lock
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      check_borg_version!
+      cmd = [@borg_path, "break-lock", @path]
+      execute_borg_command(cmd)
+      @logger&.info("Lock broken for repository at #{@path}")
+    end
+
+    def force_break_lock
+      raise BorgError, "Repository does not exist at #{@path}" unless exists?
+
+      require "fileutils"
+      removed = %w[lock.exclusive lock.roster].select do |name|
+        target = File.join(@path, name)
+        next false unless File.exist?(target)
+
+        FileUtils.rm_rf(target)
+        true
+      end
+      @logger&.info("Force-removed lock files at #{@path}: #{removed.join(", ")}")
+      removed
+    end
+
     def create
       raise BorgError, "Repository already exists at #{@path}" if exists?
 
@@ -278,62 +311,67 @@ module Ruborg
       nil # Failed to parse, skip this archive
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def get_archives_grouped_by_source_dir
       require "json"
       require "time"
       require "open3"
 
-      # Get list of all archives
       cmd = [@borg_path, "list", @path, "--json"]
       env = build_borg_env
 
       stdout, stderr, status = Open3.capture3(env, *cmd)
       raise BorgError, "Failed to list archives: #{stderr}" unless status.success?
 
-      json_data = JSON.parse(stdout)
-      archives = json_data["archives"] || []
-
-      # Group archives by source directory from metadata
+      archives = JSON.parse(stdout)["archives"] || []
+      cache = ArchiveCache.new(@original_path).fetch
       archives_by_source = Hash.new { |h, k| h[k] = [] }
 
       archives.each do |archive|
         archive_name = archive["name"]
-
-        # Get archive info to read comment (metadata)
-        info_cmd = [@borg_path, "info", "#{@path}::#{archive_name}", "--json"]
-        info_stdout, _, info_status = Open3.capture3(env, *info_cmd)
-
-        unless info_status.success?
-          # If we can't get info, put in legacy group
-          archives_by_source[""] << {
-            name: archive_name,
-            time: Time.parse(archive["time"])
-          }
-          next
-        end
-
-        info_data = JSON.parse(info_stdout)
-        comment = info_data.dig("archives", 0, "comment") || ""
-
-        # Parse source_dir from comment
-        # Format: path|||size|||hash|||source_dir
-        source_dir = if comment.include?("|||")
-                       parts = comment.split("|||")
-                       parts.length >= 4 ? (parts[3] || "") : ""
+        archive_time = Time.parse(archive["time"])
+
+        metadata = if (cached = cache[archive_name])
+                     cached
+                   else
+                     info_cmd = [@borg_path, "info", "#{@path}::#{archive_name}", "--json"]
+                     info_stdout, _, info_status = Open3.capture3(env, *info_cmd)
+
+                     if info_status.success?
+                       comment = JSON.parse(info_stdout).dig("archives", 0, "comment") || ""
+                       parsed = parse_archive_comment(comment)
+                       cache.store(archive_name, parsed)
+                       parsed
                      else
-                       ""
+                       cache.store(archive_name, { path: "", size: 0, hash: "", source_dir: "" })
+                       { path: "", size: 0, hash: "", source_dir: "" }
                      end
+                   end
 
-        archives_by_source[source_dir] << {
-          name: archive_name,
-          time: Time.parse(archive["time"])
-        }
+        archives_by_source[metadata[:source_dir] || ""] << { name: archive_name, time: archive_time }
       end
 
+      cache.save_if_changed
       archives_by_source
     rescue JSON::ParserError => e
       raise BorgError, "Failed to parse archive metadata: #{e.message}"
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def parse_archive_comment(comment)
+      if comment.include?("|||")
+        parts = comment.split("|||")
+        if parts.length >= 4
+          { path: parts[0], size: parts[1].to_i, hash: parts[2] || "", source_dir: parts[3] || "" }
+        elsif parts.length >= 3
+          { path: parts[0], size: parts[1].to_i, hash: parts[2] || "", source_dir: "" }
+        else
+          { path: parts[0], size: 0, hash: parts[1] || "", source_dir: "" }
+        end
+      else
+        { path: comment, size: 0, hash: "", source_dir: "" }
+      end
+    end
 
     def prune_per_directory_standard(retention_policy)
       # Apply standard retention policies (keep_daily, etc.) per source directory
@@ -477,6 +515,21 @@ module Ruborg
       match[1]
     end
 
+    # Get Borg path (full path to executable)
+    def self.borg_path(borg_command = "borg")
+      # If it's an absolute or relative path, expand it
+      return File.expand_path(borg_command) if borg_command.include?("/")
+
+      # Otherwise, search in PATH
+      ENV["PATH"].split(File::PATH_SEPARATOR).each do |directory|
+        path = File.join(directory, borg_command)
+        return path if File.executable?(path)
+      end
+
+      # Not found in PATH, return the command as-is
+      borg_command
+    end
+
     # Execute borg version command (extracted for testing)
     def self.execute_version_command(borg_path = "borg")
       require "open3"
@@ -572,6 +625,26 @@ module Ruborg
       borg_path
     end
 
+    def inject_lock_wait(cmd)
+      return cmd if @lock_wait.nil? || cmd[1] == "break-lock"
+
+      [cmd[0], "--lock-wait", @lock_wait.to_s] + cmd[1..]
+    end
+
+    def check_borg_version!
+      version = self.class.borg_version(@borg_path)
+      return if version_sufficient?(version, MINIMUM_BORG_VERSION)
+
+      raise BorgError,
+            "Borg #{MINIMUM_BORG_VERSION}+ is required but found #{version}. Please upgrade Borg."
+    end
+
+    def version_sufficient?(actual, minimum)
+      actual_parts  = actual.split(".").map(&:to_i)
+      minimum_parts = minimum.split(".").map(&:to_i)
+      (actual_parts <=> minimum_parts) >= 0
+    end
+
     def find_in_path(command)
       ENV["PATH"].split(File::PATH_SEPARATOR).each do |directory|
         path = File.join(directory, command)
@@ -595,6 +668,9 @@ module Ruborg
       env["BORG_RELOCATED_REPO_ACCESS_IS_OK"] = allow_relocated ? "yes" : "no"
       env["BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK"] = allow_unencrypted ? "yes" : "no"
 
+      # Inject --lock-wait for all commands except break-lock (which breaks, not acquires)
+      cmd = inject_lock_wait(cmd)
+
       # Redirect stdin from /dev/null to prevent interactive prompts
       result = system(env, *cmd, in: "/dev/null")
       raise BorgError, "Borg command failed: #{cmd.join(" ")}" unless result

data/lib/ruborg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruborg
-  VERSION = "0.8.1"
+  VERSION = "0.9.3"
 end

data/lib/ruborg.rb

@@ -3,6 +3,9 @@
 require_relative "ruborg/version"
 require_relative "ruborg/logger"
 require_relative "ruborg/config"
+require_relative "ruborg/archive_cache"
+require_relative "ruborg/catalog"
+require_relative "ruborg/progress"
 require_relative "ruborg/repository"
 require_relative "ruborg/backup"
 require_relative "ruborg/passbolt"
@@ -13,4 +16,5 @@ module Ruborg
   class ConfigError < Error; end
   class BorgError < Error; end
   class PassboltError < Error; end
+  class CatalogError < Error; end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruborg
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.3
 platform: ruby
 authors:
 - Michail Pantelelis
@@ -143,11 +143,14 @@ files:
 - SECURITY.md
 - exe/ruborg
 - lib/ruborg.rb
+- lib/ruborg/archive_cache.rb
 - lib/ruborg/backup.rb
+- lib/ruborg/catalog.rb
 - lib/ruborg/cli.rb
 - lib/ruborg/config.rb
 - lib/ruborg/logger.rb
 - lib/ruborg/passbolt.rb
+- lib/ruborg/progress.rb
 - lib/ruborg/repository.rb
 - lib/ruborg/version.rb
 - ruborg.gemspec