actionpack 3.2.22.5 → 5.2.4

data/lib/action_controller/metal/renderers.rb

@@ -1,6 +1,6 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/blank'
-require 'set'
+# frozen_string_literal: true
+
+require "set"
 
 module ActionController
   # See <tt>Renderers.add</tt>
@@ -8,40 +8,41 @@ module ActionController
     Renderers.add(key, &block)
   end
 
+  # See <tt>Renderers.remove</tt>
+  def self.remove_renderer(key)
+    Renderers.remove(key)
+  end
+
+  # See <tt>Responder#api_behavior</tt>
+  class MissingRenderer < LoadError
+    def initialize(format)
+      super "No renderer defined for format: #{format}"
+    end
+  end
+
   module Renderers
     extend ActiveSupport::Concern
 
-    included do
-      class_attribute :_renderers
-      self._renderers = Set.new.freeze
-    end
+    # A Set containing renderer names that correspond to available renderer procs.
+    # Default values are <tt>:json</tt>, <tt>:js</tt>, <tt>:xml</tt>.
+    RENDERERS = Set.new
 
-    module ClassMethods
-      def use_renderers(*args)
-        renderers = _renderers + args
-        self._renderers = renderers.freeze
-      end
-      alias use_renderer use_renderers
+    included do
+      class_attribute :_renderers, default: Set.new.freeze
     end
 
-    def render_to_body(options)
-      _handle_render_options(options) || super
-    end
+    # Used in <tt>ActionController::Base</tt>
+    # and <tt>ActionController::API</tt> to include all
+    # renderers by default.
+    module All
+      extend ActiveSupport::Concern
+      include Renderers
 
-    def _handle_render_options(options)
-      _renderers.each do |name|
-        if options.key?(name)
-          _process_options(options)
-          return send("_render_option_#{name}", options.delete(name), options)
-        end
+      included do
+        self._renderers = RENDERERS
       end
-      nil
     end
 
-    # Hash of available renderers, mapping a renderer name to its proc.
-    # Default keys are :json, :js, :xml.
-    RENDERERS = Set.new
-
     # Adds a new renderer to call within controller actions.
     # A renderer is invoked by passing its name as an option to
     # <tt>AbstractController::Rendering#render</tt>. To create a renderer
@@ -49,17 +50,16 @@ module ActionController
     # is the value paired with its key and the second is the remaining
     # hash of options passed to +render+.
     #
-    # === Example
     # Create a csv renderer:
     #
     #   ActionController::Renderers.add :csv do |obj, options|
     #     filename = options[:filename] || 'data'
     #     str = obj.respond_to?(:to_csv) ? obj.to_csv : obj.to_s
-    #     send_data str, :type => Mime::CSV,
-    #       :disposition => "attachment; filename=#{filename}.csv"
+    #     send_data str, type: Mime[:csv],
+    #       disposition: "attachment; filename=#{filename}.csv"
     #   end
     #
-    # Note that we used Mime::CSV for the csv mime type as it comes with Rails.
+    # Note that we used Mime[:csv] for the csv mime type as it comes with Rails.
     # For a custom renderer, you'll need to register a mime type with
     # <tt>Mime::Type.register</tt>.
     #
@@ -69,40 +69,112 @@ module ActionController
     #     @csvable = Csvable.find(params[:id])
     #     respond_to do |format|
     #       format.html
-    #       format.csv { render :csv => @csvable, :filename => @csvable.name }
-    #     }
+    #       format.csv { render csv: @csvable, filename: @csvable.name }
+    #     end
     #   end
-    # To use renderers and their mime types in more concise ways, see
-    # <tt>ActionController::MimeResponds::ClassMethods.respond_to</tt> and
-    # <tt>ActionController::MimeResponds#respond_with</tt>
     def self.add(key, &block)
-      define_method("_render_option_#{key}", &block)
+      define_method(_render_with_renderer_method_name(key), &block)
       RENDERERS << key.to_sym
     end
 
-    module All
-      extend ActiveSupport::Concern
-      include Renderers
+    # This method is the opposite of add method.
+    #
+    # To remove a csv renderer:
+    #
+    #   ActionController::Renderers.remove(:csv)
+    def self.remove(key)
+      RENDERERS.delete(key.to_sym)
+      method_name = _render_with_renderer_method_name(key)
+      remove_possible_method(method_name)
+    end
 
-      included do
-        self._renderers = RENDERERS
+    def self._render_with_renderer_method_name(key)
+      "_render_with_renderer_#{key}"
+    end
+
+    module ClassMethods
+      # Adds, by name, a renderer or renderers to the +_renderers+ available
+      # to call within controller actions.
+      #
+      # It is useful when rendering from an <tt>ActionController::Metal</tt> controller or
+      # otherwise to add an available renderer proc to a specific controller.
+      #
+      # Both <tt>ActionController::Base</tt> and <tt>ActionController::API</tt>
+      # include <tt>ActionController::Renderers::All</tt>, making all renderers
+      # available in the controller. See <tt>Renderers::RENDERERS</tt> and <tt>Renderers.add</tt>.
+      #
+      # Since <tt>ActionController::Metal</tt> controllers cannot render, the controller
+      # must include <tt>AbstractController::Rendering</tt>, <tt>ActionController::Rendering</tt>,
+      # and <tt>ActionController::Renderers</tt>, and have at least one renderer.
+      #
+      # Rather than including <tt>ActionController::Renderers::All</tt> and including all renderers,
+      # you may specify which renderers to include by passing the renderer name or names to
+      # +use_renderers+. For example, a controller that includes only the <tt>:json</tt> renderer
+      # (+_render_with_renderer_json+) might look like:
+      #
+      #   class MetalRenderingController < ActionController::Metal
+      #     include AbstractController::Rendering
+      #     include ActionController::Rendering
+      #     include ActionController::Renderers
+      #
+      #     use_renderers :json
+      #
+      #     def show
+      #       render json: record
+      #     end
+      #   end
+      #
+      # You must specify a +use_renderer+, else the +controller.renderer+ and
+      # +controller._renderers+ will be <tt>nil</tt>, and the action will fail.
+      def use_renderers(*args)
+        renderers = _renderers + args
+        self._renderers = renderers.freeze
+      end
+      alias use_renderer use_renderers
+    end
+
+    # Called by +render+ in <tt>AbstractController::Rendering</tt>
+    # which sets the return value as the +response_body+.
+    #
+    # If no renderer is found, +super+ returns control to
+    # <tt>ActionView::Rendering.render_to_body</tt>, if present.
+    def render_to_body(options)
+      _render_to_body_with_renderer(options) || super
+    end
+
+    def _render_to_body_with_renderer(options)
+      _renderers.each do |name|
+        if options.key?(name)
+          _process_options(options)
+          method_name = Renderers._render_with_renderer_method_name(name)
+          return send(method_name, options.delete(name), options)
+        end
       end
+      nil
     end
 
     add :json do |json, options|
       json = json.to_json(options) unless json.kind_of?(String)
-      json = "#{options[:callback]}(#{json})" unless options[:callback].blank?
-      self.content_type ||= Mime::JSON
-      json
+
+      if options[:callback].present?
+        if content_type.nil? || content_type == Mime[:json]
+          self.content_type = Mime[:js]
+        end
+
+        "/**/#{options[:callback]}(#{json})"
+      else
+        self.content_type ||= Mime[:json]
+        json
+      end
     end
 
     add :js do |js, options|
-      self.content_type ||= Mime::JS
+      self.content_type ||= Mime[:js]
       js.respond_to?(:to_js) ? js.to_js(options) : js
     end
 
     add :xml do |xml, options|
-      self.content_type ||= Mime::XML
+      self.content_type ||= Mime[:xml]
       xml.respond_to?(:to_xml) ? xml.to_xml(options) : xml
     end
   end

data/lib/action_controller/metal/rendering.rb

@@ -1,12 +1,32 @@
+# frozen_string_literal: true
+
 module ActionController
   module Rendering
     extend ActiveSupport::Concern
 
-    include AbstractController::Rendering
+    RENDER_FORMATS_IN_PRIORITY = [:body, :plain, :html]
+
+    module ClassMethods
+      # Documentation at ActionController::Renderer#render
+      delegate :render, to: :renderer
+
+      # Returns a renderer instance (inherited from ActionController::Renderer)
+      # for the controller.
+      attr_reader :renderer
+
+      def setup_renderer! # :nodoc:
+        @renderer = Renderer.for(self)
+      end
+
+      def inherited(klass)
+        klass.setup_renderer!
+        super
+      end
+    end
 
     # Before processing, set the request formats in current controller formats.
     def process_action(*) #:nodoc:
-      self.formats = request.formats.map { |x| x.ref }
+      self.formats = request.formats.map(&:ref).compact
       super
     end
 
@@ -14,52 +34,89 @@ module ActionController
     def render(*args) #:nodoc:
       raise ::AbstractController::DoubleRenderError if response_body
       super
-      self.content_type ||= Mime[lookup_context.rendered_format].to_s
-      response_body
     end
 
-    # Overwrite render_to_string because body can now be set to a rack body.
+    # Overwrite render_to_string because body can now be set to a Rack body.
     def render_to_string(*)
-      if self.response_body = super
-        string = ""
-        response_body.each { |r| string << r }
+      result = super
+      if result.respond_to?(:each)
+        string = "".dup
+        result.each { |r| string << r }
         string
+      else
+        result
       end
-    ensure
-      self.response_body = nil
+    end
+
+    def render_to_body(options = {})
+      super || _render_in_priorities(options) || " "
     end
 
     private
 
-    # Normalize arguments by catching blocks and setting them on :update.
-    def _normalize_args(action=nil, options={}, &blk) #:nodoc:
-      options = super
-      options[:update] = blk if block_given?
-      options
-    end
+      def _process_variant(options)
+        if defined?(request) && !request.nil? && request.variant.present?
+          options[:variant] = request.variant
+        end
+      end
+
+      def _render_in_priorities(options)
+        RENDER_FORMATS_IN_PRIORITY.each do |format|
+          return options[format] if options.key?(format)
+        end
 
-    # Normalize both text and status options.
-    def _normalize_options(options) #:nodoc:
-      if options.key?(:text) && options[:text].respond_to?(:to_text)
-        options[:text] = options[:text].to_text
+        nil
       end
 
-      if options[:status]
-        options[:status] = Rack::Utils.status_code(options[:status])
+      def _set_html_content_type
+        self.content_type = Mime[:html].to_s
       end
 
-      super
-    end
+      def _set_rendered_content_type(format)
+        if format && !response.content_type
+          self.content_type = format.to_s
+        end
+      end
 
-    # Process controller specific options, as status, content-type and location.
-    def _process_options(options) #:nodoc:
-      status, content_type, location = options.values_at(:status, :content_type, :location)
+      # Normalize arguments by catching blocks and setting them on :update.
+      def _normalize_args(action = nil, options = {}, &blk)
+        options = super
+        options[:update] = blk if block_given?
+        options
+      end
 
-      self.status = status if status
-      self.content_type = content_type if content_type
-      self.headers["Location"] = url_for(location) if location
+      # Normalize both text and status options.
+      def _normalize_options(options)
+        _normalize_text(options)
 
-      super
-    end
+        if options[:html]
+          options[:html] = ERB::Util.html_escape(options[:html])
+        end
+
+        if options[:status]
+          options[:status] = Rack::Utils.status_code(options[:status])
+        end
+
+        super
+      end
+
+      def _normalize_text(options)
+        RENDER_FORMATS_IN_PRIORITY.each do |format|
+          if options.key?(format) && options[format].respond_to?(:to_text)
+            options[format] = options[format].to_text
+          end
+        end
+      end
+
+      # Process controller specific options, as status, content-type and location.
+      def _process_options(options)
+        status, content_type, location = options.values_at(:status, :content_type, :location)
+
+        self.status = status if status
+        self.content_type = content_type if content_type
+        headers["Location"] = url_for(location) if location
+
+        super
+      end
   end
 end