take2 0.0.3 → 1.0.0

data/CHANGELOG.md

@@ -2,4 +2,13 @@
 #  
 * Add class validations for class helper methods
 * Add basic documentation
-* Rename the public api to :call_with_retry
+#
+0.0.2
+#
+* Add more tests
+#
+v0.0.3  
+* Fix configurations bug (#4)  
+* Ability to set custom configurations on method call (#1)  
+* More tests (#3)  
+* Update docs and badges  

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,21 +1,28 @@
 PATH
   remote: .
   specs:
-    take2 (0.0.3)
+    take2 (1.0.0)
 
 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)
-    rake (12.3.1)
+    rainbow (3.0.0)
+    rake (13.0.1)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 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.17.3

data/README.md

@@ -3,9 +3,9 @@
 ![Gem](https://img.shields.io/gem/dt/take2.svg)
 ![GitHub last commit](https://img.shields.io/github/last-commit/restaurant-cheetah/take2.svg)
 ![Gem](https://img.shields.io/gem/v/take2.svg)  
-Define rules for retrying behavior.  
-Yield block of code into the public api of the take2.  
-Things getting take two :)
+1. Define rules for retrying behavior.  
+2. Yield block of code into the with_retry method.  
+3. Things getting take two :)
 
 ## Install
 
@@ -15,59 +15,57 @@ gem install take2
 ## Examples
 
 ```ruby
-class KratosService
+class Service
   include Take2
 
-  
   number_of_retries 3
-  
+
   # Could be configured globally or on class level.
-  retriable_errors Net::HTTPRetriableError, Net::HTTPServerError
+  retriable_errors Net::HTTPRetriableError, Errno::ECONNRESET
 
   # Retry unless the response status is 5xx. The implementation is dependent of the http lib in use.
   retriable_condition proc { |error| error.response.code < 500 }
 
   # Defines callable code to run before next retry. Could be an out put to some logger.
-  on_retry proc { |error, tries| puts "#{self.name} - Retrying.. #{tries} of #{self.retriable_configuration[:retries]} (#{error})" }
-       
-  sleep_before_retry 3.3
-
-  def call_boy
-    call_api_with_retry do
-      # Some logic that might raise..
-      # If it will raise retriable, magic happens.
-      # If not the original error re raised
-
-      raise Net::HTTPRetriableError.new 'Release the Kraken...many times!!', nil
+  on_retry proc { |error, tries| puts "#{name} - Retrying.. #{tries} of #{retriable_configuration[:retries]} (#{error})" }
+
+  # The available strategies are:
+  # type :constant, start: 2 => [2, 2, 2, 2 ... ]
+  # type :linear, start: 3, factor: 2 => [3, 6, 12, 24 ... ]
+  # type :fibonacci, start: 2 => [2, 3, 5, 8, 13 ... ]
+  # type :exponential, start: 3 => [3, 7, 12, 28, 47 ... ]
+  backoff_strategy type: :fibonacci, start: 3
+
+  class << self
+    def call
+      with_retry do
+        # Some logic that might raise..
+        # If it will raise retriable, magic happens.
+        # If not the original error re raised
+
+        raise Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil)
+      end
     end
-  end
 
-  # Pass custom options per method call
-  # The class defaults will not be overwritten
-  def kill_baldur
-    call_api_with_retry(retries: 2, retriable: [IOError], retry_proc: proc {}, retry_condition_proc: proc {}, time_to_sleep: 1.11) do
-      # Some logic that might raise..
+    # Pass custom options per method call
+    # The class defaults will not be overwritten
+    def read(file)
+      with_retry(retries: 2, retriable: [IOError], retry_proc: proc {}, retry_condition_proc: proc {}) do
+        # Some logic that might raise..
+      end
     end
   end
-
 end  
 
-KratosService.new.call_boy
+Service.call
 #=> KratosService - Retrying.. 3 of 3 (Release the Kraken...many times!!)
 #=> KratosService - Retrying.. 2 of 3 (Release the Kraken...many times!!)
 #=> KratosService - Retrying.. 1 of 3 (Release the Kraken...many times!!)
 # After the retrying is done, original error re-raised  
 #=> Net::HTTPRetriableError: Release the Kraken...many times!!
 
-# Not wrapping with method
-KratosService.new.call_api_with_retry { 1 / 0 }
-
-# Or..
-Class.new { include Take2 }.new.call_api_with_retry { 1 / 0 }
-
-
 # Current configuration hash
-KratosService.retriable_configuration
+Service.retriable_configuration
 
 ```
 
@@ -80,14 +78,12 @@ KratosService.retriable_configuration
 Take2.configure do |config|
   config.retries    = 3
   config.retriable  = [
-      Net::HTTPServerError,
-      Net::HTTPServerException,
       Net::HTTPRetriableError,      
       Errno::ECONNRESET,
       IOError
   ].freeze
-  config.retry_condition_proc = proc {false}
-  config.time_to_sleep        = nil
-  config.retry_proc           = proc {Rails.logger.info "Retry message"}
+  config.retry_condition_proc = proc { false }
+  config.retry_proc           = proc { Rails.logger.info "Retry message" }
+  config.backoff_intervals    = Take2::Backoff.new(:linear, 1).intervals
 end
 ```

data/lib/take2.rb

@@ -1,38 +1,40 @@
-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
-    @configuration ||= Configuration.new
-  end
+    def config
+      @configuration ||= Configuration.new
+    end
 
-  def self.reset(options = {})
-    @configuration = Configuration.new(options)
-  end
+    def reset(options = {})
+      @configuration = Configuration.new(options)
+    end
 
-  def self.local_defaults(options)
-    configuration.validate_options(options)
-  end
+    def local_defaults(options)
+      configuration.validate!(options)
+    end
 
-  def self.configure
-    yield(configuration) if block_given?
+    def configure
+      if block_given?
+        yield(config)
+        config.validate!(config.to_hash)
+      end
+    end
   end
 
   module InstanceMethods
-
     # Yields a block and retries on retriable errors n times.
     # The raised error could be the defined retriable or it child.
     #
@@ -41,13 +43,15 @@ module Take2
     #     include Take2
     #
     #     number_of_retries 3
-    #     retriable_errors Net::HTTPRetriableError, Net::HTTPServerError
+    #     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
+    #       with_retry do
     #         # Some logic that might raise..
     #         # If it will raise retriable, magic happens.
     #         # If not the original error re raised
@@ -55,28 +59,35 @@ module Take2
     #     end
     #
     #   end
-    def call_api_with_retry(options = {})        
-      config = self.class.retriable_configuration
-      config.merge! Take2.local_defaults(options) unless options.empty?
+    def call_api_with_retry(options = {}, &block)
+      self.class.call_api_with_retry(options, &block)
+    end
+
+    alias_method :with_retry, :call_api_with_retry
+  end
+
+  module ClassMethods
+    def call_api_with_retry(options = {})
+      config = retriable_configuration
+      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
-    
-  end
 
-  module ClassMethods
+    alias_method :with_retry, :call_api_with_retry
+
     # Sets number of retries.
     #
     # Example:
@@ -99,13 +110,14 @@ module Take2
     #     retriable_errors Net::HTTPRetriableError, Errno::ECONNRESET
     #   end
     # Arguments:
-    #   errors: List of retiable errors
+    #   errors: List of retriable 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 descendants'
+      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 +132,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 +146,19 @@ module Take2
       self.retry_proc = proc
     end
 
-    # Sets number of seconds to sleep before next retry.
+    # 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
@@ -160,17 +173,23 @@ module Take2
     attr_accessor(*Take2::Configuration::CONFIG_ATTRS)
 
     def set_defaults
-      config = Take2.configuration.to_hash
-      Take2::Configuration::CONFIG_ATTRS.each do |attr|
-        instance_variable_set("@#{attr}", config[attr])
+      Take2.config.to_hash.each do |k, v|
+        instance_variable_set("@#{k}", v)
       end
     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
+    def rest(config, tries)
+      seconds = next_interval(config[:backoff_intervals], config[:retries], tries)
+      sleep(seconds)
+    end
 
-end
+    def next_interval(intervals, retries, current)
+      intervals[retries - current]
+    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