ruborg 0.8.1 → 0.9.3

data/lib/ruborg/backup.rb

@@ -3,12 +3,15 @@
 module Ruborg
   # Backup operations using Borg
   class Backup
-    def initialize(repository, config:, retention_mode: "standard", repo_name: nil, logger: nil)
+    def initialize(repository, config:, retention_mode: "standard", repo_name: nil, logger: nil,
+                   skip_hash_check: false, progress: nil)
       @repository = repository
       @config = config
       @retention_mode = retention_mode
       @repo_name = repo_name
       @logger = logger
+      @skip_hash_check = skip_hash_check
+      @progress = progress
     end
 
     def create(name: nil, remove_source: false)
@@ -26,36 +29,31 @@ module Ruborg
     def create_standard_archive(name, remove_source)
       archive_name = name || Time.now.strftime("%Y-%m-%d_%H-%M-%S")
 
-      # Show repository header in console only
       print_repository_header
-
-      # Show progress in console
-      puts "Creating archive: #{archive_name}"
+      @progress&.spin("Creating archive: #{archive_name}")
 
       cmd = build_create_command(archive_name)
-
       execute_borg_command(cmd)
 
-      # Log successful action
+      @progress&.done("Archive created: #{archive_name}")
       @logger&.info("[#{@repo_name}] Created archive #{archive_name} with #{@config.backup_paths.size} source(s)")
-      puts "✓ Archive created successfully"
 
       remove_source_files if remove_source
     end
 
     # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockNesting
     def create_per_file_archives(name_prefix, remove_source)
-      # Collect all files from backup paths
+      @progress&.spin("Collecting files...")
       files_to_backup = collect_files_from_paths(@config.backup_paths, @config.exclude_patterns)
+      @progress&.stop_spin
 
       raise BorgError, "No files found to backup" if files_to_backup.empty?
 
-      # Get list of existing archives for duplicate detection
+      @progress&.spin("Loading archive catalog...")
       existing_archives = get_existing_archive_names
+      @progress&.done("Catalog loaded — #{existing_archives.size} archive(s) known")
 
-      # Show repository header in console only
       print_repository_header
-
       puts "Found #{files_to_backup.size} file(s) to backup"
 
       backed_up_count = 0
@@ -77,8 +75,8 @@ module Ruborg
         # Ensure archive name doesn't exceed 255 characters (filesystem limit)
         archive_name = name_prefix || build_archive_name(@repo_name, sanitized_filename, path_hash, file_mtime)
 
-        # Show progress in console
-        print "  [#{index + 1}/#{files_to_backup.size}] Backing up: #{file_path}"
+        @progress&.bar(index + 1, files_to_backup.size, File.basename(file_path))
+        $stderr.print "  [#{index + 1}/#{files_to_backup.size}] Backing up: #{file_path}" unless @progress
 
         # Check if archive already exists AND contains this exact file
         if existing_archives.key?(archive_name)
@@ -89,15 +87,13 @@ module Ruborg
             stored_size = stored_info[:size]
 
             if current_size == stored_size
-              # Size same -> verify content hasn't changed (paranoid mode)
-              current_hash = calculate_file_hash(file_path)
-              stored_hash = stored_info[:hash]
-
-              if current_hash == stored_hash
-                # Content truly unchanged - file is already safely backed up
-                puts " - Archive already exists (file unchanged)"
+              # Size same -> verify content hasn't changed (paranoid mode) unless skip_hash_check is enabled
+              if @skip_hash_check
+                # Skip hash check - assume file is unchanged based on size and mtime
+                puts " - Archive already exists (skipped hash check)"
                 @logger&.info(
-                  "[#{@repo_name}] Skipped #{file_path} - archive #{archive_name} already exists (file unchanged)"
+                  "[#{@repo_name}] Skipped #{file_path} - archive #{archive_name} already exists " \
+                  "(hash check skipped)"
                 )
                 skipped_count += 1
 
@@ -106,12 +102,29 @@ module Ruborg
 
                 next
               else
-                # Size same but content changed (rare: edited + truncated/padded to same size)
-                archive_name = find_next_version_name(archive_name, existing_archives)
-                @logger&.warn(
-                  "[#{@repo_name}] File content changed but size/mtime unchanged for #{file_path}, " \
-                  "using #{archive_name}"
-                )
+                current_hash = calculate_file_hash(file_path)
+                stored_hash = stored_info[:hash]
+
+                if current_hash == stored_hash
+                  # Content truly unchanged - file is already safely backed up
+                  puts " - Archive already exists (file unchanged)"
+                  @logger&.info(
+                    "[#{@repo_name}] Skipped #{file_path} - archive #{archive_name} already exists (file unchanged)"
+                  )
+                  skipped_count += 1
+
+                  # If remove_source is enabled, delete the file (it's already safely backed up)
+                  remove_single_file(file_path) if remove_source
+
+                  next
+                else
+                  # Size same but content changed (rare: edited + truncated/padded to same size)
+                  archive_name = find_next_version_name(archive_name, existing_archives)
+                  @logger&.warn(
+                    "[#{@repo_name}] File content changed but size/mtime unchanged for #{file_path}, " \
+                    "using #{archive_name}"
+                  )
+                end
               end
             else
               # Size changed but mtime same -> content changed, add version suffix
@@ -133,7 +146,7 @@ module Ruborg
         cmd = build_per_file_create_command(archive_name, file_path, source_dir)
 
         execute_borg_command(cmd)
-        puts ""
+        puts "" unless @progress
 
         # Log successful action with details
         @logger&.info("[#{@repo_name}] Archived #{file_path} in archive #{archive_name}")
@@ -144,11 +157,13 @@ module Ruborg
       end
       # rubocop:enable Metrics/BlockLength
 
-      if skipped_count.positive?
-        puts "✓ Per-file backup completed: #{backed_up_count} file(s) backed up, #{skipped_count} skipped (unchanged)"
-      else
-        puts "✓ Per-file backup completed: #{backed_up_count} file(s) backed up"
-      end
+      summary = if skipped_count.positive?
+                  "#{backed_up_count} file(s) backed up, #{skipped_count} skipped (unchanged)"
+                else
+                  "#{backed_up_count} file(s) backed up"
+                end
+      @progress&.done(summary)
+      puts "✓ Per-file backup completed: #{summary}" unless @progress
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockNesting
 
@@ -443,12 +458,11 @@ module Ruborg
       puts "=" * 60
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def get_existing_archive_names
       require "json"
       require "open3"
 
-      # First get list of archives
       cmd = [@repository.borg_path, "list", @repository.path, "--json"]
       env = {}
       passphrase = @repository.instance_variable_get(:@passphrase)
@@ -459,73 +473,52 @@ module Ruborg
       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"] || []
+      archives = JSON.parse(stdout)["archives"] || []
+      cache = ArchiveCache.new(@repository.path).fetch
 
-      # Build hash by querying each archive individually for comment
-      # This is necessary because 'borg list' doesn't include comments
-      archives.each_with_object({}) do |archive, hash|
+      result = archives.each_with_object({}) do |archive, hash|
         archive_name = archive["name"]
 
-        # Query this specific archive to get the comment
-        info_cmd = [@repository.borg_path, "info", "#{@repository.path}::#{archive_name}", "--json"]
-        info_stdout, _, info_status = Open3.capture3(env, *info_cmd)
-
-        unless info_status.success?
-          # If we can't get info for this archive, skip it with defaults
-          hash[archive_name] = { path: "", size: 0, hash: "", source_dir: "" }
+        if (cached = cache[archive_name])
+          hash[archive_name] = cached
           next
         end
 
-        info_data = JSON.parse(info_stdout)
-        archive_info = info_data["archives"]&.first || {}
-        comment = archive_info["comment"] || ""
-
-        # Parse comment based on format
-        # The comment field stores metadata as: path|||size|||hash|||source_dir (using ||| as delimiter)
-        # For backward compatibility, handle old formats:
-        #   - Old format 1: plain path (no |||)
-        #   - Old format 2: path|||hash (2 parts)
-        #   - Old format 3: path|||size|||hash (3 parts)
-        #   - New format: path|||size|||hash|||source_dir (4 parts)
-        if comment.include?("|||")
-          parts = comment.split("|||")
-          file_path = parts[0]
-          if parts.length >= 4
-            # New format: path|||size|||hash|||source_dir
-            file_size = parts[1].to_i
-            file_hash = parts[2] || ""
-            source_dir = parts[3] || ""
-          elsif parts.length >= 3
-            # Format 3: path|||size|||hash (no source_dir)
-            file_size = parts[1].to_i
-            file_hash = parts[2] || ""
-            source_dir = ""
-          else
-            # Old format: path|||hash (size and source_dir not available)
-            file_size = 0
-            file_hash = parts[1] || ""
-            source_dir = ""
-          end
-        else
-          # Oldest format: comment is just the path string
-          file_path = comment
-          file_size = 0
-          file_hash = ""
-          source_dir = ""
-        end
+        info_cmd = [@repository.borg_path, "info", "#{@repository.path}::#{archive_name}", "--json"]
+        info_stdout, _, info_status = Open3.capture3(env, *info_cmd)
+
+        metadata = if info_status.success?
+                     parse_archive_comment(JSON.parse(info_stdout).dig("archives", 0, "comment") || "")
+                   else
+                     { path: "", size: 0, hash: "", source_dir: "" }
+                   end
 
-        hash[archive_name] = {
-          path: file_path,
-          size: file_size,
-          hash: file_hash,
-          source_dir: source_dir
-        }
+        cache.store(archive_name, metadata)
+        hash[archive_name] = metadata
       end
+
+      cache.save_if_changed
+      result
     rescue JSON::ParserError => e
       raise BorgError, "Failed to parse archive info: #{e.message}"
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def parse_archive_comment(comment)
+      if comment.include?("|||")
+        parts = comment.split("|||")
+        file_path = parts[0]
+        if parts.length >= 4
+          { path: file_path, size: parts[1].to_i, hash: parts[2] || "", source_dir: parts[3] || "" }
+        elsif parts.length >= 3
+          { path: file_path, size: parts[1].to_i, hash: parts[2] || "", source_dir: "" }
+        else
+          { path: file_path, size: 0, hash: parts[1] || "", source_dir: "" }
+        end
+      else
+        { path: comment, size: 0, hash: "", source_dir: "" }
+      end
+    end
 
     def find_next_version_name(base_name, existing_archives)
       version = 2

data/lib/ruborg/catalog.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ruborg
+  # Read-only view over the ArchiveCache for searching and reporting.
+  # Never writes back to the cache.
+  class Catalog
+    def initialize(repo_path)
+      @cache = ArchiveCache.new(repo_path).fetch
+    end
+
+    # Returns all cached entries sorted by file path.
+    def list
+      @cache.entries.sort_by { |e| e[:path].to_s }
+    end
+
+    # Returns entries whose :path matches +pattern+ (a Regexp or regex string).
+    # Raises CatalogError on invalid regex.
+    def search(pattern)
+      regex = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern)
+      list.select { |e| regex.match?(e[:path].to_s) }
+    rescue RegexpError => e
+      raise CatalogError, "Invalid regex pattern: #{e.message}"
+    end
+
+    # Returns a summary hash with aggregate statistics.
+    def stats
+      all = list
+      {
+        total_archives: all.size,
+        unique_paths: all.map { |e| e[:path] }.uniq.size,
+        total_size: all.sum { |e| e[:size].to_i },
+        source_dirs: all.map { |e| e[:source_dir] }.uniq.reject(&:empty?).size
+      }
+    end
+  end
+end