retriable 2.0.0.beta5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7f89877bb9506abc02a59892b97c55a0f995b38
-  data.tar.gz: 7b9e325e86386e6e0e739bb4a51df12882327c1b
+  metadata.gz: 1b752911d256dced83d90ff384285f521001fd21
+  data.tar.gz: bc8abdb30075bfe7948bff5e2a7ddec0cdeb62ac
 SHA512:
-  metadata.gz: 4fc3260da9272d6fe2a8b29c939ea661e49cb45d28b7a082021a44d6823c96d1612860d6a8cdfe5acc0973c0bdbbeeaa55869f0831999396826b2653c47a29c2
-  data.tar.gz: 11113a95d8b63b1bed523f0fd98755dd9b4a176435b40a3cbf877d5eabd136e30aec8eba5ee9b3369d8c1af3311f8883910f7965d19747b077e3dbf9ab867b50
+  metadata.gz: b564835a63aa4d7e890cc0417d55132a8124070b92747074d9c5795daf28d2cc896cdc887e1da31b6176ee4061a83c9513b47dc15171f1332c1b0f40d4f59752
+  data.tar.gz: 7560dac587dfc6556602117c3f698ce2a7e52ef00f465e9a1dc871e7faf8a764d220a6ef8a34fb16dd2a45c278c9965043664cec4d300bf6a508bbd4d121480a

data/.gitignore

@@ -1,7 +1,14 @@
-.DS_Store
-.rvmrc
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
-.idea
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -1,10 +1,17 @@
 language: ruby
 rvm:
   - 2.0.0
-  - 2.1.3
-  - jruby
+  - 2.1.5
+  - 2.2.0
   - rbx
+  - ruby-head
+  - jruby-head
 
 matrix:
   allow_failures:
-    - rvm: jruby
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+addons:
+  code_climate:
+    repo_token: 20a1139ef1830b4f813a10a03d90e8aa179b5226f75e75c5a949b25756ebf558

data/CHANGELOG.md

@@ -1,5 +1,9 @@
+## HEAD
+
+  * Require ruby 2.0.0 minimum in gemspec.
+
 ## 2.0.0.beta5
-* Change :max_tries back to :tries.
+* Change `:max_tries` back to `:tries`.
 
 ## 2.0.0.beta4
 * Change #retry back to #retriable. Didn't like the idea of defining a method that is also a reserved word.

data/Gemfile

@@ -2,3 +2,15 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in retriable.gemspec
 gemspec
+
+group :test do
+  gem "ruby_gntp"
+  gem "minitest-focus"
+  gem "codeclimate-test-reporter", require: false
+  gem "simplecov", require: false
+end
+
+group :development, :test do
+  gem "pry"
+  gem "awesome_print"
+end

data/Guardfile

@@ -2,13 +2,7 @@
 # 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' }
+  watch(%r{^lib/retriable/(.+)\.rb})  { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb})    { 'spec' }
 end

data/README.md

@@ -1,6 +1,8 @@
 #Retriable
 
 [![Build Status](https://secure.travis-ci.org/kamui/retriable.png)](http://travis-ci.org/kamui/retriable)
+[![Code Climate](https://codeclimate.com/github/kamui/retriable/badges/gpa.svg)](https://codeclimate.com/github/kamui/retriable)
+[![Test Coverage](https://codeclimate.com/github/kamui/retriable/badges/coverage.svg)](https://codeclimate.com/github/kamui/retriable)
 
 Retriable is an simple DSL to retry failed code blocks with randomized [exponential backoff](http://en.wikipedia.org/wiki/Exponential_backoff) time intervals. This is especially useful when interacting external api/services or file system calls.
 
@@ -23,31 +25,31 @@ gem install retriable
 In your ruby script:
 
 ```ruby
-require 'retriable', '~> 2.0'
+require 'retriable'
 ```
 
 In your Gemfile:
 
 ```ruby
-gem 'retriable'
+gem 'retriable', '~> 2.0'
 ```
 
 ## Usage
 
-Code in a `Retriable.retriable` 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):
+Code in a `Retriable.retriable` block will be retried if an exception is raised. By default, Retriable will rescue any exception inherited from `StandardError`, make 3 retry tries before raising the last exception, and also use randomized exponential backoff to calculate each succeeding try interval. The default interval table with 10 tries 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              |
+| request# | retry interval | randomized interval             |
+| -------- | -------------- | ------------------------------- |
+| 1        |    0.5         |  [0.25,   0.75]                 |
+| 2        |    0.75        |  [0.375,  1.125]                |
+| 3        |    1.125       |  [0.5625,  1.6875]              |
+| 4        |    1.6875      |  [0.84375, 2.53125]             |
+| 5        |    2.53125     |  [1.265625, 3.796875]           |
+| 6        |    3.796875    |  [1.8984375,  5.6953125]        |
+| 7        |    5.6953125   |  [2.84765625,  8.54296875]      |
+| 8        |   8.54296875   |  [4.271484375, 12.814453125]    |
+| 9        |  12.814453125  |  [6.4072265625, 19.2216796875]  |
+| 10       | 19.2216796875  |  stop                           |
 
 ```ruby
 require 'retriable'
@@ -66,11 +68,11 @@ end
 
 Here are the available options:
 
-`tries` (default: 3) - Number of attempts to make at running your code block.
+`tries` (default: 3) - Number of tries to make at running your code block.
 
-`base_interval` (default: 0.5) - The initial interval in seconds between attempts.
+`base_interval` (default: 0.5) - The initial interval in seconds between tries.
 
-`max_interval` (default: 60) - The maximum interval in seconds that any attempt can climb to.
+`max_interval` (default: 60) - The maximum interval in seconds that any try can reach.
 
 `rand_factor` (default: 0.25) - The percent range above and below the next interval is randomized between. The calculation is calculated like this:
 
@@ -86,9 +88,9 @@ randomized_interval = retry_interval * (random value in range [1 - randomization
 
 `timeout` (default: 0) - Number of seconds to allow the code block to run before raising a Timeout::Error
 
-`on` (default: [StandardError]) - An `Array` of exceptions to rescue for each attempt, a `Hash` where the keys are `Exception` classes and the values can be a single `Regexp` pattern or a list of patterns, or a single `Exception` type.
+`on` (default: [StandardError]) - An `Array` of exceptions to rescue for each try, a `Hash` where the keys are `Exception` classes and the values can be a single `Regexp` pattern or a list of patterns, or a single `Exception` type.
 
-`on_retry` - (default: nil) - Proc to call after each attempt is rescued.
+`on_retry` - (default: nil) - Proc to call after each try is rescued.
 
 ### Config
 
@@ -103,7 +105,7 @@ end
 
 ### Examples
 
-`Retriable.retriable` accepts custom arguments. This example will only retry on a `Timeout::Error`, retry 3 times and sleep for a full second before each attempt.
+`Retriable.retriable` accepts custom arguments. This example will only retry on a `Timeout::Error`, retry 3 times and sleep for a full second before each try.
 
 ```ruby
 Retriable.retriable on: Timeout::Error, tries: 3, base_interval: 1 do
@@ -131,7 +133,7 @@ Retriable.retriable on: {
 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.
+You can also specify a timeout if you want the code block to only make an try for X amount of seconds. This timeout is per try.
 
 ```ruby
 Retriable.retriable timeout: 60 do
@@ -177,11 +179,11 @@ end
 
 ### Callbacks
 
-`#retriable` 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.
+`#retriable` 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 try, the `try_number`, the `elapsed_time` for all tries 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, 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."}
+do_this_on_each_retry = Proc.new do |exception, try, elapsed_time, next_interval|
+  log "#{exception.class}: '#{exception.message}' - #{try} tries in #{elapsed_time} seconds and #{next_interval} seconds until the next try."}
 end
 
 Retriable.retriable on_retry: do_this_on_each_retry do

data/lib/retriable.rb

@@ -17,16 +17,16 @@ module Retriable
   end
 
   def retriable(
-    tries:             config.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,
-    intervals:         config.intervals,
-    timeout:           config.timeout,
-    on:                config.on,
-    on_retry:          config.on_retry
+      tries:             config.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,
+      intervals:         config.intervals,
+      timeout:           config.timeout,
+      on:                config.on,
+      on_retry:          config.on_retry
     )
 
     start_time = Time.now
@@ -46,12 +46,12 @@ module Retriable
 
     exception_list = on.kind_of?(Hash) ? on.keys : on
 
-    intervals.each.with_index(1) do |interval, attempt|
+    intervals.each.with_index(1) do |interval, try|
       begin
         if timeout
-          Timeout::timeout(timeout) { return yield(attempt) }
+          Timeout::timeout(timeout) { return yield(try) }
         else
-          return yield(attempt)
+          return yield(try)
         end
       rescue *[*exception_list] => exception
         if on.kind_of?(Hash)
@@ -66,8 +66,8 @@ module Retriable
           raise unless message_match
         end
 
-        on_retry.call(exception, attempt, elapsed_time.call, interval) if on_retry
-        raise if attempt >= tries || (elapsed_time.call + interval) > max_elapsed_time
+        on_retry.call(exception, try, elapsed_time.call, interval) if on_retry
+        raise if try >= tries || (elapsed_time.call + interval) > max_elapsed_time
         sleep interval if config.sleep_disabled != true
       end
     end

data/lib/retriable/config.rb

@@ -19,7 +19,7 @@ module Retriable
       @max_interval      = 60
       @rand_factor       = 0.5
       @multiplier        = 1.5
-      @max_elapsed_time  = 900 # 15 minn
+      @max_elapsed_time  = 900 # 15 min
       @intervals         = nil
       @timeout           = nil
       @on                = [StandardError]

data/lib/retriable/exponential_backoff.rb

@@ -7,11 +7,11 @@ module Retriable
     attr_accessor :rand_factor
 
     def initialize(
-      tries:            Retriable.config.tries,
-      base_interval:    Retriable.config.base_interval,
-      multiplier:       Retriable.config.multiplier,
-      max_interval:     Retriable.config.max_interval,
-      rand_factor:      Retriable.config.rand_factor
+        tries:            Retriable.config.tries,
+        base_interval:    Retriable.config.base_interval,
+        multiplier:       Retriable.config.multiplier,
+        max_interval:     Retriable.config.max_interval,
+        rand_factor:      Retriable.config.rand_factor
       )
 
       @tries          = tries
@@ -31,13 +31,13 @@ module Retriable
       intervals.map { |i| randomize(i) }
     end
 
-    protected
+    private
     def randomize(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)
+      min = interval - delta
+      max = interval + delta
+      rand(min..max)
     end
   end
 end

data/lib/retriable/version.rb

@@ -1,3 +1,3 @@
 module Retriable
-  VERSION = "2.0.0.beta5"
+  VERSION = "2.0.0"
 end

data/retriable.gemspec

@@ -1,31 +1,30 @@
 # coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "retriable/version"
 
-Gem::Specification.new do |s|
-  s.name        = "retriable"
-  s.version     = Retriable::VERSION
-  s.platform    = Gem::Platform::RUBY
-  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 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.
+Gem::Specification.new do |spec|
+  spec.name          = "retriable"
+  spec.version       = Retriable::VERSION
+  spec.authors       = ["Jack Chu"]
+  spec.email         = ["jack@jackchu.com"]
+  spec.summary       = %q{Retriable is an simple DSL to retry failed code blocks with randomized exponential backoff}
+  spec.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"
+  spec.homepage      = %q{http://github.com/kamui/retriable}
+  spec.license       = "MIT"
 
-  s.rubyforge_project = "retriable"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.0.0'
 
-  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"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-minitest"
 end

data/spec/exponential_backoff_spec.rb

@@ -5,6 +5,10 @@ describe Retriable::ExponentialBackoff do
     Retriable::ExponentialBackoff
   end
 
+  before do
+    srand 0
+  end
+
   it "tries defaults to 3" do
     subject.new.tries.must_equal 3
   end
@@ -21,29 +25,71 @@ describe Retriable::ExponentialBackoff do
     subject.new.multiplier.must_equal 1.5
   end
 
-  it "generates randomized intervals" do
-    i = subject.new(tries: 9).intervals
-    i[0].between?(0.25, 0.75).must_equal true
-    i[1].between?(0.375, 1.125).must_equal true
-    i[2].between?(0.562, 1.687).must_equal true
-    i[3].between?(0.8435, 2.53).must_equal true
-    i[4].between?(1.265, 3.795).must_equal true
-    i[5].between?(1.897, 5.692).must_equal true
-    i[6].between?(2.846, 8.538).must_equal true
-    i[7].between?(4.269, 12.807).must_equal true
-    i[8].between?(6.403, 19.210).must_equal true
+  it "generates 10 randomized intervals" do
+    subject.new(tries: 9).intervals.must_equal([
+      0.5244067512211441,
+      0.9113920238761231,
+      1.2406087918999114,
+      1.7632403621664823,
+      2.338001204738311,
+      4.350816718580626,
+      5.339852157217869,
+      11.889873261212443,
+      18.756037881636484
+    ])
+  end
+
+  it "generates defined number of intervals" do
+    subject.new(tries: 5).intervals.size.must_equal 5
+  end
+
+  it "generates intervals with a defined base interval" do
+    subject.new(base_interval: 1).intervals.must_equal([
+      1.0488135024422882,
+      1.8227840477522461,
+      2.4812175837998227
+    ])
+  end
+
+  it "generates intervals with a defined multiplier" do
+    subject.new(multiplier: 1).intervals.must_equal([
+      0.5244067512211441,
+      0.607594682584082,
+      0.5513816852888495
+    ])
+  end
+
+  it "generates intervals with a defined max interval" do
+    subject.new(max_interval: 1.0, rand_factor: 0.0).intervals.must_equal([
+      0.5,
+      0.75,
+      1.0
+    ])
+  end
+
+  it "generates intervals with a defined rand_factor" do
+    subject.new(rand_factor: 0.2).intervals.must_equal([
+      0.5097627004884576,
+      0.8145568095504492,
+      1.1712435167599646
+    ])
   end
 
-  it "generates 5 non-randomized intervals" do
+  it "generates 10 non-randomized intervals" do
     subject.new(
-      tries: 5,
+      tries: 10,
       rand_factor: 0.0
     ).intervals.must_equal([
       0.5,
       0.75,
       1.125,
       1.6875,
-      2.53125
+      2.53125,
+      3.796875,
+      5.6953125,
+      8.54296875,
+      12.814453125,
+      19.2216796875
     ])
   end
 end

data/spec/retriable_spec.rb

@@ -7,6 +7,10 @@ describe Retriable do
     Retriable
   end
 
+  before do
+    srand 0
+  end
+
   describe "with sleep disabled" do
     before do
       Retriable.configure do |c|
@@ -14,110 +18,128 @@ describe Retriable do
       end
     end
 
-    it "stops at first attempt if the block does not raise an exception" do
-      attempts = 0
+    it "stops at first try if the block does not raise an exception" do
+      tries = 0
       subject.retriable do
-        attempts += 1
+        tries += 1
       end
 
-      attempts.must_equal 1
+      tries.must_equal 1
     end
 
     it "raises a LocalJumpError if #retriable is not given a block" do
       -> do
-        subject.retriable on: EOFError
+        subject.retriable on: StandardError
       end.must_raise LocalJumpError
 
       -> do
-        subject.retriable on: EOFError, timeout: 2
+        subject.retriable on: StandardError, timeout: 2
       end.must_raise LocalJumpError
     end
 
-    describe "#retriable block of code raising EOFError with no arguments" do
-      before do
-        @attempts = 0
+    it "makes 3 tries when retrying block of code raising StandardError with no arguments" do
+      tries = 0
 
+      -> do
         subject.retriable do
-          @attempts += 1
-          raise EOFError.new if @attempts < 3
+          tries += 1
+          raise StandardError.new
         end
-      end
+      end.must_raise StandardError
 
-      it "uses exponential backoff" do
-        @attempts.must_equal 3
-      end
+      tries.must_equal 3
+    end
+
+    it "makes only 1 try when exception raised is not ancestor of StandardError" do
+      tries = 0
+
+      -> do
+        subject.retriable do
+          tries += 1
+          raise TestError.new
+        end
+      end.must_raise TestError
+
+      tries.must_equal 1
     end
 
-    it "#retriable on custom exception and re-raises the exception" do
+    it "#retriable with custom exception tries 3 times and re-raises the exception" do
+      tries = 0
       -> do
         subject.retriable on: TestError do
+          tries += 1
           raise TestError.new
         end
       end.must_raise TestError
+
+      tries.must_equal 3
     end
 
     it "#retriable tries 10 times" do
-      attempts = 0
+      tries = 0
 
-      subject.retriable(
-        tries: 10
-      ) do
-          attempts += 1
-          raise EOFError.new if attempts < 10
-      end
+      -> do
+        subject.retriable(
+          tries: 10
+        ) do
+            tries += 1
+            raise StandardError.new
+        end
+      end.must_raise StandardError
 
-      attempts.must_equal 10
+      tries.must_equal 10
     end
 
     it "#retriable will timeout after 1 second" do
       -> do
         subject.retriable timeout: 1 do
-          sleep 2
+          sleep 1.1
         end
       end.must_raise Timeout::Error
     end
 
-    it "applies a randomized exponential backoff to each attempt" do
-      @attempts = 0
-      @time_table = {}
+    it "applies a randomized exponential backoff to each try" do
+      @tries = 0
+      @time_table = []
 
-      handler = ->(exception, attempt, elapsed_time, next_interval) do
+      handler = ->(exception, try, elapsed_time, next_interval) do
         exception.class.must_equal ArgumentError
-        @time_table[attempt] = next_interval
+        @time_table << next_interval
       end
 
       -> do
         Retriable.retriable(
           on: [EOFError, ArgumentError],
           on_retry: handler,
-          rand_factor: 0.0,
           tries: 9
         ) do
-          @attempts += 1
+          @tries += 1
           raise ArgumentError.new
         end
       end.must_raise ArgumentError
 
-      @time_table[1].between?(0.25, 0.75).must_equal true
-      @time_table[2].between?(0.375, 1.125).must_equal true
-      @time_table[3].between?(0.562, 1.687).must_equal true
-      @time_table[4].between?(0.8435, 2.53).must_equal true
-      @time_table[5].between?(1.265, 3.795).must_equal true
-      @time_table[6].between?(1.897, 5.692).must_equal true
-      @time_table[7].between?(2.846, 8.538).must_equal true
-      @time_table[8].between?(4.269, 12.807).must_equal true
-      @time_table[9].between?(6.403, 19.210).must_equal true
+      @time_table.must_equal([
+        0.5244067512211441,
+        0.9113920238761231,
+        1.2406087918999114,
+        1.7632403621664823,
+        2.338001204738311,
+        4.350816718580626,
+        5.339852157217869,
+        11.889873261212443,
+        18.756037881636484
+      ])
     end
 
     describe "retries with an on_#retriable handler, 6 max retries, and a 0.0 rand_factor" do
       before do
         tries = 6
-        @attempts = 0
+        @tries = 0
         @time_table = {}
 
-        handler = ->(exception, attempt, elapsed_time, next_interval) do
+        handler = ->(exception, try, elapsed_time, next_interval) do
           exception.class.must_equal ArgumentError
-          @time_table[attempt] = next_interval
+          @time_table[try] = next_interval
         end
 
         Retriable.retriable(
@@ -126,16 +148,16 @@ describe Retriable do
           rand_factor: 0.0,
           tries: tries
         ) do
-          @attempts += 1
-          raise ArgumentError.new if @attempts < tries
+          @tries += 1
+          raise ArgumentError.new if @tries < tries
         end
       end
 
-      it "makes 6 attempts" do
-        @attempts.must_equal 6
+      it "makes 6 tries" do
+        @tries.must_equal 6
       end
 
-      it "applies a non-randomized exponential backoff to each attempt" do
+      it "applies a non-randomized exponential backoff to each try" do
         @time_table.must_equal({
           1 => 0.5,
           2 => 0.75,
@@ -147,24 +169,25 @@ describe Retriable do
     end
 
     it "#retriable has a max interval of 1.5 seconds" do
-      tries = 6
-      attempts = 0
+      tries = 0
       time_table = {}
 
-      handler = ->(exception, attempt, elapsed_time, next_interval) do
-        time_table[attempt] = next_interval
+      handler = ->(exception, try, elapsed_time, next_interval) do
+        time_table[try] = next_interval
       end
 
-      subject.retriable(
-        on: EOFError,
-        on_retry: handler,
-        rand_factor: 0.0,
-        tries: tries,
-        max_interval: 1.5
-      ) do
-        attempts += 1
-        raise EOFError.new if attempts < tries
-      end
+      -> do
+        subject.retriable(
+          on: StandardError,
+          on_retry: handler,
+          rand_factor: 0.0,
+          tries: 5,
+          max_interval: 1.5
+        ) do
+          tries += 1
+          raise StandardError.new
+        end
+      end.must_raise StandardError
 
       time_table.must_equal({
         1 => 0.5,
@@ -175,7 +198,7 @@ describe Retriable do
       })
     end
 
-    it "#retriable with defined intervals" do
+    it "#retriable with custom defined intervals" do
       intervals = [
         0.5,
         0.75,
@@ -185,19 +208,18 @@ describe Retriable do
       ]
       time_table = {}
 
-      handler = ->(exception, attempt, elapsed_time, next_interval) do
-        time_table[attempt] = next_interval
+      handler = ->(exception, try, elapsed_time, next_interval) do
+        time_table[try] = next_interval
       end
 
       -> do
         subject.retriable(
-          on: EOFError,
           on_retry: handler,
           intervals: intervals
         ) do
-          raise EOFError.new
+          raise StandardError.new
         end
-      end.must_raise EOFError
+      end.must_raise StandardError
 
       time_table.must_equal({
         1 => 0.5,
@@ -219,22 +241,22 @@ describe Retriable do
     end
 
     it "#retriable with a hash exception list where the values are exception message patterns" do
-      attempts = 0
-      tries = []
-      handler = ->(exception, attempt, elapsed_time, next_interval) do
-        tries[attempt] = exception
+      tries = 0
+      exceptions = []
+      handler = ->(exception, try, elapsed_time, next_interval) do
+        exceptions[try] = exception
       end
 
       e = -> do
-        subject.retriable tries: 4, on: { EOFError => nil, TestError => [/foo/, /bar/] }, on_retry: handler do
-          attempts += 1
-          case attempts
+        subject.retriable tries: 4, on: { StandardError => nil, TestError => [/foo/, /bar/] }, on_retry: handler do
+          tries += 1
+          case tries
           when 1
             raise TestError.new('foo')
           when 2
             raise TestError.new('bar')
           when 3
-            raise EOFError.new
+            raise StandardError.new
           else
             raise TestError.new('crash')
           end
@@ -242,11 +264,11 @@ describe Retriable do
       end.must_raise TestError
 
       e.message.must_equal "crash"
-      tries[1].class.must_equal TestError
-      tries[1].message.must_equal "foo"
-      tries[2].class.must_equal TestError
-      tries[2].message.must_equal "bar"
-      tries[3].class.must_equal EOFError
+      exceptions[1].class.must_equal TestError
+      exceptions[1].message.must_equal "foo"
+      exceptions[2].class.must_equal TestError
+      exceptions[2].message.must_equal "bar"
+      exceptions[3].class.must_equal StandardError
     end
 
     it "#retriable can be called in the global scope" do
@@ -258,12 +280,16 @@ describe Retriable do
 
       require_relative "../lib/retriable/core_ext/kernel"
 
-      attempts = 0
-      retriable do
-        attempts += 1
-        raise EOFError.new if attempts < 3
-      end
-      attempts.must_equal 3
+      tries = 0
+
+      -> do
+        retriable do
+          tries += 1
+          raise StandardError.new
+        end
+      end.must_raise StandardError
+
+      tries.must_equal 3
     end
   end
 
@@ -274,11 +300,11 @@ describe Retriable do
 
     subject.config.sleep_disabled.must_equal false
 
-    attempts = 0
+    tries = 0
     time_table = {}
 
-    handler = ->(exception, attempt, elapsed_time, next_interval) do
-      time_table[attempt] = elapsed_time
+    handler = ->(exception, try, elapsed_time, next_interval) do
+      time_table[try] = elapsed_time
     end
 
     -> do
@@ -289,11 +315,11 @@ describe Retriable do
         max_elapsed_time: 2.0,
         on_retry: handler
       ) do
-        attempts += 1
+        tries += 1
         raise EOFError.new
       end
     end.must_raise EOFError
 
-    attempts.must_equal 2
+    tries.must_equal 2
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,21 @@
+require "codeclimate-test-reporter"
+require "simplecov"
+
+CodeClimate::TestReporter.configure do |config|
+  config.logger.level = Logger::WARN
+end
+
+SimpleCov.start do
+  formatter SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    CodeClimate::TestReporter::Formatter
+  ]
+  add_filter 'spec/'
+end
+
 require "minitest/autorun"
 require "minitest/focus"
+require "awesome_print"
 require "pry"
 
 require_relative "../lib/retriable"

data/wercker.yml

@@ -6,8 +6,8 @@ build:
     # 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
+        - rvm-use:
+            version: 2.1.5
 
         # A step that executes `bundle install` command
         - bundle-install

metadata

@@ -1,71 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: retriable
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta5
+  version: 2.0.0
 platform: ruby
 authors:
 - Jack Chu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-09 00:00:00.000000000 Z
+date: 2015-01-30 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
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: minitest-focus
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.4'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -133,15 +119,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: retriable
-rubygems_version: 2.2.2
+rubyforge_project: 
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Retriable is an simple DSL to retry failed code blocks with randomized exponential