Metaprogramming Ruby in Practice. Talk by Justus Eapen (justuseapen.com) at Baltimore on Rails on June 13, 2017

1. Metaprogramming Rails
@JustusEapen

2. What is “metaprogramming”?

4. Metaprogramming is fun.
(dangerous)

5. Metaprogramming is usually
introspective or generative.

6. Introspection is code that tells you about code.

7. Generation is code that writes code.

8. When is this useful?

9. 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?

10. # 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

11. QUIZ:
Why should you not do that in
production?

12. Generative Methods be like...

13. 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):

14. # 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

15. # 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

16. # 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

17. ActiveRecord be like:

19. We can even get meta-meta

20. # 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]

21. QUIZ:
Why should you not do that in
production?

22. 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?

23. 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.

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

25. Danger can be fun!