What is metaprogramming is and how can we use it in our everyday code - by Cristian Planas, CTO at Playfulbet

1. The black magic of
Ruby
metaprogramming

2. I am Cristian…
Gawyn
@cristianplanas

3. … and this is the story of
how I fell in love with
Ruby

4. It was 2011, when I read
this awesome book
(the smart part of this talk is based on it)

5. I was so excited that I
created my first gem just to
play with metaprogramming.

6. Easyregexp
http://github.com/Gawyn/easyregexp

7. Easyregexp
It was a regular expressions generator.
It relied heavily in metaprogramming.
It was never much useful.

8. Anyway, I felt like this

9. I mean, people who use
metaprogramming do have
superpowers.

10. They even know mysterious,
incomprehensible spells!

11. Repeat with me
The superclass of the eigenclass of an
object is the object’s class.
The superclass of the eigenclass of a
class is the eigenclass of the class’s
superclass.

12. Sorry, today we won’t talk
about eigenclasses.

13. We will focus on the most
down to earth part of
metaprogramming.

14. When I started using
metaprogramming in my
production code, I
remembered an old movie.

16. In it, Mickey Mouse is the hard-working
apprentice of a powerful sorcerer.

17. One day, the sorcerer leaves,
and Mickey can play with
magic…

18. So let’s learn some tricks!

19. Monkey patching

20. Monkey patching
Adding code to an already defined
class.

21. An example
class String
def say_hello
p “hello”
end
end
“an string”. say_hello
=> “hello”

22. This means that we can
extend any class with our
own methods.

23. You can also redefine an
already existing method!

24. Dynamic methods

25. Dynamic methods
Define methods with an algorythm in
runtime.

26. A typical example
Imagine a class full of boring,
repeating methods.

27. A typical example
class User
ROLES = [“user”, “admin”]
# scopes for each role
scope :user, where(role: “user”)
scope :admin, where(role: “admin”)
# Identifying methods for each role
def user?
role == “user”
end
def admin?
role == “admin”
end
end

28. A typical example
Now let’s add some more roles:
ROLES = [“guest”, “user”,
“confirmed_user”, “moderator”,
“manager”, “admin”, “superadmin”]

29. Damn!

30. A typical example
Metaprogramming to the rescue!

31. A typical example
class User
ROLES = [“guest”, “user”, “confirmed_user”, “moderator”,
“manager”, “admin”, “superadmin”]
ROLES.each do |user_role|
scope user_role.to_sym, where(role: user_role)
define_method “#{user_role}?” do
role == user_role
end
end
end

32. Great!

33. Evaluating strings
as code

34. It does just that: run a string as if it was
code.
class_eval and instance_eval do the
same, just changing the context.
We can also use it on an object using
send.

35. An example
class Movie
attr_reader :title_en, :title_es, :title_it, :title_pt
def title
send(“title_#{I18n.locale}”)
end
end

36. An example
class Movie
translate :title, :overview
def translate(*attributes)
attributes.each do |attr|
define_method attr do
send(“#{attr}_#{I18n.locale}”)
end
end
end
end

37. You can even define
new methods like this!
String.class_eval(“def say_hello; puts „hello‟; end”)
“a string”.say_hello
#=> “hello”

38. method_missing

39. method_missing
It’s the method that gets executed
when the called method it’s not found.

40. We can monkey patch it!

41. An example
class MetalDetector
def method_missing(method, *args, &block)
if method =~ /metal/
puts “Metal detected!”
else
super
end
end
end
metal_detector = MetalDetector.new
metal_detector.bringing_some_metal_with_me
# => “Metal detected!”

42. A pretty exemplary use of
method_missing use are
Rails’ dynamic finders
(deprecated in Rails 4)

43. Calling finding methods with any
combination of attributes will work.
User.find_by_name_and_surname(“Mickey”, “Mouse”)
User.find_by_surname_and_movie(“Mouse”, “Fantasia”)
User.find_by_movie_and_job_and_name(“Fantasia”, “sorcerer”, “Mickey”)

44. So metaprogramming is
pretty cool, isn’t it?

45. It can get cooler

46. Let’s check how
ActiveRecord defines its
setter methods
(in an abbreviated version)

47. Defining setters
def method_missing(method, *args, &block)
unless self.class.attribute_methods_generated?
self.class.define_attribute_methods
if respond_to_without_attributes?(method)
send(method, *args, &block)
else
super
end
else
super
end
end

48. Finally it gets to something like this:
def define_write_method(attr_name)
method_definition = “def #{attr_name}=(new_value);
write_attribute(„#{attr_name}‟, new_value); end”
class_eval(method_definition, __FILE__, __LINE)
end
(as told, it’s a pretty abbreviated version)

49. To know more
Episode 8 of Metaprogramming Ruby: Inside ActiveRecord
https://github.com/rails/rails/blob/master/activerecord/lib/active_r
ecord/attribute_methods.rb
https://github.com/rails/rails/blob/master/activemodel/lib/active_
model/attribute_methods.rb
https://github.com/rails/rails/blob/master/activerecord/lib/active_r
ecord/attribute_methods/write.rb

50. But in the end of the movie, all the
magic backslashes…

51. Metaprogramming has its dangers

52. Unexpected
method override

53. It happens when you rewrite an
existing method changing its behavior
without checking the consequences.

54. That means all the code that rely in the
old method behavior will fail.

55. class Fixnum
alias :old_minus :alias :- :+
alias :+ :old_minus
end
4+3
#=> 1
5–2
#=> 7

56. Dynamic methods like the ones of the
example can also accidentally monkey
patch critical methods!

57. Code injection
through evaluation

58. If you use any kind of eval, remember to
think in all possible cases, specially if
users are involved.
You don’t want to evaluate
“User.destroy_all” on your own
application!

59. Even if users should be able to evaluate
code in your server, there are ways to
protect you:
Clean Rooms

60. Ghost methods

61. Methods working from inside
method_missing don’t “really” exist for
Ruby.

62. class MetalDetector
def method_missing(method, *args)
if method =~ /metal/
puts “Metal detected!”
else
super
end
end
end
metal_detector = MetalDetector.new
metal_detector.metal
# => “Metal detected!”
metal_detector.respond_to?(:metal)
#=> false

63. There is a work-around: to monkey
patch the respond_to? method.
Feels kinda hacky.
And still, it can be hard to maintain.

64. If you want to know more about the dangers of
method_missing, Paolo Perrotta (the author of
Metaprogramming Ruby) has a full presentation
about it: The revenge of method_missing()

65. Some final
thoughts

66. 1. I look pretty cool with Superman trunks.

67. 2. Metaprogramming is a name
for different techniques: you
can use some and avoid others.

68. Personally, I use plenty of
dynamic methods and avoid
method_missing.

69. 3. Just be sure of what you do
when you use it.

70. The sorcerer won’t come to save you!

71. Thanks!