holmes 0.0.1

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/traverse/test/json.js

@@ -0,0 +1,47 @@
+var assert = require('assert');
+var Traverse = require('../');
+
+exports['json test'] = function () {
+    var id = 54;
+    var callbacks = {};
+    var obj = { moo : function () {}, foo : [2,3,4, function () {}] };
+    
+    var scrubbed = Traverse(obj).map(function (x) {
+        if (typeof x === 'function') {
+            callbacks[id] = { id : id, f : x, path : this.path };
+            this.update('[Function]');
+            id++;
+        }
+    });
+    
+    assert.equal(
+        scrubbed.moo, '[Function]',
+        'obj.moo replaced with "[Function]"'
+    );
+    
+    assert.equal(
+        scrubbed.foo[3], '[Function]',
+        'obj.foo[3] replaced with "[Function]"'
+    );
+    
+    assert.deepEqual(scrubbed, {
+        moo : '[Function]',
+        foo : [ 2, 3, 4, "[Function]" ]
+    }, 'Full JSON string matches');
+    
+    assert.deepEqual(
+        typeof obj.moo, 'function',
+        'Original obj.moo still a function'
+    );
+    
+    assert.deepEqual(
+        typeof obj.foo[3], 'function',
+        'Original obj.foo[3] still a function'
+    );
+    
+    assert.deepEqual(callbacks, {
+        54: { id: 54, f : obj.moo, path: [ 'moo' ] },
+        55: { id: 55, f : obj.foo[3], path: [ 'foo', '3' ] },
+    }, 'Check the generated callbacks list');
+};
+

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/traverse/test/keys.js

@@ -0,0 +1,29 @@
+var assert = require('assert');
+var Traverse = require('../');
+
+exports['sort test'] = function () {
+    var acc = [];
+    Traverse({
+        a: 30,
+        b: 22,
+        id: 9
+    }).forEach(function (node) {
+        if ((! Array.isArray(node)) && typeof node === 'object') {
+            this.before(function(node) {
+                this.keys = Object.keys(node);
+                this.keys.sort(function(a, b) {
+                    a = [a === "id" ? 0 : 1, a];
+                    b = [b === "id" ? 0 : 1, b];
+                    return a < b ? -1 : a > b ? 1 : 0;
+                });
+            });
+        }
+        if (this.isLeaf) acc.push(node);
+    });
+    
+    assert.equal(
+        acc.join(' '),
+        '9 30 22',
+        'Traversal in a custom order'
+    );
+};

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/traverse/test/leaves.js

@@ -0,0 +1,21 @@
+var assert = require('assert');
+var Traverse = require('../');
+
+exports['leaves test'] = function () {
+    var acc = [];
+    Traverse({
+        a : [1,2,3],
+        b : 4,
+        c : [5,6],
+        d : { e : [7,8], f : 9 }
+    }).forEach(function (x) {
+        if (this.isLeaf) acc.push(x);
+    });
+    
+    assert.equal(
+        acc.join(' '),
+        '1 2 3 4 5 6 7 8 9',
+        'Traversal in the right(?) order'
+    );
+};
+

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/traverse/test/lib/deep_equal.js

@@ -0,0 +1,92 @@
+var traverse = require('../../');
+
+module.exports = function (a, b) {
+    if (arguments.length !== 2) {
+        throw new Error(
+            'deepEqual requires exactly two objects to compare against'
+        );
+    }
+    
+    var equal = true;
+    var node = b;
+    
+    traverse(a).forEach(function (y) {
+        var notEqual = (function () {
+            equal = false;
+            //this.stop();
+            return undefined;
+        }).bind(this);
+        
+        //if (node === undefined || node === null) return notEqual();
+        
+        if (!this.isRoot) {
+        /*
+            if (!Object.hasOwnProperty.call(node, this.key)) {
+                return notEqual();
+            }
+        */
+            if (typeof node !== 'object') return notEqual();
+            node = node[this.key];
+        }
+        
+        var x = node;
+        
+        this.post(function () {
+            node = x;
+        });
+        
+        var toS = function (o) {
+            return Object.prototype.toString.call(o);
+        };
+        
+        if (this.circular) {
+            if (traverse(b).get(this.circular.path) !== x) notEqual();
+        }
+        else if (typeof x !== typeof y) {
+            notEqual();
+        }
+        else if (x === null || y === null || x === undefined || y === undefined) {
+            if (x !== y) notEqual();
+        }
+        else if (x.__proto__ !== y.__proto__) {
+            notEqual();
+        }
+        else if (x === y) {
+            // nop
+        }
+        else if (typeof x === 'function') {
+            if (x instanceof RegExp) {
+                // both regexps on account of the __proto__ check
+                if (x.toString() != y.toString()) notEqual();
+            }
+            else if (x !== y) notEqual();
+        }
+        else if (typeof x === 'object') {
+            if (toS(y) === '[object Arguments]'
+            || toS(x) === '[object Arguments]') {
+                if (toS(x) !== toS(y)) {
+                    notEqual();
+                }
+            }
+            else if (x instanceof Date || y instanceof Date) {
+                if (!(x instanceof Date) || !(y instanceof Date)
+                || x.getTime() !== y.getTime()) {
+                    notEqual();
+                }
+            }
+            else {
+                var kx = Object.keys(x);
+                var ky = Object.keys(y);
+                if (kx.length !== ky.length) return notEqual();
+                for (var i = 0; i < kx.length; i++) {
+                    var k = kx[i];
+                    if (!Object.hasOwnProperty.call(y, k)) {
+                        notEqual();
+                    }
+                }
+            }
+        }
+    });
+    
+    return equal;
+};

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/traverse/test/mutability.js

@@ -0,0 +1,252 @@
+var assert = require('assert');
+var Traverse = require('../');
+var deepEqual = require('./lib/deep_equal');
+
+exports.mutate = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse(obj).forEach(function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    assert.deepEqual(obj, res);
+    assert.deepEqual(obj, { a : 1, b : 20, c : [ 3, 40 ] });
+};
+
+exports.mutateT = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse.forEach(obj, function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    assert.deepEqual(obj, res);
+    assert.deepEqual(obj, { a : 1, b : 20, c : [ 3, 40 ] });
+};
+
+exports.map = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse(obj).map(function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    assert.deepEqual(res, { a : 1, b : 20, c : [ 3, 40 ] });
+};
+
+exports.mapT = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse.map(obj, function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    assert.deepEqual(res, { a : 1, b : 20, c : [ 3, 40 ] });
+};
+
+exports.clone = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse(obj).clone();
+    assert.deepEqual(obj, res);
+    assert.ok(obj !== res);
+    obj.a ++;
+    assert.deepEqual(res.a, 1);
+    obj.c.push(5);
+    assert.deepEqual(res.c, [ 3, 4 ]);
+};
+
+exports.cloneT = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse.clone(obj);
+    assert.deepEqual(obj, res);
+    assert.ok(obj !== res);
+    obj.a ++;
+    assert.deepEqual(res.a, 1);
+    obj.c.push(5);
+    assert.deepEqual(res.c, [ 3, 4 ]);
+};
+
+exports.reduce = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse(obj).reduce(function (acc, x) {
+        if (this.isLeaf) acc.push(x);
+        return acc;
+    }, []);
+    assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    assert.deepEqual(res, [ 1, 2, 3, 4 ]);
+};
+
+exports.reduceInit = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse(obj).reduce(function (acc, x) {
+        if (this.isRoot) assert.fail('got root');
+        return acc;
+    });
+    assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    assert.deepEqual(res, obj);
+};
+
+exports.remove = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    Traverse(obj).forEach(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.remove();
+    });
+    
+    assert.deepEqual(obj, { a : 1, c : [ 3 ] });
+};
+
+exports.removeNoStop = function() {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 }, f: 5 };
+    
+    var keys = [];
+    Traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.remove();
+    });
+
+    assert.deepEqual(keys, [undefined, 'a', 'b', 'c', 'd', 'e', 'f'])
+}
+
+exports.removeStop = function() {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 }, f: 5 };
+    
+    var keys = [];
+    Traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.remove(true);
+    });
+
+    assert.deepEqual(keys, [undefined, 'a', 'b', 'c', 'f'])
+}
+
+exports.removeMap = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse(obj).map(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.remove();
+    });
+    
+    assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    assert.deepEqual(res, { a : 1, c : [ 3 ] });
+};
+
+exports.delete = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    Traverse(obj).forEach(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    assert.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, undefined ] }
+    ));
+    
+    assert.ok(deepEqual(
+        obj, { a : 1, c : [ 3 ] }
+    ));
+    
+    assert.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, null ] }
+    ));
+};
+
+exports.deleteNoStop = function() {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 } };
+    
+    var keys = [];
+    Traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.delete();
+    });
+
+    assert.deepEqual(keys, [undefined, 'a', 'b', 'c', 'd', 'e'])
+}
+
+exports.deleteStop = function() {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 } };
+    
+    var keys = [];
+    Traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.delete(true);
+    });
+
+    assert.deepEqual(keys, [undefined, 'a', 'b', 'c'])
+}
+
+exports.deleteRedux = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4, 5 ] };
+    Traverse(obj).forEach(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    assert.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, undefined, 5 ] }
+    ));
+    
+    assert.ok(deepEqual(
+        obj, { a : 1, c : [ 3 ,, 5 ] }
+    ));
+    
+    assert.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, null, 5 ] }
+    ));
+    
+    assert.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, 5 ] }
+    ));
+};
+
+exports.deleteMap = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = Traverse(obj).map(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    assert.ok(deepEqual(
+        obj,
+        { a : 1, b : 2, c : [ 3, 4 ] }
+    ));
+    
+    var xs = [ 3, 4 ];
+    delete xs[1];
+    
+    assert.ok(deepEqual(
+        res, { a : 1, c : xs }
+    ));
+    
+    assert.ok(deepEqual(
+        res, { a : 1, c : [ 3, ] }
+    ));
+    
+    assert.ok(deepEqual(
+        res, { a : 1, c : [ 3 ] }
+    ));
+};
+
+exports.deleteMapRedux = function () {
+    var obj = { a : 1, b : 2, c : [ 3, 4, 5 ] };
+    var res = Traverse(obj).map(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    assert.ok(deepEqual(
+        obj,
+        { a : 1, b : 2, c : [ 3, 4, 5 ] }
+    ));
+    
+    var xs = [ 3, 4, 5 ];
+    delete xs[1];
+    
+    assert.ok(deepEqual(
+        res, { a : 1, c : xs }
+    ));
+    
+    assert.ok(!deepEqual(
+        res, { a : 1, c : [ 3, 5 ] }
+    ));
+    
+    assert.ok(deepEqual(
+        res, { a : 1, c : [ 3 ,, 5 ] }
+    ));
+};

data/lib/holmes/node_modules/detective/node_modules/burrito/node_modules/traverse/test/negative.js

@@ -0,0 +1,20 @@
+var Traverse = require('../');
+var assert = require('assert');
+
+exports['negative update test'] = function () {
+    var obj = [ 5, 6, -3, [ 7, 8, -2, 1 ], { f : 10, g : -13 } ];
+    var fixed = Traverse.map(obj, function (x) {
+        if (x < 0) this.update(x + 128);
+    });
+    
+    assert.deepEqual(fixed,
+        [ 5, 6, 125, [ 7, 8, 126, 1 ], { f: 10, g: 115 } ],
+        'Negative values += 128'
+    );
+    
+    assert.deepEqual(obj,
+        [ 5, 6, -3, [ 7, 8, -2, 1 ], { f: 10, g: -13 } ],
+        'Original references not modified'
+    );
+}
+