traverse - npm Package Compare versions

Comparing version 0.3.7 to 0.3.8

index.js

@@ -52,2 +52,8 @@ module.exports = Traverse;
 Traverse.prototype.deepEqual = function (obj) {
+    if (arguments.length !== 1) {
+        throw new Error(
+            'deepEqual requires exactly one object to compare against'
+        );
+    }
+    
     var equal = true;
@@ -63,2 +69,4 @@ var node = obj;
         
+        //if (node === undefined || node === null) return notEqual();
+        
         if (!this.isRoot) {
@@ -70,2 +78,3 @@ /*
         */
+            if (typeof node !== 'object') return notEqual();
             node = node[this.key];
@@ -90,2 +99,5 @@ }
         }
+        else if (x === null || y === null || x === undefined || y === undefined) {
+            if (x !== y) notEqual();
+        }
         else if (x.__proto__ !== y.__proto__) {
@@ -105,6 +117,3 @@ notEqual();
         else if (typeof x === 'object') {
-            if (x === null || y === null) {
-                if (x !== y) notEqual();
-            }
-            else if (toS(y) === '[object Arguments]'
+            if (toS(y) === '[object Arguments]'
             || toS(x) === '[object Arguments]') {
@@ -111,0 +120,0 @@ if (toS(x) !== toS(y)) {

package.json

 {
     "name" : "traverse",
-    "version" : "0.3.7",
+    "version" : "0.3.8",
     "description" : "Traverse and transform objects by visiting every node on a recursive walk",
@@ -5,0 +5,0 @@ "author" : "James Halliday",

test/equal.js

@@ -5,15 +5,19 @@ var assert = require('assert');
 exports.deepDates = function () {
-    assert.ok(traverse.deepEqual(
-        { d : new Date, x : [ 1, 2, 3 ] },
-        { d : new Date, x : [ 1, 2, 3 ] },
+    assert.ok(
+        traverse.deepEqual(
+            { d : new Date, x : [ 1, 2, 3 ] },
+            { d : new Date, x : [ 1, 2, 3 ] }
+        ),
         'dates should be equal'
-    ));
+    );
     
     var d0 = new Date;
     setTimeout(function () {
-        assert.ok(!traverse.deepEqual(
-            { d : d0, x : [ 1, 2, 3 ], },
-            { d : new Date, x : [ 1, 2, 3 ] },
+        assert.ok(
+            !traverse.deepEqual(
+                { d : d0, x : [ 1, 2, 3 ], },
+                { d : new Date, x : [ 1, 2, 3 ] }
+            ),
             'microseconds should count in date equality'
-        ));
+        );
     }, 5);
@@ -50,78 +54,83 @@ };
 exports.deepInstances = function () {
-    assert.ok(!traverse.deepEqual(
-        [ new Boolean(false) ], [ false ],
+    assert.ok(
+        !traverse.deepEqual([ new Boolean(false) ], [ false ]),
         'boolean instances are not real booleans'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        [ new String('x') ], [ 'x' ],
+    assert.ok(
+        !traverse.deepEqual([ new String('x') ], [ 'x' ]),
         'string instances are not real strings'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        [ new Number(4) ], [ 4 ],
+    assert.ok(
+        !traverse.deepEqual([ new Number(4) ], [ 4 ]),
         'number instances are not real numbers'
-    ));
+    );
     
-    assert.ok(traverse.deepEqual(
-        [ new RegExp('x') ], [ /x/ ],
+    assert.ok(
+        traverse.deepEqual([ new RegExp('x') ], [ /x/ ]),
         'regexp instances are real regexps'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        [ new RegExp(/./) ], [ /../ ],
+    assert.ok(
+        !traverse.deepEqual([ new RegExp(/./) ], [ /../ ]),
         'these regexps aren\'t the same'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        [ function (x) { return x * 2 } ],
-        [ function (x) { return x * 2 } ],
+    assert.ok(
+        !traverse.deepEqual(
+            [ function (x) { return x * 2 } ],
+            [ function (x) { return x * 2 } ]
+        ),
         'functions with the same .toString() aren\'t necessarily the same'
-    ));
+    );
     
     var f = function (x) { return x * 2 };
-    assert.ok(traverse.deepEqual(
-        [ f ], [ f ],
+    assert.ok(
+        traverse.deepEqual([ f ], [ f ]),
         'these functions are actually equal'
-    ));
+    );
 };
 
 exports.deepEqual = function () {
-    assert.ok(!traverse.deepEqual(
-        [ 1, 2, 3 ],
-        { 0 : 1, 1 : 2, 2 : 3 },
+    assert.ok(
+        !traverse.deepEqual([ 1, 2, 3 ], { 0 : 1, 1 : 2, 2 : 3 }),
         'arrays are not objects'
-    ));
+    );
 };
 
 exports.falsy = function () {
-    assert.ok(!traverse.deepEqual(
-        [ undefined ],
-        [ null ],
+    assert.ok(
+        !traverse.deepEqual([ undefined ], [ null ]),
         'null is not undefined!'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        [ null ],
-        [ undefined ],
+    assert.ok(
+        !traverse.deepEqual([ null ], [ undefined ]),
         'undefined is not null!'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        { a : 1, b : 2, c : [ 3, undefined, 5 ] },
-        { a : 1, b : 2, c : [ 3, null, 5 ] },
+    assert.ok(
+        !traverse.deepEqual(
+            { a : 1, b : 2, c : [ 3, undefined, 5 ] },
+            { a : 1, b : 2, c : [ 3, null, 5 ] }
+        ),
         'undefined is not null, however deeply!'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        { a : 1, b : 2, c : [ 3, undefined, 5 ] },
-        { a : 1, b : 2, c : [ 3, null, 5 ] },
+    assert.ok(
+        !traverse.deepEqual(
+            { a : 1, b : 2, c : [ 3, undefined, 5 ] },
+            { a : 1, b : 2, c : [ 3, null, 5 ] }
+        ),
         'null is not undefined, however deeply!'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        { a : 1, b : 2, c : [ 3, undefined, 5 ] },
-        { a : 1, b : 2, c : [ 3, null, 5 ] },
+    assert.ok(
+        !traverse.deepEqual(
+            { a : 1, b : 2, c : [ 3, undefined, 5 ] },
+            { a : 1, b : 2, c : [ 3, null, 5 ] }
+        ),
         'null is not undefined, however deeply!'
-    ));
+    );
 };
@@ -138,19 +147,17 @@
     
-    assert.ok(traverse.deepEqual(
-        xs, ys,
+    assert.ok(
+        traverse.deepEqual(xs, ys),
         'arrays with deleted elements are only equal to'
         + ' arrays with similarly deleted elements'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        xs,
-        [ 1, 2, undefined, 4 ],
+    assert.ok(
+        !traverse.deepEqual(xs, [ 1, 2, undefined, 4 ]),
         'deleted array elements cannot be undefined'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        xs,
-        [ 1, 2, null, 4 ],
+    assert.ok(
+        !traverse.deepEqual(xs, [ 1, 2, null, 4 ]),
         'deleted array elements cannot be null'
-    ));
+    );
 };
@@ -162,16 +169,16 @@
     
-    assert.ok(traverse.deepEqual(
-        obj, { a : 1, b : 2 },
+    assert.ok(
+        traverse.deepEqual(obj, { a : 1, b : 2 }),
         'deleted object elements should not show up'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        obj, { a : 1, b : 2, c : undefined },
+    assert.ok(
+        !traverse.deepEqual(obj, { a : 1, b : 2, c : undefined }),
         'deleted object elements are not undefined'
-    ));
+    );
     
-    assert.ok(!traverse.deepEqual(
-        obj, { a : 1, b : 2, c : null },
+    assert.ok(
+        !traverse.deepEqual(obj, { a : 1, b : 2, c : null }),
         'deleted object elements are not null'
-    ));
+    );
 };
@@ -186,13 +193,32 @@
 exports.deepArguments = function () {
-    assert.ok(!traverse.deepEqual(
-        [ 4, 5, 6 ],
-        (function () { return arguments })(4, 5, 6),
+    assert.ok(
+        !traverse.deepEqual(
+            [ 4, 5, 6 ],
+            (function () { return arguments })(4, 5, 6)
+        ),
         'arguments are not arrays'
-    ));
+    );
     
-    assert.ok(traverse.deepEqual(
-        (function () { return arguments })(4, 5, 6),
-        (function () { return arguments })(4, 5, 6),
+    assert.ok(
+        traverse.deepEqual(
+            (function () { return arguments })(4, 5, 6),
+            (function () { return arguments })(4, 5, 6)
+        ),
         'arguments should equal'
-    ));
+    );
 };
+
+exports.deepUn = function () {
+    assert.ok(!traverse.deepEqual({ a : 1, b : 2 }, undefined));
+    assert.ok(!traverse.deepEqual({ a : 1, b : 2 }, {}));
+    assert.ok(!traverse.deepEqual(undefined, { a : 1, b : 2 }));
+    assert.ok(!traverse.deepEqual({}, { a : 1, b : 2 }));
+    assert.ok(traverse.deepEqual(undefined, undefined));
+    assert.ok(traverse.deepEqual(null, null));
+    assert.ok(!traverse.deepEqual(undefined, null));
+};
+
+exports.deepLevels = function () {
+    var xs = [ 1, 2, [ 3, 4, [ 5, 6 ] ] ];
+    assert.ok(!traverse.deepEqual(xs, []));
+};

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

37477

increased by2.91%

Lines of code

980

increased by3.27%

No dependency changes