take2 0.0.4 → 0.0.5

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "http://rubygems.org"
 gemspec
 
@@ -10,4 +12,5 @@ end
 group :development, :test do
   gem 'pry'
   gem 'pry-nav'
-end
+  gem 'rubocop'
+end

data/Gemfile.lock

@@ -1,20 +1,27 @@
 PATH
   remote: .
   specs:
-    take2 (0.0.3)
+    take2 (0.0.5)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    ast (2.4.0)
     coderay (1.1.2)
     diff-lcs (1.3)
+    jaro_winkler (1.5.2)
     method_source (0.8.2)
+    parallel (1.12.1)
+    parser (2.5.3.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
     pry (0.10.4)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
     pry-nav (0.2.4)
       pry (>= 0.9.10, < 0.11.0)
+    rainbow (3.0.0)
     rake (12.3.1)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
@@ -29,7 +36,17 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.0)
+    rubocop (0.62.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    ruby-progressbar (1.10.0)
     slop (3.6.0)
+    unicode-display_width (1.4.1)
 
 PLATFORMS
   ruby
@@ -39,7 +56,8 @@ DEPENDENCIES
   pry-nav
   rake
   rspec (= 3.8.0)
+  rubocop
   take2!
 
 BUNDLED WITH
-   1.16.4
+   1.16.6

data/lib/take2.rb

@@ -1,21 +1,21 @@
-require 'net/http'
+# frozen_string_literal: true
 
+require 'net/http'
 require 'take2/version'
 require 'take2/configuration'
 
 module Take2
-
   def self.included(base)
-    base.extend ClassMethods
-    base.send :set_defaults
-    base.send :include, InstanceMethods
+    base.extend(ClassMethods)
+    base.send(:set_defaults)
+    base.send(:include, InstanceMethods)
   end
 
   class << self
     attr_accessor :configuration
   end
 
-  def self.configuration
+  def self.config
     @configuration ||= Configuration.new
   end
 
@@ -28,11 +28,10 @@ module Take2
   end
 
   def self.configure
-    yield(configuration) if block_given?
+    yield(config) if block_given?
   end
 
   module InstanceMethods
-
     # Yields a block and retries on retriable errors n times.
     # The raised error could be the defined retriable or it child.
     #
@@ -43,8 +42,10 @@ module Take2
     #     number_of_retries 3
     #     retriable_errors Net::HTTPRetriableError
     #     retriable_condition proc { |error| response_status(error.response) < 500 }
-    #     on_retry proc { |error, tries| puts "#{self.name} - Retrying.. #{tries} of #{self.retriable_configuration[:retries]} (#{error})" }    
-    #     sleep_before_retry 3
+    #     on_retry proc { |error, tries|
+    #       puts "#{self.name} - Retrying.. #{tries} of #{self.retriable_configuration[:retries]} (#{error})"
+    #     }
+    #     backoff_strategy type: :exponential, start: 3
     #
     #     def give_me_food
     #       call_api_with_retry do
@@ -55,25 +56,40 @@ module Take2
     #     end
     #
     #   end
-    def call_api_with_retry(options = {})        
+    def call_api_with_retry(options = {})
       config = self.class.retriable_configuration
-      config.merge! Take2.local_defaults(options) unless options.empty?
+      config.merge!(Take2.local_defaults(options)) unless options.empty?
       tries ||= config[:retries]
       begin
         yield
       rescue => e
-        if config[:retriable].map {|klass| e.class <= klass }.any?
+        if config[:retriable].map { |klass| e.class <= klass }.any?
           unless tries.zero? || config[:retry_condition_proc]&.call(e)
             config[:retry_proc]&.call(e, tries)
-            sleep(config[:time_to_sleep]) if config[:time_to_sleep]
+            rest(config, tries)
             tries -= 1
             retry
           end
-        end        
+        end
         raise e
       end
     end
-    
+    alias_method :with_retry, :call_api_with_retry
+
+    private
+
+    def rest(config, tries)
+      seconds = if config[:time_to_sleep].to_f > 0
+        config[:time_to_sleep].to_f
+      else
+        next_interval(config[:backoff_intervals], config[:retries], tries)
+      end
+      sleep(seconds)
+    end
+
+    def next_interval(intervals, retries, current)
+      intervals[retries - current]
+    end
   end
 
   module ClassMethods
@@ -101,11 +117,12 @@ module Take2
     # Arguments:
     #   errors: List of retiable errors
     def retriable_errors(*errors)
-      raise ArgumentError, 'All retriable errors must be StandardError decendants' unless errors.all? { |e| e <= StandardError }
+      message = 'All retriable errors must be StandardError decendants'
+      raise ArgumentError, message unless errors.all? { |e| e <= StandardError }
       self.retriable = errors
     end
 
-    # Sets condition for retry attempt. 
+    # Sets condition for retry attempt.
     # If set, it MUST result to +false+ with number left retries greater that zero in order to retry.
     #
     # Example:
@@ -120,7 +137,7 @@ module Take2
       self.retry_condition_proc = proc
     end
 
-    # Defines a proc that is called *before* retry attempt. 
+    # Defines a proc that is called *before* retry attempt.
     #
     # Example:
     #   class PizzaService
@@ -134,18 +151,28 @@ module Take2
       self.retry_proc = proc
     end
 
-    # Sets number of seconds to sleep before next retry.
+    def sleep_before_retry(seconds)
+      unless (seconds.is_a?(Integer) || seconds.is_a?(Float)) && seconds.positive?
+        raise ArgumentError, 'Must be positive numer'
+      end
+      puts "DEPRECATION MESSAGE - The sleep_before_retry method is softly deprecated in favor of backoff_stategy \r
+       where the time to sleep is a starting point on the backoff intervals. Please implement it instead."
+      self.time_to_sleep = seconds
+    end
+
+    # Sets the backoff strategy
     #
     # Example:
     #   class PizzaService
     #     include Take2
-    #     sleep_before_retry 1.5
+    #     backoff_strategy type: :exponential, start: 3
     #   end
     # Arguments:
-    #   seconds: number
-    def sleep_before_retry(seconds)
-      raise ArgumentError, 'Must be positive numer' unless (seconds.is_a?(Integer) || seconds.is_a?(Float)) && seconds.positive?
-      self.time_to_sleep = seconds
+    #   hash: object
+    def backoff_strategy(options)
+      available_types = [:constant, :linear, :fibonacci, :exponential]
+      raise ArgumentError, 'Incorrect backoff type' unless available_types.include?(options[:type])
+      self.backoff_intervals = Backoff.new(options[:type], options[:start]).intervals
     end
 
     # Exposes current class configuration
@@ -167,10 +194,8 @@ module Take2
     end
 
     def response_status(response)
-      return response.status if response.respond_to? :status
-      response.status_code if response.respond_to? :status_code
+      return response.status if response.respond_to?(:status)
+      response.status_code if response.respond_to?(:status_code)
     end
-
   end
-
-end
+end

data/lib/take2/backoff.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Take2
+  class Backoff
+    attr_reader :type, :start, :retries, :factor, :intervals
+
+    def initialize(type, start = 1, factor = 1, retries = 10)
+      @type = type
+      @start = start.to_i
+      @retries = retries
+      @factor = factor
+      @intervals = intervals_table
+    end
+
+    private
+
+    def intervals_table
+      send(type)
+    end
+
+    def constant
+      Array.new(retries, start)
+    end
+
+    def linear
+      (start...(retries + start)).map { |i| i * factor }
+    end
+
+    def fibonacci
+      (1..20).map { |i| fibo(i) }.partition { |x| x >= start }.first.take(retries)
+    end
+
+    def exponential
+      (1..20).each_with_index.inject([]) do |memo, (el, ix)|
+        memo << if ix == 0
+          start
+        else
+          (2**el - 1) + rand(1..2**el)
+        end
+      end.take(retries)
+    end
+
+    def fibo(n, memo = {})
+      return n if n < 2
+      memo[n] ||= fibo(n - 1, memo) + fibo(n - 2, memo)
+    end
+  end
+end

data/lib/take2/configuration.rb

@@ -1,6 +1,17 @@
+# frozen_string_literal: true
+
+require 'take2/backoff'
+
 module Take2
   class Configuration
-    CONFIG_ATTRS = [:retries, :retriable, :retry_proc, :retry_condition_proc, :time_to_sleep].freeze
+    CONFIG_ATTRS = [:retries,
+                    :retriable,
+                    :retry_proc,
+                    :retry_condition_proc,
+                    :time_to_sleep,
+                    :backoff_setup,
+                    :backoff_intervals].freeze
+
     attr_accessor(*CONFIG_ATTRS)
 
     def initialize(options = {})
@@ -8,13 +19,15 @@ module Take2
       @retries = 3
       @retriable = [
         Net::HTTPServerException,
-        Net::HTTPRetriableError,        
+        Net::HTTPRetriableError,
         Errno::ECONNRESET,
         IOError,
-       ].freeze
+      ].freeze
       @retry_proc = proc {}
       @retry_condition_proc = proc { false }
-      @time_to_sleep = 3
+      @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)
     end
@@ -26,29 +39,41 @@ module Take2
     end
 
     def [](value)
-      self.public_send(value)
+      public_send(value)
     end
 
-    def validate_options(options, &setter)
+    def validate_options(options)
       options.each do |k, v|
-        raise ArgumentError, "#{k} is not a valid configuration"  unless CONFIG_ATTRS.include?(k)
+        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 :retry_proc, :retry_condition_proc
-            raise ArgumentError, "#{k} must be Proc" unless v.is_a?(Proc)
+        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 :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
-        setter.call(k, v) if block_given?
-      end  
+        yield(k, v) if block_given?
+      end
     end
 
     def setter
-      proc { |key, value| instance_variable_set(:"@#{key}", value) }
+      ->(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
+end

data/lib/take2/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Take2
-  VERSION = "0.0.4"
-end
+  VERSION = "0.0.5"
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rspec'
 require 'take2'
-require 'pry'
+require 'pry'

data/spec/take2/configuration_spec.rb

@@ -1,124 +1,114 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-RSpec.describe Take2::Configuration do
+require 'spec_helper'
 
+RSpec.describe(Take2::Configuration) do
   describe 'default configurations' do
-
     let(:default) { described_class.new }
 
     it 'has correct default value for retries' do
-      expect(default.retries).to eql 3
+      expect(default.retries).to(eql(3))
     end
 
     it 'has correct default retriable errors array' do
-      expect(default.retriable).to eql [      
+      expect(default.retriable).to(eql([
         Net::HTTPServerException,
-        Net::HTTPRetriableError,        
+        Net::HTTPRetriableError,
         Errno::ECONNRESET,
         IOError,
-       ].freeze
+      ].freeze))
     end
 
     it 'has default proc for retry_proc' do
       p = proc {}
-      expect(default.retry_proc.call).to eql p.call
+      expect(default.retry_proc.call).to(eql(p.call))
     end
 
     it 'has default proc for retry_condition_proc' do
-      p = proc {false}
-      expect(default.retry_condition_proc.call).to eql p.call
+      p = proc { false }
+      expect(default.retry_condition_proc.call).to(eql(p.call))
     end
 
     it 'has correct default value for time_to_sleep' do
-      expect(default.time_to_sleep).to eql 3
+      expect(default.time_to_sleep).to(eql(0))
     end
 
+    it 'has correct default value for backoff_intervals' do
+      expect(default.backoff_intervals).to eql Array.new(10, 3)
+    end
   end
 
   describe 'overwriting the default configurations' do
-
     context 'with valid hash' do
-
-      let!(:new_configs_hash) { 
+      let!(:new_configs_hash) do
         {
           retries: 2,
           retriable: [Net::HTTPRetriableError],
           retry_condition_proc: proc { true },
-          retry_proc: proc { 2*2 },
-          time_to_sleep: 0
+          retry_proc: proc { 2 * 2 },
+          time_to_sleep: 0,
+          backoff_setup: { type: :linear, start: 3 }
         }
-      }
+      end
 
       let!(:new_configuration) { described_class.new(new_configs_hash).to_hash }
 
       [:retries, :retriable, :retry_proc, :retry_condition_proc, :time_to_sleep].each do |key|
         it "sets the #{key} key" do
           if new_configs_hash[key].respond_to?(:call)
-            expect(new_configuration[key].call).to eql new_configs_hash[key].call
-          else  
-            expect(new_configuration[key]).to eql new_configs_hash[key]
+            expect(new_configuration[key].call).to(eql(new_configs_hash[key].call))
+          else
+            expect(new_configuration[key]).to(eql(new_configs_hash[key]))
           end
         end
       end
 
+      it 'sets the backoff_intervals correctly' do
+        expect(new_configuration[:backoff_intervals])
+          .to eql(Take2::Backoff.new(
+            new_configs_hash[:backoff_setup][:type],
+            new_configs_hash[:backoff_setup][:start]
+          ).intervals)
+      end
     end
 
     context 'with invalid hash' do
-
       context 'when retries set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(retries: -1) }.to raise_error ArgumentError
-          expect { described_class.new(retries: 0) }.to raise_error ArgumentError
-
+          expect { described_class.new(retries: -1) }.to(raise_error(ArgumentError))
+          expect { described_class.new(retries: 0) }.to(raise_error(ArgumentError))
         end
-
       end
 
       context 'when time_to_sleep set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(time_to_sleep: -1) }.to raise_error ArgumentError
-          
+          expect { described_class.new(time_to_sleep: -1) }.to(raise_error(ArgumentError))
         end
-
       end
 
       context 'when retriable set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(retriable: StandardError) }.to raise_error ArgumentError
-          
+          expect { described_class.new(retriable: StandardError) }.to(raise_error(ArgumentError))
         end
-
       end
 
       context 'when retry_proc set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(retry_proc: {}) }.to raise_error ArgumentError
-          
+          expect { described_class.new(retry_proc: {}) }.to(raise_error(ArgumentError))
         end
-
       end
 
       context 'when retry_condition_proc set to invalid value' do
-
         it 'raises ArgumentError' do
-
-          expect { described_class.new(retry_condition_proc: {}) }.to raise_error ArgumentError
-          
+          expect { described_class.new(retry_condition_proc: {}) }.to(raise_error(ArgumentError))
         end
+      end
 
+      context 'when backoff_setup has incorrect type' do
+        it 'raises ArgumentError' do
+          expect { described_class.new(backoff_setup: { type: :log }) }.to(raise_error(ArgumentError))
+        end
       end
-      
     end
-
   end
-
-
-end
+end