ruborg 0.8.0 → 0.9.0

data/lib/ruborg/backup.rb

@@ -3,12 +3,13 @@
 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)
       @repository = repository
       @config = config
       @retention_mode = retention_mode
       @repo_name = repo_name
       @logger = logger
+      @skip_hash_check = skip_hash_check
     end
 
     def create(name: nil, remove_source: false)
@@ -62,7 +63,10 @@ module Ruborg
       skipped_count = 0
 
       # rubocop:disable Metrics/BlockLength
-      files_to_backup.each_with_index do |file_path, index|
+      files_to_backup.each_with_index do |file_info, index|
+        file_path = file_info[:path]
+        source_dir = file_info[:source_dir]
+
         # Generate hash-based archive name with filename
         path_hash = generate_path_hash(file_path)
         filename = File.basename(file_path)
@@ -86,15 +90,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
 
@@ -103,12 +105,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
@@ -126,8 +145,8 @@ module Ruborg
           end
         end
 
-        # Create archive for single file with original path as comment
-        cmd = build_per_file_create_command(archive_name, file_path)
+        # Create archive for single file with source directory in metadata
+        cmd = build_per_file_create_command(archive_name, file_path, source_dir)
 
         execute_borg_command(cmd)
         puts ""
@@ -157,13 +176,13 @@ module Ruborg
         base_path = File.expand_path(base_path)
 
         if File.file?(base_path)
-          files << base_path unless excluded?(base_path, exclude_patterns)
+          files << { path: base_path, source_dir: base_path } unless excluded?(base_path, exclude_patterns)
         elsif File.directory?(base_path)
           Find.find(base_path) do |path|
             next unless File.file?(path)
             next if excluded?(path, exclude_patterns)
 
-            files << path
+            files << { path: path, source_dir: base_path }
           end
         end
       end
@@ -248,15 +267,15 @@ module Ruborg
       Digest::SHA256.file(file_path).hexdigest
     end
 
-    def build_per_file_create_command(archive_name, file_path)
+    def build_per_file_create_command(archive_name, file_path, source_dir)
       cmd = [@repository.borg_path, "create"]
       cmd += ["--compression", @config.compression]
 
-      # Store file metadata (path + size + hash) in archive comment for duplicate detection
-      # Format: path|||size|||hash (using ||| as delimiter to avoid conflicts with paths)
+      # Store file metadata (path + size + hash + source_dir) in archive comment
+      # Format: path|||size|||hash|||source_dir (using ||| as delimiter to avoid conflicts with paths)
       file_size = File.size(file_path)
       file_hash = calculate_file_hash(file_path)
-      metadata = "#{file_path}|||#{file_size}|||#{file_hash}"
+      metadata = "#{file_path}|||#{file_size}|||#{file_hash}|||#{source_dir}"
       cmd += ["--comment", metadata]
 
       cmd << "#{@repository.path}::#{archive_name}"
@@ -470,7 +489,7 @@ module Ruborg
 
         unless info_status.success?
           # If we can't get info for this archive, skip it with defaults
-          hash[archive_name] = { path: "", size: 0, hash: "" }
+          hash[archive_name] = { path: "", size: 0, hash: "", source_dir: "" }
           next
         end
 
@@ -479,34 +498,44 @@ module Ruborg
         comment = archive_info["comment"] || ""
 
         # Parse comment based on format
-        # The comment field stores metadata as: path|||size|||hash (using ||| as delimiter)
+        # 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)
-        #   - New format: path|||size|||hash (3 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 >= 3
-            # New format: path|||size|||hash
+          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 not available)
+            # 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
 
         hash[archive_name] = {
           path: file_path,
           size: file_size,
-          hash: file_hash
+          hash: file_hash,
+          source_dir: source_dir
         }
       end
     rescue JSON::ParserError => e

data/lib/ruborg/cli.rb

@@ -184,8 +184,23 @@ module Ruborg
       raise
     end
 
-    desc "validate", "Validate configuration file for errors and type issues"
-    def validate_config
+    desc "validate TYPE", "Validate configuration file or repository (TYPE: config or repo)"
+    option :verify_data, type: :boolean, default: false, desc: "Verify repository data (slower, only for 'repo' type)"
+    option :all, type: :boolean, default: false, desc: "Validate all repositories (only for 'repo' type)"
+    def validate(type)
+      case type
+      when "config"
+        validate_config_implementation
+      when "repo"
+        validate_repo_implementation
+      else
+        raise ConfigError, "Invalid validation type: #{type}. Use 'config' or 'repo'"
+      end
+    end
+
+    private
+
+    def validate_config_implementation
       @logger.info("Validating configuration file: #{options[:config]}")
       config = Config.new(options[:config])
 
@@ -201,6 +216,7 @@ module Ruborg
       errors.concat(validate_boolean_setting(global_settings, "auto_init", "global"))
       errors.concat(validate_boolean_setting(global_settings, "auto_prune", "global"))
       errors.concat(validate_boolean_setting(global_settings, "allow_remove_source", "global"))
+      errors.concat(validate_boolean_setting(global_settings, "skip_hash_check", "global"))
 
       # Validate borg_options booleans
       if global_settings["borg_options"]
@@ -214,6 +230,7 @@ module Ruborg
         errors.concat(validate_boolean_setting(repo, "auto_init", repo_name))
         errors.concat(validate_boolean_setting(repo, "auto_prune", repo_name))
         errors.concat(validate_boolean_setting(repo, "allow_remove_source", repo_name))
+        errors.concat(validate_boolean_setting(repo, "skip_hash_check", repo_name))
 
         if repo["borg_options"]
           warnings.concat(validate_borg_option(repo["borg_options"], "allow_relocated_repo", repo_name))
@@ -257,64 +274,8 @@ module Ruborg
       raise
     end
 
-    desc "version", "Show ruborg version"
-    def version
-      require_relative "version"
-      puts "ruborg #{Ruborg::VERSION}"
-      @logger.info("Version checked: #{Ruborg::VERSION}")
-    end
-
-    desc "metadata ARCHIVE", "Get file metadata from an archive"
-    option :file, type: :string, desc: "Specific file path (required for standard archives, auto for per-file)"
-    def metadata(archive_name)
-      @logger.info("Getting metadata for archive: #{archive_name}")
-      config = Config.new(options[:config])
-
-      raise ConfigError, "Please specify --repository" unless options[:repository]
-
-      repo_config = config.get_repository(options[:repository])
-      raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
-
-      global_settings = config.global_settings
-      merged_config = global_settings.merge(repo_config)
-      validate_hostname(merged_config)
-      passphrase = fetch_passphrase_for_repo(merged_config)
-      borg_opts = merged_config["borg_options"] || {}
-      borg_path = merged_config["borg_path"]
-
-      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
-                                                 logger: @logger)
-
-      raise BorgError, "Repository does not exist at #{repo_config["path"]}" unless repo.exists?
-
-      # Get file metadata
-      metadata = repo.get_file_metadata(archive_name, file_path: options[:file])
-
-      # Display metadata
-      puts "\n═══════════════════════════════════════════════════════════════"
-      puts "  FILE METADATA"
-      puts "═══════════════════════════════════════════════════════════════\n\n"
-      puts "Archive: #{archive_name}"
-      puts "File: #{metadata["path"]}"
-      puts "Size: #{format_size(metadata["size"])}"
-      puts "Modified: #{metadata["mtime"]}"
-      puts "Mode: #{metadata["mode"]}"
-      puts "User: #{metadata["user"]}"
-      puts "Group: #{metadata["group"]}"
-      puts "Type: #{metadata["type"]}"
-      puts ""
-
-      @logger.info("Successfully retrieved metadata for #{metadata["path"]}")
-    rescue Error => e
-      @logger.error("Failed to get metadata: #{e.message}")
-      raise
-    end
-
-    desc "check", "Check repository integrity and compatibility"
-    option :verify_data, type: :boolean, default: false, desc: "Verify repository data (slower)"
-    option :all, type: :boolean, default: false, desc: "Check all repositories"
-    def check
-      @logger.info("Checking repository compatibility")
+    def validate_repo_implementation
+      @logger.info("Validating repository compatibility")
       config = Config.new(options[:config])
       global_settings = config.global_settings
       validate_hostname(global_settings)
@@ -323,31 +284,29 @@ module Ruborg
       borg_version = Repository.borg_version
       puts "\nBorg version: #{borg_version}\n\n"
 
-      repos_to_check = if options[:all]
-                         config.repositories
-                       elsif options[:repository]
-                         repo_config = config.get_repository(options[:repository])
-                         raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
+      repos_to_validate = if options[:all]
+                            config.repositories
+                          elsif options[:repository]
+                            repo_config = config.get_repository(options[:repository])
+                            raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
 
-                         [repo_config]
-                       else
-                         raise ConfigError, "Please specify --repository or --all"
-                       end
+                            [repo_config]
+                          else
+                            raise ConfigError, "Please specify --repository or --all"
+                          end
 
-      repos_to_check.each do |repo_config|
-        check_repository(repo_config, global_settings)
+      repos_to_validate.each do |repo_config|
+        validate_repository(repo_config, global_settings)
       end
     rescue Error => e
-      @logger.error("Check failed: #{e.message}")
+      @logger.error("Validation failed: #{e.message}")
       raise
     end
 
-    private
-
-    def check_repository(repo_config, global_settings)
+    def validate_repository(repo_config, global_settings)
       repo_name = repo_config["name"]
-      puts "--- Checking repository: #{repo_name} ---"
-      @logger.info("Checking repository: #{repo_name}")
+      puts "--- Validating repository: #{repo_name} ---"
+      @logger.info("Validating repository: #{repo_name}")
 
       merged_config = global_settings.merge(repo_config)
       validate_hostname(merged_config)
@@ -392,11 +351,96 @@ module Ruborg
 
       puts ""
     rescue BorgError => e
-      puts "  ✗ Check failed: #{e.message}"
-      @logger.error("Check failed for #{repo_name}: #{e.message}")
+      puts "  ✗ Validation failed: #{e.message}"
+      @logger.error("Validation failed for #{repo_name}: #{e.message}")
       puts ""
     end
 
+    public
+
+    desc "version", "Show ruborg and borg versions"
+    def version
+      require_relative "version"
+      puts "ruborg #{Ruborg::VERSION}"
+      @logger.info("Version checked: #{Ruborg::VERSION}")
+
+      begin
+        borg_version = Repository.borg_version
+        borg_path = Repository.borg_path
+        puts "borg #{borg_version} (#{borg_path})"
+        @logger.info("Borg version: #{borg_version}, path: #{borg_path}")
+      rescue BorgError => e
+        puts "borg: not found or not executable"
+        @logger.warn("Could not determine Borg version: #{e.message}")
+      end
+    end
+
+    desc "check", "DEPRECATED: Use 'ruborg validate repo' instead"
+    option :verify_data, type: :boolean, default: false, desc: "Verify repository data (slower)"
+    option :all, type: :boolean, default: false, desc: "Validate all repositories"
+    def check
+      puts "\n⚠️  DEPRECATED COMMAND"
+      puts "══════════════════════════════════════════════════════════════════\n\n"
+      puts "The 'ruborg check' command has been renamed for consistency.\n"
+      puts "Please use: ruborg validate repo\n\n"
+      puts "Examples:"
+      puts "  ruborg validate repo --repository documents"
+      puts "  ruborg validate repo --all"
+      puts "  ruborg validate repo --repository documents --verify-data\n\n"
+      puts "══════════════════════════════════════════════════════════════════\n"
+
+      @logger.warn("Deprecated command 'check' was called. User should use 'validate repo' instead.")
+      exit 1
+    end
+
+    desc "metadata ARCHIVE", "Get file metadata from an archive"
+    option :file, type: :string, desc: "Specific file path (required for standard archives, auto for per-file)"
+    def metadata(archive_name)
+      @logger.info("Getting metadata for archive: #{archive_name}")
+      config = Config.new(options[:config])
+
+      raise ConfigError, "Please specify --repository" unless options[:repository]
+
+      repo_config = config.get_repository(options[:repository])
+      raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
+
+      global_settings = config.global_settings
+      merged_config = global_settings.merge(repo_config)
+      validate_hostname(merged_config)
+      passphrase = fetch_passphrase_for_repo(merged_config)
+      borg_opts = merged_config["borg_options"] || {}
+      borg_path = merged_config["borg_path"]
+
+      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
+                                                 logger: @logger)
+
+      raise BorgError, "Repository does not exist at #{repo_config["path"]}" unless repo.exists?
+
+      # Get file metadata
+      metadata = repo.get_file_metadata(archive_name, file_path: options[:file])
+
+      # Display metadata
+      puts "\n═══════════════════════════════════════════════════════════════"
+      puts "  FILE METADATA"
+      puts "═══════════════════════════════════════════════════════════════\n\n"
+      puts "Archive: #{archive_name}"
+      puts "File: #{metadata["path"]}"
+      puts "Size: #{format_size(metadata["size"])}"
+      puts "Modified: #{metadata["mtime"]}"
+      puts "Mode: #{metadata["mode"]}"
+      puts "User: #{metadata["user"]}"
+      puts "Group: #{metadata["group"]}"
+      puts "Type: #{metadata["type"]}"
+      puts ""
+
+      @logger.info("Successfully retrieved metadata for #{metadata["path"]}")
+    rescue Error => e
+      @logger.error("Failed to get metadata: #{e.message}")
+      raise
+    end
+
+    private
+
     def show_repositories_summary(config)
       repositories = config.repositories
       global_settings = config.global_settings
@@ -578,10 +622,14 @@ module Ruborg
         end
       end
 
+      # Get skip_hash_check setting (defaults to false)
+      skip_hash_check = merged_config["skip_hash_check"]
+      skip_hash_check = false unless skip_hash_check == true
+
       # Create backup config wrapper
       backup_config = BackupConfig.new(repo_config, merged_config)
       backup = Backup.new(repo, config: backup_config, retention_mode: retention_mode, repo_name: repo_name,
-                                logger: @logger)
+                                logger: @logger, skip_hash_check: skip_hash_check)
 
       archive_name = options[:name] ? sanitize_archive_name(options[:name]) : nil
       @logger.info("Creating archive#{"s" if retention_mode == "per_file"}: #{archive_name || "auto-generated"}")

data/lib/ruborg/config.rb

@@ -41,7 +41,7 @@ module Ruborg
 
     def global_settings
       @data.slice("passbolt", "compression", "encryption", "auto_init", "borg_options", "log_file", "retention",
-                  "auto_prune", "hostname", "allow_remove_source", "borg_path")
+                  "auto_prune", "hostname", "allow_remove_source", "borg_path", "skip_hash_check")
     end
 
     private
@@ -54,12 +54,12 @@ module Ruborg
     # Valid configuration keys at each level
     VALID_GLOBAL_KEYS = %w[
       hostname compression encryption auto_init auto_prune allow_remove_source
-      log_file borg_path passbolt borg_options retention repositories
+      log_file borg_path passbolt borg_options retention repositories skip_hash_check
     ].freeze
 
     VALID_REPOSITORY_KEYS = %w[
       name description path hostname retention_mode passbolt retention sources
-      compression encryption auto_init auto_prune borg_options allow_remove_source
+      compression encryption auto_init auto_prune borg_options allow_remove_source skip_hash_check
     ].freeze
 
     VALID_SOURCE_KEYS = %w[name paths exclude].freeze
@@ -122,8 +122,9 @@ module Ruborg
       errors.concat(validate_boolean_config(@data, "auto_init", "global"))
       errors.concat(validate_boolean_config(@data, "auto_prune", "global"))
       errors.concat(validate_boolean_config(@data, "allow_remove_source", "global"))
+      errors.concat(validate_boolean_config(@data, "skip_hash_check", "global"))
 
-      # Note: borg_options are validated as warnings in CLI validate command, not as errors here
+      # NOTE: borg_options are validated as warnings in CLI validate command, not as errors here
 
       # Validate global passbolt
       errors.concat(validate_passbolt_config(@data["passbolt"], "global")) if @data["passbolt"]
@@ -151,6 +152,7 @@ module Ruborg
         errors.concat(validate_boolean_config(repo, "auto_init", repo_name))
         errors.concat(validate_boolean_config(repo, "auto_prune", repo_name))
         errors.concat(validate_boolean_config(repo, "allow_remove_source", repo_name))
+        errors.concat(validate_boolean_config(repo, "skip_hash_check", repo_name))
 
         # Validate retention_mode
         if repo["retention_mode"] && !VALID_RETENTION_MODES.include?(repo["retention_mode"])
@@ -158,7 +160,7 @@ module Ruborg
                     "Must be one of: #{VALID_RETENTION_MODES.join(", ")}"
         end
 
-        # Note: borg_options are validated as warnings in CLI validate command, not as errors here
+        # NOTE: borg_options are validated as warnings in CLI validate command, not as errors here
 
         errors.concat(validate_passbolt_config(repo["passbolt"], repo_name)) if repo["passbolt"]