chore(deps): remove husky (#11)

azu · web-flow · commit 8b76cb5da270 · 2021-08-08T12:34:09.000+09:00
diff --git a/.githooks/pre-commit b/.githooks/pre-commit
@@ -0,0 +1,2 @@
+#!/bin/sh
+npx --no-install lint-staged
diff --git a/package.json b/package.json
@@ -27,10 +27,11 @@
   },
   "scripts": {
     "build": "textlint-scripts build",
-    "prettier": "prettier --write \"**/*.{js,jsx,ts,tsx,css}\"",
     "prepublish": "npm run --if-present build",
     "test": "textlint-scripts test",
-    "watch": "textlint-scripts build --watch"
+    "watch": "textlint-scripts build --watch",
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,css}\"",
+    "prepare": "git config --local core.hooksPath .githooks"
   },
   "husky": {
     "hooks": {
@@ -39,14 +40,14 @@
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,css}": [
-      "prettier --write",
-      "git add"
+      "prettier --write"
     ]
   },
   "prettier": {
-    "printWidth": 120,
     "singleQuote": false,
-    "tabWidth": 4
+    "printWidth": 120,
+    "tabWidth": 4,
+    "trailingComma": "none"
   },
   "dependencies": {
     "textlint-rule-helper": "^2.1.1",
@@ -55,9 +56,8 @@
   "devDependencies": {
     "@textlint/types": "^1.3.1",
     "@types/node": "^14.0.13",
-    "husky": "^4.2.5",
-    "lint-staged": "^10.2.11",
-    "prettier": "^2.0.5",
+    "lint-staged": "^11.1.2",
+    "prettier": "^2.3.2",
     "sudachi-synonyms-dictionary": "^5.0.1",
     "textlint-scripts": "^3.0.0",
     "textlint-tester": "^5.1.15",
diff --git a/src/create-index.ts b/src/create-index.ts
@@ -15,18 +15,22 @@ export type Midashi = string;
  * usedItemGroup.forEach
  */
 export class ItemGroup {
-    constructor(public items: SudachiSynonyms[]) {
-
-    }
+    constructor(public items: SudachiSynonyms[]) {}
 
     getItem(midashi: string): SudachiSynonyms | null {
-        return this.items.find(item => item.midashi === midashi) ?? null
+        return this.items.find((item) => item.midashi === midashi) ?? null;
     }
 
-    usedItems(usedItemSet: Set<SudachiSynonyms>, { allowAlphabet, allowNumber, allows }: { allowAlphabet: boolean; allowNumber: boolean; allows: string[] }): SudachiSynonyms[] {
+    usedItems(
+        usedItemSet: Set<SudachiSynonyms>,
+        { allowAlphabet, allowNumber, allows }: { allowAlphabet: boolean; allowNumber: boolean; allows: string[] }
+    ): SudachiSynonyms[] {
         // sort by used
-        return Array.from(usedItemSet.values()).filter(item => {
-            if (allowAlphabet && (item.hyoukiYure === "アルファベット表記" || item.ryakusyou === "略語・略称/アルファベット")) {
+        return Array.from(usedItemSet.values()).filter((item) => {
+            if (
+                allowAlphabet &&
+                (item.hyoukiYure === "アルファベット表記" || item.ryakusyou === "略語・略称/アルファベット")
+            ) {
                 // アルファベット表記
                 // blog <-> ブログ
                 // 略語・略称/アルファベット
@@ -61,7 +65,10 @@ $ npm install sudachi-synonyms-dictionary
 `);
     }
 };
-export type IndexType = { keyItemGroupMap: Map<Midashi, ItemGroup[]>; SudachiSynonymsItemGroup: Map<SudachiSynonyms, ItemGroup>; };
+export type IndexType = {
+    keyItemGroupMap: Map<Midashi, ItemGroup[]>;
+    SudachiSynonymsItemGroup: Map<SudachiSynonyms, ItemGroup>;
+};
 let _ret: IndexType | null = null;
 export const createIndex = async (): Promise<IndexType> => {
     if (_ret) {
@@ -71,19 +78,21 @@ export const createIndex = async (): Promise<IndexType> => {
     const keyItemGroupMap: Map<Midashi, ItemGroup[]> = new Map();
     const SudachiSynonymsItemGroup: Map<SudachiSynonyms, ItemGroup> = new Map();
     const SynonymsDictionary = await fetchDictionary();
-    SynonymsDictionary.forEach(group => {
+    SynonymsDictionary.forEach((group) => {
         const groupByVocabularyNumber = group.items.reduce((res, item) => {
             res[item.vocabularyNumber!] = (res[item.vocabularyNumber!] || []).concat(item);
             return res;
         }, {} as { [index: string]: SudachiSynonyms[] });
-        const itemGroups = Object.values(groupByVocabularyNumber).filter(items => {
-            return items.length > 1;
-        }).map(items => {
-            return new ItemGroup(items);
-        });
+        const itemGroups = Object.values(groupByVocabularyNumber)
+            .filter((items) => {
+                return items.length > 1;
+            })
+            .map((items) => {
+                return new ItemGroup(items);
+            });
         // register key with itemGroup
-        itemGroups.forEach(itemGroup => {
-            itemGroup.items.forEach(item => {
+        itemGroups.forEach((itemGroup) => {
+            itemGroup.items.forEach((item) => {
                 const oldItemGroup = keyItemGroupMap.get(item.midashi) || [];
                 keyItemGroupMap.set(item.midashi, oldItemGroup.concat(itemGroup));
                 SudachiSynonymsItemGroup.set(item, itemGroup);
diff --git a/src/textlint-rule-no-synonyms.ts b/src/textlint-rule-no-synonyms.ts
@@ -35,7 +35,6 @@ export interface Options {
     allowNumber?: boolean;
 }
 
-
 export const DefaultOptions: Required<Options> = {
     allows: [],
     preferWords: [],
@@ -58,10 +57,10 @@ const report: TextlintRuleReporter<Options> = (context, options = {}) => {
         if (!itemGroups) {
             return;
         }
-        itemGroups.forEach(itemGroup => {
+        itemGroups.forEach((itemGroup) => {
             // "アーカイブ" など同じ見出しを複数回もつItemGroupがあるため、ItemGroupごとに1度のみに限定
             let midashAtOnce = false;
-            itemGroup.items.forEach(item => {
+            itemGroup.items.forEach((item) => {
                 if (!midashAtOnce && item.midashi === segment) {
                     midashAtOnce = true;
                     usedSudachiSynonyms.add(item);
@@ -71,9 +70,18 @@ const report: TextlintRuleReporter<Options> = (context, options = {}) => {
             });
         });
     };
-    return wrapReportHandler(context,
+    return wrapReportHandler(
+        context,
         {
-            ignoreNodeTypes: [Syntax.BlockQuote, Syntax.CodeBlock, Syntax.Code, Syntax.Html, Syntax.Link, Syntax.Image, Syntax.Comment]
+            ignoreNodeTypes: [
+                Syntax.BlockQuote,
+                Syntax.CodeBlock,
+                Syntax.Code,
+                Syntax.Html,
+                Syntax.Link,
+                Syntax.Image,
+                Syntax.Comment
+            ]
         },
         (report) => {
             return {
@@ -95,27 +103,33 @@ const report: TextlintRuleReporter<Options> = (context, options = {}) => {
                             allowAlphabet,
                             allowNumber
                         });
-                        const preferWord = preferWords.find(midashi => itemGroup.getItem(midashi))
+                        const preferWord = preferWords.find((midashi) => itemGroup.getItem(midashi));
                         if (preferWord) {
-                            const deniedItems = items.filter(item => item.midashi !== preferWord)
+                            const deniedItems = items.filter((item) => item.midashi !== preferWord);
                             for (const item of deniedItems) {
                                 const index = locationMap.get(item)?.index ?? 0;
-                                const deniedWord = item.midashi
+                                const deniedWord = item.midashi;
                                 const message = `「${preferWord}」の同義語である「${deniedWord}」が利用されています`;
-                                report(node, new RuleError(message, {
-                                    index,
-                                    fix: fixer.replaceTextRange([index, index + deniedWord.length], preferWord),
-                                }));
+                                report(
+                                    node,
+                                    new RuleError(message, {
+                                        index,
+                                        fix: fixer.replaceTextRange([index, index + deniedWord.length], preferWord)
+                                    })
+                                );
                             }
                         } else if (items.length >= 2) {
-                            const 同義の見出しList = items.map(item => item.midashi);
+                            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(
+                                node,
+                                new RuleError(message, {
+                                    index
+                                })
+                            );
                         }
                     }
                 }
@@ -126,5 +140,5 @@ const report: TextlintRuleReporter<Options> = (context, options = {}) => {
 
 export default {
     linter: report,
-    fixer: report,
+    fixer: report
 };
diff --git a/test/textlint-rule-no-synonyms.test.ts b/test/textlint-rule-no-synonyms.test.ts
@@ -22,7 +22,7 @@ tester.run("textlint-rule-no-synonyms", rule, {
         {
             text: `ウェブアプリとウェブアプリケーションの違いは許容する`,
             options: {
-                allows: ["ウェブアプリ"]　// <= 片方が許可されていればOK
+                allows: ["ウェブアプリ"] // <= 片方が許可されていればOK
             }
         },
         // preferWords
@@ -31,51 +31,63 @@ tester.run("textlint-rule-no-synonyms", rule, {
             options: {
                 preferWords: ["ユーザー"]
             }
-        },
+        }
     ],
-    invalid: [{
-        text: "サーバとサーバーの表記揺れがある",
-        errors: [{
-            message: "同義語である「サーバ」と「サーバー」が利用されています",
-            index: 4
-        }]
-    }, {
-        text: "この雇入と雇入れの違いは難しい問題だ",
-        errors: [{
-            message: "同義語である「雇入」と「雇入れ」が利用されています",
-            index: 5
-        }]
-    },
+    invalid: [
+        {
+            text: "サーバとサーバーの表記揺れがある",
+            errors: [
+                {
+                    message: "同義語である「サーバ」と「サーバー」が利用されています",
+                    index: 4
+                }
+            ]
+        },
+        {
+            text: "この雇入と雇入れの違いは難しい問題だ",
+            errors: [
+                {
+                    message: "同義語である「雇入」と「雇入れ」が利用されています",
+                    index: 5
+                }
+            ]
+        },
         {
             text: "blogはブログです",
             options: {
                 allowAlphabet: false
             },
-            errors: [{
-                message: "同義語である「blog」と「ブログ」が利用されています",
-                index: 5
-            }]
+            errors: [
+                {
+                    message: "同義語である「blog」と「ブログ」が利用されています",
+                    index: 5
+                }
+            ]
         },
         {
             text: "1は数字の一種です",
             options: {
                 allowNumber: false
             },
-            errors: [{
-                message: "同義語である「1」と「一」が利用されています",
-                index: 5
-            }]
+            errors: [
+                {
+                    message: "同義語である「1」と「一」が利用されています",
+                    index: 5
+                }
+            ]
         },
         {
             text: "ユーザーは許可しユーザはエラー。allowAlphabetがtrueならuserはエラーにならない",
             output: "ユーザーは許可しユーザーはエラー。allowAlphabetがtrueならuserはエラーにならない",
             options: {
                 preferWords: ["ユーザー"]
             },
-            errors: [{
-                message: "「ユーザー」の同義語である「ユーザ」が利用されています",
-                index: 8
-            }]
+            errors: [
+                {
+                    message: "「ユーザー」の同義語である「ユーザ」が利用されています",
+                    index: 8
+                }
+            ]
         },
         {
             text: "ユーザーは許可しallowAlphabetがfalseならユーザもuserもエラー",
@@ -84,24 +96,29 @@ tester.run("textlint-rule-no-synonyms", rule, {
                 preferWords: ["ユーザー"],
                 allowAlphabet: false
             },
-            errors: [{
-                message: "「ユーザー」の同義語である「ユーザ」が利用されています",
-                index: 29
-            }, {
-                message: "「ユーザー」の同義語である「user」が利用されています",
-                index: 33
-            }]
+            errors: [
+                {
+                    message: "「ユーザー」の同義語である「ユーザ」が利用されています",
+                    index: 29
+                },
+                {
+                    message: "「ユーザー」の同義語である「user」が利用されています",
+                    index: 33
+                }
+            ]
         },
         {
             text: "ユーザはエラー",
             output: "ユーザーはエラー",
             options: {
                 preferWords: ["ユーザー"]
             },
-            errors: [{
-                message: "「ユーザー」の同義語である「ユーザ」が利用されています",
-                index: 0
-            }]
-        },
+            errors: [
+                {
+                    message: "「ユーザー」の同義語である「ユーザ」が利用されています",
+                    index: 0
+                }
+            ]
+        }
     ]
 });
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+#!/bin/sh`
	`2`	`+npx --no-install lint-staged`