rescue_registry 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 528eb94a1296262f6cb1d20d7b8209072147c72e392dabb468fdbb0d2e4d9f43
-  data.tar.gz: 296ea4a7f1a08fa3fbd981c1ec08e35e528befc17b4167a51b5cdcd480783229
+  metadata.gz: abb4709b529437899b1f600805b3218d82581ba88c03642561d015385776dee3
+  data.tar.gz: 1f3efb50ac2375c0b204bb8af849615922f48d74c2eb06179a72bef6ce101754
 SHA512:
-  metadata.gz: 076d737ba7c477015a3b984e34d2c3782b56688d039db35b27d9cf8d89b682755e1a01c0cae34996ab63ed1fdf2a6e20c8b945d8f1b84c1a5a196f002b060b6c
-  data.tar.gz: 46c7d35672ecb8d4f04b5d2cad6f4d9844ef3d6d5600c6ba2eaa090a638c2bce77f180163523c5bda7ca646db6355f172ce70da996bc9fbc5b9f6d9b4bcf7191
+  metadata.gz: b3025ac89186c93d3d16eea9f1aa4039955d4527eefbeccc939f7501753ad3f9ea306ebc3e705009ee06e9bfd928db5521643d159646e54c271642a2c9e358f0
+  data.tar.gz: f3df89c3ea0204a2388b6ccd40deb6d4061586207dc8dca97b2475b07027e28a1db19574741487fb439e7c755bf5d79c9c3f687d4ac20663b5bf2d32b5995b41

data/CHANGELOG.md

@@ -7,4 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
-No releases means no changes...
+## [0.2.0] - 2019-05-21
+### Added
+- Support for non-Rails applications.
+### Changed
+- Passthrough statuses are currently only support for Rails applications.
+- Added a new Rails middleware for handling the current context.
+### Fixed
+- Registry is now properly inherited so that new registrations in subclasses do not affect the parent.
+- Default exception handler now works property in the root context.
+
+## [0.1.0] - 2019-05-15
+### Added
+- Everything, it's the first release!

data/lib/rescue_registry.rb

@@ -3,11 +3,15 @@
 require 'active_support'
 
 module RescueRegistry
+  autoload :ActionDispatch,        "rescue_registry/action_dispatch"
+  autoload :Context,               "rescue_registry/context"
   autoload :Controller,            "rescue_registry/controller"
   autoload :ExceptionsApp,         "rescue_registry/exceptions_app"
   autoload :ExceptionHandler,      "rescue_registry/exception_handler"
   autoload :RailsExceptionHandler, "rescue_registry/exception_handler"
   autoload :Registry,              "rescue_registry/registry"
+  autoload :ResetContext,          "rescue_registry/reset_context"
+  autoload :ShowExceptions,        "rescue_registry/show_exceptions"
 
   class HandlerNotFound < StandardError; end
 
@@ -43,9 +47,16 @@ module RescueRegistry
   end
 end
 
+ActiveSupport.on_load(:before_initialize) do
+  ActionDispatch::ExceptionWrapper.singleton_class.prepend RescueRegistry::ActionDispatch::ExceptionWrapper
+  ActionDispatch::DebugExceptions.prepend RescueRegistry::ActionDispatch::DebugExceptions
+  ActionDispatch::ShowExceptions.prepend RescueRegistry::ActionDispatch::ShowExceptions
+end
+
 ActiveSupport.on_load(:action_controller) do
   include RescueRegistry::Controller
 end
 
-require 'rescue_registry/action_dispatch'
-require 'rescue_registry/railtie'
+if defined?(Rails)
+  require 'rescue_registry/railtie'
+end

data/lib/rescue_registry/action_dispatch.rb

@@ -1,71 +1,7 @@
-require 'action_dispatch'
-
-ActionDispatch::ExceptionWrapper.class_eval do
-  class << self
-    alias_method :status_code_for_exception_without_rescue_registry, :status_code_for_exception
-    def status_code_for_exception(class_name)
-      RescueRegistry.status_code_for_exception(class_name) ||
-        status_code_for_exception_without_rescue_registry(class_name)
-    end
-  end
-end
-
-# Since this is for debugging only it's less critical to make changes here. The main area that matters is
-# returning the correct status code. Since all this code relies upon the ExceptionWrapper which we've monkeypatched,
-# it should work correctly without changes. However, we can provide more details in some areas so we hook in for that.
-ActionDispatch::DebugExceptions.class_eval do
-  private
-
-  # `#log_error`
-  # TODO: We may be able to add more information, though the details remain to be determined
-
-  # `#render_for_browser_request`
-  # TODO: We may be able to add more information, though the details remain to be determined
-
-  # This would work without changes, but the formatting would be incorrect. Since it's for debugging only,
-  # we could choose to ignore it, but the detailed information would definitely be useful.
-  alias_method :render_for_api_request_without_rescue_registry, :render_for_api_request
-  def render_for_api_request(content_type, wrapper)
-    response = nil
-
-    if RescueRegistry.handles_exception?(wrapper.exception)
-      # Ideally `render_for_api_request` would be split up so we could avoid some duplication in RescueRegistry
-      begin
-        response = RescueRegistry.response_for_debugging(content_type, wrapper.exception, traces: wrapper.traces)
-      rescue Exception => e
-        # Replace the original exception (still available via `cause`) and let it get handled with default handlers
-        wrapper = ActionDispatch::ExceptionWrapper.new(wrapper.backtrace_cleaner, e)
-      end
-    end
-
-    if response
-      render(*response)
-    else
-      # One of the following is true:
-      # - No handler for the exception
-      # - No response for content_type
-      # - An exception while generating the response
-      # In any case, we go with the default here.
-      render_for_api_request_without_rescue_registry(content_type, wrapper)
-    end
-  end
-end
-
-ActionDispatch::ShowExceptions.class_eval do
-  # @private
-  alias_method :initialize_without_rescue_registry, :initialize
-
-  # @private
-  def initialize(*args)
-    initialize_without_rescue_registry(*args)
-    @exceptions_app = RescueRegistry::ExceptionsApp.new(@exceptions_app)
-  end
-
-  alias_method :call_without_rescue_registry, :call
-  def call(*args)
-    warn "Didn't expect RescueRegistry context to be set in middleware" if RescueRegistry.context
-    call_without_rescue_registry(*args)
-  ensure
-    RescueRegistry.context = nil
+module RescueRegistry
+  module ActionDispatch
+    autoload :DebugExceptions,  "rescue_registry/action_dispatch/debug_exceptions"
+    autoload :ExceptionWrapper, "rescue_registry/action_dispatch/exception_wrapper"
+    autoload :ShowExceptions,   "rescue_registry/action_dispatch/show_exceptions"
   end
 end

data/lib/rescue_registry/action_dispatch/debug_exceptions.rb

@@ -0,0 +1,43 @@
+module RescueRegistry
+  module ActionDispatch
+    # Since this is for debugging only it's less critical to make changes here. The main area that matters is
+    # returning the correct status code. Since all this code relies upon the ExceptionWrapper which we've monkeypatched,
+    # it should work correctly without changes. However, we can provide more details in some areas so we hook in for that.
+    module DebugExceptions
+      private
+
+      # `#log_error`
+      # TODO: We may be able to add more information, though the details remain to be determined
+
+      # `#render_for_browser_request`
+      # TODO: We may be able to add more information, though the details remain to be determined
+
+      # This would work without changes, but the formatting would be incorrect. Since it's for debugging only,
+      # we could choose to ignore it, but the detailed information would definitely be useful.
+      def render_for_api_request(content_type, wrapper)
+        response = nil
+
+        if RescueRegistry.handles_exception?(wrapper.exception)
+          # Ideally `render_for_api_request` would be split up so we could avoid some duplication in RescueRegistry
+          begin
+            response = RescueRegistry.response_for_debugging(content_type, wrapper.exception, traces: wrapper.traces)
+          rescue Exception => e
+            # Replace the original exception (still available via `cause`) and let it get handled with default handlers
+            wrapper = ActionDispatch::ExceptionWrapper.new(wrapper.backtrace_cleaner, e)
+          end
+        end
+
+        if response
+          render(*response)
+        else
+          # One of the following is true:
+          # - No handler for the exception
+          # - No response for content_type
+          # - An exception while generating the response
+          # In any case, we go with the default here.
+          super(content_type, wrapper)
+        end
+      end
+    end
+  end
+end

data/lib/rescue_registry/action_dispatch/exception_wrapper.rb

@@ -0,0 +1,9 @@
+module RescueRegistry
+  module ActionDispatch
+    module ExceptionWrapper
+      def status_code_for_exception(class_name)
+        RescueRegistry.status_code_for_exception(class_name, passthrough: false) || super
+      end
+    end
+  end
+end

data/lib/rescue_registry/action_dispatch/show_exceptions.rb

@@ -0,0 +1,17 @@
+module RescueRegistry
+  module ActionDispatch
+    module ShowExceptions
+      def initialize(*args)
+        super
+        @exceptions_app = RescueRegistry::ExceptionsApp.new(@exceptions_app)
+      end
+
+      def call(*args)
+        warn "Didn't expect RescueRegistry context to be set in middleware" if RescueRegistry.context
+        super
+      ensure
+        RescueRegistry.context = nil
+      end
+    end
+  end
+end

data/lib/rescue_registry/context.rb

@@ -0,0 +1,37 @@
+module RescueRegistry
+  module Context
+    extend ActiveSupport::Concern
+
+    included do
+      if respond_to?(:class_attribute)
+        # Prevents subclasses from sharing, but only available to classes
+        class_attribute :rescue_registry
+      else
+        # Allows this module to be included in a module
+        mattr_accessor :rescue_registry
+      end
+
+      self.rescue_registry = Registry.new(self)
+
+      class << self
+        delegate :register_exception, to: :rescue_registry
+      end
+    end
+
+    def rescue_registry
+      self.class.rescue_registry
+    end
+
+    class_methods do
+      def inherited(subklass)
+        super
+        subklass.rescue_registry = rescue_registry.dup
+        subklass.rescue_registry.owner = subklass
+      end
+
+      def default_exception_handler
+        ExceptionHandler
+      end
+    end
+  end
+end

data/lib/rescue_registry/controller.rb

@@ -3,16 +3,7 @@ module RescueRegistry
     extend ActiveSupport::Concern
 
     included do
-      cattr_accessor :rescue_registry
-      self.rescue_registry = Registry.new(self)
-
-      class << self
-        delegate :register_exception, to: :rescue_registry
-      end
-    end
-
-    def rescue_registry
-      self.class.rescue_registry
+      include Context
     end
 
     def process_action(*args)
@@ -32,17 +23,5 @@ module RescueRegistry
 
       super
     end
-
-    class_methods do
-      def inherited(subklass)
-        super
-        subklass.rescue_registry = rescue_registry.dup
-        subklass.rescue_registry.owner = subklass
-      end
-
-      def default_exception_handler
-        ExceptionHandler
-      end
-    end
   end
 end

data/lib/rescue_registry/exception_handler.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module RescueRegistry
   class ExceptionHandler
     def self.default_status
@@ -8,11 +10,7 @@ module RescueRegistry
     def initialize(exception, **options)
       @exception = exception
 
-      status = options[:status]
-      if status == :passthrough
-        status = ActionDispatch::ExceptionWrapper.status_code_for_exception_without_rescue_registry(exception.class.name)
-      end
-      @status = status
+      @status = options[:status]
 
       @title = options[:title]
 
@@ -46,10 +44,14 @@ module RescueRegistry
         when Proc
           @detail.call(exception)
         else
-          @detail.try(:to_s)
+          if @detail.respond_to?(:to_s)
+            val = @detail.to_s
+            # Don't return empty string
+            val.empty? ? nil : val
+          end
         end
 
-      detail.presence || default_detail_for_status
+      detail || default_detail_for_status
     end
 
     def meta
@@ -83,20 +85,25 @@ module RescueRegistry
       }
     end
 
-    def formatted_response(content_type, fallback: :json, **options)
+    # `content_type` should be an object with:
+    #   * `to_sym` returning sane name for the content_type (e.g. :jsonapi, :json, :xml, :html)
+    #   * `to_s` returning the content_type string (e.g. "application/vnd.api+json", "application/json", "text/xml", "text/html")
+    def formatted_response(content_type, fallback: :none, **options)
       body = build_payload(**options)
 
       # TODO: Maybe make a helper to register these types?
-      to_format = content_type == :jsonapi ? "to_json" : "to_#{content_type.to_sym}"
+      to_format = content_type.to_sym == :jsonapi ? "to_json" : "to_#{content_type.to_sym}"
 
       if content_type && body.respond_to?(to_format)
         formatted_body = body.public_send(to_format)
         format = content_type
       else
-        if fallback == :json
+        case fallback.to_sym
+        when :json
           formatted_body = body.to_json
-          format = Mime[:json]
-        elsif fallback == :none
+          # FIXME: This won't work without Rails
+          format = fallback
+        when :none
           return nil
         else
           raise ArgumentError, "unknown fallback=#{fallback}"

data/lib/rescue_registry/exceptions_app.rb

@@ -5,7 +5,7 @@ module RescueRegistry
     end
 
     def call(env)
-      request = ActionDispatch::Request.new(env)
+      request = ::ActionDispatch::Request.new(env)
       exception = request.get_header "action_dispatch.exception"
 
       if RescueRegistry.handles_exception?(exception)
@@ -15,20 +15,23 @@ module RescueRegistry
           content_type = Mime[:text]
         end
 
-        if (response = RescueRegistry.response_for_public(content_type, exception))
-          status, body, format = response
+        response = RescueRegistry.response_for_public(content_type, exception)
+      end
 
-          if request.path_info != "/#{status}"
-            warn "status mismatch; path_info=#{request.path_info}; status=#{status}"
-          end
+      if response
+        status, body, format = response
 
-          [status, { "Content-Type" => "#{format}; charset=#{ActionDispatch::Response.default_charset}",
-            "Content-Length" => body.bytesize.to_s }, [body]]
-        else
-          # If we have no response, it means we couldn't render for the content_type, use the default handler instead
-          @app.call(env)
+        if request.path_info != "/#{status}"
+          warn "status mismatch; path_info=#{request.path_info}; status=#{status}"
         end
+
+        [status, { "Content-Type" => "#{format}; charset=#{::ActionDispatch::Response.default_charset}",
+          "Content-Length" => body.bytesize.to_s }, [body]]
       else
+        # If we have no response, it means one of the following:
+        # * RescueRegistry doesn't handle this exception
+        # * RescueRegistry doesn't have a response to render for this content_type.
+        # In either case, we use the default handler instead
         @app.call(env)
       end
     end

data/lib/rescue_registry/railtie.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
-require 'rails/railtie'
-
 module RescueRegistry
   class Railtie < Rails::Railtie
+    initializer "rescue_registry.add_middleware" do |app|
+      # We add this middleware to ensure that the RescueRegistry.context is properly handled.
+      # The context is set in the controller action and will be available until the Middleware
+      # returns. Any middleware that are before this one will not have access to the context.
+      app.middleware.insert_before ::ActionDispatch::ShowExceptions, RescueRegistry::ResetContext
+    end
   end
 end

data/lib/rescue_registry/registry.rb

@@ -3,7 +3,7 @@ module RescueRegistry
     attr_accessor :owner
 
     def initialize(owner)
-      @owner = self
+      @owner = owner
       @handlers = { }
     end
 
@@ -11,16 +11,28 @@ module RescueRegistry
       @handlers = @handlers.dup
     end
 
+    def passthrough_allowed?
+      defined?(ActionDispatch::ExceptionWrapper)
+    end
+
+    def passthrough_status(exception)
+      ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
+    end
+
     # TODO: Support a shorthand for handler
     def register_exception(exception_class, handler: nil, **options)
       raise ArgumentError, "#{exception_class} is not an Exception" unless exception_class <= Exception
 
-      handler ||= owner.try(:default_exception_handler)
+      if owner.respond_to?(:default_exception_handler)
+        handler ||= owner.default_exception_handler
+      end
       raise ArgumentError, "handler must be provided" unless handler
 
       status = options[:status] ||= handler.default_status
       raise ArgumentError, "status must be provided" unless status
-      raise ArgumentError, "invalid status: #{status}" unless status.is_a?(Integer) || status == :passthrough
+      unless status.is_a?(Integer) || (passthrough_allowed? && status == :passthrough)
+        raise ArgumentError, "invalid status: #{status}"
+      end
 
       # TODO: Validate options here
 
@@ -33,20 +45,27 @@ module RescueRegistry
       raise HandlerNotFound, "no handler found for #{exception.class}" unless handler_info
 
       handler_class, handler_options = handler_info
+
+      if handler_options[:status] == :passthrough
+        handler_options = handler_options.merge(status: passthrough_status(exception))
+      end
+
       handler_class.new(exception, **handler_options)
     end
 
     def handles_exception?(exception)
-      handler_info_for_exception(exception).present?
+      !handler_info_for_exception(exception).nil?
     end
 
-    def status_code_for_exception(exception)
+    def status_code_for_exception(exception, passthrough: true)
       _, options = handler_info_for_exception(exception)
       return unless options
 
-      # Return no code for passthrough.
-      # Alternatively we could handle this explicitly in the ExceptionWrapper monkeypatch.
-      options[:status] == :passthrough ? nil : options[:status]
+      if options[:status] == :passthrough
+        passthrough ? passthrough_status(exception) : nil
+      else
+        options[:status]
+      end
     end
 
     def build_response(content_type, exception, **options)
@@ -54,12 +73,12 @@ module RescueRegistry
       handler.formatted_response(content_type, **options)
     end
 
-    def response_for_debugging(content_type, exception, traces: nil)
-      build_response(content_type, exception, show_details: true, traces: traces)
+    def response_for_debugging(content_type, exception, traces: nil, fallback: :none)
+      build_response(content_type, exception, show_details: true, traces: traces, fallback: fallback)
     end
 
-    def response_for_public(content_type, exception)
-      build_response(content_type, exception, fallback: :none)
+    def response_for_public(content_type, exception, fallback: :none)
+      build_response(content_type, exception, fallback: fallback)
     end
 
     private

data/lib/rescue_registry/reset_context.rb

@@ -0,0 +1,14 @@
+module RescueRegistry
+  class ResetContext
+    def initialize(app)
+      @app = app
+    end
+
+    def call(*args)
+      warn "Didn't expect RescueRegistry context to already be set in middleware" if RescueRegistry.context
+      @app.call(*args)
+    ensure
+      RescueRegistry.context = nil
+    end
+  end
+end

data/lib/rescue_registry/show_exceptions.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# This is for use in non-Rails Rack apps. Rails apps will handle exceptions with
+# ActionDispatch::DebugExceptions and ActionDispatch::ShowExceptions
+module RescueRegistry
+  class ShowExceptions
+    # Unfortunately, Rail's nice mime types are in ActionDispatch which we'd rather not require
+    CONTENT_TYPES = {
+      jsonapi: "application/vnd.api+json",
+      json:    "application/json",
+      xml:     ["application/xml", "text/xml"],
+      plain:   "text/plain"
+    }
+
+    # Match Rail's Mime::Type API on a basic level
+    MimeType = Struct.new(:to_sym, :to_s)
+
+    def initialize(app, debug: false, content_types: CONTENT_TYPES)
+      @app = app
+      @content_types = content_types
+      @debug = debug
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      handle_exception(env, exception)
+    end
+
+    private
+
+    def handle_exception(env, exception)
+      if RescueRegistry.handles_exception?(exception)
+        accept = Rack::Utils.best_q_match(env["HTTP_ACCEPT"], @content_types.values.flatten)
+        accept ||= "text/plain"
+
+        symbol = CONTENT_TYPES.find { |(k,v)| Array(v).include?(accept) }.first
+        content_type = MimeType.new(symbol, accept)
+
+        # We need a fallback to ensure that we actually do render something. Outside of Rails, there's no situation where
+        # we would want to pass through on a handled exception.
+        fallback = MimeType.new(:json, CONTENT_TYPES[:json])
+        if @debug
+          response = RescueRegistry.response_for_debugging(content_type, exception, traces: { "Full Trace" => exception.backtrace }, fallback: fallback)
+        else
+          response = RescueRegistry.response_for_public(content_type, exception, fallback: fallback)
+        end
+      end
+
+      if response
+        status, body, format = response
+        [status, { "Content-Type" => "#{format}", "Content-Length" => body.bytesize.to_s }, [body]]
+      else
+        # Let next middleware handle
+        raise exception
+      end
+    end
+  end
+end

data/lib/rescue_registry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RescueRegistry
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,25 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: rescue_registry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Peter Wagenet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-15 00:00:00.000000000 Z
+date: 2019-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -72,34 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
-- !ruby/object:Gem::Dependency
-  name: rspec-rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.8'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.8'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -127,11 +93,17 @@ files:
 - Rakefile
 - lib/rescue_registry.rb
 - lib/rescue_registry/action_dispatch.rb
+- lib/rescue_registry/action_dispatch/debug_exceptions.rb
+- lib/rescue_registry/action_dispatch/exception_wrapper.rb
+- lib/rescue_registry/action_dispatch/show_exceptions.rb
+- lib/rescue_registry/context.rb
 - lib/rescue_registry/controller.rb
 - lib/rescue_registry/exception_handler.rb
 - lib/rescue_registry/exceptions_app.rb
 - lib/rescue_registry/railtie.rb
 - lib/rescue_registry/registry.rb
+- lib/rescue_registry/reset_context.rb
+- lib/rescue_registry/show_exceptions.rb
 - lib/rescue_registry/version.rb
 - lib/tasks/rescue_registry_tasks.rake
 homepage: https://github.com/wagenet/rescue_registry