take2 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad4dbf81975a5cc73474e2423a154804f890402129dc86bd3a84f33d3bb7014e
-  data.tar.gz: 5db4c75eb7b03d975a6f4fcd36f92995107737e487cfa9e0ebc0b4c35683dbe9
+  metadata.gz: 1cb318b781932656dc817f9129c5621b55b99dc377968ffb0931f6ba3c044ab5
+  data.tar.gz: 28e00524af5f1ba059445018d47bffb0216b7517949d4ad8ed61da951db3be6f
 SHA512:
-  metadata.gz: 318ddd7bc40de226b01e17d7f54106f34e41b63317ec14bd146c9df2a2cca003341c34c93929771bd13caf92d82759f9abb9d92e1d151df758877bf34eff5e01
-  data.tar.gz: c50474f5331470bf1ac546507a6fd13c36f70f97fe0a7e98554c73c7cc94ab18861566d1998190fa517ea8ab7d3418244c16de1a014486522fdd7f4667f68890
+  metadata.gz: b9c3335fd97336deb6e7f1b0e82cf040779dbec24bb81b20b1b8bff5422e3c3612abdc49eb5c8b09e609d3e8a17941c64fdb5c4dfd417d7ebb7cec4a3a9d4ca4
+  data.tar.gz: 03aea65024971befd1c0e1db2e8d2a1dae3d9bf8ad82f87017d8c75b0461246cc5e366ef33e90dae1f4201b97b673e1acdbec8212ead4d64428104e3b6d72cf4

data/.gitignore

@@ -48,3 +48,6 @@ build-iPhoneSimulator/
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+.idea
+.ruby-gemset
+.ruby-version

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    take2 (0.1.1)
+    take2 (1.0.0)
 
 GEM
   remote: http://rubygems.org/
@@ -22,7 +22,7 @@ GEM
     pry-nav (0.2.4)
       pry (>= 0.9.10, < 0.11.0)
     rainbow (3.0.0)
-    rake (12.3.1)
+    rake (13.0.1)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
@@ -60,4 +60,4 @@ DEPENDENCIES
   take2!
 
 BUNDLED WITH
-   1.16.6
+   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,64 +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::HTTPServerException
+  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})" }
-       
-  # The available strategies are: 
+  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 ... ]    
+  # type :exponential, start: 3 => [3, 7, 12, 28, 47 ... ]
   backoff_strategy type: :fibonacci, start: 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
+  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
+        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 {}) 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
 
 ```
 
@@ -84,15 +77,13 @@ KratosService.retriable_configuration
 
 Take2.configure do |config|
   config.retries    = 3
-  config.retriable  = [      
-      Net::HTTPServerException,
+  config.retriable  = [
       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

@@ -23,11 +23,14 @@ module Take2
     end
 
     def local_defaults(options)
-      configuration.validate_options(options)
+      configuration.validate!(options)
     end
 
     def configure
-      yield(config) if block_given?
+      if block_given?
+        yield(config)
+        config.validate!(config.to_hash)
+      end
     end
   end
 
@@ -48,7 +51,7 @@ module Take2
     #     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
@@ -107,9 +110,9 @@ module Take2
     #     retriable_errors Net::HTTPRetriableError, Errno::ECONNRESET
     #   end
     # Arguments:
-    #   errors: List of retiable errors
+    #   errors: List of retriable errors
     def retriable_errors(*errors)
-      message = 'All retriable errors must be StandardError decendants'
+      message = 'All retriable errors must be StandardError descendants'
       raise ArgumentError, message unless errors.all? { |e| e <= StandardError }
       self.retriable = errors
     end
@@ -143,15 +146,6 @@ module Take2
       self.retry_proc = proc
     end
 
-    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:
@@ -179,9 +173,8 @@ 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
 
@@ -191,11 +184,7 @@ module Take2
     end
 
     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
+      seconds = next_interval(config[:backoff_intervals], config[:retries], tries)
       sleep(seconds)
     end
 

data/lib/take2/configuration.rb

@@ -8,8 +8,6 @@ module Take2
                     :retriable,
                     :retry_proc,
                     :retry_condition_proc,
-                    :time_to_sleep,
-                    :backoff_setup,
                     :backoff_intervals].freeze
 
     attr_accessor(*CONFIG_ATTRS)
@@ -17,19 +15,12 @@ module Take2
     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
@@ -42,38 +33,28 @@ module Take2
       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

data/lib/take2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Take2
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/spec/take2/configuration_spec.rb

@@ -11,12 +11,7 @@ RSpec.describe(Take2::Configuration) do
     end
 
     it 'has correct default retriable errors array' do
-      expect(default.retriable).to(eql([
-        Net::HTTPServerException,
-        Net::HTTPRetriableError,
-        Errno::ECONNRESET,
-        IOError,
-      ].freeze))
+      expect(default.retriable).to(eql([]))
     end
 
     it 'has default proc for retry_proc' do
@@ -29,10 +24,6 @@ RSpec.describe(Take2::Configuration) do
       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(0))
-    end
-
     it 'has correct default value for backoff_intervals' do
       expect(default.backoff_intervals).to eql Array.new(10, 3)
     end
@@ -46,14 +37,13 @@ RSpec.describe(Take2::Configuration) do
           retriable: [Net::HTTPRetriableError],
           retry_condition_proc: proc { true },
           retry_proc: proc { 2 * 2 },
-          time_to_sleep: 0,
-          backoff_setup: { type: :linear, start: 3 }
+          backoff_intervals: [1, 2, 3, 4, 5]
         }
       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|
+      [:retries, :retriable, :retry_proc, :retry_condition_proc, :backoff_intervals].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))
@@ -62,14 +52,6 @@ RSpec.describe(Take2::Configuration) do
           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
@@ -80,12 +62,6 @@ RSpec.describe(Take2::Configuration) do
         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))
-        end
-      end
-
       context 'when retriable set to invalid value' do
         it 'raises ArgumentError' do
           expect { described_class.new(retriable: StandardError) }.to(raise_error(ArgumentError))
@@ -104,9 +80,15 @@ RSpec.describe(Take2::Configuration) do
         end
       end
 
-      context 'when backoff_setup has incorrect type' do
+      context 'when backoff_intervals has incorrect type' do
+        it 'raises ArgumentError' do
+          expect { described_class.new(backoff_intervals: 1) }.to(raise_error(ArgumentError))
+        end
+      end
+
+      context 'when backoff_intervals size smaller then number of retries' do
         it 'raises ArgumentError' do
-          expect { described_class.new(backoff_setup: { type: :log }) }.to(raise_error(ArgumentError))
+          expect { described_class.new(backoff_intervals: [1]) }.to(raise_error(ArgumentError))
         end
       end
     end

data/spec/take2_spec.rb

@@ -6,10 +6,9 @@ RSpec.describe(Take2) do
   let!(:config) do
     Take2.configure do |c|
       c.retries               = 1
-      c.retriable             = [Net::HTTPServerException, Net::HTTPRetriableError].freeze
+      c.retriable             = [Errno::ECONNRESET, Net::HTTPRetriableError].freeze
       c.retry_condition_proc  = proc { false }
       c.retry_proc            = proc {}
-      c.time_to_sleep         = 0
       c.backoff_intervals     = Take2::Backoff.new(:linear, 1).intervals
     end
   end
@@ -35,10 +34,6 @@ RSpec.describe(Take2) do
       expect(subject[:retry_proc].call).to(eql(described_class.configuration[:retry_proc].call))
     end
 
-    it 'has a default value for :time_to_sleep' do
-      expect(subject[:time_to_sleep]).to(eql(described_class.configuration[:time_to_sleep]))
-    end
-
     it 'has a default value for :backoff_intervals' do
       expect(subject[:backoff_intervals]).to eql((1..10).to_a)
     end
@@ -111,21 +106,6 @@ RSpec.describe(Take2) do
       end
     end
 
-    describe '.sleep_before_retry' do
-      context 'with valid argument' do
-        it 'sets the :sleep_before_retry attribute' do
-          klass.sleep_before_retry(3.5)
-          expect(subject[:time_to_sleep]).to(eql(3.5))
-        end
-      end
-
-      context 'with invalid argument' do
-        it 'raises ArgumentError' do
-          expect { klass.sleep_before_retry(-1) }.to(raise_error(ArgumentError))
-        end
-      end
-    end
-
     describe '.backoff_setup' do
       context 'with valid arguments' do
         it 'sets the backoff_intervals' do
@@ -154,12 +134,14 @@ RSpec.describe(Take2) do
     describe 'class method' do
       let(:retriable_error) {  Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
       before(:each) { @tries = 0 }
+
       it 'responds to the method' do
         expect(klass).to respond_to(:call_api_with_retry)
         expect(klass).to respond_to(:with_retry)
         expect(klass.method(:with_retry).original_name).to eq(klass.method(:call_api_with_retry).original_name)
         expect(klass.method(:with_retry).source_location).to eq(klass.method(:call_api_with_retry).source_location)
       end
+
       it 'retries correct number of times' do
         expect do
           klass.call_api_with_retry { wrath_the_gods_with retriable_error }
@@ -168,6 +150,7 @@ RSpec.describe(Take2) do
         nil
       end
     end
+
     describe 'instance method' do
       it 'responds to the method' do
         expect(object).to respond_to(:call_api_with_retry)
@@ -175,6 +158,7 @@ RSpec.describe(Take2) do
         expect(object.method(:with_retry).original_name).to eq(object.method(:call_api_with_retry).original_name)
         expect(object.method(:with_retry).source_location).to eq(object.method(:call_api_with_retry).source_location)
       end
+
       context 'when raised with non retriable error' do
         let(:error) { StandardError.new('Release the Kraken!!') }
 

data/take2.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.email       = ["evnomadx@gmail.com"]
   s.homepage    = "https://github.com/restaurant-cheetah/take2"
   s.summary     = "Provides Take2 for your APIs calls"
-  s.description = "Retry API calls, methods or blocks of code. Define take2 retry behavior or use defaults and you good to go."
+  s.description = "Retry failed API calls, methods or blocks of code. Define take2 retry behavior on a class or method level and you good to go."
   s.post_install_message = "Getting Take2 is dead easy!"
 
   all_files = %x(git ls-files).split("\n")

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: take2
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Anton Magids
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-21 00:00:00.000000000 Z
+date: 2020-08-14 00:00:00.000000000 Z
 dependencies: []
-description: Retry API calls, methods or blocks of code. Define take2 retry behavior
-  or use defaults and you good to go.
+description: Retry failed API calls, methods or blocks of code. Define take2 retry
+  behavior on a class or method level and you good to go.
 email:
 - evnomadx@gmail.com
 executables: []
@@ -57,8 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Provides Take2 for your APIs calls