Major refactor to module.exports over $magic vars

Also tidied some problem.txts lacking info.

Closes #9 as suggested by @brianloveswords in #7.

Author: timoxley

Diff for: input.js

@@ -1,15 +1,42 @@
-module.exports = function(input, hydrate) {
-  hydrate = hydrate || function() {}
-  return function() {
-    return {
-      args: [JSON.stringify(input), hydrate.toString()],
+var path = require('path')
+
+var serialize = function(input) {
+  if (typeof input !== 'function') return JSON.stringify(input)
+  return JSON.stringify({
+    isFunction: true,
+    body: input.toString()
+  })
+}
+
+var deserialize = function(input) {
+  var out = JSON.parse(input)
+  if (!out.isFunction) return out
+  eval('out = (' + out.body + ')')
+  return out
+}
+
+module.exports = function() {
+  var args = Array.prototype.slice.call(arguments).map(serialize)
+
+  function input() {
+    var opts = {
+      args: args,
       solutionExecWrap: __filename,
-      execWrap: __filename
+      execWrap: __filename,
     }
+    return opts
   }
+  input.wrap = function(fn) {
+    args.push(serialize(fn))
+    return input
+  }
+  return input
+
 }
 
 module.exports.init = function() {
-  global.$input = JSON.parse(process.argv[4])
-  eval('(' +process.argv[5] + ')()') // whatever.
+  var mod = require(path.resolve(process.cwd(), process.argv[3]))
+  var args =  process.argv.slice(4).map(deserialize)
+  var wrap = args.pop()
+  wrap(args, mod)
 }

Diff for: problems/basic_filter/problem.txt

@@ -3,8 +3,9 @@ Use Array#filter to write a function called `getShortMessages`.
 `getShortMessages` takes an array of objects with '.message' properties
 and prints any messages that are *less than < 50 characters long*.
 
+Arguments:
 
-$input will be an Array of 10 to 100 random objects that look something like this:
+* messages: an Array of 10 to 100 random objects that look something like this:
 
 ```js
 
@@ -14,8 +15,15 @@ $input will be an Array of 10 to 100 random objects that look something like thi
 
 ```
 
-The console output should be of an array containing the messages themselves
-(i.e. messages *not in their containing object*).
+Conditions:
+
+* Do not use for loops or Array#forEach.
+
+Hint: Try chaining some Array methods!
+
+Expected Output:
+
+The output should be an array containing the messages themselves, without their containing object.
 
 e.g.
 
@@ -28,10 +36,6 @@ e.g.
 
 ```
 
-Do not use for loops or Array#forEach.
-
-Hint: try chaining some array methods!
-
 Resources:
 
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
@@ -43,12 +47,8 @@ Resources:
 
 ```js
 
-function getShortMessages(arr) {
+module.exports = function getShortMessages(messages) {
   // SOLUTION GOES HERE
 }
 
-// do not edit below this line
-
-console.log(getShortMessages($input))
-
 ```

Diff for: problems/basic_filter/setup.js

@@ -1,13 +1,14 @@
 var input = require('../../input')
 
-function randomInts(min, max) {
-  return Math.floor(Math.random() * max + min - 1)
+function randomInt(min, max) {
+  return Math.floor((Math.random() * max - min) + min)
 }
 
-module.exports = input(new Array(randomInts(10, 100))
+module.exports = input(new Array(randomInt(10, 100))
 .join(',').split(',')
 .map(function() {
-  return {
-    message: require('lorem-ipsum')()
-  }
-}))
+  return { message: require('lorem-ipsum')() }
+})).wrap(function(input, getShortMessages) {
+  var messages = input[0]
+  console.log(getShortMessages(messages))
+})

Diff for: problems/basic_filter/solution.js

@@ -1,11 +1,7 @@
-function getShortMessages(arr) {
-  return arr.filter(function(item) {
+module.exports = function getShortMessages(messages) {
+  return messages.filter(function(item) {
     return item.message.length < 50
   }).map(function(item) {
     return item.message
   })
 }
-
-// do not edit below this line
-
-console.log(getShortMessages($input))

Diff for: problems/basic_map/problem.txt

@@ -1,16 +1,43 @@
-Convert the following code from a for-loop to Array#map.
+Convert the following code from a for-loop to Array#map:
 
-The variable $input will be injected into your program.
-$input will be an Array of 1 to 20 Integers between 0 and 9
-Make sure to console.log your result.
+```js
+
+function doubleAll(numbers) {
+  var result = []
+  for (var i = 0; i < input.length; i++) {
+    result.push(input[i] * 2)
+  }
+  return result
+}
+
+module.exports = doubleAll
+
+```
+
+Arguments:
+
+* numbers: An Array of 1 to 20 Integers between 0 and 9
+
+Conditions:
+
+* Do not use any for/while loops.
+* You do not need to define any additional functions
+ unless a stub is provided in the boilerplate.
+
+Resources:
+
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
+
+#################
+## Boilerplate ##
+#################
 
 ```js
 
-var result = []
-for (var i = 0; i < $input.length; i++) {
-  result.push($input[i] * 2)
+function doubleAll(numbers) {
+  // SOLUTION GOES HERE
 }
 
-console.log(result)
+module.exports = doubleAll
 
 ```

Diff for: problems/basic_map/setup.js

@@ -2,22 +2,27 @@
 
 var input = require('../../input')
 
-function randomInts(min, max) {
-  return Math.floor(Math.random() * max + min - 1)
+function randomInt(min, max) {
+  return Math.floor((Math.random() * max - min) + min)
 }
 
-module.exports = input(new Array(randomInts(0, 19))
+module.exports = input(new Array(randomInt(0, 19))
 .join(',')
 .split(',')
 .map(function() {
-  return randomInts(0, 9)
-}), function() {
+  return randomInt(0, 9)
+})).wrap(function(input, doubleAll) {
+  var numbers = input[0]
   var map = Array.prototype.map
   var usedMap = false
   Array.prototype.map = function() {
     usedMap = true
     return map.apply(this, arguments)
   }
+
+  console.log('input:', numbers)
+  console.log('output:', doubleAll(numbers))
+
   setTimeout(function() {
     if (!usedMap) {
       console.log('You didn\'t use Array#map!!??')

Diff for: problems/basic_map/solution.js

@@ -1,7 +1,5 @@
-function doubleAll(arr) {
-  return arr.map(function double(num) {
+module.exports = function doubleAll(numbers) {
+  return numbers.map(function double(num) {
     return num * 2
   })
 }
-
-console.log(doubleAll($input))

Diff for: problems/basic_reduce/problem.txt

@@ -1,15 +1,18 @@
 Array#reduce
 
 Task: Given an Array of strings, use Array#reduce to create an object that
-contains the number of times each string occured in the array.
+contains the number of times each string occured in the array. Return the
+object directly (no need to console.log).
 
-Example:
+#############
+## Example ##
+#############
 
 ```js
 
-var $input = ['Apple', 'Banana', 'Apple', 'Durian', 'Durian', 'Durian']
+var inputWords = ['Apple', 'Banana', 'Apple', 'Durian', 'Durian', 'Durian']
 
-console.log(countStrings($input))
+console.log(countWords(inputWords))
 
 // =>
 // {
@@ -20,9 +23,9 @@ console.log(countStrings($input))
 
 ```
 
-Injected Variables:
+Arguments:
 
-* $input will be a Array of random Strings.
+* inputWords: An array of random Strings.
 
 Conditions:
 
@@ -41,12 +44,13 @@ Resources:
 
 ```js
 
-function countStrings(arr) {
-  // SOLUTION GOES HERE
+function countWords(inputWords) {
+  return inputWords.reduce(function(prev, curr) {
+    prev[curr] = ++prev[curr] || 1
+    return prev
+  }, {})
 }
 
-// do not edit below this line
-
-console.log(countStrings($input))
+module.exports = countWords
 
 ```

Diff for: problems/basic_reduce/setup.js

@@ -7,4 +7,6 @@ module.exports = input(lorem({count: 1, units:'paragraphs'})
                        .replace(/([^\w ])/g, '')// remove non-words and spaces
                        .toLowerCase() // lowercase I guess
                        .split(' ') // create array of words
-                      )
+                      ).wrap(function(input, countStrings) {
+                        console.log(countStrings(input[0]))
+                      })

Diff for: problems/basic_reduce/solution.js

@@ -1,10 +1,8 @@
-function countStrings(arr) {
+function countWords(arr) {
   return arr.reduce(function(prev, curr) {
     prev[curr] = ++prev[curr] || 1
     return prev
   }, {})
 }
 
-// do not edit below this line
-
-console.log(countStrings($input))
+module.exports = countWords

Diff for: problems/function_spies/problem.txt

@@ -1,10 +1,11 @@
-Overide a method with new functionality while still maintaining all of the old
+Overide a specified method of an object with new functionality while still maintaining all of the old
 behaviour.
 
 Create a spy that keeps track of how many times a function is is called.
 
-e.g.
-
+#############
+## Example ##
+#############
 
 ```js
 var spy = Spy(console, 'error')
@@ -16,15 +17,28 @@ console.error('calling console.error')
 console.log(spy.count) // 3
 
 ```
-Use this boilerplate:
 
-```
-function Spy(object, methodName) {
+Arguments:
+
+* target: an object containing the method `method`
+* method: a string the name of the method on `target`.
+
+Conditions:
+
+* Do not use any for/while loops.
+* You do not need to define any additional functions
+ unless a stub is provided in the boilerplate.
+
+#################
+## Boilerplate ##
+#################
+
+```js
+
+function Spy(target, method) {
   // SOLUTION GOES HERE
 }
 
-// do not edit below this line
-
-$test(Spy)
+module.exports = Spy
 
 ```