La chaîne d'ancêtres, ou où Ruby cherche la méthode The ancestor chain, or where Ruby looks for the method

Un message ne « trouve » pas sa méthode : il parcourt une liste.A message doesn't "find" its method: it walks a list.

Le № 1 a montré qu'include « insère le module dans la chaîne ». Voici cette chaîne en clair. ancestors révèle l'ordre exact dans lequel Ruby cherche une méthode quand un objet reçoit un message : sa classe d'abord, puis les modules qu'elle mixe, puis sa superclasse, et ainsi de suite jusqu'à BasicObject. Le premier ancêtre qui définit la méthode gagne ; les autres ne sont jamais consultés. C'est la mécanique concrète derrière le « tout est message » du Vol 1 — résoudre un message, c'est descendre cette liste jusqu'au premier qui répond.№ 1 showed that include 'inserts the module into the chain'. Here's that chain in the open. ancestors reveals the exact order in which Ruby looks up a method when an object receives a message: its class first, then the modules it mixes, then its superclass, and so on to BasicObject. The first ancestor that defines the method wins; the others are never consulted. It's the concrete mechanics behind Vol 1's 'everything is a message' — resolving a message is walking this list down to the first that answers.

String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]
#     └ la classe  └ un mixin  └ la superclasse … jusqu'à la racine

# envoyer "abc".upcase, c'est PARCOURIR cette liste de gauche à droite
# et s'arrêter au PREMIER ancêtre qui définit upcase :
"abc".method(:upcase).owner    # => String     trouvé dès le 1er
"abc".method(:tap).owner       # => Kernel      trouvé plus loin
"abc".method(:equal?).owner    # => BasicObject à la toute fin

include insère sous la classe ; prepend, au-dessus.include inserts below the class; prepend, above.

Les deux verbes mixent un module, mais à des positions opposées dans la chaîne — et la position décide de tout. include place le module juste sous la classe : ses méthodes ne s'exécutent que si la classe ne définit pas déjà le message. prepend le place juste au-dessus : ses méthodes passent en premier, et c'est ce qui permet d'envelopper une méthode existante (logging, mémoïsation, instrumentation) en redonnant la main à l'original par super. La même paire module/classe, deux comportements, selon un seul maillon de différence.Both verbs mix a module, but at opposite positions in the chain — and position decides everything. include puts the module just below the class: its methods run only if the class doesn't already define the message. prepend puts it just above: its methods go first, which is what lets you wrap an existing method (logging, memoization, instrumentation) and hand back to the original via super. The same module/class pair, two behaviors, one link of difference apart.

module Loud
  def speak = super.upcase   # enrobe : appelle l'original, puis le crie
end

class Cat
  def speak = "meow"
  include Loud               # Loud va SOUS Cat dans la chaîne
end

Cat.ancestors   # => [Cat, Loud, Object, ...]
Cat.new.speak   # => "meow"   ← Cat#speak gagne, Loud#speak n'est PAS atteint
                #    include ne peut pas envelopper une méthode de la classe

Comme Loud est sous Cat, Ruby rencontre Cat#speak d'abord et s'arrête : Loud#speak est dans la chaîne mais jamais atteint. C'est la limite d'include — il ajoute des méthodes que la classe n'a pas, il ne peut pas envelopper celles qu'elle a.Since Loud is below Cat, Ruby meets Cat#speak first and stops: Loud#speak is in the chain but never reached. That's include's limit — it adds methods the class lacks, it can't wrap the ones it has.

super remonte la chaîne d'un cran — et le diamant est déjà résolu.super climbs the chain one notch — and the diamond is already resolved.

super n'appelle pas « la méthode du parent » : il appelle la prochaine définition du même message dans la chaîne d'ancêtres, exactement le maillon suivant après celui qui s'exécute. Empiler des include et des super, c'est composer une pile de comportements dans l'ordre que ancestors affiche — et le dernier module inclus est le plus proche de la classe, donc consulté en premier. Quant au fameux « problème du diamant » de l'héritage multiple, Ruby le désamorce : un module mixé à plusieurs endroits n'apparaît qu'une fois dans la chaîne, à sa position la plus spécifique. Pas d'ambiguïté, pas d'appel en double.super doesn't call 'the parent's method': it calls the next definition of the same message in the ancestor chain, exactly the link after the one running. Stacking include and super composes a pile of behaviors in the order ancestors prints — and the last module included is closest to the class, so consulted first. As for multiple inheritance's famous 'diamond problem', Ruby defuses it: a module mixed in at several places appears only once in the chain, at its most specific position. No ambiguity, no double call.

module A; def hi = "A→" + super; end
module B; def hi = "B→" + super; end

class Base
  def hi = "Base"
end

class C < Base
  include A
  include B            # le DERNIER inclus est le plus proche de la classe
  def hi = "C→" + super
end

C.ancestors   # => [C, B, A, Base, Object, ...]
C.new.hi      # => "C→B→A→Base"
              #    super remonte la chaîne, un maillon à la fois

module Walk; def move = "marche"; end

class Animal; include Walk; end
class Robot;  include Walk; end       # Walk inclus à DEUX endroits

# pas de duplication : Ruby LINÉARISE la chaîne, Walk n'apparaît qu'une fois
class Cyborg < Animal
  include Walk                         # déjà présent via Animal
end
Cyborg.ancestors
# => [Cyborg, Animal, Walk, Object, ...]   ← un seul Walk, à sa 1re position
#    le « diamant » est résolu : aucune ambiguïté, aucun appel en double

Ce déterminisme est le vrai cadeau du modèle : une « capacité » mixée s'insère à un endroit connu de la chaîne, et super suit une route lisible. C'est exactement ce que le prochain chapitre va opposer à l'héritage profond — où la même capacité, modélisée comme une identité, éparpille le comportement sur plusieurs niveaux et brouille la route que super emprunte.This determinism is the model's real gift: a mixed-in 'capability' inserts at one known point of the chain, and super follows a readable route. That's exactly what the next chapter contrasts with deep inheritance — where the same capability, modeled as an identity, scatters the behavior across several levels and blurs the route super takes.

Une tour d'héritage pour une capacité qu'un mixin disait en une ligne.A tower of inheritance for a capability a mixin stated in one line.

Le contre-exemple du numéro, et le piège du dev qui vient de l'héritage classique. Pour donner à Money la capacité d'être comparé, il bâtit une hiérarchie — Money est un Comparable_ est une Entity — et réimplémente >, <, == à la main, niveau par niveau. La chaîne s'allonge, super doit la traverser, et le protocole reste incomplet (il manque toujours between?, clamp…). Or « pouvoir être comparé » n'est pas une identité, c'est une capacité : include Comparable l'ajoute à un seul endroit connu de la chaîne, dérive toutes les opérations d'un unique <=>, et ne prétend pas que Money « est » autre chose que Money.The issue's counter-example, and the trap of the dev coming from classical inheritance. To give Money the capability of being compared, they build a hierarchy — Money is a Comparable_ is an Entity — and reimplement >, <, == by hand, level by level. The chain lengthens, super has to traverse it, and the protocol stays incomplete (between?, clamp… still missing). But 'can be compared' isn't an identity, it's a capability: include Comparable adds it at one known point of the chain, derives every operation from a single <=>, and never pretends Money 'is' anything other than Money.

# Modéliser une CAPACITÉ (« peut être comparé ») comme une IDENTITÉ
class Entity; end
class Comparable_ < Entity
  def >(o)  = (self <=> o) > 0      # on réimplémente l'ordre à la main…
  def <(o)  = (self <=> o) < 0
  def ==(o) = (self <=> o).zero?    # … et on en oublie : >=, <=, between?, clamp
end
class Money < Comparable_
  attr_reader :cents
  def initialize(c) = @cents = c
  def <=>(o) = cents <=> o.cents
end

Money.ancestors  # => [Money, Comparable_, Entity, Object, ...]
# Money EST une Entity EST un Comparable_ — trois niveaux pour une capacité,
# une tour d'héritage où super doit traverser, et un protocole incomplet

# La même capacité, mixée à UN endroit connu
class Money
  include Comparable               # une ligne : la capacité, pas une identité
  attr_reader :cents
  def initialize(c) = @cents = c
  def <=>(o) = cents <=> o.cents   # le SEUL contrat à fournir
end

Money.ancestors  # => [Money, Comparable, Object, ...]   un seul maillon ajouté
Money.new(5) < Money.new(9)        # => true
Money.new(5).clamp(Money.new(1), Money.new(3))  # >, <, ==, between?, clamp… gratis