define_method, ou la magie qu'on peut retrouver define_method, or the magic you can find again

define_method fabrique une vraie méthode, à partir d'un nom.define_method forges a real method, from a name.

Le № 1 interceptait les messages inconnus ; voici la moitié lumineuse du volume. Plutôt que de détourner method_missing, define_method crée des méthodes réelles à l'exécution, à partir d'un nom calculé et d'un bloc. La différence avec method_missing est totale : ces méthodes existent vraiment. instance_methods les liste, respond_to? les voit, un grep les trouve, le débogueur s'y arrête. C'est la métaprog qui produit du code visible au lieu de le cacher — et le seul moyen de générer une famille de méthodes dont les noms sont des données, pas du texte écrit à la main.№ 1 intercepted unknown messages; here's the volume's bright half. Rather than hijacking method_missing, define_method creates real methods at runtime, from a computed name and a block. The difference from method_missing is total: these methods actually exist. instance_methods lists them, respond_to? sees them, a grep finds them, the debugger stops in them. It's the metaprogramming that produces visible code instead of hiding it — and the only way to generate a family of methods whose names are data, not hand-written text.

class Person
  [:name, :email].each do |attr|              # une boucle sur des noms
    define_method(attr) do                     # crée une VRAIE méthode lecteur
      instance_variable_get("@#{attr}")
    end
    define_method("#{attr}=") do |value|       # … et son écrivain
      instance_variable_set("@#{attr}", value)
    end
  end
end

p = Person.new
p.name = "Ada"
p.name                          # => "Ada"
Person.instance_methods(false).sort  # => [:email, :email=, :name, :name=]
                                     #    de vraies méthodes : listées, grep-ables
                                     #    (.sort : l'ordre de retour n'est pas garanti)

attr_accessor n'est pas un mot-clé : c'est cette boucle.attr_accessor isn't a keyword: it's this loop.

La surprise qui démystifie tout le volume : attr_accessor n'est pas une construction du langage, c'est une méthode de classe ordinaire qui appelle define_method en boucle. Rien de réservé, rien de magique — on peut la réécrire en dix lignes, et c'est instructif de le faire. Elle révèle le motif central de la métaprog déclarative : une méthode appelée au niveau de la classe (via extend, Vol 5) qui génère des méthodes d'instance. Tous les attr_*, et la moitié des macros de Rails, ne sont que ça : du define_method habillé d'un joli nom.The surprise that demystifies the whole volume: attr_accessor isn't a language construct, it's an ordinary class method calling define_method in a loop. Nothing reserved, nothing magic — you can rewrite it in ten lines, and it's instructive to do so. It reveals the central pattern of declarative metaprogramming: a method called at the class level (via extend, Vol 5) that generates instance methods. All the attr_*, and half of Rails's macros, are just that: define_method dressed in a nice name.

class Point
  attr_accessor :x, :y      # « magie » familière : lecteurs + écrivains
end

p = Point.new
p.x = 3
p.x                         # => 3
Point.instance_methods(false).sort   # => [:x, :x=, :y, :y=]

attr_accessor :x, :y ressemble à un mot-clé, mais c'est un simple appel de méthode exécuté pendant la définition de la classe. Il reçoit des symboles et génère quatre méthodes. Aucune syntaxe spéciale : juste une méthode de Module que Point hérite et appelle.attr_accessor :x, :y looks like a keyword, but it's a plain method call run during the class definition. It receives symbols and generates four methods. No special syntax: just a Module method that Point inherits and calls.

Une macro de classe génère ; class_eval et send complètent.A class macro generates; class_eval and send complete it.

Le motif déclaratif se précise. field :name, écrit dans le corps de la classe, n'est qu'un appel de méthode de classe qui fait define_method — c'est le squelette de tout DSL Ruby, des validations Rails aux schémas dry-struct du Vol 3. Deux outils l'entourent. class_eval exécute un bloc dans le contexte d'une classe, comme si on rouvrait sa définition — utile pour ajouter des méthodes à une classe qu'on n'a pas écrite (on y reviendra au № 3). Et send appelle une méthode dont le nom est une donnée, complétant la génération : on crée des méthodes par leur nom, on les appelle par leur nom.The declarative pattern sharpens. field :name, written in the class body, is just a class-method call doing define_method — the skeleton of every Ruby DSL, from Rails validations to Vol 3's dry-struct schemas. Two tools surround it. class_eval runs a block in a class's context, as if reopening its definition — useful to add methods to a class you didn't write (more on that in № 3). And send calls a method whose name is data, completing generation: you create methods by name, you call them by name.

class Model
  def self.field(name)              # une macro déclarative au niveau classe
    define_method(name) { @attrs[name] }
    define_method("#{name}=") { |v| @attrs[name] = v }
  end

  def initialize = @attrs = {}
end

class User < Model
  field :name                       # se lit comme une déclaration
  field :age
end

u = User.new
u.name = "Ada"
u.name                             # => "Ada"   field a généré de vraies méthodes

# class_eval : exécuter du code DANS le contexte d'une classe
target = String
target.class_eval do                # le bloc s'exécute « comme si on était dans String »
  def shout = upcase + "!"
end
"hi".shout                          # => "HI!"

# send : appeler une méthode dont le nom est une donnée (Vol 1)
record = User.new
%i[name age].each do |field|
  record.send("#{field}=", "?")     # send force aussi le privé ; public_send sinon
end

Ce trio — define_method pour créer, class_eval pour ouvrir un contexte, send pour appeler par nom — couvre la quasi-totalité de la métaprog constructive. Toute la différence avec le № 1 tient là : on produit des méthodes que les outils retrouvent, au lieu d'intercepter des messages qu'ils ne voient pas. Reste à savoir quand ne pas s'en servir.This trio — define_method to create, class_eval to open a context, send to call by name — covers nearly all constructive metaprogramming. The whole difference from № 1 sits there: you produce methods tools can find, instead of intercepting messages they can't see. What remains is knowing when not to use it.

Générer trois méthodes qu'on aurait écrites plus vite à la main.Generating three methods you'd have written faster by hand.

Le contre-exemple du numéro, et le piège du dev qui vient de découvrir define_method. Grisé par l'outil, il génère tout — y compris trois méthodes distinctes qu'un def aurait dites plus clairement et en moins de lignes. La génération ne paie que quand les noms sont des données (une liste qui grandit, une config externe) ou quand ils sont vraiment nombreux. Sur un petit ensemble fixe, elle ne fait qu'ajouter de l'opacité : grep ne trouve rien, source_location pointe la boucle au lieu du comportement, et le lecteur doit exécuter la table mentalement. Et la variante en chaîne (class_eval d'un texte interpolé) ajoute l'injection à l'illisibilité.The issue's counter-example, and the trap of the dev who just discovered define_method. Drunk on the tool, they generate everything — including three distinct methods a def would have stated more clearly and in fewer lines. Generation only pays when names are data (a growing list, an external config) or when they're genuinely many. On a small fixed set, it only adds opacity: grep finds nothing, source_location points at the loop instead of the behavior, and the reader must run the table in their head. And the string variant (class_eval of interpolated text) adds injection to illegibility.

# Le piège : un générateur pour 2 méthodes qui n'ont rien de commun
class Report
  { summary: :short, detail: :long, audit: :full }.each do |name, mode|
    define_method(name) { render(@data, mode) }
  end
end

# où est défini summary ? que fait audit ? il faut LIRE la boucle et la table.
# $ grep "def summary"    → rien
Report.new.method(:detail).source_location   # pointe la ligne du define_method,
                                              # pas le comportement — debug opaque
# pire encore, la variante en chaîne :
# klass.class_eval("def #{name}; render(@data, :#{mode}); end")  ← injection, zéro coloration

# Trois méthodes distinctes ? On les écrit. C'est tout.
class Report
  def summary = render(@data, :short)
  def detail  = render(@data, :long)
  def audit   = render(@data, :full)
end

# $ grep "def summary"    → trouvé, à sa ligne
Report.new.method(:detail).source_location   # pointe la vraie définition
# lisible, traçable, débogable — et plus COURT que le générateur