retryable 1.3.6 → 2.0.0

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Retryable 2.0.0 ##
+
+*   Retryable can now be used without monkey patching Kernel module(use `Retryable.retryable` instead). Thanks @oppegard
+
 ## Retryable 1.3.6 ##
 
 *   Fixed warning: assigned but unused variable - tries. Thanks @amatsuda

data/README.md

@@ -24,7 +24,7 @@ Open an URL, retry up to two times when an `OpenURI::HTTPError` occurs.
 ``` ruby
 require "open-uri"
 
-retryable(:tries => 3, :on => OpenURI::HTTPError) do
+Retryable.retryable(:tries => 3, :on => OpenURI::HTTPError) do
   xml = open("http://example.com/test.xml").read
 end
 ```
@@ -33,7 +33,7 @@ Do _something_, retry up to four times for either `ArgumentError` or
 `TimeoutError` exceptions.
 
 ``` ruby
-retryable(:tries => 5, :on => [ArgumentError, TimeoutError]) do
+Retryable.retryable(:tries => 5, :on => [ArgumentError, TimeoutError]) do
   # some crazy code
 end
 ```
@@ -49,7 +49,7 @@ ensure_cb = Proc.new do |retries|
   f.close
 end
 
-retryable(:ensure => ensure_cb) do
+Retryable.retryable(:ensure => ensure_cb) do
   # process file
 end
 ```
@@ -63,9 +63,9 @@ Sleeping
 By default Retryable waits for one second between retries. You can change this and even provide your own exponential backoff scheme.
 
 ```
-retryable(:sleep => 0) { }                # don't pause at all between retries
-retryable(:sleep => 10) { }               # sleep ten seconds between retries
-retryable(:sleep => lambda { |n| 4**n }) { }   # sleep 1, 4, 16, etc. each try
+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
@@ -73,7 +73,7 @@ Matching error messages
 You can also retry based on the exception message:
 
 ```
-retryable(:matching => /IO timeout/) do |retries, exception|
+Retryable.retryable(:matching => /IO timeout/) do |retries, exception|
   raise "yo, IO timeout!" if retries == 0
 end
 ```
@@ -83,7 +83,7 @@ Block Parameters
 Your block is called with two optional parameters: the number of tries until now, and the most recent exception.
 
 ```
-retryable do |retries, exception|
+Retryable.retryable do |retries, exception|
   puts "try #{retries} failed with exception: #{exception}" if retries > 0
   pick_up_soap
 end
@@ -98,7 +98,7 @@ exception_cb = Proc.new do |exception|
   ExceptionNotifier.notify_exception(exception, :data => {:message => "it failed"})
 end
 
-retryable(:exception_cb => exception_cb) do
+Retryable.retryable(:exception_cb => exception_cb) do
   # perform risky operation
 end
 ```
@@ -126,7 +126,7 @@ versions:
 * Ruby 1.9.2
 * Ruby 1.9.3
 * Ruby 2.0.0
-* Ruby 2.1.0
+* Ruby 2.1.2
 
 If something doesn't work on one of these versions, it's a bug.
 

data/lib/retryable.rb

@@ -1,8 +1,8 @@
 require 'retryable/version'
 require 'retryable/config'
 
-module Kernel
-  def retryable(options = {}, &block)
+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)
@@ -22,7 +22,7 @@ module Kernel
 
       # Interrupt Exception could be raised while sleeping
       begin
-        sleep opts[:sleep].respond_to?(:call) ? opts[:sleep].call(retries) : opts[:sleep]
+        Kernel.sleep opts[:sleep].respond_to?(:call) ? opts[:sleep].call(retries) : opts[:sleep]
       rescue *on_exception
       end
 
@@ -37,7 +37,7 @@ module Kernel
 
   private
 
-  def check_for_invalid_options(custom_options, default_options)
+  def self.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?

data/lib/retryable/version.rb

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

data/spec/lib/config_spec.rb

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

data/spec/lib/retryable_spec.rb

@@ -1,118 +1,118 @@
 require 'spec_helper'
 
-describe 'Kernel.retryable' do
+RSpec.describe 'Retryable.retryable' do
   before(:each) do
     Retryable.enable
     @attempt = 0
   end
 
   it 'catch StandardError only by default' do
-    lambda do
+    expect do
       count_retryable(:tries => 2) { |tries, ex| raise Exception if tries < 1 }
-    end.should raise_error Exception
-    @try_count.should == 1
+    end.to raise_error Exception
+    expect(@try_count).to eq(1)
   end
 
   it 'retries on default exception' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
 
     count_retryable(:tries => 2) { |tries, ex| raise StandardError if tries < 1 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'does not retry if disabled' do
     Retryable.disable
 
-    lambda do
+    expect do
       count_retryable(:tries => 2) { raise }
-    end.should raise_error RuntimeError
-    @try_count.should == 1
+    end.to raise_error RuntimeError
+    expect(@try_count).to eq(1)
   end
 
   it 'executes *ensure* clause' do
     ensure_cb  = Proc.new do |retries|
-      retries.should == 0
+      expect(retries).to eq(0)
     end
 
-    Kernel.retryable(:ensure => ensure_cb) { }
+    Retryable.retryable(:ensure => ensure_cb) { }
   end
 
   it 'passes retry count and exception on retry' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
 
     count_retryable(:tries => 2) do |tries, ex|
-      ex.class.should == StandardError if tries > 0
+      expect(ex.class).to eq(StandardError) if tries > 0
       raise StandardError if tries < 1
     end
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'makes another try if exception is covered by :on' do
-    Kernel.stub(:sleep)
+    allow(Kernel).to receive(:sleep)
     count_retryable(:on => [StandardError, ArgumentError, RuntimeError] ) { |tries, ex| raise ArgumentError if tries < 1 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'does not try on unexpected exception' do
-    Kernel.stub(:sleep)
-    lambda do
+    allow(Kernel).to receive(:sleep)
+    expect do
       count_retryable(:on => RuntimeError ) { |tries, ex| raise StandardError if tries < 1 }
-    end.should raise_error StandardError
-    @try_count.should == 1
+    end.to raise_error StandardError
+    expect(@try_count).to eq(1)
   end
 
   it 'retries three times' do
-    Kernel.stub(:sleep)
+    allow(Kernel).to receive(:sleep)
     count_retryable(:tries => 3) { |tries, ex| raise StandardError if tries < 2 }
-    @try_count.should == 3
+    expect(@try_count).to eq(3)
   end
 
   it 'retries on default exception' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
 
     count_retryable(:tries => 2) { |tries, ex| raise StandardError if tries < 1 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'executes exponential backoff scheme for :sleep option' do
-    [1, 4, 16, 64].each { |i| Kernel.should_receive(:sleep).once.ordered.with(i) }
-    lambda do
-      Kernel.retryable(:tries => 5, :sleep => lambda { |n| 4**n }) { raise RangeError }
-    end.should raise_error RangeError
+    [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 'does not retry any exception if :on is empty list' do
-    lambda do
+    expect do
       count_retryable(:on => []) { raise }
-    end.should raise_error RuntimeError
-    @try_count.should == 1
+    end.to raise_error RuntimeError
+    expect(@try_count).to eq(1)
   end
 
   it 'catches an exception that matches the regex' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
     count_retryable(:matching => /IO timeout/) { |c,e| raise "yo, IO timeout!" if c == 0 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'does not catch an exception that does not match the regex' do
-    should_not_receive :sleep
-    lambda do
+    expect(Kernel).not_to receive(:sleep)
+    expect do
       count_retryable(:matching => /TimeError/) { raise "yo, IO timeout!" }
-    end.should raise_error RuntimeError
-    @try_count.should == 1
+    end.to raise_error RuntimeError
+    expect(@try_count).to eq(1)
   end
 
   it 'does not allow invalid options' do
-    lambda do
-      retryable(:bad_option => 2) { raise "this is bad" }
-    end.should raise_error ArgumentError, '[Retryable] Invalid options: bad_option'
+    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
-    lambda do
-      retryable(:sleep => 0, :exception_cb => Proc.new {|e| @raised = e.to_s }) {|tries, ex| raise StandardError.new("this is fun!") if tries < 1 }
-    end.should_not raise_error
+    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
 
-    @raised.should == "this is fun!"
+    expect(@raised).to eq("this is fun!")
   end
 end

data/spec/spec_helper.rb

@@ -2,13 +2,11 @@ require File.dirname(__FILE__) + '/../lib/retryable'
 require 'rspec'
 
 RSpec.configure do |config|
-  # Remove this line if you don't want RSpec's should and should_not
-  # methods or matchers
-  require 'rspec/expectations'
+  config.disable_monkey_patching!
 
   def count_retryable(*opts)
     @try_count = 0
-    return Kernel.retryable(*opts) do |*args|
+    return Retryable.retryable(*opts) do |*args|
       @try_count += 1
       yield *args
     end

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: retryable
 version: !ruby/object:Gem::Version
-  version: 1.3.6
+  version: 2.0.0
+  prerelease: 
 platform: ruby
 authors:
 - Nikita Fedyashev
@@ -10,11 +11,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-05 00:00:00.000000000 Z
+date: 2014-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,6 +24,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -36,40 +39,39 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
-- lib/retryable.rb
+- retryable.gemspec
 - lib/retryable/config.rb
 - lib/retryable/version.rb
-- retryable.gemspec
+- lib/retryable.rb
 - spec/lib/config_spec.rb
 - spec/lib/retryable_spec.rb
-- spec/lib/version_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: 2.4.1
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Kernel#retryable, allow for retrying of code blocks.
 test_files:
 - spec/lib/config_spec.rb
 - spec/lib/retryable_spec.rb
-- spec/lib/version_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: c055a594c5bd9ebeb455b8185e027ea0d2ce259c
-  data.tar.gz: 2cbbb09e5958d1f211810dbc762bfd962a102eaf
-SHA512:
-  metadata.gz: c1f320b8298024f48f24677e4538d6da832287a7f00269da165b41454a242e2777bc7978c84916148afaa50bf63936090ae315da8e151b9fe3d6ae60d7085229
-  data.tar.gz: f75b5c6bc559c0b5841a95d74914ac16fe24e399365aed35a3b9c7500c1c08d9a636def180e12f0773558252f1ddc371fcf5496f47e16301f300e00ebef904f2

data/spec/lib/version_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Retryable::Version do
-  subject { Retryable::Version.to_s }
-
-  it { should == '1.3.5' }
-end