Normalize both text and status options.

def _normalize_options(options)
  _normalize_text(options)
  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

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
  nil
end

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

def _set_rendered_content_type(format)
  if format && !response.media_type
    self.content_type = format.to_s
  end
end

def _set_vary_header
  if response.headers["Vary"].blank? && request.should_apply_vary_header?
    response.headers["Vary"] = "Accept"
  end
end

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

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

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

# => renders app/views/posts/new.html.erb with HTTP status code 422
render "posts/new", status: :unprocessable_entity

# => renders app/views/posts/new.html.erb with HTTP status code 422
render "posts/new", status: 422

number or as the status name in Symbol form. Defaults to 200.
: The HTTP status code to send with the response. Can be specified as a
`:status`

# => renders "

Hello, World!

" with the default layout
render inline: "

Hello, World!

", layout: true

# => renders app/views/posts/show.html.erb with no layout
render "posts/show", layout: false

# => renders app/views/posts/show.html.erb with the app/views/layouts/holiday.html.erb layout
render "posts/show", layout: "holiday"

(re)enable the default layout template.
: The layout template to render. Can also be `false` or `true` to disable or
`:layout`

# => renders "

Hello, World!

"
render inline: "

Hello, <%= name %>!

", locals: { name: "World" }

: Hash of local variable assignments for the template.
`:locals`

# => renders "

Hello, World!

"
render inline: "

Hello, <%= @name %>!

", assigns: { name: "World" }

: Hash of instance variable assignments for the template.
`:assigns`

#### Options

rendered.
By default, when a rendering mode is specified, no layout template is


# => renders "

Hello, World

"
render renderable: Greeting.new

default.
renderable if it responds to `format`, falling back to `text/html` by
context. The response format is determined by calling `format` on the
: Renders the provided object by calling `render_in` with the current view
`:renderable`

# => renders "{\"hello\":\"world\"}"
render json: { hello: "world" }

JSON by calling `to_json`.
`application/json`. If the object is not a string, it will be converted to
: Renders the provided object as JSON, and sets the content type as
`:json`

# => renders "<h1>Hello, World!</h1>"
render html: "

Hello, World!

"

# => renders "

Hello, World!

"
render html: "

Hello, World!

".html_safe

the string before rendering.
`text/html`. If the string is not `html_safe?`, performs HTML escaping on
: Renders the provided HTML string, and sets the content type as
`:html`

# => renders "Hello, World!"
render plain: "Hello, World!"

: Renders the provided text, and sets the content type as `text/plain`.
`:plain`

# => renders "Hello, World!"
render body: "Hello, World!"

: Renders the provided text, and sets the content type as `text/plain`.
`:body`

# => renders "

Hello, World!

"
render inline: "

Hello, <%= @name %>!

"
@name = "World"

: Renders an ERB template string.
`:inline`

# => renders /path/to/some/file
render file: "/path/to/some/file"

unsanitized user input.
: Renders the contents of a file. This option should **not** be used with
`:file`

# => renders app/views/posts/_form.html.erb
render partial: "posts/form", locals: { post: Post.new }

: See ActionView::PartialRenderer for details.
`:partial`

#### Rendering Mode

# => "

Hello, World

"
render(renderable: Greeting.new)

# => "

Hello, World

"
render(Greeting.new)

end
end
:html
def format

end
view_context.render html: "

Hello, World

"
def render_in(view_context)
class Greeting

by calling `render_in` with the current view context.
If the first argument responds to `render_in`, the template will be rendered

# => renders app/views/posts/show.html.erb
render :show
# In a PostsController action...

# => renders app/views/posts/show.html.erb
render "posts/show"

the first argument.
If no rendering mode option is specified, the template will be derived from

Renders a template and assigns the result to `self.response_body`.

def render(*args)
  raise ::AbstractController::DoubleRenderError if response_body
  super
end

:nodoc:

def render_to_body(options = {}) # :nodoc:
  super || _render_in_priorities(options) || " "
end

Override render_to_string because body can now be set to a Rack body.
--
instead of setting `self.response_body`.
Similar to #render, but only returns the rendered template as a string,

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