L10n fr exercises on map/reduce, spies, blocking event loop

Author: tdd

exercises/blocking_event_loop/exercise.js

@@ -5,4 +5,4 @@
 var path = require('path')
 var runner = require('../runner')
 
-module.exports = runner.wrapWith(path.join(__dirname, 'wrapper.js'))
+module.exports = runner.wrapWith(path.join(__dirname, 'wrapper.js'), { localized: true })

exercises/blocking_event_loop/problem.fr.md

@@ -0,0 +1,33 @@
+# Défi
+
+Modifiez la fonction récursive `repeat()`, fournie plus bas dans la base de travail, de façon à ce qu’elle ne bloque pas la boucle événementielle (c’est-à-dire pour qu’elle laisse passer les timers et gestionnaires E/S).  Il vous faudra nécessairement en faire une fonction asynchrone.
+
+Un timeout sera déclenché après une seconde, qui affichera les résultats du test et terminara le processus.  `repeat()` doit relâcher son contrôle sur la boucle événementielle de telle sorte que ce timeout puisse s’exécuter avant que 1500 millisecondes soient passées.
+
+Essayez d’exécuter l’opération passée à `repeat()` autant de fois que possible avant le timeout !
+
+## Conditions
+
+* N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+* Ne créez aucune fonction superflue
+
+## Conseils
+
+Si votre programme prend trop de temps à s’exécuter, vous avez probablement un souci.  Utilisez Ctrl+C pour arrêter le processus Node.
+
+## Ressources
+
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Timers
+
+## Base de travail
+
+```js
+function repeat(operation, num) {
+  // modifiez cette fonction pour la rendre interruptible
+  if (num <= 0) return
+  operation()
+  return repeat(operation, --num)
+}
+
+module.exports = repeat
+```

exercises/blocking_event_loop/solution_fr/solution.js

@@ -0,0 +1,17 @@
+function repeat(operation, num) {
+  if (num <= 0) return
+
+  operation()
+
+  // relâcher le contrôle tous les 10 tours
+  // (10 est une taille de lot arbitraire).
+  if (num % 10 === 0) {
+    setTimeout(function() {
+      repeat(operation, --num)
+    })
+  } else {
+    repeat(operation, --num)
+  }
+}
+
+module.exports = repeat

exercises/blocking_event_loop/wrapper_fr.js

@@ -0,0 +1,33 @@
+'use strict'
+
+var path = require('path')
+
+var repeat = require(path.resolve(process.cwd(), process.argv[2]))
+
+var count = 0
+var CYCLES = 100000
+
+function operation() {
+  for (var i = 0; i < 1000000; i++) {}  // burn some CPU cycles
+  count++ // count how many times this function was called
+}
+
+console.log()
+console.log('l’opération :')
+console.log(operation.toString())
+console.log()
+console.log('J’essaie de répéter l’opération %d fois…', CYCLES)
+console.log('Pressez Ctrl+C pour interrompre.')
+console.log()
+
+var start = Date.now()
+repeat(operation, CYCLES)
+
+setTimeout(function() {
+  var end = Date.now()
+  console.error('J’ai effectué %d opérations.', count)
+  if (count === CYCLES) console.log('Raté ! Je n’aurais pas du pouvoir aller au bout !')
+  if (end - start < 1500) console.log('Interruption au bout d’environ 1 seconde !')
+  else console.log('Raté ! Interruption au bout de %d millisecondes', end - start)
+  process.exit()
+}, 1000)

exercises/function_spies/exercise.js

@@ -13,10 +13,10 @@ var exercise = module.exports = runner.custom(function(Spy, input) {
   var parent = {
     test: function() {
       if (!deepEqual(slice.call(arguments), input[count])) {
-        exercise.emit('fail', "Check you are passing ALL the arguments! Hint: Function#apply")
+        exercise.emit('fail', exercise.__('not_all_args'))
       }
       if (this !== parent) {
-        exercise.emit('fail', "Check the function's this! Hint: Function#apply")
+        exercise.emit('fail', exercise.__('incorrect_this'))
       }
       return arguments
     }
@@ -29,10 +29,10 @@ var exercise = module.exports = runner.custom(function(Spy, input) {
     result.push(util.format.apply(util, args))
     count = i
     if (!deepEqual(originalFn.apply(parent, args), parent.test.apply(parent, args))) {
-      exercise.emit('fail', "Check your function's return value!")
+      exercise.emit('fail', exercise.__('incorrect_return'))
     }
   })
 
-  result.push(util.format('Method called %d times. ', spy.count))
+  result.push(exercise.__('call_times', spy.count))
   return result
 }).quiet(input)

exercises/function_spies/problem.fr.md

@@ -0,0 +1,39 @@
+# Défi
+
+Ajoutez des capacités à une méthode précise sur un objet, tout en préservant son comportement d’origine : créez un espion qui garde la trace du nombre de fois que la fonction a été appelée.
+
+## Exemple
+
+```js
+var spy = Spy(console, 'error')
+
+console.error('appel de console.error')
+console.error('appel de console.error')
+console.error('appel de console.error')
+
+console.log(spy.count) // 3
+```
+
+## Arguments
+
+* `target` : un objet contenant la méthode `method`.
+* `method` : une `String` indiquant le nom de la méthode de `target` à espionner.
+
+## Conditions
+
+* N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+* Ne créez aucune fonction superflue
+
+## Conseils
+
+Les fonctions ont un contexte (une valeur de `this`), une entrée (les arguments) et une sortie (la valeur de retour).  Assurez vous que vous préservez tous ces aspects pour la fonction que vous espionnez.
+
+## Base de travail
+
+```js
+function Spy(target, method) {
+  // VOTRE SOLUTION ICI
+}
+
+module.exports = Spy
+```

exercises/function_spies/solution_fr/solution.js

@@ -0,0 +1,22 @@
+function Spy(target, method) {
+  var originalFunction = target[method]
+
+  // Utilisons un objet pour pouvoir le renvoyer par référence,
+  // et non par copie de valeur.  Ainsi nous pouvons renvoyer
+  // `result`, mais mettre à jour `count` depuis cette portée.
+  var result = {
+    count: 0
+  }
+
+  // remplaçons la méthode par sa version « espion »
+  target[method] = function() {
+    // On comptabilise l’appel
+    result.count++
+    // On invoque la version d’origine
+    return originalFunction.apply(this, arguments)
+  }
+
+  return result
+}
+
+module.exports = Spy

exercises/implement_map_with_reduce/problem.fr.md

@@ -0,0 +1,36 @@
+# Défi
+
+Utilisez `Array#reduce()` pour implémenter une version simple de `Array#map()`.
+
+## Résultat attendu
+
+Une fonction `map()` applique une fonction quelconque à chaque élément d’un tableau, et renvoie le tableau des résultats obtenus.
+
+```js
+var nums = [1,2,3,4,5]
+
+// `map` est la fonction que vous exportez
+var output = map(nums, function double(item) {
+  return item * 2
+})
+
+console.log(output) // => [2,4,6,8,10]
+```
+
+## Arguments
+
+* `input` : un tableau de données quelconques, de types variés.
+* `operation` : une fonction quelconque, à appliquer aux éléments de `input`.
+
+## Ressources
+
+* https://en.wikipedia.org/wiki/Reduce_(higher-order_function)
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/reduce
+
+## Base de travail
+
+```js
+module.exports = function arrayMap(arr, fn) {
+  // VOTRE SOLUTION ICI
+}
+```

exercises/runner.js

@@ -8,7 +8,7 @@ var os = require('os')
 var path = require('path')
 var util = require('util')
 
-var verbose = true, showInput = true, initFx, wrapUpFx, customFx, wrapperModulePath
+var verbose = true, showInput = true, initFx, wrapUpFx, customFx, wrapperModule
 
 function runner() {
   var exercise = execute(filecheck(exerciser()))
@@ -36,10 +36,17 @@ function runner() {
     callback(null, true)
   });
 
-  if (wrapperModulePath) {
+  if (wrapperModule && wrapperModule.path) {
     exercise.addSetup(function setupWrapperModule(mode, callback) {
-      this.solutionCommand = [ wrapperModulePath, this.solution ].concat(this.solutionArgs)
-      this.submissionCommand = [ wrapperModulePath, this.submission ].concat(this.submissionArgs)
+      var modulePath = wrapperModule.path
+      if (wrapperModule.options && wrapperModule.options.localized) {
+        var localizedPath = modulePath.replace(/\.\w+$/, '_' + exercise.lang + '$&')
+        if (fs.existsSync(path.resolve(process.cwd(), localizedPath))) {
+          modulePath = localizedPath
+        }
+      }
+      this.solutionCommand = [ modulePath, this.solution ].concat(this.solutionArgs)
+      this.submissionCommand = [ modulePath, this.submission ].concat(this.submissionArgs)
 
       if (input.length > 0) {
         var file = path.join(os.tmpdir(), path.basename(this.solution)) + '.input.json'
@@ -116,9 +123,9 @@ runner.quiet = function quiet() {
   return runner.apply(null, arguments)
 }
 
-runner.wrapWith = function wrapWith(modulePath) {
+runner.wrapWith = function wrapWith(modulePath, options) {
   verbose = false
-  wrapperModulePath = modulePath
+  wrapperModule = { path: modulePath, options: options }
   return runner.apply(null, Array.prototype.slice.call(arguments, 1))
 }
 

i18n/en.json

@@ -26,6 +26,12 @@
     },
     "Higher Order Functions": {
       "call_log": "Called function %d times."
+    },
+    "Function Spies": {
+      "call_times": "Method called %d times.",
+      "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"
     }
   }
 }