fix: treat RegExp-like string as global flag by default (#7)

azu · web-flow · commit a09a33fbd2ab · 2018-05-23T18:35:50.000+09:00
- use https://github.com/textlint/regexp-string-matcher
diff --git a/README.md b/README.md
@@ -18,8 +18,7 @@ Via `.textlintrc`(Recommended)
         "whitelist": {
             "allow": [
                 "ignored-word",
-                "/\\d+/",
-                "/^===/m"
+                "/===IGNORE===[\\s\\S]*?===\/IGNORE===/m"
             ]
         }
     }
@@ -29,12 +28,12 @@ Via `.textlintrc`(Recommended)
 ## Options
 
 - `allow`: `string[]`
-    - white list words or RegExp strings
+    - white list String or [RegExp-like String](https://github.com/textlint/regexp-string-matcher#regexp-like-string)
 - `whitelistConfigPaths`: `string[]`
     - File path list that includes allow words.
     - The File path is relative path from your `.textlintrc`.
     - Support file format: JSON, yml, js
-    
+
 For example, you can specify `whitelistConfigPaths` to `.textlintrc`.
 
 ```json
@@ -52,34 +51,74 @@ For example, you can specify `whitelistConfigPaths` to `.textlintrc`.
 
 These files should be following formats.
 
-
 `allow.json`:
 ```
 [
-  "allow",
+  "ignore-word",
   "/yes/i"
 ]
-```    
+```
 
 `allow.yml`:
 ```
-- "allow",
+- "ignore-word",
 - /yes/i
 ```
 
 
-### RegExp String
+## RegExp-like String
+
+This filter rule support [RegExp-like String](https://github.com/textlint/regexp-string-matcher#regexp-like-string).
+RegExp-like String is that started with `/` and ended with `/` or `/flag`.
 
-textlint-filter-rule-whitelist allow to use RegExp like string.
-The string is stated with `/` and ended with `/` or `/flag`.
+:warning: Yous should escape special characters like `\d` in string literal.
+`/\d/` should be `"\\d"`.
+
+For example, you want to ignore `/\d{4}-\d{2}-\d{2}/` pattern, you can write `allow` as follows:
 
 ```js
-"/\\d+/"; // => /\d+/
+[
+  "/\\d{4}-\\d{2}-\\d{2}/"
+]
+```
+
+### Example: Ignore pattern
+
+Some textlint rule has false-positive about unique noun.
+You want to ignore the error about unique noun.
+
+For example, you want to ignore error about `/github/i`, you can write `allow` as follows:
+
+`allow.json`:
+```
+[
+  "/github/i`
+]
+```
+
+### Example: Ignore range
+
+You want to ignore error between `===IGNORE===` mark.
+
+`allow.json`:
+```
+[
+  "/===IGNORE===[\\s\\S]*?===/IGNORE===/m`
+]
 ```
 
-**Note**:
+**text:**
+```
+ERROR Text => actual error
+
+===IGNORE===
+ERROR Text => it is ignored!
+===/IGNORE===
+
+ERROR Text => actual error
+```
 
-Multiline pattern should be use `m` flag like `/regexp/m`.
+For more information, see [textlint/regexp-string-matcher – Example](https://github.com/textlint/regexp-string-matcher#examples)
 
 ## Changelog
 
diff --git a/package.json b/package.json
@@ -39,24 +39,22 @@
     "babel-cli": "^6.11.4",
     "babel-preset-es2015": "^6.9.0",
     "babel-preset-jsdoc-to-assert": "^4.0.0",
-    "babel-preset-power-assert": "^1.0.0",
+    "babel-preset-power-assert": "^2.0.0",
     "babel-register": "^6.11.6",
     "husky": "^0.14.3",
-    "lint-staged": "^6.0.0",
-    "mocha": "^4.0.1",
-    "power-assert": "^1.4.1",
+    "lint-staged": "^7.1.2",
+    "mocha": "^5.2.0",
+    "power-assert": "^1.5.0",
     "prettier": "^1.8.2",
-    "textlint": "^9.1.1",
+    "textlint": "^10.2.1",
     "textlint-rule-report-node-types": "^1.1.0",
-    "textlint-tester": "^3.0.3"
+    "textlint-tester": "^4.1.3"
   },
   "dependencies": {
-    "@textlint/ast-node-types": "^2.0.0",
+    "@textlint/ast-node-types": "^4.0.2",
     "@textlint/get-config-base-dir": "^2.0.0",
-    "escape-string-regexp": "^1.0.5",
-    "execall": "^1.0.0",
-    "rc-config-loader": "^2.0.1",
-    "str-to-regexp": "^1.1.3"
+    "@textlint/regexp-string-matcher": "^1.0.2",
+    "rc-config-loader": "^2.0.1"
   },
   "peerDependencies": {
     "textlint": ">= 9.0.0"
diff --git a/src/textlint-filter-rule-whitelist.js b/src/textlint-filter-rule-whitelist.js
@@ -1,11 +1,9 @@
 // LICENSE : MIT
 "use strict";
 const path = require("path");
-const execall = require("execall");
-const escapeStringRegexp = require("escape-string-regexp");
-const toRegExp = require("str-to-regexp").toRegExp;
 const rcfile = require("rc-config-loader");
 const { getConfigBaseDir } = require("@textlint/get-config-base-dir");
+const { matchPatterns } = require("@textlint/regexp-string-matcher");
 const getAllowWordsFromFiles = (files, baseDirectory) => {
     let results = [];
     files.forEach(filePath => {
@@ -22,7 +20,6 @@ const getAllowWordsFromFiles = (files, baseDirectory) => {
     return results;
 };
 
-const COMPLEX_REGEX_END = /^.+\/(\w*)$/;
 const defaultOptions = {
     /**
      * White list strings or RegExp strings
@@ -48,25 +45,12 @@ module.exports = function(context, options) {
         ? getAllowWordsFromFiles(options.whitelistConfigPaths, baseDirectory)
         : [];
     const allAllowWords = allowWords.concat(whitelistConfigPaths);
-    const regExpWhiteList = allAllowWords.map(allowWord => {
-        if (!allowWord) {
-            return /^$/;
-        }
-        if (allowWord[0] === "/" && COMPLEX_REGEX_END.test(allowWord)) {
-            return toRegExp(allowWord);
-        }
-        const escapeString = escapeStringRegexp(allowWord);
-        return new RegExp(escapeString, "g");
-    });
     return {
         [Syntax.Document](node) {
             const text = getSource(node);
-            regExpWhiteList.forEach(whiteRegExp => {
-                const matches = execall(whiteRegExp, text);
-                matches.forEach(match => {
-                    const lastIndex = match.index + match.match.length;
-                    shouldIgnore([match.index, lastIndex]);
-                });
+            const matchResults = matchPatterns(text, allAllowWords);
+            matchResults.forEach(result => {
+                shouldIgnore([result.startIndex, result.endIndex]);
             });
         }
     };
diff --git a/test/textlint-filter-rule-whitelist-test.js b/test/textlint-filter-rule-whitelist-test.js
@@ -204,6 +204,38 @@ describe("textlint-rule-filter-whitelist", function() {
                     });
                 });
         });
+        it("should support multiline", function() {
+            const textlint = new TextLintCore();
+            textlint.setupRules(
+                {
+                    report: reportRule
+                },
+                {
+                    report: {
+                        nodeTypes: [ASTNodeTypes.Paragraph]
+                    }
+                }
+            );
+            textlint.setupFilterRules(
+                {
+                    whitelist: filterRule
+                },
+                {
+                    whitelist: {
+                        allow: ["/===IGNORE===[\\s\\S]*?===/IGNORE===/m"]
+                    }
+                }
+            );
+            return textlint
+                .lintMarkdown(
+                    `===IGNORE===
+ERROR Text, But this range should be ignored!
+===/IGNORE===`
+                )
+                .then(({ messages }) => {
+                    assert.equal(messages.length, 0);
+                });
+        });
         it("should messages is ignore by RegExp", function() {
             const textlint = new TextLintCore();
             textlint.setupRules(
@@ -230,5 +262,39 @@ describe("textlint-rule-filter-whitelist", function() {
                 assert.equal(messages.length, 0);
             });
         });
+
+        it("should messages is ignore by RegExp", function() {
+            const textlint = new TextLintCore();
+            textlint.setupRules(
+                {
+                    report: reportRule
+                },
+                {
+                    report: {
+                        nodeTypes: [ASTNodeTypes.Str]
+                    }
+                }
+            );
+            textlint.setupFilterRules(
+                {
+                    whitelist: filterRule
+                },
+                {
+                    whitelist: {
+                        allow: ["/#.*{#[a-z.-]+}/g"]
+                    }
+                }
+            );
+            return textlint
+                .lintMarkdown(
+                    `# JavaScriptとは {#what-is-javascript}
+            
+# JavaScriptってどのような言語？ {#about-javascript}
+`
+                )
+                .then(({ messages }) => {
+                    assert.equal(messages.length, 0);
+                });
+        });
     });
 });
diff --git a/yarn.lock b/yarn.lock
