dot.dot.dot.exampol

node_modules/bunker/.npmignore

@@ -0,0 +1 @@
+node_modules

node_modules/bunker/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.4
+  - 0.6

node_modules/bunker/README.markdown

@@ -0,0 +1,82 @@
+bunker
+======
+
+Bunker is a module to calculate code coverage using native javascript
+[burrito](https://github.com/substack/node-burrito) AST trickery.
+
+[![build status](https://secure.travis-ci.org/substack/node-bunker.png)](http://travis-ci.org/substack/node-bunker)
+
+![code coverage](http://substack.net/images/code_coverage.png)
+
+examples
+========
+
+tiny
+----
+
+````javascript
+var bunker = require('bunker');
+var b = bunker('var x = 0; for (var i = 0; i < 30; i++) { x++ }');
+
+var counts = {};
+
+b.on('node', function (node) {
+    if (!counts[node.id]) {
+        counts[node.id] = { times : 0, node : node };
+    }
+    counts[node.id].times ++;
+});
+
+b.run();
+
+Object.keys(counts).forEach(function (key) {
+    var count = counts[key];
+    console.log(count.times + ' : ' + count.node.source());
+});
+````
+
+output:
+
+    $ node example/tiny.js 
+    1 : var x=0;
+    31 : i<30
+    30 : i++
+    30 : x++;
+    30 : x++
+
+methods
+=======
+
+var bunker = require('bunker');
+
+var b = bunker(src)
+-------------------
+
+Create a new bunker code coverageifier with some source `src`.
+
+The bunker object `b` is an `EventEmitter` that emits `'node'` events with two
+parameters:
+
+* `node` - the [burrito](https://github.com/substack/node-burrito) node object
+* `stack` - the stack, [stackedy](https://github.com/substack/node-stackedy) style
+
+b.include(src)
+--------------
+
+Include some source into the bunker.
+
+b.compile()
+-----------
+
+Return the source wrapped with burrito.
+
+b.assign(context={})
+--------------------
+
+Assign the statement-tracking functions into `context`.
+
+b.run(context={})
+-----------------
+
+Run the source using `vm.runInNewContext()` with some `context`.
+The statement-tracking functions will be added to `context` by `assign()`.

node_modules/bunker/example/prof.js

@@ -0,0 +1,51 @@
+var bunker = require('bunker');
+var b = bunker('(' + function () {
+    function beep () {
+        var x = 0;
+        for (var i = 0; i < 1000; i++) {
+            for (var j = 0; j < 100; j++) {
+                x += j;
+            }
+        }
+        return x;
+    }
+    
+    beep();
+    
+} + ')()');
+
+var counts = {};
+
+b.on('node', function (node) {
+    if (!counts[node.id]) {
+        counts[node.id] = { times : 0, node : node, elapsed : 0 };
+    }
+    counts[node.id].times ++;
+    
+    var now = Date.now();
+    
+    if (last.id !== undefined) {
+        counts[last.id].elapsed += last.
+    }
+    
+    if (node.name === 'call') {
+        var start = now;
+        
+        last.id = node.id;
+        counts[node.id].elapsed += Date.now() - start;
+    }
+    else {
+        counts[node.id].elapsed += now - last;
+        last = now;
+    }
+});
+
+b.run();
+
+Object.keys(counts).forEach(function (key) {
+    var count = counts[key];
+    console.log(
+        [ count.times, count.node.source(), count.elapsed ]
+            .join(' : ')
+    );
+});

node_modules/bunker/example/tiny.js

@@ -0,0 +1,18 @@
+var bunker = require('bunker');
+var b = bunker('var x = 0; for (var i = 0; i < 30; i++) { x++ }');
+
+var counts = {};
+
+b.on('node', function (node) {
+    if (!counts[node.id]) {
+        counts[node.id] = { times : 0, node : node };
+    }
+    counts[node.id].times ++;
+});
+
+b.run();
+
+Object.keys(counts).forEach(function (key) {
+    var count = counts[key];
+    console.log(count.times + ' : ' + count.node.source());
+});

node_modules/bunker/example/top/run.js

@@ -0,0 +1,31 @@
+var bunker = require('bunker');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/src.js', 'utf8');
+
+var counts = {};
+
+var b = bunker(src);
+b.on('node', function (node) {
+    if (!counts[node.id]) {
+        counts[node.id] = { times : 0, node : node };
+    }
+    counts[node.id].times ++;
+});
+
+b.run({
+    setInterval : setInterval,
+    clearInterval : clearInterval,
+    end : function () {
+        Object.keys(counts)
+            .sort(function (a, b) {
+                return counts[b].times - counts[a].times
+            })
+            .forEach(function (key) {
+                var count = counts[key];
+                console.log(
+                    count.times + ' : ' + count.node.source()
+                );
+            })
+        ;
+    }
+});

node_modules/bunker/example/top/src.js

@@ -0,0 +1,18 @@
+function boop () {
+    for (var i = 0; i < 30; i++) {
+        nop();
+    }
+}
+
+function nop () {
+    return undefined;
+}
+
+var times = 0;
+var iv = setInterval(function () {
+    if (++times === 10) {
+        clearInterval(iv);
+        end();
+    }
+    else boop()
+}, 100);

node_modules/bunker/index.js

@@ -0,0 +1,116 @@
+var burrito = require('burrito');
+var vm = require('vm');
+var EventEmitter = require('events').EventEmitter;
+
+module.exports = function (src) {
+    var b = new Bunker();
+    if (src) b.include(src);
+    return b;
+};
+
+function Bunker () {
+    this.sources = [];
+    this.nodes = [];
+    
+    this.names = {
+        call : burrito.generateName(6),
+        expr : burrito.generateName(6),
+        stat : burrito.generateName(6),
+        return : burrito.generateName(6)
+    };
+}
+
+Bunker.prototype = new EventEmitter;
+
+Bunker.prototype.include = function (src) {
+    this.sources.push(src);
+    this.source = null;
+    return this;
+};
+
+Bunker.prototype.compile = function () {
+    var src = this.sources.join('\n');
+    var nodes = this.nodes;
+    var names = this.names;
+    
+    return burrito(src, function (node) {
+        var i = nodes.length;
+        
+        if (node.name === 'call') {
+            nodes.push(node);
+            node.wrap(names.call + '(' + i + ')(%s)');
+        }
+        else if (node.name === 'stat' || node.name === 'throw'
+        || node.name === 'var') {
+            nodes.push(node);
+            node.wrap('{' + names.stat + '(' + i + ');%s}');
+        }
+        else if (node.name === 'return') {
+            nodes.push(node);
+            // We need to wrap the new source in a function definition
+            // so that UglifyJS will allow the presence of return
+            var stat = names.stat + '(' + i + ');';
+            var wrapped = 'function ' + names.return + '() {'
+                + stat + node.source()
+                +'}'
+            ;
+            var parsed = burrito.parse(wrapped);
+            // Remove the function definition from the AST
+            parsed[1] = parsed[1][0][3];
+            node.state.update(parsed, true);
+        }
+        else if (node.name === 'binary') {
+            nodes.push(node);
+            node.wrap(names.expr + '(' + i + ')(%s)');
+        }
+        else if (node.name === 'unary-postfix' || node.name === 'unary-prefix') {
+            nodes.push(node);
+            node.wrap(names.expr + '(' + i + ')(%s)');
+        }
+        
+        if (i !== nodes.length) {
+            node.id = i;
+        }
+    });
+};
+
+Bunker.prototype.assign = function (context) {
+    if (!context) context = {};
+    
+    var self = this;
+    var stack = [];
+    
+    context[self.names.call] = function (i) {
+        var node = self.nodes[i];
+        stack.unshift(node);
+        self.emit('node', node, stack);
+        
+        return function (expr) {
+            stack.shift();
+            return expr;
+        };
+    };
+    
+    context[self.names.expr] = function (i) {
+        var node = self.nodes[i];
+        self.emit('node', node, stack);
+        
+        return function (expr) {
+            return expr;
+        };
+    };
+    
+    context[self.names.stat] = function (i) {
+        var node = self.nodes[i];
+        self.emit('node', node, stack);
+    };
+    
+    return context;
+};
+    
+Bunker.prototype.run = function (context) {
+    var src = this.compile();
+    vm.runInNewContext(src, this.assign(context));
+    
+    return this;
+};

node_modules/bunker/package.json

@@ -0,0 +1,35 @@
+{
+    "name" : "bunker",
+    "version" : "0.1.2",
+    "description" : "code coverage in native javascript",
+    "main" : "index.js",
+    "directories" : {
+        "lib" : ".",
+        "example" : "example",
+        "test" : "test"
+    },
+    "dependencies" : {
+        "burrito" : ">=0.2.5 <0.3"
+    },
+    "devDependencies" : {
+        "tap" : "~0.2.4"
+    },
+    "scripts" : {
+        "test" : "tap test/*.js"
+    },
+    "repository" : {
+        "type" : "git",
+        "url" : "http://github.com/substack/node-bunker.git"
+    },
+    "keywords" : [
+        "code",
+        "coverage"
+    ],
+    "author" : {
+        "name" : "James Halliday",
+        "email" : "mail@substack.net",
+        "url" : "http://substack.net"
+    },
+    "license" : "MIT/X11",
+    "engine" : { "node" : ">=0.4" }
+}

node_modules/bunker/test/cover.js

@@ -0,0 +1,36 @@
+var test = require('tap').test;
+var bunker = require('../');
+var fs = require('fs');
+
+var src = fs.readdirSync(__dirname + '/src').reduce(function (acc, file) {
+    acc[file] = fs.readFileSync(__dirname + '/src/' + file, 'utf8');
+    return acc;
+}, {});
+
+test('cover', function (t) {
+    t.plan(1);
+    
+    var b = bunker(src['cover.js']);
+    var counts = {};
+    
+    b.on('node', function (node) {
+        counts[node.name] = (counts[node.name] || 0) + 1;
+    });
+    
+    b.run({
+        setInterval : setInterval,
+        clearInterval : function () {
+            process.nextTick(function () {
+                t.same(counts, {
+                    binary : 11,
+                    'unary-postfix' : 11,
+                    'var' : 2,
+                    call : 2, // setInterval and clearInterval
+                    stat : 1, // clearInterval
+                });
+            });
+            
+            return clearInterval.apply(this, arguments);
+        },
+    });
+});

node_modules/bunker/test/return.js

@@ -0,0 +1,29 @@
+var test = require('tap').test;
+var bunker = require('../');
+
+test('cover', function (t) {
+    t.plan(1);
+    
+    var b = bunker('(' + function () {
+        function foo () {}
+        function bar () {}
+        
+        (function () {
+            return foo();
+        })();
+    } + ')()');
+    var counts = {};
+    
+    b.on('node', function (node) {
+        counts[node.name] = (counts[node.name] || 0) + 1;
+    });
+    b.run();
+    
+    process.nextTick(function () {
+        t.same(counts, {
+            stat : 2,
+            call : 2,
+            return : 1,
+        });
+    });
+});

node_modules/bunker/test/src/cover.js

@@ -0,0 +1,6 @@
+var i = 0;
+var iv = setInterval(function () {
+    if (i++ === 10) {
+        clearInterval(iv);
+    }
+}, 10);