expire 0.2.0

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+Cucumber::Rake::Task.new(:cucumber) do |task|
+  task.cucumber_opts = '--format pretty'
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:spec, :cucumber]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "expire"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/example_rules/bad_rules.yml

@@ -0,0 +1,2 @@
+---
+no_such_parameter: no such value

data/example_rules/good_rules.yml

@@ -0,0 +1 @@
+monthly: 5

data/exe/expire

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# -*- mode: ruby
+
+require 'expire/cli'
+Expire::CLI.start

data/expire.gemspec

@@ -0,0 +1,54 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "expire/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "expire"
+  spec.version       = Expire::VERSION
+  spec.authors       = ["Thomas Regnet"]
+  # spec.email         = ["TODO: Write your email address"]
+
+  spec.summary       = %q{Calculate expired backups.}
+  spec.homepage      = 'https://github.com/thomasregnet/expire'
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org.
+  # To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section
+  # to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = spec.homepage
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'activesupport', '~> 6.1'
+  spec.add_dependency 'pastel', '~> 0.8'
+  spec.add_dependency 'thor', '~> 1.1'
+  spec.add_dependency 'zeitwerk', "~> 2.4"
+
+  spec.add_development_dependency 'aruba', '~> 1.0'
+  spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'byebug', '~> 11.1'
+  spec.add_development_dependency 'cucumber', '~> 5.3'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'reek', '~> 6.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.9'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.2'
+  spec.add_development_dependency 'simplecov', '~> 0.21'
+end

data/lib/expire.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/core_ext/date_and_time/calculations'
+require 'date'
+require 'yaml'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect('cli' => 'CLI')
+loader.setup
+
+# Expire backup directories
+module Expire
+  # Exception derived from StandardError
+  class Error < StandardError; end
+  # Your code goes here...
+
+  def self.create_playground(base)
+    Playground.create(base)
+  end
+
+  def self.newest(path)
+    GenerateBackupListService.call(path).newest
+  end
+
+  def self.oldest(path)
+    GenerateBackupListService.call(path).oldest
+  end
+
+  def self.purge(path, options)
+    PurgeService.call(path, options)
+  end
+
+  def self.remove(path)
+    FileUtils.rm_r(path)
+  end
+
+  def self.rule_classes
+    Expire::RuleList.class_names
+  end
+
+  def self.rule_names
+    Expire::RuleList.names
+  end
+
+  def self.rule_option_names
+    Expire::RuleList.option_names
+  end
+end

data/lib/expire/all_backups_expired_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Expire
+  # Thrown if all backups are expired
+  class AllBackupsExpiredError < StandardError
+  end
+end

data/lib/expire/backup.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Expire
+  # Representation of a single backup
+  class Backup < Delegator
+    include Comparable
+
+    def initialize(datetime:, pathname:)
+      @datetime = datetime
+      @pathname = pathname
+
+      # @reasons_to_keep is a Set so a reason can added multiple times
+      # but appears only once
+      @reasons_to_keep = Set.new
+    end
+
+    attr_reader :datetime, :pathname, :reasons_to_keep
+    alias __getobj__ datetime
+
+    def same_hour?(other)
+      return false unless same_day?(other)
+      return true if hour == other.hour
+
+      false
+    end
+
+    def same_day?(other)
+      return false unless same_week?(other)
+      return true if day == other.day
+
+      false
+    end
+
+    def same_week?(other)
+      return false unless same_year?(other)
+      return true if cweek == other.cweek
+
+      false
+    end
+
+    def same_month?(other)
+      return false unless same_year?(other)
+      return true if month == other.month
+
+      false
+    end
+
+    def same_year?(other)
+      year == other.year
+    end
+
+    # The <=> method seems not to be delegated so we need to implement it
+    # Note that this Class includes the Comparable module
+    def <=>(other)
+      datetime <=> other.datetime
+    end
+
+    def add_reason_to_keep(reason)
+      reasons_to_keep << reason
+    end
+
+    # def datetime
+    #   backup.datetime
+    # end
+
+    def expired?
+      reasons_to_keep.empty?
+    end
+
+    def keep?
+      reasons_to_keep.any?
+    end
+  end
+end

data/lib/expire/backup_from_path_service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Expire
+  # Take a path and return an instance of Expire::Backup
+  class BackupFromPathService
+    def self.call(path:, by: :path)
+      new(path: path, by: by).call
+    end
+
+    def initialize(path:, by: :path)
+      @by       = by
+      @pathname = Pathname.new(path)
+
+      raise ArgumentError, "by: must be :ctime, :mtime or :path, not #{by}" unless %i[ctime mtime path].include?(by)
+    end
+
+    attr_reader :by, :pathname
+
+    def call
+      Backup.new(datetime: datetime, pathname: pathname)
+    end
+
+    private
+
+    def datetime
+      digits = extract_digits
+
+      year   = digits[0..3].to_i
+      month  = digits[4..5].to_i
+      day    = digits[6..7].to_i
+      hour   = digits[8..9].to_i
+      minute = digits[10..11].to_i
+
+      datetime_for(year, month, day, hour, minute)
+    end
+
+    def datetime_for(year, month, day, hour, minute)
+      DateTime.new(year, month, day, hour, minute)
+    rescue Date::Error
+      raise InvalidPathError, "can't construct date and time from #{pathname}" 
+    end
+
+    def extract_digits
+      basename = pathname.basename.to_s
+
+      digits = basename.gsub(/[^0-9]/, '')
+
+      digits_length = digits.length
+
+      return digits if digits_length == 12
+      return digits if digits_length == 14
+
+      raise InvalidPathError, "can't extract date and time from #{basename}"
+    end
+  end
+end

data/lib/expire/backup_list.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Expire
+  # All Backups go here
+  class BackupList
+    include Enumerable
+    extend Forwardable
+
+    def initialize(backups = [])
+      # @backups = backups.sort.reverse
+      @backups = backups
+    end
+
+    attr_reader :backups
+
+    def_delegators :backups, :each, :empty?, :last, :length, :<<
+
+    def one_per(noun)
+      backups_per_noun = self.class.new
+      return backups_per_noun unless any?
+
+      reversed = sort.reverse
+
+      backups_per_noun << reversed.first
+
+      message = "same_#{noun}?"
+
+      reversed.each do |backup|
+        backups_per_noun << backup unless backup.send(message, backups_per_noun.last)
+      end
+
+      backups_per_noun
+    end
+
+    def most_recent(amount = 1)
+      self.class.new(sort.reverse.first(amount))
+    end
+
+    def newest
+      backups.max
+    end
+
+    def oldest
+      backups.min
+    end
+
+    def not_older_than(reference_datetime)
+      sort.select { |backup| backup.datetime >= reference_datetime }
+    end
+
+    def expired
+      self.class.new(backups.select(&:expired?))
+    end
+
+    def expired_count
+      expired.length
+    end
+
+    def keep
+      self.class.new(backups.select(&:keep?))
+    end
+
+    def keep_count
+      keep.length
+    end
+  end
+end

data/lib/expire/cli.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'expire'
+require 'thor'
+
+module Expire
+  # Command line interface
+  # rubocop:disable Metrics/ClassLength
+  class CLI < Thor
+    desc 'rule_option_names', 'List rule option names ordered by their rank'
+    method_option(
+      :help,
+      aliases: '-h',
+      type:    :boolean,
+      desc:    'Display usage information'
+    )
+    def rule_option_names(*)
+      if options[:help]
+        invoke :help, ['rule_option_names']
+      else
+        require_relative 'commands/rule_option_names'
+        Expire::Commands::RuleOptionNames.new(options).execute
+      end
+    end
+
+    desc 'rule_names', 'List rule names ordered by their rank'
+    method_option(
+      :help,
+      aliases: '-h',
+      type:    :boolean,
+      desc:    'Display usage information'
+    )
+    def rule_names(*)
+      if options[:help]
+        invoke :help, ['rule_names']
+      else
+        require_relative 'commands/rule_names'
+        Expire::Commands::RuleNames.new(options).execute
+      end
+    end
+
+    desc 'rule_classes', 'List rule classes ordered by their rank'
+    method_option(
+      :help,
+      aliases: '-h',
+      type:    :boolean,
+      desc:    'Display usage information'
+    )
+    def rule_classes(*)
+      if options[:help]
+        invoke :help, ['rule_classes']
+      else
+        require_relative 'commands/rule_classes'
+        Expire::Commands::RuleClasses.new(options).execute
+      end
+    end
+
+    desc 'remove PATH', 'Remove PATH from the filesystem'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def remove(path)
+      if options[:help]
+        invoke :help, ['remove']
+      else
+        require_relative 'commands/remove'
+        Expire::Commands::Remove.new(path: path).execute
+      end
+    end
+
+    desc 'oldest PATH', 'Show the oldest backup'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def oldest(path)
+      if options[:help]
+        invoke :help, ['oldest']
+      else
+        require_relative 'commands/oldest'
+        Expire::Commands::Oldest.new(path, options).execute
+      end
+    end
+
+    desc 'newest PATH', 'Show the newest backup'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def newest(path)
+      if options[:help]
+        invoke :help, ['newest']
+      else
+        require_relative 'commands/newest'
+        Expire::Commands::Newest.new(path, options).execute
+      end
+    end
+    # Play with test-data
+    class Playground < Thor
+      desc 'create PATH', 'play with test-data'
+      def create(path)
+        Expire.create_playground(path)
+      end
+    end
+
+    desc 'purge PATH', 'Remove expired backups from PATH'
+    method_option :help, aliases: '-h', type: :boolean,
+      desc: 'Display usage information'
+    method_option :format, aliases: '-f', type: :string,
+      enum: %w[expired kept none simple enhanced],
+      default: 'none',
+      desc: 'output format'
+    method_option :purge_command, aliases: '--cmd', type: :string,
+      desc: 'run command to purge the backup'
+    method_option :rules_file, aliases: '-r', type: :string,
+      desc: 'read expire-rules from file'
+    method_option :simulate, aliases: '-s', type: :boolean,
+      desc: 'Simulate purge, do not delete anything'
+    method_option(
+      :keep_most_recent,
+      type: :string,
+      desc: 'keep the <integer> most recent backups'
+    )
+    method_option(
+      :keep_most_recent_for,
+      type: :string,
+      desc: 'keep the most recent backups for <integer> <unit>'
+    )
+    method_option(
+      :from_now_keep_most_recent_for,
+      type: :string,
+      desc: 'keep the most recent backups for <integer> <unit> calculated from now'
+    )
+    method_option(
+      :keep_hourly,
+      type: :string,
+      desc: 'keep the <integer> most recent backups from different hours'
+    )
+    method_option(
+      :keep_daily,
+      type: :string,
+      desc: 'keep the <integer> most recent backups from different days'
+    )
+    method_option(
+      :keep_weekly,
+      type: :string,
+      desc: 'keep the <integer> most recent backups from different weeks'
+    )
+    method_option(
+      :keep_monthly,
+      type: :string,
+      desc: 'keep the <integer> most recent backups from different months'
+    )
+    method_option(
+      :keep_yearly,
+      type: :string,
+      desc: 'keep the <integer> most recent backups from different years'
+    )
+    method_option(
+      :keep_hourly_for,
+      type: :string,
+      desc: 'keep one backup per hour for <integer> <unit>'
+    )
+    method_option(
+      :keep_daily_for,
+      type: :string,
+      desc: 'keep one backup per day for <integer> <unit>'
+    )
+    method_option(
+      :keep_weekly_for,
+      type: :string,
+      desc: 'keep one backup per week for <integer> <unit>'
+    )
+    method_option(
+      :keep_monthly_for,
+      type: :string,
+      desc: 'keep one backup per month for <integer> <unit>'
+    )
+    method_option(
+      :keep_yearly_for,
+      type: :string,
+      desc: 'keep one backup per year for <integer> <unit>'
+    )
+    method_option(
+      :from_now_keep_hourly_for,
+      type: :string,
+      desc: 'keep one backup per hour for <integer> <unit> calculated from now'
+    )
+    method_option(
+      :from_now_keep_daily_for,
+      type: :string,
+      desc: 'keep one backup per hour for <integer> <unit> calculated from now'
+    )
+    method_option(
+      :from_now_keep_weekly_for,
+      type: :string,
+      desc: 'keep one backup per hour for <integer> <unit> calculated from now'
+    )
+    method_option(
+      :from_now_keep_monthly_for,
+      type: :string,
+      desc: 'keep one backup per hour for <integer> <unit> calculated from now'
+    )
+    method_option(
+      :from_now_keep_yearly_for,
+      type: :string,
+      desc: 'keep one backup per hour for <integer> <unit> calculated from now'
+    )
+    def purge(path)
+      if options[:help]
+        invoke :help, ['purge']
+      else
+        require_relative 'commands/purge'
+        Expire::Commands::Purge.new(path, options).execute
+      end
+    end
+
+    desc 'playground', 'play with test-data'
+    subcommand 'playground', Playground
+
+    def self.exit_on_failure?
+      true
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end