ignore: option

Author: Sergii.Kliuchnyk

README.md

@@ -168,6 +168,10 @@ var changes = diff(
 );
 ```
 
+## `ignore: function (oldValue, newValue, options)`
+
+Function which will be called before each object comparison and if returning value will be `true` then objects will be ignored. In `options` will be `oldPath` and `newPath`. Useful to prevent from traversing through circular references and when you don't want to compare some kind of objects at all.
+
 ## `callback: function (event)` 
 
 Function which will be called for each event. If callback is passed then lib will not create array of all changes.

bower.json

@@ -1,7 +1,7 @@
 {
   "name": "simple-diff",
   "main": "simple-diff.js",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "homepage": "https://github.com/redexp/simple-diff",
   "authors": [
     "Sergii Kliuchnyk <[email protected]>"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-diff",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "simple diff for object and arrays with options",
   "main": "simple-diff.js",
   "scripts": {

simple-diff.js

@@ -29,20 +29,23 @@
                 changes.push(item);
             },
             comparators = ops.comparators || [],
+            ignore = ops.ignore,
             i, len, prop, id;
 
-        if (!isObject(oldObj) || !isObject(newObj)) {
-            if (oldObj !== newObj) {
-                callback({
-                    oldPath: oldPath,
-                    newPath: newPath,
-                    type: CHANGE_EVENT,
-                    oldValue: oldObj,
-                    newValue: newObj
-                });
+        if ((!isObject(oldObj) || !isObject(newObj)) && oldObj !== newObj) {
+			callback({
+				oldPath: oldPath,
+				newPath: newPath,
+				type: CHANGE_EVENT,
+				oldValue: oldObj,
+				newValue: newObj
+			});
 
-                return changes;
-            }
+			return changes;
+        }
+
+        if (ignore && ignore(oldObj, newObj, {oldPath: oldPath, newPath: newPath})) {
+			return changes;
         }
 
         if (isArray(oldObj)) {

simple-diff.min.js

@@ -634,4 +634,81 @@ describe('diff', function () {
             }
         ]);
     });
+
+    it('should ignore', function () {
+		var changes = diff(
+			{
+				prop: {
+					test1: {
+					    test11: 1
+                    },
+					test2: 1
+				}
+			},
+			{
+				prop: {
+					test1: {
+						test11: 2
+					},
+					test2: 2
+				}
+			},
+			{
+				ignore: function (a, b, ops) {
+					return ops.oldPath.join('.') === 'prop.test1';
+				}
+			}
+		);
+
+		expect(changes).to.deep.equal([
+			{
+				oldPath: ['prop', 'test2'],
+				newPath: ['prop', 'test2'],
+				type: 'change',
+				oldValue: 1,
+				newValue: 2
+			}
+        ]);
+
+		var root = {
+			prop: {
+			    test2: 2
+            }
+        };
+
+		root.prop.test1 = root;
+
+		changes = diff(
+			root,
+			{
+				prop: {
+					test1: {},
+                    test2: 3
+				}
+			},
+			{
+				ignore: function (oldObj, newObj, options) {
+					var parent = root;
+
+					if (options.oldPath.length === 0) return false;
+					if (parent === oldObj) return true;
+
+					return options.oldPath.slice(0, -1).find(function (prop) {
+						parent = parent[prop];
+						return parent === oldObj;
+					});
+				}
+			}
+		);
+
+		expect(changes).to.deep.equal([
+			{
+				oldPath: ['prop', 'test2'],
+				newPath: ['prop', 'test2'],
+				type: 'change',
+				oldValue: 2,
+				newValue: 3
+			}
+		]);
+    });
 });