holmes 0.0.1

data/lib/holmes/node_modules/detective/node_modules/burrito/test/label.js

@@ -0,0 +1,110 @@
+var assert = require('assert');
+var burrito = require('../');
+
+exports.callLabel = function () {
+    var times = 0;
+    var src = burrito('foo(10)', function (node) {
+        if (node.name === 'call') {
+            assert.equal(node.label(), 'foo');
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.varLabel = function () {
+    var times = 0;
+    var src = burrito('var x = 2', function (node) {
+        if (node.name === 'var') {
+            assert.deepEqual(node.label(), [ 'x' ]);
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.varsLabel = function () {
+    var times = 0;
+    var src = burrito('var x = 2, y = 3', function (node) {
+        if (node.name === 'var') {
+            assert.deepEqual(node.label(), [ 'x', 'y' ]);
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.defunLabel = function () {
+    var times = 0;
+    var src = burrito('function moo () {}', function (node) {
+        if (node.name === 'defun') {
+            assert.deepEqual(node.label(), 'moo');
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.functionLabel = function () {
+    var times = 0;
+    var src = burrito('(function zzz () {})()', function (node) {
+        if (node.name === 'function') {
+            assert.deepEqual(node.label(), 'zzz');
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.anonFunctionLabel = function () {
+    var times = 0;
+    var src = burrito('(function () {})()', function (node) {
+        if (node.name === 'function') {
+            assert.ok(node.label() === null);
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.dotCallLabel = function () {
+    var times = 0;
+    var src = burrito('process.nextTick(fn)', function (node) {
+        if (node.name === 'call') {
+            assert.equal(node.label(), 'nextTick');
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.tripleDotLabel = function () {
+    var times = 0;
+    var src = burrito('a.b.c(fn)', function (node) {
+        if (node.name === 'call') {
+            assert.equal(node.label(), 'c');
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};
+
+exports.exprLabel = function () {
+    var times = 0;
+    var src = burrito('a.b[x+1](fn)', function (node) {
+        if (node.name === 'call') {
+            assert.ok(node.label() === null);
+            times ++;
+        }
+    });
+    
+    assert.equal(times, 1);
+};

data/lib/holmes/node_modules/detective/node_modules/burrito/test/microwave.js

@@ -0,0 +1,33 @@
+var assert = require('assert');
+var burrito = require('../');
+
+exports.microwave = function () {
+    var times = 0;
+    var context = {
+        f : function (x) { return x + 1 },
+        g : function (x) { return x + 2 },
+        h : function (x) { return x + 3 },
+        z : function (x) {
+            times ++;
+            return x * 10;
+        },
+    };
+    
+    var res = burrito.microwave('f(g(h(5)))', context, function (node) {
+        if (node.name === 'call') {
+            node.wrap(function (s) {
+                return 'z(' + s + ')';
+            });
+        }
+    });
+    
+    assert.equal(res, (((((5 + 3) * 10) + 2) * 10) + 1) * 10);
+    assert.equal(times, 3);
+};
+
+exports.emptyContext = function () {
+    var res = burrito.microwave('Math.sin(2)', function (node) {
+        if (node.name === 'num') node.wrap('Math.PI / %s');
+    });
+    assert.equal(res, 1);
+};

data/lib/holmes/node_modules/detective/node_modules/burrito/test/parent.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var burrito = require('../');
+
+exports.checkParent = function () {
+    var src = 'Math.tan(0) + Math.sin(0)';
+    
+    var res = burrito.microwave(src, function (node) {
+        if (node.name === 'binary') {
+            node.wrap('%a - %b');
+        }
+        else if (node.name === 'num') {
+            assert.equal(node.parent().value[0][0], 'dot');
+            
+            var fn = node.parent().value[0][2];
+            if (fn === 'sin') {
+                node.wrap('Math.PI / 2');
+            }
+            else if (fn === 'tan') {
+                node.wrap('Math.PI / 4');
+            }
+            else assert.fail('Unknown fn');
+        }
+    });
+    
+    assert.equal(res, Math.tan(Math.PI / 4) - Math.sin(Math.PI / 2)); // ~ 0
+};

data/lib/holmes/node_modules/detective/node_modules/burrito/test/wrap.js

@@ -0,0 +1,157 @@
+var assert = require('assert');
+var burrito = require('../');
+var vm = require('vm');
+
+exports.preserveTernaryParentheses = function () {
+    var originalSource = '"anything" + (x ? y : z) + "anything"';
+    var burritoSource = burrito(originalSource, function (node) {
+        // do nothing. we just want to check that ternary parens are persisted
+    });
+    
+    var ctxt = {
+        x : false,
+        y : 'y_'+~~(Math.random()*10),
+        z : 'z_'+~~(Math.random()*10)
+    };
+    
+    var expectedOutput = vm.runInNewContext(originalSource, ctxt);
+    var burritoOutput = vm.runInNewContext(burritoSource, ctxt);
+    
+    assert.equal(burritoOutput, expectedOutput);
+    
+    ctxt.x = true;
+    
+    expectedOutput = vm.runInNewContext(originalSource, ctxt);
+    burritoOutput = vm.runInNewContext(burritoSource, ctxt);
+    
+    assert.equal(burritoOutput, expectedOutput);
+};
+
+exports.wrapCalls = function () {
+    var src = burrito('f() && g(h())\nfoo()', function (node) {
+        if (node.name === 'call') node.wrap('qqq(%s)');
+        if (node.name === 'binary') node.wrap('bbb(%s)');
+        assert.ok(node.state);
+        assert.equal(this, node.state);
+    });
+    
+    var tg = setTimeout(function () {
+        assert.fail('g() never called');
+    }, 5000);
+    
+    var times = { bbb : 0, qqq : 0 };
+    
+    var res = [];
+    vm.runInNewContext(src, {
+        bbb : function (x) {
+            times.bbb ++;
+            res.push(x);
+            return x;
+        },
+        qqq : function (x) {
+            times.qqq ++;
+            res.push(x);
+            return x;
+        },
+        f : function () { return true },
+        g : function (h) {
+            clearTimeout(tg);
+            assert.equal(h, 7);
+            return h !== 7
+        },
+        h : function () { return 7 },
+        foo : function () { return 'foo!' },
+    });
+    
+    assert.deepEqual(res, [
+        true, // f()
+        7, // h()
+        false, // g(h())
+        false, // f() && g(h())
+        'foo!', // foo()
+    ]);
+    assert.equal(times.bbb, 1);
+    assert.equal(times.qqq, 4);
+};
+
+exports.wrapFn = function () {
+    var src = burrito('f(g(h(5)))', function (node) {
+        if (node.name === 'call') {
+            node.wrap(function (s) {
+                return 'z(' + s + ')';
+            });
+        }
+    });
+    
+    var times = 0;
+    assert.equal(
+        vm.runInNewContext(src, {
+            f : function (x) { return x + 1 },
+            g : function (x) { return x + 2 },
+            h : function (x) { return x + 3 },
+            z : function (x) {
+                times ++;
+                return x * 10;
+            },
+        }),
+        (((((5 + 3) * 10) + 2) * 10) + 1) * 10
+    );
+    assert.equal(times, 3);
+};
+
+exports.binaryString = function () {
+    var src = 'z(x + y)';
+    var context = {
+        x : 3,
+        y : 4,
+        z : function (n) { return n * 10 },
+    };
+    
+    var res = burrito.microwave(src, context, function (node) {
+        if (node.name === 'binary') {
+            node.wrap('%a*2 - %b*2');
+        }
+    });
+    
+    assert.equal(res, 10 * (3*2 - 4*2));
+};
+
+exports.binaryFn = function () {
+    var src = 'z(x + y)';
+    var context = {
+        x : 3,
+        y : 4,
+        z : function (n) { return n * 10 },
+    };
+    
+    var res = burrito.microwave(src, context, function (node) {
+        if (node.name === 'binary') {
+            node.wrap(function (expr, a, b) {
+                return '(' + a + ')*2 - ' + '(' + b + ')*2';
+            });
+        }
+    });
+    
+    assert.equal(res, 10 * (3*2 - 4*2));
+};
+
+exports.intersperse = function () {
+    var src = '(' + (function () {
+        f();
+        g();
+    }).toString() + ')()';
+    
+    var times = { f : 0, g : 0, zzz : 0 };
+    
+    var context = {
+        f : function () { times.f ++ },
+        g : function () { times.g ++ },
+        zzz : function () { times.zzz ++ },
+    };
+    
+    burrito.microwave(src, context, function (node) {
+        if (node.name === 'stat') node.wrap('{ zzz(); %s }');
+    });
+    
+    assert.deepEqual(times, { f : 1, g : 1, zzz : 3 });
+};

data/lib/holmes/node_modules/detective/package.json

@@ -0,0 +1,39 @@
+{
+    "name" : "detective",
+    "description" : "Find all calls to require() no matter how crazily nested using a proper walk of the AST",
+    "version" : "0.0.4",
+    "repository" : {
+        "type" : "git",
+        "url" : "git://github.com/substack/node-detective.git"
+    },
+    "main" : "index.js",
+    "keywords" : [
+        "require",
+        "source",
+        "analyze",
+        "ast"
+    ],
+    "directories" : {
+        "lib" : ".",
+        "example" : "example",
+        "test" : "test"
+    },
+    "scripts" : {
+        "test" : "expresso"
+    },
+    "dependencies" : {
+        "burrito" : "0.2.x"
+    },
+    "devDependencies" : {
+        "expresso" : "=0.7.x"
+    },
+    "engines" : {
+        "node" : ">=0.4.0"
+    },
+    "license" : "MIT",
+    "author" : {
+        "name" : "James Halliday",
+        "email" : "mail@substack.net",
+        "url" : "http://substack.net"
+    }
+}

data/lib/holmes/node_modules/detective/test/both.js

@@ -0,0 +1,10 @@
+var assert = require('assert');
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/both.js');
+
+exports.both = function () {
+    var modules = detective.find(src);
+    assert.deepEqual(modules.strings, [ 'a', 'b' ]);
+    assert.deepEqual(modules.expressions, [ '"c"+x', '"d"+y' ]);
+};

data/lib/holmes/node_modules/detective/test/files/both.js

@@ -0,0 +1,4 @@
+require('a');
+require('b');
+require('c'+x);
+var moo = require('d'+y).moo;

data/lib/holmes/node_modules/detective/test/files/nested.js

@@ -0,0 +1,22 @@
+
+if (true) {
+    (function () {
+        require('a');
+    })();
+}
+if (false) {
+    (function () {
+        var x = 10;
+        switch (x) {
+            case 1 : require('b'); break;
+            default : break;
+        }
+    })()
+}
+
+function qqq () {
+    require
+        (
+        "c"
+    );
+}

data/lib/holmes/node_modules/detective/test/files/strings.js

@@ -0,0 +1,13 @@
+var a = require('a');
+var b = require('b');
+var c = require('c');
+var abc = a.b(c);
+
+var EventEmitter = require('events').EventEmitter;
+
+var x = require('doom')(5,6,7);
+x(8,9);
+c.require('notthis');
+var y = require('y') * 100;
+
+var EventEmitter2 = require('events2').EventEmitter();

data/lib/holmes/node_modules/detective/test/files/word.js

@@ -0,0 +1,13 @@
+var a = load('a');
+var b = load('b');
+var c = load('c');
+var abc = a.b(c);
+
+var EventEmitter = load('events').EventEmitter;
+
+var x = load('doom')(5,6,7);
+x(8,9);
+c.load('notthis');
+var y = load('y') * 100;
+
+var EventEmitter2 = load('events2').EventEmitter();

data/lib/holmes/node_modules/detective/test/nested.js

@@ -0,0 +1,8 @@
+var assert = require('assert');
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/nested.js');
+
+exports.nested = function () {
+    assert.deepEqual(detective(src), [ 'a', 'b', 'c' ]);
+};