Qu'est-ce que la métaprogrammation en Ruby ?

Question

Accepted Answer

**La métaprogrammation** est l'écriture de code qui **écrit ou modifie du code à l'exécution** — définir des méthodes dynamiquement, répondre à des méthodes non définies, et inspecter/altérer des classes à la volée. La nature dynamique de Ruby (tout est un objet, y compris les classes) le rend exceptionnellement doué pour la métaprogrammation, qui alimente une grande partie de la « magie » de Rails.

## Définir des méthodes dynamiquement

```ruby
class Product
  # define methods programmatically at runtime
  [:name, :price, :sku].each do |attribute|
    define_method(attribute) do            # creates a getter method for each
      instance_variable_get("@#{attribute}")
    end
    define_method("#{attribute}=") do |value|   # and a setter
      instance_variable_set("@#{attribute}", value)
    end
  end
end
# → Product now has name/name=, price/price=, sku/sku= — generated, not hand-written
```

`define_method` crée des méthodes à l'exécution — ici, générer des accesseurs dans une boucle au lieu de les écrire manuellement. (C'est essentiellement le fonctionnement interne de `attr_accessor`.)

## method_missing — gérer les appels de méthodes non définies

```ruby
class DynamicConfig
  def initialize = @settings = {}

def method_missing(name, *args)         # called when an UNDEFINED method is invoked
    name_str = name.to_s
    if name_str.end_with?("=")            # a setter like config.timeout = 30
      @settings[name_str.chomp("=")] = args.first
    else                                  # a getter like config.timeout
      @settings[name_str]
    end
  end
  def respond_to_missing?(name, include_private = false) = true
end

config = DynamicConfig.new
config.timeout = 30      # no `timeout=` method defined → method_missing handles it
config.timeout           # 30 — also via method_missing
```

**`method_missing`** intercepte les appels à des méthodes non définies — permettant des APIs dynamiques où les méthodes n'ont pas besoin d'être définies explicitement (utilisé largement dans Rails, par exemple les finders dynamiques).

## Autres outils de métaprogrammation

```ruby
obj.send(:method_name, args)        # call a method by name (even private)
obj.respond_to?(:method_name)        # check if a method exists
Object.const_get("ClassName")        # get a class by name string
self.class.instance_methods          # introspect methods
user.define_singleton_method(:special) { ... }   # add a method to one object
```

## Pourquoi c'est important

La métaprogrammation est l'une des fonctionnalités les plus puissantes et distinctives de Ruby, et la comprendre est précieuse à la fois pour le développement Ruby avancé et — surtout — pour comprendre comment **Rails et autres frameworks Ruby réalisent leur « magie ». ** La capacité exceptionnelle de Ruby en métaprogrammation (rendue possible par sa nature dynamique où tout, y compris les classes, est un objet qui peut être manipulé à l'exécution) permet au code d'écrire et de modifier du code à la volée : **`define_method`** génère des méthodes dynamiquement (évitant le code répétitif écrit à la main — c'est le fonctionnement de `attr_accessor` et des attributs dynamiques de Rails), et **`method_missing`** intercepte les appels de méthodes non définies (permettant des APIs dynamiques flexibles — le mécanisme derrière les finders dynamiques de Rails comme `find_by_name`, les méthodes d'attribut d'ActiveRecord, et bien plus).

Comprendre ces techniques démystifie la façon dont les frameworks comme Rails fournissent leurs APIs apparemment magiques et concises (où les méthodes que vous n'avez jamais explicitement définies fonctionnent simplement), ce qui est important à la fois pour utiliser ces frameworks efficacement et pour construire vos propres APIs et bibliothèques flexibles et similaires à des DSL.

Connaître les outils de métaprogrammation (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) reflète des connaissances Ruby avancées.

Bien que puissante, la métaprogrammation doit être utilisée avec discernement (elle peut rendre le code plus difficile à comprendre, déboguer et analyser statiquement — le compromis pour sa flexibilité).

Comprendre la métaprogrammation — ce qu'elle est (du code qui manipule du code à l'exécution), les techniques clés, et qu'elle alimente la magie de Rails — est une connaissance de niveau senior précieuse qui explique comment fonctionnent les frameworks Ruby que vous utilisez, permet la création avancée de métaprogrammation et de DSL, et est une marque d'une expertise Ruby profonde et un sujet d'entrevue avancé courant qui distingue les développeurs qui comprennent vraiment les capacités dynamiques de Ruby.