recoverable 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a004cdad4e2c84084abd80d9f768e76e68ef82e
-  data.tar.gz: 619f7e3dfb8ecb873afaa6f63c1daab89afa022c
+  metadata.gz: 8dea1219bb101ee0ff89ca0794c8a4c2648275c0
+  data.tar.gz: a82f71d6ade61164f07701c5c1bd26b375e235cb
 SHA512:
-  metadata.gz: 27fb6b8a72f506a7f19af2bafd2508a59bc61dd0582af89ab24105f7c36105c57ba42bcbbf8647d4104ad3a93ebb9cd90eef5e37094cdf8e9df0258cf90680f8
-  data.tar.gz: 0fb7fafc2453bbdbe8427acb02d904708c072fd78fe3c202e5ea587f4f064920640ae94bfccfaad1d2641ff37ddc27e3be9fc0a9dc978f943501ca60c359f6b8
+  metadata.gz: a425e9704da44b71696b128c71f4ff4b42934433335a214befc5467d887fb28ffd32f4cdd7757311ed7264a79707ec5a1b12ac2270be2378e9c8f85f6e54205a
+  data.tar.gz: affcc22857a7fffba3ddc96b326b9347429fd78e021ffca345ac99ca5b98f7bd69e393a443a282076b99b76503555746c14154d7f7831b58171da60eaed6b850

data/README.md

@@ -1,3 +1,8 @@
+[![Version      ](https://img.shields.io/gem/v/recoverable.svg?maxAge=2592000)](https://rubygems.org/gems/recoverable)
+[![Build Status ](https://travis-ci.com/Benjaminpjacobs/ship_station.svg)](https://travis-ci.com/Benjaminpjacobs/recoverable)
+[![Maintainability](https://api.codeclimate.com/v1/badges/dd436c45c8a52dc8c13c/maintainability)](https://codeclimate.com/github/Benjaminpjacobs/recoverable/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/dd436c45c8a52dc8c13c/test_coverage)](https://codeclimate.com/github/Benjaminpjacobs/recoverable/test_coverage)
+
 ## Recoverbale
 
 

data/lib/recoverable/base.rb

@@ -1,46 +1,69 @@
-module Retryable
-  RetryCountExceeded = Class.new(StandardError)
-
-  def recover(method, times, on: [StandardError], sleep: 1, handler: nil)
+module Recoverable
+  def recover(method_name, times: 1, on: StandardError, sleep: nil, custom_handler: nil, custom_exception: RetryCountExceeded)
     recoverable = Array.wrap(on)
-    proxy = create_proxy(method, times, recoverable, sleep, handler)
+    proxy       = create_proxy(method_name: method_name, times: times, recoverable: recoverable, sleep: sleep, custom_handler: custom_handler, custom_exception: custom_exception)
     self.prepend proxy
   end
 
-  def create_proxy(method, times, recoverable, sleep, handler)
+  def create_proxy(method_name:, times:, recoverable:, sleep:, custom_handler:, custom_exception:)
     Module.new do
-      define_method(method) do |*args|
-        retries = times.dup
+      define_method(method_name) do |*args|
         begin
           super *args
         rescue *recoverable => error
-          begin
-            sleep(sleep)
-            retries.next && retry
-          rescue StopIteration
-            if handler
-              handler_args = {}
-              unbound     = self.class.instance_method(handler)
-              req_params  = unbound.parameters.map{|p| p[1] if p[0] == :keyreq }.compact
-
-              return send(handler) if req_params.empty?
-
-              local_args = args.map(&:to_a).flatten(1).to_h
-              ivs        = instance_values.keys.map(&:to_sym)
-
-              req_params.each do |key|
-                handler_args[key] ||= eval(key.to_s)  if (ivs + public_methods + local_variables).include?(key)
-                handler_args[key] ||= local_args[key] if local_args.keys.include?(key)
-              end
-
-              send(handler, handler_args)
-            end
-            raise RetryCountExceeded, [error.class, error.message]
-          end
+          sleep(sleep) if sleep
+          retry        if (times -= 1) > 0
+          self.class.handle_exception(instance: self, custom_handler: custom_handler, args: args, error: error, custom_exception: custom_exception)
         end
       end
     end
   end
+
+  def handle_exception(instance:, custom_handler:, args:, error:, custom_exception: )
+    raise custom_exception.new(error) unless custom_handler
+    req_params = retrieve_required_parameters(instance, custom_handler)
+
+    return instance.send(custom_handler) if req_params.empty?
+
+    custom_handler_args = fetch_handler_args(args, instance, req_params, error)
+    instance.send(custom_handler, custom_handler_args)
+  end
+
+  def retrieve_required_parameters(instance, custom_handler)
+    unbound_method = instance.class.instance_method(custom_handler)
+    unbound_method.parameters.map{|p| p[1] if p[0] == :keyreq }.compact
+  end
+
+  def fetch_handler_args(args, instance, req_params, error)
+    custom_handler_args = {error: error}
+    local_args          = fetch_local_args(args)
+    evaluateables       = evaluateable_keys_on(instance)
+    generate_custom_handler_args(req_params: req_params, evaluateables: evaluateables, local_args: local_args, instance: instance, custom_handler_args: custom_handler_args)
+  end
+
+  def generate_custom_handler_args(req_params:, evaluateables:, local_args:, instance:, custom_handler_args:)
+    req_params.each do |key|
+      custom_handler_args[key]   = instance.send(:eval, key.to_s)  if evaluateables.include?(key)
+      custom_handler_args[key] ||= local_args[key] if local_args.keys.include?(key)
+    end
+
+    custom_handler_args
+  end
+
+  def fetch_instance_variables(instance)
+    instance.instance_values.keys.map(&:to_sym)
+  end
+
+  def fetch_local_args(args)
+    args.map(&:to_a).flatten(1).to_h
+  end
+
+  def evaluateable_keys_on(instance)
+    fetch_instance_variables(instance) +
+    instance.send(:public_methods) +
+    instance.send(:local_variables)
+  end
+  
 end
 
 

data/lib/recoverable/errors.rb

@@ -0,0 +1,7 @@
+module Recoverable
+  class RetryCountExceeded < StandardError
+    def initialize(error)
+      super error
+    end
+  end
+end

data/lib/recoverable/version.rb

@@ -1,3 +1,3 @@
 module Recoverable
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/recoverable.rb

@@ -3,6 +3,7 @@ require 'active_support/all'
 require 'logger'
 
 # App
+require 'recoverable/errors'
 require 'recoverable/base'
 
 # Models

data/spec/mocks/custom_error.rb

@@ -0,0 +1 @@
+class CustomError < StandardError; end

data/spec/mocks/foo.rb

@@ -0,0 +1,10 @@
+class Foo
+  extend Recoverable
+  
+  def bar
+    baz
+  end
+
+  def baz
+  end
+end

data/spec/mocks/unrecovered_error.rb

@@ -0,0 +1 @@
+class UnrecoveredError < StandardError; end

data/spec/recoverable_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+RSpec.describe Recoverable do
+  let!(:instance) { self.class::TestClass.new }
+  subject{ instance.bar }
+  context "passing no errors" do
+    class self::TestClass
+      extend Recoverable
+      recover :bar, times: 2
+
+      def bar; baz; end
+      def baz; end
+
+    end
+
+    it "defaults to standard error and no sleep" do
+      expect_any_instance_of(Kernel).to receive(:sleep).never
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(StandardError)
+      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+    end
+
+    it "recovers from inheritors of standard error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+    end
+
+  end
+
+  context "passing specific errors" do
+    class self::TestClass
+      extend Recoverable
+      recover :bar, times: 2, on: CustomError
+
+      def bar; baz; end
+      def baz; end
+
+    end
+
+    it "recovers from specific error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+    end
+
+    it "does not recover from different raised error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(UnrecoveredError)
+      expect{ subject }.to raise_error(UnrecoveredError)
+    end
+
+    it "does not recover from standard error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(StandardError)
+      expect{ subject }.to raise_error(StandardError)
+    end
+
+  end
+
+  context "passing specific sleep" do
+    class self::TestClass
+      extend Recoverable
+      recover :bar, times: 2, on: CustomError, sleep: 3
+
+      def bar; baz; end
+      def baz; end
+
+    end
+
+    it "recovers from specific error" do
+      expect_any_instance_of(Kernel).to receive(:sleep).with(3).exactly(2).times
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+      expect{ subject }.to raise_error(Recoverable::RetryCountExceeded)
+    end
+  end
+
+  context "passing custom error handler" do
+    class self::TestClass
+      extend Recoverable
+      recover :bar, times: 2, on: CustomError, custom_handler: :handle_error
+
+      def bar; baz; end
+      def baz; end
+      def handle_error
+        "Handled"
+      end
+
+    end
+
+    it "recovers from specific error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+      expect(subject).to eq("Handled")
+    end
+  end
+  
+  context "passing custom error handler with error message" do
+    class self::TestClass
+      extend Recoverable
+      recover :bar, times: 2, on: CustomError, custom_handler: :handle_error
+
+      def bar(arg:nil)
+        baz
+      end
+
+      def baz; end
+
+      def handle_error(error:)
+        error.message
+      end
+
+    end
+
+    subject { instance.bar(arg: "I'm a keyword Arg")}
+
+    it "recovers from specific error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError.new("Custom Error!"))
+      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+      expect(subject).to eq("Custom Error!")
+    end
+  end
+
+  context "passing custom error handler with arg" do
+    class self::TestClass
+      extend Recoverable
+      recover :bar, times: 2, on: CustomError, custom_handler: :handle_error
+
+      def bar(arg:nil)
+        baz
+      end
+
+      def baz; end
+
+      def handle_error(error:, arg:)
+        arg
+      end
+
+    end
+
+    subject { instance.bar(arg: "I'm a keyword Arg")}
+
+    it "recovers from specific error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+      expect(subject).to eq("I'm a keyword Arg")
+    end
+  end
+
+  context "passing custom error handler with a method call" do
+    class self::TestClass
+      extend Recoverable
+      recover :bar, times: 2, on: CustomError, custom_handler: :handle_error
+
+      def bar(arg:nil)
+        baz
+      end
+
+      def baz; end
+
+      def handle_error(error:)
+        "#{method_call}, #{private_method_call}"
+      end
+
+      def method_call
+        "I'm a method call"
+      end
+      private
+
+      def private_method_call
+        "I'm a private method call"
+      end
+
+    end
+
+    subject { instance.bar(arg: "I'm a keyword Arg")}
+
+    it "recovers from specific error" do
+      allow_any_instance_of(self.class::TestClass).to receive(:baz).and_raise(CustomError)
+      expect{ subject }.to_not raise_error(Recoverable::RetryCountExceeded)
+      expect(subject).to eq( "I'm a method call, I'm a private method call")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'bundler/setup'
+require 'simplecov'
+require 'pry'
+
+SimpleCov.start do
+  add_filter '/spec'
+end
+
+require 'recoverable'
+require 'mocks/foo'
+require 'mocks/custom_error'
+require 'mocks/unrecovered_error'
+require 'factory_bot'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+  config.include FactoryBot::Syntax::Methods
+
+  config.before(:suite) do
+    FactoryBot.find_definitions
+  end
+
+end
+
+RSpec::Expectations.configuration.on_potential_false_positives = :nothing

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: recoverable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ben Jacobs
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: Class Level retry DSL for ruby
 email:
 - benjaminpjacobs@gmail.com
@@ -105,7 +119,13 @@ files:
 - README.md
 - lib/recoverable.rb
 - lib/recoverable/base.rb
+- lib/recoverable/errors.rb
 - lib/recoverable/version.rb
+- spec/mocks/custom_error.rb
+- spec/mocks/foo.rb
+- spec/mocks/unrecovered_error.rb
+- spec/recoverable_spec.rb
+- spec/spec_helper.rb
 homepage: 
 licenses: []
 metadata:
@@ -130,4 +150,9 @@ rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
 summary: Class Level retry DSL for ruby
-test_files: []
+test_files:
+- spec/mocks/foo.rb
+- spec/mocks/custom_error.rb
+- spec/mocks/unrecovered_error.rb
+- spec/spec_helper.rb
+- spec/recoverable_spec.rb