add vm.runInThisContext hook and automatically call it on run-with-cover for RequireJS support

lib/command/common/run-with-cover.js

@@ -124,6 +124,8 @@ function run(args, commandName, enableHooks, callback) {
                 if (opts['self-test']) {
                     hook.unloadRequireCache(matchFn);
                 }
+                // runInThisContext is used by RequireJS [issue #23]
+                hook.hookRunInThisContext(matchFn, transformer, hookOpts);
                 hook.hookRequire(matchFn, transformer, hookOpts);
                 process.once('exit', function () {
                     var file = path.resolve(reportingDir, 'coverage.json'),

lib/hook.js

@@ -34,7 +34,8 @@ var fs = require('fs'),
     Module = require('module'),
     vm = require('vm'),
     originalLoader = Module._extensions['.js'],
-    originalCreateScript = vm.createScript;
+    originalCreateScript = vm.createScript,
+    originalRunInThisContext = vm.runInThisContext;
 
 function transformFn(matcher, transformer, verbose) {
 
@@ -139,11 +140,44 @@ function unhookCreateScript() {
     vm.createScript = originalCreateScript;
 }
 
+
+/**
+ * hooks `vm.runInThisContext` to return transformed code.
+ * @method hookRunInThisContext
+ * @static
+ * @param matcher {Function(filePath)} a function that is called with the filename passed to `vm.createScript`
+ *  Should return a truthy value when transformations need to be applied to the code, a falsy value otherwise
+ * @param transformer {Function(code, filePath)} a function called with the original code and the filename passed to
+ *  `vm.createScript`. Should return the transformed code.
+ * @param options {Object} options Optional.
+ * @param {Boolean} [options.verbose] write a line to standard error every time the transformer is called
+ */
+function hookRunInThisContext(matcher, transformer, opts) {
+    opts = opts || {};
+    var fn = transformFn(matcher, transformer, opts.verbose);
+    vm.runInThisContext = function (code, file) {
+        var ret = fn(code, file);
+        return originalRunInThisContext(ret.code, file);
+    };
+}
+
+/**
+ * unhooks vm.runInThisContext, restoring it to its original state.
+ * @method unhookRunInThisContext
+ * @static
+ */
+function unhookRunInThisContext() {
+    vm.runInThisContext = originalRunInThisContext;
+}
+
+
 module.exports = {
     hookRequire: hookRequire,
     unhookRequire: unhookRequire,
     hookCreateScript: hookCreateScript,
     unhookCreateScript: unhookCreateScript,
+    hookRunInThisContext : hookRunInThisContext,
+    unhookRunInThisContext : unhookRunInThisContext,
     unloadRequireCache: unloadRequireCache
 };
 

package.json

@@ -36,7 +36,8 @@
         "rimraf": "*",
         "nodeunit": "*",
         "jshint": "*",
-        "yui-lint": "*"
+        "yui-lint": "*",
+        "requirejs": "2.x"
     },
     "TODO": [
         "Need a legend for the HTML report + some explanation on how branch coverage is shown",

test/cli/sample-project/amd/ipsum.js

@@ -0,0 +1,11 @@
+define(function(){
+
+    function sum(a, b) {
+        return a + b;
+    }
+
+    return {
+        sum : sum
+    };
+
+});

test/cli/sample-project/amd/lorem.js

@@ -0,0 +1,7 @@
+define(['./ipsum'], function (ipsum) {
+
+    return function exec(a, b, c){
+        return ipsum.sum(a, b) * c;
+    };
+
+});

test/cli/sample-project/test/amd-run.js

@@ -0,0 +1,16 @@
+// RequireJS uses `vm.runInThisContext` see issue #23
+// make sure we add hooks for it as well
+
+var rjs = require('requirejs'),
+    assert = require('assert');
+
+rjs.config({
+    baseUrl : __dirname,
+    nodeRequire : require
+});
+
+rjs(['../amd/lorem'], function(lorem){
+    var result = lorem(1, 2, 3);
+    assert.equal(9, result);
+});
+

test/cli/test-cover-command.js

@@ -109,5 +109,21 @@ module.exports = {
             test.ok(results.grepError(/Unable to resolve file/));
             test.done();
         });
+    },
+    "should work with RequireJS and AMD modules": function (test) {
+        helper.setOpts({ lazyHook : true });
+        run([ 'test/amd-run.js', '-v' ], function (results) {
+            test.ok(results.succeeded());
+            test.ok(results.grepError(/Module load hook:/));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'lcov.info')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'lcov-report')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'coverage.json')));
+            var coverage = JSON.parse(fs.readFileSync(path.resolve(OUTPUT_DIR, 'coverage.json'), 'utf8')),
+                filtered;
+            filtered = Object.keys(coverage).filter(function (k) { return k.match(/amd\/lorem/) || k.match(/amd\/ipsum/); });
+            test.ok(filtered.length === 2);
+            test.ok(filtered.length === Object.keys(coverage).length);
+            test.done();
+        });
     }
-};
+};