expire 0.2.0

data/lib/expire/purge_service.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Expire
+  # Purge expired backups
+  class PurgeService
+    def self.call(path, options)
+      new(path, options).call
+    end
+
+    def initialize(path, options)
+      @options = options
+      @path    = path
+    end
+
+    attr_reader :options, :path
+
+    def call
+      check_preconditions
+      purge_expired_backups
+    rescue StandardError => e
+      report.error(e.message)
+      raise
+    end
+
+    private
+
+    def annotated_backup_list
+      @annotated_backup_list ||= rules.apply(backup_list, DateTime.now)
+    end
+
+    def backup_list
+      @backup_list ||= GenerateBackupListService.call(path)
+    end
+
+    def check_preconditions
+      raise NoBackupsError, "Can't find any backups" unless backup_list.any?
+      raise NoRulesError, 'Will not purge without rules' unless rules.any?
+      raise AllBackupsExpiredError, 'Will not delete all backups' if annotated_backup_list.keep_count < 1
+    end
+
+    def report
+      @report ||= report_class.new
+    end
+
+    def report_class
+      wanted_format = options[:format]
+
+      return ReportNull unless wanted_format
+      return ReportNull if wanted_format == 'none'
+
+      class_name = "::Expire::Report#{wanted_format.titleize}"
+      class_name.safe_constantize or raise ArgumentError, "unknown format \"#{wanted_format}\""
+    end
+
+    def merge_rules
+      rules_file = options[:rules_file]
+      file_rules = rules_file ? Rules.from_yaml(rules_file) : Rules.new
+
+      option_rules = Rules.from_options(options.transform_keys(&:to_sym))
+      file_rules.merge(option_rules)
+    end
+
+    def purge_expired_backups
+      annotated_backup_list.sort.each do |backup|
+        if backup.expired?
+          report.before_purge(backup)
+          purge_pathname(backup.pathname)
+          report.after_purge(backup)
+        else
+          report.on_keep(backup)
+        end
+      end
+    end
+
+    def purge_pathname(pathname)
+      return if options[:simulate]
+
+      purge_command = options[:purge_command]
+
+      if purge_command
+        system("#{purge_command} #{pathname}")
+      else
+        pathname.unlink
+      end
+    end
+
+    def rules
+      @rules ||= merge_rules
+    end
+  end
+end

data/lib/expire/refine_all_and_none.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Expire
+  # Enhance Integer and String with the methods #all? and #none?
+  module RefineAllAndNone
+    refine String do
+      def all?
+        return true if ['-1', 'all'].include?(strip.downcase)
+      end
+
+      # %w does not work here, I assume there is a problem with "0"
+      # rubocop:disable Style/RedundantPercentQ
+      def none?
+        return true if %q(0 none).include?(strip.downcase)
+      end
+      # rubocop:enable Style/RedundantPercentQ
+    end
+
+    refine Integer do
+      def all?
+        return true if self == -1
+      end
+
+      def none?
+        return true if zero?
+      end
+    end
+  end
+end

data/lib/expire/report_base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# For some unknown reason Pastel is not autoloaded by Zeitwerk
+require 'pastel'
+
+module Expire
+  # Base class for Reporters
+  class ReportBase < ReportNull
+    def initialize(receiver: $stdout)
+      @receiver = receiver
+    end
+
+    attr_reader :receiver
+
+    def error(message)
+      receiver.puts(pastel.red(message))
+    end
+
+    def pastel
+      @pastel ||= ::Pastel.new
+    end
+  end
+end

data/lib/expire/report_enhanced.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Expire
+  # Detailed information about what is being kept and why
+  class ReportEnhanced < ReportSimple
+    def on_keep(backup)
+      receiver.puts(pastel.green("keeping #{backup.pathname}"))
+      receiver.puts '  reasons:'
+      backup.reasons_to_keep.each do |reason|
+        receiver.puts "    - #{reason}"
+      end
+    end
+  end
+end

data/lib/expire/report_expired.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Expire
+  # Print the paths of expired backups
+  class ReportExpired < ReportBase
+    def before_purge(backup)
+      receiver.puts backup.pathname.to_s
+    end
+  end
+end

data/lib/expire/report_kept.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Expire
+  # Print the backups that are kept
+  class ReportKept < ReportBase
+    def on_keep(backup)
+      receiver.puts backup.pathname.to_s
+    end
+  end
+end

data/lib/expire/report_null.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Expire
+  # Ignores all messages expect #error and report nothing.
+  # When error is received the message is printed to STDOUT.
+  class ReportNull
+    def error(message)
+      puts message
+    end
+
+    def before_all(_); end
+
+    def after_all(_); end
+
+    def on_keep(_); end
+
+    def before_purge(_); end
+
+    def after_purge(_); end
+  end
+end

data/lib/expire/report_simple.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Expire
+  # Sends "keeping" and "purged" to it's receiver
+  class ReportSimple < ReportBase
+    def on_keep(backup)
+      receiver.puts(pastel.green("keeping #{backup.pathname}"))
+    end
+
+    def after_purge(backup)
+      receiver.puts(pastel.yellow("purged #{backup.pathname}"))
+    end
+  end
+end

data/lib/expire/rule_base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Expire
+  # Base class of all rules
+  class RuleBase
+    include Comparable
+
+    def self.<=>(other)
+      rank <=> other.rank
+    end
+
+    def self.camelized_name
+      match = to_s.match(/\A.*::(.+)Rule\z/) || return
+      match[1]
+    end
+
+    def self.name
+      camelized_name&.underscore
+    end
+
+    def self.option_name
+      rule_name = name || return
+      "--#{rule_name.dasherize}"
+    end
+
+    def initialize(amount:)
+      @amount = amount
+    end
+
+    attr_reader :amount
+
+    def name
+      camelized_name&.underscore
+    end
+
+    def numerus_backup
+      'backup'.pluralize(amount)
+    end
+
+    def option_name
+      rule_name = name || return
+      "--#{rule_name.dasherize}"
+    end
+
+    def <=>(other)
+      rank <=> other.rank
+    end
+
+    private
+
+    def camelized_name
+      match = self.class.to_s.match(/\A.*::(.+)Rule\z/) || return
+      match[1]
+    end
+  end
+end

data/lib/expire/rule_list.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Expire
+  # List rule classes, names and option-names
+  class RuleList
+    include Singleton
+
+    def self.class_names
+      instance.class_names
+    end
+
+    def self.names
+      instance.names
+    end
+
+    def self.name_symbols
+      instance.name_symbols
+    end
+
+    def self.option_names
+      instance.option_names
+    end
+
+    def class_names
+      @class_names ||= rule_classes.map(&:to_s).freeze
+    end
+
+    def names
+      rule_classes.map(&:name)
+    end
+
+    def name_symbols
+      names.map(&:to_sym)
+    end
+
+    def option_names
+      rule_classes.map(&:option_name)
+    end
+
+    private
+
+    def rule_classes
+      @rule_classes ||= rule_class_names.map(&:constantize).sort.freeze
+    end
+
+    def rule_class_names
+      class_symbols = Expire.constants.select { |klass| Expire.const_get(klass).to_s =~ /Rule\z/ }
+
+      class_symbols.map { |c_sym| "Expire::#{c_sym}" }
+    end
+  end
+end

data/lib/expire/rules.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Expire
+  # How backups are expired
+  class Rules
+    def self.from_options(options)
+      known_rules = RuleList.name_symbols
+
+      rule_options = options.select { |opt, _| known_rules.include?(opt) }
+
+      new(rule_options)
+    end
+
+    def self.from_yaml(file_name)
+      pathname = Pathname.new(file_name)
+      yaml_text = pathname.read
+      yaml_rules = YAML.safe_load(yaml_text, symbolize_names: true)
+      new(yaml_rules)
+    end
+
+    def initialize(given = {})
+      @rules = given.map do |rule_name, value|
+        if value.respond_to? :rank
+          value
+        else
+          rule_class = rule_class_for(rule_name)
+          rule_class.from_value(value)
+        end
+      end
+    end
+
+    attr_reader :rules
+
+    def any?
+      rules.any?
+    end
+
+    def apply(backups, reference_datetime)
+      rules.sort.each { |rule| rule.apply(backups, reference_datetime) }
+
+      backups
+    end
+
+    def count
+      @rules.length
+    end
+
+    def merge(prior_rules)
+      self.class.new(to_h.merge(prior_rules.to_h))
+    end
+
+    def to_h
+      rules.map { |rule| [rule.name.to_sym, rule] }.to_h
+    end
+
+    private
+
+    def rule_class_for(key)
+      rule_class_name_for(key).safe_constantize || raise(UnknownRuleError, key)
+    end
+
+    def rule_class_name_for(key)
+      "::Expire::#{key.to_s.camelize}Rule"
+    end
+  end
+end

data/lib/expire/templates/newest/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/expire/templates/oldest/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/expire/templates/purge/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/expire/templates/remove/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/expire/templates/rule_classes/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/expire/templates/rule_names/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/expire/templates/rule_option_names/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/expire/unknown_rule_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Expire
+  # Thrown if a rule-name is not known
+  class UnknownRuleError < StandardError
+    def initialize(rule_name)
+      super("unknown rule name \"#{rule_name}\"")
+    end
+  end
+end

data/lib/expire/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Expire
+  MAJOR = 0
+  MINOR = 2
+  TINY  = 0
+
+  VERSION = [MAJOR, MINOR, TINY].compact * '.'
+end