## 1.5.0 - February 2021

* Adds capturing groups to replacement functions for invalid patterns.

Author: gmullerb

CHANGELOG.md

@@ -1,5 +1,9 @@
 # ESLint Plugin Regex Change Log
 
+## 1.5.0 - February 2021
+
+* Adds capturing groups to replacement functions for invalid patterns.
+
 ## 1.4.0 - February 2021
 
 * Adds replacements with functions for invalid patterns.

README.md

@@ -23,7 +23,7 @@ __________________
   ..
   "devDependencies": {
     "eslint": ">=4.0.0",
-    "eslint-plugin-regex": "1.4.0",
+    "eslint-plugin-regex": "1.5.0",
     ..
 ```
 
@@ -215,7 +215,7 @@ It is specified by an `object`, with the following fields:
   * An optional `string` used to replace the **invalid** found pattern, or
   * An optional `object` that establish how the **invalid** found pattern will be replaced:
     * `function`: used to replace the **invalid** found pattern.
-      * It will receive only 1 parameter with the name `text`.
+      * It will receive 2 parameters: `text` and `captured`.
       * It must return a `string` value, if not, return value will be ignored.
       * Its definition must be only the body of the function.
       * [More Information](#definition-of-the-function-used-to-replace-invalid-found-pattern).
@@ -245,21 +245,24 @@ It is specified by an `object`, with the following fields:
 
 > [1] In order to fix issues `eslint` must be run with `--fix` option.
 
-##### Definition of the Function used to replace **invalid** found pattern
+##### Definition of the Function used to replace the *invalid* found pattern
 
 Definition of the function must be done as a `string` in 1 line, and the following rules apply:
 
 * It must return a `string` value, if not, return value will be ignored, i.e. it will silently fail.
-* Its definition must be only the body of the function.
+* Its definition must be **only the body of the function**.
 * If the function has invalid Javascript code, the function will be ignored, i.e. it will silently fail.
 
-Function will receive only 1 parameter with the name `text`, with the value of the invalid text found.
+Function will receive 2 parameters:
 
-e.g.
+* `text`: a `string` with the value of the invalid text found.
+* `captured`: an `array` of strings with the values of the captured groups for the regex.
 
-`"return text.trim()"` => only the body of the function + return a `string` value
+e.g. Using parameter `text`
 
-`.eslintrc.json`:`
+`"return text.trim()"` => only the body of the function + returns a `string` value based on `text`
+
+Having the following rule in `.eslintrc.json`:
 
 ```json
 {
@@ -285,6 +288,49 @@ when linting with fix, the result will be:
 const exception = "error19"
 ```
 
+e.g. Using parameter `captured`
+
+`"return captured[0]"` => only the body of the function + returns a `string` value based on `captured`
+
+Having the following rule in `.eslintrc.json`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror(\\w*)\\s",
+  "replacement": {
+    "function": "return captured[0]"
+  }
+}
+```
+
+then, given:
+
+`example.js`
+
+```js
+const exception = " error19 "
+```
+
+when linting with fix, the result will be:
+
+```js
+const exception = "19"
+```
+
+###### Debugging of the Replacement Function for *invalid* found pattern
+
+* It is possible to add `console` statements to print some information in the Replacement Function.
+
+```json
+{
+      regex: '\\serror(\\w*)\\s',
+      replacement: {
+        function: 'const extract = captured[0]; console.log(extract); return extract'
+      }
+    }
+```
+
 #### Mixing definitions
 
 It is possible to use both type of definitions, 'Short pattern definition' with 'Detailed pattern definition', in the array of patterns.

docs/rules/invalid-regex-rule.md

@@ -61,7 +61,7 @@ It is specified by an `object`, with the following fields:
   * An optional `string` used to replace the invalid found pattern, or
   * An optional `object` that establish how the invalid found pattern will be replaced:
     * `function`: used to replace the invalid found pattern.
-      * It will receive only 1 parameter with the name `text`.
+      * It will receive 2 parameters: `text` and `captured`.
       * It must return a `string` value, if not, return value will be ignored.
       * Its definition must be only the body of the function.
       * [More Information](#definition-of-the-function-used-to-replace-invalid-found-pattern).
@@ -105,21 +105,24 @@ It is specified by an `object`, with the following fields:
 }
 ```
 
-#### Definition of the Function used to replace **invalid** found pattern
+#### Definition of the Function used to replace the invalid found pattern
 
 Definition of the function must be done as a `string` in 1 line, and the following rules apply:
 
 * It must return a `string` value, if not, return value will be ignored, i.e. it will silently fail.
-* Its definition must be only the body of the function.
+* Its definition must be **only the body of the function**.
 * If the function has invalid Javascript code, the function will be ignored, i.e. it will silently fail.
 
-Function will receive only 1 parameter with the name `text`, with the value of the invalid text found.
+Function will receive 2 parameters:
 
-e.g.
+* `text`: a `string` with the value of the invalid text found.
+* `captured`: an `array` of strings with the values of the captured groups for the regex.
 
-`"return text.trim()"` => only the body of the function + return a `string` value
+e.g. Using parameter `text`
 
-`.eslintrc.json`:`
+`"return text.trim()"` => only the body of the function + returns a `string` value based on `text`
+
+Having the following rule in `.eslintrc.json`:
 
 ```json
 {
@@ -145,6 +148,49 @@ when linting with fix, the result will be:
 const exception = "error19"
 ```
 
+e.g. Using parameter `captured`
+
+`"return captured[0]"` => only the body of the function + returns a `string` value based on `captured`
+
+Having the following rule in `.eslintrc.json`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror(\\w*)\\s",
+  "replacement": {
+    "function": "return captured[0]"
+  }
+}
+```
+
+then, given:
+
+`example.js`
+
+```js
+const exception = " error19 "
+```
+
+when linting with fix, the result will be:
+
+```js
+const exception = "19"
+```
+
+##### Debugging of the Replacement Function for invalid found pattern
+
+* It is possible to add `console` statements to print some information in the Replacement Function.
+
+```json
+{
+      regex: '\\serror(\\w*)\\s',
+      replacement: {
+        function: 'const extract = captured[0]; console.log(extract); return extract'
+      }
+    }
+```
+
 ### String to Regular expression conversion
 
 Internally, each string from the array will be converted into a Regular Expression with `global` and `multiline` options, e.g.:

lib/rules/invalid-regex-rule.js

@@ -36,7 +36,8 @@ function checkRegexInSource(source, regex) {
   const foundDetail = regex.exec(source)
   return !!foundDetail
     ? {
-        pattern: foundDetail[0],
+        pattern: foundDetail.shift(),
+        captured: foundDetail,
         patternIndex: foundDetail.index,
         nextChar: regex.lastIndex
       }
@@ -73,7 +74,7 @@ function checkRegex(source, sourceLines, nextLine, nextChar, rootChar, pattern,
             pattern,
             from => `Invalid regular expression ${from} found`
           ),
-          fix: replace(rootChar, sourceDetail.patternIndex, sourceDetail.nextChar, sourceDetail.pattern)
+          fix: replace(rootChar, sourceDetail)
         })
         checkRegex(remainingSource, sourceLines, foundDetail.nextLine, foundDetail.nextChar, rootChar + remainingSourceStart,
           pattern, replace, report)
@@ -85,7 +86,7 @@ function checkRegex(source, sourceLines, nextLine, nextChar, rootChar, pattern,
             pattern,
             from => `Invalid regular expression ${from} found`
           ),
-          fix: replace(rootChar, sourceDetail.patternIndex, sourceDetail.nextChar, sourceDetail.pattern)
+          fix: replace(rootChar, sourceDetail)
         })
         checkRegex(remainingSource, sourceLines, nextLine + 1, nextChar, rootChar + remainingSourceStart, pattern, replace, report)
       }
@@ -96,18 +97,16 @@ function checkRegex(source, sourceLines, nextLine, nextChar, rootChar, pattern,
 function buildReplacementFunction(replacement) {
   if (/\breturn\b/.test(replacement)) {
     try {
-      const replacementFunction = new Function('text', replacement) // eslint-disable-line no-new-func
-      if(typeof replacementFunction('text') === 'string') {
-        return text => {
-          try {
-            const replacement = replacementFunction(text)
-            if (typeof replacement === 'string') {
-              return replacement
-            }
+      const replacementFunction = new Function('text', 'captured', replacement) // eslint-disable-line no-new-func
+      return (text, captured) => {
+        try {
+          const replacement = replacementFunction(text, captured)
+          if (typeof replacement === 'string') {
+            return replacement
           }
-          catch(e) { }
-          return text
         }
+        catch(e) {}
+        return text
       }
     }
     catch(e) {}
@@ -118,13 +117,16 @@ function buildReplacementFunction(replacement) {
 function createReplacement(replacement) {
   switch (typeof replacement) {
     case 'string':
-      return (from, deltaStart, deltaEnd) => fixer => fixer.replaceTextRange([from + deltaStart, from + deltaEnd], replacement)
+      return (from, found) => fixer => fixer.replaceTextRange([from + found.patternIndex, from + found.nextChar], replacement)
     case 'object':
       if (typeof replacement.function === 'string') {
         const replacementFunction = buildReplacementFunction(replacement.function)
         if (typeof replacementFunction === 'function') {
-          return (from, deltaStart, deltaEnd, text) =>
-            fixer => fixer.replaceTextRange([from + deltaStart, from + deltaEnd], replacementFunction(text))
+          return (from, found) =>
+            fixer => fixer.replaceTextRange(
+              [from + found.patternIndex, from + found.nextChar],
+              replacementFunction(found.pattern, found.captured)
+            )
         }
       }
   }

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-regex",
   "description": "ESLint rules using Regular Expression",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "license": "MIT",
   "author": "Gonzalo Müller Bravo",
   "main": "lib/index.js",

package.json

@@ -402,6 +402,66 @@ const shouldNotReplaceWithInvalidFunctionCase07 = {
   output: 'var z = 1\nvar x = "invalid"'
 }
 
+const shouldReplaceWithCapturingGroupsWithoutCaptured = {
+  code: 'var z = 1\nvar x = "invalid"',
+  filename: 'some.js',
+  options: [
+    [{
+      regex: 'inval(\\w+)',
+      replacement: 'valid'
+    }]
+  ],
+  errors: [{
+    message: 'Invalid regular expression /inval(\\w+)/gm found',
+    line: 2,
+    column: 10
+  }],
+  output: 'var z = 1\nvar x = "valid"'
+}
+
+const shouldReplaceWithFunctionWithCaptured = {
+  code: 'var z = 1\nvar x = "invalid"',
+  filename: 'some.js',
+  options: [
+    [{
+      regex: 'inval(\\w*)',
+      message: 'don`t use inval',
+      replacement: {
+        function: 'return captured[0]'
+      }
+    }]
+  ],
+  errors: [{
+    message: 'don`t use inval',
+    line: 2,
+    column: 10
+  }],
+  output: 'var z = 1\nvar x = "id"'
+}
+
+const shouldReplaceWithFunctionWithCapturedWithLog = {
+  code: 'var z = 1\nvar x = "invalid"',
+  filename: 'some.js',
+  options: [
+    [{
+      regex: 'inval(\\w*)',
+      message: 'don`t use inval',
+      replacement: {
+        /**
+         * This will generate a output to the console when testing
+         */
+        function: 'console.log(text); console.log(captured[0]); return captured[0]'
+      }
+    }]
+  ],
+  errors: [{
+    message: 'don`t use inval',
+    line: 2,
+    column: 10
+  }],
+  output: 'var z = 1\nvar x = "id"'
+}
+
 ruleTester.run(
   'invalid',
   invalidRegexRule, {
@@ -429,7 +489,10 @@ ruleTester.run(
       shouldNotReplaceWithInvalidFunctionCase04,
       shouldNotReplaceWithInvalidFunctionCase05,
       shouldNotReplaceWithInvalidFunctionCase06,
-      shouldNotReplaceWithInvalidFunctionCase07
+      shouldNotReplaceWithInvalidFunctionCase07,
+      shouldReplaceWithCapturingGroupsWithoutCaptured,
+      shouldReplaceWithFunctionWithCaptured,
+      shouldReplaceWithFunctionWithCapturedWithLog
     ]
   }
 )