L10n fr for first 6 exercises

tdd · tdd · commit 4201fc43195c · 2015-03-22T19:04:48.000+01:00
(Hello world, HOF, map, filter, every/some, reduce)
diff --git a/exercises/basic_every_some/exercise.js b/exercises/basic_every_some/exercise.js
@@ -26,7 +26,7 @@ var lists = random.arrayOf(20, function() {
   })
 })
 
-module.exports = runner.custom(function(fx, good, lists) {
+var exercise = module.exports = runner.custom(function(fx, good, lists) {
   var test = fx(good)
 
   var goodLists = 0
@@ -35,5 +35,5 @@ module.exports = runner.custom(function(fx, good, lists) {
     test(list) && ++goodLists
   })
 
-  return 'found ' + goodLists + ' good lists!'
+  return exercise.__('found_good_lists', goodLists)
 }).hideInput(good, lists)
diff --git a/exercises/basic_every_some/problem.fr.md b/exercises/basic_every_some/problem.fr.md
@@ -0,0 +1,59 @@
+# Défi
+
+Écrivez une fonction qui reçoit une liste d’utilisateurs valides, et renvoie une fonction qui, elle, retournera `true` si tous les utilisateurs qu’on lui passe sont dans la liste originellement fournie.
+
+Vous n’aurez qu’à examiner la correspondance des propriétés `id`.
+
+## Exemple
+
+```js
+var goodUsers = [
+  { id: 1 },
+  { id: 2 },
+  { id: 3 }
+]
+
+// `checkUsersValid` est la fonction que vous allez écrire
+var testAllValid = checkUsersValid(goodUsers)
+
+testAllValid([
+  { id: 2 },
+  { id: 1 }
+])
+// => true
+
+testAllValid([
+  { id: 2 },
+  { id: 4 },
+  { id: 1 }
+])
+// => false
+```
+
+## Arguments
+
+* `goodUsers` : une liste d’utilisateurs valides
+
+Utilisez `Array#some()` et `Array#every()` pour vérifier que chaque utilisateur passé à la fonction que vous aurez générée existe dans le tableau initialement transmis à la fonction exportée.
+
+## Conditions
+
+* Do not use * N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+* Ne créez aucune fonction superflue
+
+## Ressources
+
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/every
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/some
+
+## Base de travail
+
+```js
+function checkUsersValid(goodUsers) {
+  return function allUsersValid(submittedUsers) {
+    // VOTRE SOLUTION ICI
+  };
+}
+
+module.exports = checkUsersValid
+```
diff --git a/exercises/basic_every_some/problem.md b/exercises/basic_every_some/problem.md
@@ -50,7 +50,7 @@ Use array#some and Array#every to check every user passed to your returned funct
 
 ```js
 function checkUsersValid(goodUsers) {
-  return function(submittedUsers) {
+  return function allUsersValid(submittedUsers) {
     // SOLUTION GOES HERE
   };
 }
diff --git a/exercises/basic_every_some/solution/solution.js b/exercises/basic_every_some/solution/solution.js
@@ -1,5 +1,5 @@
 module.exports = function checkUsersValid(goodUsers) {
-  return function(submittedUsers) {
+  return function allUsersValid(submittedUsers) {
     return submittedUsers.every(function(submittedUser) {
       return goodUsers.some(function(goodUser) {
         return goodUser.id === submittedUser.id
diff --git a/exercises/basic_filter/problem.fr.md b/exercises/basic_filter/problem.fr.md
@@ -0,0 +1,50 @@
+# Défi
+
+Utilisez `Array#filter` pour écrire une fonction `getShortMessages()`
+
+`getShortMessages()` reçoit un tableau d’objets équipés d’une propriété `message`, et renvoie un tableau des messages qui ont *moins de 50 caractères de long*.
+
+Votre fonction doit renvoyer un tableau contenant les messages eux-mêmes, *sans leurs objets conteneurs*.
+
+## Arguments
+
+* `messages` : un tableau d’objets aléatoires ayant l’aspect suivant :
+
+```js
+{
+  message: 'Esse id amet quis eu esse aute officia ipsum.' // aléatoire
+}
+```
+
+## Conditions
+
+* N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+* Ne créez aucune fonction superflue
+
+## Conseil
+
+* Essayez d’enchaîner des méthodes de `Array` !
+
+## Exemple
+
+```
+[ 'Tempor quis esse consequat sunt ea eiusmod.',
+  'Id culpa ad proident ad nulla laborum incididunt.',
+  'Ullamco in ea et ad anim anim ullamco est.',
+  'Est ut irure irure nisi.' ]
+```
+
+## Ressources
+
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/filter
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/map
+
+## Base de travail
+
+```js
+function getShortMessages(messages) {
+  // VOTRE SOLUTION ICI
+}
+
+module.exports = getShortMessages
+```
diff --git a/exercises/basic_filter/problem.md b/exercises/basic_filter/problem.md
@@ -3,6 +3,8 @@ Use Array#filter to write a function called `getShortMessages`.
 
 `getShortMessages` takes an array of objects with '.message' properties and returns an array of messages that are *less than < 50 characters long*.
 
+The function should return an array containing the messages themselves, *without their containing object*.
+
 ## Arguments
 
 * messages: an Array of 10 to 100 random objects that look something like this:
@@ -24,9 +26,6 @@ Use Array#filter to write a function called `getShortMessages`.
 
 ## Example
 
-The function should return an array containing the messages themselves, *without their containing object*.
-
-e.g.
 ```
 [ 'Tempor quis esse consequat sunt ea eiusmod.',
   'Id culpa ad proident ad nulla laborum incididunt.',
diff --git a/exercises/basic_map/problem.fr.md b/exercises/basic_map/problem.fr.md
@@ -0,0 +1,39 @@
+# Défi
+
+Convertissez le code suivant pour utiliser `Array#map` plutôt qu’une boucle :
+
+```js
+function doubleAll(numbers) {
+  var result = []
+  for (var i = 0; i < numbers.length; i++) {
+    result.push(numbers[i] * 2)
+  }
+  return result
+}
+
+module.exports = doubleAll
+```
+
+## Arguments
+
+* `numbers` : Un tableau d’entiers
+
+## Conditions
+
+* Votre solution doit utiliser `Array.prototype.map`
+* N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+* Ne créez aucune fonction superflue
+
+## Ressources
+
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/map
+
+## Base de travail
+
+```js
+function doubleAll(numbers) {
+  // VOTRE SOLUTION ICI
+}
+
+module.exports = doubleAll
+```
diff --git a/exercises/basic_reduce/problem.fr.md b/exercises/basic_reduce/problem.fr.md
@@ -0,0 +1,42 @@
+# Défi
+
+En partant d’un tableau de `String`s, utilisez `Array#reduce()` pour créer un objet qui contient, pour chaque `String` du tableau, le nombre de fois qu’elle y apparaît.  Renvoyez l’objet directement (inutile de faire un `console.log()`).
+
+## Exemple
+
+```js
+var inputWords = ['Apple', 'Banana', 'Apple', 'Durian', 'Durian', 'Durian']
+
+console.log(countWords(inputWords))
+
+// =>
+// {
+//   Apple: 2,
+//   Banana: 1,
+//   Durian: 3
+// }
+```
+
+## Arguments
+
+* `inputWords` : un tableau de `String`s aléatoires.
+
+## Conditions
+
+* N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+* Ne créez aucune fonction superflue
+
+## Ressources
+
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/reduce
+* https://en.wikipedia.org/wiki/Reduce_(higher-order_function)
+
+## Base de travail
+
+```js
+function countWords(inputWords) {
+  // VOTRE SOLUTION ICI
+}
+
+module.exports = countWords
+```
diff --git a/exercises/basic_reduce/solution_fr/solution.js b/exercises/basic_reduce/solution_fr/solution.js
@@ -0,0 +1,8 @@
+function countWords(arr) {
+  return arr.reduce(function(countMap, word) {
+    countMap[word] = ++countMap[word] || 1 // incrémenter ou initialiser à 1
+    return countMap
+  }, {}) // le 2e argument de reduce initialise `countMap` à `{}`
+}
+
+module.exports = countWords
diff --git a/exercises/hello_world/problem.fr.md b/exercises/hello_world/problem.fr.md
@@ -0,0 +1,17 @@
+## Défi
+
+Écrivez une fonction qui prend une `String` en entrée et la renvoie en majuscules.
+
+## Arguments
+
+* `input` : une `String` contenant un texte aléatoire (type lorem ipsum).
+
+## Base de travail
+
+```js
+function upperCaser(input) {
+  // VOTRE SOLUTION ICI
+}
+
+module.exports = upperCaser
+```
diff --git a/exercises/higher_order_functions/exercise.js b/exercises/higher_order_functions/exercise.js
@@ -5,9 +5,9 @@ var runner = require('../runner')
 
 var counter
 
-module.exports = runner.init(function() {
+var exercise = module.exports = runner.init(function() {
   console.log("------------------------")
   counter = 0
 }).quiet(function count() {
-  console.log("Called function %d times.", ++counter)
+  console.log(exercise.__('call_log', ++counter))
 }, random.int(3, 10))
diff --git a/exercises/higher_order_functions/problem.fr.md b/exercises/higher_order_functions/problem.fr.md
@@ -0,0 +1,48 @@
+Une fonction d’ordre supérieur est une fonction qui fait au moins l’une des deux choses suivantes :
+
+* Prendre une ou plusieurs fonctions comme arguments
+* Renvoyer une fonction
+
+Toutes les autres fonctions sont des fonctions de premier ordre.
+
+Contrairement à de nombreux langages impératifs, JavaScript vous permet d’utiliser des fonctions d’ordre supérieur parce qu’il traite ses fonctions comme des valeurs, au même titre que n’importe quelle autre valeur en JavaScript, telles que les `String`s ou `Number`s.  Les valeurs de type `Function` peuvent être stockées dans des variables, dans des propriétés d’objets, ou être passées comme arguments à d’autres fonctions.
+
+Les valeurs de type `Function` sont en réalité des objets (qui héritent de `Function.prototype`), de sorte que vous pouvez même leur ajouter des propriétés et y stocker des valeurs, comme pour n’importe quel autre objet.
+
+La différence principale entre les `Function`s et les autres types de valeurs en JavaScript est leur syntaxe d’appel : si une référence à une fonction est suivie par des parenthèses (avec des valeurs optionnelles séparées par des virgules) : `someFunction(arg1, arg2, etc)`, alors le corps de la fonction est exécuté avec les arguments éventuellement passés.
+
+Dans cet exercice, nous allons prouver que les fonctions peuvent être passées comme des valeurs, en passant une fonction comme argument à celle que vous allez écrire.
+
+## Défi
+
+Écrivez une fonction qui en prend une autre comme premier argument, ainsi qu’un nombre `num` comme second argument, et exécute la fonction passée `num` fois.
+
+Utilisez le code de base fourni ci-dessous pour démarrer.  La majorité des exercices de cet atelier vous fourniront une base de travail.
+
+## Arguments
+
+* `operation` : Une `Function`, qui ne prend pas d’arguments et ne renvoie rien d’utile.
+* `num` : le nombre de fois qu’il vous faudra appeler `operation`
+
+## Ressources
+
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Fonctions
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/prototype
+
+## Conseils
+
+* La solution est vraiment simple.
+* Vous avez le droit d’utiliser une boucle ; points bonus si vous préférez la récursivité.
+* Vous verrez sans doute un affichage à l’exécution.  Il viendra de la fonction qui vous est passée.
+* Vous n’avez pas besoin de faire de `console.log(…)` vous-même.
+
+## Base de travail
+
+```js
+function repeat(operation, num) {
+  // VOTRE SOLUTION ICI
+}
+
+// Ne retirez pas la ligne ci-dessous
+module.exports = repeat
+```
diff --git a/exercises/runner.js b/exercises/runner.js
@@ -6,6 +6,7 @@ var filecheck = require('workshopper-exercise/filecheck')
 var fs = require('fs')
 var os = require('os')
 var path = require('path')
+var util = require('util')
 
 var verbose = true, showInput = true, initFx, wrapUpFx, customFx, wrapperModulePath
 
@@ -62,9 +63,9 @@ function runner() {
       if (showInput) {
         var displayInput = input.length === 1 ? input[0] :
           input.map(function(o) { return 'function' === typeof o ? o.toString() : o })
-        console.log(__('input'), displayInput)
+        console.log(__('input'), util.inspect(displayInput, { colors: true }).replace(/,\n\s*/g, ", "))
       }
-      console.log(__('submission'), submittedResult)
+      console.log(__('submission'), util.inspect(submittedResult, { colors: true }).replace(/,\n\s*/g, ", "))
     }
 
     if ('run' === mode) {
@@ -75,7 +76,7 @@ function runner() {
     var solutionFx = require(this.solution)
     var solutionResult = obtainResult(solutionFx, input)
     if (verbose) {
-      console.log(__('solution'), solutionResult)
+      console.log(__('solution'), util.inspect(solutionResult, { colors: true }).replace(/,\n\s*/g, ", "))
     }
     callback(null, deepEqual(submittedResult, solutionResult))
   })
diff --git a/i18n/en.json b/i18n/en.json
@@ -8,15 +8,21 @@
         "module_not_found": "Could not find your file. Make sure the path is correct.",
         "must_export_function": "You should always return a function using the module.exports object."
       },
-      "input": "input:      %j",
-      "submission": "submission: %j",
-      "solution": "solution:   %j"
+      "input": "input:      %s",
+      "submission": "submission: %s",
+      "solution": "solution:   %s"
     }
   },
   "exercises": {
     "Basic: Map": {
       "didnt_use_map": "You did not use Array#map",
       "used_map": "Yay!  You used Array#map"
+    },
+    "Basic: Every Some": {
+      "found_good_lists": "found %d good lists!"
+    },
+    "Higher Order Functions": {
+      "call_log": "Called function %d times."
     }
   }
 }
diff --git a/i18n/fr.json b/i18n/fr.json

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ Use array#some and Array#every to check every user passed to your returned funct`
`50`	`50`
`51`	`51`	```js
`52`	`52`	`function checkUsersValid(goodUsers) {`
`53`		`- return function(submittedUsers) {`
	`53`	`+ return function allUsersValid(submittedUsers) {`
`54`	`54`	`// SOLUTION GOES HERE`
`55`	`55`	`};`
`56`	`56`	`}`