actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_controller/metal/implicit_render.rb

@@ -1,19 +1,67 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 module ActionController
+  # # Action Controller Implicit Render
+  #
+  # Handles implicit rendering for a controller action that does not explicitly
+  # respond with `render`, `respond_to`, `redirect`, or `head`.
+  #
+  # For API controllers, the implicit response is always `204 No Content`.
+  #
+  # For all other controllers, we use these heuristics to decide whether to render
+  # a template, raise an error for a missing template, or respond with `204 No
+  # Content`:
+  #
+  # First, if we DO find a template, it's rendered. Template lookup accounts for
+  # the action name, locales, format, variant, template handlers, and more (see
+  # `render` for details).
+  #
+  # Second, if we DON'T find a template but the controller action does have
+  # templates for other formats, variants, etc., then we trust that you meant to
+  # provide a template for this response, too, and we raise
+  # ActionController::UnknownFormat with an explanation.
+  #
+  # Third, if we DON'T find a template AND the request is a page load in a web
+  # browser (technically, a non-XHR GET request for an HTML response) where you
+  # reasonably expect to have rendered a template, then we raise
+  # ActionController::MissingExactTemplate with an explanation.
+  #
+  # Finally, if we DON'T find a template AND the request isn't a browser page
+  # load, then we implicitly respond with `204 No Content`.
   module ImplicitRender
-    def send_action(method, *args)
-      ret = super
-      default_render unless performed?
-      ret
-    end
+    # :stopdoc:
+    include BasicImplicitRender
+
+    def default_render
+      if template_exists?(action_name.to_s, _prefixes, variants: request.variant)
+        render
+      elsif any_templates?(action_name.to_s, _prefixes)
+        message = "#{self.class.name}\##{action_name} is missing a template " \
+          "for this request format and variant.\n" \
+          "\nrequest.formats: #{request.formats.map(&:to_s).inspect}" \
+          "\nrequest.variant: #{request.variant.inspect}"
 
-    def default_render(*args)
-      render(*args)
+        raise ActionController::UnknownFormat, message
+      elsif interactive_browser_request?
+        message = "#{self.class.name}\##{action_name} is missing a template for request formats: #{request.formats.map(&:to_s).join(',')}"
+        raise ActionController::MissingExactTemplate.new(message, self.class, action_name)
+      else
+        logger.info "No template found for #{self.class.name}\##{action_name}, rendering head :no_content" if logger
+        super
+      end
     end
 
     def method_for_action(action_name)
       super || if template_exists?(action_name.to_s, _prefixes)
-        "default_render"
-      end
+                 "default_render"
+               end
     end
+
+    private
+      def interactive_browser_request?
+        request.get? && request.format == Mime[:html] && !request.xhr?
+      end
   end
 end

data/lib/action_controller/metal/instrumentation.rb

@@ -1,44 +1,32 @@
-require 'benchmark'
-require 'abstract_controller/logger'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "benchmark"
+require "abstract_controller/logger"
 
 module ActionController
-  # Adds instrumentation to several ends in ActionController::Base. It also provides
-  # some hooks related with process_action, this allows an ORM like Active Record
-  # and/or DataMapper to plug in ActionController and show related information.
+  # # Action Controller Instrumentation
+  #
+  # Adds instrumentation to several ends in ActionController::Base. It also
+  # provides some hooks related with process_action. This allows an ORM like
+  # Active Record and/or DataMapper to plug in ActionController and show related
+  # information.
   #
   # Check ActiveRecord::Railties::ControllerRuntime for an example.
   module Instrumentation
     extend ActiveSupport::Concern
 
     include AbstractController::Logger
-    include ActionController::RackDelegation
 
     attr_internal :view_runtime
 
-    def process_action(*args)
-      raw_payload = {
-        :controller => self.class.name,
-        :action     => self.action_name,
-        :params     => request.filtered_parameters,
-        :format     => request.format.try(:ref),
-        :method     => request.request_method,
-        :path       => (request.fullpath rescue "unknown")
-      }
-
-      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
-
-      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
-        begin
-          result = super
-          payload[:status] = response.status
-          result
-        ensure
-          append_info_to_payload(payload)
-        end
-      end
+    def initialize(...) # :nodoc:
+      super
+      self.view_runtime = nil
     end
 
-    def render(*args)
+    def render(*)
       render_output = nil
       self.view_runtime = cleanup_view_runtime do
         Benchmark.ms { render_output = super }
@@ -46,9 +34,9 @@ module ActionController
       render_output
     end
 
-    def send_file(path, options={})
+    def send_file(path, options = {})
       ActiveSupport::Notifications.instrument("send_file.action_controller",
-        options.merge(:path => path)) do
+        options.merge(path: path)) do
         super
       end
     end
@@ -59,8 +47,8 @@ module ActionController
       end
     end
 
-    def redirect_to(*args)
-      ActiveSupport::Notifications.instrument("redirect_to.action_controller") do |payload|
+    def redirect_to(*)
+      ActiveSupport::Notifications.instrument("redirect_to.action_controller", request: request) do |payload|
         result = super
         payload[:status]   = response.status
         payload[:location] = response.filtered_location
@@ -68,42 +56,66 @@ module ActionController
       end
     end
 
-  private
+    private
+      def process_action(*)
+        ActiveSupport::ExecutionContext[:controller] = self
 
-    # A hook invoked every time a before callback is halted.
-    def halted_callback_hook(filter)
-      ActiveSupport::Notifications.instrument("halted_callback.action_controller", :filter => filter)
-    end
+        raw_payload = {
+          controller: self.class.name,
+          action: action_name,
+          request: request,
+          params: request.filtered_parameters,
+          headers: request.headers,
+          format: request.format.ref,
+          method: request.request_method,
+          path: request.filtered_path
+        }
 
-    # A hook which allows you to clean up any time taken into account in
-    # views wrongly, like database querying time.
-    #
-    #   def cleanup_view_runtime
-    #     super - time_taken_in_something_expensive
-    #   end
-    #
-    # :api: plugin
-    def cleanup_view_runtime #:nodoc:
-      yield
-    end
+        ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload)
 
-    # Every time after an action is processed, this method is invoked
-    # with the payload, so you can add more information.
-    # :api: plugin
-    def append_info_to_payload(payload) #:nodoc:
-      payload[:view_runtime] = view_runtime
-    end
+        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
+          result = super
+          payload[:response] = response
+          payload[:status]   = response.status
+          result
+        rescue => error
+          payload[:status] = ActionDispatch::ExceptionWrapper.status_code_for_exception(error.class.name)
+          raise
+        ensure
+          append_info_to_payload(payload)
+        end
+      end
 
-    module ClassMethods
-      # A hook which allows other frameworks to log what happened during
-      # controller process action. This method should return an array
-      # with the messages to be added.
-      # :api: plugin
-      def log_process_action(payload) #:nodoc:
-        messages, view_runtime = [], payload[:view_runtime]
-        messages << ("Views: %.1fms" % view_runtime.to_f) if view_runtime
-        messages
+      # A hook invoked every time a before callback is halted.
+      def halted_callback_hook(filter, _)
+        ActiveSupport::Notifications.instrument("halted_callback.action_controller", filter: filter)
+      end
+
+      # A hook which allows you to clean up any time, wrongly taken into account in
+      # views, like database querying time.
+      #
+      #     def cleanup_view_runtime
+      #       super - time_taken_in_something_expensive
+      #     end
+      def cleanup_view_runtime # :doc:
+        yield
+      end
+
+      # Every time after an action is processed, this method is invoked with the
+      # payload, so you can add more information.
+      def append_info_to_payload(payload) # :doc:
+        payload[:view_runtime] = view_runtime
+      end
+
+      module ClassMethods
+        # A hook which allows other frameworks to log what happened during controller
+        # process action. This method should return an array with the messages to be
+        # added.
+        def log_process_action(payload) # :nodoc:
+          messages, view_runtime = [], payload[:view_runtime]
+          messages << ("Views: %.1fms" % view_runtime.to_f) if view_runtime
+          messages
+        end
       end
-    end
   end
 end