retry_upto 1.1 → 1.2

data/README.md

@@ -1,12 +1,18 @@
 # retry_upto: retry with steroids
 
 If you need to use `retry` in ruby, you probably want to retry some code only a **maximum number of times**,
-and sometimes **wait a bit** between the attempts to avoid external resources hiccups or usage limits.
+and sometimes **wait an interval of time** between the attempts to avoid external resources hiccups or usage limits.
 
 Therefore **Your Important Code** ends surrounded by counters, conditions and calls to `sleep`.
 
 This gem deals elegantly with this common scenario:
 
+    retry_upto(5) do
+      # Your Important Code
+    end
+
+Under Ruby 1.9 it also allows:
+
     5.times.retry do
       # Your Important Code
     end
@@ -21,28 +27,18 @@ Retries up to 5 times catching any exception, doesn't wait between attempts:
 
     retry_upto(5)
 
-### Waiting time between attempts
+### Time intervals between attempts
 
-Retries up to 5 times, waits 2 seconds between attempts:
+For fixed intervals, an `:interval` parameter can be passed indicating the time in seconds.
+The following example will sleep two seconds between attempts:
 
     retry_upto(5, :interval => 2)
 
-### Varying waiting time between attempts
-
-Retries up to 5 times, waits 1 second after the first attempt and increases
-the time between the following attempts (2, 4, 8, ...):
-
-    retry_upto(5, :interval => 1, :growth => 2)
+For customized intervals, the `:interval` parameter can be a lambda, which will be applied
+to the number of each attempt. For instance, the following code will sleep 3 seconds after
+the first attempt, 6 after the second, 9 after the third...
 
-Retries up to 5 times, waits 1 second after the first attempt and decreases
-the time between the following attempts (0.5, 0.25, 0.125, ...):
-
-    retry_upto(5, :interval => 1, :growth => 0.5)
-
-Retries up to 5 times, waits 1 second after the first attempt and increases
-randomly the time between the following attempts:
-
-    retry_upto(5, :interval => 1, :growth => lambda{ |x| x + rand(3) } )
+    retry_upto(5, :interval => lambda{ |attempt| attempt * 3 })
 
 ### Retrying only when certain Exceptions get raised
 
@@ -50,6 +46,10 @@ Retries up to 5 times only after a ZeroDivisionError, raising any other Exceptio
 
     retry_upto(5, :rescue => ZeroDivisionError)
 
+Retries up to 5 times only after a ZeroDivisionError or a NameError, raising any other Exception:
+
+    retry_upto(5, :rescue => [ZeroDivisionError, NameError])
+
 All the options described above can be combined together.
 
 ### More sugar!
@@ -58,7 +58,7 @@ In ruby 1.9, the `Enumerator` class gets enhanced to use `retry_upto` this way:
 
     5.times.retry
 
-And yes, this accepts the same options:
+This syntax accepts the same options:
 
     5.times.retry(:interval => 10)
 
@@ -68,7 +68,7 @@ See the LICENSE file included in the distribution.
 
 ## Authors
 
-This gem was born from gists by Raul Murciano, Glenn Gillen, Pedro Belo, Jaime Iniesta, Lleïr Borras and ideas taken from Aitor García Rey.
+This gem was born from gists by Raul Murciano, Glenn Gillen, Pedro Belo, Jaime Iniesta, Lleïr Borras and ideas taken from Aitor García Rey and Jim Remsik.
 
 Yes, so many brain cells and so few lines of code. Great, isn't it?
 

data/lib/retry_upto.rb

@@ -1,20 +1,19 @@
 # See README.md for usage explanations
 
-def retry_upto(max_retries = 1, options = {})
+def retry_upto(max_retries = 1, opts = {})
   yield
-rescue *(options[:rescue] || Exception)
-  raise if (max_retries -= 1) == 0
-  sleep(options[:interval] || 0)
-  if options[:growth].respond_to?('*')
-    options[:interval] = options[:interval] * options[:growth]
-  elsif options[:growth].respond_to?(:call)
-    options[:interval] = options[:growth].call(options[:interval])
+rescue *(opts[:rescue] || Exception)
+  attempt = attempt ? attempt+1 : 1
+  raise if (attempt == max_retries)
+  if interval = opts[:interval]
+    secs = interval.respond_to?(:call) ? interval.call(attempt) : interval
+    sleep(secs)
   end
   retry
 end
 
 class Enumerator
-  def retry(options = {}, &blk)
-    retry_upto(self.count, options, &blk)
+  def retry(opts = {}, &blk)
+    retry_upto(self.count, opts, &blk)
   end
 end

data/test/retry_upto_test.rb

@@ -1,6 +1,6 @@
 require './test/test_helper'
 
-class Retry_uptoTest < MiniTest::Unit::TestCase
+class RetryUptoTest < MiniTest::Unit::TestCase
 
   class FooError < Exception; end
   class BarError < Exception; end
@@ -12,16 +12,16 @@ class Retry_uptoTest < MiniTest::Unit::TestCase
       @bars = 0
     end
 
-    # raises FooError only in the two first calls
+    # raises FooError only in the 3 first calls
     def foo!
       @foos += 1
-      raise FooError if @foos < 3
+      raise FooError if @foos < 4
     end
 
-    # raises BarError only in the two first calls
+    # raises BarError only in the 3 first calls
     def bar!
       @bars += 1
-      raise BarError if @bars < 3
+      raise BarError if @bars < 4
     end
   end
 
@@ -39,69 +39,62 @@ class Retry_uptoTest < MiniTest::Unit::TestCase
   end
 
   def test_retries_the_desired_number_of_attempts
-    retry_upto(3){ @target.foo! }
-    assert_equal 3, @target.foos
+    retry_upto(4){ @target.foo! }
+    assert_equal 4, @target.foos
   end
 
   # interval between attempts
 
   def test_there_is_no_interval_between_attempts_by_default
-    self.expects(:sleep).times(2).with(0).returns(nil)
-    retry_upto(3){ @target.foo! }
+    self.expects(:sleep).never
+    retry_upto(4){ @target.foo! }
   end
 
   def test_interval_between_attempts_can_be_customized
-    self.expects(:sleep).times(2).with(5).returns(nil)
-    retry_upto(3, :interval => 5){ @target.foo! }
+    self.expects(:sleep).times(3).with(5).returns(nil)
+    retry_upto(4, :interval => 5){ @target.foo! }
   end
 
-  # interval growth between attempts
-
-  def test_inverval_can_be_multiplied_by_an_integer_growth
-    self.expects(:sleep).times(1).with(5)
-    self.expects(:sleep).times(1).with(15)
-    retry_upto(3, :interval => 5, :growth => 3){ @target.foo! }
-  end
-
-  def test_grow_for_inverval_between_attempts_can_be_defined_with_a_lambda
-    self.expects(:sleep).times(1).with(5)
-    self.expects(:sleep).times(1).with(7)
-    retry_upto(3, :interval => 5, :growth => lambda{ |t| t + 2 }){ @target.foo! }
+  def test_different_intervals_can_be_defined_with_a_lambda
+    self.expects(:sleep).times(1).with(3)
+    self.expects(:sleep).times(1).with(6)
+    self.expects(:sleep).times(1).with(9)
+    retry_upto(4, :interval => lambda{ |attempt| attempt * 3 }){ @target.foo! }
   end
 
   # exceptions
 
   def test_by_default_any_exception_gets_captured_if_there_are_attempts_left
-    retry_upto(3){ @target.foo! }
+    retry_upto(4){ @target.foo! }
     assert true # if we reach this no exception was raised out of retry_upto
   end
 
   def test_the_last_attempt_does_not_capture_the_exception
     assert_raises(FooError) do
-      retry_upto(2){ @target.foo! }
+      retry_upto(3){ @target.foo! }
     end
   end
 
   def test_a_specified_exception_will_be_captured_between_attempts
-    retry_upto(3, :rescue => FooError){ @target.foo! }
+    retry_upto(4, :rescue => FooError){ @target.foo! }
     assert true # if we reach this no exception was raised out of retry_upto
   end
 
   def test_several_specified_exceptions_will_be_captured_between_attempts
-    retry_upto(3, :rescue => [FooError, BarError]){ @target.foo! }
-    retry_upto(3, :rescue => [FooError, BarError]){ @target.bar! }
+    retry_upto(4, :rescue => [FooError, BarError]){ @target.foo! }
+    retry_upto(4, :rescue => [FooError, BarError]){ @target.bar! }
     assert true # if we reach this no exception was raised out of retry_upto
   end
 
   def test_the_last_attempt_does_not_capture_the_specified_exception
     assert_raises(FooError) do
-      retry_upto(2, :rescue => FooError){ @target.foo! }
+      retry_upto(3, :rescue => FooError){ @target.foo! }
     end
   end
 
   def test_a_exception_different_from_the_specified_one_will_not_be_captured_between_attempts
     assert_raises(FooError) do
-      retry_upto(3, :rescue => ZeroDivisionError){ @target.foo! }
+      retry_upto(4, :rescue => ZeroDivisionError){ @target.foo! }
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: retry_upto
 version: !ruby/object:Gem::Version
-  version: '1.1'
+  version: '1.2'
   prerelease: 
 platform: ruby
 authors:
@@ -14,11 +14,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-08 00:00:00.000000000Z
+date: 2011-10-10 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &2153033700 !ruby/object:Gem::Requirement
+  requirement: &2153491260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>'
@@ -26,10 +26,10 @@ dependencies:
         version: '2.0'
   type: :development
   prerelease: false
-  version_requirements: *2153033700
+  version_requirements: *2153491260
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &2153033220 !ruby/object:Gem::Requirement
+  requirement: &2153490760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -37,10 +37,10 @@ dependencies:
         version: 0.10.0
   type: :development
   prerelease: false
-  version_requirements: *2153033220
+  version_requirements: *2153490760
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2153032760 !ruby/object:Gem::Requirement
+  requirement: &2153490260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -48,7 +48,7 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *2153032760
+  version_requirements: *2153490260
 description: adds some useful options to retry code blocks
 email:
 - raul@murciano.net