Metaprogramming Rails

Metaprogramming Rails
@JustusEapen

What is “metaprogramming”?

Metaprogramming is fun.
(dangerous)

Metaprogramming is usually
introspective or generative.

Introspection is code that tells you about code.

Generation is code that writes code.

Introspection is useful all of the times.
Where is this method defined?
What classes inherit from this class?
What classes does this class inherit
from?
What classes include this module or
concern?
method(:method_name).source_locat
ion
Class.descendants
Class.ancestors
Oh crap. How do I do this again?

# How to get all the classes that include a module
concern :MyDopeModule do
def self.dope_classes
Rails.application.eager_load! # why is this important?
ActiveRecord::Base.descendants.select do |c|
c.included_modules.include?(MyDopeModule)
end
end
end

QUIZ:
Why should you not do that in
production?

Generative Methods are useful sometimes
I need to create many similar methods
I need to call methods dynamically
I need to dynamically set variables
I need to write a gem...
define_method(:foo) { do_something(foo) }
send(:method)
instance_variable_set(‘@var’, value):

# Getters and setters for an array attribute
# given an activerecord model with an array attribute
(1..5).each do |i|
define_method("attr_#{i}=".to_sym) do |val|
array[i] = val
save
end
define_method("attr_#{i}".to_sym) { take_aways[n] }
end

# File activerecord/lib/active_record/scoping/named.rb, line 143
def scope(name, body, &block)
unless body.respond_to?(:call)
raise ArgumentError, "The scope body needs to be callable."
end
if dangerous_class_method?(name)
raise ArgumentError, "You tried to define a scope named "#{name}" " "on the
model "#{self.name}", but Active Record already defined " "a class method with
the same name."
end
valid_scope_name?(name)
extension = Module.new(&block) if block
…
end

# File activerecord/lib/active_record/scoping/named.rb, line 143
def scope(name, body, &block)
...
if body.respond_to?(:to_proc)
singleton_class.send(:define_method, name) do |*args|
scope = all.scoping { instance_exec(*args, &body) }
scope = scope.extending(extension) if extension
scope || all
end
else
singleton_class.send(:define_method, name) do |*args|
scope = all.scoping { body.call(*args) }
scope = scope.extending(extension) if extension
scope || all
end
end
end

# To DRY on scoping by a virtual attribute on active record models
# Add this to a VirtualScopableConcern
def self.virtual_scope_by(*virtual_attrs)
virtual_attrs.each do |virtual_attr|
scope "by_#{virtual_attr}".to_sym, -> {
all.to_a.sort_by(&virtual_attr) }
end
end
virtual_scope_by [:virtual_attribute_1, :virtual_attribute_2]

What else can I do with metaprogramming?
1. Write a DSL for markup
2. Modify classes on the fly
3. Make ridiculously long method calls
a. String.method(:new).call
4. Catch undefined methods
a. Method_missing
5. Binding.pry
6. Penetrate scopes (defy encapsulation)
7. What else?

Where can I learn more?
● Metaprogramming Ruby and Antipatterns in Rails by Eugene Wang
● Metaprogramming in Ruby: It's All About the Self by Yehuda Katz
● Metaprogramming Ruby (book) by Paolo Perrotta
● In IRB, write some code, run it.

Conclusions:
Recursion is the source of all power
and...

Metaprogramming Rails

More Related Content

What's hot (20)

Similar to Metaprogramming Rails (20)

Recently uploaded (20)

Metaprogramming Rails