class User < ActiveRecord::Base
  validates :name, length: { maximum: 30 }
end

    $ git clone [email protected]:\<自分のアカウント名\>/rails.git

    $ rails new CodeReading

..
|+CodeReading/
|+rails/

# Gemfile
source 'https://rubygems.org'

gem 'rails', path: '../rails'
gem 'pg'
gem 'pry-rails'
gem 'pry-doc'
gem 'pry-byebug'
gem 'byebug'

    $ bundle install

    $ rails g model User name:string

class User < ActiveRecord::Base

binding.pry
  validates :name, length: { maximum: 30 }
end

$ rails c
[1] pry(main)> u = User.new(name: 'sample name')

From: /app/models/user.rb @ line 4 :

    1: class User < ActiveRecord::Base
    2:
    3: binding.pry
 => 4:   validates :name, length: { maximum: 3 }
    5: end

[1] pry(User)> step

From: /rails/activemodel/lib/active_model/validations/validates.rb @ line 105 ActiveModel::Validations::ClassMethods#validates:

    104: def validates(*attributes)
 => 105:   defaults = attributes.extract_options!.dup
    106:   validations = defaults.slice!(*_validates_default_keys)
    107:
    108:   raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
    109:   raise ArgumentError, "You need to supply at least one validation" if validations.empty?
    110:
    111:   defaults[:attributes] = attributes
    112:
    113:   validations.each do |key, options|
    114:     next unless options
    115:     key = "#{key.to_s.camelize}Validator"
    116:
    117:     begin
    118:       validator = key.include?('::'.freeze) ? key.constantize : const_get(key)
    119:     rescue NameError
    120:       raise ArgumentError, "Unknown validator: '#{key}'"
    121:     end
    122:
    123:     validates_with(validator, defaults.merge(_parse_validates_options(options)))
    124:   end
    125: end

104: def validates(*attributes)
105:   defaults = attributes.extract_options!.dup
106:   validations = defaults.slice!(*_validates_default_keys)

[1] pry(User)> attributes
=> [:name, {:length=>{:maximum=>30}}]

class Hash
  # By default, only instances of Hash itself are extractable.
  # Subclasses of Hash may implement this method and return
  # true to declare themselves as extractable. If a Hash
  # is extractable, Array#extract_options! pops it from
  # the Array when it is the last element of the Array.
  def extractable_options?
    instance_of?(Hash)
  end
end

class Array
  # Extracts options from a set of arguments. Removes and returns the last
  # element in the array if it's a hash, otherwise returns a blank hash.
  #
  #   def options(*args)
  #     args.extract_options!
  #   end
  #
  #   options(1, 2)        # => {}
  #   options(1, 2, a: :b) # => {:a=>:b}
  def extract_options!
    if last.is_a?(Hash) && last.extractable_options?
      pop
    else
      {}
    end
  end
end

    105: defaults = attributes.extract\_options!.dup

    106: validations = defaults.slice!(\*\_validates\_default\_keys)

protected

  # When creating custom validators, it might be useful to be able to specify
  # additional default keys. This can be done by overwriting this method.
  def _validates_default_keys # :nodoc:
    [:if, :unless, :on, :allow_blank, :allow_nil , :strict]
  end

    validates :name, length: { maximum: 3 }, unless: "name.nil?"

[1] pry(User)> validations
=> {:length=>{:maximum=>30}}
[2] pry(User)> defaults
=> {:unless=>"name.nil?"}

108: raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
109: raise ArgumentError, "You need to supply at least one validation" if validations.empty?