recoverable 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91d2cd9b2a88fc2cb068caa21ba39b4c6b2d7e15
-  data.tar.gz: 2eadd39119ec415d732ccff3b822e3c95ff96da1
+  metadata.gz: e38db8978744c68969a3ffeaf3b1966bf0f50adb
+  data.tar.gz: a8d65bab14f3605a8a491bb40f768a9e93d76d5e
 SHA512:
-  metadata.gz: b1fe4d4f02d158f7e0625d6282f382218b95d35e2ac753f8b7b802838bd5a68e1b023fed31934b28f762d10343ed399cdcd57d8ee6cb853aa022ee8d9f153aee
-  data.tar.gz: af71452c0b87834ba674960dbf8dc08e7110b4cb76237973600a31aefc998337f3991d4282ff000d0a0b91df407f6228a515fa79bf9352bdcf3ae591de566745
+  metadata.gz: 8bd87b429c301c7d2d66b466bc49e455b99ffcf7b888ddb658df992830cd250c1634ff3d6de0afb8cfa11fc4f10fcd62012522c4004a380f4acc6a05a67c93cf
+  data.tar.gz: 5ac7b6bd0cb73e0a1d8f65bd34173f6ecd2d5d2391201a6dc6b2aabe14653b840e7a2eb69d947bb2ca06271207a0e4ebde785070f0b1156a4fb5913a48c314fe

data/README.md

@@ -46,7 +46,7 @@ You can add recoverable to your class by simply extending the Gem and then telli
 
   end
 ```
-With the above configuration any instance of `Foo` will recover any `StandardError` on `#bar` and retry 2 times without a sleep between retries. After the second retry it will raise the error `Recoverable::RetryCountExceeded` along with the information about what error had occured.
+With the above configuration any instance of `Foo` will recover any `StandardError` on `#bar` and retry 2 times without a wait between retries. After the second retry it will raise the error `Recoverable::RetryCountExceeded` along with the information about what error had occured.
 
 ### Configuration Options
 
@@ -76,14 +76,14 @@ Recoverable can rescue on a collection of errors as well, however these must be
 ```
 In the above case both `CustomError` and `OtherCustomError` will be rescued on the `#bar` method.
 
-#### Sleep
+#### Wait
 
-Setting up your class with the following configuration will insert a 3 second sleep command between each retry:
+Setting up your class with the following configuration will insert a 3 second wait(utilizing ruby Kernel#sleep) between each retry:
 
 ```ruby
   class Foo
     extend Recoverable
-    recover :bar, tries: 2, sleep: 3
+    recover :bar, tries: 2, wait: 3
 
     def bar
       baz
@@ -92,9 +92,21 @@ Setting up your class with the following configuration will insert a 3 second sl
   end
 ```
 
+You can override the implementation of wait at the configuration level by including a proc that takes an integer argument:
+```ruby
+   recover :bar, tries: 2, wait: 3, wait_method: Proc.new{ |int| "Another implementation utilizing wait time" }
+```
+
+Additionally you can globally override the default wait implementation in an initializer by setting the default wait method:
+```ruby
+  Recoverable::Defaults.wait_method = Proc.new|int| 
+    #Do something else with wait time here....
+  end
+```
+
 #### Custom Exception
 
-In addition to retrying, recoverable allows you to raise a custom exception after the rescue and retry attempts.
+In addition to retrying, recoverable allows you to throw a custom exception after the rescue and retry attempts.
 
 ```ruby
 
@@ -102,7 +114,7 @@ In addition to retrying, recoverable allows you to raise a custom exception afte
 
   class Foo
     extend Recoverable
-    recover :bar, tries: 2, custom_exception: MyException
+    recover :bar, tries: 2, throw: MyException
 
     def bar
       baz
@@ -135,6 +147,125 @@ Recoverable also allows you to configure a custom error handling method. This sh
 Please note that the name of the handler method should be passed to the configuration as a symbol. Also, the handler method can take either no arguments or a single keyword argument for `error:` if you would like access to the error inside the handler. Any other data inside the handler should be retrieved via instance methods or instance variables.
 
 
+### Inheritence
+
+One of the more powerful aspects of the recoverable implementation is how it handles inheritence.
+
+In the following example, recoverable is setup on the `#bar` method which is defined on both the parent and child class.
+
+```ruby
+  class ParentClass
+    extend Recoverable
+    recover :bar, tries: 2
+    def bar
+      baz
+    end
+
+  end
+
+  class ChildClass < ParentClass
+    def bar
+      super
+    end
+
+    def baz; end
+  end
+
+```
+
+Now any call to bar that results in an error registered with the recoverable gem will be rescued and retried based on the configuration as long as the error occurs in the parent scope.
+
+However in the following case the recoverable gem will rescue the error at the child level even though the error occurs in the parent class:
+
+```ruby
+  class ParentClass
+    def bar
+      baz
+    end
+
+  end
+
+  class ChildClass < ParentClass
+    extend Recoverable
+    recover :bar, tries: 2
+    def bar
+      super
+    end
+
+    def baz; end
+  end
+
+```
+
+The gem will rescue down through multiple inheritence as well:
+
+```ruby
+  class ParentClass
+    extend Recoverable
+    recover :bar, tries: 2
+    def bar
+      baz
+    end
+
+  end
+
+  class ChildClass < ParentClass
+    def baz; end
+  end
+
+  class SubChildClass < ChildClass
+    def bar
+      super
+    end
+  end
+```
+In the above, a call to the subchild class will throw an error that will be caught and retried by the recoverable configuration in the top level parent class
+
+Lastly, error handler methods can be defined on either the parent or child class. For example, assuming that the method `bar` is called from a `ChildClass` instance, in the first example below the `handle_error` method will be called from the `ParentClass`
+
+```ruby
+ class ParentClass
+    extend Recoverable
+    recover :bar, tries: 2, custom_handler: :handle_error
+
+    def bar
+      baz
+    end
+
+    def handle_error(error:)
+      "Parent Handler!"
+    end
+  end
+
+  class ChildClass < ParentClass
+    def baz; end
+  end
+```
+However, in the next example, the same configuration would call the `handle_error` method from the `ChildClass` instance.
+
+```ruby
+class ParentClass
+  extend Recoverable
+  recover :bar, tries: 2, custom_handler: :handle_error
+
+  def bar
+    baz
+  end
+
+  def handle_error(error:)
+    "Parent Handler!"
+  end
+
+end
+
+class ChildClass < ParentClass
+  def baz; end
+
+  def handle_error(error:)
+    "Child Handler!"
+  end
+end
+```
 ## How to contribute
 
 * Fork the project

data/lib/recoverable/version.rb

@@ -1,3 +1,3 @@
 module Recoverable
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/recoverable_spec.rb

@@ -390,7 +390,7 @@ RSpec.describe Recoverable do
     context 'Configuring recoverable on child class' do
       class self::TestParentClass
         def bar
-          baz
+          qux
         end
       end
 

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: recoverable
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Ben Jacobs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-13 00:00:00.000000000 Z
+date: 2018-11-15 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: her
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.10.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.10.1
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement