permittable 0.10.0 → 0.11.1

data/lib/permittable/error_envelope.rb

@@ -45,20 +45,74 @@ module Permittable
 
     def render_envelope(controller, message:, status:, code: nil, details: nil)
       if controller.respond_to?(:render_error)
-        # errors: only when there are details — a host may document its
-        # render_error contract as `(message:, status:, code:)`, and an
-        # unconditional errors: kwarg would break those implementations.
+        host = host_method(controller)
         kwargs = { message: message, code: code, status: status }
-        kwargs[:errors] = details if details
-        controller.render_error(**kwargs)
+        kwargs[:errors] = details if details && (host.nil? || takes_errors?(host))
+        host ? host.call(**kwargs) : controller.render_error(**kwargs)
       else
         error = { message: message }
         error[:code] = code if code
         error[:details] = details if details
-        controller.render(json: { success: false, error: error }, status: status)
+        # content_type: because `render json:` only supplies application/json
+        # when the response has none yet, and `respond_to` has already set the
+        # negotiated one (text/html for a browser form, or for `Accept: */*`
+        # with html listed first). Without it this JSON body goes out as HTML.
+        # A JSON type the response already carries (a registered
+        # application/vnd.api+json, say) is the host's choice and is kept.
+        options = { json: { success: false, error: error }, status: status }
+        options[:content_type] = "application/json" unless json_media_type?(response_media_type(controller))
+        controller.render(**options)
       end
     end
 
+    # The media type (no parameters) the response already carries, or nil when
+    # it has none yet or the host has no response to ask.
+    def response_media_type(controller)
+      return nil unless controller.respond_to?(:response)
+
+      response = controller.response
+      return nil unless response
+
+      type = response.respond_to?(:media_type) ? response.media_type : response.content_type
+      return nil unless type
+
+      type.to_s.split(";").first.to_s.strip.downcase
+    end
+
+    def json_media_type?(type)
+      !type.nil? && (type == "application/json" || type.end_with?("+json"))
+    end
+
+    # The Method for the host's render_error, or nil when the controller claims
+    # to respond (respond_to? is true) yet has no such method to inspect: one
+    # served by method_missing without respond_to_missing?. Master called it
+    # straight through with errors: included, and nil keeps doing exactly that
+    # rather than raising NameError out of the rescue_from handler.
+    def host_method(controller)
+      controller.method(:render_error)
+    rescue NameError
+      nil
+    end
+
+    # A rejection always carries details, so passing errors: whenever there
+    # are some passed it on every call — and a host documenting its contract
+    # as `(message:, status:, code:)`, which the README promises keeps
+    # working, raised ArgumentError out of the rescue_from handler: a 500 for
+    # every invalid request. errors: now goes only to a method that can take
+    # it: one naming it, taking **kwargs, or declaring no keywords at all
+    # (`*args`, which received it inside its trailing Hash before).
+    def takes_errors?(method)
+      parameters = method.parameters
+      return true if parameters.any? { |kind, _| kind == :keyrest }
+
+      names = keyword_names(parameters)
+      names.empty? || names.include?(:errors)
+    end
+
+    def keyword_names(parameters)
+      parameters.filter_map { |kind, name| name if %i[key keyreq].include?(kind) }
+    end
+
     # Members are emitted in the order RFC 9457 documents them, so the wire
     # format is stable and readable. `instance` is omitted rather than guessed
     # when the host cannot name the request path (a params duck, a job).