## 1.4.0 - February 2021

* Adds replacements with functions for invalid patterns.

Author: gmullerb

.eslintrc.json

@@ -23,7 +23,6 @@
       }
     ],
     "array-bracket-spacing": "off",
-    "indent": ["error", 2],
     "quotes":  [
       "error",
       "single"

CHANGELOG.md

@@ -1,5 +1,9 @@
 # ESLint Plugin Regex Change Log
 
+## 1.4.0 - February 2021
+
+* Adds replacements with functions for invalid patterns.
+
 ## 1.3.0 - January 2021
 
 * Adds replacements for invalid patterns.

README.md

@@ -23,7 +23,7 @@ __________________
   ..
   "devDependencies": {
     "eslint": ">=4.0.0",
-    "eslint-plugin-regex": "1.2.1",
+    "eslint-plugin-regex": "1.4.0",
     ..
 ```
 
@@ -211,7 +211,14 @@ It is specified by just a regular expression `string`, i.e. `"regex"`
 It is specified by an `object`, with the following fields:
 
 * `regex`: A **required** `string` representing the **Regular expression to look for**.
-* `replacement`: If present this `string` will use to replace **invalid** found pattern.
+* `replacement` [1]:
+  * 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 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).
 * `id`: An optional `string` representing the **Pattern Id**.
 * `message`: An optional `string` specifying the **Message to be shown when an error happens** (invalid `regex` is found or required `regex` is not found).
 * `files`: An optional `object` specifying which files to analyze:
@@ -236,6 +243,48 @@ It is specified by an `object`, with the following fields:
 > * When `ignore` and `inspect` are present, `ignore` takes precedence.
 > * Global ignore file pattern, takes precedence over `files` patterns.
 
+> [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 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.
+* 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.
+
+e.g.
+
+`"return text.trim()"` => only the body of the function + return a `string` value
+
+`.eslintrc.json`:`
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror\\w*\\s",
+  "replacement": {
+    "function": "return text.trim()"
+  }
+}
+```
+
+then, given:
+
+`example.js`
+
+```js
+const exception = " error19 "
+```
+
+when linting with fix, the result will be:
+
+```js
+const exception = "error19"
+```
+
 #### Mixing definitions
 
 It is possible to use both type of definitions, 'Short pattern definition' with 'Detailed pattern definition', in the array of patterns.
@@ -335,7 +384,13 @@ Array of patterns represent different logical operation for each rule:
 
 ### Examples
 
-[For a set of Regex Rules examples check `eslint-plugin-base-style-config`](https://github.com/gmullerb/base-style-config/tree/master/js#regex-rules)
+Check:
+
+* [invalid-regex Basic rule tests](tests/lib/rules/invalid-regex-rule.e2e-test.js)
+* [invalid-regex Detailed rule tests](tests/lib/rules/invalid-regex-detailed-rule.e2e-test.js)
+* [required-regex Basic rule tests](tests/lib/rules/required-regex-rule.e2e-test.js)
+* [required-regex Detailed rule tests](tests/lib/rules/required-regex-detailed-rule.e2e-test.js)
+* [The set of Regex Rules of `eslint-plugin-base-style-config`](https://github.com/gmullerb/base-style-config/tree/master/js#regex-rules)
 
 __________________
 

docs/rules/invalid-regex-rule.md

@@ -57,7 +57,14 @@ It is specified by just a regular expression `string`, i.e. `"regex"`
 It is specified by an `object`, with the following fields:
 
 * `regex`: A **required** `string` representing the **Regular expression to look for**.
-* `replacement`: An optional `string` used to replace invalid found pattern.
+* `replacement` [1]:
+  * 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 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).
 * `id`: An optional `string` representing the **Pattern Id**.
 * `message`: An optional `string` specifying the **Message to be shown when an invalid `regex` is found**.
 * `files`: An optional `object` specifying which files to analyze:
@@ -70,6 +77,8 @@ It is specified by an `object`, with the following fields:
 > * When `ignore` and `inspect` are present, `ignore` takes precedence.
 > * Global ignore file pattern, takes precedence over `files` patterns.
 
+> [1] In order to fix issue eslint must be run with `--fix` option.
+
 `.eslintrc.json`:
 
 ```json
@@ -96,6 +105,46 @@ It is specified by an `object`, with the following fields:
 }
 ```
 
+#### Definition of the Function used to replace **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.
+* 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.
+
+e.g.
+
+`"return text.trim()"` => only the body of the function + return a `string` value
+
+`.eslintrc.json`:`
+
+```json
+{
+  "id": "regexIdN",
+  "regex": "\\serror\\w*\\s",
+  "replacement": {
+    "function": "return text.trim()"
+  }
+}
+```
+
+then, given:
+
+`example.js`
+
+```js
+const exception = " error19 "
+```
+
+when linting with fix, the result will be:
+
+```js
+const exception = "error19"
+```
+
 ### 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.:
@@ -108,6 +157,14 @@ When the pattern is found, the error message will reflect the exact location, e.
  34:25  error  Invalid regular expression /invalidRegex1/gm found  regex/invalid
 ```
 
+### Examples
+
+Check:
+
+* [invalid-regex Basic rule tests](tests/lib/rules/invalid-regex-rule.e2e-test.js)
+* [invalid-regex Detailed rule tests](tests/lib/rules/invalid-regex-detailed-rule.e2e-test.js)
+* [The set of Regex Rules of `eslint-plugin-base-style-config`](https://github.com/gmullerb/base-style-config/tree/master/js#regex-rules)
+
 ## Related Rules
 
 * [`regex/required`](docs/rules/required-regex-rule.md).

docs/rules/required-regex-rule.md

@@ -105,6 +105,14 @@ Internally, each string from the array will be converted into a Regular Expressi
 
 `"requiredRegex1"` will be transformed into `/requiredRegex1/gm`
 
+### Examples
+
+Check:
+
+* [required-regex Basic rule tests](tests/lib/rules/required-regex-rule.e2e-test.js)
+* [required-regex Detailed rule tests](tests/lib/rules/required-regex-detailed-rule.e2e-test.js)
+* [The set of Regex Rules of `eslint-plugin-base-style-config`](https://github.com/gmullerb/base-style-config/tree/master/js#regex-rules)
+
 ## Related Rules
 
 * [`regex/invalid`](docs/rules/invalid-regex-rule.md).

lib/rules/invalid-regex-rule.js

@@ -36,13 +36,14 @@ function checkRegexInSource(source, regex) {
   const foundDetail = regex.exec(source)
   return !!foundDetail
     ? {
-      patternIndex: foundDetail.index,
-      nextChar: regex.lastIndex
-    }
+        pattern: foundDetail[0],
+        patternIndex: foundDetail.index,
+        nextChar: regex.lastIndex
+      }
     : {
-      patternIndex: -1,
-      nextChar: -1
-    }
+        patternIndex: -1,
+        nextChar: -1
+      }
 }
 
 function foundStart(source, nextLine, foundAt) {
@@ -72,7 +73,7 @@ function checkRegex(source, sourceLines, nextLine, nextChar, rootChar, pattern,
             pattern,
             from => `Invalid regular expression ${from} found`
           ),
-          fix: replace(rootChar, sourceDetail.patternIndex, sourceDetail.nextChar)
+          fix: replace(rootChar, sourceDetail.patternIndex, sourceDetail.nextChar, sourceDetail.pattern)
         })
         checkRegex(remainingSource, sourceLines, foundDetail.nextLine, foundDetail.nextChar, rootChar + remainingSourceStart,
           pattern, replace, report)
@@ -84,14 +85,52 @@ function checkRegex(source, sourceLines, nextLine, nextChar, rootChar, pattern,
             pattern,
             from => `Invalid regular expression ${from} found`
           ),
-          fix: replace(rootChar, sourceDetail.patternIndex, sourceDetail.nextChar)
+          fix: replace(rootChar, sourceDetail.patternIndex, sourceDetail.nextChar, sourceDetail.pattern)
         })
         checkRegex(remainingSource, sourceLines, nextLine + 1, nextChar, rootChar + remainingSourceStart, pattern, replace, report)
       }
     }
   }
 }
 
+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
+            }
+          }
+          catch(e) { }
+          return text
+        }
+      }
+    }
+    catch(e) {}
+  }
+  return null
+}
+
+function createReplacement(replacement) {
+  switch (typeof replacement) {
+    case 'string':
+      return (from, deltaStart, deltaEnd) => fixer => fixer.replaceTextRange([from + deltaStart, from + deltaEnd], 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 () => undefined
+}
+
 function checkPatterns(fileName, source, patterns, report) {
   const sourceLines = source.split('\n')
   patterns.forEach(pattern => shouldCheck(pattern.details, fileName) && checkRegex(
@@ -101,9 +140,7 @@ function checkPatterns(fileName, source, patterns, report) {
     0,
     0,
     pattern,
-    typeof pattern.details.replacement === 'string'
-      ? (from, deltaStart, deltaEnd) => fixer => fixer.replaceTextRange([from + deltaStart, from + deltaEnd], pattern.details.replacement)
-      : () => undefined,
+    createReplacement(pattern.details.replacement),
     report
   ))
 }
@@ -144,10 +181,26 @@ module.exports = {
               type: 'string',
               minLength: 1
             },
-            replacement:  {
-              title: 'Replacement',
-              description: 'Replacement for invalid pattern',
-              type: 'string'
+            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',

lib/utils/options-utils.js

@@ -16,15 +16,15 @@ function fitDetails(details) {
 function extractPattern(regexSource) {
   return typeof regexSource !== 'string'
     ? {
-      source: regexSource.regex,
-      regex: new RegExp(regexSource.regex, 'gm'),
-      details: fitDetails(regexSource)
-    }
+        source: regexSource.regex,
+        regex: new RegExp(regexSource.regex, 'gm'),
+        details: fitDetails(regexSource)
+      }
     : {
-      source: regexSource,
-      regex: new RegExp(regexSource, 'gm'),
-      details: fitDetails({})
-    }
+        source: regexSource,
+        regex: new RegExp(regexSource, 'gm'),
+        details: fitDetails({})
+      }
 }
 
 module.exports.fromOptions = function (options) {

lib/utils/report-utils.js

@@ -5,6 +5,6 @@ module.exports.formatReportMessage = function (pattern, createMsg) {
   return !!pattern.details.message
     ? pattern.details.message
     : !!pattern.details.id
-      ? createMsg(`'${pattern.details.id}'`)
-      : createMsg(`/${pattern.source}/gm`)
+        ? createMsg(`'${pattern.details.id}'`)
+        : createMsg(`/${pattern.source}/gm`)
 }

package-lock.json

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