attempt_this 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb1e8ce9d65d7e2fd649b08462f7fec5d5c275bd
-  data.tar.gz: 42f3dfabe605a339c8f0abaa32db1e93ee130532
+  metadata.gz: fa826f48090801a88909e9e8c6dc318efd26c95b
+  data.tar.gz: 2a781b4b14bf8156258a71a0b6742ed876463cda
 SHA512:
-  metadata.gz: 67d984ccaa89933fefd5fc20358c11750baaecc56f47ba10625deac47312d8d9a46a9c41b36803461d7b6b0a6150dceec8addf7ef57dfbb7f352fa3aabcea597
-  data.tar.gz: cf0c8ab119c22978d0328d930b05e34e54f89ea57b4d15b4af4c7597f068b04245ff68efdea4fe07816756eaa2c35280f648ec1f13be7c122507165aa09b18ef
+  metadata.gz: c6a9860fd483413ca05d4cb0b95e6816dc3d7f77474920ff260b014372d41999e5ffaa6ebbdcf9ec62d857e6148a4ec398af48bf918aae03f9e498287d86bab2
+  data.tar.gz: d2d28cfc7ff30dfdd300ec4b36c2ce68530ea61118f92ceebe32f29827c1ad297a7aca2d892837e0d846aff0cf0c03c917c56b72f80150e9a58c2cc8af39e11c

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 1.9.3
+  - jruby-19mode

data/Gemfile.lock

@@ -1,15 +1,13 @@
 PATH
   remote: .
   specs:
-    attempt_this (1.0.0)
+    attempt_this (1.0.1)
 
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.2.4)
     docile (1.1.2)
-    macaddr (1.6.1)
-      systemu (~> 2.5.0)
     multi_json (1.8.4)
     rake (10.1.1)
     rspec (2.13.0)
@@ -25,18 +23,15 @@ GEM
       multi_json
       simplecov-html (~> 0.8.0)
     simplecov-html (0.8.0)
-    systemu (2.5.2)
-    uuid (2.3.7)
-      macaddr (~> 1.0)
 
 PLATFORMS
+  java
   ruby
   x86-mingw32
 
 DEPENDENCIES
   attempt_this!
-  bundler
-  rake
-  rspec
-  simplecov
-  uuid
+  bundler (~> 1.6)
+  rake (~> 10.1)
+  rspec (~> 2.13)
+  simplecov (~> 0.8)

data/attempt_this.gemspec

@@ -1,22 +1,22 @@
 Gem::Specification.new do |s|
-  s.name				= 'attempt_this'
-  s.version			= '1.0.0'
-  s.date				= '2014-04-27'
-  s.summary			= 'Retry policy mix-in'
-  s.description		= <<EOM
+  s.name        = 'attempt_this'
+  s.version     = '1.0.1'
+  s.date        = '2014-04-29'
+  s.summary     = 'Retry policy mix-in'
+  s.description = <<EOM
 Retry policy mix-in with configurable number of attempts, delays, exception filters, and fall back strategies.
 
 See project's home page for usage examples and more information.
 EOM
-  s.authors			= ['Aliaksei Baturytski']
-  s.email				= 'abaturytski@gmail.com'
-  s.files				= `git ls-files`.split($/)
-  s.homepage		= 'https://github.com/aliakb/attempt_this'
+  s.authors     = ['Aliaksei Baturytski']
+  s.email       = 'abaturytski@gmail.com'
+  s.files       = `git ls-files`.split($/)
+  s.homepage    = 'https://github.com/aliakb/attempt_this'
   s.license     = 'MIT'
+  s.required_ruby_version = '>= 1.8.7'
 
-  s.add_development_dependency('bundler')
-  s.add_development_dependency('rake')
-  s.add_development_dependency('rspec')
-  s.add_development_dependency('simplecov')
-  s.add_development_dependency('uuid')
+  s.add_development_dependency('bundler', '~> 1.6')
+  s.add_development_dependency('rake', '~> 10.1')
+  s.add_development_dependency('rspec', '~> 2.13')
+  s.add_development_dependency('simplecov', '~> 0.8')
 end

data/lib/attempt_this/attempt_object.rb

@@ -1,5 +1,5 @@
-require_relative 'binary_backoff_policy.rb'
-require_relative 'exception_type_filter.rb'
+require './lib/attempt_this/binary_backoff_policy.rb'
+require './lib/attempt_this/exception_type_filter.rb'
 
 module AttemptThis
   # Retry policy implementation.
@@ -29,29 +29,17 @@ module AttemptThis
       return self unless block
       return block.call unless AttemptThis.enabled?
 
-      last_exception = nil
-      first_time = true
+      apply_defaults
 
-      @delay_policy = ->{} unless @delay_policy
-      @reset_method = ->{} unless @reset_method
-      @exception_filter = ExceptionTypeFilter.new([StandardError]) unless @exception_filter
-
-      @enumerator.rewind
-      @enumerator.with_index do |i|
-        @delay_policy.call unless i == 0
-        last_exception = nil
-        begin
-          return block.call
-        rescue Exception => ex
-          raise unless @exception_filter.include?(ex)
-          @reset_method.call
-          last_exception = ex
-        end
+      # Retriable attempts require special error handling
+      result = each_retriable_attempt do
+        return attempt_with_reset(&block)
       end
 
-      if (last_exception)
-        return @default_method[] if @default_method
-        raise last_exception
+      # Final attempt
+      if (result != :empty)
+        @delay_policy.call unless result == :skipped
+        final_attempt(&block)
       end
     end
 
@@ -69,7 +57,7 @@ module AttemptThis
         raise(ArgumentError, "Delay should be either an number or a range of numbers; got #{delay}!")
       end
       raise(ArgumentError, 'Delay policy has already been specified!') if @delay_policy
-      @delay_policy = ->{Kernel.sleep(rand(delay))}
+      @delay_policy = lambda{Kernel.sleep(delay.first + rand(delay.count))}
 
       attempt(block)
     end
@@ -118,10 +106,52 @@ module AttemptThis
 
     # Creates a scenario with the given id.
     def scenario(id)
-      raise(ArgumentError, 'Blank id!') if id.nil? || id.empty?
+      raise(ArgumentError, 'Nil id!') if id.nil?
       raise(ArgumentError, "There is already a scenario with id #{id}") if @@scenarios.has_key?(id)
 
       @@scenarios[id] = self
     end
+
+    private
+
+
+    def final_attempt(&block)
+      attempt_with_reset(&block)
+    rescue Exception => ex
+      raise unless @default_method
+      raise unless @exception_filter.include?(ex)
+      @default_method.call
+    end
+
+    def apply_defaults
+      @delay_policy = lambda{} unless @delay_policy
+      @reset_method = lambda{} unless @reset_method
+      @exception_filter = ExceptionTypeFilter.new([StandardError]) unless @exception_filter
+    end
+
+    def each_retriable_attempt(&block)
+      result = :empty
+      @enumerator.each do
+        if (result == :empty)
+          result = :skipped
+          next
+        end
+        @delay_policy.call unless result == :skipped
+        result = :attempted
+        begin
+          block.call
+        rescue Exception => ex
+          raise unless @exception_filter.include?(ex)
+        end
+      end
+      result
+    end
+
+    def attempt_with_reset(&block)
+      block.call
+    rescue Exception => ex
+      @reset_method.call
+      raise
+    end
   end
 end

data/spec/attempt_spec.rb

@@ -5,11 +5,11 @@ describe AttemptThis do
 
   context 'attempt' do
     it 'should reject nil enumerator' do
-      ->{attempt(nil)}.should raise_error(ArgumentError)
+      lambda{attempt(nil)}.should raise_error(ArgumentError)
     end
 
     it 'should allow execution without a code block' do
-      ->{attempt(3.times)}.should_not raise_error
+      lambda{attempt(3.times)}.should_not raise_error
     end
 
     it 'should execute code block' do
@@ -32,12 +32,12 @@ describe AttemptThis do
     end
 
     it 'should re-throw the original exception' do
-      ->{attempt(2.times){raise 'Test'}}.should raise_error('Test')
+      lambda{attempt(2.times){raise 'Test'}}.should raise_error('Test')
     end
 
     it 'should attempt 3 times' do
       call_count = 0
-      ->{attempt(3.times) { call_count += 1; raise 'Test'}}.should raise_error('Test')
+      lambda{attempt(3.times) { call_count += 1; raise 'Test'}}.should raise_error('Test')
       call_count.should eql(3)
     end
 
@@ -52,34 +52,34 @@ describe AttemptThis do
     end
 
     it 'should return block\'s value' do
-      expected = UUID.generate.to_s
+      expected = "some string"
       attempt(3.times) { expected }.should eql(expected)
     end
   end
 
   context 'with_delay' do
     it 'should reject nil delay' do
-      ->{attempt(3.times).with_delay(nil)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_delay(nil)}.should raise_error(ArgumentError)
     end
 
     it 'should reject negative delay' do
-      ->{attempt(3.times).with_delay(-1)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_delay(-1)}.should raise_error(ArgumentError)
     end
 
     it 'should reject non-number delay' do
-      ->{attempt(3.times).with_delay('foo')}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_delay('foo')}.should raise_error(ArgumentError)
     end
 
     it 'should accept floating point delay' do
-      ->{attempt(3.times).with_delay(1.5)}.should_not raise_error
+      lambda{attempt(3.times).with_delay(1.5)}.should_not raise_error
     end
 
     it 'should accept zero delay' do
-      ->{attempt(3.times).with_delay(0)}.should_not raise_error
+      lambda{attempt(3.times).with_delay(0)}.should_not raise_error
     end
 
     it 'should accept calls without a code block' do
-      ->{attempt(3.times).with_delay(3)}.should_not raise_error
+      lambda{attempt(3.times).with_delay(3)}.should_not raise_error
     end
 
     it 'should call the code block' do
@@ -97,111 +97,111 @@ describe AttemptThis do
 
     it 'should sleep for given number of seconds between failed attempts' do
       Kernel.should_receive(:sleep).with(5).exactly(2).times
-      ->{attempt(3.times).with_delay(5) {raise 'Test'}}.should raise_error('Test')
+      lambda{attempt(3.times).with_delay(5) {raise 'Test'}}.should raise_error('Test')
     end
 
     it 'should not fail on zero delay' do
-      ->{attempt(3.times).with_delay(0) { raise 'Test' }}.should raise_error('Test')
+      lambda{attempt(3.times).with_delay(0) { raise 'Test' }}.should raise_error('Test')
     end
 
     it 'should reject negative start' do
-      ->{attempt(3.times).with_delay(-1..1)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_delay(-1..1)}.should raise_error(ArgumentError)
     end
 
     it 'should reject negative end' do
-      ->{attempt(3.times).with_delay(1..-1)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_delay(1..-1)}.should raise_error(ArgumentError)
     end
 
     it 'should reject non-number range' do
-      ->{attempt(3.times).with_delay('x'..'y')}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_delay('x'..'y')}.should raise_error(ArgumentError)
     end
 
     it 'should accept floating point range' do
-      ->{attempt(3.times).with_delay(1.5..3)}.should_not raise_error
+      lambda{attempt(3.times).with_delay(1.5..3)}.should_not raise_error
     end
 
     it 'should reject inverse range' do
-      ->{attempt(2.times).with_delay(3..1)}.should raise_error(ArgumentError)
+      lambda{attempt(2.times).with_delay(3..1)}.should raise_error(ArgumentError)
     end
 
     it 'should accept zero seconds interval' do
-      ->{attempt(3.times).with_delay(0..0)}.should_not raise_error
+      lambda{attempt(3.times).with_delay(0..0)}.should_not raise_error
     end
 
     it 'should wait for specified number of seconds' do
       Kernel.should_receive(:sleep).with(5).exactly(2).times
-      ->{attempt(3.times).with_delay(5..5){raise 'Test'}}.should raise_error('Test')
+      lambda{attempt(3.times).with_delay(5..5){raise 'Test'}}.should raise_error('Test')
     end
 
     it 'should reject multiple delay policies' do
-      ->{attempt(3.times).with_delay(1).with_delay(1)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_delay(1).with_delay(1)}.should raise_error(ArgumentError)
     end
   end
 
   context 'with_reset' do
     it 'should reject nil reset proc' do
-      ->{attempt(3.times).with_reset(nil)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_reset(nil)}.should raise_error(ArgumentError)
     end
 
     it 'should accept calls without a code block' do
-      ->{attempt(3.times).with_reset(->{})}.should_not raise_error
+      lambda{attempt(3.times).with_reset(lambda{})}.should_not raise_error
     end
 
     it 'should call the code block' do
       was_called = false
-      attempt(1.times).with_reset(->{}) { was_called = true }
+      attempt(1.times).with_reset(lambda{}) { was_called = true }
 
       was_called.should be_true
     end
 
     it 'should reject multiple reset procs' do
-      ->{attempt(3.times).with_reset(->{}).with_reset(->{})}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_reset(lambda{}).with_reset(lambda{})}.should raise_error(ArgumentError)
     end
 
     it 'should not be called on successful calls' do
       was_called = false
 
-      attempt(1.times).with_reset(->{ was_called = true }) {}
+      attempt(1.times).with_reset(lambda{ was_called = true }) {}
       was_called.should be_false
     end
 
     it 'should be called on each failure' do
       reset_count = 0
 
-      ->{attempt(3.times).with_reset(->{ reset_count += 1 }) { raise 'Test' }}.should raise_error('Test')
+      lambda{attempt(3.times).with_reset(lambda{ reset_count += 1 }) { raise 'Test' }}.should raise_error('Test')
       reset_count.should eql(3)
     end
   end
 
   context 'and_default_to' do
     it 'should reject nil default method' do
-      ->{attempt(3.times).and_default_to(nil)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).and_default_to(nil)}.should raise_error(ArgumentError)
     end
 
     it 'should reject duplicate default methods' do
-      ->{attempt(3.times).and_default_to(->{}).and_default_to(->{})}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).and_default_to(lambda{}).and_default_to(lambda{})}.should raise_error(ArgumentError)
     end
 
     it 'should allow calls without a code block' do
-      ->{attempt(3.times).and_default_to(->{})}.should_not raise_error
+      lambda{attempt(3.times).and_default_to(lambda{})}.should_not raise_error
     end
 
     it 'should call the code block' do
       was_called = false
-      attempt(3.times).and_default_to(->{}){ was_called = true }
+      attempt(3.times).and_default_to(lambda{}){ was_called = true }
 
       was_called.should be_true
     end
 
     it 'should not be called on success' do
       was_called = false
-      attempt(3.times).and_default_to(->{ was_called = true }) {}
+      attempt(3.times).and_default_to(lambda{ was_called = true }) {}
       was_called.should be_false
     end
 
     it 'should be called once on the failure' do
       call_count = 0
-      attempt(3.times).and_default_to(->{ call_count += 1 }){ raise 'Test'}
+      attempt(3.times).and_default_to(lambda{ call_count += 1 }){ raise 'Test'}
 
       call_count.should eql(1)
     end
@@ -210,34 +210,34 @@ describe AttemptThis do
       call_count = 0
       was_called = false
 
-      attempt(3.times).and_default_to(->{ was_called = true }) { call_count += 1; raise 'Test' if call_count < 2 }
+      attempt(3.times).and_default_to(lambda{ was_called = true }) { call_count += 1; raise 'Test' if call_count < 2 }
       was_called.should be_false
     end
   end
 
   context 'with_binary_backoff' do
     it 'should reject nil initial delay' do
-      ->{attempt(3.times).with_binary_backoff(nil)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_binary_backoff(nil)}.should raise_error(ArgumentError)
     end
 
     it 'should reject non-integer initial delay' do
-      ->{attempt(3.times).with_binary_backoff('foo')}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_binary_backoff('foo')}.should raise_error(ArgumentError)
     end
 
     it 'should reject zero initial delay' do
-      ->{attempt(3.times).with_binary_backoff(0)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_binary_backoff(0)}.should raise_error(ArgumentError)
     end
 
     it 'should reject negative initial delay' do
-      ->{attempt(3.times).with_binary_backoff(-1)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_binary_backoff(-1)}.should raise_error(ArgumentError)
     end
 
     it 'should reject multiple policies' do
-      ->{attempt(3.times).with_binary_backoff(1).with_binary_backoff(2)}.should raise_error(ArgumentError)
+      lambda{attempt(3.times).with_binary_backoff(1).with_binary_backoff(2)}.should raise_error(ArgumentError)
     end
 
     it 'should accept calls without a code block' do
-      ->{attempt(3.times).with_binary_backoff(1)}.should_not raise_error
+      lambda{attempt(3.times).with_binary_backoff(1)}.should_not raise_error
     end
 
     it 'should call the code block' do
@@ -252,21 +252,21 @@ describe AttemptThis do
       Kernel.should_receive(:sleep).ordered.with(2)
       Kernel.should_receive(:sleep).ordered.with(4)
 
-      attempt(4.times).with_binary_backoff(1).and_default_to(->{}) { raise 'Test' }
+      attempt(4.times).with_binary_backoff(1).and_default_to(lambda{}) { raise 'Test' }
     end
   end
 
   context 'with_filter' do
     it 'should reject empty exceptions list' do
-      ->{attempt.with_filter}.should raise_error(ArgumentError)
+      lambda{attempt.with_filter}.should raise_error(ArgumentError)
     end
 
     it 'should reject non-exceptions' do
-      ->{attempt.with_filter(1)}.should raise_error(ArgumentError)
+      lambda{attempt.with_filter(1)}.should raise_error(ArgumentError)
     end
 
     it 'should accept calls without a block' do
-      ->{attempt(2.times).with_filter(Exception)}.should_not raise_error
+      lambda{attempt(2.times).with_filter(Exception)}.should_not raise_error
     end
 
     it 'should call code within the block' do
@@ -277,19 +277,19 @@ describe AttemptThis do
 
     it 'should ignore other exceptions' do
       count = 0
-      ->{attempt(3.times).with_filter(StandardError){ count += 1; raise(Exception, 'Test')}}.should raise_error(Exception)
+      lambda{attempt(3.times).with_filter(StandardError){ count += 1; raise(Exception, 'Test')}}.should raise_error(Exception)
       count.should eql(1)
     end
 
     it 'should not ignore specified exceptions' do
       count = 0
-      ->{attempt(3.times).with_filter(RuntimeError){ count += 1; raise 'Test'}}.should raise_error(RuntimeError)
+      lambda{attempt(3.times).with_filter(RuntimeError){ count += 1; raise 'Test'}}.should raise_error(RuntimeError)
       count.should eql(3)
     end
 
     it 'should not ignore derived exceptions' do
       count = 0
-      ->{attempt(3.times).with_filter(Exception){ count += 1; raise(StandardError, 'Test')}}.should raise_error(StandardError)
+      lambda{attempt(3.times).with_filter(Exception){ count += 1; raise(StandardError, 'Test')}}.should raise_error(StandardError)
       count.should eql(3)
     end
   end

data/spec/scenarios_spec.rb

@@ -9,24 +9,20 @@ describe AttemptThis do
 
   context 'validation' do
     it 'should reject nil scenario id' do
-      ->{AttemptThis.attempt(3.times).scenario(nil)}.should raise_error(ArgumentError)
-    end
-
-    it 'should reject empty scenario id' do
-      ->{AttemptThis.attempt(3.times).scenario('')}.should raise_error(ArgumentError)
+      lambda{AttemptThis.attempt(3.times).scenario(nil)}.should raise_error(ArgumentError)
     end
 
     it 'should accept string ids' do
-      ->{AttemptThis.attempt(3.times).scenario('uploads')}.should_not raise_error
+      lambda{AttemptThis.attempt(3.times).scenario('uploads')}.should_not raise_error
     end
 
     it 'should accept symbol ids' do
-      ->{AttemptThis.attempt(3.times).scenario(:uploads)}.should_not raise_error
+      lambda{AttemptThis.attempt(3.times).scenario(:uploads)}.should_not raise_error
     end
 
     it 'should reject duplicate names' do
       AttemptThis.attempt(3.times).scenario(:uploads)
-      ->{AttemptThis.attempt(3.times).scenario(:uploads)}.should raise_error(ArgumentError)
+      lambda{AttemptThis.attempt(3.times).scenario(:uploads)}.should raise_error(ArgumentError)
     end
   end
 
@@ -35,16 +31,16 @@ describe AttemptThis do
       AttemptThis.attempt(3.times).scenario(:test)
       count = 0
 
-      ->{attempt(:test) { count += 1; raise 'Test' }}.should raise_error('Test')
+      lambda{attempt(:test) { count += 1; raise 'Test' }}.should raise_error('Test')
       count.should eql(3)
     end
 
     it 'should reuse scenario' do
       AttemptThis.attempt(3.times).scenario(:test)
-      ->{attempt(:test) { raise 'Test'}}.should raise_error('Test')
+      lambda{attempt(:test) { raise 'Test'}}.should raise_error('Test')
 
       count = 0
-      ->{attempt(:test) {count += 1; raise 'Test'}}.should raise_error('Test')
+      lambda{attempt(:test) {count += 1; raise 'Test'}}.should raise_error('Test')
       count.should eql(3)
     end
   end

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 require 'simplecov'
 SimpleCov.start
 
-require 'uuid'
-require_relative '../lib/attempt_this.rb'
+require 'attempt_this.rb'

metadata

@@ -1,85 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: attempt_this
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Aliaksei Baturytski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-27 00:00:00.000000000 Z
+date: 2014-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.13'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: uuid
-  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'
+        version: '0.8'
 description: |
   Retry policy mix-in with configurable number of attempts, delays, exception filters, and fall back strategies.
 
@@ -89,7 +75,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -113,17 +100,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Retry policy mix-in