patiently_try 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4f76c4e188cd73428d39ae170470fbcb9cd5fc0
-  data.tar.gz: 86afb035db2b84b8cff826fc5c5480fa2fd073b2
+  metadata.gz: 10305ce860974756386078ebdb953dfeaff4dec3
+  data.tar.gz: b5009fc983d963ec0d5709ec2fe6f09d800155be
 SHA512:
-  metadata.gz: 9d3f4ade2244163104ace00a2833427a5effacd67ac1195254c8f894935de58e5c38d1a8d45e789d1f5f9f7c03f840bf0598b6fc79e5bc27e7eac922f4e964d4
-  data.tar.gz: 564f4fa5bd52f62f516e24c13461be359f7a5594af382f2afd6363d2d262e9987407ff11b94b8a76ce08d92b695cbe5863e822fc2f01c942025e1e5187e147f5
+  metadata.gz: c90f36ffc4a6c6d9ed9595e31f8c55ace4fac943d25a809497b3c6290d5691a9be03faa7fd27536e34b871f06d135619ec860e5a107939d97b365496c08ec976
+  data.tar.gz: 93167bc6d4b94a5791052a58e06567164427b38916e984189c987df7d2123451c1eeb4859461011e52422b861d809f0454ce022dcaa31cfdc369edb6d9e0a6c5

data/README.md

@@ -1,6 +1,9 @@
+[![Gem Version](https://badge.fury.io/rb/patiently_try.svg)](https://badge.fury.io/rb/patiently_try)
+[![Build Status](https://travis-ci.org/Ninigi/patiently_try.svg?branch=master)](https://travis-ci.org/Ninigi/patiently_try)
+
 # PatientlyTry
 
-Just another DSL gem to surround your code with retry blocks. I use it with ActiveSupport
+Just another DSL gem to surround your code with retry blocks. I use it with ActiveResource
 to retry stuff, but you can use it with every piece of code that might, or might not raise
 an error that can magically resolve itself.
 
@@ -35,11 +38,14 @@ end
 
 I would recommend to keep the retried code block as small as possible, to avoid unintentional retries.
 
-You can use the following options:
+## Options
+
+The following options are available:
 
 * `retries: 100` - The number of retries you want to attempt before giving up and reraising the error.
-* `wait: 0` - How long you want to wait before retrying (in seconds)
+* `wait: 0` - How long you want to wait between retries (in seconds).
 * `catch: [StandardError]` - If you want only specific errors to be caught (value can be an array or a single error).
+* `raise_if_caught: []` - If you want to exclude an error from being caught through inheritance.
 * `logging: true` - If you do not want any output, set this to false.
 
 ```ruby
@@ -51,6 +57,19 @@ patiently_try retries: 2, wait: 1, catch: [Timeout::Error, Errno::ECONNREFUSED]
 end
 ```
 
+The `:catch` and `:raise_if_caught` can be used together to limit the amount of errors that will be retried.
+If only `:raise_if_caught` is set, it will retry every `StandardError` except the ones specified.
+
+```ruby
+patiently_try raise_if_caught: [ArgumentError] do
+  # This will trigger retries, since NoMethodError is a StandardError
+  raise NoMethodError
+
+  # This will not trigger a retry and fail on first try
+  raise StandardError
+end
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Ninigi/patiently_try. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/lib/patiently_try/version.rb

@@ -1,3 +1,3 @@
 module PatientlyTry
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/patiently_try.rb

@@ -2,24 +2,48 @@ require "patiently_try/version"
 
 module PatientlyTry
   def patiently_try(opts = {})
-    retries      = opts[:retries] || 100
-    wait         = opts[:wait] || 0
-    catch_errors = opts[:catch] || StandardError
-    logging      = opts[:logging].nil? ? true : opts[:logging]
-    try          = 0
+    retries         = opts[:retries] || 100
+    wait            = opts[:wait] || 0
+    catch_errors    = Array(opts[:catch] || StandardError)
+    excluded_errors = Array(opts[:raise_if_caught])
+    logging         = opts[:logging].nil? ? true : opts[:logging]
+    try             = 0
 
     begin
       yield
-    rescue *(Array(catch_errors)) => e
+    rescue *(catch_errors) => e
       try += 1
-      puts "Failed with: #{e.inspect}" if logging
 
-      raise e if try >= retries
+      _log_error if logging
+
+      if try >= retries || _rescued_but_excluded?(e, excluded_errors)
+        _log_backtrace if logging
+        raise e
+      end
+
+      _log_retry if logging
 
-      puts "Retrying (#{try}/#{retries})"
       sleep wait if wait && wait > 0
 
       retry
     end
   end
+
+  private
+
+  def _log_retry
+    puts "Retrying (#{try}/#{retries})"
+  end
+
+  def _rescued_but_excluded?(e, excluded_errors)
+    excluded_errors.to_a.inject(false) { |excl, error| excl || e.is_a?(error) }
+  end
+
+  def _log_error(e)
+    puts "Failed with: #{e.inspect}"
+  end
+
+  def _log_backtrace(e)
+    puts e.backtrace.join("\n")
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patiently_try
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Fabian Zitter
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-19 00:00:00.000000000 Z
+date: 2017-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Surrounds your code with a try catch block and will retry for X times.