Sort arrays of objects with the same keys, optionally, additional by value

README.md

@@ -38,6 +38,35 @@ Ignore case when sorting.
 `--reverse, -r`\
 Reverse the ordering z -> a
 
+`--secondary-sort-by-value, -sv`\
+Sort arrays of objects with identical keys by their value as well.
+
+```
+[
+    {
+        "b":"c",
+        "a": "b",
+        "g": "h"
+    },
+    {
+        "b":"c",
+        "a": "a",
+        "g": "h"
+    },
+] -> [
+    {
+        "a": "a",
+        "b":"c",
+        "g": "h"
+    },
+    {
+        "a": "b",
+        "b":"c",
+        "g": "h"
+    },
+]
+```
+
 `--depth=DEPTH, -d`\
 The sorting _DEPTH_ on multidimensional objects.
 Use a number greater then 0 for the _DEPTH_ value.

app/cmd.js

@@ -10,6 +10,7 @@ const sortJson = require('./');
 const alias = {
   depth: ['d'],
   reverse: ['r'],
+  secondaryValueSort: ['secondary-sort-by-value', 'sv'],
   ignoreCase: ['ignore-case', 'i'],
   indentSize: ['indent-size', 'spaces'],
   noFinalNewLine: ['no-final-newline', 'nn'],

app/overwrite.js

@@ -20,6 +20,7 @@ function overwriteFile(path, options) {
     fileContent = fs.readFileSync(path, 'utf8');
     newData = visit(JSON.parse(fileContent), options);
   } catch (e) {
+    /* eslint-disable-next-line no-console */
     console.error('Failed to retrieve json object from file');
     throw e;
   }

app/visit.js

@@ -14,7 +14,6 @@
 function visit(old, options) {
   const sortOptions = options || {};
 
-  const ignoreCase = sortOptions.ignoreCase || false;
   const reverse = sortOptions.reverse || false;
   const depth = sortOptions.depth || Infinity;
   const level = sortOptions.level || 1;
@@ -27,9 +26,26 @@ function visit(old, options) {
   const copy = Array.isArray(old) ? [] : {};
   let keys = Object.keys(old);
   if (processing) {
-    keys = ignoreCase ?
-      keys.sort((left, right) => left.toLowerCase().localeCompare(right.toLowerCase())) :
-      keys.sort();
+    const sorter = (left, right, { ignoreCase, secondaryValueSort }) => {
+      if (secondaryValueSort && old[left] instanceof Object && old[right] instanceof Object) {
+        const sortedLeft = visit(old[left], options);
+        const sortedRight = visit(old[right], options);
+
+        if (ignoreCase) {
+          return JSON.stringify(sortedLeft)
+            .toLowerCase()
+            .localeCompare(JSON.stringify(sortedRight).toLowerCase());
+        }
+        return JSON.stringify(sortedLeft).localeCompare(JSON.stringify(sortedRight));
+      }
+
+      if (ignoreCase) {
+        return left.toLowerCase().localeCompare(right.toLowerCase());
+      }
+
+      return left.localeCompare(right);
+    };
+    keys.sort((left, right) => sorter(left, right, sortOptions));
   }
 
   if (reverse) {
@@ -39,7 +55,13 @@ function visit(old, options) {
   keys.forEach((key) => {
     const subSortOptions = Object.assign({}, sortOptions);
     subSortOptions.level = level + 1;
-    copy[key] = visit(old[key], subSortOptions);
+    const sortedValue = visit(old[key], subSortOptions);
+
+    if (Array.isArray(copy)) {
+      copy.push(sortedValue);
+    } else {
+      copy[key] = sortedValue;
+    }
   });
 
   return copy;

tests/visit.js

@@ -143,4 +143,279 @@ describe('visit', () => {
 
     expect(JSON.stringify(visit(givenData))).to.equal(JSON.stringify(expectedData));
   });
+
+  it('sorts nested array of similar objects by value case-invariant', () => {
+    const givenData = {
+      "abc": "def",
+      "aa": [
+        {
+          "y": "c",
+          "g": 3,
+          "a": "b",
+        },
+        {
+          "g": 3,
+          "y": "c",
+          "a": "b",
+          "b": "b",
+        },
+        {
+          "a": "b",
+          "y": "c",
+          "g": 3,
+        },
+      ],
+    };
+    const expectedData = {
+      "aa": [
+        {
+          "a": "b",
+          "b": "b",
+          "g": 3,
+          "y": "c",
+        },
+        {
+          "a": "b",
+          "g": 3,
+          "y": "c",
+        },
+        {
+          "a": "b",
+          "g": 3,
+          "y": "c",
+        },
+      ],
+      "abc": "def",
+    };
+
+    const options = {
+      secondaryValueSort: true,
+      ignoreCase: true,
+    };
+
+    expect(JSON.stringify(visit(givenData, options))).to.equal(JSON.stringify(expectedData));
+  });
+
+  it('sorts nested array of objects by value case-invariant', () => {
+    const givenData = [
+      {
+        "y": "c",
+        "g": 3,
+        "a": "b",
+      },
+      {
+        "a": "aa",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "g": 1,
+        "y": "b",
+        "a": "h",
+      },
+      {
+        "a": "a",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "a": "aa",
+        "g": 3,
+        "y": 100,
+      },
+      {
+        "y": 101,
+        "a": "A",
+        "g": 3,
+      },
+    ];
+    const expectedData = [
+      {
+        "a": "A",
+        "g": 3,
+        "y": 101
+      },
+      {
+        "a": "a",
+        "g": 4,
+        "y": 100
+      },
+      {
+        "a": "aa",
+        "g": 3,
+        "y": 100
+      },
+      {
+        "a": "aa",
+        "g": 4,
+        "y": 100
+      },
+      {
+        "a": "b",
+        "g": 3,
+        "y": "c"
+      },
+      {
+        "a": "h",
+        "g": 1,
+        "y": "b"
+      },
+    ];
+
+    const options = {
+      secondaryValueSort: true,
+      ignoreCase: true,
+    };
+
+    expect(JSON.stringify(visit(givenData, options))).to.equal(JSON.stringify(expectedData));
+  });
+
+  it('sorts nested array of objects by value case-variant', () => {
+    const givenData = [
+      {
+        "y": "c",
+        "g": 3,
+        "a": "b",
+      },
+      {
+        "a": "aa",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "a": "aa",
+        "g": 3,
+        "y": 100,
+      },
+      {
+        "g": 1,
+        "y": "b",
+        "a": "h",
+      },
+      {
+        "a": "a",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "y": 101,
+        "a": "A",
+        "g": 3,
+      },
+    ];
+    const expectedData = [
+      {
+        "a": "A",
+        "g": 3,
+        "y": 101
+      },
+      {
+        "a": "a",
+        "g": 4,
+        "y": 100
+      },
+      {
+        "a": "aa",
+        "g": 3,
+        "y": 100
+      },
+      {
+        "a": "aa",
+        "g": 4,
+        "y": 100
+      },
+      {
+        "a": "b",
+        "g": 3,
+        "y": "c"
+      },
+      {
+        "a": "h",
+        "g": 1,
+        "y": "b"
+      }
+    ];
+
+    const options = {
+      secondaryValueSort: true,
+      ignoreCase: false,
+    };
+
+    expect(JSON.stringify(visit(givenData, options))).to.equal(JSON.stringify(expectedData));
+  });
+
+  it('sorts nested array of objects not value', () => {
+    const givenData = [
+      {
+        "y": "c",
+        "g": 3,
+        "a": "b",
+      },
+      {
+        "a": "aa",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "a": "aa",
+        "g": 3,
+        "y": 100,
+      },
+      {
+        "g": 1,
+        "y": "b",
+        "a": "h",
+      },
+      {
+        "a": "a",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "y": 101,
+        "a": "A",
+        "g": 3,
+      },
+    ];
+    const expectedData = [
+      {
+        "a": "b",
+        "g": 3,
+        "y": "c",
+      },
+      {
+        "a": "aa",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "a": "aa",
+        "g": 3,
+        "y": 100,
+      },
+      {
+        "a": "h",
+        "g": 1,
+        "y": "b",
+      },
+      {
+        "a": "a",
+        "g": 4,
+        "y": 100,
+      },
+      {
+        "a": "A",
+        "g": 3,
+        "y": 101,
+      }
+    ];
+
+    const options = {
+      secondaryValueSort: false,
+      ignoreCase: false,
+    };
+
+    expect(JSON.stringify(visit(givenData, options))).to.equal(JSON.stringify(expectedData));
+  });
+
 });