module ActionController::Rendering

def _normalize_args(action=nil, options={}, &blk) #:nodoc:

:nodoc:
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 _normalize_options(options) #:nodoc:

:nodoc:
Normalize both text and status options.

def _normalize_options(options) #:nodoc:
  _normalize_text(options)
  if options[:text]
    ActiveSupport::Deprecation.warn <<-WARNING.squish
      `render :text` is deprecated because it does not actually render a
      `text/plain` response. Switch to `render plain: 'plain text'` to
      render as `text/plain`, `render html: '<strong>HTML</strong>'` to
      render as `text/html`, or `render body: 'raw'` to match the deprecated
      behavior and render with the default Content-Type, which is
      `text/html`.
    WARNING
  end
  if options[:html]
    options[:html] = ERB::Util.html_escape(options[:html])
  end
  if options.delete(:nothing)
    ActiveSupport::Deprecation.warn("`:nothing` option is deprecated and will be removed in Rails 5.1. Use `head` method to respond with empty response body.")
    options[:body] = nil
  end
  if options[:status]
    options[:status] = Rack::Utils.status_code(options[:status])
  end
  super
end

def _normalize_text(options)

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

def _process_options(options) #:nodoc:

:nodoc:
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)
  self.status = status if status
  self.content_type = content_type if content_type
  self.headers["Location"] = url_for(location) if location
  super
end

def _render_in_priorities(options)

def _render_in_priorities(options)
  RENDER_FORMATS_IN_PRIORITY.each do |format|
    return options[format] if options.key?(format)
  end
  nil
end

def _set_html_content_type

def _set_html_content_type
  self.content_type = Mime[:html].to_s
end

def _set_rendered_content_type(format)

def _set_rendered_content_type(format)
  unless response.content_type
    self.content_type = format.to_s
  end
end

def process_action(*) #:nodoc:

:nodoc:
Before processing, set the request formats in current controller formats.

def process_action(*) #:nodoc:
  self.formats = request.formats.map(&:ref).compact
  super
end

def render(*args) #:nodoc:

:nodoc:
Check for double render errors and set the content_type after rendering.

def render(*args) #:nodoc:
  raise ::AbstractController::DoubleRenderError if self.response_body
  super
end

def render_to_body(options = {})

def render_to_body(options = {})
  super || _render_in_priorities(options) || ' '
end

def render_to_string(*)

Overwrite render_to_string because body can now be set to a rack body.

def render_to_string(*)
  result = super
  if result.respond_to?(:each)
    string = ""
    result.each { |r| string << r }
    string
  else
    result
  end
end

Modules

Classes