rescata 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6630bf8886b66cdfdac2d8bf50faeaf12c77c939
+  data.tar.gz: 301a28bfb6323f4661c03986760ecb6b07eb2839
+SHA512:
+  metadata.gz: c47d2249c54d3561923562e3f703bc80e56082111b4af19d552a9677ac35101cbff2921ed76bb3555ffe7032287fd4a95c73a51854315ca7a5d7493023a4405b
+  data.tar.gz: 47cceaa05f8533cb3a3b4d232a55220edaf93c091d68986ecb9436395bc73b2fea9ca4ed6aaaee8a899c3d19e9a8d363d9c050e74a62752fbd4291fc80397ca4

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Julio Lopez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,213 @@
+# rescata
+Microlibrary for rescue exceptions declaratively in your Ruby classes.
+
+Dry up your code from `begin... rescue... ensure.... end`
+
+## Installation
+
+Installing Rescata is as simple as running:
+
+```
+$ gem install rescata
+```
+
+Include Rescata in your Gemfile with gem 'rescata' or require it with require 'rescata'.
+
+## Usage
+
+### Rescuing from errors
+
+After include `Rescata`, you can rescue any error inherited from `StandardError` passing to `rescata` the method that you want to rescue if something is raised inside of it, and the method you want to execute(in `with` key) for rescue it(both method's names as symbols).
+
+```ruby
+class User
+  include Rescata
+  rescata :operation, with: :rescuing_operation
+
+  def operation
+    raise "some problem"
+  end
+
+  def rescuing_operation
+    "do_something"
+  end
+end
+
+# Next line execute :rescuing_operation if a raise is launched inside of operation
+# The error will be rescued
+puts User.new.operation
+#=> "do_something"
+```
+
+You can get the error instance if your method derived to rescue can receive an argument.
+
+```ruby
+class User
+  include Rescata
+  rescata :operation, with: :rescuing_operation
+
+  def operation
+    raise "a problem"
+  end
+
+  def rescuing_operation(e)
+    "is happening #{e.message}"
+  end
+end
+
+puts User.new.operation
+#=> "is happening a problem"
+```
+
+### Rescuing from an error class
+
+Also is possible rescue just from a particular error class, just use `in` key as a hash argument into `rescata` to make that possible.
+
+```ruby
+class User
+  include Rescata
+  rescata :operation, with: :rescuing_operation, in: ArgumentError
+  rescata :other_operation, with: :rescuing_operation, in: NameError
+
+  def operation
+    raise "a problem"
+  end
+
+  def other_operation
+    raise NameError, "other problem"
+  end
+
+  def rescuing_operation(e)
+    "is happening #{e.message}"
+  end
+end
+
+# This will be raise an error(in the example above we are just recuing 'operation' from ArgumentError)
+User.new.operation
+#=> RuntimeError: a problem
+
+# This will be rescued
+puts User.new.other_operation
+#=> "is happening other problem"
+```
+
+Send an array if you want to rescue for two or more class errors.
+
+```ruby
+class User
+  include Rescata
+  rescata :operation, with: :rescuing_operation, in: [NameError, ArgumentError]
+
+  def operation
+    raise ArgumentError, "a problem"
+  end
+
+  def rescuing_operation(e)
+    "is happening #{e.message}"
+  end
+end
+
+# This will be rescued because ArgumentError is included into the error classes specified
+puts User.new.operation
+#=> "is happening other problem"
+```
+
+### Rescuing using lambdas and blocks
+
+You can rescue a method using a lambda. Just add it into the `with` key(don't forget receive the error instance if you need it). Or use a block if you want.
+
+```ruby
+class User
+  include Rescata
+  # Rescuing using a lambda
+  rescata :operation, with: lambda{|e| "is happening #{e.message}" }
+
+  # Rescuing using a block
+  rescata :other_operation do |e|
+    "is happening #{e.message}"
+  end
+
+  def operation
+    raise "a problem"
+  end
+
+  def other_operation
+    raise "other problem"
+  end
+end
+
+# both methods will be rescued
+puts User.new.operation
+#=> "is happening a problem"
+
+puts User.new.other_operation
+#=> "is happening other problem"
+```
+
+Also you can still rescuing from particular errors using lambdas or blocks. This gives you freedom to build any custom solution to rescue for specific error classes.
+
+```ruby
+rescata :operation, with: :rescuing_operation, in: CustomError
+rescata :operation, with: lambda{|e| do_something }, in: RuntimeError
+rescata :operation, in: [ArgumentError, NameError] do |e|
+  do_something
+end
+```
+
+### Rescuing multiple methods at once
+
+Rescue from multiple methods in the same line sending them into an array as first variable of `rescata`.
+
+```ruby
+# Rescuing multiple methods in many ways
+rescata [:operation, :other_operation], with: :rescuing_operations
+rescata [:operation, :other_operation], with: lambda{|e| do_something }, in: CustomError
+rescata [:operation, :other_operation], in: [CustomError, NameError] do |e|
+  do_something
+end
+```
+
+### Ensuring
+
+And we haven't forgotten the ensure actions, you can ensure your methods using `ensuring` key as a hash argument into `rescata`, you can ensure from a method or a lambda, if you opt for lambda it will receive the instance of your class as a variable to do whatever you need.
+
+```ruby
+class User
+  attr_accessor :name
+
+  include Rescata
+  rescata :operation, with: :rescuing_operation, ensuring: :ensuring_method
+  rescata :other_operation, with: :rescuing_operation, ensuring: lambda{|instance| instance.name = "Piero" }
+
+  def initialize(name)
+    @name = name
+  end
+
+  def operation
+    raise "a problem"
+  end
+
+  def other_operation
+    raise "other problem"
+  end
+
+  def rescuing_operation
+    #do_something
+  end
+
+  def ensuring_method
+    @name = "Piero"
+  end
+end
+
+# Both methods will be rescued and executed its ensure actions
+u = User.new("Julio")
+u.operation
+puts u.name
+#=> "Piero"
+
+u = User.new("Julio")
+u.other_operation
+puts u.name
+#=> "Piero"
+```

data/lib/rescata.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2015 Julio Lopez
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+module Rescata
+  VERSION = "0.1.1"
+
+  def self.included(base)
+    class << base; attr_accessor :rescues; end
+    base.extend ClassMethods
+    base.rescues = {}
+  end
+
+  module ClassMethods
+    def rescata(methods, options = {}, &block)
+      error_classes = Array(options[:in])
+      error_classes.each do |klass|
+        raise ArgumentError, 'Error class must be an Exception or sub-class' if klass.is_a?(Class) ? (klass <= Exception).nil? : true
+      end
+
+      options[:with] = block if block_given?
+      raise ArgumentError, 'Rescuer is incorrectly, supply it like a Method or a Proc with a hash with key :with as an argument' unless options[:with] && (options[:with].is_a?(Symbol) || options[:with].is_a?(Proc))
+
+      Array(methods).each do |method_name|
+        rescues[method_name] ||= []
+        rescues[method_name] << {
+          rescuer: options[:with]
+        }.merge(options[:in] ? {error_class: error_classes} : {})
+        .merge(options[:ensuring] ? {ensurer: options[:ensuring]} : {})
+      end
+    end
+
+    def method_added(method_name)
+      return unless rescues && collection = rescues[method_name]
+      alias_method_name = :"rescuing_old_#{method_name}"
+      return if instance_methods.include?(alias_method_name)
+      alias_method alias_method_name, method_name
+      define_method method_name do
+        begin 
+          send(alias_method_name)
+        rescue => e
+          handler = collection.select{|i| i[:error_class] ? i[:error_class].include?(e.class) : true }.first
+          rescuer, error_classes, ensurer = handler[:rescuer], handler[:error_class], handler[:ensurer]
+          raise e if error_classes && !error_classes.include?(e.class)
+          case rescuer
+          when Symbol
+            method(rescuer).arity == 0 ? send(rescuer) : send(rescuer, e)
+          when Proc
+            rescuer.arity == 0 ? rescuer.call : rescuer.call(e)
+          end
+        ensure
+          ensurer.is_a?(Symbol) ? send(ensurer) : ensurer.call(self) if ensurer
+        end
+      end
+    end
+  end
+end

data/rescata.gemspec

@@ -0,0 +1,20 @@
+require "./lib/rescata"
+
+Gem::Specification.new do |s|
+  s.name              = "rescata"
+  s.version           = Rescata::VERSION
+  s.summary           = "Microlibrary for rescue exceptions declaratively in your Ruby classes."
+  s.description       = "Microlibrary for rescue exceptions declaratively in your Ruby classes."
+  s.authors           = ["Julio Lopez"]
+  s.email             = ["ljuliom@gmail.com"]
+  s.homepage          = "http://github.com/TheBlasfem/rescata"
+  s.files = Dir[
+    "LICENSE",
+    "README.md",
+    "lib/**/*.rb",
+    "*.gemspec",
+    "test/**/*.rb"
+  ]
+  s.license           = "MIT"
+  s.add_development_dependency "cutest", "1.1.3"
+end

data/test/test_rescata.rb

@@ -0,0 +1,516 @@
+require File.expand_path("../lib/rescata", File.dirname(__FILE__))
+
+scope do
+  test "raise if rescuer method is not sent" do
+    assert_raise(ArgumentError) do
+      Class.new do
+        include Rescata
+        rescata :get_talks
+      end
+    end
+  end
+
+  test "rescue an error with method" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks
+
+      def get_talks
+        raise "throwing an error!"
+      end
+
+      def rescue_get_talks
+        "rescued!"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued!"
+  end
+
+  test "rescue an error with method passing the error variable" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks
+
+      def get_talks
+        raise "i want"
+      end
+
+      def rescue_get_talks(e)
+        "rescued because #{e.message}"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued because i want"
+  end
+
+  test "raise if rescuer is not a method or a proc" do
+    assert_raise(ArgumentError) do
+      Class.new do
+        include Rescata
+        rescata :get_talks, with: "whatever"
+      end
+    end
+  end
+
+  test "raise if error class sent is not a class" do
+    assert_raise(ArgumentError) do
+      Class.new do
+        include Rescata
+        rescata :get_talks, with: :rescue_get_talks, in: "whatever"
+      end
+    end
+  end
+
+  test "raise if error class sent is not a Exception class or subclass" do
+    assert_raise(ArgumentError) do
+      Class.new do
+        include Rescata
+        rescata :get_talks, with: :rescue_get_talks, in: User
+      end
+    end
+  end
+
+  test "rescue from a class error" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, in: ArgumentError
+
+      def get_talks
+        raise ArgumentError
+      end
+
+      def rescue_get_talks
+        "rescued!"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued!"
+  end
+
+  test "rescue with method from a class error passing error variable" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, in: ArgumentError
+
+      def get_talks
+        raise ArgumentError, "i want"
+      end
+
+      def rescue_get_talks(e)
+        "rescued because #{e.message}"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued because i want"
+  end
+
+  test "raise if different class error raises" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, in: NameError
+
+      def get_talks
+        raise StandardError
+      end
+
+      def rescue_get_talks
+        "rescued!"
+      end
+    end
+
+    assert_raise(StandardError) do
+      User.new.get_talks
+    end
+  end
+
+  test "raise if error class sent in array is not a class" do
+    assert_raise(ArgumentError) do
+      Class.new do
+        include Rescata
+        rescata :get_talks, with: :rescue_get_talks, in: [NameError, "whatever"]
+      end
+    end
+  end
+
+  test "raise if error class sent in array is not a Exception class or subclass" do
+    assert_raise(ArgumentError) do
+      Class.new do
+        include Rescata
+        rescata :get_talks, with: :rescue_get_talks, in: [NameError, User]
+      end
+    end
+  end
+
+  test "rescue with method from a sent array of error classes" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, in: [NameError, ArgumentError]
+
+      def get_talks
+        raise ArgumentError
+      end
+
+      def rescue_get_talks
+        "rescued!"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued!"
+  end
+
+  test "raise if different class error raise from array of error classes" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, in: [NameError, ArgumentError]
+
+      def get_talks
+        raise StandardError
+      end
+
+      def rescue_get_talks
+        "rescued!"
+      end
+    end
+
+    assert_raise(StandardError) do
+      User.new.get_talks
+    end
+  end
+
+  test "rescue an error with proc" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: lambda{"rescued"}
+
+      def get_talks
+        raise "throwing an error"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued"
+  end
+
+  test "rescue an error with proc sending error variable" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: lambda{|e| "rescued because #{e.message}"}
+
+      def get_talks
+        raise "i want"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued because i want"
+  end
+
+  test "rescue with proc from a class error passing error variable" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: lambda{|e| "rescued because #{e.message}"}, in: ArgumentError
+
+      def get_talks
+        raise ArgumentError, "i want"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued because i want"
+  end
+
+  test "rescue with proc from a sent array of error classes" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: lambda{"rescued"}, in: [NameError, ArgumentError]
+
+      def get_talks
+        raise ArgumentError
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued"
+  end
+
+  test "rescue an error with block" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks do
+        "rescued"
+      end
+
+      def get_talks
+        raise "throwing an error"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued"
+  end
+
+  test "rescue an error with block sending error variable" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks do |e|
+        "rescued because #{e.message}"
+      end
+
+      def get_talks
+        raise "i want"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued because i want"
+  end
+
+  test "rescue with block from a class error passing error variable" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, in: ArgumentError do |e|
+        "rescued because #{e.message}"
+      end
+
+      def get_talks
+        raise ArgumentError, "i want"
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued because i want"
+  end
+
+  test "rescue with block from a sent array of error classes" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, in: [NameError, ArgumentError] do
+        "rescued"
+      end
+
+      def get_talks
+        raise ArgumentError
+      end
+    end
+
+    assert_equal User.new.get_talks, "rescued"
+  end
+
+  test "no screw up with child classes" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks
+
+      def get_talks
+        raise "OH NOOO"
+      end
+
+      def rescue_get_talks
+        "yep"
+      end
+    end
+
+    Student = Class.new(User) do
+      def demo
+        "hi"
+      end
+    end
+    
+    assert_equal Student.new.demo, "hi"
+  end
+
+  test "rescuing from method of parent class" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks
+
+      def get_talks
+        raise "OH NOOO"
+      end
+
+      def rescue_get_talks
+        "yep"
+      end
+    end
+
+    Student = Class.new(User)
+    assert_equal Student.new.get_talks, "yep"
+  end
+
+  test "rescuing multiples methods at once with a method" do
+    User = Class.new do
+      include Rescata
+      rescata [:get_talks, :other_method], with: :rescue_get_talks
+
+      def get_talks
+        raise "OH NOOO"
+      end
+
+      def other_method
+        raise "OH NOOO"
+      end
+
+      def rescue_get_talks
+        "yep"
+      end
+    end
+    assert_equal User.new.get_talks, "yep"
+    assert_equal User.new.other_method, "yep"
+  end
+
+  test "rescuing multiples methods at once with a method and particular class error" do
+    User = Class.new do
+      include Rescata
+      rescata [:get_talks, :other_method], with: :rescue_get_talks, in: ArgumentError
+
+      def get_talks
+        raise StandardError, "OH NOOO"
+      end
+
+      def other_method
+        raise ArgumentError, "OH NOOO"
+      end
+
+      def rescue_get_talks
+        "yep"
+      end
+    end
+
+    assert_raise(StandardError) do
+      User.new.get_talks
+    end
+    assert_equal User.new.other_method, "yep"
+  end
+
+  test "rescuing multiples methods at once with lambda and particular class error" do
+    User = Class.new do
+      include Rescata
+      rescata [:get_talks, :other_method], with: lambda{|e| "#{e.message} i want"}, in: ArgumentError
+
+      def get_talks
+        raise StandardError, "OH NOOO"
+      end
+
+      def other_method
+        raise ArgumentError, "raised because"
+      end
+    end
+
+    assert_raise(StandardError) do
+      User.new.get_talks
+    end
+    assert_equal User.new.other_method, "raised because i want"
+  end
+
+  test "rescuing multiples methods at once with block and particular class error" do
+    User = Class.new do
+      include Rescata
+      rescata [:get_talks, :other_method], in: ArgumentError do |e|
+        "#{e.message} i want"
+      end
+
+      def get_talks
+        raise StandardError, "OH NOOO"
+      end
+
+      def other_method
+        raise ArgumentError, "raised because"
+      end
+    end
+
+    assert_raise(StandardError) do
+      User.new.get_talks
+    end
+    assert_equal User.new.other_method, "raised because i want"
+  end
+
+  test "rescuing same method with multiple rescatas as first assert" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, in: StandardError
+      rescata :get_talks, with: :rescue_get_talks2, in: ArgumentError
+    
+      def get_talks
+        raise StandardError, "OH NOOO"
+      end
+
+      def rescue_get_talks
+        "yep"
+      end
+
+      def rescue_get_talks2
+        "yep2"
+      end
+    end
+
+    assert_equal User.new.get_talks, "yep"
+  end
+
+  test "rescuing same method with multiple rescatas as last assert" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, in: StandardError
+      rescata :get_talks, with: :rescue_get_talks2, in: ArgumentError
+    
+      def get_talks
+        raise ArgumentError, "OH NOOO"
+      end
+
+      def rescue_get_talks
+        "yep"
+      end
+
+      def rescue_get_talks2
+        "yep2"
+      end
+    end
+
+    assert_equal User.new.get_talks, "yep2"
+  end
+
+  test "ensure with a method" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, ensuring: :ensure_method
+      
+      attr_accessor :x
+      def initialize
+        @x = 1
+      end
+
+      def get_talks
+        raise "throwing an error!"
+      end
+
+      def rescue_get_talks
+        "rescued!"
+      end
+
+      def ensure_method
+        @x += 1
+      end
+    end
+
+    u = User.new
+    u.get_talks
+    assert_equal u.x, 2
+  end
+
+  test "ensure with a lambda" do
+    User = Class.new do
+      include Rescata
+      rescata :get_talks, with: :rescue_get_talks, ensuring: lambda{|u| u.x += 1 }
+      
+      attr_accessor :x
+      def initialize
+        @x = 1
+      end
+
+      def get_talks
+        raise "throwing an error!"
+      end
+
+      def rescue_get_talks
+        "rescued!"
+      end
+    end
+
+    u = User.new
+    u.get_talks
+    assert_equal u.x, 2
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: rescata
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Julio Lopez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cutest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+description: Microlibrary for rescue exceptions declaratively in your Ruby classes.
+email:
+- ljuliom@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/rescata.rb
+- rescata.gemspec
+- test/test_rescata.rb
+homepage: http://github.com/TheBlasfem/rescata
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Microlibrary for rescue exceptions declaratively in your Ruby classes.
+test_files: []