A Brief Introduction to AttributeMethods

KichijojiKaigi #12
A Brief Introduction to
A Brief Introduction to
AttributeMethods
AttributeMethods
by Chris Salzberg

View Slide

きっかけ

View Slide

View Slide

Model Ancestry
Topic.ancestors
=> [Topic(...),
Topic::GeneratedAssociationMethods,
#,
ActiveRecord::Base,
ActiveRecord::Suppressor,
ActiveRecord::SecureToken,
ActiveRecord::Store,
ActiveRecord::Serialization,
ActiveModel::Serializers::JSON,
ActiveModel::Serialization,
ActiveRecord::Reflection,
ActiveRecord::NoTouching,
ActiveRecord::TouchLater,
...
Topic.ancestors
=> [Topic(...),
#,
ActiveRecord::Base,
...
class Topic < ActiveRecord::Base
# ...
end
# ...
end

View Slide

Model Ancestry
Topic.ancestors
=> [Topic(...),
#,
ActiveRecord::Base,
ActiveRecord::Base,
...
Topic.ancestors
=> [Topic(...),
#,
ActiveRecord::Base,
ActiveRecord::Base,
...
# ...
end
# ...
end
What’s this?

View Slide

Generated Attribute Methods
generated_methods = Topic.ancestors[2]
=> #
generated_methods.instance_methods(false)
=> []
Topic.new
=> #
=> [:type=,
:content,
:title_before_type_cast,
:title_came_from_user?,
:title_changed?,
:title_change,
:title_will_change!,
:title_was,
:title_previously_changed?,
:title_previous_change,
:restore_title!,
:saved_change_to_title?,
:saved_change_to_title,
:title_before_last_save,
:will_save_change_to_title?,
:title_change_to_be_saved,
:title_in_database,
... ]
=> #
=> []
Topic.new
=> #
=> [:type=,
:content,
:title_changed?,
:title_change,
:title_was,
:restore_title!,
:title_in_database,
... ]

View Slide

Generated Attribute Methods
=> #
=> []
Topic.new
=> #
=> [:type=,
:content,
:title_changed?,
:title_change,
:title_was,
:restore_title!,
:title_in_database,
... ]
=> #
=> []
Topic.new
=> #
=> [:type=,
:content,
:title_changed?,
:title_change,
:title_was,
:restore_title!,
:title_in_database,
... ]
?

View Slide

My PR
Topic.ancestors
=> [Topic(id: integer, title: string, author_name: string...),
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...

View Slide

My PR
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
ActiveRecord::AttributeMethods::Dirty

View Slide

My PR
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
ActiveModel::Dirty

View Slide

My PR
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
ActiveModel::Dirty
ActiveRecord::AttributeMethods::Query
ActiveRecord::AttributeMethods::BeforeTypeCast

View Slide

AttributeMethods: Rails has Two
●
ActiveModel::AttributeMethods
– Virtual attributes
– Prefixed/suffixed methods map to handlers
●
ActiveRecord::AttributeMethods
– Persisted attributes
– Uses prefixes/suffixes to define:
●
reader/writer/query methods
●
(persisted) dirty attributes
●
type casting methods

View Slide

ActiveModel
ActiveModel
::
::
AttributeMethods
AttributeMethods

View Slide

View Slide

Provides a way to add prefixes and suffixes
to your methods as well as handling the
creation of ActiveRecord::Base-like class
methods such as table_name.
Summary

View Slide

Usage
●
include ActiveModel::AttributeMethods in your class
●
Call each of its methods you want to add, such as
attribute_method_suffix or attribute_method_prefix.
●
Call define_attributes after the other methods are called.
●
Define the various generic _attribute methods that you have
declared (“handlers”)
●
Define an attributes method which returns a hash with each
attribute name in your model as hash key and the attribute value
as hash value. Hash keys must be strings.

View Slide

class Person
include ActiveModel::AttributeMethods
attribute_method_affix prefix: 'reset_',
suffix: '_to_default!'
attribute_method_suffix '_contrived?'
attribute_method_prefix 'clear_'
define_attribute_methods :name
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
def attribute_contrived?(attr)
true
end
def clear_attribute(attr)
send("#{attr}=", nil)
end
def reset_attribute_to_default!(attr)
send("#{attr}=", 'Default Name')
end
end
class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
person = Person.new
person.name
# => 'Gem'
person.name_contrived?
# => true
person.clear_name
person.name
# => nil
person.reset_name_to_default!
person.name
# => 'Default Name'
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'

View Slide

class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
Include the Module

View Slide

class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
Define prefixes/suffixes

View Slide

class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
Define Handlers

View Slide

Handling Attribute Methods
●
Define prefix/suffix/affix and corresponding
handlers which receive attribute name
attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
attribute_method_suffix "_previously_changed?", "_previous_change"
attribute_method_affix prefix: "restore_", suffix: "!"
attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
attribute_method_suffix "_previously_changed?", "_previous_change"
attribute_method_affix prefix: "restore_", suffix: "!"
def attribute_changed?(attr, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
!!changes_include?(attr) &&
(to == OPTION_NOT_GIVEN || to == _read_attribute(attr)) &&
(from == OPTION_NOT_GIVEN || from == changed_attributes[attr])
end
def attribute_changed?(attr, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
!!changes_include?(attr) &&
(to == OPTION_NOT_GIVEN || to == _read_attribute(attr)) &&
(from == OPTION_NOT_GIVEN || from == changed_attributes[attr])
end

View Slide

def attribute_method_prefix(*prefixes)
self.attribute_method_matchers += prefixes.map! do |prefix|
AttributeMethodMatcher.new prefix: prefix
end
undefine_attribute_methods
end
def attribute_method_prefix(*prefixes)
self.attribute_method_matchers += prefixes.map! do |prefix|
AttributeMethodMatcher.new prefix: prefix
end
end
def attribute_method_suffix(*suffixes)
self.attribute_method_matchers += suffixes.map! do |suffix|
AttributeMethodMatcher.new suffix: suffix
end
end
def attribute_method_suffix(*suffixes)
self.attribute_method_matchers += suffixes.map! do |suffix|
AttributeMethodMatcher.new suffix: suffix
end
end
def attribute_method_affix(*affixes)
self.attribute_method_matchers += affixes.map! do |affix|
AttributeMethodMatcher.new prefix: affix[:prefix], suffix: affix[:suffix]
end
end
def attribute_method_affix(*affixes)
self.attribute_method_matchers += affixes.map! do |affix|
AttributeMethodMatcher.new prefix: affix[:prefix], suffix: affix[:suffix]
end
end
Prefixes/Suffixes/Affixes

View Slide

Attribute Method Matcher
class AttributeMethodMatcher
attr_reader :prefix, :suffix, :method_missing_target
AttributeMethodMatch = Struct.new(:target, :attr_name, :method_name)
def initialize(options = {})
@prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
@regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
@method_missing_target = "#{@prefix}attribute#{@suffix}"
@method_name = "#{prefix}%s#{suffix}"
end
def match(method_name)
if @regex =~ method_name
AttributeMethodMatch.new(method_missing_target, $1, method_name)
end
end
def method_name(attr_name)
@method_name % attr_name
end
def plain?
prefix.empty? && suffix.empty?
end
end
class AttributeMethodMatcher
attr_reader :prefix, :suffix, :method_missing_target
end
def match(method_name)
if @regex =~ method_name
AttributeMethodMatch.new(method_missing_target, $1, method_name)
end
end
def method_name(attr_name)
@method_name % attr_name
end
def plain?
prefix.empty? && suffix.empty?
end
end

View Slide

“Method Missing Target”
"#{@prefix}attribute#{@suffix}"

View Slide

“Method Missing”?
# Allows access to the object attributes, which are held in the hash
# returned by attributes, as though they were first-class
# methods. So a +Person+ class with a +name+ attribute can for example use
# Person#name and Person#name= and never directly use
# the attributes hash -- except for multiple assignments with
# ActiveRecord::Base#attributes=.
#
# It's also possible to instantiate related objects, so a Client
# class belonging to the +clients+ table with a +master_id+ foreign key
# can instantiate master through Client#master.
def method_missing(method, *args, &block)
if respond_to_without_attributes?(method, true)
super
else
match = matched_attribute_method(method.to_s)
match ? attribute_missing(match, *args, &block) : super
end
end
#
super
else
end
end

View Slide

“Method Missing”?
#
#
#
#
#
#
#
super
else
end
end
#
#
#
#
#
#
#
super
else
end
end

View Slide

Method Missing Matching
super
else
end
end
super
else
end
end
def matched_attribute_method(method_name)
matches = self.class.send(:attribute_method_matchers_matching, method_name)
matches.detect { |match| attribute_method?(match.attr_name) }
end
end
def self.attribute_method_matchers_matching(method_name)
attribute_method_matchers_cache.compute_if_absent(method_name) do
# Must try to match prefixes/suffixes first, or else the matcher with no
# prefix/suffix will match every time.
matchers = attribute_method_matchers.partition(&:plain?).reverse.flatten(1)
matchers.map { |method| method.match(method_name) }.compact
end
end
end
end

View Slide

“Attribute Method”?
super
else
end
end
super
else
end
end
end
end
end
end
end
end

View Slide

attribute_method?
def attribute_method?(attr_name)
respond_to_without_attributes?(:attributes) && attributes.include?(attr_name)
end
end

View Slide

attribute_method?
end
end
def attributes
{ 'name' => @name }
end
def attributes
{ 'name' => @name }
end

View Slide

attribute_method?
end
end
def attributes
{ 'name' => @name }
end
def attributes
{ 'name' => @name }
end
●
Returns true if the attribute name is a key on
the model’s attributes hash

View Slide

Attribute Missing?
super
else
end
end
super
else
end
end
end
end
end
end
end
end

View Slide

attribute_missing
# +attribute_missing+ is like +method_missing+, but for attributes. When
# +method_missing+ is called we check to see if there is a matching
# attribute method. If so, we tell +attribute_missing+ to dispatch the
# attribute. This method can be overloaded to customize the behavior.
def attribute_missing(match, *args, &block)
__send__(match.target, match.attr_name, *args, &block)
end
end

View Slide

attribute_missing
#
#
#
#
end
#
#
#
#
end
●
attribute_missing is method_missing,
but for attributes
– if reset_foo_to_default! matches prefix/suffix
matchers, attribute_missing is called with the
match target, the attribute, and any args/block

View Slide

attribute_missing
end
end
@prefix @suffix attribute
name
reset_attribute_to_default!(“name”)
reset_attribute_to_default!(“name”)

View Slide

Method Missing Flow

View Slide

Method Missing Flow
Which matchers have matches?
#=> [## target=”reset_attribute_to_default!” attr_name=”name” ...>]

View Slide

Method Missing Flow
Which are included in attributes?
{ ‘name’ => @name }.include?(“name”)

View Slide

Method Missing Flow
Which are included in attributes?
attribute_missing calls handler method
person.reset_attribute_to_default!(“name”)
person.reset_attribute_to_default!(“name”)

View Slide

But...

View Slide

Rails almost never actually does this.

View Slide

class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
class Person
attr_accessor :name
def attributes
{ 'name' => @name }
end
private
true
end
end
end
end
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
person = Person.new
person.name
# => 'Gem'
# => true
person.clear_name
person.name
# => nil
person.name
# => 'Default Name'
Define Attribute Methods

View Slide

def define_attribute_methods(*attr_names)
attr_names.flatten.each { |attr_name| define_attribute_method(attr_name) }
end
end
def define_attribute_method(attr_name)
attribute_method_matchers.each do |matcher|
method_name = matcher.method_name(attr_name)
unless instance_method_already_implemented?(method_name)
generate_method = "define_method_#{matcher.method_missing_target}"
if respond_to?(generate_method, true)
send(generate_method, attr_name.to_s)
else
define_proxy_call true, generated_attribute_methods, method_name,
matcher.method_missing_target, attr_name.to_s
end
end
end
attribute_method_matchers_cache.clear
end
else
end
end
end
end
Defining Attribute Methods

View Slide

end
end
else
end
end
end
end
else
end
end
end
end
For AR
(Ugly!)

View Slide

end
end
else
end
end
end
end
else
end
end
end
end
Defines mapping to handler
(like method_missing)

View Slide

end
end
else
end
end
end
end
else
end
end
end
end
What’s this?

View Slide

else
end
end
end
end
else
end
end
end
end
end
end
def instance_method_already_implemented?(method_name)
generated_attribute_methods.method_defined?(method_name)
end
end
Here too

View Slide

def generated_attribute_methods
@generated_attribute_methods ||= Module.new.tap { |mod| include mod }
end
end
Tap, Include & Memoize
●
Common technique:
– Instantiate anonymous module (Module.new)
– include module into class
– memoize included module
●
Now dynamically define methods on
module, and they will be overridable in class

View Slide

AM::AttributeMethods Recap
●
Defines prefixed/suffixed matchers
●
Overrides method_missing (respond_to?)
to dispatch to attribute methods
●
For performance, for each matcher also
defines methods on included anonymous
module to dispatch to attribute methods
●
(Also can be used to define aliases, similar to
generated methods but on class)

View Slide

ActiveRecord
ActiveRecord
::
::
AttributeMethods
AttributeMethods

View Slide

View Slide

Some Differences
●
Assumes attributes are column values
●
Assumes including class is an AR::Base
●
Changes to make it threadsafe
●
Blacklists certain method names
●
Overrides respond_to?, hardcodes
assumption that attributes are columns

View Slide

# frozen_string_literal: true
require "mutex_m"
module ActiveRecord
# = Active Record Attribute Methods
module AttributeMethods
extend ActiveSupport::Concern
included do
initialize_generated_modules
include Read
include Write
include BeforeTypeCast
include Query
include PrimaryKey
include TimeZoneConversion
include Dirty
include Serialization
# frozen_string_literal: true
require "mutex_m"
module ActiveRecord
# = Active Record Attribute Methods
included do
include Read
include Write
include BeforeTypeCast
include Query
include PrimaryKey
include TimeZoneConversion
include Dirty
include Serialization
Extending AM:AttributeMethods
Include module in module
?

View Slide

Initialize Generated Modules
def initialize_generated_modules
@generated_attribute_methods = GeneratedAttributeMethods.new
@attribute_methods_generated = false
include @generated_attribute_methods
super
end
super
end

View Slide

class GeneratedAttributeMethods < Module
include Mutex_m
end
include Mutex_m
end
super
end
super
end
A Module Builder!

View Slide

include Mutex_m
end
include Mutex_m
end
super
end
super
end
Module Builder instance acts like a mutex

View Slide

super
end
super
end
Eagerly Generate Modules
module ActiveRecord
# ...
module ClassMethods
def inherited(child_class)
child_class.initialize_generated_modules
super
end
module ActiveRecord
# ...
module ClassMethods
def inherited(child_class)
child_class.initialize_generated_modules
super
end
module ActiveRecord
included do
module ActiveRecord
included do

View Slide

Why You No Memoize?
to avoid check-then-set race conditions

View Slide

end
end
Race Condition
●
Two (or more) threads could instantiate, include
and return two (or more) different modules
●
AR avoids this by eagerly assigning
@generated_attribute_methods when
including AttributeMethods or when
subclassing AR model class

View Slide

# Generates all the attribute related methods for columns in the database
# accessors, mutators and query methods.
def define_attribute_methods # :nodoc:
return false if @attribute_methods_generated
# Use a mutex; we don't want two threads simultaneously trying to define
# attribute methods.
generated_attribute_methods.synchronize do
superclass.define_attribute_methods unless self == base_class
super(attribute_names)
@attribute_methods_generated = true
end
end
end
end
define_attribute_methods

View Slide

end
end
end
end

View Slide

end
end
end
end
●
Since generated_attribute_methods is an
instance of a class (Module subclass) which
includes Mutex_m, we can call synchronize on it

View Slide

end
end
end
end
def attribute_names
@attribute_names ||= if !abstract_class? && table_exists?
attribute_types.keys
else
[]
end
end
def attribute_names
@attribute_names ||= if !abstract_class? && table_exists?
attribute_types.keys
else
[]
end
end

View Slide

end
end
end
end
?

View Slide

end
end
end
end
?
●
When attribute methods are defined on an AR
model, all superclasses up to AR::Base also
get their attribute methods defined

View Slide

Initializing an AR Object

View Slide

def initialize(attributes = nil)
self.class.define_attribute_methods
@attributes = self.class._default_attributes.deep_dup
init_internals
initialize_internals_callback
# ...
def initialize(attributes = nil)
@attributes = self.class._default_attributes.deep_dup
init_internals
initialize_internals_callback
# ...
Eagerly Defining Methods
module ActiveRecord
module Core
# ...
module ClassMethods
def allocate
super
end
module ActiveRecord
module Core
# ...
module ClassMethods
def allocate
super
end
module ActiveRecord
module Core
# ...
def init_with(coder)
coder = LegacyYamlAdapter.convert(self.class, coder)
@attributes = self.class.yaml_encoder.decode(coder)
init_internals
@new_record = coder["new_record"]
module ActiveRecord
module Core
# ...
def init_with(coder)
coder = LegacyYamlAdapter.convert(self.class, coder)
@attributes = self.class.yaml_encoder.decode(coder)
init_internals
@new_record = coder["new_record"]

View Slide

attribute_method?
end
end
def attribute_method?(attribute)
super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, "")))
end
end

View Slide

attribute_method?
end
end
end
end
Private Method? Yuck.

View Slide

if dangerous_attribute_method?(method_name)
raise DangerousAttributeError, "#{method_name} is defined by Active Record. Check
to make sure that you don't have an attribute or method with the same name."
end
if superclass == Base
super
else
# If ThisClass < ... < SomeSuperClass < ... < Base and SomeSuperClass
# defines its own attribute method, then we don't want to overwrite that.
defined = method_defined_within?(method_name, superclass, Base) &&
! superclass.instance_method(method_name).owner.is_a?(GeneratedAttributeMethods)
defined || super
end
end
end
super
else
defined || super
end
end
instance_method_
already_implemented?
end
end

View Slide

end
super
else
defined || super
end
end
end
super
else
defined || super
end
end
instance_method_
end
end
Another Private Method?

View Slide

end
super
else
defined || super
end
end
end
super
else
defined || super
end
end
instance_method_
end
end
?

View Slide

def respond_to?(name, include_private = false)
return false unless super
case name
when :to_partial_path
name = "to_partial_path".freeze
when :to_model
name = "to_model".freeze
else
name = name.to_s
end
# If the result is true then check for the select case.
# For queries selecting a subset of columns, return false for unselected columns.
# We check defined?(@attributes) not to issue warnings if called on objects that
# have been allocated but not yet initialized.
if defined?(@attributes) && self.class.column_names.include?(name)
return has_attribute?(name)
end
true
end
case name
when :to_model
else
name = name.to_s
end
end
true
end
respond_to?

View Slide

case name
when :to_model
else
name = name.to_s
end
end
true
end
case name
when :to_model
else
name = name.to_s
end
end
true
end
respond_to?
Coupled
to ActiveRecord

View Slide

end
end
else
end
end
end
end
else
end
end
end
end
More AM/AR Coupling

View Slide

def define_method_attribute(name)
safe_name = name.unpack("h*".freeze).first
temp_method = "__temp__#{safe_name}"
ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
sync_with_transaction_state = "sync_with_transaction_state" if name == primary_key
generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
def #{temp_method}
#{sync_with_transaction_state}
name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
_read_attribute(name) { |n| missing_attribute(n, caller) }
end
STR
generated_attribute_methods.module_eval do
alias_method name, temp_method
undef_method temp_method
end
end
def define_method_attribute(name)
temp_method = "__temp__#{safe_name}"
def #{temp_method}
_read_attribute(name) { |n| missing_attribute(n, caller) }
end
STR
generated_attribute_methods.module_eval do
alias_method name, temp_method
undef_method temp_method
end
end
ActiveRecord::AttrMethods::Read
"define_method_#{"attribute"}"

View Slide

def define_method_attribute=(name)
def __temp__#{safe_name}=(value)
_write_attribute(name, value)
end
alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
undef_method :__temp__#{safe_name}=
STR
end
def define_method_attribute=(name)
def __temp__#{safe_name}=(value)
_write_attribute(name, value)
end
alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
undef_method :__temp__#{safe_name}=
STR
end
ActiveRecord::AttrMethods::Write
"define_method_#{"attribute="}"

View Slide

Problems
●
Hard to extend
– AM/AR AttributeMethods heavily coupled
– Can’t use pure AM prefix/suffixes in AR model
●
Poor encapsulation
– Many private method overrides
●
Confusing and obscure internal API
– define_attribute_method
– define_method_attribute

View Slide

NASTY!

View Slide

Ok, you do better
●
Extract AttributeMethodMatcher into a
Module Builder :
– prefix/suffix + generated regex
– methods for defining attribute methods on itself
– dynamically defined method_missing + respond_to?
●
Each prefix/suffix/affix has its own module
●
ActiveRecord module builder can subclass
ActiveModel module builder

View Slide

module ActiveModel
class AttributeMethodMatcher < Module
NAME_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
attr_reader :prefix, :suffix, :method_missing_target, :method_names
@method_names = Set.new
define_method_missing
end
# ...
module ActiveModel
class AttributeMethodMatcher < Module
NAME_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
attr_reader :prefix, :suffix, :method_missing_target, :method_names
@method_names = Set.new
define_method_missing
end
# ...
Module Builder Refactor (1)

View Slide

def define_method_missing
matcher = self
define_method :method_missing do |method_name, *arguments, &method_block|
if (match = matcher.match(method_name.to_s)) &&
method_name != :attributes &&
attribute_method?(match.attr_name) &&
!respond_to_without_attributes?(method_name, true)
attribute_missing(match, *arguments, &method_block)
else
super(method_name, *arguments, &method_block)
end
end
end
def define_method_missing
matcher = self
define_method :method_missing do |method_name, *arguments, &method_block|
if (match = matcher.match(method_name.to_s)) &&
method_name != :attributes &&
attribute_method?(match.attr_name) &&
!respond_to_without_attributes?(method_name, true)
attribute_missing(match, *arguments, &method_block)
else
super(method_name, *arguments, &method_block)
end
end
end
●
Access builder method using a closure

View Slide

name = method_name(attr_name)
method_names << name.to_sym
unless instance_method_already_implemented?(name)
generate_method = "define_method_#{method_missing_target}"
else
define_proxy_call true, name, method_missing_target, attr_name.to_s
end
end
end
name = method_name(attr_name)
method_names << name.to_sym
unless instance_method_already_implemented?(name)
generate_method = "define_method_#{method_missing_target}"
else
define_proxy_call true, name, method_missing_target, attr_name.to_s
end
end
end
●
Builder defines attribute methods on itself, no
passing around anonymous module

View Slide

module ActiveRecord
class AttributeMethodMatcher < ActiveModel::AttributeMethodMatcher
include Mutex_m
def initialize(*)
super
end
#...
synchronize do
super(*attr_names)
end
end
# ...
module ActiveRecord
class AttributeMethodMatcher < ActiveModel::AttributeMethodMatcher
include Mutex_m
def initialize(*)
super
end
#...
synchronize do
super(*attr_names)
end
end
# ...
AR subclasses AM

View Slide

The Result
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...
Topic.ancestors
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
ActiveRecord::Base,
...

View Slide

AR decoupled from AM
●
AR and AM matchers are entirely isolated
➢
Can co-exist alongside each other in ancestors
➢
Can use AM::AttributeMethods in AR::Base
model
●
Subclass AR::AttributeMethodMatcher to
add new attribute features and use in any
AR::Base model

View Slide

Module Bloat?

View Slide

Alternative Implementation
●
Module Builder “lite” version using just one
builder
– All matchers in one builder instance
– Delegate attribute_method_prefix, etc to
module
●
Retains benefits of code encapsulation
●
Avoids “module bloat”, all methods on one
module

View Slide

Alternative Implementation
●
Module Builder “lite” version using just one
builder
– All matchers in one builder instance
– Delegate attribute_method_prefix, etc to
module
●
Retains benefits of code encapsulation
●
Avoids “module bloat”, all methods on one
module
●
But still struggling with mysterious 4-5% performance drop...

View Slide

View Slide

A Brief Introduction to AttributeMethods

A Brief Introduction to AttributeMethods

Chris Salzberg

More Decks by Chris Salzberg

Other Decks in Programming

Featured

Transcript