comparators:

Author: Sergii.Kliuchnyk

README.md

@@ -140,6 +140,34 @@ Property name with unique value in it array. Default value is `id`. If your arra
 
 Hash where key is path to array and value is id property. Path examples: `users.list`, `user.list.1.friends`, `users.list.*.friends`
 
+## `comparators: [[Class, function (oldValue, newValue, options)], ...]`
+
+Array of comparators to handle comparison of objects which do not have own properties. For example instead of `user.name` you have `user.getName()` or you need to compare `Date` objects or you just know quick way to compare large objects like by `id` property and you do not need full list of changes of those objects. First value of comparator should be some class and second is function which should return `true` if objects are equal and `false` if they not. In `options` will be `oldPath` and `newPath`.
+```javascript
+var now = new Date();
+var prevHour = new Date();
+prevHour.setHours(-1);
+
+var changes = diff(
+	{
+		createdAt: now
+	},
+	{
+		createdAt: prevHour
+	},
+	{
+		comparators: [
+			[Date, function(oldValue, newValue, options) {
+			    options.oldPath; // ['createdAt']
+			    options.newPath; // ['createdAt']
+			    
+			    return oldValue.toString() === newValue.toString();
+			}]
+		]
+	}
+);
+```
+
 ## `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.4.0",
+  "version": "1.5.0",
   "homepage": "https://github.com/redexp/simple-diff",
   "authors": [
     "Sergii Kliuchnyk <sergiikliuchnyk@gmail.com>"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-diff",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "simple diff for object and arrays with options",
   "main": "simple-diff.js",
   "scripts": {
@@ -25,6 +25,8 @@
     "gulp-rename": "^1.2.2",
     "gulp-replace": "^0.5.4",
     "gulp-uglify": "^1.5.4",
-    "mocha": "^2.5.3"
+    "mocha": "^2.5.3",
+    "sinon": "^1.17.7",
+    "sinon-chai": "^2.8.0"
   }
 }

simple-diff.js

@@ -28,6 +28,7 @@
             callback = ops.callback || function (item) {
                 changes.push(item);
             },
+            comparators = ops.comparators || [],
             i, len, prop, id;
 
         if (!isObject(oldObj) || !isObject(newObj)) {
@@ -180,6 +181,29 @@
             }
         }
         else {
+            if (comparators.length > 0) {
+                for (i = 0, len = comparators.length; i < len; i++) {
+                    if (oldObj instanceof comparators[i][0] === false && newObj instanceof comparators[i][0] === false) continue;
+
+                    var objEqual = comparators[i][1](oldObj, newObj, {
+                        oldPath: oldPath,
+                        newPath: newPath
+                    });
+
+                    if (!objEqual) {
+						callback({
+							oldPath: oldPath,
+							newPath: newPath,
+							type: CHANGE_EVENT,
+							oldValue: oldObj,
+							newValue: newObj
+						});
+                    }
+
+					return changes;
+				}
+            }
+
             for (prop in oldObj) {
                 if (!oldObj.hasOwnProperty(prop)) continue;
 

simple-diff.min.js

@@ -1,7 +1,10 @@
 var expect = require('chai').expect,
+    sinon = require('sinon'),
     diff = require('../simple-diff'),
     undefined;
 
+require('chai').use(require('sinon-chai'));
+
 describe('diff', function () {
     it('should find changes in objects', function () {
         var changes = diff(
@@ -550,4 +553,85 @@ describe('diff', function () {
             }
         ]);
     });
+
+    it('should handle comparators: [] to compare custom class objects', function () {
+        var cb = sinon.spy(function (a, b, ops) {
+			expect(a).to.be.instanceOf(Date);
+			expect(b).to.be.instanceOf(Date);
+
+			expect(ops).to.deep.equal({
+				oldPath: ['prop', 'date'],
+				newPath: ['prop', 'date']
+			});
+
+            return a.toString() === b.toString();
+		});
+
+        var changes = diff(
+            {
+                prop: {
+                    test1: {},
+                    test2: [{}],
+                    date: new Date()
+                }
+            },
+            {
+                prop: {
+					test1: {},
+					test2: [{}],
+                    date: new Date()
+                }
+            },
+            {
+                comparators: [
+                    [Date, cb]
+                ]
+            }
+        );
+
+        expect(changes).to.deep.equal([]);
+        expect(cb).to.have.callCount(1);
+
+        var nowDate = new Date();
+        var prevDate = new Date();
+        prevDate.setHours(-1);
+
+		changes = diff(
+			{
+				prop: {
+					test1: 1,
+					date: nowDate
+				}
+			},
+			{
+				prop: {
+					test1: 2,
+					date: prevDate
+				}
+			},
+			{
+				comparators: [
+					[Date, cb]
+				]
+			}
+		);
+
+		expect(cb).to.have.callCount(2);
+		expect(changes).to.deep.equal([
+            {
+                oldPath: ['prop', 'test1'],
+                newPath: ['prop', 'test1'],
+                type: 'change',
+                oldValue: 1,
+                newValue: 2
+            },
+            {
+                oldPath: ['prop', 'date'],
+                newPath: ['prop', 'date'],
+                type: 'change',
+                oldValue: nowDate,
+                newValue: prevDate
+            }
+        ]);
+    });
 });