fixup! add rescue_from :exception to truly rescue all exceptions

Author: Jelkster

CHANGELOG.md

@@ -2,7 +2,6 @@
 
 #### Features
 
-* [#1754](https://github.com/ruby-grape/grape/pull/1754): Added `rescue_from :exception` to truly rescue from all exceptions - [@jelkster](https://github.com/jelkster).
 * Your contribution here.
 
 #### Fixes
@@ -12,6 +11,7 @@
 * [#1749](https://github.com/ruby-grape/grape/pull/1749): Allow rescue from non-`StandardError` exceptions - [@dm1try](https://github.com/dm1try).
 * [#1750](https://github.com/ruby-grape/grape/pull/1750): Fix a circular dependency warning due to router being loaded by API - [@salasrod](https://github.com/salasrod).
 * [#1752](https://github.com/ruby-grape/grape/pull/1752): Fix `include_missing` behavior for aliased parameters - [@jonasoberschweiber](https://github.com/jonasoberschweiber).
+* [#1754](https://github.com/ruby-grape/grape/pull/1754): Allow rescue from non-`StandardError` exceptions to use default error handling - [@jelkster](https://github.com/jelkster).
 * Your contribution here.
 
 ### 1.0.2 (1/10/2018)

README.md

@@ -2083,14 +2083,6 @@ end
 This mimics [default `rescue` behaviour](https://ruby-doc.org/core/StandardError.html) when an exception type is not provided.
 Any other exception should be rescued explicitly, see [below](#exceptions-that-should-be-rescued-explicitly).
 
-In the event you want to truly rescue all exceptions, this can be done.
-
-```ruby
-class Twitter::API < Grape::API
-  rescue_from :exception
-end
-```
-
 Grape can also rescue from all exceptions and still use the built-in exception handing.
 This will give the same behavior as `rescue_from :all` with the addition that Grape will use the exception handling defined by all Exception classes that inherit `Grape::Exceptions::Base`.
 

lib/grape/dsl/request_response.rb

@@ -116,9 +116,6 @@ def rescue_from(*args, &block)
           elsif args.include?(:grape_exceptions)
             namespace_inheritable(:rescue_all, true)
             namespace_inheritable(:rescue_grape_exceptions, true)
-          elsif args.include?(:exception)
-            namespace_inheritable(:rescue_exception, true)
-            namespace_inheritable(:exception_rescue_handler, handler)
           else
             handler_type =
               case options[:rescue_subclasses]

lib/grape/endpoint.rb

@@ -285,14 +285,12 @@ def build_stack(helpers)
                 default_status: namespace_inheritable(:default_error_status),
                 rescue_all: namespace_inheritable(:rescue_all),
                 rescue_grape_exceptions: namespace_inheritable(:rescue_grape_exceptions),
-                rescue_exception: namespace_inheritable(:rescue_exception),
                 default_error_formatter: namespace_inheritable(:default_error_formatter),
                 error_formatters: namespace_stackable_with_hash(:error_formatters),
                 rescue_options: namespace_stackable_with_hash(:rescue_options) || {},
                 rescue_handlers: namespace_reverse_stackable_with_hash(:rescue_handlers) || {},
                 base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers) || {},
-                all_rescue_handler: namespace_inheritable(:all_rescue_handler),
-                exception_rescue_handler: namespace_inheritable(:exception_rescue_handler)
+                all_rescue_handler: namespace_inheritable(:all_rescue_handler)
 
       stack.concat namespace_stackable(:middleware)
 

lib/grape/middleware/error.rb

@@ -13,7 +13,6 @@ def default_options
           error_formatters: {},
           rescue_all: false, # true to rescue all exceptions
           rescue_grape_exceptions: false,
-          rescue_exception: false,
           rescue_subclasses: true, # rescue subclasses of exceptions listed
           rescue_options: {
             backtrace: false, # true to display backtrace, true to let Grape handle Grape::Exceptions
@@ -54,7 +53,6 @@ def find_handler(klass)
         handler = options[:rescue_handlers].find(-> { [] }) { |error, _| klass <= error }[1]
         handler ||= options[:base_only_rescue_handlers][klass]
         handler ||= options[:all_rescue_handler]
-        handler ||= options[:exception_rescue_handler]
 
         if handler.instance_of?(Symbol)
           raise NoMethodError, "undefined method `#{handler}'" unless respond_to?(handler)
@@ -68,9 +66,9 @@ def rescuable?(klass)
         return false if klass == Grape::Exceptions::InvalidVersionHeader
 
         if klass <= StandardError
-          rescue_all? || rescue_exception? || rescue_class_or_its_ancestor?(klass) || rescue_with_base_only_handler?(klass)
+          rescue_all? || rescue_class_or_its_ancestor?(klass) || rescue_with_base_only_handler?(klass)
         else
-          rescue_exception? || rescue_class_or_its_ancestor?(klass) || rescue_with_base_only_handler?(klass)
+          rescue_class_or_its_ancestor?(klass) || rescue_with_base_only_handler?(klass)
         end
       end
 
@@ -128,10 +126,6 @@ def rescue_all?
         options[:rescue_all]
       end
 
-      def rescue_exception?
-        options[:rescue_exception]
-      end
-
       def rescue_class_or_its_ancestor?(klass)
         (options[:rescue_handlers] || []).any? { |error, _handler| klass <= error }
       end

spec/grape/dsl/request_response_spec.rb

@@ -157,47 +157,6 @@ def self.imbue(key, value)
           end
         end
 
-        describe ':exception' do
-          it 'sets rescue_exception to true' do
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_exception, true)
-            expect(subject).to receive(:namespace_inheritable).with(:exception_rescue_handler, nil)
-            subject.rescue_from :exception
-          end
-
-          it 'sets given proc as rescue handler' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_exception, true)
-            expect(subject).to receive(:namespace_inheritable).with(:exception_rescue_handler, rescue_handler_proc)
-            subject.rescue_from :exception, rescue_handler_proc
-          end
-
-          it 'sets given block as rescue handler' do
-            rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_exception, true)
-            expect(subject).to receive(:namespace_inheritable).with(:exception_rescue_handler, rescue_handler_proc)
-            subject.rescue_from :exception, &rescue_handler_proc
-          end
-
-          it 'sets a rescue handler declared through :with option' do
-            with_block = -> { 'hello' }
-            expect(subject).to receive(:namespace_inheritable).with(:rescue_exception, true)
-            expect(subject).to receive(:namespace_inheritable).with(:exception_rescue_handler, an_instance_of(Proc))
-            subject.rescue_from :exception, with: with_block
-          end
-
-          it 'abort if :with option value is not Symbol, String or Proc' do
-            expect { subject.rescue_from :exception, with: 1234 }.to raise_error(ArgumentError, "with: #{integer_class_name}, expected Symbol, String or Proc")
-          end
-
-          it 'abort if both :with option and block are passed' do
-            expect do
-              subject.rescue_from :exception, with: -> { 'hello' } do
-                error!('bye')
-              end
-            end.to raise_error(ArgumentError, 'both :with option and block cannot be passed')
-          end
-        end
-
         describe 'list of exceptions is passed' do
           it 'sets hash of exceptions as rescue handlers' do
             expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, StandardError => nil)

spec/grape/middleware/exception_spec.rb

@@ -341,42 +341,4 @@ def app
       expect(last_response.body).to include('error', 'rain!', 'backtrace', 'original exception', 'RuntimeError')
     end
   end
-
-  context 'with rescue_exception' do
-    context 'StandardError raised' do
-      subject do
-        Rack::Builder.app do
-          use Spec::Support::EndpointFaker
-          use Grape::Middleware::Error, rescue_exception: true
-          run ExceptionSpec::ExceptionApp
-        end
-      end
-      it 'sets the message appropriately' do
-        get '/'
-        expect(last_response.body).to eq('rain!')
-      end
-      it 'defaults to a 500 status' do
-        get '/'
-        expect(last_response.status).to eq(500)
-      end
-    end
-
-    context 'Non-StandardError raised' do
-      subject do
-        Rack::Builder.app do
-          use Spec::Support::EndpointFaker
-          use Grape::Middleware::Error, rescue_exception: true
-          run ExceptionSpec::OtherExceptionApp
-        end
-      end
-      it 'sets the message appropriately' do
-        get '/'
-        expect(last_response.body).to eq('snow!')
-      end
-      it 'defaults to a 500 status' do
-        get '/'
-        expect(last_response.status).to eq(500)
-      end
-    end
-  end
 end