retriable 1.4.1 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03ab323e10afdc5d56ba1cb8dafe474b384ebab4
-  data.tar.gz: b8018f10039fd5add022bd21bc89e3df94c742bf
+  metadata.gz: 75d7bf8633f7cf7fe492aa7d1b001d68a2389b34
+  data.tar.gz: 92a103a316a6c12a01e5374f4656e7be57cc3c76
 SHA512:
-  metadata.gz: eb6d13ae6aef5945c071c28d122b2018c6faadc8a4567542a3b687e12905cd335c7542627b3be8d3d4b386189d31f9c0af0d3d214dc8d87047e0708d4606327b
-  data.tar.gz: 3446c5920eb959cb60bd7a5cf4de8ace6df8480fbe80b82b526676557f5e0316780544b8986fb022a44a6d679a7a515931c236e67805d335fbf47938bf831735
+  metadata.gz: 6bb179a0ae1696e706d42b3a1769e67396238011363a5c152cd48a376fca099bf03db84413ca3e982cbadb13a14693a271d5eb2aa91dc4587301e2570490ada4
+  data.tar.gz: 9f4de38db13683ead4e8b78abf5be5ce200b942e453cbc94c6a934bacd3b5e31e4060be9803b03590c856ab41062c82cfe4a94924489eb7582027236e6df3d28

data/.travis.yml

@@ -1,7 +1,10 @@
 language: ruby
 rvm:
-  - 1.9.2
-  - 1.9.3
   - 2.0.0
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-19mode
+  - 2.1.3
+  - jruby
+  - rbx
+
+matrix:
+  allow_failures:
+    - rvm: rbx

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 2.0.0.beta1
+* Require ruby 2.0+.
+* Default to random exponential backoff, removes the `interval` option. Exponential backoff is configurable via arguments.
+* Allow configurable defaults via `#configure`.
+* Change `Retriable.retriable` to `Retriable.retry`
+* Support `max_elapsed_time` termination.
+
 ## 1.4.1
 * Fixes non kernel mode bug. Remove DSL class, move `#retriable` into Retriable module. Thanks @mkrogemann.
 

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb})
+  watch(%r{^lib/retriable/(.*/)?([^/]+)\.rb})     { |m| "test/#{m[1]}/test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb})      { 'test' }
+
+  # with Minitest::Spec
+  watch(%r{^spec/(.*)_spec\.rb})
+  watch(%r{^lib/retriable/(.+)\.rb})         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb}) { 'spec' }
+end

data/README.md

@@ -2,9 +2,15 @@
 
 [![Build Status](https://secure.travis-ci.org/kamui/retriable.png)](http://travis-ci.org/kamui/retriable)
 
-Retriable is an simple DSL to retry a code block if an exception should be raised.  This is especially useful when interacting external api/services or file system calls.
+Retriable is an simple DSL to retry failed code blocks with randomized [exponential backoff](http://en.wikipedia.org/wiki/Exponential_backoff). This is especially useful when interacting external api/services or file system calls.
 
-##Installation
+## Requirements
+
+Ruby 2.0+
+
+If you need 1.9.x support, use the [1.x branch](https://github.com/kamui/retriable/tree/1.x).
+
+## Installation
 
 via command line:
 
@@ -24,9 +30,22 @@ In your Gemfile:
 gem 'retriable'
 ```
 
-##Usage
+## Usage
 
-Code in a retriable block will be retried if an exception is raised. By default, Retriable will rescue any exception inherited from `StandardError` (and `Timeout::Error`, which does not inherit from `StandardError` in ruby 1.8) and make 3 retry attempts before raising the last exception.
+Code in a `Retriable.retry` block will be retried if an exception is raised. By default, Retriable will rescue any exception inherited from `StandardError`, make 3 retry attempts before raising the last exception, and also use randomized exponential backoff to calculate each succeeding attempt interval. The default interval table with 10 attempts looks like this (in seconds):
+
+| request# | retry interval | randomized interval |
+| -------- | -------------- | ------------------- |
+| 1        |    0.5         |   [0.25,   0.75]    |
+| 2        |    0.75        |   [0.375,  1.125]   |
+| 3        |    1.125       |   [0.562,  1.687]   |
+| 4        |    1.687       |   [0.8435, 2.53]    |
+| 5        |    2.53        |   [1.265,  3.795]   |
+| 6        |    3.795       |   [1.897,  5.692]   |
+| 7        |    5.692       |   [2.846,  8.538]   |
+| 8        |    8.538       |   [4.269, 12.807]   |
+| 9        |   12.807       |   [6.403, 19.210]   |
+| 10       |   19.210       |   stop              |
 
 ```ruby
 require 'retriable'
@@ -34,31 +53,53 @@ require 'retriable'
 class Api
   # Use it in methods that interact with unreliable services
   def get
-    Retriable.retriable do
+    Retriable.retry do
       # code here...
     end
   end
 end
 ```
 
-###Options
+### Options
 
 Here are the available options:
 
-`tries` (default: 3) - Number of attempts to make at running your code block
+`max_tries` (default: 3) - Number of attempts to make at running your code block.
+
+`base_interval` (default: 0.5) - The initial interval in seconds between attempts.
+
+`max_interval` (default: 60) - The maximum interval in seconds that any attempt can climb to.
 
-`interval` (default: 0) - Number of seconds to sleep between attempts
+`rand_factor` (default: 0.25) - The percent range above and below the next interval is randomized between. The calculation is calculated like this: `randomized_interval =
+      retry_interval * (random value in range [1 - randomization_factor, 1 + randomization_factor])`
+
+`multiplier` (default: 1.5) - Each successive interval grows by this factor. A multipler of 1.5 means the next interval will be 1.5x the current interval.
+
+`max_elapsed_time`  (default: 900 (15 min)) - The maximum amount of total time that code is allowed to keep being retried
 
 `timeout` (default: 0) - Number of seconds to allow the code block to run before raising a Timeout::Error
 
-`on` (default: [StandardError, Timeout::Error]) - `StandardError` and `Timeout::Error` or array of exceptions to rescue for each attempt
+`on` (default: [StandardError]) - An array of exceptions to rescue for each attempt, also accepts a single Exception type
 
 `on_retry` - (default: nil) - Proc to call after each attempt is rescued
 
-You can pass options via an options `Hash`. This example will only retry on a `Timeout::Error`, retry 3 times and sleep for a full second before each attempt.
+### Config
+
+You can change the global defaults with a `#configure` block:
+
+```ruby
+Retriable.configure do |c|
+  c.max_tries = 5
+  c.max_elapsed_time = 3600 # 1 hour
+end
+```
+
+### Examples
+
+`Retriable.retry` accepts custom arguments. This example will only retry on a `Timeout::Error`, retry 3 times and sleep for a full second before each attempt.
 
 ```ruby
-Retriable.retriable :on => Timeout::Error, :tries => 3, :interval => 1 do
+Retriable.retry on: Timeout::Error, max_tries: 3, base_interval: 1 do
   # code here...
 end
 ```
@@ -66,7 +107,7 @@ end
 You can also specify multiple errors to retry on by passing an array of exceptions.
 
 ```ruby
-Retriable.retriable :on => [Timeout::Error, Errno::ECONNRESET] do
+Retriable.retry on: [Timeout::Error, Errno::ECONNRESET] do
   # code here...
 end
 ```
@@ -74,7 +115,7 @@ end
 You can also specify a timeout if you want the code block to only make an attempt for X amount of seconds. This timeout is per attempt.
 
 ```ruby
-Retriable.retriable :timeout => 1 do
+Retriable.retry timeout: 60 do
   # code here...
 end
 ```
@@ -82,42 +123,50 @@ end
 If you need millisecond units of time for the sleep or the timeout:
 
 ```ruby
-Retriable.retriable :interval => (200/1000.0), :timeout => (500/1000.0) do
+Retriable.retry base_interval: (200/1000.0), timeout: (500/1000.0) do
   # code here...
 end
 ```
 
-###Exponential Backoff
+### Turn off Exponential Backoff
 
-If you'd like exponential backoff, interval can take a Proc
+Exponential backoff is enabled by default, if you want to simply execute code every second, you can do this:
 
 ```ruby
-# with exponential back-off - sleep 4, 16, 64, 256, give up
-Retriable.retryable :times => 4, :interval => lambda {|attempts| 4 ** attempts} do
+Retriable.retryable base_interval: 1.0, multiplier: 1.0, rand_factor: 0.0 do
   # code here...
 end
 ```
-###Callbacks
 
-Retriable also provides a callback called `:on_retry` that will run after an exception is rescued. This callback provides the number of `tries`, and the `exception` that was raised in the current attempt. As these are specified in a `Proc`, unnecessary variables can be left out of the parameter list.
+If you don't want exponential backoff, but you still want some randomization between intervals, this code will run every 1 seconds with a randomization factor of 0.2, which means each interval will be a random value between 0.8 and 1.2 (1 second +/- 0.2):
+
+```ruby
+Retriable.retryable base_interval: 1.0, multiplier: 1.0, rand_factor: 0.2 do
+  # code here...
+end
+```
+
+### Callbacks
+
+Retriable.retry also provides a callback called `:on_retry` that will run after an exception is rescued. This callback provides the `exception` that was raised in the current attempt, the `try_number`, the `elapsed_time` for all attempts so far, and the time in seconds of the `next_interval`. As these are specified in a `Proc`, unnecessary variables can be left out of the parameter list.
 
 ```ruby
-do_this_on_each_retry = Proc.new do |exception, tries|
-  log "#{exception.class}: '#{exception.message}' - #{tries} attempts."}
+do_this_on_each_retry = Proc.new do |exception, try_number, elapsed_time, next_interval|
+  log "#{exception.class}: '#{exception.message}' - #{try_number} attempts in #{elapsed_time} seconds and #{next_interval} seconds until the next attempt."}
 end
 
-Retriable.retriable :on_retry => do_this_on_each_retry do
+Retriable.retry on_retry: do_this_on_each_retry do
   # code here...
 end
 ```
 
-###Ensure/Else
+### Ensure/Else
 
 What if I want to execute a code block at the end, whether or not an exception was rescued ([ensure](http://ruby-doc.org/docs/keywords/1.9/Object.html#method-i-ensure))? Or, what if I want to execute a code block if no exception is raised ([else](http://ruby-doc.org/docs/keywords/1.9/Object.html#method-i-else))? Instead of providing more callbacks, I recommend you just wrap retriable in a begin/retry/else/ensure block:
 
 ```ruby
 begin
-  Retriable.retriable do
+  Retriable.retry do
     # some code
   end
 rescue => e
@@ -129,9 +178,9 @@ ensure
 end
 ```
 
-##Kernel Extension
+## Kernel Extension
 
-If you want to call `Retriable.retriable` without the `Retriable` module prefix and you don't mind extending `Kernel`,
+If you want to call `Retriable.retry` without the `Retriable` module prefix and you don't mind extending `Kernel`,
 there is a kernel extension available for this.
 
 In your ruby script:
@@ -146,7 +195,7 @@ or in your Gemfile:
 gem 'retriable', require: 'retriable/core_ext/kernel'
 ```
 
-and then you can call `retriable` in any context like this:
+and then you can call `#retriable` in any context like this:
 
 ```ruby
 retriable do
@@ -154,6 +203,6 @@ retriable do
 end
 ```
 
-##Credits
+## Credits
 
 Retriable was originally forked from the retryable-rb gem by [Robert Sosinski](https://github.com/robertsosinski), which in turn originally inspired by code written by [Michael Celona](http://github.com/mcelona) and later assisted by [David Malin](http://github.com/dmalin). The [attempt](https://rubygems.org/gems/attempt) gem by Daniel J. Berger was also an inspiration.

data/Rakefile

@@ -4,13 +4,13 @@ require 'bundler'
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
-task :default => :test
+task default: :test
 
 desc "Run tests"
 task :test do
   Rake::TestTask.new do |t|
-    t.libs << 'lib' << 'test'
-    t.pattern = 'test/**/*_test.rb'
+    t.libs << 'lib' << 'spec'
+    t.pattern = 'spec/**/*_spec.rb'
     t.verbose = true
   end
 end

data/lib/retriable.rb

@@ -1,17 +1,69 @@
-require 'retriable/retry'
+require 'timeout'
+require 'retriable/config'
+require 'retriable/version'
 
 module Retriable
   extend self
 
-  def retriable(opts = {}, &block)
+  attr_accessor :config
+
+  def self.configure
+    self.config ||= Config.new
+    yield(config)
+  end
+
+  def retry(
+    max_tries:         config.max_tries,
+    base_interval:     config.base_interval,
+    max_interval:      config.max_interval,
+    rand_factor:       config.rand_factor,
+    multiplier:        config.multiplier,
+    max_elapsed_time:  config.max_elapsed_time,
+    timeout:           config.timeout,
+    on:                config.on,
+    on_retry:          config.on_retry,
+    &block)
+
     raise LocalJumpError unless block_given?
 
-    Retry.new do |r|
-      r.tries    = opts[:tries] if opts[:tries]
-      r.on       = opts[:on] if opts[:on]
-      r.interval = opts[:interval] if opts[:interval]
-      r.timeout  = opts[:timeout] if opts[:timeout]
-      r.on_retry = opts[:on_retry] if opts[:on_retry]
-    end.perform(&block)
+    attempt = 0
+    start_time = Time.now
+    interval = base_interval
+
+    begin
+      attempt += 1
+      if timeout
+        Timeout::timeout(timeout) { return block.call(attempt) }
+      else
+        return block.call(attempt)
+      end
+    rescue *[*on] => exception
+      raise if attempt >= max_tries
+
+      return if (Time.now - start_time) > max_elapsed_time
+
+      interval = randomized_interval(rand_factor, interval)
+
+      on_retry.call(exception, attempt, Time.now - start_time, interval) if on_retry
+
+      sleep interval if interval > 0 && config.sleep_disabled != true
+
+      interval = if interval >= (max_interval / multiplier)
+        max_interval
+      else
+        interval * multiplier
+      end
+
+      retry
+    end
+  end
+
+  private
+  def randomized_interval(rand_factor, interval)
+    return interval if rand_factor == 0
+    delta = rand_factor * interval * 1.0
+    min_interval = interval - delta
+    max_interval = interval + delta
+    rand(min_interval..max_interval)
   end
 end

data/lib/retriable/config.rb

@@ -0,0 +1,27 @@
+module Retriable
+  class Config
+    attr_accessor :sleep_disabled
+    attr_accessor :max_tries
+    attr_accessor :base_interval
+    attr_accessor :max_interval
+    attr_accessor :rand_factor
+    attr_accessor :multiplier
+    attr_accessor :max_elapsed_time
+    attr_accessor :timeout
+    attr_accessor :on
+    attr_accessor :on_retry
+
+    def initialize
+      @sleep_disabled    = false
+      @max_tries         = 3
+      @base_interval     = 0.5
+      @max_interval      = 60
+      @rand_factor       = 0.5
+      @multiplier        = 1.5
+      @max_elapsed_time  = 900 # 15 minn
+      @timeout           = nil
+      @on                = [StandardError]
+      @on_retry          = nil
+    end
+  end
+end

data/lib/retriable/core_ext/kernel.rb

@@ -1,6 +1,7 @@
 require 'retriable'
 
 module Kernel
-  include Retriable
-  private :retriable
+  def retriable(opts={}, &block)
+    Retriable.retry(opts, &block)
+  end
 end

data/lib/retriable/version.rb

@@ -1,3 +1,3 @@
 module Retriable
-  VERSION = '1.4.1'
+  VERSION = '2.0.0.beta1'
 end

data/retriable.gemspec

@@ -10,8 +10,9 @@ Gem::Specification.new do |s|
   s.authors     = ["Jack Chu"]
   s.email       = ["jack@jackchu.com"]
   s.homepage    = %q{http://github.com/kamui/retriable}
-  s.summary     = %q{Retriable is an simple DSL to retry a code block if an exception should be raised.}
-  s.description = %q{Retriable is an simple DSL to retry a code block if an exception should be raised. This is especially useful when interacting external api/services or file system calls.}
+  s.summary     = %q{Retriable is an simple DSL to retry failed code blocks with randomized exponential backoff}
+  s.description = %q{Retriable is an simple DSL to retry failed code blocks with randomized exponential backoff. This is especially useful when interacting external api/services or file system calls.
+}
   s.license       = "MIT"
 
   s.rubyforge_project = "retriable"
@@ -23,4 +24,8 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'minitest', '>= 5.0'
+  s.add_development_dependency 'minitest-focus'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-minitest'
 end

data/spec/retriable_spec.rb

@@ -0,0 +1,111 @@
+require_relative 'spec_helper'
+
+class TestError < Exception; end
+
+describe Retriable do
+  subject do
+    Retriable
+  end
+
+  before do
+    Retriable.configure do |c|
+      c.sleep_disabled = true
+    end
+  end
+
+  it 'raises a LocalJumpError if retry is not given a block' do
+    lambda do
+      subject.retry on: EOFError
+    end.must_raise LocalJumpError
+  end
+
+  describe 'retry block of code raising EOFError with no arguments' do
+    before do
+      @attempts = 0
+
+      subject.retry do
+        @attempts += 1
+        raise EOFError.new if @attempts < 3
+      end
+    end
+
+    it 'uses exponential backoff' do
+      @attempts.must_equal 3
+    end
+  end
+
+  it 'retry on custom exception and re-raises the exception' do
+    lambda do
+      subject.retry on: TestError do
+        raise TestError.new
+      end
+    end.must_raise TestError
+  end
+
+  it 'retry with 10 max tries' do
+    attempts = 0
+
+    subject.retry(
+      max_tries: 10
+    ) do
+        attempts += 1
+        raise EOFError.new if attempts < 10
+    end
+
+    attempts.must_equal 10
+  end
+
+  describe 'retries with an on_retry handler, 6 max retries, and a 0.0 rand_factor' do
+    before do
+      max_tries = 6
+      @attempts = 0
+      @time_table = {}
+
+      handler = Proc.new do |exception, attempt, elapsed_time, next_interval|
+        exception.class.must_equal ArgumentError
+        @time_table[attempt] = next_interval
+      end
+
+      Retriable.retry(
+        on: [EOFError, ArgumentError],
+        on_retry: handler,
+        rand_factor: 0.0,
+        max_tries: max_tries
+      ) do
+        @attempts += 1
+        raise ArgumentError.new if @attempts < max_tries
+      end
+    end
+
+    it 'makes 6 attempts' do
+      @attempts.must_equal 6
+    end
+
+    it 'applies a non-randomized exponential backoff to each attempt' do
+      @time_table.must_equal({
+        1 => 0.5,
+        2 => 0.75,
+        3 => 1.125,
+        4 => 1.6875,
+        5 => 2.53125
+      })
+    end
+  end
+
+  it 'can call #retriable in the global' do
+    lambda do
+      retriable do
+        puts 'should raise NoMethodError'
+      end
+    end.must_raise NoMethodError
+
+    require_relative '../lib/retriable/core_ext/kernel'
+
+    i = 0
+    retriable do
+      i += 1
+      raise EOFError.new if i < 3
+    end
+    i.must_equal 3
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/autorun'
+require 'minitest/focus'
+require 'pry'
+
+require_relative '../lib/retriable'

data/wercker.yml

@@ -0,0 +1,27 @@
+box: wercker/rvm
+# Build definition
+build:
+    # The steps that will be executed on build
+    # See the Ruby section on the wercker devcenter:
+    # http://devcenter.wercker.com/articles/languages/ruby.html
+    steps:
+        # Uncomment this to force RVM to use a specific Ruby version
+        # - rvm-use:
+            # version: 2.1.0
+
+        # A step that executes `bundle install` command
+        - bundle-install
+
+        # A custom script step, name value is used in the UI
+        # and the code value contains the command that get executed
+        - script:
+            name: echo ruby information
+            code: |
+                echo "ruby version $(ruby --version) running"
+                echo "from location $(which ruby)"
+                echo -p "gem list: $(gem list)"
+
+        # Add more steps here:
+        - script:
+             name: rake
+             code: bundle exec rake

metadata

@@ -1,65 +1,123 @@
 --- !ruby/object:Gem::Specification
 name: retriable
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0.beta1
 platform: ruby
 authors:
 - Jack Chu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-06 00:00:00.000000000 Z
+date: 2014-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-description: Retriable is an simple DSL to retry a code block if an exception should
-  be raised. This is especially useful when interacting external api/services or file
-  system calls.
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Retriable is an simple DSL to retry failed code blocks with randomized exponential backoff. This is especially useful when interacting external api/services or file system calls.
 email:
 - jack@jackchu.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/retriable.rb
+- lib/retriable/config.rb
 - lib/retriable/core_ext/kernel.rb
-- lib/retriable/retry.rb
 - lib/retriable/version.rb
 - retriable.gemspec
-- test/retriable_test.rb
+- spec/retriable_spec.rb
+- spec/spec_helper.rb
+- wercker.yml
 homepage: http://github.com/kamui/retriable
 licenses:
 - MIT
@@ -70,20 +128,21 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: retriable
-rubygems_version: 2.0.7
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Retriable is an simple DSL to retry a code block if an exception should be
-  raised.
+summary: Retriable is an simple DSL to retry failed code blocks with randomized exponential
+  backoff
 test_files:
-- test/retriable_test.rb
+- spec/retriable_spec.rb
+- spec/spec_helper.rb

data/lib/retriable/retry.rb

@@ -1,44 +0,0 @@
-require 'timeout'
-
-module Retriable
-  class Retry
-    attr_accessor :tries
-    attr_accessor :interval
-    attr_accessor :timeout
-    attr_accessor :on
-    attr_accessor :on_retry
-
-    def initialize
-      @tries      = 3
-      @interval   = 0
-      @timeout    = nil
-      @on         = [StandardError, Timeout::Error]
-      @on_retry   = nil
-
-      yield self if block_given?
-    end
-
-    def perform
-      count = 0
-      begin
-        if @timeout
-          Timeout::timeout(@timeout) { yield }
-        else
-          yield
-        end
-      rescue *[*on] => exception
-        @tries -= 1
-        if @tries > 0
-          count += 1
-          @on_retry.call(exception, count) if @on_retry
-          sleep_for = @interval.respond_to?(:call) ? @interval.call(count) : @interval
-          sleep sleep_for if sleep_for > 0
-
-          retry
-        else
-          raise
-        end
-      end
-    end
-  end
-end

data/test/retriable_test.rb

@@ -1,84 +0,0 @@
-require 'retriable'
-require 'minitest/autorun'
-
-class RetriableTest < Minitest::Test
-  def test_raise_no_block
-    assert_raises LocalJumpError do
-      Retriable.retriable :on => StandardError
-    end
-  end
-
-  def test_without_arguments
-    i = 0
-
-    Retriable.retriable do
-      i += 1
-      raise StandardError.new
-    end
-    rescue StandardError
-    assert_equal 3, i
-  end
-
-  def test_with_one_exception_and_two_tries
-    i = 0
-
-    Retriable.retriable :on => EOFError, :tries => 2 do
-      i += 1
-      raise EOFError.new
-    end
-
-    rescue EOFError
-    assert_equal i, 2
-  end
-
-  def test_with_arguments
-    i = 0
-
-    on_retry = Proc.new do |exception, tries|
-      assert_equal exception.class, ArgumentError
-      assert_equal i, tries
-    end
-
-    Retriable.retriable :on => [EOFError, ArgumentError], :on_retry => on_retry, :tries => 5, :sleep => 0.2 do |h|
-      i += 1
-      raise ArgumentError.new
-    end
-
-  rescue ArgumentError
-    assert_equal 5, i
-  end
-
-  def test_with_interval_proc
-    was_called = false
-
-    sleeper = Proc.new do |attempts|
-      was_called = true
-      attempts
-    end
-
-    Retriable.retriable :on => EOFError, :interval => sleeper do |h|
-      raise EOFError.new
-    end
-    rescue
-    assert_equal was_called, true
-  end
-
-  def test_kernel_ext
-    assert_raises NoMethodError do
-      retriable do
-        puts 'should raise NoMethodError'
-      end
-    end
-
-    require 'retriable/core_ext/kernel'
-    i = 0
-
-    retriable do
-      i += 1
-      raise StandardError.new
-    end
-
-    rescue StandardError
-    assert_equal 3, i
-  end
-end