some files

.gitignore

@@ -12,3 +12,4 @@ logs
 results
 
 npm-debug.log
+/node_modules

index.js

@@ -0,0 +1,11 @@
+var extend = require('./lib/extend'),
+	merge = require('./lib/merge');
+
+var deap = module.exports = extend.deep;
+
+deap(deap, {
+	extend: extend.deep,
+	merge: merge.deep,
+	extendShallow: extend.shallow,
+	mergeShallow: merge.shallow
+});

lib/extend.js

@@ -0,0 +1,33 @@
+var typeOf = require('./typeof'),
+	slice = Array.prototype.slice;
+
+module.exports = {
+	shallow : extend,
+	deep: deepExtend
+};
+
+function extend(a, b /*, [b2..n] */) {
+	slice.call(arguments, 1).forEach(function(b) {
+		Object.getOwnPropertyNames(b).forEach(function(p) {
+			a[p] = b[p];
+		});
+	});
+	return a;
+};
+
+function deepExtend(a, b /*, [b2..n] */) {
+	slice.call(arguments, 1).forEach(function(b) {
+		Object.getOwnPropertyNames(b).forEach(function(p) {
+			if(typeOf(b[p]) === 'object') {
+				if(typeOf(a[p]) === 'object')
+					extend(a[p], b[p]);
+				else
+					a[p] = extend({}, b[p]);
+			} else
+				a[p] = b[p];
+		});
+	});
+	return a;
+};
+
+

lib/merge.js

@@ -0,0 +1,34 @@
+var typeOf = require('./typeof'),
+	extend = require('./extend').shallow,
+	slice = Array.prototype.slice;
+
+module.exports = {
+	shallow: merge,
+	deep: deepMerge
+};
+
+function merge(a, b /*, [b2..n] */) {
+	slice.call(arguments, 1).forEach(function(b) {
+		Object.getOwnPropertyNames(b).forEach(function(p) {
+			if(a.hasOwnProperty(p)) a[p] = b[p];
+		});
+	});
+	return a;
+}
+
+function deepMerge(a, b /*, [b2..n] */) {
+	slice.call(arguments, 1).forEach(function(b) {
+		Object.getOwnPropertyNames(b).forEach(function(p) {
+			if(a.hasOwnProperty(p)) {
+				if(typeOf(b[p]) === 'object') {
+					if(typeOf(a[p]) === 'object')
+						deepMerge(a[p], b[p]);
+					else
+						a[p] = extend({}, b[p]);
+				} else
+					a[p] = b[p];
+			}
+		});
+	});
+	return a;
+}

lib/typeof.js

@@ -0,0 +1,18 @@
+
+module.exports = function(obj) {
+	var t = typeof obj;
+	if(t !== 'object') return t;
+
+	// typeof null == 'object' so check seperately
+	if(obj === null) return 'null';
+
+	// typeof new Array|String|Number|Boolean|RegExp == 'object' so check seperately
+	switch(obj.constructor) {
+		case Array:		return 'array';
+		case String:	return 'string';
+		case Number:	return 'number';
+		case Boolean:	return 'boolean';
+		case RegExp:	return 'regexp';
+	}
+	return 'object';
+};

package.json

@@ -0,0 +1,37 @@
+{
+  "name": "deap",
+  "version": "0.0.0",
+  "description": "extend and merge objects, deep or shallow",
+  "main": "index.js",
+  "scripts": {
+    "test": "./node_modules/.bin/mocha test/*.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/selfcontained/deap.git"
+  },
+  "keywords": [
+    "extend",
+    "merge",
+    "mixin",
+    "deep",
+    "shallow"
+  ],
+  "author": "Brad Harris <bmharris@gmail.com> (http://selfcontained.us)",
+  "contributors": [
+    {
+      "name": "Brad Harris",
+      "email": "bmharris@gmail.com",
+      "url": "http://selfcontained.us"
+    },
+    {
+      "name": "Matt Dunlap"
+    }
+  ],
+  "license": "BSD",
+  "readmeFilename": "README.md",
+  "devDependencies": {
+    "mocha": "~1.9.0",
+    "chai": "~1.6.0"
+  }
+}

test/deap.test.js

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

test/extend.test.js

@@ -0,0 +1,62 @@
+var assert = require('chai').assert,
+	extend = require('../lib/extend');
+
+describe('shallow extend', function() {
+	var shallow = extend.shallow;
+
+	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.equal(c.a, b.a);
+		assert.equal(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 contain reference objects', function() {
+		var deep = { foo: 'bar' },
+			a = { burp: 'adurp' , nested: deep };
+
+
+		var result = shallow({}, a);
+
+		assert.strictEqual(result.nested, deep);
+	});
+
+});
+
+describe('deep extend', function() {
+
+	it('should not contain reference objects', function() {
+		var deep = { foo: 'bar' },
+			a = { burp: 'adurp' , nested: deep };
+
+
+		var result = extend.deep({}, a);
+
+		assert.notStrictEqual(result.nested, deep);
+	});
+
+});

test/merge.test.js

@@ -0,0 +1,83 @@
+var merge = require('../lib/merge'),
+	assert = require('chai').assert;
+
+describe('shallow merge', function() {
+	var shallowMerge = merge.shallow;
+
+	it('should not merge anything into an empty object', function() {
+		var result = shallowMerge({}, { foo: 'bar' });
+
+		assert.deepEqual(result, {});
+	});
+
+	it('should replace existing values only', function() {
+		var a = { burp: 'adurp' },
+			b = { burp: 'zing', grr: 'arghh' };
+
+		var result = shallowMerge(a, b);
+
+		assert.deepEqual(result, a);
+		assert.equal(a.burp, b.burp);
+		assert.isUndefined(a.grr);
+	});
+
+});
+
+describe('deep merge', function() {
+	var deepMerge = merge.deep;
+
+	it('should merge a nested object one level deep', function() {
+		var a = { foo: 'bar', deep: { foo: 'bar', baz: 'buzz' }},
+			b = { deep: { foo: 'beep' } };
+
+		var result = deepMerge(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 merge 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 = deepMerge(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 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: b.foo,
+			boo: c.boo,
+			poo: a.poo
+		});
+	});
+
+	it('should not merge 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 = deepMerge(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);
+	});
+
+
+});