feat: add allowLineSeparatedGroups option to sort-keys (fixes #12759)

docs/rules/sort-keys.md

@@ -61,7 +61,7 @@ let obj = {b: 1, ...c, a: 2};
 
 ```json
 {
-    "sort-keys": ["error", "asc", {"caseSensitive": true, "natural": false, "minKeys": 2}]
+    "sort-keys": ["error", "asc", {"caseSensitive": true, "natural": false, "minKeys": 2, "allowLineSeparatedGroups": false}]
 }
 ```
 
@@ -75,6 +75,7 @@ The 2nd option is an object which has 3 properties.
 * `caseSensitive` - if `true`, enforce properties to be in case-sensitive order. Default is `true`.
 * `minKeys` - Specifies the minimum number of keys that an object should have in order for the object's unsorted keys to produce an error. Default is `2`, which means by default all objects with unsorted keys will result in lint errors.
 * `natural` - if `true`, enforce properties to be in natural order. Default is `false`. Natural Order compares strings containing combination of letters and numbers in the way a human being would sort. It basically sorts numerically, instead of sorting alphabetically. So the number 10 comes after the number 3 in Natural Sorting.
+* `allowLineSeparatedGroups` - if `true`, Group object keys through line break. Default is `false`.
 
 Example for a list:
 
@@ -214,6 +215,38 @@ let obj = {
 };
 ```
 
+### allowLineSeparatedGroups
+
+Examples of **incorrect** code for the `{allowLineSeparatedGroups: true}` option:
+
+```js
+/*eslint sort-keys: ["error", "asc", {allowLineSeparatedGroups: true}]*//
+/*eslint-env es6*/
+
+// Each group follows the sort-keys rule.
+let obj = {
+    c: 2,
+    b: 3, // 'b' should be before 'c'.
+
+    a: 3
+};
+```
+
+Examples of **correct** code for the `{allowLineSeparatedGroups: true}` option:
+
+```js
+/*eslint sort-keys: ["error", "asc", {allowLineSeparatedGroups: true}]*//
+/*eslint-env es6*/
+
+// Divide groups through line breaks.
+let obj = {
+    b: 2,
+    c: 3,
+
+    a: 3
+};
+```
+
 ## When Not To Use It
 
 If you don't want to notify about properties' order, then it's safe to disable this rule.

lib/rules/sort-keys.js

@@ -37,6 +37,20 @@ function getPropertyName(node) {
     return node.key.name || null;
 }
 
+/**
+ * Check the Line Separated Groups
+ *
+ * - Compare the start line of the current node with the last line of the previous node.
+ *   If the difference between the two values is greater than 0, Not the same group.
+ * @param {number} thisStartLine is start line of the current node.
+ * @param {number} prevEndLine is end line of the previous node.
+ * @returns {number} number of lines between nodes.
+ * @private
+ */
+function checkLineSeparatedGroups(thisStartLine, prevEndLine) {
+    return Math.max(thisStartLine - prevEndLine - 1, 0);
+}
+
 /**
  * Functions which check that the given 2 names are in specific order.
  *
@@ -105,13 +119,18 @@ module.exports = {
                         type: "integer",
                         minimum: 2,
                         default: 2
+                    },
+                    allowLineSeparatedGroups: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
             }
         ],
 
         messages: {
+            allowLineSeparatedGroups: "'{{thisName}}' should be before '{{prevName}}'. To separate groups by line break, apply the allowLineSeparatedGroups option.",
             sortKeys: "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'."
         }
     },
@@ -124,6 +143,7 @@ module.exports = {
         const insensitive = options && options.caseSensitive === false;
         const natural = options && options.natural;
         const minKeys = options && options.minKeys;
+        const allowLineSeparatedGroups = options && options.allowLineSeparatedGroups || false;
         const isValidOrder = isValidOrders[
             order + (insensitive ? "I" : "") + (natural ? "N" : "")
         ];
@@ -136,6 +156,7 @@ module.exports = {
                 stack = {
                     upper: stack,
                     prevName: null,
+                    prevEndLine: null,
                     numKeys: node.properties.length
                 };
             },
@@ -156,13 +177,24 @@ module.exports = {
                 }
 
                 const prevName = stack.prevName;
+                const prevEndLine = stack.prevEndLine;
                 const numKeys = stack.numKeys;
                 const thisName = getPropertyName(node);
+                const thisStartLine = node.loc.start.line;
+                const isLineSeparatedGroups = prevEndLine && checkLineSeparatedGroups(thisStartLine, prevEndLine);
+
+                if (thisStartLine !== null) {
+                    stack.prevEndLine = thisStartLine;
+                }
 
                 if (thisName !== null) {
                     stack.prevName = thisName;
                 }
 
+                if (allowLineSeparatedGroups && isLineSeparatedGroups) {
+                    return;
+                }
+
                 if (prevName === null || thisName === null || numKeys < minKeys) {
                     return;
                 }
@@ -171,7 +203,7 @@ module.exports = {
                     context.report({
                         node,
                         loc: node.key.loc,
-                        messageId: "sortKeys",
+                        messageId: isLineSeparatedGroups ? "allowLineSeparatedGroups" : "sortKeys",
                         data: {
                             thisName,
                             prevName,

tests/lib/rules/sort-keys.js

@@ -163,7 +163,53 @@ ruleTester.run("sort-keys", rule, {
         { code: "var obj = {è:4, À:3, 'Z':2, '#':1}", options: ["desc", { natural: true, caseSensitive: false }] },
 
         // desc, natural, insensitive, minKeys should ignore unsorted keys when number of keys is less than minKeys
-        { code: "var obj = {a:1, _:2, b:3}", options: ["desc", { natural: true, caseSensitive: false, minKeys: 4 }] }
+        { code: "var obj = {a:1, _:2, b:3}", options: ["desc", { natural: true, caseSensitive: false, minKeys: 4 }] },
+
+        // allowLineSeparatedGroups, default false
+        {
+            code: `
+                var obj = {
+                    f: 1,
+                    g: 2,
+
+
+                    a: 3,
+                    b: 4,
+                    c: 5,
+
+                    d: 6,
+                    e: 7
+                }
+            `,
+            options: ["asc", { allowLineSeparatedGroups: true }]
+        },
+        {
+            code: `
+                var obj = {
+                    b: 1,
+                    c: 2,
+
+                    a: 3
+                }
+            `,
+            options: ["asc", { allowLineSeparatedGroups: true }]
+        },
+        {
+            code: `
+                var obj = {
+                    c: 1,
+                    d: 2,
+
+                    a: 3,
+                    b() {
+
+                    },
+                    e: 4
+                }
+            `,
+            options: ["asc", { allowLineSeparatedGroups: true }],
+            parserOptions: { ecmaVersion: 6 }
+        }
     ],
     invalid: [
 
@@ -1761,6 +1807,28 @@ ruleTester.run("sort-keys", rule, {
                     }
                 }
             ]
+        },
+
+        // If allowLineSeparatedGroups option is false, Groups are not divided by line breaks.
+        {
+            code: `
+                var obj = {
+                    b: 1,
+                    c: 2,
+
+                    a: 3
+                }
+            `,
+            options: ["asc", { allowLineSeparatedGroups: false }],
+            errors: [
+                {
+                    messageId: "allowLineSeparatedGroups",
+                    data: {
+                        thisName: "a",
+                        prevName: "c"
+                    }
+                }
+            ]
         }
     ]
 });