raise / rescue / ensure, ou l'erreur est un objet raise / rescue / ensure, or the error is an object

Lever une exception, c'est envoyer un objet vers le haut de la pile.Raising an exception is sending an object up the stack.

Le Vol 7 ouvre le flux d'erreur. Et fidèle au fil de la série, une exception n'est pas une construction à part : c'est un objet (Vol 1), instance d'une classe d'erreur, qu'on lève et qu'on rattrape par son type. raise crée et propulse cet objet vers le haut de la pile d'appels, en déroulant chaque méthode au passage, jusqu'à ce qu'un rescue du bon type l'attrape. ensure, lui, garantit qu'un bout de code s'exécute quoi qu'il arrive — succès ou erreur. Trois mots, trois rôles : signaler, rattraper, nettoyer. Tout le mécanisme tient là.Vol 7 opens the error flow. And true to the series' thread, an exception isn't a separate construct: it's an object (Vol 1), an instance of an error class, raised and caught by its type. raise creates and propels that object up the call stack, unwinding each method along the way, until a rescue of the right type catches it. ensure guarantees a piece of code runs whatever happens — success or error. Three words, three roles: signal, catch, clean up. The whole mechanism sits there.

# une exception est un OBJET, levé puis rattrapé par sa CLASSE
err = ArgumentError.new("âge négatif")
err.is_a?(StandardError)   # => true   c'est un objet, dans une hiérarchie
err.message                # => "âge négatif"

def set_age(n)
  raise ArgumentError, "âge négatif" if n < 0   # lever : on signale
  @age = n
end

begin
  set_age(-1)
rescue ArgumentError => e   # rattraper PAR TYPE
  puts "refusé : #{e.message}"
ensure
  puts "toujours exécuté"    # nettoyer : quoi qu'il arrive
end

rescue trie par type — et un rescue nu en attrape trop.rescue sorts by type — and a bare rescue catches too much.

rescue n'attrape pas « les erreurs » en bloc : il teste la classe de l'objet-exception, comme un case sur son type. rescue KeyError n'attrape que KeyError et ses sous-classes ; tout le reste continue de remonter. C'est le duck typing appliqué aux erreurs (Vol 3) : on trie par ce que l'erreur est. Le piège du débutant est le rescue nu — sans classe, il vaut rescue StandardError et ratisse donc presque tout. Un timeout réseau et un bug de programmation finissent dans le même filet, traités pareil. Nommer le type qu'on attrape, c'est décider quelle erreur on sait gérer, et laisser passer celles qu'on ne sait pas.rescue doesn't catch 'errors' wholesale: it tests the exception object's class, like a case on its type. rescue KeyError catches only KeyError and its subclasses; everything else keeps climbing. It's duck typing applied to errors (Vol 3): you sort by what the error is. The beginner's trap is the bare rescue — with no class, it means rescue StandardError and so rakes in almost everything. A network timeout and a programming bug land in the same net, handled the same. Naming the type you catch is deciding which error you know how to handle, and letting through the ones you don't.

def fetch_user(id)
  row = db.query(id)          # peut lever Timeout::Error (réseau)
  User.new(row.fetch(:name)) # peut lever KeyError (donnée incomplète)
rescue => e                   # un rescue NU = rescue StandardError
  Rails.logger.warn(e)        # … attrape les DEUX, et tout le reste
  nil                         # un timeout réseau et un bug de données
end                           # finissent traités pareil : noyés en nil

Le rescue nu vaut rescue StandardError : il attrape le Timeout (réseau, qu'on pourrait retenter) et le KeyError (donnée invalide, une vraie faute) et n'importe quel NoMethodError dû à un bug. Tout devient nil, indistinctement — on a perdu l'information que portait le type de l'erreur.The bare rescue means rescue StandardError: it catches the Timeout (network, retryable) and the KeyError (invalid data, a real fault) and any NoMethodError from a bug. Everything becomes nil, indistinctly — you've lost the information the error's type carried.

ensure court toujours, retry relance, raise nu re-lève.ensure always runs, retry retries, bare raise re-raises.

L'anatomie complète tient en cinq mots-clés, chacun avec un rôle net. begin délimite la zone à risque ; rescue rattrape par type ; else court si — et seulement si — rien n'a été levé ; ensure court dans tous les cas, c'est la garantie de nettoyage ; retry relance le begin depuis le début, pour les erreurs transitoires. Et raise sans argument, dans un rescue, re-lève l'exception courante telle quelle : on journalise, puis on laisse remonter, sans rien avaler. Une méthode ou un bloc font office de begin implicite — pas besoin de l'écrire. Cinq mots, et le flux d'erreur n'a plus de zone d'ombre.The full anatomy is five keywords, each with a clear role. begin marks the risky zone; rescue catches by type; else runs if — and only if — nothing was raised; ensure runs in every case, the cleanup guarantee; retry restarts the begin from the top, for transient errors. And raise with no argument, inside a rescue, re-raises the current exception as is: you log, then let it climb, swallowing nothing. A method or block acts as an implicit begin — no need to write it. Five words, and the error flow has no blind spots.

begin
  attempt                  # le code à risque
rescue Timeout::Error
  retry if (tries ||= 0; tries += 1) < 3   # RETRY : relance le begin
rescue KeyError => e
  log(e)
  raise                    # RAISE nu : re-lève LA MÊME erreur, sans l'avaler
else
  commit                   # ELSE : court seulement si AUCUNE exception
ensure
  connection.close         # ENSURE : court TOUJOURS, succès comme échec
end

# pas besoin de begin : une méthode (ou un bloc) est son propre begin
def charge(card)
  gateway.bill(card)
rescue Gateway::Declined => e
  notify(e)
  raise                    # on a journalisé, mais l'erreur doit remonter
ensure
  audit_log.write(card.id) # toujours, qu'on ait payé ou échoué
end

Deux pièges de retry à nommer en passant : sans compteur, il boucle à l'infini si l'erreur persiste ; et il relance tout le begin, donc gare aux effets déjà appliqués avant le point de rupture. retry est fait pour le transitoire — un timeout, une latence réseau — borné par un nombre d'essais, jamais pour réessayer une opération vouée à échouer.Two retry traps worth naming in passing: with no counter, it loops forever if the error persists; and it restarts the whole begin, so beware effects already applied before the breaking point. retry is for the transient — a timeout, network latency — bounded by an attempt count, never to re-run an operation doomed to fail.

Nettoyer dans rescue : on saute le cas normal, on avale l'erreur.Cleaning up in rescue: you skip the normal case, you swallow the error.

Le contre-exemple du numéro naît d'une confusion des rôles. On veut fermer un fichier, alors on met file.close dans le rescue — ou on le duplique entre le chemin heureux et le rescue. Mais rescue ne court que sur erreur : si parse réussit puis quelque chose lève après, ou si on oublie une branche, la fermeture manque. Et nettoyer dans rescue oblige souvent à rattraper l'exception, donc à l'avaler. Le nettoyage n'est pas une réaction à l'erreur, c'est une garantie inconditionnelle : sa place est ensure, qui court dans tous les cas sans rien rattraper. Mieux encore quand elle existe : la forme à bloc, qui ferme la ressource pour toi.The issue's counter-example springs from confusing roles. You want to close a file, so you put file.close in the rescue — or duplicate it between the happy path and the rescue. But rescue runs only on error: if parse succeeds then something raises later, or you miss a branch, the close is skipped. And cleaning up in rescue often forces you to catch the exception, hence to swallow it. Cleanup isn't a reaction to the error, it's an unconditional guarantee: its place is ensure, which runs in every case without catching anything. Better still where it exists: the block form, which closes the resource for you.

# Le piège : mettre le nettoyage dans rescue
def process(path)
  file = File.open(path)
  data = parse(file)       # si parse lève…
  file.close               # … cette ligne est SAUTÉE → descripteur fuité
  data
rescue => e
  file.close               # on ferme ici, mais on vient d'AVALER l'erreur
  nil                      # parse a échoué — l'appelant ne le saura jamais
end
# deux bugs en un : la fermeture manque sur le chemin heureux interrompu,
# et l'exception est noyée en nil

# ensure : le nettoyage court TOUJOURS, et n'avale rien
def process(path)
  file = File.open(path)
  parse(file)              # si ça lève, l'erreur REMONTE intacte…
ensure
  file&.close              # … mais ceci s'exécute quand même (succès ou échec)
end

# encore mieux — la forme à bloc ferme pour toi, sans ensure à écrire :
def process(path)
  File.open(path) { |file| parse(file) }   # close garanti à la sortie du bloc
end