retryable 2.0.0 → 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e02743f5a92c56de8d631d1ce21a2bc1b18abacf
+  data.tar.gz: 236dafbf366171b840d64a1317ad14becf56c099
+SHA512:
+  metadata.gz: a9cbd76de408e65f6b6238de7082c017a2a05278f5f01c38cacc8088929f08ae4266c1c711a8290fb7255d87120fe83295d63cd7758f66ae7332b0cb35ec490a
+  data.tar.gz: 89fe460024058360678c483b41e75bc75442446c4698df5623bad47e09b0b5321b5370441595940ce8ef9446c772ed1f37523f55f5014c9a493efdd0da744bd0

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Retryable 2.0.1 ##
+
+*   Retryable can now be configured globally via Retryable.configure block.
+
 ## Retryable 2.0.0 ##
 
 *   Retryable can now be used without monkey patching Kernel module(use `Retryable.retryable` instead). Thanks @oppegard

data/README.md

@@ -58,6 +58,20 @@ end
 
     :tries => 2, :on => StandardError, :sleep => 1, :matching  => /.*/, :ensure => Proc.new { }, :exception_cb => Proc.new { }
 
+Retryable also could be configured globally to change those defaults:
+
+```
+Retryable.configure do |config|
+  config.ensure       = Proc.new {}
+  config.exception_cb = Proc.new {}
+  config.matching     = /.*/
+  config.on           = StandardError
+  config.sleep        = 1
+  config.tries        = 2
+end
+```
+
+
 Sleeping
 --------
 By default Retryable waits for one second between retries. You can change this and even provide your own exponential backoff scheme.
@@ -127,6 +141,7 @@ versions:
 * Ruby 1.9.3
 * Ruby 2.0.0
 * Ruby 2.1.2
+* Ruby 2.2.0
 
 If something doesn't work on one of these versions, it's a bug.
 

data/lib/retryable.rb

@@ -1,46 +1,93 @@
 require 'retryable/version'
-require 'retryable/config'
+require 'retryable/configuration'
 
 module Retryable
-  def self.retryable(options = {}, &block)
-    opts = {:tries => 2, :sleep => 1, :on => StandardError, :matching  => /.*/, :ensure => Proc.new {}, :exception_cb => Proc.new {}}
-    check_for_invalid_options(options, opts)
-    opts.merge!(options)
+  class << self
+    # A Retryable configuration object. Must act like a hash and return sensible
+    # values for all Retryable configuration options. See Retryable::Configuration.
+    attr_writer :configuration
 
-    return if opts[:tries] == 0
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Retryable.configure do |config|
+    #     config.ensure       = Proc.new {}
+    #     config.exception_cb = Proc.new {}
+    #     config.matching     = /.*/
+    #     config.on           = StandardError
+    #     config.sleep        = 1
+    #     config.tries        = 2
+    #   end
+    def configure
+      yield(configuration)
+    end
+
+    # The configuration object.
+    # @see Retryable.configure
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def enabled?
+      configuration.enabled?
+    end
+
+    def enable
+      configuration.enable
+    end
+
+    def disable
+      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
+      }
 
-    on_exception, tries = [ opts[:on] ].flatten, opts[:tries]
-    retries = 0
-    retry_exception = nil
+      check_for_invalid_options(options, opts)
+      opts.merge!(options)
 
-    begin
-      return yield retries, retry_exception
-    rescue *on_exception => exception
-      raise unless Retryable.enabled?
-      raise unless exception.message =~ opts[:matching]
-      raise if retries+1 >= tries
+      return if opts[:tries] == 0
+
+      on_exception, tries = [ opts[:on] ].flatten, opts[:tries]
+      retries = 0
+      retry_exception = nil
 
-      # Interrupt Exception could be raised while sleeping
       begin
-        Kernel.sleep opts[:sleep].respond_to?(:call) ? opts[:sleep].call(retries) : opts[:sleep]
-      rescue *on_exception
-      end
+        return yield retries, retry_exception
+      rescue *on_exception => exception
+        raise unless configuration.enabled?
+        raise unless exception.message =~ opts[:matching]
+        raise if retries+1 >= tries
 
-      retries += 1
-      retry_exception = exception
-      opts[:exception_cb].call(retry_exception)
-      retry
-    ensure
-      opts[:ensure].call(retries)
+        # Interrupt Exception could be raised while sleeping
+        begin
+          Kernel.sleep opts[:sleep].respond_to?(:call) ? opts[:sleep].call(retries) : opts[:sleep]
+        rescue *on_exception
+        end
+
+        retries += 1
+        retry_exception = exception
+        opts[:exception_cb].call(retry_exception)
+        retry
+      ensure
+        opts[:ensure].call(retries)
+      end
     end
-  end
 
-  private
+    private
 
-  def self.check_for_invalid_options(custom_options, default_options)
-    invalid_options = default_options.merge(custom_options).keys - default_options.keys
+    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?
+      raise ArgumentError.new("[Retryable] Invalid options: #{invalid_options.join(", ")}") unless invalid_options.empty?
+    end
   end
 end
 

data/lib/retryable/configuration.rb

@@ -0,0 +1,65 @@
+module Retryable
+  # Used to set up and modify settings for the retryable.
+  class Configuration
+    OPTIONS = [
+      :ensure,
+      :exception_cb,
+      :matching,
+      :on,
+      :sleep,
+      :tries
+    ].freeze
+
+    attr_accessor :ensure
+    attr_accessor :exception_cb
+    attr_accessor :matching
+    attr_accessor :on
+    attr_accessor :sleep
+    attr_accessor :tries
+
+    attr_accessor :enabled
+
+    alias_method :enabled?, :enabled
+
+    def initialize
+      @ensure       = Proc.new {}
+      @exception_cb = Proc.new {}
+      @matching     = /.*/
+      @on           = StandardError
+      @sleep        = 1
+      @tries        = 2
+
+      @enabled     = true
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+  end
+end

data/lib/retryable/version.rb

@@ -2,7 +2,7 @@ module Retryable
   class Version
     MAJOR = 2 unless defined? Retryable::Version::MAJOR
     MINOR = 0 unless defined? Retryable::Version::MINOR
-    PATCH = 0 unless defined? Retryable::Version::PATCH
+    PATCH = 1 unless defined? Retryable::Version::PATCH
 
     class << self
 

data/retryable.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/retryable/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.add_development_dependency 'bundler', '~> 1.0'
   gem.authors = ["Nikita Fedyashev", "Carlo Zottmann", "Chu Yeow"]
-  gem.description = %q{Kernel#retryable, allow for retrying of code blocks.}
+  gem.description = %q{Retryable#retryable, allow for retrying of code blocks.}
   gem.email = %q{loci.master@gmail.com}
   gem.files = %w(CHANGELOG.md LICENSE.md README.md Rakefile retryable.gemspec)
   gem.files += Dir.glob("lib/**/*.rb")

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe Retryable do
+  it 'is enabled by default' do
+    expect(Retryable).to be_enabled
+  end
+
+  it 'could be disabled' do
+    Retryable.disable
+    expect(Retryable).not_to be_enabled
+  end
+
+  context 'when disabled' do
+    before do
+      Retryable.disable
+    end
+
+    it 'could be re-enabled' do
+      Retryable.enable
+      expect(Retryable).to be_enabled
+    end
+  end
+
+  context 'when configured globally with custom sleep parameter' do
+    it 'passes retry count and exception on retry' do
+      expect(Kernel).to receive(:sleep).once.with(3)
+
+      Retryable.configure do |config|
+        config.sleep = 3
+      end
+
+      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
+  end
+end

data/spec/spec_helper.rb

@@ -4,6 +4,10 @@ require 'rspec'
 RSpec.configure do |config|
   config.disable_monkey_patching!
 
+  config.before(:each) do
+    reset_config
+  end
+
   def count_retryable(*opts)
     @try_count = 0
     return Retryable.retryable(*opts) do |*args|
@@ -11,4 +15,10 @@ RSpec.configure do |config|
       yield *args
     end
   end
+
+  private
+
+  def reset_config
+    Retryable.configuration = nil
+  end
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: retryable
 version: !ruby/object:Gem::Version
-  version: 2.0.0
-  prerelease: 
+  version: 2.0.1
 platform: ruby
 authors:
 - Nikita Fedyashev
@@ -11,25 +10,23 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-03 00:00:00.000000000 Z
+date: 2015-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: Kernel#retryable, allow for retrying of code blocks.
+description: Retryable#retryable, allow for retrying of code blocks.
 email: loci.master@gmail.com
 executables: []
 extensions: []
@@ -39,39 +36,38 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
-- retryable.gemspec
-- lib/retryable/config.rb
-- lib/retryable/version.rb
 - lib/retryable.rb
-- spec/lib/config_spec.rb
+- lib/retryable/configuration.rb
+- lib/retryable/version.rb
+- retryable.gemspec
+- spec/lib/configuration_spec.rb
 - spec/lib/retryable_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/nfedyashev/retryable
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
-summary: Kernel#retryable, allow for retrying of code blocks.
+specification_version: 4
+summary: Retryable#retryable, allow for retrying of code blocks.
 test_files:
-- spec/lib/config_spec.rb
+- spec/lib/configuration_spec.rb
 - spec/lib/retryable_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/retryable/config.rb

@@ -1,16 +0,0 @@
-module Retryable
-  @enabled = true
-  class << self; attr_accessor :enabled; end
-
-  def self.enable
-    @enabled = true
-  end
-
-  def self.disable
-    @enabled = false
-  end
-
-  def self.enabled?
-    !!@enabled
-  end
-end

data/spec/lib/config_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Retryable do
-  it 'is enabled by default' do
-    expect(Retryable).to be_enabled
-  end
-
-  it 'could be disabled' do
-    Retryable.disable
-    expect(Retryable).not_to be_enabled
-  end
-
-  context 'when disabled' do
-    before do
-      Retryable.disable
-    end
-
-    it 'could be re-enabled' do
-      Retryable.enable
-      expect(Retryable).to be_enabled
-    end
-  end
-end