feat(rule): support "allows" options

azu · azu · commit c6a7ce204055 · 2019-11-24T19:03:40.000+09:00
diff --git a/README.md b/README.md
@@ -32,6 +32,11 @@ textlint --rule @textlint-ja/no-synonyms README.md
 
 ```ts
 export interface Options {
+    /**
+     * 許可するワードの配列
+     * ワードは完全一致で比較し、一致した場合は無視されます
+     */
+    allows?: string[];
     /**
      * 同じ語形の語の中でのアルファベットの表記揺れを許可するかどうか
      * trueの場合はカタカナとアルファベットの表記ゆれを許可します
@@ -47,6 +52,7 @@ export interface Options {
 {
     "rules": {
         "@textlint-ja/no-synonyms": {
+            "allows": ["ウェブアプリ", "ウェブアプリケーション"],
             "allowAlphabet": false
         }
     }
diff --git a/package.json b/package.json
@@ -49,6 +49,7 @@
     "tabWidth": 4
   },
   "dependencies": {
+    "textlint-rule-helper": "^2.1.1",
     "tiny-segmenter": "^0.2.0"
   },
   "devDependencies": {
diff --git a/src/create-index.ts b/src/create-index.ts
@@ -18,12 +18,15 @@ export class ItemGroup {
 
     }
 
-    usedItems(usedItemSet: Set<SudachiSynonyms>, { allowAlphabet }: { allowAlphabet: boolean }): SudachiSynonyms[] {
+    usedItems(usedItemSet: Set<SudachiSynonyms>, { allowAlphabet, allows }: { allowAlphabet: boolean, allows: string[] }): SudachiSynonyms[] {
         // sort by used
         return Array.from(usedItemSet.values()).filter(item => {
             if (allowAlphabet && item.hyoukiYure === "アルファベット表記") {
                 return false;
             }
+            if (allows.includes(item.midashi)) {
+                return false;
+            }
             return this.items.includes(item);
         });
     }
diff --git a/src/textlint-rule-no-synonyms.ts b/src/textlint-rule-no-synonyms.ts
@@ -1,11 +1,17 @@
 import { TextlintRuleReporter } from "@textlint/types";
 import { createIndex, ItemGroup, Midashi } from "./create-index";
 import { SudachiSynonyms } from "sudachi-synonyms-dictionary";
+import { wrapReportHandler } from "textlint-rule-helper";
 
 const TinySegmenter = require("tiny-segmenter");
 const segmenter = new TinySegmenter(); // インスタンス生成
 
 export interface Options {
+    /**
+     * 許可するワードの配列
+     * ワードは完全一致で比較し、一致した場合は無視されます
+     */
+    allows?: string[];
     /**
      * 同じ語形の語の中でのアルファベットの表記揺れを許可するかどうか
      * trueの場合はカタカナとアルファベットの表記ゆれを許可します
@@ -16,12 +22,14 @@ export interface Options {
 
 
 export const DefaultOptions: Required<Options> = {
+    allows: [],
     allowAlphabet: true
 };
 
 const report: TextlintRuleReporter<Options> = (context, options = {}) => {
     const allowAlphabet = options.allowAlphabet !== undefined ? options.allowAlphabet : DefaultOptions.allowAlphabet;
-    const { Syntax, getSource, report, RuleError } = context;
+    const allows = options.allows !== undefined ? options.allows : DefaultOptions.allows;
+    const { Syntax, getSource, RuleError } = context;
     const usedSudachiSynonyms: Set<SudachiSynonyms> = new Set();
     const locationMap: Map<SudachiSynonyms, { index: number }> = new Map();
     const usedItemGroup: Set<ItemGroup> = new Set();
@@ -44,36 +52,44 @@ const report: TextlintRuleReporter<Options> = (context, options = {}) => {
             });
         });
     };
-    return {
-        async [Syntax.Str](node) {
-            const { keyItemGroupMap } = await indexPromise;
-            const text = getSource(node);
-            const segments: string[] = segmenter.segment(text);
-            let absoluteIndex = node.range[0];
-            segments.forEach((segement) => {
-                matchSegment(segement, absoluteIndex, keyItemGroupMap);
-                absoluteIndex += segement.length;
-            });
+    return wrapReportHandler(context,
+        {
+            ignoreNodeTypes: [Syntax.BlockQuote, Syntax.CodeBlock, Syntax.Code, Syntax.Html, Syntax.Link, Syntax.Image, Syntax.Comment]
         },
-        async [Syntax.DocumentExit](node) {
-            await indexPromise;
-            for (const itemGroup of usedItemGroup.values()) {
-                const items = itemGroup.usedItems(usedSudachiSynonyms, {
-                    allowAlphabet
-                });
-                if (items.length >= 2) {
-                    const 同義の見出しList = items.map(item => item.midashi);
-                    // select last used
-                    const matchSegment = locationMap.get(items[items.length - 1]);
-                    const index = matchSegment ? matchSegment.index : 0;
-                    const message = `同義語である「${同義の見出しList.join("」「")}」が利用されています`;
-                    report(node, new RuleError(message, {
-                        index
-                    }));
+        (report) => {
+            return {
+                async [Syntax.Str](node) {
+                    const { keyItemGroupMap } = await indexPromise;
+                    const text = getSource(node);
+                    const segments: string[] = segmenter.segment(text);
+                    let absoluteIndex = node.range[0];
+                    segments.forEach((segement) => {
+                        matchSegment(segement, absoluteIndex, keyItemGroupMap);
+                        absoluteIndex += segement.length;
+                    });
+                },
+                async [Syntax.DocumentExit](node) {
+                    await indexPromise;
+                    for (const itemGroup of usedItemGroup.values()) {
+                        const items = itemGroup.usedItems(usedSudachiSynonyms, {
+                            allows,
+                            allowAlphabet
+                        });
+                        if (items.length >= 2) {
+                            const 同義の見出しList = items.map(item => item.midashi);
+                            // select last used
+                            const matchSegment = locationMap.get(items[items.length - 1]);
+                            const index = matchSegment ? matchSegment.index : 0;
+                            const message = `同義語である「${同義の見出しList.join("」「")}」が利用されています`;
+                            report(node, new RuleError(message, {
+                                index
+                            }));
+                        }
+                    }
                 }
-            }
+            };
         }
-    };
+    );
 };
 
 export default report;
diff --git a/test/textlint-rule-no-synonyms.test.ts b/test/textlint-rule-no-synonyms.test.ts
@@ -7,7 +7,16 @@ import rule from "../src/textlint-rule-no-synonyms";
 tester.run("textlint-rule-no-synonyms", rule, {
     valid: [
         "新参入、借り入れ、問題のパスポート、マネー、雇入 片方のペアだけならOKです",
-        "This is アーカイブ"
+        "This is アーカイブ",
+        // allow links
+        `「[インターフェース](https://example.com)」と「[インタフェース](https://example.com)」`,
+        // "allows
+        {
+            text: `ウェブアプリとウェブアプリケーションの違いは許容する`,
+            options: {
+                allows: ["ウェブアプリ"]　// <= 片方が許可されていればOK
+            }
+        }
     ],
     invalid: [{
         text: "この雇入と雇入れの違いは難しい問題だ",
diff --git a/yarn.lock b/yarn.lock
@@ -752,7 +752,7 @@
   dependencies:
     any-observable "^0.3.0"
 
-"@textlint/ast-node-types@^4.2.5":
+"@textlint/ast-node-types@^4.2.1", "@textlint/ast-node-types@^4.2.5":
   version "4.2.5"
   resolved "https://registry.yarnpkg.com/@textlint/ast-node-types/-/ast-node-types-4.2.5.tgz#ae13981bc8711c98313a6ac1c361194d6bf2d39b"
   integrity sha512-+rEx4jLOeZpUcdvll7jEg/7hNbwYvHWFy4IGW/tk2JdbyB3SJVyIP6arAwzTH/sp/pO9jftfyZnRj4//sLbLvQ==
@@ -864,7 +864,7 @@
   dependencies:
     "@textlint/text-to-ast" "^3.1.6"
 
-"@textlint/types@^1.2.3":
+"@textlint/types@^1.1.2", "@textlint/types@^1.2.3":
   version "1.2.3"
   resolved "https://registry.yarnpkg.com/@textlint/types/-/types-1.2.3.tgz#6a27d6a2035873904d45c775b6205f162f169f91"
   integrity sha512-48wXioiKIKAWPkgTWf/KyvZpjGH5L2ohmrSVgtx/u8q+KcY+q+/dslKy7QN0H+Yeu5Vj4GZRHOzCYWtzHMQleQ==
@@ -4105,6 +4105,16 @@ text-table@^0.2.0:
   resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
   integrity sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=
 
+textlint-rule-helper@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/textlint-rule-helper/-/textlint-rule-helper-2.1.1.tgz#d572588685359134bc779939b217e61f087dab0f"
+  integrity sha512-6fxgHzoJVkjl3LaC1b2Egi+5wbhG4i0pU0knJmQujVhxIJ3D3AcQQZPs457xKAi5xKz1WayYeTeJ5jrD/hnO7g==
+  dependencies:
+    "@textlint/ast-node-types" "^4.2.1"
+    "@textlint/types" "^1.1.2"
+    structured-source "^3.0.2"
+    unist-util-visit "^1.1.0"
+
 textlint-scripts@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/textlint-scripts/-/textlint-scripts-3.0.0.tgz#4140a44c2cc77f9e22d99313ceb69661d5516d43"

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,11 @@ textlint --rule @textlint-ja/no-synonyms README.md`
`32`	`32`
`33`	`33`	```ts
`34`	`34`	`export interface Options {`
	`35`	`+ /**`
	`36`	`+ * 許可するワードの配列`
	`37`	`+ * ワードは完全一致で比較し、一致した場合は無視されます`
	`38`	`+ */`
	`39`	`+ allows?: string[];`
`35`	`40`	`/**`
`36`	`41`	`* 同じ語形の語の中でのアルファベットの表記揺れを許可するかどうか`
`37`	`42`	`* trueの場合はカタカナとアルファベットの表記ゆれを許可します`
`@@ -47,6 +52,7 @@ export interface Options {`
`47`	`52`	`{`
`48`	`53`	`"rules": {`
`49`	`54`	`"@textlint-ja/no-synonyms": {`
	`55`	`+ "allows": ["ウェブアプリ", "ウェブアプリケーション"],`
`50`	`56`	`"allowAlphabet": false`
`51`	`57`	`}`
`52`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,12 +18,15 @@ export class ItemGroup {`
`18`	`18`
`19`	`19`	`}`
`20`	`20`
`21`		`- usedItems(usedItemSet: Set<SudachiSynonyms>, { allowAlphabet }: { allowAlphabet: boolean }): SudachiSynonyms[] {`
	`21`	`+ usedItems(usedItemSet: Set<SudachiSynonyms>, { allowAlphabet, allows }: { allowAlphabet: boolean, allows: string[] }): SudachiSynonyms[] {`
`22`	`22`	`// sort by used`
`23`	`23`	`return Array.from(usedItemSet.values()).filter(item => {`
`24`	`24`	`if (allowAlphabet && item.hyoukiYure === "アルファベット表記") {`
`25`	`25`	`return false;`
`26`	`26`	`}`
	`27`	`+ if (allows.includes(item.midashi)) {`
	`28`	`+ return false;`
	`29`	`+ }`
`27`	`30`	`return this.items.includes(item);`
`28`	`31`	`});`
`29`	`32`	`}`