activejob-retry 0.0.1 → 0.1.1

data/lib/active_job/retry/exponential_options_validator.rb

@@ -1,57 +0,0 @@
-module ActiveJob
-  module Retry
-    class ExponentialOptionsValidator
-      DELAY_MULTIPLIER_KEYS = %i(min_delay_multiplier max_delay_multiplier).freeze
-
-      def initialize(options)
-        @options = options
-        @retry_limit = options[:limit] || options.fetch(:strategy, []).length
-      end
-
-      def validate!
-        validate_strategy!
-        validate_delay_multipliers!
-      end
-
-      private
-
-      attr_reader :options, :retry_limit
-
-      def validate_strategy!
-        unless options[:strategy]
-          raise InvalidConfigurationError, "You must define a backoff strategy"
-        end
-
-        return unless retry_limit
-
-        unless retry_limit > 0
-          raise InvalidConfigurationError,
-                "Exponential backoff cannot be used with infinite or no retries"
-        end
-
-        return if options[:strategy].length == retry_limit
-
-        raise InvalidConfigurationError, "Strategy must have a delay for each retry"
-      end
-
-      def validate_delay_multipliers!
-        unless both_or_neither_multiplier_supplied?
-          raise InvalidConfigurationError,
-                "If one of min/max_delay_multiplier is supplied, both are required"
-        end
-
-        return unless options[:min_delay_multiplier] && options[:max_delay_multiplier]
-
-        return if options[:min_delay_multiplier] <= options[:max_delay_multiplier]
-
-        raise InvalidConfigurationError,
-              "min_delay_multiplier must be less than or equal to max_delay_multiplier"
-      end
-
-      def both_or_neither_multiplier_supplied?
-        supplied = DELAY_MULTIPLIER_KEYS.map { |key| options.key?(key) }
-        supplied.none? || supplied.all?
-      end
-    end
-  end
-end

data/lib/active_job/retry/invalid_configuration_error.rb

@@ -1,6 +0,0 @@
-module ActiveJob
-  module Retry
-    class InvalidConfigurationError < StandardError
-    end
-  end
-end

data/lib/active_job/retry/options_validator.rb

@@ -1,84 +0,0 @@
-module ActiveJob
-  module Retry
-     class OptionsValidator
-      def initialize(options)
-        @options = options
-      end
-
-      def validate!
-        validate_limit!
-        validate_delay!
-        validate_fatal_exceptions!
-        validate_retry_exceptions!
-      end
-
-      private
-
-      attr_reader :options
-
-      # Limit must be an integer >= -1
-      # If it is -1 you *must* set `infinite_job: true` and understand that you're
-      # entering a world of pain and your ops team might hurt you.
-      def validate_limit!
-        return unless options[:limit]
-
-        unless options[:limit].is_a?(Fixnum)
-          raise InvalidConfigurationError, "Limit must be an integer"
-        end
-
-        raise InvalidConfigurationError, "Limit must be >= -1" if options[:limit] < -1
-
-        if options[:limit] == -1 && !options[:infinite_job]
-          raise InvalidConfigurationError,
-                "You must set `infinite_job: true` to use an infinite job"
-        end
-      end
-
-      # Delay must be non-negative
-      def validate_delay!
-        return unless options[:delay]
-
-        unless options[:delay] >= 0
-          raise InvalidConfigurationError, "Delay must be non-negative"
-        end
-      end
-
-      # Fatal exceptions must be an array (cannot be nil, since then all exceptions would
-      # be fatal - for that just set `limit: 0`)
-      def validate_fatal_exceptions!
-        return unless options[:fatal_exceptions]
-
-        unless options[:retry_exceptions].nil?
-          raise InvalidConfigurationError,
-                "fatal_exceptions and retry_exceptions cannot be used together"
-        end
-
-        unless options[:fatal_exceptions].is_a?(Array)
-          raise InvalidConfigurationError, "fatal_exceptions must be an array"
-        end
-
-        unless options[:fatal_exceptions].all? { |ex| ex.is_a?(Class) && ex <= Exception }
-          raise InvalidConfigurationError, "fatal_exceptions must be exceptions!"
-        end
-      end
-
-      # Retry exceptions must be an array of exceptions or `nil` to retry any exception
-      def validate_retry_exceptions!
-        return unless options[:retry_exceptions]
-
-        unless options[:fatal_exceptions].nil?
-          raise InvalidConfigurationError,
-                "retry_exceptions and fatal_exceptions cannot be used together"
-        end
-
-        unless options[:retry_exceptions].is_a?(Array)
-          raise InvalidConfigurationError, "retry_exceptions must be an array or nil"
-        end
-
-        unless options[:retry_exceptions].all? { |ex| ex.is_a?(Class) && ex <= Exception }
-          raise InvalidConfigurationError, "retry_exceptions must be exceptions!"
-        end
-      end
-    end
-  end
-end