Let's imagine we are building DSL similar to ActiveRecord associations.
class Person
associated_with :account
end
Person.new.account # => "Account associated with a Person"
In order to build this feature, we will create a new module that dynamically defines association methods.
module Associations
def associated_with(name)
define_method(name) do
puts "associated #{name}"
end
end
end
class Person
extend Associations
associated_with :account
end
Person.new.account #=> "associated account"
define_method creates an instance method on a receiver, which is exactly what we need.
define_method basically has done this;
class Person
...
def account
"associated account"
end
end
We can easily validate this theory by inspecting the ancestors chain and instance methods:
Person.ancestors # => Person,Object,Kernel,BasicObject
Person.instance_methods(false) # => [account]
Overwriting dynamically defined method
If we wish to overwrite a dynamically defined method we can do it without any problems since this is just a "regular" instance method (albeit defined with some metaprogramming)
class Person
extend Associations
associated_with :account
def account
"overridden"
end
end
Person.new.account #=> "overridden"
But, calling a super when overriding will fail
def account
super
"overridden"
end
Person.new.account # => `account': super: no superclass method `account' for ...
This makes sense since we are calling super on the method we've completely overwritten.
In order for super to work the method need to be defined in Persons ancestors chain.
We can do this by generating a new module on the fly, including that module in the class and define dynamic methods on that module instead of the class itself.
module Associations
# Create new module on the fly.
# Include that module in the ancestor chain
def generated_association_methods
@generated_association_methods ||= begin
mod = const_set(:GeneratedAssociationMethods, Module.new)
include mod
mod
end
end
def associated_with(name)
mixin = generated_association_methods
# define methods on the newly created module
mixin.define_method(name) do
puts "associated #{name}"
end
end
end
class Person
extend Associations
associated_with :account
end
Now dynamically defined methods live inside the Person::GeneratedAssociationMethods, which is part of ancestors chain.
Person.ancestors # => Person,**Person::GeneratedAssociationMethods**, Object,Kernel,BasicObject
Person.instance_methods(false) # => []
So calling super will work fine:
def account
super
"overridden"
end
Person.new.account
#=> "associated_account"
#=> "overridden"
I've seen this pattern used in Rails codebase in multiple places where this kind of behaviour is needed.
✌️
Top comments (1)
A great insight how ruby magic works .