hanlint 0.0.17 → 0.0.18

package/src/rules/sentence/hardWord.js

@@ -5,7 +5,10 @@ import { dictionaryFindings } from "../shared/dictionaryRule.js";
 export const name = "hardWord";
 export const mechanism = "dictionary";
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  return dictionaryFindings(doc, "easyWords", name, NOTICE);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "easyWords", name, NOTICE, config);
 }

package/src/rules/sentence/japaneseLoan.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "japaneseLoan";
 export const mechanism = "dictionary";
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  return dictionaryFindings(doc, "japaneseLoan", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "japaneseLoan", name, ERROR, config);
 }

package/src/rules/sentence/nounPile.js

@@ -1,4 +1,6 @@
 // @ts-check
+import { nounRuns } from "../../analysis/index.js";
+import { attested, usageKindOf } from "../../usage/counts.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "nounPile";
@@ -10,12 +12,16 @@ export const mechanism = "threshold";
  */
 export function run(doc, config) {
   const findings = [];
+  const kind = usageKindOf(config);
   for (const sentence of doc.sentences) {
-    if (sentence.nounRun >= config.nounPileMin) {
-      findings.push(
-        finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, config.enforceStyle.includes(name) ? "error" : "notice", SENTENCE, sentence.index),
-      );
+    if (sentence.nounRun < config.nounPileMin) continue;
+    if (kind) {
+      const piles = nounRuns(sentence.text).filter(([, length]) => length >= config.nounPileMin).map(([chain]) => chain);
+      if (piles.length && piles.every((chain) => attested(chain, kind, config.usageMin))) continue;
     }
+    findings.push(
+      finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, config.enforceStyle.includes(name) ? "error" : "notice", SENTENCE, sentence.index),
+    );
   }
   return findings;
 }

package/src/rules/sentence/phraseRepeat.js

@@ -0,0 +1,53 @@
+// @ts-check
+import { loadEntries } from "../../data/load.js";
+import { compile } from "../../regex.js";
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+
+export const name = "phraseRepeat";
+export const mechanism = "repeat";
+
+/** 산문 문장이 이 수보다 적으면 비율이 튄다. 뜻은 파이썬 rules/sentence/phraseRepeat.py 가 소유한다. */
+const MIN_SENTENCES = 8;
+/** 되풀이로 세려면 몇 번 나와야 하는가. 한 번은 버릇이 아니다. */
+const MIN_HITS = 2;
+
+/** @returns {{pattern: import("../../regex.js").Pattern, share: number, label: string, why: string, source: string}[]} */
+function entries() {
+  return loadEntries("phraseRepeat.json").map((one) => ({
+    pattern: compile(String(one.pattern)),
+    share: Number(one.share),
+    label: String(one.label),
+    why: String(one.why),
+    source: String(one.source),
+  }));
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  void config;
+  const findings = [];
+  const prose = doc.sentences.filter((one) => one.length > 0 && one.ending !== "없음");
+  if (prose.length < MIN_SENTENCES) return findings;
+  for (const { pattern, share, label, why, source } of entries()) {
+    const hit = prose.filter((one) => pattern.search(one.text) !== null);
+    if (hit.length < MIN_HITS || hit.length / prose.length <= share) continue;
+    const lines = [...new Set(hit.map((one) => one.line))].sort((a, b) => a - b).join(", ");
+    const share100 = `${Math.round(share * 100)}%`;
+    findings.push(
+      finding(
+        name,
+        hit[0].line,
+        hit[0].text,
+        `\`${label}\` 꼴이 산문 ${prose.length}문장 가운데 ${hit.length}번이다 (${lines}줄. 상한 ${share100}). ${why} (${source})`,
+        null,
+        NOTICE,
+        DOCUMENT,
+        -1,
+      ),
+    );
+  }
+  return findings;
+}

package/src/rules/sentence/redundantPair.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "redundantPair";
 export const mechanism = "dictionary";
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  return dictionaryFindings(doc, "redundantPair", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "redundantPair", name, ERROR, config);
 }

package/src/rules/sentence/translationese.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "translationese";
 export const mechanism = "dictionary";
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  return dictionaryFindings(doc, "translationese", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "translationese", name, ERROR, config);
 }

package/src/rules/shared/dictionaryRule.js

@@ -1,6 +1,7 @@
 // @ts-check
 /** 사전 규칙의 공통 구현. cliche, translationese, redundantPair, japaneseLoan 이 사전 이름만 바꿔 쓴다. */
 import { fitJosa } from "../../analysis/grammar/josa.js";
+import { conventional, usageKindOf } from "../../usage/counts.js";
 import { ERROR, SENTENCE, finding } from "../finding.js";
 
 /**
@@ -41,11 +42,24 @@ function matchFinding(sentence, match, ruleName, severity) {
   );
 }
 
-export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR) {
+/**
+ * 사전의 매치를 지적으로. config 를 주면 그 종류의 관용 항목 (usage.conventional) 은 넘긴다. 뜻은 파이썬
+ * rules/shared/dictionaryRule.py 의 dictionaryFindings 가 소유한다.
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {string} dictionary
+ * @param {string} ruleName
+ * @param {string} [severity]
+ * @param {import("../../config/settings.js").Config | null} [config]
+ * @returns {import("../finding.js").Finding[]}
+ */
+export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR, config = null) {
   const findings = [];
+  const kind = config ? usageKindOf(config) : null;
   for (const sentence of doc.sentences) {
     for (const match of sentence.matches) {
-      if (match.dictionary === dictionary) findings.push(matchFinding(sentence, match, ruleName, severity));
+      if (match.dictionary !== dictionary) continue;
+      if (kind && config && conventional(dictionary, match.pattern, kind, config.usageShare)) continue;
+      findings.push(matchFinding(sentence, match, ruleName, severity));
     }
   }
   return findings;
@@ -57,9 +71,10 @@ export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR)
  * @param {string} dictionary
  * @param {string} ruleName
  * @param {string} [severity]
+ * @param {string | null} [builtinSeverity]
  * @returns {import("../finding.js").Finding[]}
  */
-export function overridingFindings(doc, dictionary, ruleName, severity = ERROR) {
+export function overridingFindings(doc, dictionary, ruleName, severity = ERROR, builtinSeverity = null) {
   const findings = [];
   for (const sentence of doc.sentences) {
     /** @type {Map<string, import("../../fingerprint/dictionaries.js").DictionaryMatch>} */
@@ -67,14 +82,15 @@ export function overridingFindings(doc, dictionary, ruleName, severity = ERROR)
     for (const match of sentence.matches) {
       if (match.dictionary === dictionary) chosen.set(`${match.start}:${match.end}`, match);
     }
-    for (const match of [...chosen.values()].sort((a, b) => a.start - b.start)) findings.push(matchFinding(sentence, match, ruleName, severity));
+    for (const match of [...chosen.values()].sort((a, b) => a.start - b.start)) findings.push(matchFinding(sentence, match, ruleName, match.pattern && builtinSeverity ? builtinSeverity : severity));
   }
   return findings;
 }
 
 /**
  * 문장마다 가장 앞의 매치 하나만 지적한다. 뜻은 파이썬 rules/shared/dictionaryRule.py 의 firstMatchFindings 가 소유한다.
- * 구체 무늬와 종결어미가 한 사전에 같이 사는 화면 사전에 쓴다. fix 는 내지 않는다.
+ * 구체 무늬와 종결어미가 한 사전에 같이 사는 화면 사전에 쓴다. 항목에 to 규칙이 있으면 문장 전체를 낱말로 다시 쓴
+ * 제안을 fix 로 낸다 (진행, 실패, 요구, 완료). 뜻을 골라야 하는 일반 종결어미는 to 가 없어 fix 도 없다.
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
  * @param {string} dictionary
  * @param {string} ruleName
@@ -86,18 +102,33 @@ export function firstMatchFindings(doc, dictionary, ruleName, severity = ERROR)
   for (const sentence of doc.sentences) {
     const match = sentence.matches.find((m) => m.dictionary === dictionary);
     if (!match) continue;
+    const [fragment, replacement] = match.rewrite ? changedSpan(sentence.text, match.rewrite) : [null, null];
     findings.push(
       finding(
         ruleName,
         sentence.line + countNewlines(sentence.text.slice(0, match.start)),
         sentence.text,
         `\`${match.text}\` ${match.why} (${match.source})`,
-        null,
+        match.rewrite,
         severity,
         SENTENCE,
         sentence.index,
+        fragment,
+        replacement,
       ),
     );
   }
   return findings;
 }
+
+/**
+ * 두 글의 공통 앞뒤를 뺀 바뀐 조각. 편집기의 `이대로 고치기` 가 이 조각만 바꾼다. 뜻은 파이썬 changedSpan 이 소유한다.
+ * @param {string} before @param {string} after @returns {[string, string]}
+ */
+export function changedSpan(before, after) {
+  let head = 0;
+  while (head < Math.min(before.length, after.length) && before[head] === after[head]) head++;
+  let tail = 0;
+  while (tail < Math.min(before.length, after.length) - head && before[before.length - 1 - tail] === after[after.length - 1 - tail]) tail++;
+  return [before.slice(head, before.length - tail), after.slice(head, after.length - tail)];
+}

package/src/text.js

@@ -64,7 +64,7 @@ export function countIn(text, needle, end = text.length) {
 
 /**
  * 파이썬 round(value, digits). 정확한 이진 값을 십진으로 풀어 반올림하고 정확히 절반이면 짝수로 간다.
- * Math.round 는 절반을 위로 올려 13/16 을 0.813 으로 만들고 파이썬은 0.812 다. 두 판의 글자가 같으려면 파이썬 쪽이다.
+ * Math.round 는 절반을 위로 올려 13/16 을 0.813 으로 만들고 파이썬은 0.812 다. 두 구현의 글자가 같으려면 파이썬 쪽이다.
  * toFixed(100) 은 1e21 아래의 수를 정확한 십진 전개로 준다. 지문의 비율과 평균이 사는 범위다.
  * @param {number} value
  * @param {number} digits

package/src/usage/counts.js

@@ -0,0 +1,54 @@
+// @ts-check
+/**
+ * 명사 연쇄 빈도표. 글 종류마다 data/usageCounts.<종류>.json 하나이고 값은 그 연쇄가 나온 문서 수다.
+ * 뜻은 파이썬 usage/counts.py 가 소유한다. 표의 키는 nounRuns 의 어절들을 빈칸 하나로 이은 것이다.
+ */
+import { USAGE_OF } from "../config/settings.js";
+import { readText } from "../data/load.js";
+
+/** @typedef {{ kind: string, source: string, documents: number, minLength: number, minDocuments: number, chains: Record<string, number>, patterns?: Record<string, Record<string, number>> }} UsageTable */
+
+/** @type {Map<string, UsageTable>} */
+const tables = new Map();
+
+/**
+ * 이 설정이 볼 빈도표의 종류. usageKind 가 null 이면 프리셋이 정하고 "" 면 보지 않는다.
+ * @param {import("../config/settings.js").Config} config @returns {string | null}
+ */
+export function usageKindOf(config) {
+  const kind = config.usageKind === null ? USAGE_OF[config.preset] : config.usageKind;
+  return kind || null;
+}
+
+/** 표 전체. @param {string} kind @returns {UsageTable} */
+export function usageTable(kind) {
+  let table = tables.get(kind);
+  if (!table) {
+    table = JSON.parse(readText(`usageCounts.${kind}.json`));
+    tables.set(kind, /** @type {UsageTable} */ (table));
+  }
+  return /** @type {UsageTable} */ (table);
+}
+
+/** 이 연쇄가 그 종류의 말뭉치에서 몇 편의 문서에 나왔나. 표에 없으면 0. @param {string[]} chain @param {string} kind */
+export function chainDocuments(chain, kind) {
+  return usageTable(kind).chains[chain.join(" ")] ?? 0;
+}
+
+/** 연쇄가 minimum 편 이상의 문서에 나왔으면 그 종류의 관용이다. @param {string[]} chain @param {string} kind @param {number} minimum */
+export function attested(chain, kind, minimum) {
+  return chainDocuments(chain, kind) >= minimum;
+}
+
+/** 사전 항목이 그 종류의 말뭉치에서 몇 편의 문서에 나왔나. @param {string} dictionary @param {string} pattern @param {string} kind */
+export function patternDocuments(dictionary, pattern, kind) {
+  return usageTable(kind).patterns?.[dictionary]?.[pattern] ?? 0;
+}
+
+/**
+ * 사전 항목이 그 종류의 문서 share 이상에 나오면 관용이다. 뜻은 파이썬 usage/counts.py 의 conventional 이 소유한다.
+ * @param {string} dictionary @param {string} pattern @param {string} kind @param {number} share
+ */
+export function conventional(dictionary, pattern, kind, share) {
+  return patternDocuments(dictionary, pattern, kind) >= share * usageTable(kind).documents;
+}

package/src/usage/index.js

@@ -0,0 +1,8 @@
+// @ts-check
+/**
+ * 용례 (usage). 실제 글에서 낱말이 어떻게 쓰였는지를 든다. 뜻은 파이썬 usage/ 가 소유한다.
+ * counts 는 실리는 빈도표, sentences 는 사용자 기계의 문장 역인덱스다.
+ * fingerprint 와 같은 층이다. rules 와 cli 가 쓰고, analysis 와 config 와 data 만 쓴다.
+ */
+export { attested, chainDocuments, conventional, patternDocuments, usageKindOf, usageTable } from "./counts.js";
+export { UsageIndex, buildIndex, defaultRoot as defaultUsageRoot, indexTokens, listIndexes, loadIndex, queryCores, readDocuments } from "./sentences.js";