dot.dot.dot.exampol

node_modules/runforcover/README.markdown

@@ -0,0 +1,56 @@
+runforcover
+======
+
+Runforcover is a require-hook library that uses node-bunker to provide code coverage data
+for your unit test library, whatever it might be.
+
+methods
+=======
+var runforcover = require('runforcover');
+
+var coverage = runforcover.cover([RegExp | path]);
+-------
+
+Attach runforcover to the global `require` object and patch `require.extensions['.js']` to
+provide coverage metadata for all files required after this point. Returns a function
+object that can be called to obtain a object keying files to `CoverageData` objects, with 
+a method for releasing control back to vanilla `require`. Usage:
+
+````javascript
+
+var coverage = runforcover.cover(/.*/g);
+
+require('some/library');
+
+coverage(function(coverageData) {
+    // coverageData is an object keyed by filename.
+    var stats = coverageData['/full/path/to/file.js'].stats()
+
+    // the percentage of lines run versus total lines in file
+    console.log(stats.percentage);
+
+    // the number of missing lines
+    console.log(stats.missing);
+
+    // the number of lines run (seen)
+    console.log(stats.seen);
+
+    // an array of line objects representing 'missed' lines
+    stats.lines;
+
+    stats.lines.forEach(function(line) {
+        // the line number of the line:
+        console.log(line.number);
+
+        // returns a string containing the source data for the line:
+        console.log(line.source());   
+    }); 
+   
+    // return control back to the original require function
+    coverage.release(); 
+});
+````
+
+license
+=======
+new BSD.

node_modules/runforcover/index.js

@@ -0,0 +1,127 @@
+var bunker = require('bunker'),
+    Module = require('module').Module,
+    path = require('path'),
+    fs = require('fs'),
+    vm = require('vm');
+
+function CoverageData (filename, bunker) {
+  this.bunker = bunker;
+  this.filename = filename;
+  this.nodes = {};
+};
+
+CoverageData.prototype.visit = function(node) {
+  ++(this.nodes[node.id] = this.nodes[node.id] || {node:node, count:0}).count;
+};
+
+CoverageData.prototype.missing = function() {
+  var nodes = this.nodes,
+      missing = this.bunker.nodes.filter(function(node) {
+        return !nodes[node.id];
+      });
+
+  return missing;
+};
+
+CoverageData.prototype.stats = function() {
+  var missing = this.missing(),
+      filedata = fs.readFileSync(this.filename, 'utf8').split('\n');
+
+  var seenLines = [],
+      lines = 
+      missing.sort(function(lhs, rhs) {
+        return lhs.node[0].start.line < rhs.node[0].start.line ? -1 :
+               lhs.node[0].start.line > rhs.node[0].start.line ? 1  :
+               0;
+      }).filter(function(node) {
+
+        var okay = (seenLines.indexOf(node.node[0].start.line) < 0);
+        if(okay)
+          seenLines.push(node.node[0].start.line);
+        return okay;
+
+      }).map(function(node, idx, all) {
+        return {
+          lineno:node.node[0].start.line + 1,
+          source:function() { return filedata[node.node[0].start.line]; }
+        };
+      });
+
+  return {
+    percentage:(filedata.length-seenLines.length)/filedata.length,
+    lines:lines,
+    missing:seenLines.length,
+    seen:(filedata.length-seenLines.length)
+  };
+};
+
+module.exports.createEnvironment = function(module, filename) {
+    var req = function(path) {
+      return Module._load(path, module);
+    };
+    req.resolve = function(request) {
+      return Module._resolveFilename(request, module)[1];
+    }
+    req.paths = Module._paths;
+    req.main = process.mainModule;
+    req.extensions = Module._extensions;
+    req.registerExtension = function() {
+      throw new Error('require.registerExtension() removed. Use ' +
+                      'require.extensions instead.');
+    }
+    require.cache = Module._cache;
+
+    var ctxt = {};
+    for(var k in global)
+      ctxt[k] = global[k];
+
+    ctxt.require = req;
+    ctxt.exports = module.exports;
+    ctxt.__filename = filename;
+    ctxt.__dirname = path.dirname(filename);
+    ctxt.process = process;
+    ctxt.console = console;
+    ctxt.module = module;
+    ctxt.global = ctxt;
+
+    return ctxt;
+};
+
+module.exports.cover = function(fileRegex) {
+  var originalRequire = require.extensions['.js'],
+      coverageData = {},
+      match = fileRegex instanceof RegExp ?
+        fileRegex : new RegExp(
+            fileRegex ? fileRegex.replace(/\//g, '\\/').replace(/\./g, '\\.') : '.*'
+        , 'g'),
+      target = this;
+
+  require.extensions['.js'] = function(module, filename) {
+    if(!match.test(filename)) return originalRequire(module, filename);
+
+    var context = target.createEnvironment(module, filename),
+        data = fs.readFileSync(filename, 'utf8'),
+        bunkerized = bunker(data),
+        coverage = coverageData[filename] = new CoverageData(filename, bunkerized);
+
+    bunkerized.on('node', coverage.visit.bind(coverage));
+    bunkerized.assign(context);
+
+    var wrapper = '(function(ctxt) { with(ctxt) { return '+Module.wrap(bunkerized.compile())+'; } })',
+        compiledWrapper = vm.runInThisContext(wrapper, filename, true)(context);
+
+    var args = [context.exports, context.require, module, filename, context.__dirname];
+    return compiledWrapper.apply(module.exports, args);
+  };
+
+  var retval = function(ready) {
+    ready(coverageData);
+  };
+
+  retval.release = function() {
+    require.extensions['.js'] = originalRequire;
+  };
+
+  return retval;
+};
+

node_modules/runforcover/package.json

@@ -0,0 +1,32 @@
+{
+    "name" : "runforcover",
+    "version" : "0.0.2",
+    "description" : "require plugin for js code coverage using bunker",
+    "main" : "index.js",
+    "directories" : {
+        "lib" : ".",
+        "test" : "test"
+    },
+    "dependencies" : {
+        "bunker" : "0.1.X"
+    },
+    "scripts" : {
+        "test" : "node test/index.js"
+    },
+    "repository" : {
+        "type" : "git",
+        "url" : "http://github.com/chrisdickinson/node-runforcover.git"
+    },
+    "keywords" : [
+        "code",
+        "coverage",
+        "bunker"
+    ],
+    "author" : {
+        "name" : "Chris Dickinson",
+        "email" : "chris@neversaw.us",
+        "url" : "http://neversaw.us"
+    },
+    "license" : "new BSD",
+    "engine" : { "node" : ">=0.4" }
+}

node_modules/runforcover/test/index.js

@@ -0,0 +1 @@
+require('./interface').coverageInterface()

node_modules/runforcover/test/interface.js

@@ -0,0 +1,50 @@
+var assert = require('assert');
+var runforcover = require('../');
+
+exports.coverageInterface = function() {
+  assert.ok(runforcover.cover);
+
+  var originalRequire = require.extensions['.js'];
+
+  var coverage = runforcover.cover();
+
+  assert.notEqual(originalRequire, require.extensions['.js']);
+
+  var file = require('./src/coverage');
+
+  coverage(function(coverageData) {
+    assert.equal(Object.keys(coverageData).length, 1);
+    assert.equal(Object.keys(coverageData)[0], __dirname + '/src/coverage.js');
+
+    var fileCoverageData = coverageData[Object.keys(coverageData)[0]]; 
+
+    assert.ok(fileCoverageData.stats);
+    assert.ok(fileCoverageData.missing);
+
+    var stats = fileCoverageData.stats();
+
+    assert.ok(stats.percentage !== undefined);
+    assert.ok(stats.lines !== undefined);
+    assert.ok(stats.missing !== undefined);
+    assert.ok(stats.seen !== undefined);
+
+    assert.equal(stats.lines.length, 3);
+    assert.equal(stats.lines[0].source(), '  if(a > 0) {');
+    assert.equal(stats.lines[1].source(), '    return a + 1;');
+    assert.equal(stats.lines[2].source(), '    return a - 1;');
+
+    file.something(1);
+    stats = fileCoverageData.stats();
+
+    assert.equal(stats.lines.length, 1);
+    assert.equal(stats.lines[0].source(), '    return a - 1;');
+
+    file.something(-1);
+    stats = fileCoverageData.stats();
+
+    assert.equal(stats.lines.length, 0);
+
+    coverage.release();
+    assert.equal(require.extensions['.js'], originalRequire); 
+  });
+};

node_modules/runforcover/test/src/coverage.js

@@ -0,0 +1,7 @@
+exports.something = function(a) {
+  if(a > 0) {
+    return a + 1;
+  } else {
+    return a - 1;
+  }
+};