Classes ouvertes, ou le monkey-patch et sa portée Open classes, or monkey-patching and its scope

Aucune classe n'est fermée — on peut rouvrir même String.No class is closed — you can reopen even String.

Dernier barreau de l'échelle du volume, et le plus puissant. Le № 1 interceptait, le № 2 générait dans nos classes ; ici on rouvre n'importe quelle classe — la nôtre, celle d'une gem, ou String, Integer, Array du cœur de Ruby — pour y ajouter ou y changer du comportement. Ce n'est pas une faille : une classe Ruby n'est jamais close, écrire class String une seconde fois la rouvre. La conséquence directe du Vol 1 (les classes sont des objets qu'on manipule) et du Vol 5 (la méthode s'insère dans la chaîne d'ancêtres). La puissance est totale ; sa portée aussi — et c'est précisément le danger.The volume's last rung, and the most powerful. № 1 intercepted, № 2 generated in our classes; here you reopen any class — yours, a gem's, or String, Integer, Array from Ruby's core — to add or change behavior. It's not a loophole: a Ruby class is never closed, writing class String a second time reopens it. The direct consequence of Vol 1 (classes are objects you manipulate) and Vol 5 (the method inserts into the ancestor chain). The power is total; so is its reach — and that's precisely the danger.

# une classe n'est jamais « fermée » : on la ROUVRE, même String
class String
  def shout = upcase + "!"
end

"hello".shout                 # => "HELLO!"
"".respond_to?(:shout)        # => true   TOUS les String l'ont désormais
"x".method(:shout).owner      # => String  la méthode vit DANS String même

# rien de spécial : on a juste ajouté un maillon à la classe String (Vol 5)
String.instance_methods(false).include?(:shout)   # => true

Un monkey-patch agit à distance, sur le code des autres.A monkey-patch acts at a distance, on everyone else's code.

Rouvrir une classe du cœur ne touche pas « ta » classe : il n'y en a qu'une, partagée par tout le processus. Ajouter ou écraser une méthode sur String ou Array la change pour chaque bout de code qui les utilise — le tien, mais aussi celui de chaque gem chargée. Si deux endroits définissent la même méthode, la dernière chargée gagne, sans erreur ni avertissement. C'est l'action à distance : un changement local en apparence, global en effet. Le refinement répond exactement à ça — il confine l'ajout au fichier qui l'active par using, et laisse la classe intacte partout ailleurs.Reopening a core class doesn't touch 'your' class: there's only one, shared by the whole process. Adding or overriding a method on String or Array changes it for every piece of code using them — yours, but also every loaded gem's. If two places define the same method, the last loaded wins, with no error or warning. That's action at a distance: a change local in appearance, global in effect. The refinement answers exactly that — it confines the addition to the file that activates it via using, and leaves the class intact everywhere else.

# Dans TON fichier, un patch global qui paraît anodin
class Array
  def sum = "total inconnu"      # tu écrases la vraie méthode sum de Ruby
end

[1, 2, 3].sum                    # => "total inconnu"   ← chez toi, ok

# … mais AUSSI partout ailleurs, à distance :
require "csv"                     # une gem qui fait des .sum en interne
prices.sum                       # cassé, silencieusement, dans du code
                                  # que tu n'as jamais lu — la dernière
                                  # définition chargée gagne, sans erreur

Il n'existe qu'un seul Array dans le processus. Le rouvrir change l'unique classe que tout le monde partage — y compris la gem CSV qui fait des .sum en interne. Le bug n'apparaît pas chez toi : il surgit au fond d'un code que tu n'as pas écrit, sans la moindre trace de qui a patché.There's only one Array in the process. Reopening it changes the single class everyone shares — including the CSV gem doing .sum internally. The bug doesn't show in your code: it erupts deep in code you didn't write, with no trace of who patched.

refine décrit, using active — et la portée est lexicale.refine describes, using activates — and the scope is lexical.

Un refinement se fait en deux temps. refine String do … end, dans un module, décrit un ajout sans encore rien changer : la classe reste intacte. C'est using MonModule qui l'active — et seulement à partir de cette ligne, jusqu'à la fin du fichier, du module ou de la classe où il est écrit. La portée est lexicale : elle dépend de l'endroit où le code est écrit, pas de qui appelle quoi à l'exécution. C'est ce qui rend le refinement sûr là où le monkey-patch ne l'est pas — le changement ne peut pas fuir hors du texte qui l'a demandé. Le prix : quelques limites et un cran de lenteur.A refinement is two steps. refine String do … end, in a module, describes an addition without changing anything yet: the class stays intact. It's using MyModule that activates it — and only from that line, to the end of the file, module or class where it's written. The scope is lexical: it depends on where the code is written, not on who calls what at runtime. That's what makes the refinement safe where the monkey-patch isn't — the change can't leak beyond the text that asked for it. The price: a few limits and a notch of slowness.

module Sluggable
  refine String do            # l'ajout est DÉCRIT, pas encore actif
    def to_slug = downcase.strip.gsub(/\s+/, "-")
  end
end

# fichier A : on l'active
using Sluggable               # portée lexicale : d'ici à la fin du fichier
"Hello World".to_slug         # => "hello-world"

# fichier B : on ne l'active pas
"Hello World".to_slug         # NoMethodError — String y est resté vierge

# La portée est LEXICALE, pas dynamique : décidée par où le code est ÉCRIT
module Helper
  using Sluggable
  def self.run(s) = s.to_slug   # ok : le using couvre ce module
end

class Other
  def run(s) = s.to_slug         # NoMethodError : pas de using ici
end

# limites à connaître :
#  · ne s'active qu'au top-level d'un fichier, d'un module ou d'une classe
#  · invisible au code défini ailleurs, même appelé depuis ici
#  · un cran plus lent que l'appel direct

Garde la hiérarchie des recours en tête : d'abord, pas de patch du tout — une fonction ou un module qui prend l'objet (Slug.from(str)) ne touche aucune classe et ne peut entrer en collision avec personne. Ensuite, si un patch est vraiment justifié, le refinement, local. Le monkey-patch global, en tout dernier, et seulement quand le changement doit être universel et que tu en assumes la portée.Keep the ladder of recourse in mind: first, no patch at all — a function or module that takes the object (Slug.from(str)) touches no class and can collide with no one. Then, if a patch is truly justified, the refinement, local. The global monkey-patch, last of all, and only when the change must be universal and you own its reach.

String#to_slug en global dans une lib : la collision est une échéance.String#to_slug global in a lib: the collision is a deadline.

Le contre-exemple obligatoire du numéro. On ajoute String#to_slug en monkey-patch global, souvent dans une bibliothèque partagée — c'est élégant à l'appel, str.to_slug se lit bien. Mais on vient de réserver un nom sur l'unique String que tout le monde partage. Le jour où une autre gem, ou une version de Rails, définit to_slug autrement, la dernière chargée gagne : silencieusement, sans erreur, le comportement change selon l'ordre des require. Ce n'est pas un risque hypothétique, c'est une question de temps. Et la parade ne coûte presque rien : une fonction qui prend la chaîne ne touche aucune classe ; un refinement la garde locale.The issue's mandatory counter-example. You add String#to_slug as a global monkey-patch, often in a shared library — it's elegant at the call site, str.to_slug reads well. But you just reserved a name on the single String everyone shares. The day another gem, or a Rails version, defines to_slug differently, the last loaded wins: silently, with no error, behavior shifts with require order. It's not a hypothetical risk, it's a matter of time. And the remedy costs almost nothing: a function taking the string touches no class; a refinement keeps it local.

# Dans une gem PARTAGÉE : on ajoute to_slug à String, en global
class String
  def to_slug = downcase.strip.gsub(/\s+/, "-").gsub(/[^a-z0-9-]/, "")
end

"Été 2026".to_slug              # => "t-2026"   pratique, sur le moment

# … jusqu'au jour où une AUTRE gem définit aussi String#to_slug,
# autrement (en gardant les accents, par ex.). La dernière chargée gagne.
# Aucune erreur, aucun avertissement : juste un slug qui change selon
# l'ordre des require. La collision n'est pas un risque — c'est une échéance.

# Option A — pas de patch : une fonction qui PREND la String
module Slug
  def self.from(str) = str.downcase.strip.gsub(/\s+/, "-").gsub(/[^a-z0-9-]/, "")
end
Slug.from("Été 2026")           # => "t-2026"   zéro classe touchée, zéro collision

# Option B — un refinement, si tu tiens à la syntaxe str.to_slug
module Sluggable
  refine String do
    def to_slug = Slug.from(self)
  end
end
# le fichier qui en a besoin fait « using Sluggable » — et lui seul