## 1.6.0 - February 2021

* Adds additional parameter `$` to replacement function for invalid patterns in order to allow smaller definitions.

Author: gmullerb

CHANGELOG.md

@@ -1,5 +1,9 @@
 # ESLint Plugin Regex Change Log
 
+## 1.6.0 - February 2021
+
+* Adds additional parameter `$` to replacement function for invalid patterns in order to allow smaller definitions.
+
 ## 1.5.0 - February 2021
 
 * Adds capturing groups to replacement functions for invalid patterns.

README.md

@@ -23,7 +23,7 @@ __________________
   ..
   "devDependencies": {
     "eslint": ">=4.0.0",
-    "eslint-plugin-regex": "1.5.0",
+    "eslint-plugin-regex": "1.6.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 2 parameters: `text` and `captured`.
+      * It will receive 3 parameters: `text`, `captured` and `$`, that can be used as desired.
       * 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).
@@ -253,10 +253,15 @@ Definition of the function must be done as a `string` in 1 line, and the followi
 * 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 2 parameters:
+Function will receive 3 parameters, to be used as desired:
 
 * `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.
+* `$`: an `array` of strings, with the value of the invalid text found plus the values of the captured groups for the regex.
+  * `$[0]` = `text`: a `string` with the value of the invalid text found.
+  * `$[1..]` = `captured`: an `array` of strings with the values of the captured groups for the regex.
+    * `$[1]` = `captured[0]` and so on.
+  * It allows smaller definitions.
 
 e.g. Using parameter `text`
 
@@ -274,6 +279,18 @@ Having the following rule in `.eslintrc.json`:
 }
 ```
 
+or using `$`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror\\w*\\s",
+  "replacement": {
+    "function": "return $[0].trim()"
+  }
+}
+```
+
 then, given:
 
 `example.js`
@@ -304,6 +321,18 @@ Having the following rule in `.eslintrc.json`:
 }
 ```
 
+or using `$`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror(\\w*)\\s",
+  "replacement": {
+    "function": "return $[1]"
+  }
+}
+```
+
 then, given:
 
 `example.js`
@@ -318,6 +347,72 @@ when linting with fix, the result will be:
 const exception = "19"
 ```
 
+e.g. Using parameters `text` and `captured`
+
+`"return text + ' = ' + captured[0]  + ' + ' + captured[1] + ' = ' + (parseInt(captured[0]) + parseInt(captured[1]))"` => only the body of the function + returns a `string` value based on `text` and `captured`
+
+Having the following rule in `.eslintrc.json`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return text + ' = ' + captured[0]  + ' + ' + captured[1] + ' = ' + (parseInt(captured[0]) + parseInt(captured[1]))"
+  }
+}
+```
+
+or using `$`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return $[0] + ' = ' + $[1]  + ' + ' + $[2] + ' = ' + (parseInt($[1]) + parseInt($[2]))"
+  }
+}
+```
+
+or :
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return text + ' = ' + $[1]  + ' + ' + $[2] + ' = ' + (parseInt($[1]) + parseInt($[2]))"
+  }
+}
+```
+
+or :
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return `${text} = ${captured[0]} + ${captured[1]} = ${parseInt($[1]) + parseInt($[2])}`"
+  }
+}
+```
+
+then, given:
+
+`example.js`
+
+```js
+const sum = "4+5"
+```
+
+when linting with fix, the result will be:
+
+```js
+const sum = "4+5 = 4 + 5 = 9"
+```
+
 ###### Debugging of the Replacement Function for *invalid* found pattern
 
 * It is possible to add `console` statements to print some information in the Replacement Function.

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 2 parameters: `text` and `captured`.
+      * It will receive 3 parameters: `text`, `captured` and `$`, that can be used as desired.
       * 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).
@@ -113,10 +113,15 @@ Definition of the function must be done as a `string` in 1 line, and the followi
 * 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 2 parameters:
+Function will receive 3 parameters, to be used as desired:
 
 * `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.
+* `$`: an `array` of strings, with the value of the invalid text found plus the values of the captured groups for the regex.
+  * `$[0]` = `text`: a `string` with the value of the invalid text found.
+  * `$[1..]` = `captured`: an `array` of strings with the values of the captured groups for the regex.
+    * `$[1]` = `captured[0]` and so on.
+  * It allows smaller definitions.
 
 e.g. Using parameter `text`
 
@@ -134,6 +139,18 @@ Having the following rule in `.eslintrc.json`:
 }
 ```
 
+or using `$`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror\\w*\\s",
+  "replacement": {
+    "function": "return $[0].trim()"
+  }
+}
+```
+
 then, given:
 
 `example.js`
@@ -164,6 +181,18 @@ Having the following rule in `.eslintrc.json`:
 }
 ```
 
+or using `$`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror(\\w*)\\s",
+  "replacement": {
+    "function": "return $[1]"
+  }
+}
+```
+
 then, given:
 
 `example.js`
@@ -178,6 +207,72 @@ when linting with fix, the result will be:
 const exception = "19"
 ```
 
+e.g. Using parameters `text` and `captured`
+
+`"return text + ' = ' + captured[0]  + ' + ' + captured[1] + ' = ' + (parseInt(captured[0]) + parseInt(captured[1]))"` => only the body of the function + returns a `string` value based on `text` and `captured`
+
+Having the following rule in `.eslintrc.json`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return text + ' = ' + captured[0]  + ' + ' + captured[1] + ' = ' + (parseInt(captured[0]) + parseInt(captured[1]))"
+  }
+}
+```
+
+or using `$`:
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return $[0] + ' = ' + $[1]  + ' + ' + $[2] + ' = ' + (parseInt($[1]) + parseInt($[2]))"
+  }
+}
+```
+
+or :
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return text + ' = ' + $[1]  + ' + ' + $[2] + ' = ' + (parseInt($[1]) + parseInt($[2]))"
+  }
+}
+```
+
+or :
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "(\\d+)\\+(\\d+)",
+  "replacement": {
+    "function": "return `${text} = ${captured[0]} + ${captured[1]} = ${parseInt($[1]) + parseInt($[2])}`"
+  }
+}
+```
+
+then, given:
+
+`example.js`
+
+```js
+const sum = "4+5"
+```
+
+when linting with fix, the result will be:
+
+```js
+const sum = "4+5 = 4 + 5 = 9"
+```
+
 ##### Debugging of the Replacement Function for invalid found pattern
 
 * It is possible to add `console` statements to print some information in the Replacement Function.

lib/rules/invalid-regex-rule.js

@@ -36,8 +36,7 @@ function checkRegexInSource(source, regex) {
   const foundDetail = regex.exec(source)
   return !!foundDetail
     ? {
-        pattern: foundDetail.shift(),
-        captured: foundDetail,
+        $: foundDetail,
         patternIndex: foundDetail.index,
         nextChar: regex.lastIndex
       }
@@ -97,16 +96,16 @@ function checkRegex(source, sourceLines, nextLine, nextChar, rootChar, pattern,
 function buildReplacementFunction(replacement) {
   if (/\breturn\b/.test(replacement)) {
     try {
-      const replacementFunction = new Function('text', 'captured', replacement) // eslint-disable-line no-new-func
-      return (text, captured) => {
+      const replacementFunction = new Function('text', 'captured', '$', replacement) // eslint-disable-line no-new-func
+      return $ => {
         try {
-          const replacement = replacementFunction(text, captured)
+          const replacement = replacementFunction($[0], $.slice(1), $)
           if (typeof replacement === 'string') {
             return replacement
           }
         }
         catch(e) {}
-        return text
+        return $[0]
       }
     }
     catch(e) {}
@@ -125,7 +124,7 @@ function createReplacement(replacement) {
           return (from, found) =>
             fixer => fixer.replaceTextRange(
               [from + found.patternIndex, from + found.nextChar],
-              replacementFunction(found.pattern, found.captured)
+              replacementFunction(found.$)
             )
         }
       }

package-lock.json

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