pax_global_header00006660000000000000000000000064125704167370014526gustar00rootroot0000000000000052 comment=59c511f5aeae19e3dd1de054077a789d7302be34 node-deep-equal-1.0.1/000077500000000000000000000000001257041673700144725ustar00rootroot00000000000000node-deep-equal-1.0.1/.travis.yml000066400000000000000000000001641257041673700166040ustar00rootroot00000000000000language: node_js node_js: - '0.8' - '0.10' - '0.12' - 'iojs' before_install: - npm install -g npm@latest node-deep-equal-1.0.1/LICENSE000066400000000000000000000020611257041673700154760ustar00rootroot00000000000000This software is released under the MIT license: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. node-deep-equal-1.0.1/example/000077500000000000000000000000001257041673700161255ustar00rootroot00000000000000node-deep-equal-1.0.1/example/cmp.js000066400000000000000000000003171257041673700172430ustar00rootroot00000000000000var equal = require('../'); console.dir([ equal( { a : [ 2, 3 ], b : [ 4 ] }, { a : [ 2, 3 ], b : [ 4 ] } ), equal( { x : 5, y : [6] }, { x : 5, y : 6 } ) ]); node-deep-equal-1.0.1/index.js000066400000000000000000000057531257041673700161510ustar00rootroot00000000000000var pSlice = Array.prototype.slice; var objectKeys = require('./lib/keys.js'); var isArguments = require('./lib/is_arguments.js'); var deepEqual = module.exports = function (actual, expected, opts) { if (!opts) opts = {}; // 7.1. All identical values are equivalent, as determined by ===. if (actual === expected) { return true; } else if (actual instanceof Date && expected instanceof Date) { return actual.getTime() === expected.getTime(); // 7.3. Other pairs that do not both pass typeof value == 'object', // equivalence is determined by ==. } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') { return opts.strict ? actual === expected : actual == expected; // 7.4. For all other Object pairs, including Array objects, equivalence is // determined by having the same number of owned properties (as verified // with Object.prototype.hasOwnProperty.call), the same set of keys // (although not necessarily the same order), equivalent values for every // corresponding key, and an identical 'prototype' property. Note: this // accounts for both named and indexed properties on Arrays. } else { return objEquiv(actual, expected, opts); } } function isUndefinedOrNull(value) { return value === null || value === undefined; } function isBuffer (x) { if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false; if (typeof x.copy !== 'function' || typeof x.slice !== 'function') { return false; } if (x.length > 0 && typeof x[0] !== 'number') return false; return true; } function objEquiv(a, b, opts) { var i, key; if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) return false; // an identical 'prototype' property. if (a.prototype !== b.prototype) return false; //~~~I've managed to break Object.keys through screwy arguments passing. // Converting to array solves the problem. if (isArguments(a)) { if (!isArguments(b)) { return false; } a = pSlice.call(a); b = pSlice.call(b); return deepEqual(a, b, opts); } if (isBuffer(a)) { if (!isBuffer(b)) { return false; } if (a.length !== b.length) return false; for (i = 0; i < a.length; i++) { if (a[i] !== b[i]) return false; } return true; } try { var ka = objectKeys(a), kb = objectKeys(b); } catch (e) {//happens when one is a string literal and the other isn't return false; } // having the same number of owned properties (keys incorporates // hasOwnProperty) if (ka.length != kb.length) return false; //the same set of keys (although not necessarily the same order), ka.sort(); kb.sort(); //~~~cheap key test for (i = ka.length - 1; i >= 0; i--) { if (ka[i] != kb[i]) return false; } //equivalent values for every corresponding key, and //~~~possibly expensive deep test for (i = ka.length - 1; i >= 0; i--) { key = ka[i]; if (!deepEqual(a[key], b[key], opts)) return false; } return typeof a === typeof b; } node-deep-equal-1.0.1/lib/000077500000000000000000000000001257041673700152405ustar00rootroot00000000000000node-deep-equal-1.0.1/lib/is_arguments.js000066400000000000000000000012011257041673700202700ustar00rootroot00000000000000var supportsArgumentsClass = (function(){ return Object.prototype.toString.call(arguments) })() == '[object Arguments]'; exports = module.exports = supportsArgumentsClass ? supported : unsupported; exports.supported = supported; function supported(object) { return Object.prototype.toString.call(object) == '[object Arguments]'; }; exports.unsupported = unsupported; function unsupported(object){ return object && typeof object == 'object' && typeof object.length == 'number' && Object.prototype.hasOwnProperty.call(object, 'callee') && !Object.prototype.propertyIsEnumerable.call(object, 'callee') || false; }; node-deep-equal-1.0.1/lib/keys.js000066400000000000000000000003121257041673700165450ustar00rootroot00000000000000exports = module.exports = typeof Object.keys === 'function' ? Object.keys : shim; exports.shim = shim; function shim (obj) { var keys = []; for (var key in obj) keys.push(key); return keys; } node-deep-equal-1.0.1/package.json000066400000000000000000000016431257041673700167640ustar00rootroot00000000000000{ "name": "deep-equal", "version": "1.0.1", "description": "node's assert.deepEqual algorithm", "main": "index.js", "directories": { "lib": ".", "example": "example", "test": "test" }, "scripts": { "test": "tape test/*.js" }, "devDependencies": { "tape": "^3.5.0" }, "repository": { "type": "git", "url": "http://github.com/substack/node-deep-equal.git" }, "keywords": [ "equality", "equal", "compare" ], "author": { "name": "James Halliday", "email": "mail@substack.net", "url": "http://substack.net" }, "license": "MIT", "testling": { "files": "test/*.js", "browsers": { "ie": [ 6, 7, 8, 9 ], "ff": [ 3.5, 10, 15 ], "chrome": [ 10, 22 ], "safari": [ 5.1 ], "opera": [ 12 ] } } } node-deep-equal-1.0.1/readme.markdown000066400000000000000000000023641257041673700175000ustar00rootroot00000000000000# deep-equal Node's `assert.deepEqual() algorithm` as a standalone module. This module is around [5 times faster](https://gist.github.com/2790507) than wrapping `assert.deepEqual()` in a `try/catch`. [![browser support](https://ci.testling.com/substack/node-deep-equal.png)](https://ci.testling.com/substack/node-deep-equal) [![build status](https://secure.travis-ci.org/substack/node-deep-equal.png)](https://travis-ci.org/substack/node-deep-equal) # example ``` js var equal = require('deep-equal'); console.dir([ equal( { a : [ 2, 3 ], b : [ 4 ] }, { a : [ 2, 3 ], b : [ 4 ] } ), equal( { x : 5, y : [6] }, { x : 5, y : 6 } ) ]); ``` # methods ``` js var deepEqual = require('deep-equal') ``` ## deepEqual(a, b, opts) Compare objects `a` and `b`, returning whether they are equal according to a recursive equality algorithm. If `opts.strict` is `true`, use strict equality (`===`) to compare leaf nodes. The default is to use coercive equality (`==`) because that's how `assert.deepEqual()` works by default. # install With [npm](http://npmjs.org) do: ``` npm install deep-equal ``` # test With [npm](http://npmjs.org) do: ``` npm test ``` # license MIT. Derived largely from node's assert module. node-deep-equal-1.0.1/test/000077500000000000000000000000001257041673700154515ustar00rootroot00000000000000node-deep-equal-1.0.1/test/cmp.js000066400000000000000000000042311257041673700165660ustar00rootroot00000000000000var test = require('tape'); var equal = require('../'); var isArguments = require('../lib/is_arguments.js'); var objectKeys = require('../lib/keys.js'); test('equal', function (t) { t.ok(equal( { a : [ 2, 3 ], b : [ 4 ] }, { a : [ 2, 3 ], b : [ 4 ] } )); t.end(); }); test('not equal', function (t) { t.notOk(equal( { x : 5, y : [6] }, { x : 5, y : 6 } )); t.end(); }); test('nested nulls', function (t) { t.ok(equal([ null, null, null ], [ null, null, null ])); t.end(); }); test('strict equal', function (t) { t.notOk(equal( [ { a: 3 }, { b: 4 } ], [ { a: '3' }, { b: '4' } ], { strict: true } )); t.end(); }); test('non-objects', function (t) { t.ok(equal(3, 3)); t.ok(equal('beep', 'beep')); t.ok(equal('3', 3)); t.notOk(equal('3', 3, { strict: true })); t.notOk(equal('3', [3])); t.end(); }); test('arguments class', function (t) { t.ok(equal( (function(){return arguments})(1,2,3), (function(){return arguments})(1,2,3), "compares arguments" )); t.notOk(equal( (function(){return arguments})(1,2,3), [1,2,3], "differenciates array and arguments" )); t.end(); }); test('test the arguments shim', function (t) { t.ok(isArguments.supported((function(){return arguments})())); t.notOk(isArguments.supported([1,2,3])); t.ok(isArguments.unsupported((function(){return arguments})())); t.notOk(isArguments.unsupported([1,2,3])); t.end(); }); test('test the keys shim', function (t) { t.deepEqual(objectKeys.shim({ a: 1, b : 2 }), [ 'a', 'b' ]); t.end(); }); test('dates', function (t) { var d0 = new Date(1387585278000); var d1 = new Date('Fri Dec 20 2013 16:21:18 GMT-0800 (PST)'); t.ok(equal(d0, d1)); t.end(); }); test('buffers', function (t) { t.ok(equal(Buffer('xyz'), Buffer('xyz'))); t.end(); }); test('booleans and arrays', function (t) { t.notOk(equal(true, [])); t.end(); }) test('null == undefined', function (t) { t.ok(equal(null, undefined)) t.notOk(equal(null, undefined, { strict: true })) t.end() })