package/package.json000664 001750 001750 00000004603 13006511720 013137 0ustar00000000 000000 { "name": "deep-eql", "description": "Improved deep equality testing for Node.js and the browser.", "keywords": [ "chai util", "deep equal", "object equal", "testing" ], "license": "MIT", "author": "Jake Luer ", "contributors": [ "Keith Cirkel (https://github.com/keithamus)", "dougluce (https://github.com/dougluce)", "Lorenz Leutgeb (https://github.com/flowlo)" ], "main": "./index", "files": [ "index.js", "deep-eql.js" ], "repository": { "type": "git", "url": "git@github.com:chaijs/deep-eql.git" }, "scripts": { "bench": "node bench", "build": "browserify $npm_pakcage_main --standalone deepEqual -o deep-eql.js", "lint": "eslint --ignore-path .gitignore .", "prepublish": "npm run build", "semantic-release": "semantic-release pre && npm publish && semantic-release post", "pretest": "npm run lint", "test": "npm run test:node && npm run test:browser", "test:node": "istanbul cover _mocha", "test:browser": "karma start --singleRun=true", "watch": "karma start --auto-watch --singleRun=false", "upload-coverage": "lcov-result-merger 'coverage/**/lcov.info' | coveralls; exit 0" }, "config": { "ghooks": { "commit-msg": "validate-commit-msg" } }, "eslintConfig": { "extends": [ "strict/es5" ], "rules": { "complexity": 0, "spaced-comment": 0, "no-use-before-define": 0 } }, "dependencies": { "type-detect": "^3.0.0" }, "devDependencies": { "benchmark": "^2.1.0", "browserify": "^13.0.0", "browserify-istanbul": "^1.0.0", "component": "*", "coveralls": "2.11.8", "eslint": "^2.4.0", "eslint-config-strict": "^8.5.0", "eslint-plugin-filenames": "^0.2.0", "ghooks": "^1.0.1", "istanbul": "^0.4.2", "karma": "^0.13.22", "karma-browserify": "^5.0.2", "karma-coverage": "^0.5.5", "karma-mocha": "^0.2.2", "karma-phantomjs-launcher": "^1.0.0", "karma-sauce-launcher": "^0.3.1", "kewlr": "^0.3.1", "lcov-result-merger": "^1.0.2", "lodash.isequal": "^4.4.0", "mocha": "^3.1.2", "phantomjs-prebuilt": "^2.1.5", "semantic-release": "^4.3.5", "simple-assert": "^1.0.0", "travis-after-all": "^1.4.4", "validate-commit-msg": "^2.3.1", "watchify": "^3.7.0" }, "engines": { "node": ">=0.12" }, "version": "2.0.0" }package/README.md000664 001750 001750 00000010156 13006511341 012127 0ustar00000000 000000

ChaiJS deep-eql

Improved deep equality testing for [node](http://nodejs.org) and the browser.

license:mit tag:? build:? coverage:? code quality:? dependencies:? devDependencies:?
Selenium Test Status
Join the Slack chat Join the Gitter chat

## What is Deep-Eql? Deep Eql is a module which you can use to determine if two objects are "deeply" equal - that is, rather than having referential equality (`a === b`), this module checks an object's keys recursively, until it finds primitives to check for referential equality. For more on equality in JavaScript, read [the comparison operators article on mdn](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators). As an example, take the following: ```js 1 === 1 // These are primitives, they hold the same reference - they are strictly equal 1 == '1' // These are two different primitives, through type coercion they hold the same value - they are loosely equal { a: 1 } !== { a: 1 } // These are two different objects, they hold different references and so are not strictly equal - even though they hold the same values inside { a: 1 } != { a: 1 } // They have the same type, meaning loose equality performs the same check as strict equality - they are still not equal. deepEql({ a: 1 }, { a: 1 }) === true // deepEql can determine that they share the same keys and those keys share the same values, therefore they are deeply equal! ``` ## Installation ### Node.js `deep-eql` is available on [npm](http://npmjs.org). $ npm install deep-eql ## Usage The primary export of `deep-eql` is function that can be given two objects to compare. It will always return a boolean which can be used to determine if two objects are deeply equal. ### Rules - Strict equality for non-traversable nodes according to [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). - `eql(NaN, NaN).should.be.true;` - `eql(-0, +0).should.be.false;` - All own and inherited enumerable properties are considered: - `eql(Object.create({ foo: { a: 1 } }), Object.create({ foo: { a: 1 } })).should.be.true;` - `eql(Object.create({ foo: { a: 1 } }), Object.create({ foo: { a: 2 } })).should.be.false;` - Arguments are not Arrays: - `eql([], arguments).should.be.false;` - `eql([], Array.prototype.slice.call(arguments)).should.be.true;` package/LICENSE000664 001750 001750 00000002125 13006511341 011652 0ustar00000000 000000 Copyright (c) 2013 Jake Luer (http://alogicalparadox.com) 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. package/index.js000664 001750 001750 00000032744 13006511341 012324 0ustar00000000 000000 'use strict'; /* globals Symbol: true, Uint8Array: true, WeakMap: true */ /*! * deep-eql * Copyright(c) 2013 Jake Luer * MIT Licensed */ /*! * Module dependencies */ var type = require('type-detect'); function FakeMap() { this.clear(); } FakeMap.prototype = { clear: function clearMap() { this.keys = []; this.values = []; return this; }, set: function setMap(key, value) { var index = this.keys.indexOf(key); if (index >= 0) { this.values[index] = value; } else { this.keys.push(key); this.values.push(value); } return this; }, get: function getMap(key) { return this.values[this.keys.indexOf(key)]; }, delete: function deleteMap(key) { var index = this.keys.indexOf(key); if (index >= 0) { this.values = this.values.slice(0, index).concat(this.values.slice(index + 1)); this.keys = this.keys.slice(0, index).concat(this.keys.slice(index + 1)); } return this; }, }; var MemoizeMap = null; if (typeof WeakMap === 'function') { MemoizeMap = WeakMap; } else { MemoizeMap = FakeMap; } /*! * Check to see if the MemoizeMap has recorded a result of the two operands * * @param {Mixed} leftHandOperand * @param {Mixed} rightHandOperand * @param {MemoizeMap} memoizeMap * @returns {Boolean|null} result */ function memoizeCompare(leftHandOperand, rightHandOperand, memoizeMap) { if (!memoizeMap) { return null; } var leftHandMap = memoizeMap.get(leftHandOperand); if (leftHandMap) { var result = leftHandMap.get(rightHandOperand); if (typeof result === 'boolean') { return result; } } return null; } /*! * Set the result of the equality into the MemoizeMap * * @param {Mixed} leftHandOperand * @param {Mixed} rightHandOperand * @param {MemoizeMap} memoizeMap * @param {Boolean} result */ function memoizeSet(leftHandOperand, rightHandOperand, memoizeMap, result) { if (!memoizeMap || typeof leftHandOperand !== 'object' || typeof rightHandOperand !== 'object') { return; } var leftHandMap = memoizeMap.get(leftHandOperand); if (leftHandMap) { leftHandMap.set(rightHandOperand, result); } else { leftHandMap = new MemoizeMap(); leftHandMap.set(rightHandOperand, result); memoizeMap.set(leftHandOperand, leftHandMap); } } /*! * Primary Export */ module.exports = deepEqual; module.exports.MemoizeMap = MemoizeMap; /** * Assert deeply nested sameValue equality between two objects of any type. * * @param {Mixed} leftHandOperand * @param {Mixed} rightHandOperand * @param {Object} [options] (optional) Additional options * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality. * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular references to blow the stack. * @return {Boolean} equal match */ function deepEqual(leftHandOperand, rightHandOperand, options) { // Equal references (except for Numbers) can be returned early if (leftHandOperand === rightHandOperand) { // Handle +-0 cases return leftHandOperand !== 0 || 1 / leftHandOperand === 1 / rightHandOperand; } // handle NaN cases if ( leftHandOperand !== leftHandOperand && // eslint-disable-line no-self-compare rightHandOperand !== rightHandOperand // eslint-disable-line no-self-compare ) { return true; } // Primitives/null/undefined can be checked for referential equality; returning early if ( typeof leftHandOperand !== 'object' || leftHandOperand === null || leftHandOperand === undefined // eslint-disable-line no-undefined ) { return leftHandOperand === rightHandOperand; } // Deeper comparisons are pushed through to a larger function return extensiveDeepEqual(leftHandOperand, rightHandOperand, options); } /*! * The main logic of the `deepEqual` function. * * @param {Mixed} leftHandOperand * @param {Mixed} rightHandOperand * @param {Object} [options] (optional) Additional options * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality. * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular references to blow the stack. * @return {Boolean} equal match */ function extensiveDeepEqual(leftHandOperand, rightHandOperand, options) { options = options || {}; options.memoize = options.memoize === false ? false : options.memoize || new MemoizeMap(); var comparator = options && options.comparator; var memoizeResult = memoizeCompare(leftHandOperand, rightHandOperand, options.memoize); if (memoizeResult !== null) { return memoizeResult; } var comparatorResult = comparator && comparator(leftHandOperand, rightHandOperand); if (comparatorResult === false || comparatorResult === true) { memoizeSet(leftHandOperand, rightHandOperand, options.memoize, comparatorResult); memoizeSet(rightHandOperand, leftHandOperand, options.memoize, comparatorResult); return comparatorResult; } var leftHandType = type(leftHandOperand); if (leftHandType !== type(rightHandOperand)) { memoizeSet(leftHandOperand, rightHandOperand, options.memoize, false); memoizeSet(rightHandOperand, leftHandOperand, options.memoize, false); return false; } // Temporarily set the operands in the memoize object to prevent blowing the stack memoizeSet(leftHandOperand, rightHandOperand, options.memoize, true); memoizeSet(rightHandOperand, leftHandOperand, options.memoize, true); var result = extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options); memoizeSet(leftHandOperand, rightHandOperand, options.memoize, result); memoizeSet(rightHandOperand, leftHandOperand, options.memoize, result); return result; } function extensiveDeepEqualByType(leftHandOperand, rightHandOperand, leftHandType, options) { switch (leftHandType) { case 'String': case 'Number': case 'Boolean': case 'Date': // If these types are their instance types (e.g. `new Number`) then re-deepEqual against their values return deepEqual(leftHandOperand.valueOf(), rightHandOperand.valueOf()); case 'Promise': case 'Symbol': case 'function': case 'WeakMap': case 'WeakSet': case 'Error': return leftHandOperand === rightHandOperand; case 'Arguments': case 'Int8Array': case 'Uint8Array': case 'Uint8ClampedArray': case 'Int16Array': case 'Uint16Array': case 'Int32Array': case 'Uint32Array': case 'Float32Array': case 'Float64Array': case 'Array': return iterableEqual(leftHandOperand, rightHandOperand, options); case 'RegExp': return regexpEqual(leftHandOperand, rightHandOperand); case 'Generator': return generatorEqual(leftHandOperand, rightHandOperand, options); case 'DataView': return iterableEqual(new Uint8Array(leftHandOperand.buffer), new Uint8Array(rightHandOperand.buffer), options); case 'ArrayBuffer': return iterableEqual(new Uint8Array(leftHandOperand), new Uint8Array(rightHandOperand), options); case 'Set': return entriesEqual(leftHandOperand, rightHandOperand, options); case 'Map': return entriesEqual(leftHandOperand, rightHandOperand, options); default: return objectEqual(leftHandOperand, rightHandOperand, options); } } /*! * Compare two Regular Expressions for equality. * * @param {RegExp} leftHandOperand * @param {RegExp} rightHandOperand * @return {Boolean} result */ function regexpEqual(leftHandOperand, rightHandOperand) { return leftHandOperand.toString() === rightHandOperand.toString(); } /*! * Compare two Sets/Maps for equality. Faster than other equality functions. * * @param {Set} leftHandOperand * @param {Set} rightHandOperand * @param {Object} [options] (Optional) * @return {Boolean} result */ function entriesEqual(leftHandOperand, rightHandOperand, options) { // IE11 doesn't support Set#entries or Set#@@iterator, so we need manually populate using Set#forEach if (leftHandOperand.size !== rightHandOperand.size) { return false; } if (leftHandOperand.size === 0) { return true; } var leftHandItems = []; var rightHandItems = []; leftHandOperand.forEach(function gatherEntries(key, value) { leftHandItems.push([ key, value ]); }); rightHandOperand.forEach(function gatherEntries(key, value) { rightHandItems.push([ key, value ]); }); return iterableEqual(leftHandItems.sort(), rightHandItems.sort(), options); } /*! * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers. * * @param {Iterable} leftHandOperand * @param {Iterable} rightHandOperand * @param {Object} [options] (Optional) * @return {Boolean} result */ function iterableEqual(leftHandOperand, rightHandOperand, options) { var length = leftHandOperand.length; if (length !== rightHandOperand.length) { return false; } if (length === 0) { return true; } var index = -1; while (++index < length) { if (deepEqual(leftHandOperand[index], rightHandOperand[index], options) === false) { return false; } } return true; } /*! * Simple equality for generator objects such as those returned by generator functions. * * @param {Iterable} leftHandOperand * @param {Iterable} rightHandOperand * @param {Object} [options] (Optional) * @return {Boolean} result */ function generatorEqual(leftHandOperand, rightHandOperand, options) { return iterableEqual(getGeneratorEntries(leftHandOperand), getGeneratorEntries(rightHandOperand), options); } /*! * Determine if the given object has an @@iterator function. * * @param {Object} target * @return {Boolean} `true` if the object has an @@iterator function. */ function hasIteratorFunction(target) { return typeof Symbol !== 'undefined' && typeof target === 'object' && typeof Symbol.iterator !== 'undefined' && typeof target[Symbol.iterator] === 'function'; } /*! * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array. * This will consume the iterator - which could have side effects depending on the @@iterator implementation. * * @param {Object} target * @returns {Array} an array of entries from the @@iterator function */ function getIteratorEntries(target) { if (hasIteratorFunction(target)) { try { return getGeneratorEntries(target[Symbol.iterator]()); } catch (iteratorError) { return []; } } return []; } /*! * Gets all entries from a Generator. This will consume the generator - which could have side effects. * * @param {Generator} target * @returns {Array} an array of entries from the Generator. */ function getGeneratorEntries(generator) { var generatorResult = generator.next(); var accumulator = [ generatorResult.value ]; while (generatorResult.done === false) { generatorResult = generator.next(); accumulator.push(generatorResult.value); } return accumulator; } /*! * Gets all own and inherited enumerable keys from a target. * * @param {Object} target * @returns {Array} an array of own and inherited enumerable keys from the target. */ function getEnumerableKeys(target) { var keys = []; for (var key in target) { keys.push(key); } return keys; } /*! * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of * each key. If any value of the given key is not equal, the function will return false (early). * * @param {Mixed} leftHandOperand * @param {Mixed} rightHandOperand * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against * @param {Object} [options] (Optional) * @return {Boolean} result */ function keysEqual(leftHandOperand, rightHandOperand, keys, options) { var length = keys.length; if (length === 0) { return true; } for (var i = 0; i < length; i += 1) { if (deepEqual(leftHandOperand[keys[i]], rightHandOperand[keys[i]], options) === false) { return false; } } return true; } /*! * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual` * for each enumerable key in the object. * * @param {Mixed} leftHandOperand * @param {Mixed} rightHandOperand * @param {Object} [options] (Optional) * @return {Boolean} result */ function objectEqual(leftHandOperand, rightHandOperand, options) { var leftHandKeys = getEnumerableKeys(leftHandOperand); var rightHandKeys = getEnumerableKeys(rightHandOperand); if (leftHandKeys.length && leftHandKeys.length === rightHandKeys.length) { leftHandKeys.sort(); rightHandKeys.sort(); if (iterableEqual(leftHandKeys, rightHandKeys) === false) { return false; } return keysEqual(leftHandOperand, rightHandOperand, leftHandKeys, options); } var leftHandEntries = getIteratorEntries(leftHandOperand); var rightHandEntries = getIteratorEntries(rightHandOperand); if (leftHandEntries.length && leftHandEntries.length === rightHandEntries.length) { leftHandEntries.sort(); rightHandEntries.sort(); return iterableEqual(leftHandEntries, rightHandEntries, options); } if (leftHandKeys.length === 0 && leftHandEntries.length === 0 && rightHandKeys.length === 0 && rightHandEntries.length === 0) { return true; } return false; }