angelfan (耿)

尝试理解 ActionController::Base#render

angelfan — Sun, 25 Sep 2016 13:12:28 +0800

尝试理解 ActionController::Base#render

我是带着以下两个问题去翻 ActionView 相关的源码的，标题是后来取的

是通过什么手段将 controller 的实例变量复制到 view 中的
这些实例变量是怎么被使用的，是怎将 erb(也可能是 slim haml 等) 转化成标准的 html 的

在我们的 controller 的书写中是通过 render 来渲染 view 的比如我们会写：

def index
  render :index
end

# 虽然我们一般不写, 不过最终还是会调用render
# actionpack/lib/action_controller/metal/implicit_render.rb中实现了隐式调用
# 就是通过重写send_action
# send_action 原名send, 在AbstractController::Base#process_action中被调用
# process_action在识别路由分发请求之后会被调用, 
# https://ruby-china.org/topics/30916简单介绍了下rails如何识别路由并转发到对应的controller

接下来我的切入点就变成寻找#render

从`#render`开始

# actionpack/lib/abstract_controller/rendering.rb
# 它在ActionController::Base中被include
# 同时ActionController::Base还include ActionView::Layouts(这是controller转战view的关键点)
# 详细include了那些模块看actionpack/lib/action_controller/base.rb

module AbstractController
  module Rendering

    def render(*args, &block)
      options = _normalize_render(*args, &block)
      rendered_body = render_to_body(options)
      if options[:html]
        _set_html_content_type
      else
        _set_rendered_content_type rendered_format
      end
      self.response_body = rendered_body
    end
  end
end

一看就知道 render_to_body 是关键点，因为 response_boy 内容全靠它

# config.ru
require 'action_dispatch'
require 'action_controller'

routes = ActionDispatch::Routing::RouteSet.new
routes.draw do
  get '/' => 'test#index'
end

class TestController < ActionController::Metal
  # Rendering在ActionController::Base中才被include
  # 这里用的是Metal  
  include AbstractController::Rendering

  def index
    @var = 'you had got the instance variable'
    render 'index'
    # 这个'index'在我们这里其实是无意义的, 其实可以render任何东西
    # 比如 render 'xxx', 因为我们的render_to_body没有使用这些参数
    # 调用render只是为了使render_to_body被调用
  end

  def render_to_body(*_args)
    template = ERB.new File.read("#{params[:action]}.html.erb")
    template.result(binding)
  end
end

run routes

# index.html.erb
Message: <%= @var %>

在看#render_to_body之前我先看了一下#_normalize_render

# actionpack/lib/abstract_controller/rendering.rb 
# AbstractController::Rendering
# render各种用法详见 http://guides.rubyonrails.org/layouts_and_rendering.html
# 这里主要是对参数进行处理
# 比如是否需要特别处理 例如render status: 200
# 是否需要套用layout
# 是否需要加上prefixes  => YourControler._prefixes
# 处理完之后才会交给render_to_body, 因为它需要就根据你写的代码见招拆招
def _normalize_render(*args, &block)
  options = _normalize_args(*args, &block)
  if defined?(request) && !request.nil? && request.variant.present?
    options[:variant] = request.variant
  end

  _normalize_options(options)
  options
end

# ActionController::Base中引用了太多的模块很多方法被多个模块不断的重写, 不同模块的重写附加的职能是不同的
# 为了知道一个方法被那些模块重写 把下面这段代码复制粘贴到`rails c`下就能用
class Module
  def ancestors_that_implement_instance_method(instance_method)
    ancestors.find_all do |ancestor|
      (ancestor.instance_methods(false) + ancestor.private_instance_methods(false)).include?(instance_method)
    end
  end
end

# 贴一下这两个方法被那些模块重写过
ActionController::Base.ancestors_that_implement_instance_method(:_normalize_args)
# [
#     [0] ActionController::Rendering,
#     [1] ActionView::Rendering,
#     [2] AbstractController::Rendering
# ]

ActionController::Base.ancestors_that_implement_instance_method(:_normalize_options)
# [
#     [0] ActionController::Rendering,
#     [1] ActionView::Layouts,
#     [2] ActionView::Rendering,
#     [3] AbstractController::Rendering
# ]

进入 render_to_body

先看一下哪些地方重写了#render_to_body

ActionController::Base.ancestors_that_implement_instance_method(:render_to_body)
# rails5中会搜到了5个同名方法 api那边会重写一次
# [
#     [0] ActionController::Renderers, # 负责处理:json, :js, :xml等
#     [1] ActionController::Rendering, # 负责处理 :body, :text, :plain, :html
#     [2] ActionView::Rendering, #  恩 这个就是我要找的
#     [3] AbstractController::Rendering # 它什么都不干 就是一个接口, 毕竟人家叫Abstract
# ]

# actionview/lib/action_view/rendering.rb
module ActionView
  module Rendering
    def render_to_body(options = {})
      _process_options(options)
      _render_template(options)
    end
  end
end

主要看#_render_template

# 到这里我的第一个问题的答案就水落石出了(是通过什么手段将controller的实例变量复制到view中的)
def _render_template(options) #:nodoc:
  variant = options.delete(:variant)
  assigns = options.delete(:assigns)
  context = view_context

  context.assign assigns if assigns
  lookup_context.rendered_format = nil if options[:formats]
  lookup_context.variants = variant if variant

  view_renderer.render(context, options)
end

def view_context
  view_context_class.new(view_renderer, view_assigns, self)
end

# view_context接受三个参数, 其中包括view_assigns
def view_assigns
  protected_vars = _protected_ivars
  variables      = instance_variables

  variables.reject! { |s| protected_vars.include? s }
  variables.each_with_object({}) { |name, hash|
    hash[name.slice(1, name.length)] = instance_variable_get(name)
  }
end

# #view_assigns会把我们在controller中定义的实例变量拿过来先放到hash中存起来, 不过会去掉_protected_ivars(实现这套框架引入的实例变量)
# 然后交给ActionView::Base
def initialize(context = nil, assigns = {}, controller = nil, formats = nil) #:nodoc:
  ...
  assign(assigns)
  ...
end

# 将hash通过instance_variable_set变成view(ActionView::Base)的实例变量
def assign(new_assigns) # :nodoc:
  @_assigns = new_assigns.each { |key, value| instance_variable_set("@#{key}", value) }
end

OK 第一个问题解决，我很早之前有猜测过是用了binding

继续寻找第二个问题的答案 #view_context

def view_context_class
  @view_context_class ||= begin
    ......
    # 这就是为什么在view中输出self.class是匿名的class
    Class.new(ActionView::Base) do
      if routes
        include routes.url_helpers(supports_path)
        include routes.mounted_helpers
      end

      if helpers
        include helpers
      end
    end
  end
end

def view_context
  # self就是当前controller的实例
  view_context_class.new(view_renderer, view_assigns, self)
end

#lookup_context

def lookup_context
  @_lookup_context ||=
    ActionView::LookupContext.new(self.class._view_paths, details_for_lookup, _prefixes)
end

# 它知道要去哪里找view
# YourController.new.lookup_context.view_paths.paths

#view_renderer

def view_renderer
  @_view_renderer ||= ActionView::Renderer.new(lookup_context)
end

# 它知道什么情况下怎么处理, 比如render text: 'xx', render html: 'xx' 等等

看到这里我一开始其实是有点迷糊的因为在_render_template中最终通过view_renderer#render输出为什么 view_context 还要拿个 view_renderer 在手里后来才想起来在 view 中也会 render 它同样要依靠 ActionView::Renderer

通过运行 ActionView::Base.ancestors_that_implement_instance_method(:render) 会发先 view 中的#render在 ActionView::Helpers::RenderingHelper 中

module ActionView
  module Helpers
    # = Action View Rendering
    #
    # Implements methods that allow rendering from a view context.
    # In order to use this module, all you need is to implement
    # view_renderer that returns an ActionView::Renderer object.
    module RenderingHelper
    end
  end
end
# 看文档注释 果然是这样

通过猜 + 翻看注释发现我寻找答案应该是在 view_renderer 中，一路看下去

module ActionView
  class Renderer
    def render(context, options)
      if options.key?(:partial)
        render_partial(context, options)
      else
        render_template(context, options)
      end
    end

    # 只看render_template好了
    def render_template(context, options) #:nodoc:
      TemplateRenderer.new(@lookup_context).render(context, options)
    end
  end
end

def render_template(template, layout_name = nil, locals = nil) #:nodoc:
  view, locals = @view, locals || {}

  render_with_layout(layout_name, locals) do |layout|
    instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
      template.render(view, locals) { |*name| view._layout_for(*name) }
    end
  end
end

# 最终进入
module ActionView
  # = Action View Template
  class Template

    def render(view, locals, buffer=nil, &block)
      instrument_render_template do
        compile!(view)
        view.send(method_name, locals, buffer, &block)
      end
    rescue => e
      handle_render_error(view, e)
    end

    def compile!(view) #:nodoc:
      return if @compiled

      @compile_mutex.synchronize do
        ...

        instrument("!compile_template") do
          compile(mod)
        end

        ...
      end
    end

    def compile(mod) #:nodoc:
      ...
      method_name = self.method_name
      code = @handler.call(self)

      source = <<-end_src
        def #{method_name}(local_assigns, output_buffer)
          _old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
        ensure
          @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
        end
      end_src

      mod.module_eval(source, identifier, 0)
      ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
    end

    def method_name #:nodoc:
      @method_name ||= begin
        m = "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
        m.tr!('-', '_')
        m
      end
    end
  end
end

code = @handler.call(self)

@handler => ActionView::Template::Handlers::ERB

self => ActionView::Template

它会输出一串字符串

就像 ActionView::Template::Handlers::Erubis.new("<h1><%= @abc %></h1>").src 会输出

"@output_buffer = output_buffer || ActionView::OutputBuffer.new;@output_buffer.safe_append='<h1>'.freeze;@output_buffer.append=( @abc );@output_buffer.safe_append='</h1>'.freeze;@output_buffer.to_s"

这样相当于

def method_name(local_assigns, output_buffer) # method_name每次都不一样, 用完之后会通过#define_finalizer回收
  ...
  @output_buffer = output_buffer || ActionView::OutputBuffer.new
  @output_buffer.safe_append='<h1>'.freeze
  @output_buffer.append=( @abc )
  @output_buffer.safe_append='</h1>'.freeze
  @output_buffer.to_s
  ...
end

这个方法通过 mod.module_eval(source, identifier, 0) 作用到 ActionView::Base 上了所以可以抓到@abc这个实例变量

至此完成 erb 到 html 的转换

两个问题解完

小结

rails中的v(view)和c(controller)是靠着AbstractController::Rendering#render来承上(c)启下(v), 通过#render_to_body 作为接口来获取 view 的结果作为 response_body 返回给客户端

在我们的 view 中会使用一些 helper, 比如我们自己定义的 helper method 以及通过路由生成的 url helper, 所以在 ActionView::Rendering 会以 Class.new(ActionView::Base) 的方式来加载这个 helper method

三个比较重要的东西 view_context lookup_context view_renderer, xxx_context 其实什么事情都不会干，只是有一堆关于上下文环境相关的东西就好比军师， view_renderer 就好比士兵吧，军师把相关信息告诉士兵，然后士兵执行 (渲染出 view)

view 其实是先被 compile 成一堆字符串 (OutputBuffer 相关), 然后通过 module_eval 转换成成相应的方法

尝试理解 ActionDispatch::Routing::RouteSet

angelfan — Fri, 26 Aug 2016 19:51:46 +0800

ActionDispatch::Routing::RouteSet

版本 ActionPack::VERSION => 5.0.0(alpha)

请求是怎么被分发的

例子

这玩意可以当 rack app 跑起来

require 'action_dispatch'

Routes = ActionDispatch::Routing::RouteSet.new.tap do |app|
  app.draw do
    get 'tests', to: 'tests#welcome'
  end
end

class TestsController
  # 这段代码是我在rails v 4.2.6下面跑的
  # rails v 5.0 以后改成dispatch
  # https://github.com/rails/rails/blob/v4.2.7.1/actionpack/lib/action_dispatch/routing/route_set.rb#L73
  # https://github.com/rails/rails/blob/v5.0.0.beta1/actionpack/lib/action_dispatch/routing/route_set.rb#L50
  def self.action(method)
    controller = self.new
    controller.method(method.to_sym)
  end

  def welcome(env)
    [200, {"Content-Type" => "text/html"}, ["<h1>Hello</h1>"]]
  end
end

run Routes
# http://localhost:9292/tests

猜想

为什么可以这样，根据 Rack App 的实现，猜想可能是这样

ActionDispatch::Routing::RouteSet 里面应该会有个 #call, 然后根据当前的请求 (env) 分发到指定的 Controller

env 中会有我们想要的资料，比如请求方法，请求路径，请求参数等等

请求方法 + 请求路径可以帮助我们找到对应的路由，然后就可以根据定义的路由找到 Controller#Action

然后按照 Rack App 返回 status, head, body

咱们自己按照这种思路写一个试试看

class Router
  attr_accessor :routes

  def initialize
    super
    @routes = {}
  end

  def call(env)
    resource = routes[env['PATH_INFO']]
    controller = Object.const_get(resource[:controller]).new
    action = resource[:action]
    dispatch(controller, action, env)
  end

  def dispatch(controller, action, env)
    controller.send(action, env)
  end

  def draw(path, resource)
    routes[path] = resource
  end
end

class HelloController
  def hello(env)
    your_name = env['QUERY_STRING'].split('=').last
    [400, { 'Content-Type' => 'text/plain' }, ["hello: #{your_name}"]]
  end
end

router = Router.new.tap do |app|
  # 为了检测猜想先这样简单实现下
  app.draw('/hello', { controller: 'HelloController', action: 'hello' })
end

run router

# http://localhost:9292/hello?name=yourname

恩，可以跑起来了

看源码

先开始看 RouteSet

# action_dispatch/routing/route_set.rb:710
class RouteSet
  class Dispatcher ... end # 平时总是喜欢说分发请求, 看名字好像跟它有关系

  def call(env)
    req = make_request(env)
    req.path_info = Journey::Router::Utils.normalize_path(req.path_info) # req.path_info => env['QUERY_STRING']
    @router.serve(req)
  end
end

的确有这么个东西，它处理了一下 env 然后甩手就交给了 @router.serve(req)

找一下@router是什么东西

# action_dispatch/routing/route_set.rb:324
def initialize(config = DEFAULT_CONFIG)
  ...
  @set    = Journey::Routes.new
  @router = Journey::Router.new @set
  ...
end

看一下Journey::Router#serve干了什么

def serve(req)
  # 寻找目标路由
  find_routes(req).each do |match, parameters, route|
    ...
    status, headers, body = route.app.serve(req)
    ...
    return [status, headers, body]
  end

  return [404, {'X-Cascade' => 'pass'}, ['Not Found']]
end

route.app.serve => ActionDispatch::Routing::RouteSet::Dispatcher#serve

# ActionDispatch::Routing::RouteSet
def serve(req)
  ...
  controller = controller req
  res        = controller.make_response! req
  dispatch(controller, params[:action], req, res)
  .....
end

def dispatch(controller, action, req, res)
  controller.dispatch(action, req, res)
  # 剩下的就交给Controller的类方法dispatch去处理了
end

基本流程就是

request 进来后 RouteSet 把请求交给Journey::Router去处理
Journey::Router拿到 request 去找 Route
然后执行 Route#pp#serve,
Dispatcher(Route#app)取得request#controller_class然后调用Controller.dispatch
ActionController::Metal 里面有个类方法 self.dispatch(name, req, res)他会负责将请求分发到指定的Action

ps: Route#app在rails5中有三种类型 StaticDispatcher, Constraints, Dispatcher

def app(blocks)
  if to.is_a?(Class) && to < ActionController::Metal
    Routing::RouteSet::StaticDispatcher.new to
  else
    if to.respond_to?(:call)
      Constraints.new(to, blocks, Constraints::CALL)
    elsif blocks.any?
      Constraints.new(dispatcher(defaults.key?(:controller)), blocks, Constraints::SERVE)
    else
      dispatcher(defaults.key?(:controller)) # Routing::RouteSet::Dispatcher.new raise_on_name_error
    end
  end
end

整理一下思路，写了如下迷你版 demo

迷你版 demo

另外两个感兴趣的问题

Journey::Router 是如何根据 request 找到对应的Route的
'test/:id/hello/:name' 是如何将识别参数:id, :name 的

先看一组测试用例

paths = %w{
  /articles(.:format)
  /articles/:id/edit(.:format)
}
parser  = ActionDispatch::Journey::Parser.new
ast = paths.map { |x|
  ast = parser.parse x
  ast.each { |n| n.memo = x } # 实际上这个memo有两种值 nil || Route的实例对象
  ast
  # parser.parse x 会将路径变成一个个的节点 也就是Journey::Nodes里面的各种类型的节点
  # 并且该节点下面会带上正则表达式
  # 该正则有两个作用
  # 1. 将/articles/1231/edit的1231匹配出来将来作为params[:id]
  # 2. 生成TransitionTable表的@regexp_states, 因为也可能需要靠他来匹配路径 寻找memo中的路由(Route实例)索引
}

builder = ActionDispatch::Journey::GTG::Builder.new ActionDispatch::Journey::Nodes::Or.new ast
table = builder.transition_table

simulate = ActionDispatch::Journey::GTG::Simulator.new table

# 匹配到的路由
simulate.simulate('/articles/100/edit').memos

ast 的 memo 本是空值，在第一次开始寻找路由的时候才将其中为 terminal？的结点赋值

# ActionDispatch::Journey::Route
def ast
  @decorated_ast ||= begin
    decorated_ast = path.ast # 在Mapper#add_route的时候就已经建立了
    # 如果这个节点是终点就将当前的Route实例穿给该节点
    decorated_ast.find_all(&:terminal?).each { |n| n.memo = self }
    decorated_ast
  end
end

terminal 的意思是一个路由的端点 (不知道怎么翻译)

比如 '/articles' 它有两个端点，一个是 articles 另一个是 format

因为我们的req#path_info可能是'/articles' 也可能是 '/articles.xxx',

simulate.simulate('/articles/100/edit') 实际上是逐个去匹配，

'/', 'articles', '/', '100', '/', 'edit'

大概可能像是这样

tring_states = {
    0 => {
        '/' => 1
    },
    1 => {
        'articles' => 2,
    },
    2 => {
        '/' => 3
    },
    4 => {
        '/'=> 5
    }
    5 => {
        'edit'=> '6(memo index)'
    }
}
regexp_states = {
    3 => {
        /[^\.\/\?]+/ => 4 #（用来匹配:id, 即100）
    }
}

为了更好的帮助我自己理解TransitionTable 整理了一段代码

TransitionTable

上面那个动作之所以会被触发是因为在Journey::Router#find_routes过程中 (请求进来了需要找到指定的路由以便按照上面所说的方式去分发请求) 会 callJourney::Route#ast

# ActionDispatch::Journey::Router
def find_routes req
  # 看方法名即知道有可能找到不止一个路由
  # 'articles/new'
  # 'articles/:id'
  # 按照匹配方式他们可以同时配  req.path_info => '/articles/new' 匹配到
  routes = filter_routes(req.path_info).concat custom_routes.find_all { |r|
    r.path.match(req.path_info)
  }

  # 解决方式就是按照路由书写的顺序来排列
  # resource :xxx的书写路由顺序是 index, create, new, edit, show, update(patch), update(put), destroy
  # 最终执行的时候执行完第一个路由就直接返回了
  routes.sort_by!(&:precedence)
  ...
end

所以实际上寻找路由是通过req#path_info去TransitionTable中去找

关于参数的问题实际上就是将'hello/:xx' 的路由生成一个 /\A\/hello\/([^\/.?]+)(?:.([^\/.?]+))?\Z/ 正则

reg = /\A\/hello\/([^\/.?]+)(?:\.([^\/.?]+))?\Z/
path_info = '/hello/name.js'
reg.match(path_info) # #<MatchData "/hello/name.js" 1:"name" 2:"js">

思路理得差不多，然后参照一下 rails 中处理参数的方式稍微完善一下之前的 demo 得到如下

进阶版 demo

先这样吧~~~

autocomplete: 'off'火狐中不起作用

angelfan — Wed, 24 Jun 2015 13:27:33 +0800

登陆之后选择“记住密码”后，在新建用户的时候会自动填充用户名和密码 password 表单加入 autocomplete:=off 不起作用，想请教一下大家是怎么解决这个问题的注：

在 IE 下没有发现该问题，
当再次选择一用户登录，并记住密码，该问题消失（也就是只有当记住一个用户和密码的时候才会有这种问题）
虽然添加一个隐藏的 password 表单可以解决问题（密码被自动填充到隐藏表单去了），但总是觉得不靠谱

（描述的不清楚的话，还请包涵）

如何根据经纬度获取地址名称

angelfan — Sat, 20 Jun 2015 22:04:16 +0800

伸手党了！有用过 JS 的 API, 想问下有没有可用的 gem

Ubuntu 下可以安装 QQ 么？

angelfan — Tue, 07 Apr 2015 21:24:18 +0800

第一次玩 ubuntu，在网上找了半天，没安装成功，求个解决方案！感谢！

js 中修改 data-method 无效么？

angelfan — Sun, 15 Mar 2015 11:18:44 +0800

一个取消喜欢的链接

<a data-remote="true" data-method="delete" href="/articles/22/like">
<i class="fa fa-smile-o"></i>
<span>取消喜欢</span>
</a>

点击后发送 ajax 请求，然后再 js 中修改了 data-method 属性

('span ').text('喜欢');
data("method", "post")

属性修改成功

<a data-remote="true" data-method="post" href="/articles/22/like">
<i class="fa fa-smile-o"></i>
<span>喜欢</span>
</a>

点击该喜欢链接依然发送了一个 delete 请求

问题：是不可以通过这种方式来修改么？还是有其他需要注意的细节？

关于 block 的问题

angelfan — Thu, 26 Feb 2015 10:58:33 +0800

class Song
  attr_reader :a

  def initialize
    @a = []
  end

  def abc
    @a << 10
  end

end

def song
  sing = Song.new
  yield sing
end

def song(&block)
  sing = Song.new
  capture(sing , &block)
end

song do |a|
  a.abc
  a.abc
  a.abc
end

end

我想问一下的是，yield sing 和 capture(sing , &block) 有什么不同（ps:我写的是第一种，第二种用 capture(sing , &block) 是我在别的地方看到的，如果因为简化代码造成 capture 用法错误还请指出，见谅哈，因为我从来没用这样用过 capture）

截取 HTML 富文本的问题

angelfan — Thu, 05 Feb 2015 10:59:36 +0800

如题：如何截取一段带 html 标签的富文本，普通的截取会导致乱码，去掉标签截取又不是想要的结果。想知道有没有现成的 gem 可以使用？

求推荐一个富文本编辑器

angelfan — Sat, 31 Jan 2015 22:35:57 +0800

想找个富文本编辑器，想咨询下 Simditor 好用么，或者有什么其他的更好用的富文本编辑器

Rails 启动时的报错 invalid Unicode escape

angelfan — Mon, 26 Jan 2015 10:35:44 +0800

ArgumentError: regexp preprocess failed: invalid Unicode escape Backtrace at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/rake-10.0.2/lib/rake/backtrace.rb:10 Rake at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/rake-10.0.2/lib/rake/backtrace.rb:2 (root) at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/rake-10.0.2/lib/rake/backtrace.rb:1 require at org/jruby/RubyKernel.java:1071 require at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/polyglot-0.3.3/lib/polyglot.rb:63 (root) at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/rake-10.0.2/lib/rake/backtrace.rb:61 require at org/jruby/RubyKernel.java:1071 require at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/rake-10.0.2/lib/rake.rb:68 each at org/jruby/RubyArray.java:1620 require at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/bundler-1.2.2/lib/bundler/runtime.rb:66 each at org/jruby/RubyArray.java:1620 require at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/bundler-1.2.2/lib/bundler/runtime.rb:55 require at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/bundler-1.2.2/lib/bundler.rb:128 (root) at D:/studyresource/evndajian/ESF VPDC/config/application.rb:8 require at org/jruby/RubyKernel.java:1071 (root) at D:/studyresource/evndajian/ESF VPDC/config/application.rb:53 tap at org/jruby/RubyKernel.java:1816 (root) at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/railties-3.2.11/lib/rails/commands.rb:50 require at org/jruby/RubyKernel.java:1071 (root) at D:/use/studyinstallpath/jruby/jruby-1.6.8/lib/ruby/gems/1.8/gems/railties-3.2.11/lib/rails/commands.rb:6 load at org/jruby/RubyKernel.java:1097 (root) at -e:1 求个解决办法

寻求伙伴一起学习 Ruby on Rails

angelfan — Tue, 20 Jan 2015 21:35:31 +0800

背景：工作一年，结束 ruby on rails 整整大半年。一直是一个人在学习，或者一个人做一些简单的东西。虽然目前技术一般，但对各种新奇的东西充满着好奇。

目的：寻找个志同道合的伙伴一起学习，一起讨论一些东西，做一个快乐的苦逼程序员

有没有志同道合的小伙伴？

南京有没有招聘 ruby on rails 的公司

angelfan — Tue, 23 Dec 2014 11:30:14 +0800

简介工作一年，ruby on rails 经验一年，想在南京找一份工作

angelfan (耿)

尝试理解 ActionController::Base#render

尝试理解 ActionController::Base#render

从#render开始

进入 render_to_body

小结

尝试理解 ActionDispatch::Routing::RouteSet

ActionDispatch::Routing::RouteSet

请求是怎么被分发的

例子

猜想

看源码

另外两个感兴趣的问题

autocomplete: 'off'火狐中不起作用

如何根据经纬度获取地址名称

Ubuntu 下可以安装 QQ 么？

js 中修改 data-method 无效么？

问题：是不可以通过这种方式来修改么？还是有其他需要注意的细节？

关于 block 的问题

截取 HTML 富文本的问题

求推荐一个富文本编辑器

Rails 启动时的报错 invalid Unicode escape

寻求伙伴一起学习 Ruby on Rails

南京有没有招聘 ruby on rails 的公司

从`#render`开始