Vous voulez créer un programme accessible à l’utilisateur lambda mais vous êtes méfiants (et vous aurez raison) parce que vous savez pertinemment que les utilisateurs sont des imbéciles qui ne savent pas utiliser votre programme! Alors vous allez leur balancer des erreurs très sympas pour vous faire plaisir et pour les encadrer un peu (il faut bien que quelqu’un le fasse).

Mon exception, ma bataille

On va reprendre mon exemple de l’Equipe de France. On va ajouter des joueurs dans l’EDF mais on va vérifier uniquement leur nationalité. Si il est français, ok! Si il n’est pas français, ou corse (je n’ai rien contre vous les corses mais faudrait commencer par avoir des numéros de département corrects!), on affiche une erreur.

Voici le code :

class ErreurNationalite < RuntimeError
  attr :entree_utilisateur
  def initialize(entree_utilisateur)
    @entree_utilisateur = entree_utilisateur
  end
end
 
class EquipeDeFrance
  def nationalite(pays)
    if pays!="France"
      raise ErreurNationalite.new(pays), "Erreur fatale de nationalité!"
    end
  end
  def initialize(pays)
    self.nationalite(pays)
    rescue ErreurNationalite => mauvais_pays
    puts "T'as mis un mauvais pays, t'as mis " + mauvais_pays.entree_utilisateur + "."
    raise
  end
end
joueur = EquipeDeFrance.new("Espagne")
→ test.rb:11:in `nationalite': Erreur fatale de nationalité! (ErreurNationalite)
T'as mis un mauvais pays, t'as mis Espagne.

Ouhla, beaucoup de code! Mais on va y aller petit à petit.
Alors avant tout, je crée ma classe d’exception. Je l’appelle ErreurNationalite et elle hérite de RuntimeError (qui est une classe d’exception de Ruby). Elle hérite donc entre autres de ses méthodes. J’aurais pu prendre NoMethodError ou même Exception, mais voilà, RuntimeError me plaît.
Dans cette classe, je crée la méthode d’initialisation et je crée un attribut “entree_utilisateur” que l’on appelera plus tard pour lire ce que l’imbécile l’utilisateur a entré!

Ensuite, je crée ma classe EquipeDeFrance qui va me permettre d’ajouter des nouveaux joueurs à l’EDF (je ne mets pas les noms, juste la nationalité). Dans cette classe, je crée d’abord une méthode pour gérer les erreurs. Donc, si quelqu’un ne mets pas “France”, je raise une erreur avec ma classe ErreurNationalite. Ca consiste en fait à créer un objet de la classe ErreurNationalite, suivi (après la virgule) du texte d’erreur qui s’affichera en plus.

Enfin, j’ai la méthode classique initialize avec comme paramètre le pays. Rappelez-vous: quand je fais EquipeDeFrance.new, j’appelle en fait la méthode initialize. Ici, cette méthode ne fait que vérifier la nationalité en appelant la méthode nationalite précédemment créée. Si cette méthode rencontre une erreur, on exécute le rescue avec le type d’exception, en l’occurence… ErreurNationalite! La notre!
Avec la flèche (=>), ce que je fais c’est tout simplement mettre le contenu du résultat de ErreurNationalite dans la variable mauvais_pays. Pourquoi ? Pour le réutiliser la ligne d’après. J’appelle l’attribut entree_utilisateur (rappelez-vous…) de mauvais_pays. Enfin, à la fin, j’appelle raise sans rien, et Ruby est assez intelligent pour comprendre qu’il s’agit du raise pour ErreurNationalite.

Voilà ce qui s’affiche en somme:

  • le raise affiche test.rb:11:in `nationalite': Erreur fatale de nationalité! (ErreurNationalite)
  • le rescue (avec sa ligne suivante) affiche T'as mis un mauvais pays, t'as mis Espagne.

On aurait pu n’en mettre qu’un seul, mais c’est pour montrer ce que peuvent afficher les deux.