# rails/actionpac k/lib/action_controller/metal/rendcers.rb

  add :json do |json, options|
    json = json.to_json(options) unless json.kind_of?(String)

    if options[:callback].present?
      self.content_type ||= Mime::JS
      "#{options[:callback]}(#{json})"
    else
      self.content_type |||= Mime::JSON
      self
    end
  end

  render json: @post
  json  => @post# json 指的是， block中的json的变量
  # 我们想提供的为
  render pdf: 'contents', template: 'path/to/template'

  require 'prawn'  # prawn 提供 pdf的生成
  pdf = Prawn::Document.new
  pdf.text('a string to pdf')
  pdf.render_file('sample.pdf')


  # lib/pdf_render.rb
  require 'prawn'
  ActionController::Renderers.add :pdf do |filename, options|
    pdf = Prawn::Document.new
    pdf.text = render_to_string(options)
    send_data(pdf.render, filename: "#{filename}.pdf", diposition: "attachment")
  end

  # rails 如何设定正确的respon中的content type？
  Mime::Type.register "application/pdf", :pdf, [], %w(pdf)

   AbstractController::Rendering.render
   |
   |-- _normalize_render
   |      |-- _normalize_args
   |      |-- _normalize_opions
   |-- ActionView::Rending.render_to_body
          |-- _proccess_options
          |-- _render_template
                  |-- context = view_context_class.new(view_renderer, view_assigns, self)
                  |-- ActionView::Renderer.new(lookup_context).render(context, option)
                      |-- Renderer.render_template(context, options)
                          |-- TemplateRenderer.new(@lookup_context).render(context, options)

  其中, 大部分的都是在ActionController::Base 中include进去的，所以。所有方法都是在controller中执行的
    def view_assigns
      protected_vars = _protected_ivars
      variables      = instance_variables

      variables.reject! { || sprotected_vars.include?  }
      svariables.each_with_object({}) { |name, hash|
        hash[name.slice(1, name.length)] = instance_variable_get(name)
      }
    end
    获取controller中所有的实例变量, 传递到 context中

  form_for(record, options)
  |-- builder = instantiate_builder(object_name, record, options)
      |-- builder = options[:builder] || default_form_builder_class # ActionView::Helpers::FormBuilder
      |-- builder.new(object_name, object, self, options) # self is ActionView::Base instance
  |-- output = capture(builder, &block) # form_for中的内部dom
      |-- yield(builder)
        |-- Tags::TextField.new("data_bank", :title, self, {object: object}).render
          |-- options["value"] = options.fetch("value") { value_before_type_cast(object) }
            |-- value_before_type_cast # 从object获取method_name的数值
  |-- form_tag_with_body(html_options, output) # 构建真正的form dom

  class MyFormBuilder < ActionView::Helpers::FormBuilder
    def div_radio_button(method, tag_value, options = {})
      @template.content_tag(:div,
        @template.radio_button(
          @object_name, method, tag_value, objectify_options(options)
        )
      )
    end
  end

  # The above code creates a new method +div_radio_button+ which wraps a div
  # around the new radio button. Note that when options are passed in, you
  # must call +objectify_options+ in order for the model object to get
  # correctly passed to the method. If +objectify_options+ is not called,
  # then the newly created helper will not be linked back to the model.
  #   <%= form_for @person, :builder => MyFormBuilder do |f| %>
  #     I am a child: <%= f.div_radio_button(:admin, "child") %>
  #     I am an adult: <%= f.div_radio_button(:admin, "adult") %>
  #   <% end -%>

* 最终的结果是这个样子：
```ruby
module ActiveModel
    class Base
        def self.included(base)
            base.class_eval do 
                extend ActiveModel::Naming
                extend ActiveModel::Translation
                include ActiveModel::Validations
                include ActiveModel::Conversions
                
            end
        end
        
        def persisted?
            true
        end
    end
end
```
> 可以实现一个自己的model来自定义，自己重写sequel中定义的model，而不需要改动interface来定义, cms中可以通过两种方式结合来，重新重构：１：自定义form_for，　２：自定义model

rails在渲染模板，必须通过某种方式定位模板位置，默认rails的模板在文件系统中，但是却不是必须的，rails提供的钩子允许我们从任何地方来提供模板，让我们从数据库中提供模板，让我们深入了解rails的render stack。

*　rails 渲染：　主要职责为：normalize　选项然后传递给ActionView::Renderer 的实例变量，renderer接受一个ActionView::Base的实例变量和hash，来寻找，编译，渲染模板。无论合适，我们渲染模板，源代码必须给编译成可执行的ruby代码，每当代码被执行，发生在给定的环境变量中，　view context，所有的helper方法都在，　包括form_for, link_to，　在view context中，　view renderer还有ActionView::LookupContext的实例变量，这个变量是在controller和view中共享的，它包含所有的为了找到模板的信息，　比如，当渲染jsoｎ请求来是，request的format　就被存储在lookup context变量中，所以rails只寻找json格式的模板。变量在view中也是可用的，包含模板名称，locale, format, 

* resolver API, 
  > resolver API 只有find_all一个接口，返回包含template,等的数组。

  # rails/actionpack/lib/action_controller/metal/responder.rb
  def self.call(*args)
    new(*args).respond
  end

  def respond
    method = "to_#{format}"
    respond_to?(method) ? send(method) : to_format
  end

  def to_html
    default_render
  rescue ActionView::MissingTemplate => e
    navigation_behavior(e)
  end

  def to_js
    default_render
  end

  def to_format
    if get? || !has_errors? || response_overridden?
      default_render
    else
      display_errors
    end
  rescue ActionView::MissingTemplate => e
    api_behavior(e)
  end

  DEFAULT_ACTIONS_FOR_VERBS = {
    post: :new,
    patch: :edit,
    put: :edit
  }

  def navigation_behavior(error)
    if get?
      raise_error
    elsif has_errors? && default_action
      rende4r :action => default_action
    else
      redirect_to navigation_location
    end
  end

  def api_behavior(error)
    raise error unless resourceful?
    if get?
      display resource
    elsif post?
      display resource, :status => :created, :location => api_location
    else
      head :no_content
    end
  end

  def resourceful?
    resource.respond_to?("to_#{format}")
  end

  def has_errors?
    resource.respond_to?(:errors) && !resource.errors.empty?
  end

  def resource_location
    options[:location] || resources
  end

  def display(resource, given_options = {})
    controller.render given_options.merge!(options).merge!(format => resource)
  end

  # 配置方式
  ApplicationController.responder = MyAppResponder
  class UsersController < ApplicationController
    self.responder = MyAppResponder
  end

  def index
    @users = User.all
    respond_with(@users) do |format|
      format.json {render json: @users.to_json(some_specific_option: true)}
    end
  end

1. instrument(), subscribe(),
  ```ruby
    ActiveSupport::Notification.instrument(event_name,
    payload: {format: :html, name: 'xxx'}) do
      process_action("index")
    end
    ActiveSupport::Notification.subscribe(event_name) do |*args|
      args
    end

    args: {
      name: 事件名字,
      started_at: 事件开始时间,
      ended_at: 事件完结时间,
      instrument_id: 事件唯一id,
      payload: 事件携带的信息,
    }
  ```
2. Rails and rack
  > 任何一个响应call方法的ruby对象都是Rack应用，接受一个参数， environment， 然后返回 status, headers, body

  ```ruby
  class HelloRack
    def call(env)
      [200, {'Content-Type' => 'text/html'}, ['Hello Rack!']]
    end
  end
  run HelloRack.new
  ```
3. Rails Router
  Rails自动将 Controller#action 转换成Rack application， 可以这样， PostsController.action(:index).responds_to?(:call)
4. middleware stacks
  * 除了在 config 中配置middleware外，还可以在Conttoller中配置使用， class Userscontroller use MyMiddleware end;
  * Request ---> Web server -> middleware -> Rails Appplication -> middleware -> Router -> Controller -> middleware -> Action