Comparing version 0.2.3 to 0.2.4
594
index.js
@@ -6,13 +6,13 @@ /** | ||
'use strict'; | ||
'use strict' | ||
// module variables | ||
var util = require('./lib/util'); | ||
exports.util = util; | ||
var util = require('./lib/util') | ||
exports.util = util | ||
var deepEqual = require('./lib/deepequal'); | ||
var deepEqual = require('./lib/deepequal') | ||
var OPEN = /\[["']|^\s*["']/; | ||
var CLOSE = /["']\]|["']\s*$/; | ||
var QUOTES = /^(["'])(.*)\1$/; | ||
var OPEN = /\[["']|^\s*["']/ | ||
var CLOSE = /["']\]|["']\s*$/ | ||
var QUOTES = /^(["'])(.*)\1$/ | ||
@@ -29,3 +29,3 @@ /** | ||
*/ | ||
exports.deepEqual = deepEqual; | ||
exports.deepEqual = deepEqual | ||
@@ -48,5 +48,5 @@ /** | ||
function isCircular (obj) { | ||
return _checkCircular({_visited: []}, obj); | ||
return _checkCircular({_visited: []}, obj) | ||
} | ||
exports.isCircular = isCircular; | ||
exports.isCircular = isCircular | ||
@@ -57,16 +57,16 @@ /** | ||
*/ | ||
function _checkCircular(opts, obj) { | ||
var key; | ||
if (util.isObject(obj)) { | ||
if (~opts._visited.indexOf(obj)) { | ||
return true; | ||
} | ||
opts._visited.push(obj); | ||
for (key in obj) { | ||
if (obj.hasOwnProperty(key) && _checkCircular(opts, obj[key])) { | ||
return true; | ||
} | ||
} | ||
} | ||
return false; | ||
function _checkCircular (opts, obj) { | ||
var key | ||
if (util.isObject(obj)) { | ||
if (~opts._visited.indexOf(obj)) { | ||
return true | ||
} | ||
opts._visited.push(obj) | ||
for (key in obj) { | ||
if (obj.hasOwnProperty(key) && _checkCircular(opts, obj[key])) { | ||
return true | ||
} | ||
} | ||
} | ||
return false | ||
} | ||
@@ -93,18 +93,18 @@ | ||
function extend (target) { | ||
var i, source, key; | ||
var i, source, key | ||
for (i = 1; i < arguments.length; i++) { | ||
source = arguments[i]; | ||
if (typeof source === 'object' && source) { | ||
for (key in source) { | ||
if (source.hasOwnProperty(key)) { | ||
target[key] = source[key]; | ||
} | ||
} | ||
} | ||
} | ||
return target; | ||
for (i = 1; i < arguments.length; i++) { | ||
source = arguments[i] | ||
if (typeof source === 'object' && source) { | ||
for (key in source) { | ||
if (source.hasOwnProperty(key)) { | ||
target[key] = source[key] | ||
} | ||
} | ||
} | ||
} | ||
return target | ||
} | ||
exports.extend = extend; | ||
exports.assign = extend; | ||
exports.extend = extend | ||
exports.assign = extend | ||
@@ -130,7 +130,7 @@ /** | ||
function merge () { | ||
var args = [].slice.call(arguments); | ||
args.unshift({}); | ||
return mergeExt.apply(null, args); | ||
var args = [].slice.call(arguments) | ||
args.unshift({}) | ||
return mergeExt.apply(null, args) | ||
} | ||
exports.merge = merge; | ||
exports.merge = merge | ||
@@ -159,15 +159,15 @@ /** | ||
function mergeExt (opts, target) { | ||
var visited = []; | ||
var visited = [] | ||
opts = opts || {}; | ||
opts._visited = visited; | ||
opts._count = 0; | ||
opts = opts || {} | ||
opts._visited = visited | ||
opts._count = 0 | ||
for (var i = 2; i < arguments.length; i++) { | ||
target = _merge(opts, target, arguments[i]); | ||
} | ||
for (var i = 2; i < arguments.length; i++) { | ||
target = _merge(opts, target, arguments[i]) | ||
} | ||
return target; | ||
return target | ||
} | ||
exports.mergeExt = mergeExt; | ||
exports.mergeExt = mergeExt | ||
@@ -183,127 +183,119 @@ /** | ||
*/ | ||
function _merge(opts, target, source) { | ||
var i, | ||
j, | ||
tmp, | ||
test, | ||
equal, | ||
key, | ||
s = { // hold booleans for source | ||
isObj: util.isObject(source), | ||
isFn: util.isFunction(source), | ||
isArr: util.isArray(source), | ||
}, | ||
t = { // hold booleans for target | ||
isObj: util.isObject(target), | ||
isFn: util.isFunction(target), | ||
isArr: util.isArray(target), | ||
}; | ||
function _merge (opts, target, source) { | ||
var i | ||
var j | ||
var tmp | ||
var test | ||
var equal | ||
var key | ||
var s = { // hold booleans for source | ||
isObj: util.isObject(source), | ||
isFn: util.isFunction(source), | ||
isArr: util.isArray(source) | ||
} | ||
var t = { // hold booleans for target | ||
isObj: util.isObject(target), | ||
isFn: util.isFunction(target), | ||
isArr: util.isArray(target) | ||
} | ||
if (!opts._visited) { | ||
opts._visited = []; | ||
} | ||
if (!opts._visited) { | ||
opts._visited = [] | ||
} | ||
if (target === source || // for primitives or null | ||
undefined === source // target stays the same | ||
){ | ||
return target; | ||
} | ||
if (target === source || // for primitives or null | ||
undefined === source // target stays the same | ||
) { | ||
return target | ||
} | ||
if (null === source) { | ||
if (!opts.ignoreNull || target === undefined) { | ||
target = source; | ||
} | ||
return target; | ||
} | ||
if (source === null) { | ||
if (!opts.ignoreNull || target === undefined) { | ||
target = source | ||
} | ||
return target | ||
} | ||
if (null === target || undefined === target) { | ||
if (s.isObj && s.isArr){ | ||
// clone into array | ||
target = _merge(opts, [], source); | ||
} | ||
else if (s.isObj) { | ||
// clone source | ||
target = _merge(opts, {}, source); | ||
} | ||
else { | ||
// copy primitives | ||
target = source; | ||
} | ||
return target; | ||
} | ||
if (target === null || undefined === target) { | ||
if (s.isObj && s.isArr) { | ||
// clone into array | ||
target = _merge(opts, [], source) | ||
} else if (s.isObj) { | ||
// clone source | ||
target = _merge(opts, {}, source) | ||
} else { | ||
// copy primitives | ||
target = source | ||
} | ||
return target | ||
} | ||
// create new instances for "special" objects | ||
if (s.isObj) { | ||
if (util.isRegExp(source)){ | ||
// create new RegExp | ||
target = new RegExp(source); | ||
return target; | ||
} | ||
else if (util.isDate(source)){ | ||
// create new Date | ||
target = new Date(source); | ||
return target; | ||
} | ||
else if (util.isBuffer(source)){ | ||
// create new Buffer | ||
target = new Buffer(source); | ||
return target; | ||
} | ||
} | ||
// create new instances for "special" objects | ||
if (s.isObj) { | ||
if (util.isRegExp(source)) { | ||
// create new RegExp | ||
target = new RegExp(source) | ||
return target | ||
} else if (util.isDate(source)) { | ||
// create new Date | ||
target = new Date(source) | ||
return target | ||
} else if (util.isBuffer(source)) { | ||
// create new Buffer | ||
target = new Buffer(source) | ||
return target | ||
} | ||
} | ||
if (s.isFn) { // replace with source function | ||
target = source; | ||
// TODO - clone possible keys | ||
return target; | ||
} | ||
if (s.isFn) { // replace with source function | ||
target = source | ||
// TODO - clone possible keys | ||
return target | ||
} | ||
if (s.isArr) { | ||
if (t.isArr) { | ||
test = [].concat(target); // test for duplicates | ||
for (i = 0; i < source.length; i++) { | ||
tmp = source[i]; | ||
if (! ~test.indexOf(tmp)) { | ||
if (!util.isObject(tmp) || null === tmp) { // primitive or function or null or undefined | ||
target.push(tmp); | ||
} | ||
else { | ||
equal = false; | ||
j = test.length; | ||
while (j-->0 && !(equal = deepEqual(test[j], tmp))); | ||
if (!equal) target.push( _merge(opts, null, tmp) ); | ||
} | ||
} | ||
} | ||
} | ||
else { | ||
// if target is not array replace with source | ||
target = _merge(opts, [], source); | ||
} | ||
return target; | ||
} | ||
if (s.isArr) { | ||
if (t.isArr) { | ||
test = [].concat(target) // test for duplicates | ||
for (i = 0; i < source.length; i++) { | ||
tmp = source[i] | ||
if (!~test.indexOf(tmp)) { | ||
if (!util.isObject(tmp) || tmp === null) { // primitive or function or null or undefined | ||
target.push(tmp) | ||
} else { | ||
equal = false | ||
j = test.length | ||
while (j-- > 0 && !(equal = deepEqual(test[j], tmp))); | ||
if (!equal) target.push(_merge(opts, null, tmp)) | ||
} | ||
} | ||
} | ||
} else { | ||
// if target is not array replace with source | ||
target = _merge(opts, [], source) | ||
} | ||
return target | ||
} | ||
if (!t.isFn && !t.isObj && !t.isArr){ | ||
// copy primitives | ||
target = source; | ||
return target; | ||
} | ||
if (!t.isFn && !t.isObj && !t.isArr) { | ||
// copy primitives | ||
target = source | ||
return target | ||
} | ||
// copy properties if not circular | ||
if ( ! ~opts._visited.indexOf(source) ){ | ||
opts._visited.push(source); | ||
for (key in source) { | ||
if( source.hasOwnProperty(key) ) { | ||
// copy properties if not circular | ||
if (!~opts._visited.indexOf(source)) { | ||
opts._visited.push(source) | ||
for (key in source) { | ||
if (source.hasOwnProperty(key)) { | ||
target[key] = _merge(opts, target[key], source[key]) | ||
} | ||
} | ||
opts._visited.pop() | ||
} else if (!opts.ignoreCircular) { | ||
throw new Error('can not merge circular structures.') | ||
} | ||
target[key] = _merge(opts, target[key], source[key]); | ||
} | ||
} | ||
opts._visited.pop(); | ||
} | ||
else if (!opts.ignoreCircular) { | ||
throw new Error('can not merge circular structures.'); | ||
} | ||
return target; | ||
return target | ||
} | ||
exports._merge = _merge; | ||
exports._merge = _merge | ||
@@ -328,5 +320,5 @@ /** | ||
function clone (obj) { | ||
return _merge({}, (util.isArray(obj) ? [] : {}), obj); | ||
return _merge({}, (util.isArray(obj) ? [] : {}), obj) | ||
} | ||
exports.clone = clone; | ||
exports.clone = clone | ||
@@ -340,25 +332,23 @@ /** | ||
function _segment (char) { | ||
var tmp; | ||
char = char || '.'; | ||
return function(k){ | ||
if (tmp) { | ||
tmp += char + k; | ||
if (CLOSE.test(k)) { | ||
k = tmp; | ||
tmp = ''; | ||
} | ||
else { | ||
return; | ||
} | ||
} | ||
else if (OPEN.test(k)) { | ||
tmp = k; | ||
if (CLOSE.test(k)) { | ||
tmp = ''; | ||
} else { | ||
return; | ||
} | ||
} | ||
return k.trim().replace(QUOTES, '$2'); | ||
}; | ||
var tmp | ||
char = char || '.' | ||
return function (k) { | ||
if (tmp) { | ||
tmp += char + k | ||
if (CLOSE.test(k)) { | ||
k = tmp | ||
tmp = '' | ||
} else { | ||
return | ||
} | ||
} else if (OPEN.test(k)) { | ||
tmp = k | ||
if (CLOSE.test(k)) { | ||
tmp = '' | ||
} else { | ||
return | ||
} | ||
} | ||
return k.trim().replace(QUOTES, '$2') | ||
} | ||
} | ||
@@ -373,26 +363,26 @@ | ||
function _splitPath (keys) { | ||
var out; | ||
var out | ||
if (util.isString(keys)) { | ||
out = []; | ||
keys | ||
.split('.') | ||
.map(_segment('.')) | ||
.forEach(function(k){ | ||
k = (k||' ').trim() | ||
.replace(/^([^\[]+)\[(["']?)(.+)\2\]$/, function(m, m1, m2, m3) { | ||
if (m1 && m3) { | ||
out.push(m1, m3); | ||
} | ||
return ''; | ||
}); | ||
if (k) { | ||
out.push(k); | ||
} | ||
}); | ||
keys = out; | ||
} | ||
return keys; | ||
if (util.isString(keys)) { | ||
out = [] | ||
keys | ||
.split('.') | ||
.map(_segment('.')) | ||
.forEach(function (k) { | ||
k = (k || ' ').trim() | ||
.replace(/^([^[]+)\[(["']?)(.+)\2\]$/, function (m, m1, m2, m3) { | ||
if (m1 && m3) { | ||
out.push(m1, m3) | ||
} | ||
return '' | ||
}) | ||
if (k) { | ||
out.push(k) | ||
} | ||
}) | ||
keys = out | ||
} | ||
return keys | ||
} | ||
exports._splitPath = _splitPath; | ||
exports._splitPath = _splitPath | ||
@@ -406,21 +396,21 @@ /** | ||
function _splitProps (props) { | ||
var test = {}; | ||
var test = {} | ||
if (util.isString(props)) { | ||
props = props | ||
.split(',') | ||
.map(_segment(',')) | ||
.filter(function(k){ | ||
return k; | ||
}); | ||
} | ||
if (util.isArray(props)) { | ||
props.forEach(function(key){ | ||
test[key] = 1; | ||
}); | ||
return test; | ||
} | ||
return {}; | ||
if (util.isString(props)) { | ||
props = props | ||
.split(',') | ||
.map(_segment(',')) | ||
.filter(function (k) { | ||
return k | ||
}) | ||
} | ||
if (util.isArray(props)) { | ||
props.forEach(function (key) { | ||
test[key] = 1 | ||
}) | ||
return test | ||
} | ||
return {} | ||
} | ||
exports._splitProps = _splitProps; | ||
exports._splitProps = _splitProps | ||
@@ -447,18 +437,19 @@ /** | ||
function pick (obj, props) { | ||
var key, | ||
val, | ||
out, | ||
test = _splitProps(props); | ||
var key | ||
var val | ||
var out | ||
var test = _splitProps(props) | ||
if (util.isObject(obj)) { | ||
out = {}; | ||
for (key in test) { | ||
if ((val = get(obj, key)) != undefined) { // jshint ignore:line | ||
set(out, key, val); | ||
} | ||
} | ||
} | ||
return out; | ||
if (util.isObject(obj)) { | ||
out = {} | ||
for (key in test) { | ||
val = get(obj, key) | ||
if (val !== undefined && val !== null) { | ||
set(out, key, val) | ||
} | ||
} | ||
} | ||
return out | ||
} | ||
exports.pick = pick; | ||
exports.pick = pick | ||
@@ -485,17 +476,17 @@ /** | ||
function omit (obj, props) { | ||
var key, | ||
out, | ||
test = _splitProps(props); | ||
var key | ||
var out | ||
var test = _splitProps(props) | ||
if (util.isObject(obj)) { | ||
out = clone(obj); | ||
for (key in test) { | ||
if ((get(obj, key))) { | ||
set(out, key, null); | ||
} | ||
} | ||
} | ||
return out; | ||
if (util.isObject(obj)) { | ||
out = clone(obj) | ||
for (key in test) { | ||
if ((get(obj, key))) { | ||
set(out, key, null) | ||
} | ||
} | ||
} | ||
return out | ||
} | ||
exports.omit = omit; | ||
exports.omit = omit | ||
@@ -524,25 +515,24 @@ /** | ||
*/ | ||
function get(obj, keys, _default) { | ||
var i, | ||
key, | ||
tmp = obj || {}; | ||
function get (obj, keys, _default) { | ||
var i | ||
var key | ||
var tmp = obj || {} | ||
keys = _splitPath(keys); | ||
keys = _splitPath(keys) | ||
if (!keys || keys.length === 0) { | ||
return _default; | ||
} | ||
if (!keys || keys.length === 0) { | ||
return _default | ||
} | ||
for (i=0; i<keys.length; i++) { | ||
key = keys[i]; | ||
if (tmp && tmp.hasOwnProperty(key)) { | ||
tmp = tmp[key]; | ||
} | ||
else { | ||
return _default; | ||
} | ||
} | ||
return tmp; | ||
for (i = 0; i < keys.length; i++) { | ||
key = keys[i] | ||
if (tmp && tmp.hasOwnProperty(key)) { | ||
tmp = tmp[key] | ||
} else { | ||
return _default | ||
} | ||
} | ||
return tmp | ||
} | ||
exports.get = get; | ||
exports.get = get | ||
@@ -553,3 +543,3 @@ /** | ||
*/ | ||
exports.select = get; | ||
exports.select = get | ||
@@ -576,32 +566,32 @@ /** | ||
*/ | ||
function set(obj, keys, value) { | ||
var i, | ||
key, | ||
last, | ||
tmp = obj || {}; | ||
function set (obj, keys, value) { | ||
var i | ||
var key | ||
var last | ||
var tmp = obj || {} | ||
keys = _splitPath(keys); | ||
keys = _splitPath(keys) | ||
if (!keys || keys.length === 0) { | ||
return; | ||
} | ||
if (!keys || keys.length === 0) { | ||
return | ||
} | ||
last = keys.pop(); | ||
last = keys.pop() | ||
for (i=0; i<keys.length; i++) { | ||
key = keys[i]; | ||
if (!tmp[key]) { | ||
tmp[key] = {}; | ||
} | ||
if (tmp.hasOwnProperty(key)) { | ||
tmp = tmp[key]; | ||
} | ||
} | ||
if (value === null) { | ||
delete(tmp[last]); | ||
} else { | ||
tmp[last] = value; | ||
} | ||
return obj; | ||
for (i = 0; i < keys.length; i++) { | ||
key = keys[i] | ||
if (!tmp[key]) { | ||
tmp[key] = {} | ||
} | ||
if (tmp.hasOwnProperty(key)) { | ||
tmp = tmp[key] | ||
} | ||
} | ||
if (value === null) { | ||
delete (tmp[last]) | ||
} else { | ||
tmp[last] = value | ||
} | ||
return obj | ||
} | ||
exports.set = set; | ||
exports.set = set |
@@ -0,1 +1,2 @@ | ||
/* eslint eqeqeq:0 one-var:0 */ | ||
/** | ||
@@ -30,6 +31,6 @@ * @module deepequal.js | ||
'use strict'; | ||
'use strict' | ||
// can't use standard util here as required functions are missing in node < 0.11 | ||
var util = require('./util'); | ||
var util = require('./util') | ||
@@ -42,50 +43,49 @@ /** | ||
*/ | ||
function deepEqual(actual, expected) { | ||
// 7.1. All identical values are equivalent, as determined by ===. | ||
if (actual === expected) { | ||
return true; | ||
function deepEqual (actual, expected) { | ||
// 7.1. All identical values are equivalent, as determined by ===. | ||
if (actual === expected) { | ||
return true | ||
} else if (util.isBuffer(actual) && util.isBuffer(expected)) { | ||
if (actual.length != expected.length) return false | ||
} else if (util.isBuffer(actual) && util.isBuffer(expected)) { | ||
if (actual.length != expected.length) return false; | ||
for (var i = 0; i < actual.length; i++) { | ||
if (actual[i] !== expected[i]) return false | ||
} | ||
for (var i = 0; i < actual.length; i++) { | ||
if (actual[i] !== expected[i]) return false; | ||
} | ||
return true | ||
return true; | ||
// 7.2. If the expected value is a Date object, the actual value is | ||
// equivalent if it is also a Date object that refers to the same time. | ||
} else if (util.isDate(actual) && util.isDate(expected)) { | ||
return actual.getTime() === expected.getTime() | ||
// 7.2. If the expected value is a Date object, the actual value is | ||
// equivalent if it is also a Date object that refers to the same time. | ||
} else if (util.isDate(actual) && util.isDate(expected)) { | ||
return actual.getTime() === expected.getTime(); | ||
// 7.3 If the expected value is a RegExp object, the actual value is | ||
// equivalent if it is also a RegExp object with the same source and | ||
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). | ||
} else if (util.isRegExp(actual) && util.isRegExp(expected)) { | ||
return actual.source === expected.source && | ||
actual.global === expected.global && | ||
actual.multiline === expected.multiline && | ||
actual.lastIndex === expected.lastIndex && | ||
actual.ignoreCase === expected.ignoreCase | ||
// 7.3 If the expected value is a RegExp object, the actual value is | ||
// equivalent if it is also a RegExp object with the same source and | ||
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). | ||
} else if (util.isRegExp(actual) && util.isRegExp(expected)) { | ||
return actual.source === expected.source && | ||
actual.global === expected.global && | ||
actual.multiline === expected.multiline && | ||
actual.lastIndex === expected.lastIndex && | ||
actual.ignoreCase === expected.ignoreCase; | ||
// 7.4. Other pairs that do not both pass typeof value == 'object', | ||
// equivalence is determined by ==. | ||
} else if (!util.isObject(actual) && !util.isObject(expected)) { | ||
return actual == expected | ||
// 7.4. Other pairs that do not both pass typeof value == 'object', | ||
// equivalence is determined by ==. | ||
} else if (!util.isObject(actual) && !util.isObject(expected)) { | ||
return actual == expected; | ||
// 7.5 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); | ||
} | ||
// 7.5 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) | ||
} | ||
} | ||
module.exports = deepEqual; | ||
module.exports = deepEqual | ||
function isArguments(object) { | ||
return Object.prototype.toString.call(object) == '[object Arguments]'; | ||
function isArguments (object) { | ||
return Object.prototype.toString.call(object) == '[object Arguments]' | ||
} | ||
@@ -96,46 +96,48 @@ | ||
*/ | ||
function _objEquiv(a, b) { | ||
var ka, kb, key, i; | ||
function _objEquiv (a, b) { | ||
var ka, kb, key, i | ||
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b)) | ||
return false; | ||
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(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. | ||
var aIsArgs = isArguments(a), | ||
bIsArgs = isArguments(b); | ||
if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) | ||
return false; | ||
if (aIsArgs) { | ||
a = Array.prototype.slice.call(a); | ||
b = Array.prototype.slice.call(b); | ||
return deepEqual(a, b); | ||
} | ||
try { | ||
ka = Object.keys(a); | ||
kb = Object.keys(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])) return false; | ||
} | ||
return true; | ||
// 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. | ||
var aIsArgs = isArguments(a), | ||
bIsArgs = isArguments(b) | ||
if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) { | ||
return false | ||
} | ||
if (aIsArgs) { | ||
a = Array.prototype.slice.call(a) | ||
b = Array.prototype.slice.call(b) | ||
return deepEqual(a, b) | ||
} | ||
try { | ||
ka = Object.keys(a) | ||
kb = Object.keys(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])) return false | ||
} | ||
return true | ||
} |
@@ -27,71 +27,71 @@ /** | ||
'use strict'; | ||
'use strict' | ||
// NOTE: These type checking functions intentionally don't use `instanceof` | ||
// because it is fragile and can be easily faked with `Object.create()`. | ||
var isArray = exports.isArray = Array.isArray; | ||
exports.isArray = isArray; | ||
var isArray = exports.isArray = Array.isArray | ||
exports.isArray = isArray | ||
function isBoolean(arg) { | ||
return typeof arg === 'boolean'; | ||
function isBoolean (arg) { | ||
return typeof arg === 'boolean' | ||
} | ||
exports.isBoolean = isBoolean; | ||
exports.isBoolean = isBoolean | ||
function isNull(arg) { | ||
return arg === null; | ||
function isNull (arg) { | ||
return arg === null | ||
} | ||
exports.isNull = isNull; | ||
exports.isNull = isNull | ||
function isNullOrUndefined(arg) { | ||
return arg == null; // jshint ignore:line | ||
function isNullOrUndefined (arg) { | ||
return arg == null // jshint ignore:line | ||
} | ||
exports.isNullOrUndefined = isNullOrUndefined; | ||
exports.isNullOrUndefined = isNullOrUndefined | ||
function isNumber(arg) { | ||
return typeof arg === 'number'; | ||
function isNumber (arg) { | ||
return typeof arg === 'number' | ||
} | ||
exports.isNumber = isNumber; | ||
exports.isNumber = isNumber | ||
function isString(arg) { | ||
return typeof arg === 'string'; | ||
function isString (arg) { | ||
return typeof arg === 'string' | ||
} | ||
exports.isString = isString; | ||
exports.isString = isString | ||
function isSymbol(arg) { | ||
return typeof arg === 'symbol'; // jshint ignore:line | ||
function isSymbol (arg) { | ||
return typeof arg === 'symbol' // jshint ignore:line | ||
} | ||
exports.isSymbol = isSymbol; | ||
exports.isSymbol = isSymbol | ||
function isUndefined(arg) { | ||
return arg === void 0; | ||
function isUndefined (arg) { | ||
return arg === void 0 | ||
} | ||
exports.isUndefined = isUndefined; | ||
exports.isUndefined = isUndefined | ||
function isRegExp(re) { | ||
return isObject(re) && objectToString(re) === '[object RegExp]'; | ||
function isRegExp (re) { | ||
return isObject(re) && objectToString(re) === '[object RegExp]' | ||
} | ||
exports.isRegExp = isRegExp; | ||
exports.isRegExp = isRegExp | ||
function isObject(arg) { | ||
return typeof arg === 'object' && arg !== null; | ||
function isObject (arg) { | ||
return typeof arg === 'object' && arg !== null | ||
} | ||
exports.isObject = isObject; | ||
exports.isObject = isObject | ||
function isDate(d) { | ||
return isObject(d) && objectToString(d) === '[object Date]'; | ||
function isDate (d) { | ||
return isObject(d) && objectToString(d) === '[object Date]' | ||
} | ||
exports.isDate = isDate; | ||
exports.isDate = isDate | ||
function isError(e) { | ||
function isError (e) { | ||
return isObject(e) && | ||
(objectToString(e) === '[object Error]' || e instanceof Error); | ||
(objectToString(e) === '[object Error]' || e instanceof Error) | ||
} | ||
exports.isError = isError; | ||
exports.isError = isError | ||
function isFunction(arg) { | ||
return typeof arg === 'function'; | ||
function isFunction (arg) { | ||
return typeof arg === 'function' | ||
} | ||
exports.isFunction = isFunction; | ||
exports.isFunction = isFunction | ||
function isPrimitive(arg) { | ||
function isPrimitive (arg) { | ||
return arg === null || | ||
@@ -101,14 +101,14 @@ typeof arg === 'boolean' || | ||
typeof arg === 'string' || | ||
typeof arg === 'symbol' || /* ES6 symbol*/ // jshint ignore:line | ||
typeof arg === 'undefined'; | ||
typeof arg === 'symbol' || /* ES6 symbol */ // jshint ignore:line | ||
typeof arg === 'undefined' | ||
} | ||
exports.isPrimitive = isPrimitive; | ||
exports.isPrimitive = isPrimitive | ||
function isBuffer(arg) { | ||
return arg instanceof Buffer; | ||
function isBuffer (arg) { | ||
return arg instanceof Buffer | ||
} | ||
exports.isBuffer = isBuffer; | ||
exports.isBuffer = isBuffer | ||
function objectToString(o) { | ||
return Object.prototype.toString.call(o); | ||
function objectToString (o) { | ||
return Object.prototype.toString.call(o) | ||
} |
{ | ||
"name": "mergee", | ||
"description": "Utilities for objects", | ||
"version": "0.2.3", | ||
"version": "0.2.4", | ||
"main": "index.js", | ||
@@ -15,3 +15,3 @@ "engines": { | ||
"devDependencies": { | ||
"mocha": "~2.2.5" | ||
"mocha": "~3.2.0" | ||
}, | ||
@@ -21,3 +21,3 @@ "scripts": { | ||
"cover": "istanbul cover _mocha --report lcov --report text -- -R dot --check-leaks test/*.mocha.js", | ||
"lint": "jshint --show-non-errors *.js */*.js", | ||
"lint": "eslint '*.js' '**/*.js'", | ||
"doc": "mkdir -p doc && jsdox -o doc index.js", | ||
@@ -42,3 +42,10 @@ "clean": "rm -rf doc coverage" | ||
}, | ||
"homepage": "https://github.com/commenthol/mergee" | ||
"homepage": "https://github.com/commenthol/mergee", | ||
"eslintConfig": { | ||
"extends": "standard", | ||
"plugins": [ | ||
"standard" | ||
], | ||
"rules": {} | ||
} | ||
} |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
32005
6
755
1