L10n fr for exercises on trampoline, async loop and recursion.

Author: tdd

exercises/async_loops/exercise.js

@@ -42,17 +42,17 @@ module.exports = runner.custom(function(f) {
     console.log(submittedUsers)
 
     if (!deepEqual(submittedUsers, users)) {
-      self.emit('fail', 'expected: \n' + inspect(users) + '\n but got: \n'+ inspect(submittedUsers))
+      self.emit('fail', self.__('bad_result', inspect(users), inspect(submittedUsers)))
       return callback(null, false)
     }
 
-    console.log('All %d users loaded!', submittedUsers.length)
+    console.log(self.__('all_loaded', submittedUsers.length))
     callback(null, true)
   }
 
   fx.call(fx, ids, load, done)
   var tooLong = setTimeout(function() {
-    self.emit('fail', 'Took too long!')
+    self.emit('fail', self.__('took_too_long'))
     callback(null, false)
   }, 1000)
 }).quiet(users)

exercises/async_loops/problem.fr.md

@@ -0,0 +1,51 @@
+Le code ci-dessous est cassé !
+
+Un développeur Java a ajouté le code atroce ci-dessous à notre projet et ne l’a pas testé !
+
+```js
+function loadUsers(userIds, load, done) {
+  var users = []
+  for (var i = 0; i < userIds.length; i++) {
+    users.push(load(userIds[i]))
+  }
+  return users
+}
+
+module.exports = loadUsers
+```
+
+## Défi
+
+Corrigez ce code !  La fonction de rappel `done()` devrait être appelée une fois que tous les utilisateurs ont été chargés.  L’ordre des utilisateurs devrait correspondre à celui des IDs reçus.  Vu que cette fonction est asynchrone, on se fiche de sa valeur de retour.
+
+## Arguments
+
+* `userIds` : un tableau d’IDs numériques d’utilisateurs.
+* `load` : une fonction asynchrone de chargement d’un objet utilisateur.  Reçoit un ID et une fonction de rappel.  Celle-ci sera appelée avec le résultat du chargement pour l’utilisateur avec l’ID indiqué (soit un objet utilisateur, soit `null`).
+* `done` : une fonction de rappel finale, qui attend comme argument un tableau des objets utilisateurs chargés.
+
+## Conditions
+
+* N’utilisez pas de boucles `for`/`while` (mais `Array#forEach()` reste autorisé).
+* L’ordre des utilisateurs dans le tableau passé à `done()` doit correspondre à celui des IDs dans le tableau `userIds` que vous aurez reçu.
+* Les utilisateurs doivent être chargés en parallèle, donc la séquence entière ne devrait pas dépasser une seconde.
+* Ne créez aucune fonction superflue
+
+## Conseils
+
+* Vous n’avez pas besoin d’un tri pour maintenir l’ordre du résultat.
+* Si vous utilisez `console.log()`, ça va impacter notre vérification.  Ne vous en servez que pendant votre phase de mise au point avec `{appname} run`.
+
+## Base de travail
+
+```js
+function loadUsers(userIds, load, done) {
+  var users = []
+  for (var i = 0; i < userIds.length; i++) {
+    users.push(load(userIds[i]))
+  }
+  return users
+}
+
+module.exports = loadUsers
+```

exercises/recursion/problem.fr.md

@@ -0,0 +1,55 @@
+## Défi
+
+Écrivez une fonction récursive qui renvoie toutes les dépendances (et sous-dépendances) unique d’un module, triées alphabétiquement.  Elles doivent être affichées au format *dependance@version*, par ex. `inflection@1.2.6`.
+
+On autorise des versions multiples d’un même module, mais les doublons (versions identiques) doivent être retirés.
+
+## Arguments
+
+* `tree` : Une arborescence de dépendances.  Voir ci-dessous pour sa structure.
+
+## Exemple
+
+```js
+var loremIpsum = {
+  "name": "lorem-ipsum",
+  "version": "0.1.1",
+  "dependencies": {
+    "optimist": {
+      "version": "0.3.7",
+      "dependencies": {
+        "wordwrap": {
+          "version": "0.0.2"
+        }
+      }
+    },
+    "inflection": {
+      "version": "1.2.6"
+    }
+  }
+}
+
+getDependencies(loremIpsum) // => [ 'inflection@1.2.6', 'optimist@0.3.7', 'wordwrap@0.0.2' ]
+
+```
+
+## Conditions
+
+* N’utilisez pas de boucle `for`/`while`.
+
+## Base de travail
+
+```js
+function getDependencies(tree) {
+  // VOTRE SOLUTION ICI
+  // Note : n’hésitez pas à ajouter des arguments dont vous auriez besoin dans
+  // vos appels récursifs.  Mais ça n’a rien d’obligatoire !  Il y a bien des
+  // manières de faire de la récursivité.
+}
+
+module.exports = getDependencies
+```
+
+## Ressources
+
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/keys

exercises/trampoline/exercise.js

@@ -2,11 +2,12 @@
 
 var runner = require('../runner')
 
-module.exports = runner.custom(function(repeat) {
-  console.log('repeating 100000 times')
+var exercise = module.exports = runner.custom(function(repeat) {
+  var COUNT = 100000
+  console.log(exercise.__('intro', COUNT))
   var count = 0
   repeat(function() {
     count++
-  }, 100000)
-  console.log('Sucessfully executed %d times.', count)
+  }, COUNT)
+  console.log(exercise.__('result', count))
 }).quiet()

exercises/trampoline/problem.fr.md

@@ -0,0 +1,59 @@
+La base de travail fournie plus bas contient une définition de `repeat()`.  Celle-ci recevra une opération sous forme de `Function`, et un nombre `num`, pour invoquer la fonction `num` fois :
+
+```js
+var count = 0
+repeat(function() {
+  count++
+}, 100)
+
+console.log('exécuté %d fois.', count)
+// => exécuté 100 fois.
+```
+
+MAIS vous remarquerez qu’exécuter `repeat()` avec un nombre trop grand de répétitions causera un débordement de pile (*stack overflow*) :
+
+```
+var count = 0
+repeat(function() {
+  count++
+}, 100000)
+
+console.log('exécuté %d fois', count)
+// => RangeError: Maximum call stack size exceeded
+```
+
+# Défi
+
+Modifiez la base de travail ci-dessous pour qu’elle utilise un trampoline afin que la fonction s’appelle elle-même continuellement.
+
+Vous pouvez supposer que l’opération qui vous sera fournie ne prend aucun argument (ou qu’ils sont déjà pré-remplis), et que sa valeur de retour est sans importance.
+
+## Conditions
+
+Vos modifications de l’implémentation de `repeat()` ne doivent pas utiliser de boucles ou d’itérateurs (ex. `forEach()`).
+
+## Conseils
+
+- Modifiez `repeat()` pour qu’elle envoie la « prochaine étape », s’il y en a une.
+- Un trampoline continue à exécuter les étapes en obtenant à chaque tour la suivante, jusqu’à ce qu’il n’y en ait plus.  Pour le coup, vous pouvez utiliser une boucle dans votre fonction de trampoline !
+- Si votre programme prend trop de temps à s’exécuter, vous avez probablement un souci.  Utilisez Ctrl+C pour arrêter le processus Node.
+
+## Base de travail
+
+```js
+function repeat(operation, num) {
+  // Modifiez ce code pour qu’il ne cause pas de débordement de pile !
+  if (num <= 0) return
+  operation()
+  return repeat(operation, --num)
+}
+
+function trampoline(fn) {
+  // Voilà où implémenter votre trampoline ; une boucle est autorisée ici.
+}
+
+module.exports = function(operation, num) {
+  // Et voilà où vous voudrez sans doute plutôt appeler votre trampoline !
+  return repeat(operation, num)
+}
+```

i18n/en.json

@@ -32,6 +32,15 @@
       "incorrect_return": "Check your function's return value!",
       "incorrect_this": "Check the function's this! Hint: Function#apply",
       "not_all_args": "Check you are passing ALL the arguments! Hint: Function#apply"
+    },
+    "Trampoline": {
+      "intro": "repeating %d times",
+      "result": "Successfully executed %d times."
+    },
+    "Async Loops": {
+      "all_loaded": "All %d users loaded!",
+      "bad_result": "expected: \n%s\n but got:\n%s",
+      "took_too_long": "Took too long!"
     }
   }
 }

i18n/fr.json

@@ -52,6 +52,15 @@
       "incorrect_return": "Vérifiez la valeur de retour de votre fonction !",
       "incorrect_this": "Vérifiez le `this` de votre fonction ! Conseil : `Function#apply()`.",
       "not_all_args": "Vérifiez que vous transmettez bien TOUS les arguments ! Conseil : `Function#apply()`."
+    },
+    "Trampoline": {
+      "intro": "Répétition de la fonction %d fois",
+      "result": "Ai pu exécuter la fonction avec succès %d fois."
+    },
+    "Async Loops": {
+      "all_loaded": "L’ensemble des %d utilisateurs a été chargé !",
+      "bad_result": "j’attendais : \n%s\n mais j’ai reçu :\n%s",
+      "took_too_long": "Ça a pris trop longtemps !"
     }
   }
 }