ruborg 0.8.0 → 0.9.0

data/lib/ruborg/repository.rb

@@ -114,7 +114,7 @@ module Ruborg
         # For example: /var/folders/foo -> var/folders/foo
         # Try both the original path and the path with leading slash removed
         normalized_path = file_path.start_with?("/") ? file_path[1..] : file_path
-        file_metadata = files.find { |f| f["path"] == file_path || f["path"] == normalized_path }
+        file_metadata = files.find { |f| [file_path, normalized_path].include?(f["path"]) }
         raise BorgError, "File '#{file_path}' not found in archive" unless file_metadata
 
         file_metadata
@@ -166,8 +166,8 @@ module Ruborg
 
       unless keep_files_modified_within
         # Fall back to standard pruning if no file metadata retention specified
-        @logger&.info("No file metadata retention specified, using standard pruning")
-        prune_standard_archives(retention_policy)
+        @logger&.info("No file metadata retention specified, using standard pruning per directory")
+        prune_per_directory_standard(retention_policy)
         return
       end
 
@@ -176,35 +176,50 @@ module Ruborg
       # Parse time duration (e.g., "30d" -> 30 days)
       cutoff_time = Time.now - parse_time_duration(keep_files_modified_within)
 
-      # Get all archives with metadata
-      archives = list_archives_with_metadata
-      @logger&.info("Found #{archives.size} archive(s) to evaluate for pruning")
+      # Get all archives with metadata including source directory
+      archives_by_source = get_archives_grouped_by_source_dir
+      @logger&.info("Found #{archives_by_source.values.sum(&:size)} archive(s) in #{archives_by_source.size} source director(ies)")
 
-      archives_to_delete = []
+      total_deleted = 0
 
-      archives.each do |archive|
-        # Get file metadata from archive
-        file_mtime = get_file_mtime_from_archive(archive[:name])
+      # Process each source directory separately
+      archives_by_source.each do |source_dir, archives|
+        source_desc = source_dir.empty? ? "legacy archives (no source dir)" : source_dir
+        @logger&.info("Processing source directory: #{source_desc} (#{archives.size} archives)")
+
+        archives_to_delete = []
 
-        # Delete archive if file was modified before cutoff
-        if file_mtime && file_mtime < cutoff_time
-          archives_to_delete << archive[:name]
-          @logger&.debug("Archive #{archive[:name]} marked for deletion (file mtime: #{file_mtime})")
+        archives.each do |archive|
+          # Get file metadata from archive
+          file_mtime = get_file_mtime_from_archive(archive[:name])
+
+          # Delete archive if file was modified before cutoff
+          if file_mtime && file_mtime < cutoff_time
+            archives_to_delete << archive[:name]
+            @logger&.debug("Archive #{archive[:name]} marked for deletion (file mtime: #{file_mtime})")
+          end
         end
-      end
 
-      return if archives_to_delete.empty?
+        next if archives_to_delete.empty?
 
-      @logger&.info("Deleting #{archives_to_delete.size} archive(s)")
+        @logger&.info("Deleting #{archives_to_delete.size} archive(s) from #{source_desc}")
 
-      # Delete archives
-      archives_to_delete.each do |archive_name|
-        @logger&.debug("Deleting archive: #{archive_name}")
-        delete_archive(archive_name)
+        # Delete archives
+        archives_to_delete.each do |archive_name|
+          @logger&.debug("Deleting archive: #{archive_name}")
+          delete_archive(archive_name)
+        end
+
+        total_deleted += archives_to_delete.size
       end
 
-      @logger&.info("Pruned #{archives_to_delete.size} archive(s) based on file modification time")
-      puts "Pruned #{archives_to_delete.size} archive(s) based on file modification time"
+      if total_deleted.zero?
+        @logger&.info("No archives to prune")
+        puts "No archives to prune"
+      else
+        @logger&.info("Pruned #{total_deleted} archive(s) total across all source directories")
+        puts "Pruned #{total_deleted} archive(s) based on file modification time"
+      end
     end
 
     def list_archives_with_metadata
@@ -263,6 +278,142 @@ module Ruborg
       nil # Failed to parse, skip this archive
     end
 
+    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_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] || "") : ""
+                     else
+                       ""
+                     end
+
+        archives_by_source[source_dir] << {
+          name: archive_name,
+          time: Time.parse(archive["time"])
+        }
+      end
+
+      archives_by_source
+    rescue JSON::ParserError => e
+      raise BorgError, "Failed to parse archive metadata: #{e.message}"
+    end
+
+    def prune_per_directory_standard(retention_policy)
+      # Apply standard retention policies (keep_daily, etc.) per source directory
+      archives_by_source = get_archives_grouped_by_source_dir
+      @logger&.info("Applying standard retention per directory: #{archives_by_source.size} director(ies)")
+
+      total_pruned = 0
+
+      archives_by_source.each do |source_dir, archives|
+        source_desc = source_dir.empty? ? "legacy archives (no source dir)" : source_dir
+        @logger&.info("Processing source directory: #{source_desc} (#{archives.size} archives)")
+
+        # Create a temporary prefix to filter this directory's archives
+        # Since we can't directly use borg prune with filtering, we need to delete individually
+        archives_to_keep = apply_retention_policy(archives, retention_policy)
+        archives_to_delete = archives.map { |a| a[:name] } - archives_to_keep.map { |a| a[:name] }
+
+        next if archives_to_delete.empty?
+
+        @logger&.info("Pruning #{archives_to_delete.size} archive(s) from #{source_desc}")
+
+        archives_to_delete.each do |archive_name|
+          @logger&.debug("Deleting archive: #{archive_name}")
+          delete_archive(archive_name)
+        end
+
+        total_pruned += archives_to_delete.size
+      end
+
+      if total_pruned.zero?
+        @logger&.info("No archives to prune")
+        puts "No archives to prune"
+      else
+        @logger&.info("Pruned #{total_pruned} archive(s) total across all source directories")
+        puts "Pruned #{total_pruned} archive(s) across all source directories"
+      end
+    end
+
+    def apply_retention_policy(archives, policy)
+      # Sort archives by time (newest first)
+      sorted = archives.sort_by { |a| a[:time] }.reverse
+      to_keep = []
+
+      # Apply keep_last first (if specified)
+      to_keep += sorted.take(policy["keep_last"]) if policy["keep_last"]
+
+      # Apply time-based retention (keep_within)
+      if policy["keep_within"]
+        cutoff = Time.now - parse_time_duration(policy["keep_within"])
+        to_keep += sorted.select { |a| a[:time] >= cutoff }
+      end
+
+      # Apply count-based retention (keep_daily, keep_weekly, etc.)
+      # Group archives by time period and keep the newest from each period
+      %w[hourly daily weekly monthly yearly].each do |period|
+        keep_count = policy["keep_#{period}"]
+        next unless keep_count
+
+        case period
+        when "hourly"
+          grouped = sorted.group_by { |a| a[:time].strftime("%Y-%m-%d-%H") }
+        when "daily"
+          grouped = sorted.group_by { |a| a[:time].strftime("%Y-%m-%d") }
+        when "weekly"
+          grouped = sorted.group_by { |a| a[:time].strftime("%Y-W%W") }
+        when "monthly"
+          grouped = sorted.group_by { |a| a[:time].strftime("%Y-%m") }
+        when "yearly"
+          grouped = sorted.group_by { |a| a[:time].strftime("%Y") }
+        end
+
+        # Keep the newest archive from each of the most recent N periods
+        grouped.keys.sort.reverse.take(keep_count.to_i).each do |key|
+          to_keep << grouped[key].first
+        end
+      end
+
+      to_keep.uniq { |a| a[:name] }
+    end
+
     def delete_archive(archive_name)
       cmd = [@borg_path, "delete", "#{@path}::#{archive_name}"]
       execute_borg_command(cmd)
@@ -326,6 +477,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"

data/lib/ruborg/version.rb

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

data/ruborg.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "lib/ruborg/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruborg"
+  spec.version = Ruborg::VERSION
+  spec.authors = ["Michail Pantelelis"]
+  spec.email = ["mpantel@aegean.gr"]
+
+  spec.summary = "A friendly Ruby frontend for Borg backup"
+  spec.description = "Ruborg provides a user-friendly interface to Borg backup. " \
+                     "It reads YAML configuration files and orchestrates backup operations, " \
+                     "supporting repository creation, backup management, and Passbolt integration."
+  spec.homepage = "https://github.com/mpantel/ruborg"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "#{spec.homepage}.git"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_dependency "psych", "~> 5.0"
+  spec.add_dependency "thor", "~> 1.3"
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "bundler-audit", "~> 0.9"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+  spec.add_development_dependency "rubocop-rspec", "~> 3.0"
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruborg
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Michail Pantelelis
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: psych
@@ -137,6 +138,7 @@ files:
 - CHANGELOG.md
 - CLAUDE.md
 - LICENSE
+- PER_DIRECTORY_RETENTION.md
 - README.md
 - Rakefile
 - SECURITY.md
@@ -149,6 +151,7 @@ files:
 - lib/ruborg/passbolt.rb
 - lib/ruborg/repository.rb
 - lib/ruborg/version.rb
+- ruborg.gemspec
 - ruborg.yml.example
 homepage: https://github.com/mpantel/ruborg
 licenses:
@@ -158,6 +161,7 @@ metadata:
   source_code_uri: https://github.com/mpantel/ruborg.git
   changelog_uri: https://github.com/mpantel/ruborg/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -172,7 +176,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: A friendly Ruby frontend for Borg backup
 test_files: []