retryable 2.0.4 → 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d2cf59f84731d2def08398714a4366b4b92d15eb
+  data.tar.gz: 391c2797ed522cc3a95c2d767335eb3bbb50a105
+SHA512:
+  metadata.gz: 7c5df44eb01cc472a8e4f1dc41469b02af8f062fa11290f4cf00481621cdd0e66e5caf93eeef46a2504d9e9fe858c3905d4d1ca479676785b99590668c4dc848
+  data.tar.gz: 3c60ad3b26e1af54e5c411d525d3edc271cfb2bf5302f67d2bdc043af649f519cc31d97c1374cdee188d1db7b83eef3db85a4e4b76bafe383b53c3d667240990

data/CHANGELOG.md

@@ -1,8 +1,18 @@
+## Retryable 3.0.0 ##
+NOTE: this version is backwards compatible with 2.0.4 version unless you're running it against Ruby 1.8 version.
+
+*   retryable can now also be configured via stored contexts.
+*   Ruby 1.8 support has been dropped.
+    
+    Thanks @chubchenko for refactoring and various improvements.
+
 ## Retryable 2.0.4 ##
 
 *   :infinite value is now available as :tries paramater.  Use it for retrying your blocks infinitely until it stops failing.
 *   :sleep_method parameter has been added. This can be very useful when you are working with Celluloid which implements its own version of the method sleep.
-    Use `:sleep_method => Celluloid.method(:sleep)` in such cases.
+    Use `:sleep_method: Celluloid.method(:sleep)` in such cases.
+    
+    Thanks @alexcastano
 
 ## Retryable 2.0.3 ##
 

data/Gemfile

@@ -0,0 +1,25 @@
+source 'http://rubygems.org'
+
+gem 'rake', '~> 10.4'
+gem 'yard'
+
+group :development do
+  gem 'fasterer'
+  gem 'overcommit'
+  gem 'pry', '= 0.9.12.6'
+  gem 'rubocop'
+  gem 'rubocop-rspec'
+end
+
+group :test do
+  gem 'codeclimate-test-reporter'
+  gem 'rspec', '~> 3.1'
+  gem 'simplecov', require: false
+end
+
+platforms :rbx do
+  gem 'racc'
+  gem 'rubysl', '~> 2.0'
+end
+
+gemspec

data/README.md

@@ -1,8 +1,12 @@
-retryable gem
-=====
+# Retryable
 
+[![Gem Version](https://badge.fury.io/rb/retryable.svg)](https://badge.fury.io/rb/retryable)
 [![Build Status](https://travis-ci.org/nfedyashev/retryable.png?branch=master)](https://travis-ci.org/nfedyashev/retryable)
 [![Dependency Status](https://www.versioneye.com/ruby/retryable/badge.svg)](https://www.versioneye.com/ruby/retryable)
+[![Code Climate](https://codeclimate.com/github/nfedyashev/retryable/badges/gpa.svg)](https://codeclimate.com/github/nfedyashev/retryable)
+[![Test Coverage](https://codeclimate.com/github/nfedyashev/retryable/badges/coverage.svg)](https://codeclimate.com/github/nfedyashev/retryable/coverage)
+
+[![Inline docs](http://inch-ci.org/github/nfedyashev/retryable.svg?branch=master)](http://inch-ci.org/github/nfedyashev/retryable)
 
 Description
 --------
@@ -16,6 +20,21 @@ runs the passed block. Should an exception occur, it'll retry for (n-1) times.
 Should the number of retries be reached without success, the last exception
 will be raised.
 
+Installation
+-------
+
+Install the gem:
+
+``` bash
+$ gem install retryable
+```
+
+Add it to your Gemfile:
+
+``` ruby
+gem 'retryable'
+```
+
 
 Examples
 --------
@@ -25,24 +44,24 @@ Open an URL, retry up to two times when an `OpenURI::HTTPError` occurs.
 ``` ruby
 require "open-uri"
 
-Retryable.retryable(:tries => 3, :on => OpenURI::HTTPError) do
+Retryable.retryable(tries: 3, on: OpenURI::HTTPError) do
   xml = open("http://example.com/test.xml").read
 end
 ```
 
 Try the block forever.
 ```ruby
-Retryable.retryable(:tries => :infinite) do
-  # some code
+Retryable.retryable(tries: :infinite) do
+  # code here
 end
 ```
 
-Do _something_, retry up to four times for either `ArgumentError` or
+Do something, retry up to four times for either `ArgumentError` or
 `TimeoutError` exceptions.
 
 ``` ruby
-Retryable.retryable(:tries => 5, :on => [ArgumentError, TimeoutError]) do
-  # some crazy code
+Retryable.retryable(tries: 5, on: [ArgumentError, TimeoutError]) do
+  # code here
 end
 ```
 
@@ -51,33 +70,42 @@ Ensure that block of code is executed, regardless of whether an exception was ra
 ``` ruby
 f = File.open("testfile")
 
-ensure_cb = Proc.new do |retries|
+ensure_cb = proc do |retries|
   puts "total retry attempts: #{retries}"
 
   f.close
 end
 
-Retryable.retryable(:ensure => ensure_cb) do
+Retryable.retryable(ensure: ensure_cb) do
   # process file
 end
 ```
 
 ## Defaults
 
-    :tries => 2, :on => StandardError, :sleep => 1, :matching  => /.*/, :ensure => Proc.new { }, :exception_cb => Proc.new { }, :not => [], :sleep_method => lambda { |n| Kernel.sleep(n) }
+    tries: 2,
+    on: StandardError,
+    sleep: 1,
+    matching : /.*/,
+    ensure: proc { },
+    exception_cb: proc { },
+    not: [],
+    sleep_method: lambda { |n| Kernel.sleep(n) },
+    contexts = {}
 
 Retryable also could be configured globally to change those defaults:
 
-```
+```ruby
 Retryable.configure do |config|
-  config.ensure       = Proc.new {}
-  config.exception_cb = Proc.new {}
+  config.ensure       = proc {}
+  config.exception_cb = proc {}
   config.matching     = /.*/
   config.on           = StandardError
   config.sleep        = 1
   config.tries        = 2
   config.not          = []
   config.sleep_method = Celluloid.method(:sleep)
+  config.contexts     = {}
 end
 ```
 
@@ -86,19 +114,19 @@ Sleeping
 --------
 By default Retryable waits for one second between retries. You can change this and even provide your own exponential backoff scheme.
 
-```
-Retryable.retryable(:sleep => 0) { }                     # don't pause at all between retries
-Retryable.retryable(:sleep => 10) { }                    # sleep ten seconds between retries
-Retryable.retryable(:sleep => lambda { |n| 4**n }) { }   # sleep 1, 4, 16, etc. each try
+```ruby
+Retryable.retryable(sleep: 0) { }                     # don't pause at all between retries
+Retryable.retryable(sleep: 10) { }                    # sleep ten seconds between retries
+Retryable.retryable(sleep: lambda { |n| 4**n }) { }   # sleep 1, 4, 16, etc. each try
 ```
 
 Matching error messages
 --------
 You can also retry based on the exception message:
 
-```
-Retryable.retryable(:matching => /IO timeout/) do |retries, exception|
-  raise "yo, IO timeout!" if retries == 0
+```ruby
+Retryable.retryable(matching: /IO timeout/) do |retries, exception|
+  raise "oops IO timeout!" if retries == 0
 end
 ```
 
@@ -106,31 +134,61 @@ Block Parameters
 --------
 Your block is called with two optional parameters: the number of tries until now, and the most recent exception.
 
-```
+```ruby
 Retryable.retryable do |retries, exception|
   puts "try #{retries} failed with exception: #{exception}" if retries > 0
-  pick_up_soap
+  # code here
 end
 ```
 
 Callback to run after an exception is rescued
 --------
 
-```
-exception_cb = Proc.new do |exception|
+```ruby
+exception_cb = proc do |exception|
   # http://smartinez87.github.io/exception_notification
-  ExceptionNotifier.notify_exception(exception, :data => {:message => "it failed"})
+  ExceptionNotifier.notify_exception(exception, data: {message: "it failed"})
 end
 
-Retryable.retryable(:exception_cb => exception_cb) do
-  # perform risky operation
+Retryable.retryable(exception_cb: exception_cb) do
+  # code here
 end
 ```
 
-You can temporary disable retryable blocks
+Contexts
 --------
 
+Contexts allow you to extract common `Retryable.retryable` calling options for reuse or readability purposes.
+
+```ruby
+Retryable.configure do |config|
+  config.contexts[:faulty_service] = {
+    :on: [FaultyServiceTimeoutError],
+    :sleep: 10,
+    :tries: 5
+  }
+end
+
+
+Retryable.with_context(:faulty_service) {
+  # code here
+}
+```
+
+You may also override options defined in your contexts:
+
+```ruby
+# :on & sleep defined in the context earlier are still effective
+Retryable.with_context(:faulty_service, tries: 999) {
+  # code here
+}
 ```
+
+
+You can temporary disable retryable blocks
+--------
+
+```ruby
 Retryable.enabled?
 => true
 
@@ -145,10 +203,10 @@ Specify exceptions where a retry should NOT be performed
 No more tries will be made if an exception listed in `:not` is raised.
 Takes precedence over `:on`.
 
-```
+```ruby
 class MyError < StandardError; end
 
-Retryable.retryable(:tries => 5, :on => [StandardError], :not => [MyError]) do
+Retryable.retryable(tries: 5, on: [StandardError], not: [MyError]) do
   raise MyError "No retries!"
 end
 
@@ -159,9 +217,9 @@ Specify the sleep method to use
 This can be very useful when you are working with [Celluloid](https://github.com/celluloid/celluloid)
 which implements its own version of the method sleep.
 
-```
-Retryable.retryable(:sleep_method => Celluloid.method(:sleep)) do
-  retrieve_url
+```ruby
+Retryable.retryable(sleep_method: Celluloid.method(:sleep)) do
+  # code here
 end
 ```
 
@@ -171,12 +229,15 @@ Supported Ruby Versions
 This library aims to support and is [tested against][travis] the following Ruby
 versions:
 
-* Ruby 1.8.7
-* Ruby 1.9.2
 * Ruby 1.9.3
 * Ruby 2.0.0
 * Ruby 2.1.2
 * Ruby 2.2.0
+* Ruby 2.3.1
+* Ruby 2.4.0
+* Ruby 2.5.0
+
+*NOTE: if you need `retryable` to be running on Ruby 1.8 use gem versions prior to 3.0.0 release*
 
 If something doesn't work on one of these versions, it's a bug.
 
@@ -185,27 +246,3 @@ however support will only be provided for the versions listed above.
 
 If you would like this library to support another Ruby version or
 implementation, you may volunteer to be a maintainer.
-
-
-Installation
--------
-
-Install the gem:
-
-``` bash
-$ gem install retryable
-```
-
-Add it to your Gemfile:
-
-``` ruby
-gem 'retryable'
-```
-
-## Thanks
-
-[Chu Yeow for this nifty piece of code](http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/)
-
-[Scott Bronson](https://github.com/bronson/retryable)
-
-[travis]: http://travis-ci.org/nfedyashev/retryable

data/Rakefile

@@ -4,8 +4,8 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task :test => :spec
-task :default => :spec
+task test: :spec
+task default: :spec
 
 require 'yard'
 YARD::Rake::YardocTask.new

data/lib/retryable.rb

@@ -11,13 +11,15 @@ module Retryable
     #
     # @example
     #   Retryable.configure do |config|
-    #     config.ensure       = Proc.new {}
-    #     config.exception_cb = Proc.new {}
+    #     config.contexts     = {}
+    #     config.ensure       = proc {}
+    #     config.exception_cb = proc {}
     #     config.matching     = /.*/
     #     config.on           = StandardError
     #     config.sleep        = 1
     #     config.tries        = 2
     #     config.not          = []
+    #     config.sleep_method = ->(seconds) { Kernel.sleep(seconds) }
     #   end
     def configure
       yield(configuration)
@@ -29,6 +31,15 @@ module Retryable
       @configuration ||= Configuration.new
     end
 
+    def with_context(context_key, options = {}, &block)
+      unless configuration.contexts.keys.include? context_key
+        raise ArgumentError, "#{context_key} not found in Retryable.configuration.contexts. Available contexts: #{configuration.contexts.keys}"
+      end
+      retryable(configuration.contexts[context_key].merge(options), &block) if block
+    end
+
+    alias retryable_with_context with_context
+
     def enabled?
       configuration.enabled?
     end
@@ -41,25 +52,16 @@ module Retryable
       configuration.disable
     end
 
-    def retryable(options = {}, &block)
-      opts = {
-        :tries        => self.configuration.tries,
-        :sleep        => self.configuration.sleep,
-        :on           => self.configuration.on,
-        :matching     => self.configuration.matching,
-        :ensure       => self.configuration.ensure,
-        :exception_cb => self.configuration.exception_cb,
-        :not          => self.configuration.not,
-        :sleep_method => self.configuration.sleep_method
-      }
+    def retryable(options = {})
+      opts = configuration.to_hash
 
       check_for_invalid_options(options, opts)
       opts.merge!(options)
 
       return if opts[:tries] == 0
 
-      on_exception = [ opts[:on] ].flatten
-      not_exception = [ opts[:not] ].flatten
+      on_exception = [opts[:on]].flatten
+      not_exception = [opts[:not]].flatten
       tries = opts[:tries]
       retries = 0
       retry_exception = nil
@@ -71,7 +73,7 @@ module Retryable
       rescue *on_exception => exception
         raise unless configuration.enabled?
         raise unless exception.message =~ opts[:matching]
-        raise if tries != :infinite && retries+1 >= tries
+        raise if tries != :infinite && retries + 1 >= tries
 
         # Interrupt Exception could be raised while sleeping
         begin
@@ -95,8 +97,8 @@ module Retryable
 
     def check_for_invalid_options(custom_options, default_options)
       invalid_options = default_options.merge(custom_options).keys - default_options.keys
-
-      raise ArgumentError.new("[Retryable] Invalid options: #{invalid_options.join(", ")}") unless invalid_options.empty?
+      return if invalid_options.empty?
+      raise ArgumentError, "[Retryable] Invalid options: #{invalid_options.join(', ')}"
     end
   end
 end

data/lib/retryable/configuration.rb

@@ -1,45 +1,39 @@
 module Retryable
   # Used to set up and modify settings for the retryable.
   class Configuration
-    OPTIONS = [
+    VALID_OPTION_KEYS = [
+      :contexts,
       :ensure,
       :exception_cb,
       :matching,
+      :not,
       :on,
       :sleep,
-      :tries,
-      :not,
-      :sleep_method
+      :sleep_method,
+      :tries
     ].freeze
 
-    attr_accessor :ensure
-    attr_accessor :exception_cb
-    attr_accessor :matching
-    attr_accessor :on
-    attr_accessor :sleep
-    attr_accessor :tries
-    attr_accessor :not
-    attr_accessor :sleep_method
+    attr_accessor(*VALID_OPTION_KEYS)
 
     attr_accessor :enabled
 
-    alias_method :enabled?, :enabled
-
     def initialize
-      @ensure       = Proc.new {}
-      @exception_cb = Proc.new {}
+      @contexts     = {}
+      @ensure       = proc {}
+      @exception_cb = proc {}
       @matching     = /.*/
       @on           = StandardError
       @sleep        = 1
       @tries        = 2
       @not          = []
-      @sleep_method = lambda do |seconds| Kernel.sleep(seconds) end
-      @enabled     = true
+      @sleep_method = ->(seconds) { Kernel.sleep(seconds) }
+      @enabled      = true
     end
 
     def enable
       @enabled = true
     end
+    alias enabled? enabled
 
     def disable
       @enabled = false
@@ -54,9 +48,8 @@ module Retryable
 
     # Returns a hash of all configurable options
     def to_hash
-      OPTIONS.inject({}) do |hash, option|
-        hash[option.to_sym] = self.send(option)
-        hash
+      VALID_OPTION_KEYS.each_with_object({}) do |key, memo|
+        memo[key] = instance_variable_get("@#{key}")
       end
     end
 

data/lib/retryable/version.rb

@@ -1,16 +1,40 @@
 module Retryable
-  class Version
-    MAJOR = 2 unless defined? Retryable::Version::MAJOR
-    MINOR = 0 unless defined? Retryable::Version::MINOR
-    PATCH = 4 unless defined? Retryable::Version::PATCH
+  # This module holds the Retryable version information.
+  module Version
+    module_function
 
-    class << self
+    # @return [Integer]
+    def major
+      3
+    end
+
+    # @return [Integer]
+    def minor
+      0
+    end
+
+    # @return [Integer]
+    def patch
+      0
+    end
+
+    # @return [Hash]
+    def to_h
+      {
+        major: major,
+        minor: minor,
+        patch: patch
+      }
+    end
 
-      # @return [String]
-      def to_s
-        [MAJOR, MINOR, PATCH].compact.join('.')
-      end
+    # @return [Hash]
+    def to_a
+      [major, minor, patch].compact
+    end
 
+    # @return [String]
+    def to_s
+      to_a.join('.')
     end
   end
 end

data/retryable.gemspec

@@ -1,20 +1,24 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/retryable/version', __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'retryable/version'
 
-Gem::Specification.new do |gem|
-  gem.add_development_dependency 'bundler', '~> 1.0'
-  gem.authors = ["Nikita Fedyashev", "Carlo Zottmann", "Chu Yeow"]
-  gem.description = %q{Retryable#retryable, allow for retrying of code blocks.}
-  gem.email = %q{nfedyashev@gmail.com}
-  gem.files = %w(CHANGELOG.md LICENSE.md README.md Rakefile retryable.gemspec)
-  gem.files += Dir.glob("lib/**/*.rb")
-  gem.files += Dir.glob("spec/**/*")
-  gem.homepage = %q{http://github.com/nfedyashev/retryable}
-  gem.name = 'retryable'
-  gem.license = 'MIT'
-  gem.require_paths = ["lib"]
-  gem.required_rubygems_version = '>= 1.3.6'
-  gem.summary = gem.description
-  gem.test_files = Dir.glob("spec/**/*")
-  gem.version = Retryable::Version
+Gem::Specification.new do |spec|
+  spec.name    = 'retryable'
+  spec.version = Retryable::Version
+  spec.authors = ['Nikita Fedyashev', 'Carlo Zottmann', 'Chu Yeow']
+  spec.email   = ['nfedyashev@gmail.com']
+
+  spec.summary     = 'Retrying code blocks in Ruby'
+  spec.description = spec.summary
+  spec.homepage    = 'http://github.com/nfedyashev/retryable'
+  spec.licenses    = ['MIT']
+
+  spec.require_paths = ['lib']
+  spec.files         = Dir['{config,lib,spec}/**/*', '*.md', '*.gemspec', 'Gemfile', 'Rakefile']
+  spec.test_files    = spec.files.grep(%r{^spec/})
+
+  spec.required_ruby_version     = Gem::Requirement.new('>= 1.9.3')
+  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
+
+  spec.add_development_dependency 'bundler', '~> 1.0'
 end

data/spec/{lib → retryable}/configuration_spec.rb

@@ -2,22 +2,22 @@ require 'spec_helper'
 
 RSpec.describe Retryable do
   it 'is enabled by default' do
-    expect(Retryable).to be_enabled
+    expect(described_class).to be_enabled
   end
 
   it 'could be disabled' do
-    Retryable.disable
-    expect(Retryable).not_to be_enabled
+    described_class.disable
+    expect(described_class).not_to be_enabled
   end
 
   context 'when disabled' do
     before do
-      Retryable.disable
+      described_class.disable
     end
 
     it 'could be re-enabled' do
-      Retryable.enable
-      expect(Retryable).to be_enabled
+      described_class.enable
+      expect(described_class).to be_enabled
     end
   end
 
@@ -25,15 +25,15 @@ RSpec.describe Retryable do
     it 'passes retry count and exception on retry' do
       expect(Kernel).to receive(:sleep).once.with(3)
 
-      Retryable.configure do |config|
+      described_class.configure do |config|
         config.sleep = 3
       end
 
-      count_retryable(:tries => 2) do |tries, ex|
+      counter(tries: 2) do |tries, ex|
         expect(ex.class).to eq(StandardError) if tries > 0
         raise StandardError if tries < 1
       end
-      expect(@try_count).to eq(2)
+      expect(counter.count).to eq(2)
     end
   end
 end

data/spec/retryable/version_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+RSpec.describe Retryable::Version do
+  before do
+    allow(described_class).to receive(:major).and_return(2)
+    allow(described_class).to receive(:minor).and_return(0)
+    allow(described_class).to receive(:patch).and_return(4)
+  end
+
+  describe '.to_h' do
+    it 'returns a hash with the right values' do
+      expect(described_class.to_h).to be_a Hash
+      expect(described_class.to_h[:major]).to eq(2)
+      expect(described_class.to_h[:minor]).to eq(0)
+      expect(described_class.to_h[:patch]).to eq(4)
+    end
+  end
+
+  describe '.to_a' do
+    it 'returns an array with the right values' do
+      expect(described_class.to_a).to be_an Array
+      expect(described_class.to_a).to eq([2, 0, 4])
+    end
+  end
+
+  describe '.to_s' do
+    it 'returns a string with the right value' do
+      expect(described_class.to_s).to be_a String
+      expect(described_class.to_s).to eq('2.0.4')
+    end
+  end
+end

data/spec/retryable_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'timeout'
+
+RSpec.describe Retryable do
+  describe '.retryable' do
+    before do
+      described_class.enable
+      @attempt = 0
+    end
+
+    it 'catch StandardError only by default' do
+      expect do
+        counter(tries: 2) { |tries| raise Exception if tries < 1 }
+      end.to raise_error Exception
+      expect(counter.count).to eq(1)
+    end
+
+    it 'retries on default exception' do
+      expect(Kernel).to receive(:sleep).once.with(1)
+
+      counter(tries: 2) { |tries| raise StandardError if tries < 1 }
+      expect(counter.count).to eq(2)
+    end
+
+    it 'does not retry if disabled' do
+      described_class.disable
+
+      expect do
+        counter(tries: 2) { raise }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'executes *ensure* clause' do
+      ensure_cb = proc do |retries|
+        expect(retries).to eq(0)
+      end
+
+      described_class.retryable(ensure: ensure_cb) {}
+    end
+
+    it 'passes retry count and exception on retry' do
+      expect(Kernel).to receive(:sleep).once.with(1)
+
+      counter(tries: 2) do |tries, ex|
+        expect(ex.class).to eq(StandardError) if tries > 0
+        raise StandardError if tries < 1
+      end
+      expect(counter.count).to eq(2)
+    end
+
+    it 'makes another try if exception is covered by :on' do
+      allow(Kernel).to receive(:sleep)
+      counter(on: [StandardError, ArgumentError, RuntimeError]) do |tries|
+        raise ArgumentError if tries < 1
+      end
+      expect(counter.count).to eq(2)
+    end
+
+    it 'does not try on unexpected exception' do
+      allow(Kernel).to receive(:sleep)
+      expect do
+        counter(on: RuntimeError) { |tries| raise StandardError if tries < 1 }
+      end.to raise_error StandardError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'retries three times' do
+      allow(Kernel).to receive(:sleep)
+      counter(tries: 3) { |tries| raise StandardError if tries < 2 }
+      expect(counter.count).to eq(3)
+    end
+
+    it 'retries infinitely' do
+      expect do
+        Timeout.timeout(3) do
+          counter(tries: :infinite, sleep: 0.1) { raise StandardError }
+        end
+      end.to raise_error Timeout::Error
+
+      expect(counter.count).to be > 10
+    end
+
+    it 'executes exponential backoff scheme for :sleep option' do
+      [1, 4, 16, 64].each { |i| expect(Kernel).to receive(:sleep).once.ordered.with(i) }
+      expect do
+        described_class.retryable(tries: 5, sleep: ->(n) { 4**n }) { raise RangeError }
+      end.to raise_error RangeError
+    end
+
+    it 'calls :sleep_method option' do
+      sleep_method = double
+      expect(sleep_method).to receive(:call).twice
+      expect do
+        described_class.retryable(tries: 3, sleep_method: sleep_method) { |tries| raise RangeError if tries < 9 }
+      end.to raise_error RangeError
+    end
+
+    it 'does not retry any exception if :on is empty list' do
+      expect do
+        counter(on: []) { raise }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'catches an exception that matches the regex' do
+      expect(Kernel).to receive(:sleep).once.with(1)
+      counter(matching: /IO timeout/) { |c, _e| raise 'yo, IO timeout!' if c == 0 }
+      expect(counter.count).to eq(2)
+    end
+
+    it 'does not catch an exception that does not match the regex' do
+      expect(Kernel).not_to receive(:sleep)
+      expect do
+        counter(matching: /TimeError/) { raise 'yo, IO timeout!' }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'does not allow invalid options' do
+      expect do
+        described_class.retryable(bad_option: 2) { raise 'this is bad' }
+      end.to raise_error ArgumentError, '[Retryable] Invalid options: bad_option'
+    end
+
+    it 'accepts a callback to run after an exception is rescued' do
+      expect do
+        described_class.retryable(sleep: 0, exception_cb: proc { |e| @raised = e.to_s }) do |tries|
+          raise StandardError, 'this is fun!' if tries < 1
+        end
+      end.not_to raise_error
+
+      expect(@raised).to eq('this is fun!')
+    end
+
+    it 'does not retry on :not exception' do
+      expect do
+        counter(not: RuntimeError) { |tries| raise RuntimeError if tries < 1 }
+      end.to raise_error RuntimeError
+      expect(counter.count).to eq(1)
+    end
+
+    it 'gives precidence for :not over :on' do
+      expect do
+        counter(sleep: 0, tries: 3, on: StandardError, not: IndexError) do |tries|
+          raise tries >= 1 ? IndexError : StandardError
+        end
+      end.to raise_error IndexError
+      expect(counter.count).to eq(2)
+    end
+  end
+end

data/spec/retryable_with_context_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+RSpec.describe Retryable do
+  describe '.with_context' do
+    before do
+      described_class.enable
+      @attempt = 0
+    end
+
+    it 'properly checks context configuration' do
+      expect do
+        described_class.with_context(:foo) {}
+      end.to raise_error ArgumentError, 'foo not found in Retryable.configuration.contexts. Available contexts: []'
+
+      expect do
+        described_class.retryable_with_context(:bar) {}
+      end.to raise_error ArgumentError, 'bar not found in Retryable.configuration.contexts. Available contexts: []'
+
+      expect do
+        described_class.configure do |config|
+          config.contexts[:faulty_service] = {
+            sleep: 3
+          }
+        end
+
+        described_class.retryable_with_context(:baz) {}
+      end.to raise_error ArgumentError, 'baz not found in Retryable.configuration.contexts. Available contexts: [:faulty_service]'
+    end
+
+    it 'properly fetches context options' do
+      allow(Kernel).to receive(:sleep)
+
+      described_class.configure do |config|
+        config.contexts[:faulty_service] = {
+          tries: 3
+        }
+      end
+
+      c = counter_with_context(:faulty_service) { |tries| raise StandardError if tries < 2 }
+      expect(c.count).to eq(3)
+    end
+
+    it 'properly overrides context options with local arguments' do
+      allow(Kernel).to receive(:sleep)
+
+      described_class.configure do |config|
+        config.contexts[:faulty_service] = {
+          tries: 1
+        }
+      end
+
+      c = counter_with_context(:faulty_service, tries: 3) { |tries| raise StandardError if tries < 2 }
+      expect(c.count).to eq(3)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,25 +1,16 @@
-require File.dirname(__FILE__) + '/../lib/retryable'
-require 'rspec'
-require 'pry'
+require 'retryable'
+require 'simplecov'
 
-RSpec.configure do |config|
-  config.disable_monkey_patching!
+Dir.glob(File.expand_path('../support/**/*.rb', __FILE__), &method(:require))
 
-  config.before(:each) do
-    reset_config
-  end
+SimpleCov.start
 
-  def count_retryable(*opts)
-    @try_count = 0
-    return Retryable.retryable(*opts) do |*args|
-      @try_count += 1
-      yield *args
-    end
-  end
+RSpec.configure do |config|
+  config.disable_monkey_patching!
 
-  private
+  config.include(Counter)
 
-  def reset_config
+  config.before do
     Retryable.configuration = nil
   end
 end

data/spec/support/counter.rb

@@ -0,0 +1,58 @@
+module Counter
+  class PlainGenerator
+    attr_reader :count
+
+    def initialize(options)
+      @options = options
+      @count = 0
+    end
+
+    def around
+      Retryable.retryable(@options) do |*arguments|
+        increment
+        yield(*arguments)
+      end
+    end
+
+    private
+
+    def increment
+      @count += 1
+    end
+  end
+
+  class GeneratorWithContext
+    attr_reader :count
+
+    def initialize(context_key, options)
+      @context_key = context_key
+      @count = 0
+      @options = options
+    end
+
+    def around
+      Retryable.with_context(@context_key, @options) do |*arguments|
+        increment
+        yield(*arguments)
+      end
+    end
+
+    private
+
+    def increment
+      @count += 1
+    end
+  end
+
+  def counter(options = {}, &block)
+    @counter ||= PlainGenerator.new(options)
+    @counter.around(&block) if block_given?
+    @counter
+  end
+
+  def counter_with_context(context_key, options = {}, &block)
+    @counter_with_context ||= GeneratorWithContext.new(context_key, options)
+    @counter_with_context.around(&block) if block_given?
+    @counter_with_context
+  end
+end

metadata

@@ -1,97 +1,81 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: retryable
-version: !ruby/object:Gem::Version 
-  hash: 7
-  prerelease: 
-  segments: 
-  - 2
-  - 0
-  - 4
-  version: 2.0.4
+version: !ruby/object:Gem::Version
+  version: 3.0.0
 platform: ruby
-authors: 
+authors:
 - Nikita Fedyashev
 - Carlo Zottmann
 - Chu Yeow
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2016-07-14 00:00:00 +03:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2018-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: bundler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :development
-  version_requirements: *id001
-description: Retryable#retryable, allow for retrying of code blocks.
-email: nfedyashev@gmail.com
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Retrying code blocks in Ruby
+email:
+- nfedyashev@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - CHANGELOG.md
+- Gemfile
 - LICENSE.md
 - README.md
 - Rakefile
-- retryable.gemspec
+- lib/retryable.rb
 - lib/retryable/configuration.rb
 - lib/retryable/version.rb
-- lib/retryable.rb
-- spec/lib/configuration_spec.rb
-- spec/lib/retryable_spec.rb
+- retryable.gemspec
+- spec/retryable/configuration_spec.rb
+- spec/retryable/version_spec.rb
+- spec/retryable_spec.rb
+- spec/retryable_with_context_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
+- spec/support/counter.rb
 homepage: http://github.com/nfedyashev/retryable
-licenses: 
+licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 23
-      segments: 
-      - 1
-      - 3
-      - 6
+    - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 2.4.5.2
 signing_key: 
-specification_version: 3
-summary: Retryable#retryable, allow for retrying of code blocks.
-test_files: 
-- spec/lib/configuration_spec.rb
-- spec/lib/retryable_spec.rb
+specification_version: 4
+summary: Retrying code blocks in Ruby
+test_files:
+- spec/retryable/configuration_spec.rb
+- spec/retryable/version_spec.rb
+- spec/retryable_spec.rb
+- spec/retryable_with_context_spec.rb
 - spec/spec_helper.rb
+- spec/support/counter.rb

data/spec/lib/retryable_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-require 'timeout'
-
-RSpec.describe 'Retryable.retryable' do
-  before(:each) do
-    Retryable.enable
-    @attempt = 0
-  end
-
-  it 'catch StandardError only by default' do
-    expect do
-      count_retryable(:tries => 2) { |tries, ex| raise Exception if tries < 1 }
-    end.to raise_error Exception
-    expect(@try_count).to eq(1)
-  end
-
-  it 'retries on default exception' do
-    expect(Kernel).to receive(:sleep).once.with(1)
-
-    count_retryable(:tries => 2) { |tries, ex| raise StandardError if tries < 1 }
-    expect(@try_count).to eq(2)
-  end
-
-  it 'does not retry if disabled' do
-    Retryable.disable
-
-    expect do
-      count_retryable(:tries => 2) { raise }
-    end.to raise_error RuntimeError
-    expect(@try_count).to eq(1)
-  end
-
-  it 'executes *ensure* clause' do
-    ensure_cb  = Proc.new do |retries|
-      expect(retries).to eq(0)
-    end
-
-    Retryable.retryable(:ensure => ensure_cb) { }
-  end
-
-  it 'passes retry count and exception on retry' do
-    expect(Kernel).to receive(:sleep).once.with(1)
-
-    count_retryable(:tries => 2) do |tries, ex|
-      expect(ex.class).to eq(StandardError) if tries > 0
-      raise StandardError if tries < 1
-    end
-    expect(@try_count).to eq(2)
-  end
-
-  it 'makes another try if exception is covered by :on' do
-    allow(Kernel).to receive(:sleep)
-    count_retryable(:on => [StandardError, ArgumentError, RuntimeError] ) { |tries, ex| raise ArgumentError if tries < 1 }
-    expect(@try_count).to eq(2)
-  end
-
-  it 'does not try on unexpected exception' do
-    allow(Kernel).to receive(:sleep)
-    expect do
-      count_retryable(:on => RuntimeError ) { |tries, ex| raise StandardError if tries < 1 }
-    end.to raise_error StandardError
-    expect(@try_count).to eq(1)
-  end
-
-  it 'retries three times' do
-    allow(Kernel).to receive(:sleep)
-    count_retryable(:tries => 3) { |tries, ex| raise StandardError if tries < 2 }
-    expect(@try_count).to eq(3)
-  end
-
-  it 'retries infinitely' do
-    expect do
-      Timeout::timeout(3) do
-        count_retryable(:tries => :infinite, :sleep => 0.1) { |tries, ex| raise StandardError }
-      end
-    end.to raise_error Timeout::Error
-
-    expect(@try_count).to be > 10
-  end
-
-  it 'retries on default exception' do
-    expect(Kernel).to receive(:sleep).once.with(1)
-
-    count_retryable(:tries => 2) { |tries, ex| raise StandardError if tries < 1 }
-    expect(@try_count).to eq(2)
-  end
-
-  it 'executes exponential backoff scheme for :sleep option' do
-    [1, 4, 16, 64].each { |i| expect(Kernel).to receive(:sleep).once.ordered.with(i) }
-    expect do
-      Retryable.retryable(:tries => 5, :sleep => lambda { |n| 4**n }) { raise RangeError }
-    end.to raise_error RangeError
-  end
-
-  it 'calls :sleep_method option' do
-    sleep_method = double
-    expect(sleep_method).to receive(:call).twice
-    expect do
-      Retryable.retryable(:tries => 3, :sleep_method => sleep_method) { |tries, ex| raise RangeError if tries < 9}
-    end.to raise_error RangeError
-  end
-
-  it 'does not retry any exception if :on is empty list' do
-    expect do
-      count_retryable(:on => []) { raise }
-    end.to raise_error RuntimeError
-    expect(@try_count).to eq(1)
-  end
-
-  it 'catches an exception that matches the regex' do
-    expect(Kernel).to receive(:sleep).once.with(1)
-    count_retryable(:matching => /IO timeout/) { |c,e| raise "yo, IO timeout!" if c == 0 }
-    expect(@try_count).to eq(2)
-  end
-
-  it 'does not catch an exception that does not match the regex' do
-    expect(Kernel).not_to receive(:sleep)
-    expect do
-      count_retryable(:matching => /TimeError/) { raise "yo, IO timeout!" }
-    end.to raise_error RuntimeError
-    expect(@try_count).to eq(1)
-  end
-
-  it 'does not allow invalid options' do
-    expect do
-      Retryable.retryable(:bad_option => 2) { raise "this is bad" }
-    end.to raise_error ArgumentError, '[Retryable] Invalid options: bad_option'
-  end
-
-  it 'accepts a callback to run after an exception is rescued' do
-    expect do
-      Retryable.retryable(:sleep => 0, :exception_cb => Proc.new {|e| @raised = e.to_s }) {|tries, ex| raise StandardError.new("this is fun!") if tries < 1 }
-    end.not_to raise_error
-
-    expect(@raised).to eq("this is fun!")
-  end
-
-  it 'does not retry on :not exception' do
-    expect do
-      count_retryable(:not => RuntimeError ) { |tries, ex| raise RuntimeError if tries < 1 }
-    end.to raise_error RuntimeError
-    expect(@try_count).to eq(1)
-  end
-
-  it 'gives precidence for :not over :on' do
-    expect do
-      count_retryable(:sleep => 0, :tries => 3, :on => StandardError, :not => IndexError ) { |tries, ex| raise tries >= 1 ? IndexError : StandardError }
-    end.to raise_error IndexError
-    expect(@try_count).to eq(2)
-  end
-end