clear

node_modules/deap/test/clone.test.js

@@ -0,0 +1,240 @@
+var lib = require('../lib/deap'),
+	assert = require('chai').assert;
+
+describe('shallow clone', function() {
+	var shallow = lib.cloneShallow;
+
+	it('should not return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			result = shallow(a);
+
+		assert.notStrictEqual(result, a);
+	});
+
+	it('should copy simple values', function() {
+		var a = { s: 'string', n: 1, b: false, a: [], o: {}},
+			b = shallow(a);
+
+		assert.deepEqual(b, a);
+		assert.equal(b.s, a.s);
+		assert.equal(b.n, a.n);
+		assert.equal(b.b, a.b);
+		assert.strictEqual(b.a, a.a);
+		assert.strictEqual(b.o, a.o);
+	});
+
+	it('should preserve object references', function() {
+		var deep = { foo: 'bar' },
+			a = { burp: 'adurp' , nested: deep },
+			result = shallow(a);
+
+		assert.strictEqual(result.nested, deep);
+	});
+
+	it('should preserve date references', function() {
+		var a = { burp: 'adurp', date: new Date() },
+			date = a.date;
+
+		var result = shallow(a);
+
+		assert.strictEqual(result.date, date);
+	});
+
+	it('should preserve regexp references', function() {
+		var a = { burp: 'adurp', regexp: /foo/g },
+			regexp = a.regexp;
+
+		var result = shallow(a);
+
+		assert.strictEqual(result.regexp, regexp);
+	});
+
+	it('should preserve array references', function() {
+		var a = { burp: 'adurp', array: [] },
+			array = a.array;
+
+		var result = shallow(a);
+
+		assert.strictEqual(result.array, array);
+	});
+
+	it('should clone Date objects', function() {
+		var a = new Date();
+
+		var result = shallow(a);
+
+		assert.equal(result.toString(), a.toString());
+		assert.notStrictEqual(result, a);
+	});
+
+	it('should clone RegExp objects', function() {
+		var a = /foo/;
+
+		var result = shallow(a);
+
+		assert.equal(result.toString(), a.toString());
+		assert.notStrictEqual(result, a);
+	});
+
+	it('should work for multiple arguments', function() {
+		var a = { doom: 'song' },
+			b = { burp: 'adurp' },
+			c = { grr: { doh: 'argh' } };
+
+		var result = shallow(a, b, c);
+
+		assert.deepEqual(a, { doom: 'song' });
+		assert.deepEqual(b, { burp: 'adurp' });
+		assert.deepEqual(c, { grr: { doh: 'argh' } });
+		assert.sameMembers(Object.keys(result), ['doom', 'burp', 'grr']);
+		assert.equal(result.doom, a.doom);
+		assert.equal(result.burp, b.burp);
+		assert.deepEqual(result.grr, c.grr);
+		assert.strictEqual(result.grr, c.grr);
+	});
+
+	describe('on an array', function() {
+
+		it('should preserve references', function() {
+			var a = ['string', 1, false, [], {}];
+
+			var result = shallow(a);
+
+			assert.deepEqual(result, a);
+			assert.equal(result[0], a[0]);
+			assert.equal(result[1], a[1]);
+			assert.equal(result[2], a[2]);
+			assert.strictEqual(result[3], a[3]);
+			assert.strictEqual(result[4], a[4]);
+		});
+
+	});
+
+});
+
+
+describe('clone', function() {
+	var clone = lib.clone;
+
+	it('should not return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			result = clone(a);
+
+		assert.notStrictEqual(result, a);
+	});
+
+	it('should copy simple values', function() {
+		var a = { s: 'string', n: 1, b: false, a: [], o: {}},
+			b = clone(a);
+
+		assert.deepEqual(b, a);
+		assert.equal(b.s, a.s);
+		assert.equal(b.n, a.n);
+		assert.equal(b.b, a.b);
+		assert.deepEqual(b.a, a.a);
+		assert.deepEqual(b.o, a.o);
+	});
+
+	it('should not preserve object references', function() {
+		var deeper = { boo: 'far' },
+			deep = { foo: 'bar', nested: deeper },
+			a = { burp: 'adurp' , nested: deep };
+
+		var result = clone(a);
+
+		assert.deepEqual(result, a);
+		assert.notStrictEqual(result.nested, deep);
+		assert.notStrictEqual(result.nested.nested, deeper);
+	});
+
+	it('should not preserve date references', function() {
+		var a = { burp: 'adurp', date: new Date() },
+			date = a.date;
+
+		var result = clone(a);
+
+		assert.deepEqual(result, a);
+		assert.equal(result.date.getTime(), date.getTime()); // added this because deepEqual doesn't work with dates
+		assert.notStrictEqual(result.date, date);
+	});
+
+	it('should not preserve regexp references', function() {
+		var a = { burp: 'adurp', regexp: /foo/g },
+			regexp = a.regexp;
+
+		var result = clone(a);
+
+		assert.deepEqual(result, a);
+		assert.notStrictEqual(result.regexp, regexp);
+	});
+
+	it('should not preserve array references', function() {
+		var deeper = { boo: 'far' },
+			deep = { foo: 'bar', nested: deeper },
+			a = { burp: 'adurp' , nested: [deep, deeper] };
+
+		var result = clone(a);
+
+		assert.deepEqual(result, a);
+		assert.notStrictEqual(result.nested, a.nested);
+		assert.notStrictEqual(result.nested[0], deep);
+		assert.notStrictEqual(result.nested[0].nested, deeper);
+		assert.notStrictEqual(result.nested[1], deeper);
+
+		assert.deepEqual(result.nested[0].nested, result.nested[1]);
+		assert.notStrictEqual(result.nested[0].nested, result.nested[1]);
+	});
+
+	it('should clone Date objects', function() {
+		var a = new Date();
+
+		var result = clone(a);
+
+		assert.equal(result.toString(), a.toString());
+		assert.notStrictEqual(result, a);
+	});
+
+	it('should clone RegExp objects', function() {
+		var a = /foo/;
+
+		var result = clone(a);
+
+		assert.equal(result.toString(), a.toString());
+		assert.notStrictEqual(result, a);
+	});
+
+	it('should work for multiple arguments', function() {
+		var a = { doom: 'song' },
+			b = { burp: 'adurp' },
+			c = { grr: { doh: 'argh' } };
+
+		var result = clone(a, b, c);
+
+		assert.deepEqual(a, { doom: 'song' });
+		assert.deepEqual(b, { burp: 'adurp' });
+		assert.deepEqual(c, { grr: { doh: 'argh' } });
+		assert.sameMembers(Object.keys(result), ['doom', 'burp', 'grr']);
+		assert.equal(result.doom, a.doom);
+		assert.equal(result.burp, b.burp);
+		assert.deepEqual(result.grr, c.grr);
+		assert.notStrictEqual(result.grr, c.grr);
+	});
+
+	describe('on an array', function() {
+
+		it('should not preserve references', function() {
+			var a = ['string', 1, false, [], {}];
+
+			var result = clone(a);
+
+			assert.deepEqual(result, a);
+			assert.equal(result[0], a[0]);
+			assert.equal(result[1], a[1]);
+			assert.equal(result[2], a[2]);
+			assert.notStrictEqual(result[3], a[3]);
+			assert.notStrictEqual(result[4], a[4]);
+		});
+
+	});
+
+});

node_modules/deap/test/deap.test.js

@@ -0,0 +1,53 @@
+var assert = require('chai').assert,
+	deap = require('../index'),
+	lib = require('../lib/deap');
+
+describe('deap', function() {
+
+	it('should have clone defined', function() {
+		assert.isFunction(deap.clone);
+		assert.deepEqual(deap.clone, lib.clone);
+	});
+
+	it('should have cloneShallow defined', function() {
+		assert.isFunction(deap.cloneShallow);
+		assert.deepEqual(deap.cloneShallow, lib.cloneShallow);
+	});
+
+	it('should have extend exposed as a top level function', function() {
+		assert.isFunction(deap);
+		assert.equal(deap, lib.extend);
+	});
+
+	it('should have extend defined', function() {
+		assert.isFunction(deap.extend);
+		assert.deepEqual(deap.extend, lib.extend);
+	});
+
+	it('should have extendShallow defined', function() {
+		assert.isFunction(deap.extendShallow);
+		assert.deepEqual(deap.extendShallow, lib.extendShallow);
+	});
+
+	it('should have update defined', function() {
+		assert.isFunction(deap.update);
+		assert.deepEqual(deap.update, lib.update);
+	});
+
+	it('should have updateShallow defined', function() {
+		assert.isFunction(deap.updateShallow);
+		assert.deepEqual(deap.updateShallow, lib.updateShallow);
+	});
+
+	it('should have merge defined', function() {
+		assert.isFunction(deap.merge);
+		assert.deepEqual(deap.merge, lib.merge);
+	});
+
+	it('should have mergeShallow defined', function() {
+		assert.isFunction(deap.mergeShallow);
+		assert.deepEqual(deap.mergeShallow, lib.mergeShallow);
+	});
+
+
+});

node_modules/deap/test/extend.test.js

@@ -0,0 +1,155 @@
+var assert = require('chai').assert,
+	lib = require('../lib/deap');
+
+describe('shallow extend', function() {
+	var shallow = lib.extendShallow;
+
+	it('should return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = shallow(a, b);
+
+		assert.strictEqual(result, a);
+	});
+
+	it('should copy simple values', function() {
+		var a = {},
+			b = { s: 'string', n: 1, b: false, a: [], o: {}};
+
+		var c = shallow(a, b);
+
+		assert.deepEqual(c, a);
+		assert.equal(c.s, b.s);
+		assert.equal(c.n, b.n);
+		assert.equal(c.b, b.b);
+		assert.strictEqual(c.a, b.a);
+		assert.strictEqual(c.o, b.o);
+	});
+
+	it('should only alter first param', function() {
+		var a = { doom: 'song' },
+			b = { burp: 'adurp' },
+			c = { grr: 'argh' };
+
+		var result = shallow({}, a, b, c);
+
+		assert.deepEqual(a, { doom: 'song' });
+		assert.deepEqual(b, { burp: 'adurp' });
+		assert.deepEqual(c, { grr: 'argh' });
+		assert.sameMembers(Object.keys(result), ['doom', 'burp', 'grr']);
+		assert.equal(result.doom, a.doom);
+		assert.equal(result.burp, b.burp);
+		assert.equal(result.grr, c.grr);
+
+	});
+
+	it('should preserve object references', function() {
+		var deep = { foo: 'bar' },
+			a = { burp: 'adurp' , nested: deep };
+
+
+		var result = shallow({}, a);
+
+		assert.strictEqual(result.nested, deep);
+	});
+
+	it('should preserve date references', function() {
+		var a = { burp: 'adurp', date: new Date() },
+			date = a.date;
+
+		var result = shallow({}, a);
+
+		assert.strictEqual(result.date, date);
+	});
+
+	it('should preserve regexp references', function() {
+		var a = { burp: 'adurp', regexp: /foo/g },
+			regexp = a.regexp;
+
+		var result = shallow({}, a);
+
+		assert.strictEqual(result.regexp, regexp);
+	});
+
+	it('should preserve array references', function() {
+		var a = { burp: 'adurp', array: [] },
+			array = a.array;
+
+		var result = shallow({}, a);
+
+		assert.strictEqual(result.array, array);
+	});
+
+	it('should not pick up non-enumberable properties', function() {
+		var result = shallow({}, function() {});
+
+		assert.deepEqual(result, {});
+		assert.equal(Object.keys(result).length, 0);
+		assert.equal(Object.getOwnPropertyNames(result).length, 0);
+	});
+});
+
+describe('deep extend', function() {
+	var deepExtend = lib.extend;
+
+	it('should return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = deepExtend(a, b);
+
+		assert.strictEqual(result, a);
+	});
+
+	it('should not preserve object references', function() {
+		var deeper = { boo: 'far' },
+			deep = { foo: 'bar', nested: deeper },
+			a = { burp: 'adurp' , nested: deep };
+
+		var result = deepExtend({}, a);
+
+		assert.deepEqual(result, a);
+		assert.notStrictEqual(result.nested, deep);
+		assert.notStrictEqual(result.nested.nested, deeper);
+	});
+
+	it('should not preserve date references', function() {
+		var a = { burp: 'adurp', date: new Date() },
+			date = a.date;
+
+		var result = deepExtend({}, a);
+
+		assert.deepEqual(result, a);
+		assert.equal(result.date.getTime(), date.getTime()); // added this because deepEqual doesn't work with dates
+		assert.notStrictEqual(result.date, date);
+	});
+
+	it('should not preserve regexp references', function() {
+		var a = { burp: 'adurp', regexp: /foo/g },
+			regexp = a.regexp;
+
+		var result = deepExtend({}, a);
+
+		assert.deepEqual(result, a);
+		assert.notStrictEqual(result.regexp, regexp);
+	});
+
+	it('should not preserve array references', function() {
+		var deeper = { boo: 'far' },
+			deep = { foo: 'bar', nested: deeper },
+			a = { burp: 'adurp' , nested: [deep, deeper] };
+
+		var result = deepExtend({}, a);
+
+		assert.deepEqual(result, a);
+		assert.notStrictEqual(result.nested, a.nested);
+		assert.notStrictEqual(result.nested[0], deep);
+		assert.notStrictEqual(result.nested[0].nested, deeper);
+		assert.notStrictEqual(result.nested[1], deeper);
+
+		assert.deepEqual(result.nested[0].nested, result.nested[1]);
+		assert.notStrictEqual(result.nested[0].nested, result.nested[1]);
+	});
+
+});

node_modules/deap/test/merge.test.js

@@ -0,0 +1,134 @@
+var lib = require('../lib/deap'),
+	assert = require('chai').assert;
+
+describe('shallow merge', function() {
+	var shallowMerge = lib.mergeShallow;
+
+	it('should merge everything into an empty object', function() {
+		var a = { foo: 'bar' },
+			result = shallowMerge({}, a);
+
+		assert.deepEqual(result, a);
+	});
+
+	it('should return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = shallowMerge(a, b);
+
+		assert.strictEqual(result, a);
+	});
+
+	it('should not replace existing values', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = shallowMerge(a, b);
+
+		assert.deepEqual(result, { burp: 'adurp', grr: 'arghh' });
+		assert.equal(result.burp, a.burp);
+	});
+
+});
+
+describe('deep merge', function() {
+	var deepMerge = lib.merge;
+
+	it('should return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = deepMerge(a, b);
+
+		assert.strictEqual(result, a);
+	});
+
+	it('should merge a nested object one level deep', function() {
+		var a = { foo: 'bar', deep: { foo: 'bar', baz: 'buzz' }},
+			b = { foo: 'bop', deep: { foo: 'beep', biz: 'baz' } };
+
+		var result = deepMerge(a, b);
+
+		assert.equal(result.foo, 'bar');
+		assert.equal(result.deep.foo, 'bar');
+		assert.equal(result.deep.baz, 'buzz');
+		assert.equal(result.deep.biz, 'baz');
+	});
+
+	it('should merge a nested object two levels deep', function() {
+		var a = { foo: 'bar', deep: { hi: 'hello', deeper: { foo: 'bar', baz: 'buzz' }}},
+			b = { foo: 'baz', deep: { hi: 'bye', bye: 'hi', deeper: { foo: 'beep', bop: 'boop' } } };
+
+		var result = deepMerge({}, a, b);
+
+		assert.equal(result.foo, a.foo);
+		assert.isObject(result.deep);
+		assert.equal(result.deep.hi, a.deep.hi);
+		assert.equal(result.deep.bye, b.deep.bye);
+		assert.isObject(result.deep.deeper);
+		assert.equal(result.deep.deeper.foo, a.deep.deeper.foo);
+		assert.equal(result.deep.deeper.baz, a.deep.deeper.baz);
+		assert.equal(result.deep.deeper.bop, b.deep.deeper.bop);
+	});
+
+	it('should merge properties from multiple objects', function() {
+		var a = { foo: ['one'], boo: 'far', poo: 'tar' },
+			b = { foo: ['two', 'three'], zoo: 'car' },
+			c = { boo: 'star', two: 'czar' };
+
+		var result = deepMerge({}, a, b, c);
+
+		assert.deepEqual(result, {
+			foo: a.foo,
+			boo: a.boo,
+			poo: a.poo,
+			zoo: b.zoo,
+			two: c.two
+		});
+	});
+
+	it('should not preserve nested object references', function() {
+		var a = { foo: 'bar' },
+			nested = { grr: 'argh' },
+			newFoo = { burp: nested },
+			b = { foo: newFoo, foo2: newFoo };
+
+		var result = deepMerge(a, b);
+		assert.equal(a.foo, 'bar');
+		assert.deepEqual(a.foo2.burp, b.foo2.burp);
+		assert.notStrictEqual(a.foo2.burp, nested);
+	});
+
+	it('should not override a string with an object', function() {
+		var a = { foo: 'bar' },
+			b = { foo: { biz: 'baz' } };
+
+		var result = deepMerge(a, b);
+		assert.deepEqual(a, { foo: 'bar' });
+	});
+
+	it('should preserve array references', function() {
+		var a = { nested: [{ foo: 'bar' }] },
+			b = { nested: [{ boo: 'far' }] },
+			deep = a.nested;
+
+		var result = deepMerge(a, b);
+
+		assert.deepEqual(result.nested, a.nested);
+		assert.notStrictEqual(result.nested, b.nested);
+		assert.strictEqual(result.nested, deep);
+	});
+
+	it('should not preserve references in arrays', function() {
+		var a = { nested: [{ foo: 'bar' }] },
+			b = { nested: [{ boo: 'far' }] },
+			deeper = a.nested[0];
+
+		var result = deepMerge({}, a, b);
+
+		assert.deepEqual(result.nested, a.nested);
+		assert.notStrictEqual(result.nested[0], deeper);
+	});
+
+});

node_modules/deap/test/shallow.test.js

@@ -0,0 +1,24 @@
+var assert = require('chai').assert,
+	lib = require('../lib/deap'),
+	shallow = require('../shallow');
+
+describe('shallow', function() {
+
+	it('should be defined correctly', function() {
+		assert.isFunction(shallow);
+
+		assert.isFunction(shallow.extend);
+		assert.isFunction(shallow.update);
+		assert.isFunction(shallow.merge);
+		assert.isFunction(shallow.clone);
+	});
+
+	it('should have shallow functions', function() {
+		assert.equal(shallow, lib.extendShallow);
+		assert.equal(shallow.extend, lib.extendShallow);
+		assert.equal(shallow.update, lib.updateShallow);
+		assert.equal(shallow.merge, lib.mergeShallow);
+		assert.equal(shallow.clone, lib.cloneShallow);
+	});
+
+});

node_modules/deap/test/update.test.js

@@ -0,0 +1,136 @@
+var lib = require('../lib/deap'),
+	assert = require('chai').assert;
+
+describe('shallow update', function() {
+	var shallowUpdate = lib.updateShallow;
+
+	it('should not update anything into an empty object', function() {
+		var result = shallowUpdate({}, { foo: 'bar' });
+
+		assert.deepEqual(result, {});
+	});
+
+	it('should return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = shallowUpdate(a, b);
+
+		assert.strictEqual(result, a);
+	});
+
+	it('should replace existing values only', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = shallowUpdate(a, b);
+
+		assert.deepEqual(result, a);
+		assert.equal(a.burp, b.burp);
+		assert.isUndefined(a.grr);
+	});
+
+});
+
+describe('deep update', function() {
+	var deepUpdate = lib.update;
+
+	it('should return a reference to the first argument', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = deepUpdate(a, b);
+
+		assert.strictEqual(result, a);
+	});
+
+	it('should update a nested object one level deep', function() {
+		var a = { foo: 'bar', deep: { foo: 'bar', baz: 'buzz' }},
+			b = { deep: { foo: 'beep' } };
+
+		var result = deepUpdate(a, b);
+
+		assert.equal(result.foo, a.foo);
+		assert.equal(result.deep.foo, b.deep.foo);
+		assert.equal(result.deep.baz, a.deep.baz);
+	});
+
+	it('should update a nested object two levels deep', function() {
+		var a = { foo: 'bar', deep: { hi: 'hello', deeper: { foo: 'bar', baz: 'buzz' }}},
+			b = { deep: { deeper: { foo: 'beep' } } };
+
+		var result = deepUpdate(a, b);
+
+		assert.equal(result.foo, a.foo);
+		assert.isObject(result.deep);
+		assert.equal(result.deep.hi, a.deep.hi);
+		assert.isObject(result.deep.deeper);
+		assert.equal(result.deep.deeper.foo, b.deep.deeper.foo);
+		assert.equal(result.deep.deeper.baz, a.deep.deeper.baz);
+	});
+
+	it('should update properties from multiple objects', function() {
+		var a = { foo: ['one'], boo: 'far', poo: 'tar' },
+			b = { foo: ['two', 'three'], zoo: 'car' },
+			c = { boo: 'star', two: 'czar' };
+
+		var result = deepUpdate(a, b, c);
+
+		assert.deepEqual(result, {
+			foo: b.foo,
+			boo: c.boo,
+			poo: a.poo
+		});
+	});
+
+	it('should not update properties that are not on the first argument', function() {
+		var a = { foo: 'bar', deep: { deeper: { foo: 'bar' } } },
+			b = { boo: 'far', deep: { hi: 'hello', deeper: { foo: 'beep', baz: 'buzz' } } };
+
+		var result = deepUpdate(a, b);
+
+		assert.isUndefined(result.boo);
+		assert.isObject(result.deep);
+		assert.isUndefined(result.deep.hi);
+		assert.isObject(result.deep.deeper);
+		assert.isUndefined(result.deep.deeper.baz);
+		assert.equal(result.deep.deeper.foo, b.deep.deeper.foo);
+	});
+
+	it('should not preserve nested object references', function() {
+		var a = { foo: 'bar' },
+			nested = { grr: 'argh' },
+			newFoo = { burp: nested },
+			b = { foo: newFoo };
+
+		var result = deepUpdate(a, b);
+
+		assert.deepEqual(a.foo.burp, b.foo.burp);
+		assert.notStrictEqual(a.foo.burp, nested);
+	});
+
+	it('should preserve array references', function() {
+		var a = { nested: [{ foo: 'bar' }] },
+			b = { nested: [{ boo: 'far' }] },
+			deep = a.nested;
+
+		var result = deepUpdate(a, b);
+
+		assert.deepEqual(result.nested, b.nested);
+		assert.notStrictEqual(result.nested, b.nested);
+		assert.strictEqual(result.nested, a.nested);
+		assert.strictEqual(result.nested, deep);
+	});
+
+	it('should not preserve references in arrays', function() {
+		var a = { nested: [{ foo: 'bar' }] },
+			b = { nested: [{ boo: 'far' }] },
+			deeper = a.nested[0];
+
+		var result = deepUpdate(a, b);
+
+		assert.deepEqual(result.nested, b.nested);
+		assert.notStrictEqual(result.nested[0], deeper);
+	});
+
+});