expire 0.2.0

data/lib/expire/generate_backup_list_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Expire
+  # Reads contents of a directory and returns a corresponding BackupList
+  class GenerateBackupListService
+    def self.call(path)
+      new(path).call
+    end
+
+    def initialize(path)
+      @path = path
+    end
+
+    attr_reader :path
+
+    def call
+      if path == '-'
+        generate_backup_list_from($stdin)
+      else
+        pathname = Pathname.new(path)
+        raise InvalidPathError, "#{pathname} does not exit" unless pathname.exist?
+
+        generate_backup_list_from(pathname.children)
+      end
+    end
+
+    private
+
+    def generate_backup_list_from(source)
+      backup_list = BackupList.new
+
+      source.each do |backup_path|
+        backup_list << BackupFromPathService.call(path: purify_backup_path(backup_path))
+      end
+
+      backup_list
+    end
+
+    # backup_path may be a String or a Pathname so we call #to_s to
+    # ensure that chomp works as expected
+    def purify_backup_path(backup_path)
+      backup_path.to_s.chomp.strip
+    end
+  end
+end

data/lib/expire/invalid_path_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Thrown if a path is invalid
+  class InvalidPathError < StandardError
+  end
+end

data/lib/expire/keep_adjective_for_rule_base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Expire
+  # Hold backups for a period
+  class KeepAdjectiveForRuleBase < FromNowKeepAdjectiveForRuleBase
+    ADJECTIVE_FOR = {
+      'week' => 'weekly',
+      'month' => 'monthly',
+      'year' => 'yearly'
+    }.freeze
+
+    PRIMARY_RANK = 30
+
+    def self.primary_rank
+      PRIMARY_RANK
+    end
+
+    def self.rank
+      primary_rank + secondary_rank
+    end
+
+    def apply(backups, _)
+      super(backups, backups.newest)
+    end
+
+    def primary_rank
+      self.class.primary_rank
+    end
+
+    def reason_to_keep
+      "keep #{amount} #{ADJECTIVE_FOR[spacing]} #{numerus_backup}"
+    end
+  end
+end

data/lib/expire/keep_adjective_rule_base.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Expire
+  # Base class for rules with an adjective in their name
+  class KeepAdjectiveRuleBase < RuleBase
+    using RefineAllAndNone
+
+    NOUN_FOR = {
+      'hourly' => 'hour',
+      'daily' => 'day',
+      'weekly' => 'week',
+      'monthly' => 'month',
+      'yearly' => 'year'
+    }.freeze
+
+    PRIMARY_RANK = 20
+    SECONDARY_RANK_FOR = {
+      'hourly' => 1,
+      'daily' => 2,
+      'weekly' => 3,
+      'monthly' => 4,
+      'yearly' => 5
+    }.freeze
+
+    def self.from_value(value)
+      value = -1 if value.all?
+      value = 0 if value.none?
+
+      integer_value = Integer(value)
+      raise ArgumentError, 'must be at least -1' if integer_value < -1
+
+      new(amount: integer_value)
+    end
+
+    def self.primary_rank
+      PRIMARY_RANK
+    end
+
+    def self.rank
+      primary_rank + secondary_rank
+    end
+
+    def self.secondary_rank
+      match = name.downcase.match(/(hourly|daily|weekly|monthly|yearly)/)
+      return unless match
+
+      SECONDARY_RANK_FOR[match[1]]
+    end
+
+    def adjective
+      @adjective ||= infer_adjective
+    end
+
+    def apply(backups, _)
+      per_spacing = backups.one_per(spacing)
+      kept = amount == -1 ? per_spacing : per_spacing.most_recent(amount)
+      kept.each { |backup| backup.add_reason_to_keep(reason_to_keep) }
+    end
+
+    def rank
+      @rank ||= primary_rank + secondary_rank
+    end
+
+    def primary_rank
+      self.class.primary_rank
+    end
+
+    def secondary_rank
+      self.class.secondary_rank
+    end
+
+    def spacing
+      NOUN_FOR[adjective]
+    end
+
+    private
+
+    def class_name
+      self.class.to_s
+    end
+
+    def infer_adjective
+      match = class_name.downcase.match(/(hourly|daily|weekly|monthly|yearly)/)
+      return unless match
+
+      match[1]
+    end
+
+    def reason_to_keep
+      "keep #{pretty_amount} #{adjective} #{numerus_backup}"
+    end
+
+    def pretty_amount
+      amount == -1 ? 'all' : amount.to_s
+    end
+  end
+end

data/lib/expire/keep_daily_for_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep a daily backup for a certain period of time
+  class KeepDailyForRule < KeepAdjectiveForRuleBase
+  end
+end

data/lib/expire/keep_daily_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per day
+  class KeepDailyRule < KeepAdjectiveRuleBase
+  end
+end

data/lib/expire/keep_hourly_for_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per hour for a certain period of time.
+  class KeepHourlyForRule < KeepAdjectiveForRuleBase
+  end
+end

data/lib/expire/keep_hourly_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per hour
+  class KeepHourlyRule < KeepAdjectiveRuleBase
+  end
+end

data/lib/expire/keep_monthly_for_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per mounth for a certain period of time
+  class KeepMonthlyForRule < KeepAdjectiveForRuleBase
+  end
+end

data/lib/expire/keep_monthly_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per month
+  class KeepMonthlyRule < KeepAdjectiveRuleBase
+  end
+end

data/lib/expire/keep_most_recent_for_rule.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep the most recent backups for a
+  # certain period of time.
+  class KeepMostRecentForRule < FromNowKeepMostRecentForRule
+    extend FromRangeValue
+    include NumerusUnit
+
+    RULE_RANK = 11
+
+    attr_reader :unit
+
+    def self.rank
+      RULE_RANK
+    end
+
+    def apply(backups, _)
+      reference_datetime = backups.newest
+      super(backups, reference_datetime)
+    end
+
+    def rank
+      self.class.rank
+    end
+
+    def reason_to_keep
+      "keep most recent backups for #{amount} #{numerus_unit}"
+    end
+  end
+end

data/lib/expire/keep_most_recent_rule.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep the most recent Backups
+  class KeepMostRecentRule < RuleBase
+    using RefineAllAndNone
+
+    RULE_RANK = 10
+
+    def self.from_value(value)
+      return new(amount: 0) if value.none?
+
+      new(amount: Integer(value))
+    end
+
+    def self.rank
+      RULE_RANK
+    end
+
+    def rank
+      self.class.rank
+    end
+
+    def apply(backups, _)
+      backups.most_recent(amount).each do |backup|
+        backup.add_reason_to_keep(reason_to_keep)
+      end
+    end
+
+    private
+
+    def reason_to_keep
+      return 'keep the most recent backup' if amount == 1
+
+      "keep the #{amount} most recent backups"
+    end
+  end
+end

data/lib/expire/keep_weekly_for_rule.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per week for a certain
+  # period of time.
+  class KeepWeeklyForRule < KeepAdjectiveForRuleBase
+  end
+end

data/lib/expire/keep_weekly_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per week
+  class KeepWeeklyRule < KeepAdjectiveRuleBase
+  end
+end

data/lib/expire/keep_yearly_for_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per year
+  class KeepYearlyForRule < KeepAdjectiveForRuleBase
+  end
+end

data/lib/expire/keep_yearly_rule.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Keep one backup per year
+  class KeepYearlyRule < KeepAdjectiveRuleBase
+  end
+end

data/lib/expire/no_backups_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Thrown if no backups can be found
+  class NoBackupsError < StandardError
+  end
+end

data/lib/expire/no_rules_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Thrown if a rule-name is not known
+  class NoRulesError < StandardError
+  end
+end

data/lib/expire/numerus_unit.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Expire
+  # A mixin to get the right numerus of #unit
+  module NumerusUnit
+    def numerus_unit
+      unit.pluralize(amount)
+    end
+  end
+end

data/lib/expire/path_already_exists_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Thrown if a file or directory exists when it should not
+  class PathAlreadyExistsError < StandardError
+  end
+end

data/lib/expire/playground.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Expire
+  # Create playground with example data
+  class Playground
+    STEP_WIDTHS = {
+      'hourly' => 'hour',
+      'daily' => 'day',
+      'weekly' => 'week',
+      'monthly' => 'month',
+      'yearly' => 'year'
+    }.freeze
+
+    def self.create(base)
+      new(base).create
+    end
+
+    def initialize(base)
+      @base        = base
+      @backups_dir = Pathname.new("#{base}/backups")
+
+      @options = {
+        hourly:  42,
+        daily:   15,
+        weekly:  15,
+        monthly: 25,
+        yearly:  5
+      }
+    end
+
+    attr_reader :backups_dir, :base, :options
+
+    def create
+      raise_if_backups_dir_exists
+
+      oldest_backup = DateTime.now
+
+      STEP_WIDTHS.each do |adjective, noun|
+        options[adjective.to_sym].times do
+          oldest_backup = oldest_backup.ago(1.send(noun))
+          mkbackup(oldest_backup)
+        end
+      end
+    end
+
+    private
+
+    def mkbackup(datetime)
+      backup_name = datetime.to_s.sub(/:\d\d[+-]\d\d:\d\d\z/, '')
+      FileUtils.mkdir_p("#{backups_dir}/#{backup_name}")
+    end
+
+    def raise_if_backups_dir_exists
+      return unless FileTest.exist?(backups_dir)
+
+      raise(
+        PathAlreadyExistsError,
+        "Will not create playground in existing path #{backups_dir}"
+      )
+    end
+  end
+end