retriable 1.3.3.1 → 1.4.0

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.4.0
+* By default, retriable doesn't monkey patch `Kernel`. If you want this functionality,
+you can `require 'retriable/core_ext/kernel'.
+* Upgrade minitest to 5.x.
+* Refactor the DSL into it's own class.
+
 ## 1.3.3.1
 * Allow sleep parameter to be a proc/lambda to allow for exponential backoff.
 

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Jack Chu (http://www.jackchu.com)
+Copyright (c) 2012-2013 Jack Chu (http://www.jackchu.com)
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.md

@@ -1,13 +1,12 @@
-Retriable
-============
+#Retriable
 
 [![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.
 
-Installation
-------------
-Via command line:
+##Installation
+
+via command line:
 
 ```ruby
 gem install retriable
@@ -25,8 +24,7 @@ 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.
 
@@ -36,13 +34,15 @@ require 'retriable'
 class Api
   # Use it in methods that interact with unreliable services
   def get
-    retriable do
+    Retriable.retriable do
       # code here...
     end
   end
 end
 ```
 
+###Options
+
 Here are the available options:
 
 `tries` (default: 3) - Number of attempts to make at running your code block
@@ -58,7 +58,7 @@ Here are the available options:
 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.
 
 ```ruby
-retriable :on => Timeout::Error, :tries => 3, :interval => 1 do
+Retriable.retriable :on => Timeout::Error, :tries => 3, :interval => 1 do
   # code here...
 end
 ```
@@ -66,7 +66,7 @@ end
 You can also specify multiple errors to retry on by passing an array of exceptions.
 
 ```ruby
-retriable :on => [Timeout::Error, Errno::ECONNRESET] do
+Retriable.retriable :on => [Timeout::Error, Errno::ECONNRESET] do
   # code here...
 end
 ```
@@ -74,7 +74,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 :timeout => 1 do
+Retriable.retriable :timeout => 1 do
   # code here...
 end
 ```
@@ -82,19 +82,22 @@ end
 If you need millisecond units of time for the sleep or the timeout:
 
 ```ruby
-retriable :interval => (200/1000.0), :timeout => (500/1000.0) do
+Retriable.retriable :interval => (200/1000.0), :timeout => (500/1000.0) do
   # code here...
 end
 ```
 
+###Exponential Backoff
+
 If you'd like exponential backoff, interval can take a Proc
 
 ```ruby
 # with exponential back-off - sleep 4, 16, 64, 256, give up
-retryable :times => 4, :interval => lambda {|attempts| 4 ** attempts} do
+Retriable.retryable :times => 4, :interval => lambda {|attempts| 4 ** attempts} 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.
 
@@ -103,16 +106,18 @@ do_this_on_each_retry = Proc.new do |exception, tries|
   log "#{exception.class}: '#{exception.message}' - #{tries} attempts."}
 end
 
-retriable :on_retry => do_this_on_each_retry do
+Retriable.retriable :on_retry => do_this_on_each_retry do
   # code here...
 end
 ```
 
+###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 do
+  Retriable.retriable do
     # some code
   end
 rescue => e
@@ -124,30 +129,31 @@ ensure
 end
 ```
 
-Non Kernel version
-------------------
-By default, `require 'retriable'` will include the `#retriable` method into the `Kernel` so that you can use it everywhere. If you don't want this behaviour, you can load a non-kernel version:
+##Kernel Extension
+
+If you want to call `Retriable.retriable` without the `Retriable` module prefix and you don't mind extending `Kernel`,
+there is a kernel extension available for this.
+
+In your ruby script:
 
 ```ruby
-gem 'retriable', require => 'retriable/no_kernel'
+require 'retriable/core_ext/kernel'
 ```
 
-Or in your ruby script:
+or in your Gemfile:
 
 ```ruby
-require 'retriable/no_kernel'
+gem 'retriable', require: 'retriable/core_ext/kernel'
 ```
 
-In this case, you'll just execute a retriable block from the `Retriable` module:
+and then you can call `retriable` in any context like this:
 
 ```ruby
-Retriable.retriable do
+retriable do
   # code here...
 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/lib/retriable.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+require 'retriable/retry'
+require 'retriable/dsl'
 
-require 'retriable/no_kernel'
-require 'retriable/core_ext/kernel'
+module Retriable
+end

data/lib/retriable/core_ext/kernel.rb

@@ -1,9 +1,6 @@
-# encoding: utf-8
+require 'retriable'
 
 module Kernel
-  include Retriable
+  include Retriable::DSL
+  private :retriable
 end
-
-class Object
-  include Kernel
-end

data/lib/retriable/dsl.rb

@@ -0,0 +1,17 @@
+require 'retriable/retry'
+
+module Retriable
+  module DSL
+    def retriable(opts = {}, &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)
+    end
+  end
+end

data/lib/retriable/{retriable.rb → retry.rb}

@@ -1,10 +1,6 @@
- # encoding: utf-8
-
 require 'timeout'
 
 module Retriable
-  extend self
-
   class Retry
     attr_accessor :tries
     attr_accessor :interval
@@ -35,7 +31,6 @@ module Retriable
         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
 
@@ -46,16 +41,4 @@ module Retriable
       end
     end
   end
-
-  def retriable(opts = {}, &block)
-    raise 'no block given' 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)
-  end
 end

data/lib/retriable/version.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Retriable
-  VERSION = '1.3.3.1'
+  VERSION = '1.4.0'
 end

data/retriable.gemspec

@@ -12,6 +12,7 @@ Gem::Specification.new do |s|
   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.license       = "MIT"
 
   s.rubyforge_project = "retriable"
 

data/test/retriable_test.rb

@@ -1,9 +1,14 @@
-# encoding: utf-8
-
 require 'retriable'
+require 'retriable/core_ext/kernel'
 require 'minitest/autorun'
 
-class RetriableTest < MiniTest::Unit::TestCase
+class RetriableTest < Minitest::Test
+  def test_raise_no_block
+    assert_raises LocalJumpError do
+      retriable :on => StandardError
+    end
+  end
+
   def test_without_arguments
     i = 0
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: retriable
 version: !ruby/object:Gem::Version
-  version: 1.3.3.1
+  version: 1.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-02 00:00:00.000000000 Z
+date: 2013-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -61,13 +61,14 @@ files:
 - Rakefile
 - lib/retriable.rb
 - lib/retriable/core_ext/kernel.rb
-- lib/retriable/no_kernel.rb
-- lib/retriable/retriable.rb
+- lib/retriable/dsl.rb
+- lib/retriable/retry.rb
 - lib/retriable/version.rb
 - retriable.gemspec
 - test/retriable_test.rb
 homepage: http://github.com/kamui/retriable
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -78,12 +79,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2391393966112040014
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2391393966112040014
 requirements: []
 rubyforge_project: retriable
 rubygems_version: 1.8.25

data/lib/retriable/no_kernel.rb

@@ -1,4 +0,0 @@
-# encoding: utf-8
-
-require 'retriable/retriable'
-require 'retriable/version'