holmes 0.0.1

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/uglify-js/tmp/instrument.js

@@ -0,0 +1,97 @@
+// sample on how to use the parser and walker API to instrument some code
+
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+function instrument(code) {
+        var ast = jsp.parse(code, false, true); // true for the third arg specifies that we want
+                                                // to have start/end tokens embedded in the
+                                                // statements
+        var w = pro.ast_walker();
+
+        // we're gonna need this to push elements that we're currently looking at, to avoid
+        // endless recursion.
+        var analyzing = [];
+        function do_stat() {
+                var ret;
+                if (this[0].start && analyzing.indexOf(this) < 0) {
+                        // without the `analyzing' hack, w.walk(this) would re-enter here leading
+                        // to infinite recursion
+                        analyzing.push(this);
+                        ret = [ "splice", // XXX: "block" is safer
+                                [ [ "stat",
+                                    [ "call", [ "name", "trace" ],
+                                      [ [ "string", this[0].toString() ],
+                                        [ "num", this[0].start.line ],
+                                        [ "num", this[0].start.col ],
+                                        [ "num", this[0].end.line ],
+                                        [ "num", this[0].end.col ]]]],
+                                  w.walk(this) ]];
+                        analyzing.pop(this);
+                }
+                return ret;
+        };
+        var new_ast = w.with_walkers({
+                "stat"     : do_stat,
+                "label"    : do_stat,
+                "break"    : do_stat,
+                "continue" : do_stat,
+                "debugger" : do_stat,
+                "var"      : do_stat,
+                "const"    : do_stat,
+                "return"   : do_stat,
+                "throw"    : do_stat,
+                "try"      : do_stat,
+                "defun"    : do_stat,
+                "if"       : do_stat,
+                "while"    : do_stat,
+                "do"       : do_stat,
+                "for"      : do_stat,
+                "for-in"   : do_stat,
+                "switch"   : do_stat,
+                "with"     : do_stat
+        }, function(){
+                return w.walk(ast);
+        });
+        return pro.gen_code(new_ast, { beautify: true });
+}
+
+
+
+
+////// test code follows.
+
+var code = instrument(test.toString());
+console.log(code);
+
+function test() {
+        // simple stats
+        a = 5;
+        c += a + b;
+        "foo";
+
+        // var
+        var foo = 5;
+        const bar = 6, baz = 7;
+
+        // switch block.  note we can't track case lines the same way.
+        switch ("foo") {
+            case "foo":
+                return 1;
+            case "bar":
+                return 2;
+        }
+
+        // for/for in
+        for (var i = 0; i < 5; ++i) {
+                console.log("Hello " + i);
+        }
+        for (var i in [ 1, 2, 3]) {
+                console.log(i);
+        }
+
+        // note however that the following is broken.  I guess we
+        // should add the block brackets in this case...
+        for (var i = 0; i < 5; ++i)
+                console.log("foo");
+}

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/uglify-js/tmp/instrument2.js

@@ -0,0 +1,138 @@
+// sample on how to use the parser and walker API to instrument some code
+
+var jsp = require("uglify-js").parser;
+var pro = require("uglify-js").uglify;
+
+function instrument(code) {
+        var ast = jsp.parse(code, false, true); // true for the third arg specifies that we want
+                                                // to have start/end tokens embedded in the
+                                                // statements
+        var w = pro.ast_walker();
+
+        function trace (line, comment) {
+                var code = pro.gen_code(line, { beautify: true });
+                var data = line[0]
+
+                var args = []
+                if (!comment) comment = ""
+                if (typeof data === "object") {
+                        code = code.split(/\n/).shift()
+                        args = [ [ "string", data.toString() ],
+                                 [ "string", code ],
+                                 [ "num", data.start.line ],
+                                 [ "num", data.start.col ],
+                                 [ "num", data.end.line ],
+                                 [ "num", data.end.col ]]
+                } else {
+                        args = [ [ "string", data ],
+                                 [ "string", code ]]
+
+                }
+                return [ "call", [ "name", "trace" ], args ];
+        }
+
+        // we're gonna need this to push elements that we're currently looking at, to avoid
+        // endless recursion.
+        var analyzing = [];
+        function do_stat() {
+                var ret;
+                if (this[0].start && analyzing.indexOf(this) < 0) {
+                        // without the `analyzing' hack, w.walk(this) would re-enter here leading
+                        // to infinite recursion
+                        analyzing.push(this);
+                        ret = [ "splice",
+                                [ [ "stat", trace(this) ],
+                                  w.walk(this) ]];
+                        analyzing.pop(this);
+                }
+                return ret;
+        }
+
+        function do_cond(c, t, f) {
+                return [ this[0], w.walk(c),
+                         ["seq", trace(t), w.walk(t) ],
+                         ["seq", trace(f), w.walk(f) ]];
+        }
+
+        function do_binary(c, l, r) {
+                if (c !== "&&" && c !== "||") {
+                        return [this[0], c, w.walk(l), w.walk(r)];
+                }
+                return [ this[0], c,
+                         ["seq", trace(l), w.walk(l) ],
+                         ["seq", trace(r), w.walk(r) ]];
+        }
+
+        var new_ast = w.with_walkers({
+                "stat"        : do_stat,
+                "label"       : do_stat,
+                "break"       : do_stat,
+                "continue"    : do_stat,
+                "debugger"    : do_stat,
+                "var"         : do_stat,
+                "const"       : do_stat,
+                "return"      : do_stat,
+                "throw"       : do_stat,
+                "try"         : do_stat,
+                "defun"       : do_stat,
+                "if"          : do_stat,
+                "while"       : do_stat,
+                "do"          : do_stat,
+                "for"         : do_stat,
+                "for-in"      : do_stat,
+                "switch"      : do_stat,
+                "with"        : do_stat,
+                "conditional" : do_cond,
+                "binary"      : do_binary
+        }, function(){
+                return w.walk(ast);
+        });
+        return pro.gen_code(new_ast, { beautify: true });
+}
+
+
+////// test code follows.
+
+var code = instrument(test.toString());
+console.log(code);
+
+function test() {
+        // simple stats
+        a = 5;
+        c += a + b;
+        "foo";
+
+        // var
+        var foo = 5;
+        const bar = 6, baz = 7;
+
+        // switch block.  note we can't track case lines the same way.
+        switch ("foo") {
+            case "foo":
+                return 1;
+            case "bar":
+                return 2;
+        }
+
+        // for/for in
+        for (var i = 0; i < 5; ++i) {
+                console.log("Hello " + i);
+        }
+        for (var i in [ 1, 2, 3]) {
+                console.log(i);
+        }
+
+        for (var i = 0; i < 5; ++i)
+                console.log("foo");
+
+        for (var i = 0; i < 5; ++i) {
+                console.log("foo");
+        }
+
+        var k = plurp() ? 1 : 0;
+        var x = a ? doX(y) && goZoo("zoo")
+              : b ? blerg({ x: y })
+              : null;
+
+        var x = X || Y;
+}

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/uglify-js/tmp/test.js

@@ -0,0 +1,16 @@
+#! /usr/bin/env node
+
+global.sys = require(/^v0\.[012]/.test(process.version) ? "sys" : "util");
+var fs = require("fs");
+var uglify = require("uglify-js"), // symlink ~/.node_libraries/uglify-js.js to ../uglify-js.js
+    jsp = uglify.parser,
+    pro = uglify.uglify;
+
+var code = fs.readFileSync("hoist.js", "utf8");
+var ast = jsp.parse(code);
+
+ast = pro.ast_lift_variables(ast);
+
+console.log(pro.gen_code(ast, {
+        beautify: true
+}));

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/uglify-js/uglify-js.js

@@ -0,0 +1,17 @@
+//convienence function(src, [options]);
+function uglify(orig_code, options){
+  options || (options = {});
+  var jsp = uglify.parser;
+  var pro = uglify.uglify;
+
+  var ast = jsp.parse(orig_code, options.strict_semicolons); // parse code and get the initial AST
+  ast = pro.ast_mangle(ast, options.mangle_options); // get a new AST with mangled names
+  ast = pro.ast_squeeze(ast, options.squeeze_options); // get an AST with compression optimizations
+  var final_code = pro.gen_code(ast, options.gen_options); // compressed code here
+  return final_code;
+};
+
+uglify.parser = require("./lib/parse-js");
+uglify.uglify = require("./lib/process");
+
+module.exports = uglify

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

@@ -0,0 +1,43 @@
+{
+    "name" : "burrito",
+    "description" : "Wrap up expressions with a trace function while walking the AST with rice and beans on the side",
+    "version" : "0.2.11",
+    "repository" : {
+        "type" : "git",
+        "url" : "git://github.com/substack/node-burrito.git"
+    },
+    "main" : "./index.js",
+    "keywords" : [
+        "trace",
+        "ast",
+        "walk",
+        "syntax",
+        "source",
+        "tree",
+        "uglify"
+    ],
+    "directories" : {
+        "lib" : ".",
+        "example" : "example",
+        "test" : "test"
+    },
+    "scripts" : {
+        "test" : "expresso"
+    },
+    "dependencies" : {
+        "traverse" : ">=0.5.1 <0.6.0",
+        "uglify-js" : "1.0.7"
+    },
+    "devDependencies" : {
+        "expresso" : "=0.7.x"
+    },
+    "engines" : {
+        "node" : ">=0.4.0"
+    },
+    "license" : "BSD",
+    "author" : {
+        "name" : "James Halliday",
+        "email" : "mail@substack.net",
+        "url" : "http://substack.net"
+    }
+}

data/lib/holmes/node_modules/detective/node_modules/burrito/server.js

@@ -0,0 +1,4 @@
+var express = require('express');
+var app = express.createServer();
+app.use(express.static(__dirname));
+app.listen(8080);

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

@@ -0,0 +1,29 @@
+var assert = require('assert');
+var burrito = require('../');
+var vm = require('vm');
+
+exports.ast = function () {
+    var ast = burrito.parse('f(g(h(5)))', false, true);
+    var src = burrito(ast, 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);
+};

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

@@ -0,0 +1,47 @@
+var assert = require('assert');
+var burrito = require('../');
+
+exports.wrapError = function () {
+    try {
+        var src = burrito('f() && g()', function (node) {
+            if (node.name === 'binary') node.wrap('h(%a, %b')
+        });
+        assert.fail('should have blown up');
+    }
+    catch (err) {
+        assert.ok(err.message.match(/unexpected/i));
+        assert.ok(err instanceof SyntaxError);
+        assert.ok(!err.stack.match(/uglify-js/));
+        assert.equal(err.line, 0);
+        assert.equal(err.col, 10);
+        assert.equal(err.pos, 10);
+    }
+};
+
+exports.nonString = function () {
+    assert.throws(function () {
+        burrito.parse(new Buffer('[]'));
+    });
+    
+    assert.throws(function () {
+        burrito.parse(new String('[]'));
+    });
+    
+    assert.throws(function () {
+        burrito.parse();
+    });
+};
+
+exports.syntaxError = function () {
+    try {
+        var src = burrito('f() && g())', function (node) {
+            if (node.name === 'binary') node.wrap('h(%a, %b)')
+        });
+        assert.fail('should have blown up');
+    }
+    catch (err) {
+        assert.ok(err.message.match(/unexpected/i));
+        assert.ok(err instanceof SyntaxError);
+        assert.ok(!err.stack.match(/uglify-js/));
+    }
+};

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

@@ -0,0 +1,8 @@
+var burrito = require('../');
+var assert = require('assert');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/fail/src.js', 'utf8');
+
+exports.fail = function () {
+    burrito(src, function (node) {});
+};

data/lib/holmes/node_modules/detective/node_modules/burrito/test/fail/src.js

@@ -0,0 +1,60 @@
+var path = require('path')
+
+module.exports = function(fs, ready) {
+  var global_files = {}
+
+  var recurse = function(dir, okay) {
+    fs.readdir(dir, function(err, dir_files) {
+      var countdown = 0
+        , files = []
+        , dirs  = []
+        , checked = 0
+      dir_files.forEach(function(file, idx, all) {
+        fs.stat(path.join(dir, file), function(err, stat) {
+          if(stat.isDirectory() && !/node_modules/g.test(dir)) {
+            dirs.push(file)
+          } else if(/\.js$/g.test(file)) {
+            files.push(file)
+          }
+
+          if(++checked >= dir_files.length)
+            recurse_dirs()
+        })
+      })
+
+      function recurse_dirs() {
+        var total = 0
+        dirs.forEach(function(this_dir) {
+          recurse(path.join(dir, this_dir), function(err, data) {
+            if(++total >= dirs.length)
+              recurse_files() 
+          })
+        })
+
+        if(!dirs.length)
+          recurse_files()
+      }
+
+      function recurse_files() {
+        var total = 0
+        files.forEach(function(file) {
+          fs.readFile(path.join(dir, file), 'utf8', function(err, src) {
+            global_files[path.join(dir, file)] = src
+            ++total >= files.length &&
+              okay(null, global_files)
+          })
+        })
+
+        if(!files.length)
+          okay(null, global_files)
+      }
+
+      if(!dir_files.length)
+        okay(null, global_files)
+    })
+  }
+
+  recurse('.', ready)
+}
+
+