lib/take2/configuration.rb in take2-0.1.1 vs lib/take2/configuration.rb in take2-1.0.0

@@ -6,32 +6,23 @@
   class Configuration
     CONFIG_ATTRS = [:retries,
                     :retriable,
                     :retry_proc,
                     :retry_condition_proc,
-                    :time_to_sleep,
-                    :backoff_setup,
                     :backoff_intervals].freeze
 
     attr_accessor(*CONFIG_ATTRS)
 
     def initialize(options = {})
       # Defaults
       @retries = 3
-      @retriable = [
-        Net::HTTPServerException,
-        Net::HTTPRetriableError,
-        Errno::ECONNRESET,
-        IOError,
-      ].freeze
+      @retriable = []
       @retry_proc = proc {}
       @retry_condition_proc = proc { false }
-      @time_to_sleep = 0 # TODO: Soft deprecate time to sleep
-      @backoff_setup = { type: :constant, start: 3 }
-      @backoff_intervals = Backoff.new(*@backoff_setup.values).intervals
-      # Overwriting the defaults
-      validate_options(options, &setter)
+      @backoff_intervals = Backoff.new(:constant, 3).intervals
+
+      merge_options!(options)
     end
 
     def to_hash
       CONFIG_ATTRS.each_with_object({}) do |key, hash|
         hash[key] = public_send(key)
@@ -40,40 +31,30 @@
 
     def [](value)
       public_send(value)
     end
 
-    def validate_options(options)
+    def merge_options!(options = {})
+      validate!(options).each do |key, value|
+        public_send("#{key}=", value)
+      end
+      self
+    end
+
+    def validate!(options)
       options.each do |k, v|
         raise ArgumentError, "#{k} is not a valid configuration" unless CONFIG_ATTRS.include?(k)
         case k
         when :retries
           raise ArgumentError, "#{k} must be positive integer" unless v.is_a?(Integer) && v.positive?
-        when :time_to_sleep
-          raise ArgumentError, "#{k} must be positive number" unless (v.is_a?(Integer) || v.is_a?(Float)) && v >= 0
         when :retriable
           raise ArgumentError, "#{k} must be array of retriable errors" unless v.is_a?(Array)
+        when :backoff_intervals
+          raise ArgumentError, "#{k} must be array of retriable errors" unless v.is_a?(Array)
+          raise ArgumentError, "#{k} size must be greater or equal to number of retries" unless v.size >= retries
         when :retry_proc, :retry_condition_proc
           raise ArgumentError, "#{k} must be Proc" unless v.is_a?(Proc)
-        when :backoff_setup
-          available_types = [:constant, :linear, :fibonacci, :exponential]
-          raise ArgumentError, 'Incorrect backoff type' unless available_types.include?(v[:type])
         end
-        yield(k, v) if block_given?
       end
-    end
-
-    def setter
-      ->(key, value) {
-        if key == :backoff_setup
-          assign_backoff_intervals(value)
-        else
-          public_send("#{key}=", value)
-        end
-      }
-    end
-
-    def assign_backoff_intervals(backoff_setup)
-      @backoff_intervals = Backoff.new(backoff_setup[:type], backoff_setup[:start]).intervals
     end
   end
 end