feat: suggestions

Author: UnderKoen

lib/rules/invalid-regex-rule.js

@@ -1,10 +1,10 @@
 //  Copyright (c) 2020 Gonzalo Müller Bravo.
 //  Licensed under the MIT License (MIT), see LICENSE.txt
-const { buildCreateFunction } = require('../utils/create-utils.js')
-const { formatReportMessage } = require('../utils/report-utils.js')
-const { shouldCheck } = require('../utils/check-utils.js')
+const {buildCreateFunction} = require('../utils/create-utils.js')
+const {formatReportMessage} = require('../utils/report-utils.js')
+const {shouldCheck} = require('../utils/check-utils.js')
 
-const { REGEX_FLAGS_FIELD_DEFINITION, FILES_FIELD_DEFINITION } = require('./common-fields-definitions.js')
+const {REGEX_FLAGS_FIELD_DEFINITION, FILES_FIELD_DEFINITION} = require('./common-fields-definitions.js')
 
 /**
  * @param {string} source Text that was checked.
@@ -14,9 +14,9 @@ const { REGEX_FLAGS_FIELD_DEFINITION, FILES_FIELD_DEFINITION } = require('./comm
 function foundStartLocation(source, foundAt) {
   return Array.from(source.substring(0, foundAt))
     .reduce((result, char) => char !== '\n'
-      ? { line: result.line, column: result.column + 1 }
-      : { line: result.line + 1, column: 0 },
-    { line: 1, column: 0 })
+      ? {line: result.line, column: result.column + 1}
+      : {line: result.line + 1, column: 0},
+    {line: 1, column: 0})
 }
 
 /**
@@ -28,8 +28,9 @@ function foundStartLocation(source, foundAt) {
  * @param {{ regex: RegExp, id: string | undefined, message: string | undefined }} pattern Information of the pattern to be use to inspect.
  * @param {*} replace Replacement function
  * @param {Function} report Report function
+ * @param {*[]} [suggestions] Array of suggestion functions.
  */
-function checkRegex(source, pattern, replace, report) {
+function checkRegex(source, pattern, replace, report, suggestions = []) {
   /**
    * @param {string} source Text to be checked.
    * @param {RegExp} regex Regular Expression use to check.
@@ -48,12 +49,16 @@ function checkRegex(source, pattern, replace, report) {
     from => `Invalid regular expression ${from} found`
   )
   pattern.regex.test('')
-  let matchDetail = { matchStart: -1 }
-  while(matchDetail.matchStart !== matchDetail.nextChar && (matchDetail = checkRegexInSource())) {
+  let matchDetail = {matchStart: -1}
+  while (matchDetail.matchStart !== matchDetail.nextChar && (matchDetail = checkRegexInSource())) {
     report({
-      loc: { start: foundStartLocation(source, matchDetail.matchStart) },
+      loc: {start: foundStartLocation(source, matchDetail.matchStart)},
       message,
-      fix: replace(0, matchDetail)
+      fix: replace(0, matchDetail),
+      suggest: suggestions.map(s => ({
+        desc: s.message,
+        fix: s.replacement(0, matchDetail),
+      })),
     })
   }
 }
@@ -68,11 +73,12 @@ function buildReplacementFunction(replacement) {
           return replacement
         }
       }
-      catch(e) {}
+      catch (e) {
+      }
       return $[0]
     }
   }
-  catch(e) {
+  catch (e) {
     return null
   }
 }
@@ -91,7 +97,7 @@ function createReplacement(replacement) {
   switch (typeof replacement) {
     case 'string':
       return (from, matchDetail) => fixer => fixer.replaceTextRange([from + matchDetail.matchStart, from + matchDetail.nextChar], replacement)
-    case 'object':{
+    case 'object': {
       const replacementFunction = buildReplacementFunction(replacement.function)
       if (typeof replacementFunction === 'function') {
         return (from, matchDetail) =>
@@ -106,14 +112,27 @@ function createReplacement(replacement) {
 }
 
 function checkPatterns(fileName, source, patterns, report) {
-  patterns.forEach(pattern => shouldCheck(pattern.files, fileName) &&
-    checkRegex(source, pattern, createReplacement(pattern.details.replacement), report))
+  patterns.forEach(pattern => {
+    if (!shouldCheck(pattern.files, fileName)) {
+      return
+    }
+
+    const replacement = createReplacement(pattern.details.replacement)
+    let suggestions = pattern.details.suggestions || []
+    suggestions = suggestions.map((d) => ({
+      message: d.message,
+      replacement: createReplacement(d.replacement)
+    }))
+
+    checkRegex(source, pattern, replacement, report, suggestions)
+  })
 }
 
 module.exports = {
   meta: {
     type: 'suggestion',
     fixable: 'code',
+    hasSuggestions: true,
     docs: {
       description: 'Invalid regular expressions to be reported',
       category: 'Stylistic Issues',
@@ -148,7 +167,7 @@ module.exports = {
             },
             flags: REGEX_FLAGS_FIELD_DEFINITION,
             replacement: {
-              oneOf:[{
+              oneOf: [{
                 title: 'Replacement',
                 description: 'Replacement for invalid pattern',
                 type: 'string'
@@ -168,15 +187,53 @@ module.exports = {
                 maxProperties: 1
               }]
             },
-            message: {
-              title: 'Invalid message',
-              description: 'Message to be shown when Invalid pattern is found',
-              type: 'string',
-              minLength: 3
+            suggestions: {
+              type: 'array',
+              description: 'Array of suggestions to be used when the pattern is found',
+              title: 'Suggestions',
+              items: {
+                type: 'object',
+                description: 'Suggestion to be used when the pattern is found',
+                properties: {
+                  message: {
+                    title: 'Suggestion message',
+                    description: 'Message to be shown when the suggestion is applied',
+                    type: 'string',
+                    minLength: 3
+                  },
+                  replacement: {
+                    oneOf: [{
+                      title: 'Replacement',
+                      description: 'Replacement for invalid pattern',
+                      type: 'string'
+                    }, {
+                      title: 'Detailed replacement',
+                      description: 'Detailed replacements for invalid patterns',
+                      type: 'object',
+                      properties: {
+                        function: {
+                          title: 'Replacement function',
+                          description: 'Function used to replace the found pattern. It receives the found text and must return the replacement text',
+                          type: 'string',
+                          minLength: 1
+                        }
+                      },
+                      minProperties: 1,
+                      maxProperties: 1
+                    }]
+                  }
+                },
+              },
+              message: {
+                title: 'Invalid message',
+                description: 'Message to be shown when Invalid pattern is found',
+                type: 'string',
+                minLength: 3
+              },
+              files: FILES_FIELD_DEFINITION
             },
-            files: FILES_FIELD_DEFINITION
-          },
-          required: ['regex']
+            required: ['regex']
+          }
         }]
       },
       minItems: 1