[minor] ignore sort ordering with objects

Author: omgaz

src/index.js

@@ -7,7 +7,15 @@ function isArray(toCheck) {
   return typeof toCheck === 'object' && Boolean(toCheck.length);
 }
 
-const defaultOptions = {
+function isPrimitive(toCheck) {
+  return toCheck !== Object(toCheck);
+}
+
+function toPrimitive(val) {
+  return isPrimitive(val) ? val : JSON.stringify(val);
+}
+
+var defaultOptions = {
   respectArrayOrder: true,
 };
 
@@ -39,11 +47,11 @@ function diffler(obj1, obj2, options = defaultOptions) {
 
       // If property is an object then we need to recursively go down the rabbit hole
       else if (typeof obj1Val === 'object') {
-        let obj1ValForDiff = obj1Val;
-        let obj2ValForDiff = obj2Val;
+        var obj1ValForDiff = obj1Val;
+        var obj2ValForDiff = obj2Val;
         if (!options.respectArrayOrder && isArray(obj1Val) && isArray(obj2Val)) {
-          obj1ValForDiff = obj1Val.sort();
-          obj2ValForDiff = obj2Val.sort();
+          obj1ValForDiff = obj1Val.map(toPrimitive).sort();
+          obj2ValForDiff = obj2Val.map(toPrimitive).sort();
         }
         var tempDiff = diffler(obj1ValForDiff, obj2ValForDiff);
         if (Object.keys(tempDiff).length > 0) {

tests/index.js

@@ -58,43 +58,56 @@ describe('getDiff', () => {
       const testObjectB = { arr: ['three', 'two', 'one'] };
       const difference = diffler(testObjectA, testObjectB);
       assert.strictEqual(Object.keys(difference).length, 1);
-      assert.deepStrictEqual(difference, { arr: { 0: { from: 'one', to: 'three' }, 2: { from: 'three', to: 'one' } } });
+      assert.deepStrictEqual(difference, {
+        arr: {
+          0: { from: 'one', to: 'three' },
+          2: { from: 'three', to: 'one' },
+        },
+      });
     });
 
     it('returns false when array order shifted but respectArrayOrder is false', () => {
       const testObjectA = { arr: ['one', 'two', 'three'] };
       const testObjectB = { arr: ['three', 'two', 'one'] };
-      const difference = diffler(testObjectA, testObjectB, { respectArrayOrder: false });
+      const difference = diffler(testObjectA, testObjectB, {
+        respectArrayOrder: false,
+      });
       assert.strictEqual(Object.keys(difference).length, 0);
       assert.deepStrictEqual(difference, {});
     });
 
     it('returns false when array order shifted but respectArrayOrder is false as numbers', () => {
       const testObjectA = { arr: [1, 2, 3] };
       const testObjectB = { arr: [2, 3, 1] };
-      const difference = diffler(testObjectA, testObjectB, { respectArrayOrder: false });
+      const difference = diffler(testObjectA, testObjectB, {
+        respectArrayOrder: false,
+      });
       assert.strictEqual(Object.keys(difference).length, 0);
       assert.deepStrictEqual(difference, {});
     });
 
     it('returns false when array order shifted but respectArrayOrder is false as mixed', () => {
       const testObjectA = { arr: [1, 'two', 3] };
       const testObjectB = { arr: ['two', 3, 1] };
-      const difference = diffler(testObjectA, testObjectB, { respectArrayOrder: false });
+      const difference = diffler(testObjectA, testObjectB, {
+        respectArrayOrder: false,
+      });
       assert.strictEqual(Object.keys(difference).length, 0);
       assert.deepStrictEqual(difference, {});
     });
 
-    it('returns diff when array order shifted for non-primitives and respectArrayOrder is false', () => {
+    it('returns no diff when array order shifted for non-primitives and respectArrayOrder is false', () => {
       const testObjectA = {
-        myArray: [{ foo: 'bar' }, { baz: 'bat' }],
+        myArray: ['a string', { foo: 'bar' }, 1, { baz: 'bat' }],
       };
 
       const testObjectB = {
-        myArray: [{ baz: 'bat' }, { foo: 'bar' }],
+        myArray: [{ baz: 'bat' }, { foo: 'bar' }, 1, 'a string'],
       };
-      const difference = diffler(testObjectA, testObjectB, { respectArrayOrder: false });
-      assert.strictEqual(Object.keys(difference).length, 1);
+      const difference = diffler(testObjectA, testObjectB, {
+        respectArrayOrder: false,
+      });
+      assert.strictEqual(Object.keys(difference).length, 0);
       assert.deepStrictEqual(difference, {});
     });
 
@@ -103,23 +116,32 @@ describe('getDiff', () => {
       const testObjectB = { arr: ['one', 'two', 'three'] };
       const difference = diffler(testObjectA, testObjectB);
       assert.strictEqual(Object.keys(difference).length, 1);
-      assert.deepStrictEqual(difference, { arr: { 2: { from: null, to: 'three' } } });
+      assert.deepStrictEqual(difference, {
+        arr: { 2: { from: null, to: 'three' } },
+      });
     });
 
     it('returns change when array item removed', () => {
       const testObjectA = { arr: ['one', 'two', 'three'] };
       const testObjectB = { arr: ['one', 'two'] };
       const difference = diffler(testObjectA, testObjectB);
       assert.strictEqual(Object.keys(difference).length, 1);
-      assert.deepStrictEqual(difference, { arr: { 2: { from: 'three', to: null } } });
+      assert.deepStrictEqual(difference, {
+        arr: { 2: { from: 'three', to: null } },
+      });
     });
 
     it('returns change and removal when array item removed from middle', () => {
       const testObjectA = { arr: ['one', 'two', 'three'] };
       const testObjectB = { arr: ['one', 'three'] };
       const difference = diffler(testObjectA, testObjectB);
       assert.strictEqual(Object.keys(difference).length, 1);
-      assert.deepStrictEqual(difference, { arr: { 1: { from: 'two', to: 'three' }, 2: { from: 'three', to: null } } });
+      assert.deepStrictEqual(difference, {
+        arr: {
+          1: { from: 'two', to: 'three' },
+          2: { from: 'three', to: null },
+        },
+      });
     });
   });