根据ActiveRecord::Base里的继承链向上阅读
module ActiveRecord #:nodoc:
class Base
extend ActiveModel::Naming
extend ActiveSupport::Benchmarkable
extend ActiveSupport::DescendantsTracker
extend ConnectionHandling
extend QueryCache::ClassMethods
extend Querying
extend Translation
extend DynamicMatchers
extend Explain
extend Enum
extend Delegation::DelegateCache
extend Aggregations::ClassMethods
include Core
include Persistence
include ReadonlyAttributes
include ModelSchema
include Inheritance
include Scoping
include Sanitization
include AttributeAssignment
include ActiveModel::Conversion
include Integration
include Validations
include CounterCache
include Attributes
include AttributeDecorators
include Locking::Optimistic
include Locking::Pessimistic
include DefineCallbacks
include AttributeMethods
include Callbacks
include Timestamp
include Associations
include ActiveModel::SecurePassword
include AutosaveAssociation
include NestedAttributes
include Transactions
include TouchLater
include NoTouching
include Reflection
include Serialization
include Store
include SecureToken
include Suppressor
end
ActiveSupport.run_load_hooks(:active_record, Base)
end
ActiveRecord::Suppressor
先是Suppressor，先看功能部分：
order = Order.last
Order.suppress do
order.update(phone_number: "1xxxxxxxxxx")
end
order #=> phone_number 并没有被保存到数据库
被suppress（抑制）包裹的持久化语句将不会执行save操作。
module Suppressor
extend ActiveSupport::Concern
module ClassMethods
def suppress(&block)
previous_state = SuppressorRegistry.suppressed[name]
SuppressorRegistry.suppressed[name] = true
yield
ensure
SuppressorRegistry.suppressed[name] = previous_state
end
end
def save(*) # :nodoc:
SuppressorRegistry.suppressed[self.class.name] ? true : super
end
def save!(*) # :nodoc:
SuppressorRegistry.suppressed[self.class.name] ? true : super
end
end
class SuppressorRegistry # :nodoc:
extend ActiveSupport::PerThreadRegistry
attr_reader :suppressed
def initialize
@suppressed = {}
end
end
end
关于ActiveSupport::PerThreadRegistry可以看这里.
ActiveRecord::SecureToken
定义了随机生成token的，并保存到相应字段的功能。
# frozen_string_literal: true
module ActiveRecord
module SecureToken
extend ActiveSupport::Concern
module ClassMethods
# Example using #has_secure_token
#
# # Schema: User(token:string, auth_token:string)
# class User < ActiveRecord::Base
# has_secure_token
# has_secure_token :auth_token
# end
#
# user = User.new
# user.save
# user.token # => "pX27zsMN2ViQKta1bGfLmVJE"
# user.auth_token # => "77TMHrHJFvFDwodq8w7Ev2m7"
# user.regenerate_token # => true
# user.regenerate_auth_token # => true
#
# <tt>SecureRandom::base58</tt> is used to generate the 24-character unique token, so collisions are highly unlikely.
#
# Note that it's still possible to generate a race condition in the database in the same way that
# {validates_uniqueness_of}[rdoc-ref:Validations::ClassMethods#validates_uniqueness_of] can.
# You're encouraged to add a unique index in the database to deal with this even more unlikely scenario.
def has_secure_token(attribute = :token)
# Load securerandom only when has_secure_token is used.
require "active_support/core_ext/securerandom"
define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token }
before_create { send("#{attribute}=", self.class.generate_unique_secure_token) unless send("#{attribute}?") }
end
def generate_unique_secure_token
SecureRandom.base58(24)
end
end
end
end
ActiveRecord::Store
实现对一个字段的序列化。可参考。
require "active_support/core_ext/hash/indifferent_access"
module ActiveRecord
module Store
extend ActiveSupport::Concern
included do
class << self
attr_accessor :local_stored_attributes
end
end
module ClassMethods
def store(store_attribute, options = {})
serialize store_attribute, IndifferentCoder.new(store_attribute, options[:coder])
store_accessor(store_attribute, options[:accessors], options.slice(:prefix, :suffix)) if options.has_key? :accessors
end
def store_accessor(store_attribute, *keys, prefix: nil, suffix: nil)
keys = keys.flatten
accessor_prefix =
case prefix
when String, Symbol
"#{prefix}_"
when TrueClass
"#{store_attribute}_"
else
""
end
accessor_suffix =
case suffix
when String, Symbol
"_#{suffix}"
when TrueClass
"_#{store_attribute}"
else
""
end
_store_accessors_module.module_eval do
keys.each do |key|
accessor_key = "#{accessor_prefix}#{key}#{accessor_suffix}"
define_method("#{accessor_key}=") do |value|
write_store_attribute(store_attribute, key, value)
end
define_method(accessor_key) do
read_store_attribute(store_attribute, key)
end
define_method("#{accessor_key}_changed?") do
return false unless attribute_changed?(store_attribute)
prev_store, new_store = changes[store_attribute]
prev_store&.dig(key) != new_store&.dig(key)
end
define_method("#{accessor_key}_change") do
return unless attribute_changed?(store_attribute)
prev_store, new_store = changes[store_attribute]
[prev_store&.dig(key), new_store&.dig(key)]
end
define_method("#{accessor_key}_was") do
return unless attribute_changed?(store_attribute)
prev_store, _new_store = changes[store_attribute]
prev_store&.dig(key)
end
define_method("saved_change_to_#{accessor_key}?") do
return false unless saved_change_to_attribute?(store_attribute)
prev_store, new_store = saved_change_to_attribute(store_attribute)
prev_store&.dig(key) != new_store&.dig(key)
end
define_method("saved_change_to_#{accessor_key}") do
return unless saved_change_to_attribute?(store_attribute)
prev_store, new_store = saved_change_to_attribute(store_attribute)
[prev_store&.dig(key), new_store&.dig(key)]
end
define_method("#{accessor_key}_before_last_save") do
return unless saved_change_to_attribute?(store_attribute)
prev_store, _new_store = saved_change_to_attribute(store_attribute)
prev_store&.dig(key)
end
end
end
# assign new store attribute and create new hash to ensure that each class in the hierarchy
# has its own hash of stored attributes.
self.local_stored_attributes ||= {}
self.local_stored_attributes[store_attribute] ||= []
self.local_stored_attributes[store_attribute] |= keys
end
def _store_accessors_module # :nodoc:
@_store_accessors_module ||= begin
mod = Module.new
include mod
mod
end
end
def stored_attributes
parent = superclass.respond_to?(:stored_attributes) ? superclass.stored_attributes : {}
if local_stored_attributes
parent.merge!(local_stored_attributes) { |k, a, b| a | b }
end
parent
end
end
private
def read_store_attribute(store_attribute, key) # :doc:
accessor = store_accessor_for(store_attribute)
accessor.read(self, store_attribute, key)
end
def write_store_attribute(store_attribute, key, value) # :doc:
accessor = store_accessor_for(store_attribute)
accessor.write(self, store_attribute, key, value)
end
def store_accessor_for(store_attribute)
type_for_attribute(store_attribute).accessor
end
class HashAccessor # :nodoc:
def self.read(object, attribute, key)
prepare(object, attribute)
object.public_send(attribute)[key]
end
def self.write(object, attribute, key, value)
prepare(object, attribute)
if value != read(object, attribute, key)
object.public_send :"#{attribute}_will_change!"
object.public_send(attribute)[key] = value
end
end
def self.prepare(object, attribute)
object.public_send :"#{attribute}=", {} unless object.send(attribute)
end
end
class StringKeyedHashAccessor < HashAccessor # :nodoc:
def self.read(object, attribute, key)
super object, attribute, key.to_s
end
def self.write(object, attribute, key, value)
super object, attribute, key.to_s, value
end
end
class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
def self.prepare(object, store_attribute)
attribute = object.send(store_attribute)
unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
attribute = IndifferentCoder.as_indifferent_hash(attribute)
object.send :"#{store_attribute}=", attribute
end
attribute
end
end
class IndifferentCoder # :nodoc:
def initialize(attr_name, coder_or_class_name)
@coder =
if coder_or_class_name.respond_to?(:load) && coder_or_class_name.respond_to?(:dump)
coder_or_class_name
else
ActiveRecord::Coders::YAMLColumn.new(attr_name, coder_or_class_name || Object)
end
end
def dump(obj)
@coder.dump self.class.as_indifferent_hash(obj)
end
def load(yaml)
self.class.as_indifferent_hash(@coder.load(yaml || ""))
end
def self.as_indifferent_hash(obj)
case obj
when ActiveSupport::HashWithIndifferentAccess
obj
when Hash
obj.with_indifferent_access
else
ActiveSupport::HashWithIndifferentAccess.new
end
end
end
end
end
ActiveRecord::Reflection
用于保存Model的associations和aggregations的配置自信息.参考
ActiveRecord::NoTouching
实现在一个block里暂时禁用掉touch功能。参考
ActiveRecord::TouchLater
touch_later实现在一个事物里先执行别的语句之后，在commit之前执行touch的功能模块。
ActiveRecord:Transaction
事务模块的实现。参考
ActiveRecord::NestedAttributes
nested_attributes的实现。参考
