take2 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acfd63c354cf04ae963d43d3aac5674c09e14812be5a8641369aca9531b482ea
-  data.tar.gz: ddf1dc96cb20c3fd9cc7296a0dbda95bbc45e276d0d0dbdda7f84b072342ee58
+  metadata.gz: f2b9d1165c2bbc7d0e0e59b161ef35e9d72586f8498738312bf72ebf5e5b2f31
+  data.tar.gz: 1b4d00168ff6b2cdc14be86fcf65b05e0ff919ca4e61535e76cdd3fac0006680
 SHA512:
-  metadata.gz: 589514e2648a9ebac2c687e6fa160134c7b0a68c2bca6bccfc59def42ee94496aa8b348fc5436cfb23fada557aab3947391819a9e71ee930bbee44d16783debb
-  data.tar.gz: a839b2e092071f2b8113c263aab9b840c86e9f60c33129d2026d1a8a5a3c08e7d4d379ac22efe2517292a5a9f9ad61cfe2b397941db87ad011c63c6fc818b7e3
+  metadata.gz: 8f01b351dd0a3640fd09d7fe00b515543bbbfaf9ec1abb60bbf2b962e20b32490edb06cab51b81ee65383864e90f92e54533639a1bed1eaae1ed24afe599e378
+  data.tar.gz: 853ffe970c1c08306ff42966d7946ed92445e7d6b999801eeedf9ff2eae4f0ef12e321ff9ab75a2ce22d9514af5797d497c9f090dfee4aa4be7e7a7809911e64

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    take2 (0.0.5)
+    take2 (0.1.0)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -30,7 +30,12 @@ class KratosService
   # 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
+  # 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
 
   def call_boy
     call_api_with_retry do
@@ -45,7 +50,7 @@ class KratosService
   # 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
+    call_api_with_retry(retries: 2, retriable: [IOError], retry_proc: proc {}, retry_condition_proc: proc {}) do
       # Some logic that might raise..
     end
   end
@@ -88,5 +93,6 @@ Take2.configure do |config|
   config.retry_condition_proc = proc {false}
   config.time_to_sleep        = nil
   config.retry_proc           = proc {Rails.logger.info "Retry message"}
+  config.backoff_intervals    = Take2::Backoff.new(:linear, 1).intervals
 end
 ```

data/lib/take2.rb

@@ -13,22 +13,22 @@ module Take2
 
   class << self
     attr_accessor :configuration
-  end
 
-  def self.config
-    @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(options)
+    end
 
-  def self.configure
-    yield(config) if block_given?
+    def configure
+      yield(config) if block_given?
+    end
   end
 
   module InstanceMethods
@@ -56,8 +56,16 @@ module Take2
     #     end
     #
     #   end
+    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 = self.class.retriable_configuration
+      config = retriable_configuration
       config.merge!(Take2.local_defaults(options)) unless options.empty?
       tries ||= config[:retries]
       begin
@@ -74,25 +82,7 @@ module Take2
         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
     # Sets number of retries.
     #
     # Example:
@@ -197,5 +187,18 @@ module Take2
       return response.status if response.respond_to?(:status)
       response.status_code if response.respond_to?(:status_code)
     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
+      sleep(seconds)
+    end
+
+    def next_interval(intervals, retries, current)
+      intervals[retries - current]
+    end
   end
 end

data/lib/take2/version.rb

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

data/spec/take2_spec.rb

@@ -151,132 +151,130 @@ RSpec.describe(Take2) do
       raise error
     end
 
-    context 'when raised with non retriable error' do
-      let(:error) { StandardError.new('Release the Kraken!!') }
-
+    describe 'class method' do
+      let(:retriable_error) {  Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
       before(:each) { @tries = 0 }
-
-      it 're raises the original error' do
-        expect do
-          object.call_api_with_retry { wrath_the_gods_with error }
-        end.to(raise_error(error.class))
+      it 'responds to the method' do
+        expect(klass).to respond_to(:call_api_with_retry)
       end
-
-      it 'is not retried' do
+      it 'retries correct number of times' do
         expect do
-          object.call_api_with_retry { wrath_the_gods_with error }
-        end.to(change { @tries }.from(0).to(1))
+          klass.call_api_with_retry { wrath_the_gods_with retriable_error }
+        end.to(change { @tries }.from(0).to(klass.retriable_configuration[:retries] + 1))
       rescue
         nil
       end
     end
+    describe 'instance method' do
+      context 'when raised with non retriable error' do
+        let(:error) { StandardError.new('Release the Kraken!!') }
 
-    context 'when raised with retriable error' do
-      let(:retriable_error) {  Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
-
-      before(:each) { @tries = 0 }
+        before(:each) { @tries = 0 }
 
-      it 'retries correct number of times' do
-        expect do
-          object.call_api_with_retry { wrath_the_gods_with retriable_error }
-        end.to(change { @tries }.from(0).to(klass.retriable_configuration[:retries] + 1))
-      rescue
-        nil
-      end
+        it 're raises the original error' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with error }
+          end.to(raise_error(error.class))
+        end
 
-      it 'calls the retry proc' do
-        expect(klass.retriable_configuration[:retry_proc])
-          .to(receive(:call)
-          .exactly(klass.retriable_configuration[:retries]))
-        begin
-          object.call_api_with_retry { wrath_the_gods_with retriable_error }
+        it 'is not retried' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with error }
+          end.to(change { @tries }.from(0).to(1))
         rescue
           nil
         end
       end
 
-      it 'calls the retry_condition proc' do
-        expect(klass.retriable_configuration[:retry_condition_proc])
-          .to(receive(:call)
-          .exactly(klass.retriable_configuration[:retries]))
-        begin
-          object.call_api_with_retry { wrath_the_gods_with retriable_error }
+      context 'when raised with retriable error' do
+        let(:retriable_error) {  Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
+
+        before(:each) { @tries = 0 }
+
+        it 'retries correct number of times' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          end.to(change { @tries }.from(0).to(klass.retriable_configuration[:retries] + 1))
         rescue
           nil
         end
-      end
 
-      # it 'sleeps the correct amount of time' do
-      #   allow_any_instance_of(Object).to(receive(:sleep).with(klass.retriable_configuration[:time_to_sleep]))
-      #   begin
-      #     object.call_api_with_retry { wrath_the_gods_with retriable_error }
-      #   rescue
-      #     nil
-      #   end
-      # end
+        it 'calls the retry proc' do
+          expect(klass.retriable_configuration[:retry_proc])
+            .to(receive(:call)
+            .exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
+        end
 
-      it 're raises the original error' do
-        expect do
-          object.call_api_with_retry { wrath_the_gods_with retriable_error }
-        end.to(raise_error(retriable_error.class))
-      end
-    end
+        it 'calls the retry_condition proc' do
+          expect(klass.retriable_configuration[:retry_condition_proc])
+            .to(receive(:call)
+            .exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
+        end
 
-    context 'with custom options' do
-      let(:retriable_error)     { Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
-      let(:new_retriable_error) { IOError.new('You shall not PASS!') }
+        it 're raises the original error' do
+          expect do
+            object.call_api_with_retry { wrath_the_gods_with retriable_error }
+          end.to(raise_error(retriable_error.class))
+        end
+      end
 
-      before(:each) { @tries = 0 }
+      context 'with custom options' do
+        let(:retriable_error)     { Net::HTTPRetriableError.new('Release the Kraken...many times!!', nil) }
+        let(:new_retriable_error) { IOError.new('You shall not PASS!') }
 
-      it 'overwrites the :retries' do
-        expect do
-          object.call_api_with_retry(retries: 3) { wrath_the_gods_with retriable_error }
-        end.to(change { @tries }.from(0).to(4))
-      rescue
-        nil
-      end
+        before(:each) { @tries = 0 }
 
-      it 'overwrites the :retry_proc' do
-        new_proc = proc { 1**1 }
-        expect(new_proc).to(receive(:call).exactly(klass.retriable_configuration[:retries]))
-        begin
-          object.call_api_with_retry(retry_proc: new_proc) { wrath_the_gods_with retriable_error }
+        it 'overwrites the :retries' do
+          expect do
+            object.call_api_with_retry(retries: 3) { wrath_the_gods_with retriable_error }
+          end.to(change { @tries }.from(0).to(4))
         rescue
           nil
         end
-      end
 
-      it 'overwrites the :retry_condition_proc' do
-        new_proc = proc { true }
-        expect(new_proc).to(receive(:call).exactly(klass.retriable_configuration[:retries]))
-        begin
-          object.call_api_with_retry(retry_condition_proc: new_proc) { wrath_the_gods_with retriable_error }
-        rescue
-          nil
+        it 'overwrites the :retry_proc' do
+          new_proc = proc { 1**1 }
+          expect(new_proc).to(receive(:call).exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry(retry_proc: new_proc) { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
         end
-      end
 
-      # it 'overwrites the :time_to_sleep' do
-      #   allow_any_instance_of(Object).to(receive(:sleep).with(1.66))
-      #   begin
-      #     object.call_api_with_retry(time_to_sleep: 1.66) { wrath_the_gods_with retriable_error }
-      #   rescue
-      #     nil
-      #   end
-      # end
+        it 'overwrites the :retry_condition_proc' do
+          new_proc = proc { true }
+          expect(new_proc).to(receive(:call).exactly(klass.retriable_configuration[:retries]))
+          begin
+            object.call_api_with_retry(retry_condition_proc: new_proc) { wrath_the_gods_with retriable_error }
+          rescue
+            nil
+          end
+        end
 
-      it 'overwrites the :retriable' do
-        expect do
-          object.call_api_with_retry(retriable: [new_retriable_error]) { wrath_the_gods_with retriable_error }
-        end.to(change { @tries }.from(0).to(1))
-      rescue
-        nil
-      end
+        it 'overwrites the :retriable' do
+          expect do
+            object.call_api_with_retry(retriable: [new_retriable_error]) { wrath_the_gods_with retriable_error }
+          end.to(change { @tries }.from(0).to(1))
+        rescue
+          nil
+        end
 
-      it 'raises ArgumentError if there are invalid keys' do
-        expect do
-          object.call_api_with_retry(invalid_key: :nope) { wrath_the_gods_with retriable_error }
-        end.to(raise_error(ArgumentError))
+        it 'raises ArgumentError if there are invalid keys' do
+          expect do
+            object.call_api_with_retry(invalid_key: :nope) { wrath_the_gods_with retriable_error }
+          end.to(raise_error(ArgumentError))
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: take2
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Anton Magids
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-09 00:00:00.000000000 Z
+date: 2019-07-28 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.
@@ -58,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: Provides Take2 for your APIs calls