Name: js-handler/node_modules/nodeunit/node_modules/tap/node_modules/runforcover/index.js 
1:
var bunker = require('bunker'),
2:
    Module = require('module').Module,
3:
    path = require('path'),
4:
    fs = require('fs'),
5:
    vm = require('vm');
6:
 
7:
function CoverageData (filename, bunker) {
8:
  this.bunker = bunker;
9:
  this.filename = filename;
10:
  this.nodes = {};
11:
};
12:
 
13:
CoverageData.prototype.visit = function(node) {
14:
  ++(this.nodes[node.id] = this.nodes[node.id] || {node:node, count:0}).count;
15:
};
16:
 
17:
CoverageData.prototype.missing = function() {
18:
  var nodes = this.nodes,
19:
      missing = this.bunker.nodes.filter(function(node) {
20:
        return !nodes[node.id];
21:
      });
22:
 
23:
  return missing;
24:
};
25:
 
26:
CoverageData.prototype.stats = function() {
27:
  var missing = this.missing(),
28:
      filedata = fs.readFileSync(this.filename, 'utf8').split('\n');
29:
 
30:
  var seenLines = [],
31:
      lines =
32:
      missing.sort(function(lhs, rhs) {
33:
        return lhs.node[0].start.line < rhs.node[0].start.line ? -1 :
34:
               lhs.node[0].start.line > rhs.node[0].start.line ? 1  :
35:
               0;
36:
      }).filter(function(node) {
37:
 
38:
        var okay = (seenLines.indexOf(node.node[0].start.line) < 0);
39:
        if(okay)
40:
          seenLines.push(node.node[0].start.line);
41:
        return okay;
42:
 
43:
      }).map(function(node, idx, all) {
44:
        return {
45:
          lineno:node.node[0].start.line + 1,
46:
          source:function() { return filedata[node.node[0].start.line]; }
47:
        };
48:
      });
49:
 
50:
  return {
51:
    percentage:(filedata.length-seenLines.length)/filedata.length,
52:
    lines:lines,
53:
    missing:seenLines.length,
54:
    seen:(filedata.length-seenLines.length)
55:
  };
56:
};
57:
 
58:
module.exports.createEnvironment = function(module, filename) {
59:
    var req = function(path) {
60:
      return Module._load(path, module);
61:
    };
62:
    req.resolve = function(request) {
63:
      return Module._resolveFilename(request, module)[1];
64:
    }
65:
    req.paths = Module._paths;
66:
    req.main = process.mainModule;
67:
    req.extensions = Module._extensions;
68:
    req.registerExtension = function() {
69:
      throw new Error('require.registerExtension() removed. Use ' +
70:
                      'require.extensions instead.');
71:
    }
72:
    require.cache = Module._cache;
73:
 
74:
    var ctxt = {};
75:
    for(var k in global)
76:
      ctxt[k] = global[k];
77:
 
78:
    ctxt.require = req;
79:
    ctxt.exports = module.exports;
80:
    ctxt.__filename = filename;
81:
    ctxt.__dirname = path.dirname(filename);
82:
    ctxt.process = process;
83:
    ctxt.console = console;
84:
    ctxt.module = module;
85:
    ctxt.global = ctxt;
86:
 
87:
    return ctxt;
88:
};
89:
 
90:
module.exports.cover = function(fileRegex) {
91:
  var originalRequire = require.extensions['.js'],
92:
      coverageData = {},
93:
      match = fileRegex instanceof RegExp ?
94:
        fileRegex : new RegExp(
95:
            fileRegex ? fileRegex.replace(/\//g, '\\/').replace(/\./g, '\\.') : '.*'
96:
        , 'g'),
97:
      target = this;
98:
 
99:
  require.extensions['.js'] = function(module, filename) {
100:
    if(!match.test(filename)) return originalRequire(module, filename);
101:
 
102:
    var context = target.createEnvironment(module, filename),
103:
        data = fs.readFileSync(filename, 'utf8'),
104:
        bunkerized = bunker(data),
105:
        coverage = coverageData[filename] = new CoverageData(filename, bunkerized);
106:
 
107:
    bunkerized.on('node', coverage.visit.bind(coverage));
108:
    bunkerized.assign(context);
109:
 
110:
    var wrapper = '(function(ctxt) { with(ctxt) { return '+Module.wrap(bunkerized.compile())+'; } })',
111:
        compiledWrapper = vm.runInThisContext(wrapper, filename, true)(context);
112:
 
113:
    var args = [context.exports, context.require, module, filename, context.__dirname];
114:
    return compiledWrapper.apply(module.exports, args);
115:
  };
116:
 
117:
  var retval = function(ready) {
118:
    ready(coverageData);
119:
  };
120:
 
121:
  retval.release = function() {
122:
    require.extensions['.js'] = originalRequire;
123:
  };
124:
 
125:
  return retval;
126:
};