la-ferme

raise "This is an error"

raise ArgumentError.new("This is an argument error")

begin
 raise "This is an error"
rescue
 puts "An error occurred!"
end

begin
 raise "This is an error"
rescue ex
 puts "An error occurred: #{ex.message}"
end

begin
 raise ArgumentError.new("This is an argument error")
rescue ArgumentError
 puts "An argument error occurred!"
end

# or

begin
 raise ArgumentError.new("This is an argument error")
rescue ex : ArgumentError
 puts "An argument error occurred: #{ex.message}"
end

begin
 raise ArgumentError.new("This is an argument error")
rescue ArgumentError
 puts "An argument error occurred!"
rescue
 puts "An error occurred!"
end

begin
 puts "No error occurred"
rescue
 puts "An error occurred!"
else
 puts "No error occurred"
end

begin
 raise "This is an error"
rescue
 puts "An error occurred!"
ensure
 puts "This is always executed"
end

class MyException < Exception
 def initialize
   @message = "This is my exception"
 end
end

raise MyException.new

Instructions

Le jour que tu attendais depuis si longtemps est enfin arrivé : tu es désormais le fier propriétaire d'une belle ferme dans les Alpes.

Tu n'aimes toujours pas te lever trop tôt le matin pour nourrir tes vaches. Comme tu es un excellent ingénieur, tu construis un distributeur de nourriture, le FEED-M-ALL.

La dernière chose dont tu as besoin pour terminer ton projet, c'est un bout de code qui calcule la quantité de fourrage que chaque vache doit recevoir. Il est important que chaque vache reçoive la même quantité ; il faut éviter les conflits. Les vaches sont très sensibles.

Heureusement, tu n'as pas besoin de trouver toi-même toutes les formules pour calculer les quantités de fourrage. Tu utilises une mystérieuse bibliothèque externe que tu as trouvée sur internet. Elle est censée produire les vaches les plus heureuses. La bibliothèque expose une classe qui implémente l'interface suivante. Tu t'appuieras sur elle dans le code que tu écriras toi-même.

class FodderCalculator
  def fodder_amount! : Number 
  end

  def fattening_factor! : Number
  end
end

Au fur et à mesure que tu travailles sur ton code, tu amélioreras la gestion des erreurs pour la rendre plus robuste et plus facile à déboguer plus tard, quand tu l'utiliseras dans ta vie quotidienne à la ferme.

1. Répartis la nourriture équitablement

Tout d'abord, tu te concentres sur l'écriture du code nécessaire pour calculer la quantité de fourrage par vache.

Implémente une méthode TheFarm.divide_food qui accepte comme arguments un objet FodderCalculator et un nombre de vaches sous forme d'entier. Pour cette tâche, tu supposes que le nombre de vaches transmis est toujours supérieur à zéro. La méthode doit renvoyer la quantité de nourriture par vache.

Pour faire le calcul, tu dois d'abord récupérer la quantité totale de fourrage pour toutes les vaches. Pour cela, il faut appeler la méthode fodder_amount! en lui passant le nombre de vaches. De plus, tu as besoin d'un facteur par lequel cette quantité doit être multipliée. Tu obtiens ce facteur en appelant la méthode fattening_factor!. Avec ces deux valeurs et le nombre de vaches, tu peux maintenant calculer la quantité de nourriture par vache (sous forme de float64).

Si l'une des méthodes que tu appelles renvoie une erreur, l'exécution doit s'arrêter et renvoyer 0.

fodder_calculator = FodderCalculator.new(50, 1.5)
TheFarm.divide_food(fodder_calculator, 5)
# => 15.0

fodder_calculator = FodderCalculator.new(50, nil)
TheFarm.divide_food(fodder_calculator, 5)
# => 0

2. Vérifie le nombre de vaches

En travaillant sur la première tâche ci-dessus, tu as réalisé que la bibliothèque externe que tu utilises n'est pas d'aussi bonne qualité que tu le pensais. Par exemple, elle ne sait pas gérer correctement les entrées invalides. Tu veux contourner cette limitation en ajoutant une vérification de la valeur d'entrée dans ton propre code.

Écris une fonction TheFarm.validate_input_and_divide_food qui a la même signature que TheFarm.divide_food ci-dessus.

• Si le nombre de vaches transmis est supérieur à 0, la fonction doit appeler TheFarm.divide_food et renvoyer le résultat de cet appel.
• Si le nombre de vaches est inférieur ou égal à 0, la fonction doit lever une erreur avec le message "Number of cows must be greater than 0".

TheFarm.validate_input_and_divide_food(fodderCalculator, 5)
# => 15

TheFarm.validate_input_and_divide_food(fodderCalculator, -2)
# Error: Number of cows must be greater than 0

3. Améliore la gestion des erreurs

Vérifier le nombre de vaches avant de le transmettre était une bonne idée, mais le message d'erreur trop vague ne te satisfait pas vraiment. Tu décides de faire mieux en créant une classe d'erreur personnalisée appelée InvalidCowsError.

L'erreur personnalisée doit contenir le nombre de vaches (Int32) et un message personnalisé (String), et la méthode Expection doit sérialiser les données au format suivant :

{number of cows} cows are invalid: {custom message}

Muni de ton erreur personnalisée, implémente une fonction TheFarm.validate_number_of_cows qui accepte le nombre de vaches sous forme d'entier et renvoie une erreur (ou nil).

• Si le nombre de vaches est inférieur à 0, la fonction renvoie une InvalidCowsError avec le message personnalisé défini sur "there are no negative cows".
• Si le nombre de vaches est 0, la fonction renvoie une InvalidCowsError avec le message personnalisé défini sur "no cows don't need food".
• Sinon, la fonction renvoie nil pour indiquer que la validation a réussi.

TheFarm.validate_number_of_cows(5)
# => nil

TheFarm.validate_number_of_cows(-5)
# => InvalidCowsError: -5 cows are invalid: there are no negative cows

Après le dur labeur que représente la mise en place de cette fonction de validation, tu remarques qu'il se fait déjà tard et tu quittes ton bureau pour profiter du coucher de soleil sur les montagnes. Tu remets à un autre jour le soin d'ajouter réellement la nouvelle fonction de validation à ton code.