adamshen (adam.shen)

# In Warden::Manager

def call(env) # :nodoc:
  return @app.call(env) if env['warden'] && env['warden'].manager != self

  env['warden'] = Proxy.new(env, self)
  result = catch(:warden) do
    @app.call(env)
  end

  result ||= {}
  case result
  when Array
    handle_chain_result(result.first, result, env)
  when Hash
    process_unauthenticated(env, result)
  when Rack::Response
    handle_chain_result(result.status, result, env)
  end
end

这样一来，不管在 controller 里的任何地方 throw(:warden)，该请求就会立即被 warden 接管

warden 在 rack env 里增加了一个 warden 属性，使用 lazy load 的模式给下面一层调用。在 controller 里如果需要用到验证就去 get 这个对象，不然直接不用就行了

devise 会注册一个 helper 方法，然后把 authentication_xxxxx! 方法委托到 env['warden'] 对象上来执行

# In Devise::Controller::Helpers

def warden
  request.env['warden'] or raise MissingWarden
end

def self.define_helpers(mapping) #:nodoc:
  mapping = mapping.name

  class_eval <<-METHODS, __FILE__, __LINE__ + 1
    def authenticate_#{mapping}!(opts={})
      opts[:scope] = :#{mapping}
      warden.authenticate!(opts) if !devise_controller? || opts.delete(:force)
    end

    def #{mapping}_signed_in?
      !!current_#{mapping}
    end

    def current_#{mapping}
      @current_#{mapping} ||= warden.authenticate(scope: :#{mapping})
    end

    def #{mapping}_session
      current_#{mapping} && warden.session(:#{mapping})
    end
  METHODS

  ActiveSupport.on_load(:action_controller) do
    if respond_to?(:helper_method)
      helper_method "current_#{mapping}", "#{mapping}_signed_in?", "#{mapping}_session"
    end
  end
end

这个对象的 authenticate! 方法会做身份确认，如果没有通过就 throw(:warden)

# In Warden::Proxy

def authenticate!(*args)
  user, opts = _perform_authentication(*args)
  throw(:warden, opts) unless user
  user
end

对于不同类型的认证失败，需要配置一个 failure_app 来处理后续的流程

对于 devise 来说，这个 failure_app 是 Devise::FailureApp，devise 会把它写入到 warden 的配置里

所以使用用户名密码的策略认证失败（关于策略下面再说）会返回通知，而没有登陆则会重定向到 sign_in 页面

# In Warden::Manager

def call_failure_app(env, options = {})
  if config.failure_app
    options.merge!(:attempted_path => ::Rack::Request.new(env).fullpath)
    env["PATH_INFO"] = "/#{options[:action]}"
    env["warden.options"] = options

    _run_callbacks(:before_failure, env, options)
    config.failure_app.call(env).to_a
  else
    raise "No Failure App provided"
  end
end # call_failure_app

scope

warden 实现 scope 的方式是用一个 hash 来记录不同 scope 的 user 对象，把 scope 的名字用作 key，然后大量的 api 里把 scope 作为可选参数

# In Warden::Proxy

def initialize(env, manager) #:nodoc:
  @env, @users, @winning_strategies, @locked = env, {}, {}, false
  @manager, @config = manager, manager.config.dup
  @strategies = Hash.new { |h,k| h[k] = {} }
  manager._run_callbacks(:on_request, self)
end

def session(scope = @config.default_scope)
  raise NotAuthenticated, "#{scope.inspect} user is not logged in" unless authenticated?(scope)
  raw_session["warden.user.#{scope}.session"] ||= {}
end

def authenticated?(scope = @config.default_scope)
  result = !!user(scope)
  yield if block_given? && result
  result
end

# Same API as authenticated?, but returns false when authenticated.
# :api: public
def unauthenticated?(scope = @config.default_scope)
  result = !authenticated?(scope)
  yield if block_given? && result
  result
end

上面@users就是那个可以包含不同 scope 的 user 对象的 hash，从 session 方法可以看到，不同的 scope 在 session 中是有 namespace 作为区分的，这样就可以从 session 中读出不同 scope 的 user_id

devise 里有 map 的概念，一个 map 对应一个 scope

map 的配置用 Devise::Mapping 来记录，这里不继续展开，devise 会为每个 scope 注册不同的 helper 方法，这样在调用 warden api 的时候，这个 map 对应的 scope 就自动作为参数传给了 warden

Devise.mappings
=> {:user=>
  #<Devise::Mapping:0x007f9e0d5eded8
   @class_name="User",
   @controllers={:sessions=>"devise/sessions", :passwords=>"devise/passwords", :registrations=>"devise/registrations"},
   @failure_app=Devise::FailureApp,
   @format=nil,
   @klass=#<Devise::Getter:0x007f9e0d5eda00 @name="User">,
   @modules=[:database_authenticatable, :rememberable, :recoverable, :registerable, :validatable, :trackable],
   @path="users",
   @path_names={:registration=>"", :new=>"new", :edit=>"edit", :sign_in=>"sign_in", :sign_out=>"sign_out", :password=>"password", :sign_up=>"sign_up", :cancel=>"cancel"},
   @path_prefix=nil,
   @router_name=nil,
   @routes=[:session, :password, :registration],
   @scoped_path="users",
   @sign_out_via=:delete,
   @singular=:user,
   @strategies=[:rememberable, :database_authenticatable],
   @used_helpers=[:session, :password, :registration],
   @used_routes=[:session, :password, :registration]>}

strategies

回到 authenticate! 方法里做检查的部分，看看 warden 如何做身份验证

# In Warden::Proxy

def _perform_authentication(*args)
  scope, opts = _retrieve_scope_and_opts(args)
  user = nil

  # Look for an existing user in the session for this scope.
  # If there was no user in the session. See if we can get one from the request.
  return user, opts if user = user(opts.merge(:scope => scope))
  _run_strategies_for(scope, args)

  if winning_strategy && winning_strategy.successful?
    opts[:store] = opts.fetch(:store, winning_strategy.store?)
    set_user(winning_strategy.user, opts.merge!(:event => :authentication))
  end

  [@users[scope], opts]
end

这个方法大致的作用是从 session 里找出某个 scope 的 key，如果有的话就根据提前定义的规则根据 key 来找到 user 对象。如果 session 里不存在 key，那么就根据这个 scope 的 strategies 列表来进行 auth，如果有策略命中的话就会返回 user 对象

strategy 存在类变量里

# In Warden::Proxy

def _fetch_strategy(name, scope)
  @strategies[scope][name] ||= if klass = Warden::Strategies[name]
    klass.new(@env, scope)
  elsif @config.silence_missing_strategies?
    nil
  else
    raise "Invalid strategy #{name}"
  end
end

# In Warden::Strategies

def [](label)
  _strategies[label]
end

# :api: private
def _strategies
  @strategies ||= {}
end

strategy 必须继承自 Warden::Strategies::Base，含有 authenticate! 方法，在 devise 下 2 个默认的 strategy 在 lib/devise/strategies 目录下

这是根据用户名密码校验用户的 strategy 的 auth 方法，检查密码的时候有用到 BCrypt

# In Devise::Strategies::DatabaseAuthenticatable

def authenticate!
    resource  = password.present? && mapping.to.find_for_database_authentication(authentication_hash)
    hashed = false

    if validate(resource){ hashed = true; resource.valid_password?(password) }
      remember_me(resource)
      resource.after_database_authentication
      success!(resource)
    end

    mapping.to.new.password = password if !hashed && Devise.paranoid
    fail(:not_found_in_database) unless resource
end

devise 会给每个 scope 注册好 strategies，这样 warden 就会按照顺序去做检查了

# In Devise

Devise.mappings.each_value do |mapping|
   warden_config.scope_defaults mapping.name, strategies: mapping.strategies

   warden_config.serialize_into_session(mapping.name) do |record|
     mapping.to.serialize_into_session(record)
   end

   warden_config.serialize_from_session(mapping.name) do |args|
     mapping.to.serialize_from_session(*args)
   end
 end

总结

devise 依赖于 warden，要看 devise 的代码，最好先把 warden 代码过一遍

warden 是一个 rack app，会生成 env['warden'] 对象，供 Rails Controller 调用

warden 对不同的 scope 可以配置不同的 strategy。在进行 authenticate 的时候，要把 scope 传给 warden(或默认 default_scope)。warden 先查找 session 里的 user_key，并根据 session 里的 user_key 找到 user 对象，如果失败就会取出 scope 的 strategies 列表，挨个命中。

使用 catch 和 throw 可以跳出多层调用栈，有点像 goto 语句。如果未通过身份认证，通过 catch(:warden)，warden 会控制响应的后续过程。

warden 的设计很值得学习，作为一个框架，它将 authenticate 的部分问题解决了，并提供了简洁的 api 供上层调用。要完成 authenticate 验证，只需要写 strategy 和 failure_app 类，并将配置写入 warden 的类变量即可。

普通码农的思维总结

adamshen — Sat, 01 Apr 2017 11:43:50 +0800

看到这个标题，你一定会有疑问，什么叫普通码农。

相对普通码农，自然会有超级码农。记得刚参加工作的时候，我被分到一个路由器的组，专门干移植 bootloader 的工作。同组还有一个同事干同样的工作，只是我们会跟进不同项目。有一天早上，当我还在研究初始化代码的时候，我看到他正在用 GDB 工具看反汇编出来的代码。我问他这是在干嘛，他说他已经完成了这几个项目的移植，现在正在考虑是否可以对初始化代码用汇编来写。我当时在想，Are you kidding me？不过过一段时间他居然真的用汇编把这些东西给折腾出来了。

似乎有些人，他们更擅长高强度的脑力劳动。当时我们常常上完一天班已经很累了，他还能精力十足地跑两公里回家。果然几年以后，他就成为了别人眼中的大牛。这是超级码农，当时同组还有另一位同事，他只是编写简单的 html 代码，但干了两个月就辞职了。辞职的时候兴冲冲地和我说，终于不用再看这些烦人的代码啦。码农有各种各样的，其中也有一大堆和我一样的人。我们对于编程，即没有那么绝对的擅长，也没有那么厌倦。这样的人，姑且称之为普通码农吧。

作为一个普通码农，这些年我在编码的时候走了不少弯路。所以我想总结一下其中的几个经验教训，顺便和大家交流一下。

经验一、只在同一个抽象层次进行思考

人的短期记忆是很有限的，带来的结果就是在一个时间点上，我们能记住的逻辑拓扑是有限的。因此编码的时候，最好不要进行太多的纵向跨层次的思考。

复杂的单一应用维护起来比较让人头疼，因此通常会被拆分成微服务或者多个组件。接着每个组件有对应的框架结构，以及常用的第三方依赖。到具体编码的时候，我们只需要设计一组类去解决实际的问题。

一个实际的问题由一个或者一组类来解决，这一组类和他们的之间的接口是一个层次。到具体某个类里，它的每个接口的实现是下一个层次。如果某个算法特别复杂，又可以再抽象出一个层次。这样，没有必要的话不要写太长的方法。

在编码的时候可以有意识地切换思考的层次，在设计类图的时候不要想实现细节，在写一个子方法的时候不要去想该如何改善接口。

很多 Git Repo 在 commit 的时候要求改动接口和具体实现要分开提交，就是遵循上述的原则。这么多的语言、框架、范例就是为了让我们在面对复杂问题的时候，有一个相对标准的解耦的思路，节省我们的脑力。

过去在看大量代码的时候，我常常很焦虑，甚至怀疑我自己的职业生涯。然而只要学会循序渐进，不要在某个单点上透支注意力，解决一个复杂问题的时候可能就没有那么吃力了。

经验二、定期整理自己的知识结构

科学家发现，儿童和成人学习语言的方式是不同的。儿童学习语言会增加大脑的神经突触，而成人则是强化神经网络之间的联结。

对于我们学习的知识来说，最好的结构是树状和网状，不要把它们像关系型数据库一样存在不同的表里。

人脑有两个系统，一个和直觉、联想有关，可以快速作出决策。另一个和分析、运算有关，推演起来十分缓慢。强化各个概念之间的联结，会把原来分散的短期记忆融合到自己长期的记忆中去。这样不仅不容易把自己所学的知识忘记，还会同时加快自己的思考过程。

你可以把自己想象成一个人工智能，虽然运算能力没那么强大，但是框架却要比 tensorflow 好上一万倍。你不需要太多的数据，也可以优化自己的模型。

其实仔细一想，很多知识是完全相通的。我在学习 YARV 的时候，发现它的指令集和一些 cpu 指令集比如 x86 或者 mips 的有很多共通之处。而 js 实现异步的原理，和实时性操作系统 ucosii 实现多进程的方式如出一辙。

过去我在学习的时候，总是想方设法让自己强记某些知识，最后发现这样不仅低效且很容易因为经常忘记而让自己失去信心。所以，学习新的知识时，要尽量把它和老的知识做比较，建立知识点之间的联系，才能事半功倍。

经验三、Plan yourself

从一个点上看，人的短期记忆有限。有一条时间线上看，人在一段时间内的精力是有限的。

不要胡乱投资时间。我在刚参加工作的那几年，因为几个对硬件的问题不了解，就买了好几本数字高频电路的书来看。然而这些问题我到现在也没有搞懂，纯粹浪费了大量的时间。

你可以对自己想干的事情和所需要的技能作一个评估，决定自己要把时间投资在哪个技术领域。当然这不仅仅限于技术，也可以把时间用在技术之外的地方，这个看个人喜好了。

这是一个升维的问题，时常跳出自己当前的任务，想一想自己的整个生活。不要盲目，当更高维度的问题解决以后，自己在面临当前任务的时候也会更加心无旁贷。

总结

编码和其他很多事情一样，都不是一件容易的事情。如果你想节约时间，可以快乐编码，上完班可以找三四个好友，聚在大排档，喝点啤酒，谈谈人生。那么可以学习一门为优雅而生的语言——ruby。

入坑以后，你就会发现，这 TM 还是要有这么多东西要学，一点也不轻松。于是你就会抛弃轻松编码的幻想，继续努力工作。

完。

从 Rails 中学习元编程的使用场景

adamshen — Mon, 27 Mar 2017 16:53:17 +0800

Ruby 有许多元编程的特性，到底什么时候该用呢？这是个值得思考的问题

在不该用的地方使用这些特性，只能影响程序的可维护性，违反了写代码的蠢萌原则 (Kiss)

其实 Rails 里，就有大量使用元编程的例子。总结下来，主要目的有这么几种：

一、Rails 中元编程的使用场景

1.1 简化接口

在刚开始学习 Rails 的时候，我常常被 Rails dsl 的表达能力给震惊到

before_action :require_no_sso!, only: [:new, :create]
has_many :users, through: :team_users
resources :teams
...

短短几个单词能够干的事情很多，而为了支持这样的语法，就要在 dsl 的原方法里使用元编程来动态定义和调用一些方法

这种极简化接口的特点就是，只用最少数的语句描述关键行为，将实现的细节完全隐藏，达到代码的高度简洁

1.2 让代码更加语义化

比如 1.day.ago 这种完全可以读出来的代码，要用 money patch 来实现。

(4.months + 5.years).from_now

各种 hack scope，动态扩展类，使原本需要用函数调用实现的功能，还是依然可以用优雅的链式调用来进行表达

比如 ActiveRecord 里的 wherechain，写起来十分的优雅，令人感到舒服

Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(author: 'David')

1.3 Warning & Patch

比如 Api 变了，可以用 alias_method 来做个兼容

# *_action is the same as append_*_action
 alias_method :"append_#{callback}_action", :"#{callback}_action"

 define_method "append_#{callback}_filter" do |*names, &blk|
   ActiveSupport::Deprecation.warn("append_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use append_#{callback}_action instead.")
   send("append_#{callback}_action", *names, &blk)
 end

ruby 的动态特性使得在进行版本兼容的时候可以更加随心所欲

if RUBY_VERSION > "..."
    do something
end

1.4 DRY，减少重复性代码

如果要用相同的逻辑 wrapper 一些方法，或者注册一些逻辑相同的 helper 方法时，可以用元编程来减少代码量

%w(info debug warn error fatal unknown).each do |level|
  class_eval <<-METHOD, __FILE__, __LINE__ + 1
        def #{level}(progname = nil, &block)
          logger.#{level}(progname, &block) if logger
        end
  METHOD
end

1.5 实现功能性需求

有些 api 本身就需要利用语言的动态特性，这时就不得不用了

def helper_method(*meths)
  meths.flatten!
  self._helper_methods += meths

  meths.each do |meth|
    _helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
            def #{meth}(*args, &blk)                             
              controller.send(%(#{meth}), *args, &blk) 
            end                                                    
    ruby_eval
  end
end

再者，如果想扩展或者改变一些 ruby 语言的特性，就可以用到元编程

例如 autoload 和 ActiveSupport::Concern 或者 mattr_accessor 和 class_attribute 这样的功能，原生的 ruby 是不支持的，但是可以通过元编程来进行支持

二、总结

当你想实现的功能本来就依赖 ruby 的动态特性时，就必须要使用元编程。

另外元编程可以为模块化、语义化和 Dsl 提供支撑，让我们可以写更少的代码，写更明白的代码。

在使用 Ruby 或者 Rails 的过程中，你遇到过哪些令你印象深刻的坑？

adamshen — Fri, 03 Mar 2017 07:51:22 +0800

如题，请教各位，有没有哪些坑令你至今依然难以忘记

详解 has_many 方法在 Active Record 中的运行过程

adamshen — Thu, 02 Mar 2017 11:14:05 +0800

一、Reflection

Reflection 是 ar 用来记录 model 的 associations & aggregations 配置的一个类，不同的方法会创建不同的 Reflection 类型

composed_of 方法会创建一个 AggregateReflection 实例，而 has_many 方法会创建一个 AssociationReflection 实例

# Holds all the methods that are shared between MacroReflection and ThroughReflection.
#                                                                                     
#   AbstractReflection                                                                
#     MacroReflection                                                                 
#       AggregateReflection                                                           
#       AssociationReflection                                                         
#         HasManyReflection                                                           
#         HasOneReflection                                                            
#         BelongsToReflection                                                         
#         HasAndBelongsToManyReflection                                               
#     ThroughReflection                                                               
#       PolymorphicReflection                                                         
#         RuntimeReflection

Reflection 由统一的一个 builder 来进行实例化，下面的 create 方法创建一个 Reflection，它会把一条 dsl 语句 tokenize 成各种属性集，用来对 association 进行实际的配置

module ActiveRecord
  # = Active Record Reflection
  module Reflection # :nodoc:
    extend ActiveSupport::Concern

    included do
      class_attribute :_reflections, instance_writer: false
      class_attribute :aggregate_reflections, instance_writer: false
      self._reflections = {}
      self.aggregate_reflections = {}
    end

    def self.create(macro, name, scope, options, ar)
      klass = case macro
              when :composed_of
                AggregateReflection
              when :has_many
                HasManyReflection
              when :has_one
                HasOneReflection
              when :belongs_to
                BelongsToReflection
              else
                raise "Unsupported Macro: #{macro}"
              end

      reflection = klass.new(name, scope, options, ar)
      options[:through] ? ThroughReflection.new(reflection) : reflection
    end
    ...
end

比如下面这条语句会生成的 Reflection 如下，然后在创建 association 方法的时候，会调取这个 Reflection 来查询配置

has_many :tracks, -> { order("position") }, dependent: :destroy

 #<ActiveRecord::Reflection::HasManyReflection:0x007fc4ccd7e310
  @active_record=
   CheckCard(id: integer, name: string, title: string, level: integer, submit_times: integer, finish_times: integer, created_at: datetime, updated_at: datetime, user_id: integer, period: string),
  @association_scope_cache={},
  @automatic_inverse_of=nil,
  @constructable=true,
  @foreign_type="tracks_type",
  @klass=nil,
  @name=:tracks,
  @options={:dependent=>:destroy},
  @plural_name="tracks",
  @scope=#<Proc:0x007fc4ccd7e338@/usr/local/lib/ruby/gems/2.4.0/gems/activerecord-5.0.1/lib/active_record/associations/builder/association.rb:55>,
  @scope_lock=#<Thread::Mutex:0x007fc4ccd7e158>,
  @type=nil>]

在 association 设置完毕后，这个 Reflection 会被加入 model 的 Reflections 列表里，可以用 reflect_on_all_associations 方法打印出这个表，有什么用呢？文档上是这么说的

This information, for example, can be used in a form builder that takes an Active Record object and creates input fields for all of the attributes depending on their type and displays the associations to other objects.

Reflection 的实例除了保存配置以外，还存在一个 cache 和一个互斥锁。当进行一次 association 查询以后，相应的 statement 就会存到这个 cache 里，所以重新进行相同的 association 查询时要进行 reload 操作

二、has_many 的运行过程

  module Associations # :nodoc
    module Builder #:nodoc:
      autoload :Association,           'active_record/associations/builder/association'
      autoload :SingularAssociation,   'active_record/associations/builder/singular_association'
      autoload :CollectionAssociation, 'active_record/associations/builder/collection_association'

      autoload :BelongsTo,           'active_record/associations/builder/belongs_to'
      autoload :HasOne,              'active_record/associations/builder/has_one'
      autoload :HasMany,             'active_record/associations/builder/has_many'
      autoload :HasAndBelongsToMany, 'active_record/associations/builder/has_and_belongs_to_many'
    end

    module ClassMethod
     def has_many(name, scope = nil, options = {}, &extension)
        reflection = Builder::HasMany.build(self, name, scope, options, &extension)
        Reflection.add_reflection self, name, reflection
      end
    end
end

has_many 方法只有两行，它的实现方式全部都被封装到了 ActiveRecord::Associations::Builder::HasMany 类里

Builder::HasMany.build 方法不仅创建了 reflection，还同时对 association 进行了配置

这里类的继承关系是 Builder::HasMany < Builder::CollectionAssociation < Builder::Association

# The hierarchy is defined as follows:
#  Association
#    - SingularAssociation
#      - BelongsToAssociation
#      - HasOneAssociation
#    - CollectionAssociation
#      - HasManyAssociation

Builder::HasMany.build 方法由父类 Builder::Association 类来实现，它创建了一个 Reflection，定义了各种 accessors 方法，以及 callback 和 validations

module ActiveRecord::Associations::Builder # :nodoc:
  class Association #:nodoc:
    def self.build(model, name, scope, options, &block)
      if model.dangerous_attribute_method?(name)
        raise ArgumentError, "You tried to define an association named #{name} on the model #{model.name}, but " \
                             "this will conflict with a method #{name} already defined by Active Record. " \
                             "Please choose a different association name."
      end

      extension = define_extensions model, name, &block
      reflection = create_reflection model, name, scope, options, extension
      define_accessors model, reflection
      define_callbacks model, reflection
      define_validations model, reflection
      reflection
    end

接下来逐步看一下它的运行流程，首先检查一下方法名称是否已经被定义，然后生成一个 extension。define_extensions 方法在 CollectionAssociation 类里

In Model...

class Author < ApplicationRecord
  has_many :books do
    def find_by_book_prefix(book_number)
      find_by(category_id: book_number[0..2])
    end
  end
end

method...
    def self.define_extensions(model, name)
      if block_given?
        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
        extension = Module.new(&Proc.new)
        model.parent.const_set(extension_module_name, extension)
      end
    end

老实说这个方法，呃，十分有趣

首先假如 has_many 方法有 block，这个 block 会被传递给 Proc.new，然后再用&符号转成 block。也就是说，原来的 block 被通过一个 Proc 的中转交给了新建的 Module

这个新建的 Module 会立即在他的 scope 下运行这个 block。所以上面定义的这个 find_by_book_prefix 方法在新建的这个 Module 上被定义了

最后把新建的这个 Module 绑定在一个常量上，这个常量属于 model 的 parent 类，总之看起来既让人迷惑又觉得很酷

这个新建 Module 有什么用呢？其实和用 lambda 定义的 scope 作用是一样的，如果你同时用了 lambda 定义 scope，那么它们会呈链式调用

def self.wrap_scope(scope, mod)
  if scope
    if scope.arity > 0
      proc { |owner| instance_exec(owner, &scope).extending(mod) }
    else
      proc { instance_exec(&scope).extending(mod) }
    end
  else
    proc { extending(mod) }
  end
end

接下来是创建 Reflection 的方法

def self.create_reflection(model, name, scope, options, extension = nil)
  raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)

  if scope.is_a?(Hash)
    options = scope
    scope   = nil
  end

  validate_options(options)

  scope = build_scope(scope, extension)

  ActiveRecord::Reflection.create(macro, name, scope, options, model)
end

首先检查参数，允许没有 lambda 的情况，options 提前。然后校验 options 的 keys 是否合法。合并 lambda 和 extension，最后创建 reflection

接下来是生成 accessor 方法

def self.define_accessors(model, reflection)
  mixin = model.generated_association_methods
  name = reflection.name
  define_readers(mixin, name)
  define_writers(mixin, name)
end

def generated_association_methods
  @generated_association_methods ||= begin
    mod = const_set(:GeneratedAssociationMethods, Module.new)
    include mod
    mod
  end
end

这里生成的 accessor 方法并不是直接定义在 model 上，而是先新建一个 Module，include 到 model 里，然后再把各种方法定义到这个 Module 上。我猜这样做是为了可以让你自己在 model 定义同名方法，并使用 default_scope 调用原方法

Builder::Association 会定义类似 student.books 以及 student.books=这两个方法，Builder:: CollectionAssociation 扩展定义了_ids 方法

In super...
    def self.define_readers(mixin, name)
      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
        def #{name}(*args)
          association(:#{name}).reader(*args)
        end
      CODE
    end

    def self.define_writers(mixin, name)
      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
        def #{name}=(value)
          association(:#{name}).writer(value)
        end
      CODE
    end

In child...
    # Defines the setter and getter methods for the collection_singular_ids.
    def self.define_readers(mixin, name)
      super

      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
        def #{name.to_s.singularize}_ids
          association(:#{name}).ids_reader
        end
      CODE
    end

    def self.define_writers(mixin, name)
      super

      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
        def #{name.to_s.singularize}_ids=(ids)
          association(:#{name}).ids_writer(ids)
        end
      CODE
    end

再接下来是定义 callbacks，关于 callbacks 链可以见上一篇文章

这里没有做什么特别的事情，只是从 Reflection 中提取 callback 的配置，然后写到相对应的 callbacks 链中

CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]

def self.define_callbacks(model, reflection)
  super
  name    = reflection.name
  options = reflection.options
  CALLBACKS.each { |callback_name|
    define_callback(model, callback_name, name, options)
  }
end

def self.define_callback(model, callback_name, name, options)
  full_callback_name = "#{callback_name}_for_#{name}"

  # TODO : why do i need method_defined? I think its because of the inheritance chain
  model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
  callbacks = Array(options[callback_name.to_sym]).map do |callback|
    case callback
    when Symbol
      ->(method, owner, record) { owner.send(callback, record) }
    when Proc
      ->(method, owner, record) { callback.call(owner, record) }
    else
      ->(method, owner, record) { callback.send(method, owner, record) }
    end
  end
  model.send "#{full_callback_name}=", callbacks
end

最后 define_validations，Builder::HasMany 并没有覆写这个方法，所以这里什么也没干

三、总结

声明 associations 的各个方法 belongs_to、has_many 的运行过程分两步。一是创建 Reflection，二是把 Reflection 当参数丢过去来进行实际配置。

运行过程由 Builder 控制，因为 associations 的 dsl 基本都需要创建读写命令和 callbacks，流程差不多。所以它们的配置方法由父类来定义，然后具体的实现细节由不同的子类来实现。

详解 Rails Controller 中的 Callback

adamshen — Wed, 22 Feb 2017 11:15:54 +0800

一、ActiveSupport::Callbacks

1.1 例子

rails 中的 callback 使用 ActiveSupport::Callbacks 模块来实现，Api 文档里有一个相应的例子

使用的方法是先创建一个空的 callback 链表，给这个 callback 链表 push 一些方法，然后在需要运行 callback 的地方调用该队列

class Record
  include ActiveSupport::Callbacks
  define_callbacks :save

  def save
    run_callbacks :save do
      puts "- save"
    end
  end
end

class PersonRecord < Record
  set_callback :save, :before, :saving_message
  def saving_message
    puts "saving..."
  end

  set_callback :save, :after do |object|
    puts "saved"
  end
end

person = PersonRecord.new
person.save

Output:

saving... -save saved

1.2 初始化 callback 链

define_callbacks 方法会定义一个类变量，然后把一个空的 callback 链赋值给这个类变量。这个变量的值可以被子类继承，一旦该类被继承，子类也会拥有这个 callback 链

同时在这个方法里会根据 name 来创建一个 run 方法以供调用

def define_callbacks(*names)
  options = names.extract_options!

  names.each do |name|
    class_attribute "_#{name}_callbacks", instance_writer: false
    set_callbacks name, CallbackChain.new(name, options)

    module_eval <<-RUBY, __FILE__, __LINE__ + 1
      def _run_#{name}_callbacks(&block)
        __run_callbacks__(_#{name}_callbacks, &block)
      end
    RUBY
  end
end

def set_callbacks(name, callbacks) # :nodoc:
  send "_#{name}_callbacks=", callbacks
end

1.3 注册 hook_method

set_callback 方法会将一个 hook_method 注入 Callback 链

def set_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)
  self_chain = get_callbacks name
  mapped = filters.map do |filter|
    Callback.build(self_chain, filter, type, options)
  end

  __update_callbacks(name) do |target, chain|
    options[:prepend] ? chain.prepend(*mapped) : chain.append(*mapped)
    target.set_callbacks name, chain
  end
end

1.4 调用 callback 链

run_callbacks 方法会调用前面 define_callbacks 方法里定义的 run 方法

def run_callbacks(kind, &block)
  send "_run_#{kind}_callbacks", &block
end

run 方法内部根据 callback 链生成一个 callback 队列，然后直接运行这个 callback 队列

def __run_callbacks__(callbacks, &block)
  if callbacks.empty?
    yield if block_given?
  else
    runner = callbacks.compile
    e = Filters::Environment.new(self, false, nil, block)
    runner.call(e).value
  end
end

二、Controller 中的 callback

2.1 定义 callback 链

contoller 中的 callback 链在 AbstractController::Callbacks 中定义

module AbstractController
  extend ActiveSupport::Autoload

  ...
  autoload :Callbacks
  ...
end

module AbstractController
  module Callbacks
    ...
    included do
      define_callbacks :process_action,
                       terminator: ->(controller, result_lambda) { result_lambda.call if result_lambda.is_a?(Proc); controller.performed? },
                       skip_after_callbacks_if_terminated: true
    end
    ...
  end
end

2.2 注册 hook_method

在 controller 里我们不使用 set_callback 来定义 callback 函数，因为 rails wrapper 了一层 help 方法，可以省略一些参数

[:before, :after, :around].each do |callback|
  define_method "#{callback}_action" do |*names, &blk|
    _insert_callbacks(names, blk) do |name, options|
      set_callback(:process_action, callback, name, options)
    end
  end

  define_method "#{callback}_filter" do |*names, &blk|
    ActiveSupport::Deprecation.warn("#{callback}_filter is deprecated and will be removed in Rails 5.1. Use #{callback}_action instead.")
    send("#{callback}_action", *names, &blk)
  end

  define_method "prepend_#{callback}_action" do |*names, &blk|
    _insert_callbacks(names, blk) do |name, options|
      set_callback(:process_action, callback, name, options.merge(:prepend => true))
    end
  end

  define_method "prepend_#{callback}_filter" do |*names, &blk|
    ActiveSupport::Deprecation.warn("prepend_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use prepend_#{callback}_action instead.")
    send("prepend_#{callback}_action", *names, &blk)
  end

  # Skip a before, after or around callback. See _insert_callbacks
  # for details on the allowed parameters.
  define_method "skip_#{callback}_action" do |*names|
    _insert_callbacks(names) do |name, options|
      skip_callback(:process_action, callback, name, options)
    end
  end

  define_method "skip_#{callback}_filter" do |*names, &blk|
    ActiveSupport::Deprecation.warn("skip_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use skip_#{callback}_action instead.")
    send("skip_#{callback}_action", *names, &blk)
  end

  # *_action is the same as append_*_action
  alias_method :"append_#{callback}_action", :"#{callback}_action"

  define_method "append_#{callback}_filter" do |*names, &blk|
    ActiveSupport::Deprecation.warn("append_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use append_#{callback}_action instead.")
    send("append_#{callback}_action", *names, &blk)
  end
end

根据代码，在 rails5.1 里调用各种 xxxxx_filter 的结果就是直接转发给 xxxxx_action，同时给 xxxxx_action 取了个别名叫 append_xxxxx_action

既然知道了 callbacks 链的 name 是:process_action，我们就可以用 define_callbacks 生成的方法打印出 callbacks 链

class Api::Test < ApplicationController
  puts _process_action_callbacks
  before_action :authenticate_api_user!, only: :create
  puts _process_action_callbacks
  ...
end

before_action 前，callbacks 链里只有两个 callback

#<ActiveSupport::Callbacks::CallbackChain:0x0055aba4e7c278
 @callbacks=nil,
 @chain=
  [#<ActiveSupport::Callbacks::Callback:0x0055aba4e7c980
    @chain_config=
     {:scope=>[:kind],
      :terminator=>#<Proc:0x0055aba4e2fd88@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/callbacks.rb:12 (lambda)>,
      :skip_after_callbacks_if_terminated=>true},
    @filter=:set_request_start,
    @if=[],
    @key=:set_request_start,
    @kind=:before,
    @name=:process_action,
    @unless=[]>,
   #<ActiveSupport::Callbacks::Callback:0x0055aba4e7c3b8
    @chain_config=
     {:scope=>[:kind],
      :terminator=>#<Proc:0x0055aba4e2fd88@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/callbacks.rb:12 (lambda)>,
      :skip_after_callbacks_if_terminated=>true},
    @filter=:update_auth_header,
    @if=[],
    @key=:update_auth_header,
    @kind=:after,
    @name=:process_action,
    @unless=[]>],
 @config=
  {:scope=>[:kind],
   :terminator=>#<Proc:0x0055aba4e2fd88@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/callbacks.rb:12 (lambda)>,
   :skip_after_callbacks_if_terminated=>true},
 @mutex=#<Thread::Mutex:0x0055aba4e7c228>,
 @name=:process_action>

执行了 before_action 后，callback 链里增加了一个 callback

#<ActiveSupport::Callbacks::CallbackChain:0x0055aba4bcd9f0
 @callbacks=nil,
 @chain=
  ...同上省略
   #<ActiveSupport::Callbacks::Callback:0x0055aba4c14968
    @chain_config=
     {:scope=>[:kind],
      :terminator=>#<Proc:0x0055aba4e2fd88@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/callbacks.rb:12 (lambda)>,
      :skip_after_callbacks_if_terminated=>true},
    @filter=:authenticate_api_user!,
    @if=[#<Proc:0x0055aba4c4c340@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/callbacks.rb:52>],
    @key=:authenticate_api_user!,
    @kind=:before,
    @name=:process_action,
    @unless=[]>],
 @config=
  {:scope=>[:kind],
   :terminator=>#<Proc:0x0055aba4e2fd88@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/callbacks.rb:12 (lambda)>,
   :skip_after_callbacks_if_terminated=>true},
 @mutex=#<Thread::Mutex:0x0055aba4bb1ea8>,
 @name=:process_action>

试着打印生成的 callback 队列

_process_action_callbacks.compile
=> #<ActiveSupport::Callbacks::CallbackSequence:0x0055aba3454738
 @after=[#<Proc:0x0055aba34541c0@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:216>],
 @before=
  [#<Proc:0x0055aba3454080@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:163>,
   #<Proc:0x0055aba34543a0@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:144>],
 @call=#<Proc:0x0055aba3454698@/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:506>>

2.3 调用 callback 链

# Override AbstractController::Base's process_action to run the
# process_action callbacks around the normal behavior.
def process_action(*args)
  run_callbacks(:process_action) do
    super
  end
end

前面的 set 和 define 都发生在类源文件被 load 的过程中，但是 run_callbacks 在何时被调用却并不清晰，因此在 controller 中直接打印调用栈来查看

 [
...
"/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:101:in `__run_callbacks__'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:750:in `_run_process_action_callbacks'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:90:in `run_callbacks'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/callbacks.rb:19:in `process_action'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_controller/metal/rescue.rb:20:in `process_action'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_controller/metal/instrumentation.rb:32:in `block in process_action'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/notifications.rb:164:in `block in instrument'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/notifications/instrumenter.rb:21:in `instrument'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/notifications.rb:164:in `instrument'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_controller/metal/instrumentation.rb:30:in `process_action'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_controller/metal/params_wrapper.rb:248:in `process_action'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activerecord-5.0.1/lib/active_record/railties/controller_runtime.rb:18:in `process_action'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/abstract_controller/base.rb:126:in `process'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_controller/metal.rb:190:in `dispatch'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_controller/metal.rb:262:in `dispatch'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/routing/route_set.rb:50:in `dispatch'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/routing/route_set.rb:32:in `serve'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/journey/router.rb:39:in `block in serve'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/journey/router.rb:26:in `each'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/journey/router.rb:26:in `serve'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/routing/route_set.rb:725:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/warden-1.2.7/lib/warden/manager.rb:36:in `block in call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/warden-1.2.7/lib/warden/manager.rb:35:in `catch'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/warden-1.2.7/lib/warden/manager.rb:35:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/rack-2.0.1/lib/rack/etag.rb:25:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/rack-2.0.1/lib/rack/conditional_get.rb:25:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/rack-2.0.1/lib/rack/head.rb:12:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activerecord-5.0.1/lib/active_record/migration.rb:553:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/callbacks.rb:38:in `block in call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:97:in `__run_callbacks__'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:750:in `_run_call_callbacks'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/callbacks.rb:90:in `run_callbacks'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/callbacks.rb:36:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/executor.rb:12:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/remote_ip.rb:79:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/debug_exceptions.rb:49:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/show_exceptions.rb:31:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-5.0.1/lib/rails/rack/logger.rb:36:in `call_app'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-5.0.1/lib/rails/rack/logger.rb:24:in `block in call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/tagged_logging.rb:69:in `block in tagged'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/tagged_logging.rb:26:in `tagged'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/tagged_logging.rb:69:in `tagged'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-5.0.1/lib/rails/rack/logger.rb:24:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/request_id.rb:24:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/rack-2.0.1/lib/rack/runtime.rb:22:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/activesupport-5.0.1/lib/active_support/cache/strategy/local_cache_middleware.rb:28:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/executor.rb:12:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/actionpack-5.0.1/lib/action_dispatch/middleware/static.rb:136:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/rack-2.0.1/lib/rack/sendfile.rb:111:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/rack-cors-0.4.1/lib/rack/cors.rb:81:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/railties-5.0.1/lib/rails/engine.rb:522:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/puma-3.7.0/lib/puma/configuration.rb:226:in `call'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/puma-3.7.0/lib/puma/server.rb:578:in `handle_request'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/puma-3.7.0/lib/puma/server.rb:415:in `process_client'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/puma-3.7.0/lib/puma/server.rb:275:in `block in run'",
 "/home/adam/.rbenv/versions/2.3.0/lib/ruby/gems/2.3.0/gems/puma-3.7.0/lib/puma/thread_pool.rb:120:in `block in spawn_thread'"]

大致上一次请求从 puma 侦听到 IO 并交给 rack，经过路由找到对应的 controller 之后，就会进到 process_action

很多 module 都有这个方法，利用 super 根据 include 进来的顺序倒顺执行，控制响应请求的过程，callback 是其中一环

使用 serialize 在 db 中储存 hash 对象时遇到的一个小问题

adamshen — Mon, 12 Dec 2016 11:11:04 +0800

更改 attibutes 方法生成出来的 hash 对象再 save 以后，会改变数据库里实际所存储的值

class Request < ActiveRecord::Base
  serialize :options
end

request = Request.last
=> options: {level: 7}

request_hash = request.attributes
request_hash['options'] = {level: 0}
request.save
request.reload

request  => options: {level: 0}

造成这个问题的原因是 attributes 方法得到的 hash 里，key options 所指向的 obj 和 ActiveRecord::Attribute::FromDatabase 实例里 value 变量所指向的 obj 是同一个 obj

request.options.equal?(request.attributes['options'])
=> true

AD 的 instance 里用 attributes 变量暂存 record 的值

# From: /opt/rubies/ruby-2.3.1/lib/ruby/gems/2.3.0/gems/activerecord-5.0.0.1/lib/active_record/attribute_methods.rb @ line 275:
def attributes
  @attributes.to_hash
end

它是一个 ActiveRecord::AttributeSet 的实例

每一个 column 的 value 用 ActiveRecord::Attribute::FromDatabase 的实例来存储

request.instance_variable_get(:@attributes)

=> #<ActiveRecord::AttributeSet:0x00000008d8e930
 @attributes=
  #<ActiveRecord::LazyAttributeHash:0x00000008d8e980
   @additional_types={},
   @delegate_hash=
    {"options"=>
      #<ActiveRecord::Attribute::FromDatabase:0x00000008d86de8
       @name="options",
       @original_attribute=nil,
       @type=#<ActiveModel::Type::Text:0x00000000f73668 @limit=nil, @precision=nil, @scale=nil>,
       @value=
        {:level => 0}
     }

当使用 attributes 方法时，只是取出 ActiveRecord::Attribute::FromDatabase 实例的 value 变量指向的对象，没有进行 dup，所以产生了上述问题

# From: /opt/rubies/ruby-2.3.1/lib/ruby/gems/2.3.0/gems/activerecord-5.0.0.1/lib/active_record/attribute_set.rb @ line 21:
def to_hash
  initialized_attributes.transform_values(&:value)
end

[上海] VaneCloud 中科氢氧 Ruby 高级工程师

adamshen — Thu, 08 Sep 2016 15:56:53 +0800

我们是谁？

中科氢氧云计算（上海）有限公司（以下简称“中科氢氧”）于 2015 年成立，是《中国云体系产业创新战略联盟》的理事单位。公司在北京、广州、合肥等地设有多个分支机构，业务范围覆盖华北、华东、华中和华南等大部分地区。

中科氢氧的核心技术团队，由中科院的骨干技术人员以及原 IBM 等前全球 50 强的研发团队共同组成，公司致力于开发企业私有云平台 (vaneCloud)、大数据解决方案和私有云盘（VaneDisk）的提供商。创新、服务激情和责任是我们公司创立至今一直秉承的服务理念，以此来为我们的客户提供赋有前瞻性和可持续性的优质的产品和服务。

招聘职位

rails 高级工程师

岗位职责

基于 Ruby on Rails 框架进行云计算管理平台的设计和开发

职位要求

熟悉 Ruby, Ruby on Rails，有两年及以上 Ruby on Rails 项目开发经验；
熟悉 HTML, CSS, Javascript，jQuery，JSON 等 Web 相关技术；
熟悉 Git 等版本控制工具，Linux 操作系统；
有良好的代码书写和编程习惯、非常强的学习能力，解决问题的能力；
加分条件：云计算等相关工作经验者优先；有大中型 WEB 网站开发经验者优先; 有自己的 blog 或 github 链接；
具有团队合作精神，有责任感，能承受一定的工作压力、保持工作效率

福利待遇

我们不想说弹（jia）性（ban）工作，如果你产出足够高效，时间自己安排，做五休二
10K~20K，一年至少一次薪水调整
四险一金带薪年假
云计算先关，高挑战、快成长环境

舒适的工作环境

工作地点

上海市徐汇区漕河泾桂平路 471 号 3 号楼 3 楼

简历投递

wangxiangyu@vanecloud.com

介绍一个好玩的工具给大家，可以生成类关联网状图

adamshen — Mon, 29 Aug 2016 12:53:55 +0800

https://github.com/blazeeboy/rubrowser

我玩了下 puma 的

有没有人实践过用 Docker 部署 Rails 集群，效果如何？

adamshen — Wed, 27 Jul 2016 11:47:40 +0800

对 Rails 来说容器级别的隔离应该满足部署集群的需要了吧？

[上海] VaneCloud 中科氢氧 Rails 高级工程师

adamshen — Tue, 12 Jul 2016 13:52:54 +0800

我们是谁？

招聘职位

rails 高级工程师

岗位职责

基于 Ruby on Rails 框架进行云计算管理平台的设计和开发

职位要求

熟悉 Ruby, Ruby on Rails，有两年及以上 Ruby on Rails 项目开发经验；
熟悉 HTML, CSS, Javascript，jQuery，JSON 等 Web 相关技术；
熟悉 Git 等版本控制工具，Linux 操作系统；
有良好的代码书写和编程习惯、非常强的学习能力，解决问题的能力；
加分条件：云计算等相关工作经验者优先；有大中型 WEB 网站开发经验者优先; 有自己的 blog 或 github 链接；
具有团队合作精神，有责任感，能承受一定的工作压力、保持工作效率

福利待遇

我们不想说弹（jia）性（ban）工作，如果你产出足够高效，时间自己安排，做五休二
10K~20K，一年至少一次薪水调整
四险一金带薪年假
云计算先关，高挑战、快成长环境

舒适的工作环境

工作地点

上海市徐汇区漕河泾桂平路 471 号 3 号楼 3 楼

简历投递

wangxiangyu@vanecloud.com

在 Rails 项目里，redis 一般用来存哪些数据？

adamshen — Wed, 01 Jun 2016 21:20:56 +0800

上次听演讲，薄荷说薄荷网的 Redis 服务器里数据量最大的都存了十几个 G 的数据了，larry 说简书有许多 redis 服务器，不同的服务器里存了不同的东西。很好奇这些 redis 服务器里都存了什么，如果我自己做项目，要如何设计哪些数据存在 mysql 里，哪些存在 redis 里？

无聊爬了下 GitHub 上的开源 Rails 项目

adamshen — Wed, 25 May 2016 12:29:56 +0800

按照 star 数量排序，本站排名 11。如果不算工具类的，仅次于 discourse。

Name	Description
discourse/discourse	A platform for community discussion. Free, open, simple.
gitlabhq/gitlabhq	GitLab is version control for your server
cantino/huginn	Build agents that monitor and act on your behalf. Your agents are standing by!
diaspora/diaspora	A privacy-aware, distributed, open source social network.
errbit/errbit	The open source error catcher that's Airbrake API compliant
lockitron/selfstarter	Roll your own crowdfunding
fatfreecrm/fat_free_crm	Ruby on Rails CRM platform for Web 2.0 and beyond
edavis10/redmine	Redmine is a flexible project management web application written using Ruby on Rails framework. http://github.com/edavis10/redmine is the official git mirror of the svn repository
comfy/comfortable-mexican-sofa	ComfortableMexicanSofa is a powerful Rails 4 CMS Engine
ruby-china/ruby-china	Ruby China website source code.
teambox/teambox	This is the legacy version of Teambox - the award-winning collaboration solution, inspired by Basecamp, Yammer and Twitter.
redmine/redmine	Mirror of redmine code source - Official SVN repository is at https://svn.redmine.org/redmine - contact: @jbbarth or jeanbaptiste.barth (at) gmail (dot) com
instructure/canvas-lms	The open LMS by Instructure, Inc.
hummingbird-me/hummingbird	Probably the coolest anime discovery platform around.
feedbin/feedbin	RSS Reader
publify/publify	A self hosted Web publishing platform on Rails.
tenex/rails-assets	The solution to assets management in Rails
natew/obtvse	Deprecated: See natew/obtvse2
gitlabhq/gitlab-ci	Mirror of GitLab CI, please use GitLab.com repo for issues
rubygems/rubygems.org	The Ruby community's gem hosting service.
eliotsykes/rspec-rails-examples	RSpec cheatsheet & Rails app: Learn how to expertly test Rails apps from a model codebase
churchio/onebody	private member portal for churches, built with Ruby on Rails
houndci/hound	Automated review for code style
loomio/loomio	Loomio is an open-source web application that helps groups make better decisions together.
ivaldi/brimir	Email helpdesk built using Ruby on Rails and Zurb Foundation
jcs/lobsters	Rails code running the Lobsters link aggregation site
RailsApps/rails-stripe-membership-saas	An example Rails 4.2 app with Stripe and the Payola gem for a membership or subscription site.
drhenner/ror_ecommerce	Ruby on Rails Ecommerce platform, perfect for your small business solution.
phusion/juvia	A commenting server similar to Disqus and IntenseDebate. CURRENTLY UNMAINTAINED
chloerei/writings	Closed] Source code of writings.io
SquareSquash/web	Squash’s front-end and API host.
iridakos/duckrails	A development tool to quickly & dynamically mock API endpoints
asciinema/asciinema.org	asciinema.org web app
peritor/webistrano	Webistrano is a Web UI for managing Capistrano deployments
24pullrequests/24pullrequests	Giving back little gifts of code for Christmas
fdietz/team_dashboard	Visualize your team's metrics all in one place.
shakacode/react-webpack-rails-tutorial	Example of integration of Rails, react, redux, using the react_on_rails gem, webpack, enabling the es7 and jsx transpilers, and node integration. Live Demo:
coderwall/coderwall-legacy	Professional network for software engineers
xaviershay/enki	A Ruby on Rails blogging app for the fashionable developer. It's better than Mephisto or SimpleLog
jeromegn/DocumentUp	Pretty documentation generator for Github projects with proper Readme.
github-archive/swordfish	EXPERIMENTAL password management app. Don't use this.
peatio/peatio	An open-source assets exchange.
SUSE/Portus	Authorization service and frontend for Docker registry (v2)
TracksApp/tracks	Tracks is a GTD™ web application, built with Ruby on Rails
fredwu/angel_nest	Project code name: Angel Nest. :)
ryanb/railscasts	railscasts.com in open source (outdated).
hotsh/rstat.us	Simple microblogging network based on the ostatus protocol.
github-awards	Discover your ranking on github
spark/thermostat	A place for all things related to ye olde Spark Thermostat Hackathon
copycopter/copycopter-server	Copycopter Server is open source. Run it as a web service.
DefactoSoftware/Hours	Time registration that doesn't suck
saberma/shopqi	An open source clone of Shopify.
robotmay/photographer-io	An open source photography community. No longer in production but still open source.
zendesk/samson	Web interface for deployments
iobridge/thingspeak	An open source “Internet of Things” application
thoughtworks/cruisecontrol.rb	CruiseControl for Ruby. Keep it simple.
daqing/rabel	A powerful web community software to manage people, relationship and information
masuidrive/open-wripe	https://wri.pe source code
chiliproject/chiliproject	ChiliProject is a web based project management system built on Ruby on Rails
rafaelfranca/simple_form-bootstrap	Example application with SimpleForm and Twitter Bootstrap
joelmoss/strano	Capistrano and Github sittin' in a tree...
binarylogic/authlogic_example	An example rails app using the Authlogic authentication library
harrystech/prelaunchr	A small and simple Rails 4 project that is ready to be used as a prelaunch site. It includes all the necessary requirements like prize groups, open/closed states, and simple social sharing.
Crowdtilt/CrowdtiltOpen	Open source crowdfunding platform -
19wu/19wu	19 屋 - 专注于技术社区的活动平台，Based on Rails, AngularJS and Bootstrap
ari/jobsworth	Project Management, Collaboration and Time Tracking.
courtenay/altered_beast	Ground-up rewrite of Beast, a Ruby on Rails forum.
RailsApps/rails3-bootstrap-devise-cancan	Outdated. See the rails-devise-pundit example app for Rails 4.1.
atmos/heaven	Rails app for GitHub Flow
documentcloud/documentcloud	The DocumentCloud platform

带 demo 的看这里 https://github.com/adamshen/rails_source_colletion/blob/master/README.md

del

adamshen — Mon, 23 May 2016 23:27:46 +0800

.......

最近 electron 发布了 v1.0 之后，超级火爆啊

adamshen — Fri, 13 May 2016 11:31:52 +0800

会不会迎来新一轮爆炸？

发现一个还不错的 Ruby C API Guide

adamshen — Wed, 20 Apr 2016 09:51:35 +0800

https://silverhammermba.github.io/emberb/c/

adamshen (adam.shen)

感觉 UI 风格比以前好看了耶

论坛新人值得一看的，Ruby China 上的经典讨论贴子集合 (2016 年 以前)

Asset Pipe

Front

Turbolink

Api

ActiveRecord

Cache

Log

并发

测试

rspec

Ruby

重构

Rails

性能

db

部署

算法

使用 Ruby 进行混合云开发的小伙伴，一起来交流一下吧

Warden 的代码学习

Warden

auth result handle

scope

strategies

总结

普通码农的思维总结

从 Rails 中学习元编程的使用场景

一、Rails 中元编程的使用场景

1.1 简化接口

1.2 让代码更加语义化

1.3 Warning & Patch

1.4 DRY，减少重复性代码

1.5 实现功能性需求

二、总结

在使用 Ruby 或者 Rails 的过程中，你遇到过哪些令你印象深刻的坑？

详解 has_many 方法在 Active Record 中的运行过程

一、Reflection

二、has_many 的运行过程

三、总结

详解 Rails Controller 中的 Callback

一、ActiveSupport::Callbacks

1.1 例子

1.2 初始化 callback 链

1.3 注册 hook_method

1.4 调用 callback 链

二、Controller 中的 callback

2.1 定义 callback 链

2.2 注册 hook_method

2.3 调用 callback 链

推荐一下编辑器 nuclide 的 remote 功能，可以方便地修改远程代码

使用 serialize 在 db 中储存 hash 对象时遇到的一个小问题

[上海] VaneCloud 中科氢氧 Ruby 高级工程师

我们是谁？

招聘职位

岗位职责

职位要求

福利待遇

舒适的工作环境

工作地点

简历投递

介绍一个好玩的工具给大家，可以生成类关联网状图

有没有人实践过用 Docker 部署 Rails 集群，效果如何？

[上海] VaneCloud 中科氢氧 Rails 高级工程师

我们是谁？

招聘职位

岗位职责

职位要求

福利待遇

舒适的工作环境

工作地点

简历投递

在 Rails 项目里，redis 一般用来存哪些数据？

无聊爬了下 GitHub 上的开源 Rails 项目

del

最近 electron 发布了 v1.0 之后，超级火爆啊

发现一个还不错的 Ruby C API Guide

论坛新人值得一看的，Ruby China 上的经典讨论贴子集合 (2016 年以前)