From 7e2671a99914fee3826115c2a6daa5dd461b655b Mon Sep 17 00:00:00 2001
From: Andreas Schmidt <info@portal-as.de>
Date: Sun, 15 Jun 2014 19:40:12 +0200
Subject: [PATCH 1/2] Improve objectDiff.

* Exportable as NodeJs module.
* Proper date handling.
* Remove equal elements to save space.
* Handle array elements using IDs.
* Provide a mechanism for applying changes.
* Shortened tokens.
---
 MIT-LICENSE.txt |   2 +-
 index.html      |   4 +-
 objectDiff.js   | 563 +++++++++++++++++++++++++++---------------------
 3 files changed, 316 insertions(+), 253 deletions(-)

diff --git a/MIT-LICENSE.txt b/MIT-LICENSE.txt
index bc57aac..7f826ca 100644
--- a/MIT-LICENSE.txt
+++ b/MIT-LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (c) Nikita Vasilyev
+Copyright (c) Nikita Vasilyev (modifications by Andreas Schmidt)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/index.html b/index.html
index b2834f3..edaa25f 100644
--- a/index.html
+++ b/index.html
@@ -28,7 +28,7 @@
 	</tr>
 </table>
 
-<a class="footer" href="https://github.com/NV/objectDiff.js">objectDiff.js on GitHub</a>
+<a class="footer" href="https://github.com/Darneas/objectDiff.js">objectDiff.js on GitHub</a>
 
 <script src="objectDiff.js"></script>
 <script defer>
@@ -63,7 +63,7 @@
 	}
 
 	if (!bError && !aError) {
-		var diff = objectDiff.diffOwnProperties(aObj, bObj);
+		var diff = objectDiff.basicDiff(aObj, bObj);
 		result.innerHTML = objectDiff.convertToXMLString(diff);
 	}
 };
diff --git a/objectDiff.js b/objectDiff.js
index 36359b1..484944e 100644
--- a/objectDiff.js
+++ b/objectDiff.js
@@ -1,284 +1,347 @@
-var objectDiff = typeof exports != 'undefined' ? exports : {};
+var objectDiff = typeof exports != "undefined" ? exports : {};
 
-/**
- * @param {Object} a
- * @param {Object} b
- * @return {Object}
- */
-objectDiff.diff = function diff(a, b) {
-
-	if (a === b) {
-		return {
-			changed: 'equal',
-			value: a
-		}
-	}
+objectDiff.token = { changed: "c", value: "v", equal: "e", primitive: "p", added: "a", removed: "r", object: "o" };
 
-	var value = {};
-	var equal = true;
+objectDiff.isDate = function isDate(obj) {
+    return Object.prototype.toString.call(obj) == "[object Date]";
+};
 
-	for (var key in a) {
-		if (key in b) {
-			if (a[key] === b[key]) {
-				value[key] = {
-					changed: 'equal',
-					value: a[key]
-				}
-			} else {
-				var typeA = typeof a[key];
-				var typeB = typeof b[key];
-				if (a[key] && b[key] && (typeA == 'object' || typeA == 'function') && (typeB == 'object' || typeB == 'function')) {
-					var valueDiff = diff(a[key], b[key]);
-					if (valueDiff.changed == 'equal') {
-						value[key] = {
-							changed: 'equal',
-							value: a[key]
-						}
-					} else {
-						equal = false;
-						value[key] = valueDiff;
-					}
-				} else {
-					equal = false;
-					value[key] = {
-						changed: 'primitive change',
-						removed: a[key],
-						added: b[key]
-					}
-				}
-			}
-		} else {
-			equal = false;
-			value[key] = {
-				changed: 'removed',
-				value: a[key]
-			}
-		}
-	}
+/**
+ * This methods minifies the model but preserves ID info to make entities still identifiable.
+ * @param {Object} difference
+ */
+objectDiff.removeEqualPath = function (difference) {
+    if (!difference)
+        return;
+
+    for (var key in difference[objectDiff.token.value]) {
+        var obj = difference[objectDiff.token.value][key];
+        var type = typeof (obj);
+        if (type == "object" || type == "function") {
+            if (obj && obj[objectDiff.token.changed] === objectDiff.token.equal && key !== "id") {
+                delete difference.v[key];
+            } else {
+                objectDiff.removeEqualPath(obj);
+            }
+        }
+    }
+};
 
-	for (key in b) {
-		if (!(key in a)) {
-			equal = false;
-			value[key] = {
-				changed: 'added',
-				value: b[key]
-			}
-		}
-	}
+/**
+ * @param {Object} object
+ */
+objectDiff.cleanArray = function(object) {
+    if (!Array.isArray(object))
+        return;
+
+    var i = 0;
+    while (i < object.length) {
+        if (object[i] === undefined || object[i] === null) {
+            object.splice(i, 1);
+        } else {
+            i++;
+        }
+    }
+};
 
-	if (equal) {
-		return {
-			changed: 'equal',
-			value: a
-		}
-	} else {
-		return {
-			changed: 'object change',
-			value: value
-		}
-	}
+/**
+ * @param {Object} obj
+ */
+objectDiff.cleanRecurse = function(obj) {
+    for (var key in obj) {
+        var type = typeof(obj);
+        if (type == "object" || type == "function") {
+            objectDiff.cleanRecurse(obj[key]);
+            objectDiff.cleanArray(obj);
+        }
+    }
 };
 
+/**
+ * @param {Object} object
+ * @param {Object} message
+ * @return {Object} changed object
+ */
+objectDiff.applyChanges = function(object, message) {
+    if (message[objectDiff.token.changed] === objectDiff.token.equal) {
+        return;
+    }
+
+    if (message[objectDiff.token.changed] === objectDiff.token.object) {
+        Object.keys(message[objectDiff.token.value]).forEach(function(d) {
+            if (message[objectDiff.token.value][d][objectDiff.token.changed] == objectDiff.token.primitive) {
+                object[d] = message[objectDiff.token.value][d][objectDiff.token.added];
+            } else if (message[objectDiff.token.value][d][objectDiff.token.changed] == objectDiff.token.added) {
+                object[d] = message[objectDiff.token.value][d][objectDiff.token.value];
+            } else if (message[objectDiff.token.value][d][objectDiff.token.changed] == objectDiff.token.removed) {
+                if (Array.isArray(object)) {
+                    object[d] = undefined;
+                } else {
+                    delete object[d];
+                }
+            } else if (message[objectDiff.token.value][d][objectDiff.token.changed] == objectDiff.token.object) {
+                objectDiff.applyChanges(object[d], message[objectDiff.token.value][d]);
+            }
+        });
+
+        objectDiff.cleanArray(object);
+    }
+};
 
 /**
  * @param {Object} a
  * @param {Object} b
- * @return {Object}
+ * @return {Object} changes
  */
-objectDiff.diffOwnProperties = function diffOwnProperties(a, b) {
+objectDiff.diff = function diff(a, b) {
+    var difference = objectDiff.basicDiff(a, b);
+    objectDiff.cleanRecurse(b);
+    objectDiff.removeEqualPath(difference);
+    return difference;
+};
 
-	if (a === b) {
-		return {
-			changed: 'equal',
-			value: a
-		}
-	}
+/**
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} changes
+ */
+objectDiff.basicDiff = function basicDiff(a, b) {
+    var res = {};
+    if (a === b) {
+        res[objectDiff.token.changed] = objectDiff.token.equal;
+        res[objectDiff.token.value] = a;
+        return res;
+    }
+
+    // in case that a and b are arrays, they are reshuffled based on id to make add/remove/change more sensible.
+    if (Array.isArray(a) && Array.isArray(b)) {
+        var idFound = false;
+        for (var keyA in a) {
+            if (a[keyA].id !== undefined) {
+                idFound = true;
+                break;
+            }
+        }
+        
+        if (!idFound) {
+            for (var keyB in b) {
+                if (b[keyB].id !== undefined) {
+                    idFound = true;
+                    break;
+                }
+            }
+        }
+
+        // require at least one id to be set on an element
+        if (idFound) {
+            var insertIndex = a.length;
+            var tmpB = [];
+            for (var bKey in b) {
+                var found = false;
+                for (var aKey = 0; aKey < a.length; aKey++) {
+                    if (!a[aKey] || a[aKey].id === undefined || !b[bKey] || b[bKey].id === undefined)
+                        continue;
+
+                    if (b[bKey].id === a[aKey].id) {
+                        tmpB[aKey] = b[bKey];
+                        found = true;
+                        break;
+                    }
+                }
+
+                if (!found) {
+                    tmpB[insertIndex++] = b[bKey];
+                }
+            }
+
+            // Clean and read elements to Array.
+            b.splice(0, b.length);
+            for (var k in tmpB) {
+                b[k] = tmpB[k];
+            }
+
+        }
+    }
+
+    var value = {};
+    var equal = true;
+
+    for (var key in a) {
+        if (key in b) {
+            if (a[key] === b[key]) {
+                value[key] = {};
+                value[key][objectDiff.token.changed] = objectDiff.token.equal;
+                value[key][objectDiff.token.value] = a[key];
+            }
+            else if ((a[key] && objectDiff.isDate(a[key])) && (b[key] && objectDiff.isDate(b[key]))) {
+                if (a[key].getTime() === b[key].getTime()) {
+                    value[key] = {};
+                    value[key][objectDiff.token.changed] = objectDiff.token.equal;
+                    value[key][objectDiff.token.value] = a[key];
+                } else {
+                    equal = false;
+                    value[key] = { };
+                    value[key][objectDiff.token.changed] = objectDiff.token.primitive;
+                    value[key][objectDiff.token.added] = b[key];
+                }
+            } else {
+                var typeA = typeof a[key];
+                var typeB = typeof b[key];
+                if (a[key] && b[key] && (typeA == "object" || typeA == "function") && (typeB == "object" || typeB == "function")) {
+                    var valueDiff = basicDiff(a[key], b[key]);
+                    if (valueDiff[objectDiff.token.changed] == objectDiff.token.equal) {
+                        value[key] = {};
+                        value[key][objectDiff.token.changed] = objectDiff.token.equal;
+                        value[key][objectDiff.token.value] = a[key];
+                    } else {
+                        equal = false;
+                        value[key] = valueDiff;
+                    }
+                } else {
+                    equal = false;
+                    value[key] = { };
+                    value[key][objectDiff.token.changed] = objectDiff.token.primitive;
+                    value[key][objectDiff.token.added] = b[key];
+                }
+            }
+        } else {
+            equal = false;
+            value[key] = { };
+            value[key][objectDiff.token.changed] = objectDiff.token.removed;
+            value[key][objectDiff.token.value] = a[key];
+        }
+    }
+
+    for (key in b) {
+        if (!(key in a)) {
+            equal = false;
+            value[key] = { };
+            value[key][objectDiff.token.changed] = objectDiff.token.added;
+            value[key][objectDiff.token.value] = b[key];
+        }
+    }
+
+    if (equal) {
+        res[objectDiff.token.changed] = objectDiff.token.equal;
+        res[objectDiff.token.value] = a;
+        return res;
+    } else {
+        res[objectDiff.token.changed] = objectDiff.token.object;
+        res[objectDiff.token.value] = value;
+        return res;
+    }
+}
+	
+/**
+ * @param {Object} changes
+ * @return {string}
+ */
+objectDiff.convertToXMLString = function convertToXMLString(changes) {
+	var properties = [];
 
-	var diff = {};
-	var equal = true;
-	var keys = Object.keys(a);
-
-	for (var i = 0, length = keys.length; i < length; i++) {
-		var key = keys[i];
-		if (b.hasOwnProperty(key)) {
-			if (a[key] === b[key]) {
-				diff[key] = {
-					changed: 'equal',
-					value: a[key]
-				}
-			} else {
-				var typeA = typeof a[key];
-				var typeB = typeof b[key];
-				if (a[key] && b[key] && (typeA == 'object' || typeA == 'function') && (typeB == 'object' || typeB == 'function')) {
-					var valueDiff = diffOwnProperties(a[key], b[key]);
-					if (valueDiff.changed == 'equal') {
-						diff[key] = {
-							changed: 'equal',
-							value: a[key]
-						}
-					} else {
-						equal = false;
-						diff[key] = valueDiff;
-					}
-				} else {
-					equal = false;
-					diff[key] = {
-						changed: 'primitive change',
-						removed: a[key],
-						added: b[key]
-					}
-				}
-			}
-		} else {
-			equal = false;
-			diff[key] = {
-				changed: 'removed',
-				value: a[key]
-			}
-		}
+	var diff = changes[objectDiff.token.value];
+	if (changes[objectDiff.token.changed] == objectDiff.token.equal) {
+		return inspect(diff);
 	}
 
-	keys = Object.keys(b);
-
-	for (i = 0, length = keys.length; i < length; i++) {
-		key = keys[i];
-		if (!a.hasOwnProperty(key)) {
-			equal = false;
-			diff[key] = {
-				changed: 'added',
-				value: b[key]
-			}
+	for (var key in diff) {
+		var changed = diff[key][objectDiff.token.changed];
+		switch (changed) {
+			case objectDiff.token.equal:
+				properties.push(objectDiff.stringifyObjectKey(escapeHTML(key)) + '<span>: </span>' + objectDiff.inspect(diff[key][objectDiff.token.value]));
+				break;
+
+			case objectDiff.token.removed:
+				properties.push('<del class="diff">' + objectDiff.stringifyObjectKey(objectDiff.escapeHTML(key)) + '<span>: </span>' + objectDiff.inspect(diff[key][objectDiff.token.value]) + '</del>');
+				break;
+
+			case objectDiff.token.added:
+				properties.push('<ins class="diff">' + objectDiff.stringifyObjectKey(objectDiff.escapeHTML(key)) + '<span>: </span>' + objectDiff.inspect(diff[key][objectDiff.token.value]) + '</ins>');
+				break;
+
+			case objectDiff.token.primitive:
+				var prefix = objectDiff.stringifyObjectKey(objectDiff.escapeHTML(key)) + '<span>: </span>';
+				properties.push(
+					'<del class="diff diff-key">' + prefix + objectDiff.inspect(diff[key].removed) + '</del><span>,</span>\n' +
+					'<ins class="diff diff-key">' + prefix + objectDiff.inspect(diff[key].added) + '</ins>');
+				break;
+
+			case objectDiff.token.object:
+				properties.push(objectDiff.stringifyObjectKey(key) + '<span>: </span>' + objectDiff.convertToXMLString(diff[key]));
+				break;
 		}
 	}
 
-	if (equal) {
-		return {
-			value: a,
-			changed: 'equal'
-		}
-	} else {
-		return {
-			changed: 'object change',
-			value: diff
-		}
-	}
+	return '<span>{</span>\n<div class="diff-level">' + properties.join('<span>,</span>\n') + '\n</div><span>}</span>';
 };
 
+/**
+ * @param {string} key
+ * @return {string}
+ */
+objectDiff.stringifyObjectKey = function(key) {
+	return /^[a-z0-9_$]*$/i.test(key) ?
+		key :
+		JSON.stringify(key);
+}
 
-(function() {
-
-	/**
-	 * @param {Object} changes
-	 * @return {string}
-	 */
-	objectDiff.convertToXMLString = function convertToXMLString(changes) {
-		var properties = [];
-
-		var diff = changes.value;
-		if (changes.changed == 'equal') {
-			return inspect(diff);
-		}
-
-		for (var key in diff) {
-			var changed = diff[key].changed;
-			switch (changed) {
-				case 'equal':
-					properties.push(stringifyObjectKey(escapeHTML(key)) + '<span>: </span>' + inspect(diff[key].value));
-					break;
-
-				case 'removed':
-					properties.push('<del class="diff">' + stringifyObjectKey(escapeHTML(key)) + '<span>: </span>' + inspect(diff[key].value) + '</del>');
-					break;
-
-				case 'added':
-					properties.push('<ins class="diff">' + stringifyObjectKey(escapeHTML(key)) + '<span>: </span>' + inspect(diff[key].value) + '</ins>');
-					break;
-
-				case 'primitive change':
-					var prefix = stringifyObjectKey(escapeHTML(key)) + '<span>: </span>';
-					properties.push(
-						'<del class="diff diff-key">' + prefix + inspect(diff[key].removed) + '</del><span>,</span>\n' +
-						'<ins class="diff diff-key">' + prefix + inspect(diff[key].added) + '</ins>');
-					break;
-
-				case 'object change':
-					properties.push(stringifyObjectKey(key) + '<span>: </span>' + convertToXMLString(diff[key]));
-					break;
-			}
-		}
-
-		return '<span>{</span>\n<div class="diff-level">' + properties.join('<span>,</span>\n') + '\n</div><span>}</span>';
-	};
-
-	/**
-	 * @param {string} key
-	 * @return {string}
-	 */
-	function stringifyObjectKey(key) {
-		return /^[a-z0-9_$]*$/i.test(key) ?
-			key :
-			JSON.stringify(key);
-	}
+/**
+ * @param {string} string
+ * @return {string}
+ */
+objectDiff.escapeHTML = function(string) {
+	return string.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
 
-	/**
-	 * @param {string} string
-	 * @return {string}
-	 */
-	function escapeHTML(string) {
-		return string.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-	}
+/**
+ * @param {Object} obj
+ * @return {string}
+ */
+objectDiff.inspect = function(obj){
+	return _inspect('', obj);
 
 	/**
-	 * @param {Object} obj
+	 * @param {string} accumulator
+	 * @param {object} obj
+	 * @see http://jsperf.com/continuation-passing-style/3
 	 * @return {string}
 	 */
-	function inspect(obj) {
-
-		return _inspect('', obj);
-
-		/**
-		 * @param {string} accumulator
-		 * @param {object} obj
-		 * @see http://jsperf.com/continuation-passing-style/3
-		 * @return {string}
-		 */
-		function _inspect(accumulator, obj) {
-			switch(typeof obj) {
-				case 'object':
-					if (!obj) {
-						accumulator += 'null';
-						break;
-					}
-					var keys = Object.keys(obj);
-					var length = keys.length;
-					if (length === 0) {
-						accumulator += '<span>{}</span>';
-					} else {
-						accumulator += '<span>{</span>\n<div class="diff-level">';
-						for (var i = 0; i < length; i++) {
-							var key = keys[i];
-							accumulator = _inspect(accumulator + stringifyObjectKey(escapeHTML(key)) + '<span>: </span>', obj[key]);
-							if (i < length - 1) {
-								accumulator += '<span>,</span>\n';
-							}
+	function _inspect(accumulator, obj) {
+		switch(typeof obj) {
+			case 'object':
+				if (!obj) {
+					accumulator += 'null';
+					break;
+				}
+				var keys = Object.keys(obj);
+				var length = keys.length;
+				if (length === 0) {
+					accumulator += '<span>{}</span>';
+				} else {
+					accumulator += '<span>{</span>\n<div class="diff-level">';
+					for (var i = 0; i < length; i++) {
+						var key = keys[i];
+						accumulator = _inspect(accumulator + objectDiff.stringifyObjectKey(objectDiff.escapeHTML(key)) + '<span>: </span>', obj[key]);
+						if (i < length - 1) {
+							accumulator += '<span>,</span>\n';
 						}
-						accumulator += '\n</div><span>}</span>'
 					}
-					break;
+					accumulator += '\n</div><span>}</span>'
+				}
+				break;
 
-				case 'string':
-					accumulator += JSON.stringify(escapeHTML(obj));
-					break;
+			case 'string':
+				accumulator += JSON.stringify(objectDiff.escapeHTML(obj));
+				break;
 
-				case 'undefined':
-					accumulator += 'undefined';
-					break;
+			case 'undefined':
+				accumulator += 'undefined';
+				break;
 
-				default:
-					accumulator += escapeHTML(String(obj));
-					break;
-			}
-			return accumulator;
+			default:
+				accumulator += objectDiff.escapeHTML(String(obj));
+				break;
 		}
+		return accumulator;
 	}
-})();
+}

From f077c03f0f8d52fd76357e9aec2985a29ce13a96 Mon Sep 17 00:00:00 2001
From: Andreas Schmidt <info@portal-as.de>
Date: Sun, 21 Dec 2014 23:32:03 +0100
Subject: [PATCH 2/2] Add bower.json. Update version.

---
 bower.json   | 21 +++++++++++++++++++++
 package.json |  2 +-
 2 files changed, 22 insertions(+), 1 deletion(-)
 create mode 100644 bower.json

diff --git a/bower.json b/bower.json
new file mode 100644
index 0000000..013bb2a
--- /dev/null
+++ b/bower.json
@@ -0,0 +1,21 @@
+{
+  "name": "objectDiff-enhanced",
+  "main": "objectDiff.js",
+  "version": "1.1.1",
+  "homepage": "https://github.com/Darneas/objectDiff.js",
+  "authors": [
+    "Andreas Schmidt <info@portal-as.de>"
+  ],
+  "description": "\"Methods for calculating diff on JavaScript objects.\"",
+  "moduleType": [
+    "node"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ]
+}
diff --git a/package.json b/package.json
index f0e15c3..16c308e 100644
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
   "keywords": [
     "diff"
   ],
-  "version": "1.1.0",
+  "version": "1.1.1",
   "homepage": "https://github.com/NV/objectDiff.js",
   "author": {
     "name": "Nikita Vasilyev",