feat: add allowLexeme option (#12)

Leko · web-flow · commit 7a2deb712790 · 2021-08-10T22:03:17.000+09:00
diff --git a/README.md b/README.md
@@ -76,6 +76,13 @@ textlint --rule @textlint-ja/no-synonyms README.md
      * Default: true
      */
     allowNumber?: boolean;
+    /**
+     * 語彙素の異なる同義語を許可するかどうか
+     * trueの場合は語彙素の異なる同義語を許可します
+     * 例) 「ルーム」と「部屋」
+     * Default: true
+     */
+    allowLexeme?: boolean;
 }
 ```
 
@@ -88,7 +95,8 @@ textlint --rule @textlint-ja/no-synonyms README.md
             "allows": ["ウェブアプリ", "ウェブアプリケーション"],
             "preferWords": ["ユーザー"],
             "allowAlphabet": false,
-            "allowNumber": false
+            "allowNumber": false,
+            "allowLexeme": false
         }
     }
 }
diff --git a/src/create-index.ts b/src/create-index.ts
@@ -69,18 +69,20 @@ export type IndexType = {
     keyItemGroupMap: Map<Midashi, ItemGroup[]>;
     SudachiSynonymsItemGroup: Map<SudachiSynonyms, ItemGroup>;
 };
-let _ret: IndexType | null = null;
-export const createIndex = async (): Promise<IndexType> => {
-    if (_ret) {
-        return Promise.resolve(_ret);
+const _cache = new Map<boolean, IndexType>();
+const firstVocabularyNumber = 1;
+export const createIndex = async ({ allowLexeme }: { allowLexeme: boolean }): Promise<IndexType> => {
+    if (_cache.has(allowLexeme)) {
+        return Promise.resolve(_cache.get(allowLexeme)!);
     }
     assertInstallationSudachiSynonymsDictionary();
     const keyItemGroupMap: Map<Midashi, ItemGroup[]> = new Map();
     const SudachiSynonymsItemGroup: Map<SudachiSynonyms, ItemGroup> = new Map();
     const SynonymsDictionary = await fetchDictionary();
     SynonymsDictionary.forEach((group) => {
         const groupByVocabularyNumber = group.items.reduce((res, item) => {
-            res[item.vocabularyNumber!] = (res[item.vocabularyNumber!] || []).concat(item);
+            const vocabularyNumber = allowLexeme ? item.vocabularyNumber! : firstVocabularyNumber;
+            res[vocabularyNumber] = (res[vocabularyNumber] || []).concat(item);
             return res;
         }, {} as { [index: string]: SudachiSynonyms[] });
         const itemGroups = Object.values(groupByVocabularyNumber)
@@ -99,9 +101,10 @@ export const createIndex = async (): Promise<IndexType> => {
             });
         });
     });
-    _ret = {
+    const _ret = {
         keyItemGroupMap,
         SudachiSynonymsItemGroup
     };
+    _cache.set(allowLexeme, _ret);
     return Promise.resolve(_ret);
 };
diff --git a/src/textlint-rule-no-synonyms.ts b/src/textlint-rule-no-synonyms.ts
@@ -33,25 +33,34 @@ export interface Options {
      * Default: true
      */
     allowNumber?: boolean;
+    /**
+     * 語彙素の異なる同義語を許可するかどうか
+     * trueの場合は語彙素の異なる同義語を許可します
+     * 例) 「ルーム」と「部屋」
+     * Default: true
+     */
+    allowLexeme?: boolean;
 }
 
 export const DefaultOptions: Required<Options> = {
     allows: [],
     preferWords: [],
     allowAlphabet: true,
-    allowNumber: true
+    allowNumber: true,
+    allowLexeme: true
 };
 
 const report: TextlintRuleReporter<Options> = (context, options = {}) => {
     const allowAlphabet = options.allowAlphabet ?? DefaultOptions.allowAlphabet;
     const allowNumber = options.allowNumber ?? DefaultOptions.allowNumber;
+    const allowLexeme = options.allowLexeme ?? DefaultOptions.allowLexeme;
     const allows = options.allows !== undefined ? options.allows : DefaultOptions.allows;
     const preferWords = options.preferWords !== undefined ? options.preferWords : DefaultOptions.preferWords;
     const { Syntax, getSource, RuleError, fixer } = context;
     const usedSudachiSynonyms: Set<SudachiSynonyms> = new Set();
     const locationMap: Map<SudachiSynonyms, { index: number }> = new Map();
     const usedItemGroup: Set<ItemGroup> = new Set();
-    const indexPromise = createIndex();
+    const indexPromise = createIndex({ allowLexeme });
     const matchSegment = (segment: string, absoluteIndex: number, keyItemGroupMap: Map<Midashi, ItemGroup[]>) => {
         const itemGroups = keyItemGroupMap.get(segment);
         if (!itemGroups) {
@@ -104,7 +113,8 @@ const report: TextlintRuleReporter<Options> = (context, options = {}) => {
                             allowNumber
                         });
                         const preferWord = preferWords.find((midashi) => itemGroup.getItem(midashi));
-                        if (preferWord) {
+                        const allowed = allows.find((midashi) => itemGroup.getItem(midashi));
+                        if (preferWord && !allowed) {
                             const deniedItems = items.filter((item) => item.midashi !== preferWord);
                             for (const item of deniedItems) {
                                 const index = locationMap.get(item)?.index ?? 0;
diff --git a/test/textlint-rule-no-synonyms.test.ts b/test/textlint-rule-no-synonyms.test.ts
@@ -31,6 +31,28 @@ tester.run("textlint-rule-no-synonyms", rule, {
             options: {
                 preferWords: ["ユーザー"]
             }
+        },
+        // allowLexeme
+        {
+            text: "部屋の同義語はルームです",
+            options: {
+                allowLexeme: true
+            }
+        },
+        {
+            text: "部屋の英語はroomです",
+            options: {
+                allowLexeme: false,
+                allowAlphabet: true
+            }
+        },
+        {
+            text: "部屋の英語はroomです",
+            options: {
+                allowLexeme: false,
+                allowAlphabet: false,
+                allows: ["部屋"] // <= 片方が許可されていればOK
+            }
         }
     ],
     invalid: [
@@ -76,6 +98,31 @@ tester.run("textlint-rule-no-synonyms", rule, {
                 }
             ]
         },
+        {
+            text: "部屋のカタカナ英語はルームです",
+            options: {
+                allowLexeme: false
+            },
+            errors: [
+                {
+                    message: "同義語である「部屋」と「ルーム」が利用されています",
+                    index: 10
+                }
+            ]
+        },
+        {
+            text: "部屋の英語はroomです",
+            options: {
+                allowAlphabet: false,
+                allowLexeme: false
+            },
+            errors: [
+                {
+                    message: "同義語である「部屋」と「room」が利用されています",
+                    index: 6
+                }
+            ]
+        },
         {
             text: "ユーザーは許可しユーザはエラー。allowAlphabetがtrueならuserはエラーにならない",
             output: "ユーザーは許可しユーザーはエラー。allowAlphabetがtrueならuserはエラーにならない",
@@ -119,6 +166,20 @@ tester.run("textlint-rule-no-synonyms", rule, {
                     index: 0
                 }
             ]
+        },
+        {
+            text: "ルームは許可しallowLexemeがfalseなら部屋もエラー",
+            output: "ルームは許可しallowLexemeがfalseならルームもエラー",
+            options: {
+                preferWords: ["ルーム"],
+                allowLexeme: false
+            },
+            errors: [
+                {
+                    message: "「ルーム」の同義語である「部屋」が利用されています",
+                    index: 26
+                }
+            ]
         }
     ]
 });

Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,13 @@ textlint --rule @textlint-ja/no-synonyms README.md`
`76`	`76`	`* Default: true`
`77`	`77`	`*/`
`78`	`78`	`allowNumber?: boolean;`
	`79`	`+ /**`
	`80`	`+ * 語彙素の異なる同義語を許可するかどうか`
	`81`	`+ * trueの場合は語彙素の異なる同義語を許可します`
	`82`	`+ * 例) 「ルーム」と「部屋」`
	`83`	`+ * Default: true`
	`84`	`+ */`
	`85`	`+ allowLexeme?: boolean;`
`79`	`86`	`}`
`80`	`87`	```
`81`	`88`
`@@ -88,7 +95,8 @@ textlint --rule @textlint-ja/no-synonyms README.md`
`88`	`95`	`"allows": ["ウェブアプリ", "ウェブアプリケーション"],`
`89`	`96`	`"preferWords": ["ユーザー"],`
`90`	`97`	`"allowAlphabet": false,`
`91`		`- "allowNumber": false`
	`98`	`+ "allowNumber": false,`
	`99`	`+ "allowLexeme": false`
`92`	`100`	`}`
`93`	`101`	`}`
`94`	`102`	`}`