hanlint 0.0.7 → 0.0.8

package/src/fingerprint/sourceSentence.js

@@ -0,0 +1,37 @@
+// @ts-check
+/** 평문 지문의 문장을 마크다운 표식을 보존한 원문 문장에 다시 맞춘다. */
+import { splitSentences } from "../analysis/splitSentences.js";
+import { plainText } from "../document/plainText.js";
+
+/**
+ * @param {import("./build.js").DocumentPrint} document
+ * @returns {Map<number, string>}
+ */
+export function sourceSentenceTexts(document) {
+  /** @type {Map<number, import("./build.js").SentencePrint[]>} */
+  const byBlock = new Map();
+  for (const sentence of document.sentences) {
+    const found = byBlock.get(sentence.blockIndex) ?? [];
+    found.push(sentence);
+    byBlock.set(sentence.blockIndex, found);
+  }
+  const blocks = new Map(document.blocks.map((block) => [block.index, block]));
+  const result = new Map();
+  for (const [blockIndex, plainSentences] of byBlock) {
+    const block = blocks.get(blockIndex);
+    if (!block) continue;
+    const rawSentences = splitSentences(block.text);
+    if (rawSentences.length !== plainSentences.length) continue;
+    if (plainSentences.some((plain, index) => plainText(rawSentences[index].text) !== plain.text)) continue;
+    plainSentences.forEach((plain, index) => result.set(plain.index, rawSentences[index].text));
+  }
+  return result;
+}
+
+/**
+ * @param {import("./build.js").DocumentPrint} document
+ * @param {import("./build.js").SentencePrint} sentence
+ */
+export function sourceSentenceText(document, sentence) {
+  return sourceSentenceTexts(document).get(sentence.index);
+}

package/src/fingerprint/topics.js

@@ -1,6 +1,6 @@
 // @ts-check
 /** 화제어 집합. 조사를 뗀 명사 어절의 근사. 파이썬 fingerprint/topics.py 와 같다. */
-import { stripJosa, tailOf, words } from "../analysis/surface/tokenize.js";
+import { stripJosa, tailOf, words } from "../analysis/tokenize.js";
 import { loadLines } from "../data/load.js";
 
 const WORD = /^[가-힣A-Za-z][가-힣A-Za-z0-9]*$/;

package/src/index.js

@@ -8,11 +8,10 @@
  * ```
  *
  * 합격과 불합격을 판정하지 않는다. 지적 목록이 비어 있다는 것은 세어서 잡히는 결함이 없다는 뜻이다.
- * 지문 지도 (audit, map), 프로파일, kiwi 정밀 모드는 파이썬 패키지에 있다.
+ * 지문 지도 (audit, map) 와 프로파일은 파이썬 패키지에 있다.
  */
 import { readFileSync } from "node:fs";
 
-import { makeAnalyzer } from "./analysis/index.js";
 import { loadConfig } from "./config/loadConfig.js";
 import { configFromMapping, defaultConfig } from "./config/settings.js";
 import { loadVersion } from "./data/load.js";
@@ -25,19 +24,6 @@ import { ruleDoc, ruleNames, ruleSummary, runAll } from "./rules/registry.js";
 export { applyFixes, configFromMapping, defaultConfig, fingerprintDict, loadConfig, ruleDoc, ruleNames, ruleSummary };
 export const version = loadVersion();
 
-/** @type {Map<string, import("./analysis/index.js").Analyzer>} */
-const analyzers = new Map();
-
-/** @param {import("./config/settings.js").Config} config */
-export function analyzerFor(config) {
-  let analyzer = analyzers.get(config.analyzer);
-  if (!analyzer) {
-    analyzer = makeAnalyzer(config.analyzer);
-    analyzers.set(config.analyzer, analyzer);
-  }
-  return analyzer;
-}
-
 /**
  * 글을 한 번 읽어 지문을 만든다.
  * @param {string} text
@@ -45,7 +31,7 @@ export function analyzerFor(config) {
  * @param {string | null} [path]
  */
 export function fingerprint(text, config = defaultConfig(), path = null) {
-  return buildFingerprint(parseMarkdown(text, path), analyzerFor(config), config);
+  return buildFingerprint(parseMarkdown(text, path), config);
 }
 
 /**

package/src/report/compactReport.js

@@ -1,9 +1,14 @@
 // @ts-check
 /** 한 줄에 지적 하나. AI 와 스크립트가 읽는 꼴이다. 파이썬 report/compactReport.py 와 같은 글자다. */
 
+/** 줄바꿈과 이어진 공백을 하나로 눕힌다. 한 줄은 이 꼴의 계약이다. @param {string} text */
+function flat(text) {
+  return text.split(/\s+/).filter(Boolean).join(" ");
+}
+
 /** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
 export function renderCompact(path, findings) {
   return findings
-    .map((f) => `${path}:${f.line} [${f.rule}] ${f.why}` + (f.fix ? `  고친 뒤: ${f.fix}` : ""))
+    .map((f) => `${path}:${f.line} [${f.rule}] ${flat(f.why)}` + (f.fix ? `  고친 뒤: ${flat(f.fix)}` : ""))
     .join("\n");
 }

package/src/report/fingerprintJson.js

@@ -4,12 +4,14 @@
  * 아래층을 index 로 가리킨다. 실수는 소수 여섯째 자리로 맞춰 두 구현이 같은 글자를 낸다.
  */
 
+import { roundHalfEven } from "../text.js";
+
 export const LAYERS = ["all", "sentences", "paragraphs", "sections", "document"];
 
 /** @param {number | null} value */
 function num(value) {
   if (value === null) return null;
-  return Math.round(value * 1e6) / 1e6;
+  return roundHalfEven(value, 6);
 }
 
 /** @param {Set<string>} set */
@@ -29,6 +31,7 @@ function sentenceDict(s) {
     length: s.length,
     ending: s.ending,
     mood: s.mood,
+    register: s.register,
     commas: s.commas,
     connectorStart: s.connectorStart,
     causal: s.causal,
@@ -102,9 +105,11 @@ function documentDict(doc) {
     sectionCount: doc.sections.length,
     questionCount: doc.questionCount,
     readerCallCount: doc.readerCallCount,
+    register: doc.register,
+    registerShare: roundHalfEven(doc.registerShare, 3),
     countPromises: doc.countPromises.map(([n, unit, line, text]) => [n, unit, line, text]),
-    promises: doc.promises.map(([line, text]) => [line, text]),
-    recalls: doc.recalls.map(([line, text]) => [line, text]),
+    promises: doc.reader.final.promises.map(([line, text]) => [line, text]),
+    recalls: doc.reader.final.recalls.map(([line, text]) => [line, text]),
     disabled: doc.disabled.map(([name, start, end]) => [name, start, end]),
   };
 }

package/src/report/jsonReport.js

@@ -1,13 +1,60 @@
 // @ts-check
-/** 기계가 읽는 꼴. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다. */
+/**
+ * 기계가 읽는 꼴. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다.
+ * 지적마다 `exemplar` 를 붙인다. 승인 원문 완전 일치 `patch`는 맞는 지적에만 별도로 붙인다.
+ * 실제 수정 차이는 파이썬의 exemplarLift와 patchMemory 탐침에서 따로 잰다.
+ */
+import { exemplarFor } from "../data/exemplars.js";
 import { findingAsDict } from "../rules/finding.js";
+import { exemplarInRegister } from "./registerMatch.js";
+import { operationGuidance } from "./operationMatch.js";
+import { patchData } from "./patchMatch.js";
+
+/** @param {import("../rules/finding.js").Finding} finding @param {string | null | undefined} register @param {string | null | undefined} preset @param {import("../data/exemplars.js").Exemplar[]} customExemplars */
+function findingWithExemplar(finding, document, register, preset, customExemplars, patches) {
+  const data = findingAsDict(finding);
+  const exemplar = exemplarFor(finding.rule, preset, customExemplars);
+  if (exemplar) {
+    const adapted = exemplarInRegister(exemplar, register);
+    data.exemplar = { before: adapted.before, after: adapted.after, moved: adapted.moved };
+  }
+  const selected = patchData(document, finding, preset, patches);
+  if (selected) data.patch = selected;
+  return data;
+}
 
 /**
  * @param {Map<string, import("../rules/finding.js").Finding[]>} results
  * @param {string | null} [configLabel]
+ * @param {Map<string, string> | null} [registers]
+ * @param {string | null} [preset]
+ * @param {import("../data/exemplars.js").Exemplar[]} [customExemplars]
+ * @param {Map<string, import("../fingerprint/build.js").DocumentPrint> | null} [documents]
+ * @param {import("../data/patches.js").Patch[]} [patches]
+ * @param {import("../data/operations.js").SurfaceOperation[]} [operations]
+ * @param {string[]} [protectedTerms]
  */
-export function renderJson(results, configLabel = null) {
-  const files = [...results].map(([path, findings]) => ({ path, findings: findings.map(findingAsDict) }));
+export function renderJson(
+  results,
+  configLabel = null,
+  registers = null,
+  preset = null,
+  customExemplars = [],
+  documents = null,
+  patches = [],
+  operations = [],
+  protectedTerms = [],
+) {
+  const files = [...results].map(([path, findings]) => {
+    const document = documents?.get(path);
+    const entry = {
+      path,
+      findings: findings.map((finding) => findingWithExemplar(finding, document, registers?.get(path), preset, customExemplars, patches)),
+    };
+    const selectedOperations = operationGuidance(document, findings, preset, operations, patches, protectedTerms);
+    if (selectedOperations.length) entry.operations = selectedOperations;
+    return entry;
+  });
   /** @type {Record<string, unknown>} */
   const data = { version: 1 };
   if (configLabel !== null) data.config = configLabel;

package/src/report/operationMatch.js

@@ -0,0 +1,31 @@
+// @ts-check
+/** 현재 문장에 승인 표면 치환이 안전하게 하나만 적용되는지 계산한다. */
+import { operationData, operationFor } from "../data/operations.js";
+import { sourceSentenceTexts } from "../fingerprint/sourceSentence.js";
+import { selectedPatch } from "./patchMatch.js";
+
+/**
+ * @param {import("../fingerprint/build.js").DocumentPrint | null | undefined} document
+ * @param {import("../rules/finding.js").Finding[]} findings
+ * @param {string | null | undefined} preset
+ * @param {import("../data/operations.js").SurfaceOperation[]} operations
+ * @param {import("../data/patches.js").Patch[]} [patches]
+ * @param {string[]} [protectedTerms]
+ */
+export function operationGuidance(document, findings, preset, operations, patches = [], protectedTerms = []) {
+  if (!document || !preset || !operations.length) return [];
+  const reserved = new Set(findings.filter((finding) => finding.at >= 0 && finding.fix !== null).map((finding) => finding.at));
+  for (const finding of findings) {
+    if (finding.at >= 0 && selectedPatch(document, finding, preset, patches)) reserved.add(finding.at);
+  }
+  const sourceTexts = sourceSentenceTexts(document);
+  const guidance = [];
+  for (const sentence of document.sentences) {
+    if (reserved.has(sentence.index)) continue;
+    const sourceText = sourceTexts.get(sentence.index);
+    if (sourceText === undefined) continue;
+    const applied = operationFor(sourceText, preset, operations, protectedTerms);
+    if (applied) guidance.push({ line: sentence.line, operation: operationData(applied, preset) });
+  }
+  return guidance;
+}

package/src/report/patchMatch.js

@@ -0,0 +1,44 @@
+// @ts-check
+/** 현재 지적과 지문을 승인 패치의 선택 조건에 맞댄다. */
+import { flatSentence, patchFor } from "../data/patches.js";
+import { readerKind } from "../fingerprint/readerState.js";
+import { sourceSentenceText } from "../fingerprint/sourceSentence.js";
+import { SENTENCE, localCue } from "../rules/finding.js";
+
+/**
+ * @param {import("../fingerprint/build.js").DocumentPrint | null | undefined} document
+ * @param {import("../rules/finding.js").Finding} finding
+ * @param {string | null | undefined} preset
+ * @param {import("../data/patches.js").Patch[]} patches
+ */
+export function selectedPatch(document, finding, preset, patches) {
+  if (!patches.length || !document || finding.scope !== SENTENCE || finding.at < 0 || finding.at >= document.sentences.length) return undefined;
+  const sentence = document.sentences[finding.at];
+  const sourceText = sourceSentenceText(document, sentence);
+  if (!sourceText) return undefined;
+  const state = document.reader.beforeSentence[finding.at];
+  return patchFor(finding.rule, preset, sourceText, sentence.text, localCue(finding), readerKind(sentence, state), patches);
+}
+
+/**
+ * @param {import("../fingerprint/build.js").DocumentPrint | null | undefined} document
+ * @param {import("../rules/finding.js").Finding} finding
+ * @param {string | null | undefined} preset
+ * @param {import("../data/patches.js").Patch[]} patches
+ */
+export function patchData(document, finding, preset, patches) {
+  const patch = selectedPatch(document, finding, preset, patches);
+  if (!patch || !preset) return undefined;
+  return {
+    before: patch.before,
+    after: patch.after,
+    moved: patch.moved,
+    match: {
+      sourceText: flatSentence(patch.sourceText),
+      sentence: flatSentence(patch.sentence),
+      preset,
+      cue: patch.cue,
+      reader: patch.reader,
+    },
+  };
+}

package/src/report/registerMatch.js

@@ -0,0 +1,40 @@
+// @ts-check
+/** 한 문체로 저장한 본보기와 문형을 검사한 글의 문체에 맞춘다. */
+import { HAPNIDA, REGISTERS, convertTemplate } from "../analysis/grammar/index.js";
+
+/** 섞임과 없음은 데이터 정본의 합니다체를 유지한다. @param {string | null | undefined} register */
+export function targetRegister(register) {
+  return register && REGISTERS.includes(register) ? register : HAPNIDA;
+}
+
+/** @param {import("../data/exemplars.js").Exemplar} exemplar @param {string | null | undefined} register */
+export function exemplarInRegister(exemplar, register) {
+  const target = targetRegister(register);
+  const before = convertTemplate(exemplar.before, target);
+  const after = convertTemplate(exemplar.after, target);
+  if (before.skipped || after.skipped) {
+    throw new Error(
+      exemplar.rule + " 본보기의 서술어를 못 풀었다: " + (before.skipped + after.skipped),
+    );
+  }
+  return { rule: exemplar.rule, before: before.text, after: after.text, moved: exemplar.moved, presets: exemplar.presets };
+}
+
+/** @param {import("../data/patterns.js").Pattern} pattern @param {string | null | undefined} register */
+export function patternInRegister(pattern, register) {
+  const target = targetRegister(register);
+  const form = convertTemplate(pattern.form, target);
+  const example = convertTemplate(pattern.example, target);
+  const instead = convertTemplate(pattern.instead, target);
+  const skipped = form.skipped + example.skipped + instead.skipped;
+  if (skipped) throw new Error(pattern.name + " 문형의 서술어를 못 풀었다: " + skipped);
+  return {
+    name: pattern.name,
+    form: form.text,
+    when: pattern.when,
+    example: example.text,
+    instead: instead.text,
+    avoids: pattern.avoids,
+    source: pattern.source,
+  };
+}

package/src/report/textReport.js

@@ -1,8 +1,42 @@
 // @ts-check
-/** 사람이 읽는 지적 목록. `파일:줄` 로 시작해 편집기가 바로 연다. 파이썬 report/textReport.py 와 같은 글자다. */
+/**
+ * 사람이 읽는 지적 목록. `파일:줄` 로 시작해 편집기가 바로 연다. 파이썬 report/textReport.py 와 같은 글자다.
+ * 끝에 본보기를 붙인다. 전과 후를 제 줄에 둔다. 왜 한 줄이 아닌지는 파이썬 report/textReport.py 가 소유한다.
+ */
+import { exemplarFor, shortened, twoLines } from "../data/exemplars.js";
+import { exemplarInRegister } from "./registerMatch.js";
 
-/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
-export function renderText(path, findings) {
+/** 그 글에 나온 규칙의 본보기. 이름 순이고 규칙 하나에 세 줄이다. @param {import("../rules/finding.js").Finding[]} findings @param {string | null | undefined} register @param {string | null | undefined} preset @param {import("../data/exemplars.js").Exemplar[]} customExemplars */
+function exemplarLines(findings, register, preset, customExemplars) {
+  const lines = [];
+  let cut = false;
+  for (const name of [...new Set(findings.map((f) => f.rule))].sort()) {
+    let exemplar = exemplarFor(name, preset, customExemplars);
+    if (!exemplar) continue;
+    exemplar = exemplarInRegister(exemplar, register);
+    const [before, after] = twoLines(exemplar);
+    cut = cut || shortened(exemplar);
+    lines.push(`  [${name}]`, `    전  ${before}`, `    후  ${after}`);
+  }
+  if (!lines.length) return [];
+  const head = "본보기 (고치기 전, 고친 뒤)";
+  return [cut ? `${head}. 잘린 것은 hanlint explain <규칙>` : head, ...lines];
+}
+
+/** 본보기 아래에 붙이는 선택지. 지적 자리별이며 순위는 없다. @param {import("../rules/finding.js").Finding[]} findings */
+function candidateLines(findings) {
+  const chosen = findings.filter((finding) => finding.candidates.length);
+  if (!chosen.length) return [];
+  const lines = ["후보 (기계가 고르지 않음)"];
+  for (const finding of chosen) {
+    lines.push(`  ${finding.line}줄 [${finding.rule}]`);
+    for (const candidate of finding.candidates) lines.push(`    - ${candidate.text} (${candidate.why})`);
+  }
+  return lines;
+}
+
+/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings @param {string | null | undefined} [register] @param {string | null | undefined} [preset] @param {import("../data/exemplars.js").Exemplar[]} [customExemplars] */
+export function renderText(path, findings, register = null, preset = null, customExemplars = []) {
   if (!findings.length) return `${path}  집은 자리 없음`;
   const errors = findings.filter((f) => f.severity === "error").length;
   const notices = findings.length - errors;
@@ -14,6 +48,8 @@ export function renderText(path, findings) {
     if (f.fix) lines.push(`  고친 뒤: ${f.fix}`);
     lines.push("");
   }
-  lines.push(`규칙이 왜 있는지 보려면: hanlint explain ${findings[0].rule}`);
-  return lines.join("\n");
+  lines.push(...exemplarLines(findings, register, preset, customExemplars));
+  const candidates = candidateLines(findings);
+  if (candidates.length) lines.push("", ...candidates);
+  return lines.join("\n").replace(/\n+$/, "");
 }

package/src/rules/code/duplicateBlock.js

@@ -1,8 +1,9 @@
 // @ts-check
+import { roundHalfEven } from "../../text.js";
 import { DOCUMENT, NOTICE, finding } from "../finding.js";
-import { codeBlocksOf } from "../shared/codeBlocks.js";
 
 export const name = "duplicateBlock";
+export const mechanism = "repeat";
 const MIN_LINES = 4;
 
 /** 줄 다중집합의 겹침 비. 2 * 공통 / (a + b). @param {string[]} a @param {string[]} b */
@@ -28,7 +29,7 @@ function similarity(a, b) {
  */
 export function run(doc, config) {
   const findings = [];
-  const blocks = codeBlocksOf(doc).filter((b) => b.lines.filter(([, line]) => line.trim()).length >= MIN_LINES);
+  const blocks = doc.codeBlocks.filter((b) => b.lines.filter(([, line]) => line.trim()).length >= MIN_LINES);
   for (let later = 0; later < blocks.length; later++) {
     const current = blocks[later];
     const currentLines = current.lines.filter(([, line]) => line.trim()).map(([, line]) => line.trim());
@@ -38,7 +39,7 @@ export function run(doc, config) {
       const ratio = similarity(previous.lines.filter(([, line]) => line.trim()).map(([, line]) => line.trim()), currentLines);
       if (ratio >= config.duplicateBlockRatio) {
         findings.push(
-          finding(name, current.startLine, currentLines[0], `${previous.startLine}번째 줄의 블록과 ${Math.round(ratio * 100)}% 같다. 다른 줄만 남기거나 앞 블록을 가리킨다`, null, NOTICE, DOCUMENT, current.index),
+          finding(name, current.startLine, currentLines[0], `${previous.startLine}번째 줄의 블록과 ${roundHalfEven(ratio * 100, 0)}% 같다. 다른 줄만 남기거나 앞 블록을 가리킨다`, null, NOTICE, DOCUMENT, current.index),
         );
         break;
       }

package/src/rules/code/firstResultDistance.js

@@ -3,6 +3,7 @@ import { CODE, IMAGE, TABLE } from "../../document/model.js";
 import { NOTICE, PARAGRAPH, finding } from "../finding.js";
 
 export const name = "firstResultDistance";
+export const mechanism = "threshold";
 const RESULT_KINDS = [CODE, IMAGE, TABLE];
 
 /**

package/src/rules/code/inputFileSource.js

@@ -1,39 +1,23 @@
 // @ts-check
+import { createdIn, fileName, readsIn, writeTargets } from "../../fingerprint/codeMarkers.js";
 import { DOCUMENT, NOTICE, finding } from "../finding.js";
-import { codeBlocksOf } from "../shared/codeBlocks.js";
 
 export const name = "inputFileSource";
+export const mechanism = "reader";
 
-const QUOTED = "\\(\\s*[\"']([^\"'\\n]+)[\"']";
-const READS = new RegExp(
-  "\\b(?:read_csv|read_excel|read_parquet|read_json|read_sql|read_table|read_ndjson|scan_csv|scan_parquet|scan_ndjson|" +
-    "read_text|read_bytes|loadtxt|imread|load_workbook)" + QUOTED,
-  "g",
-);
-const OPENS = new RegExp("\\bopen" + QUOTED + "\\s*(?:,\\s*(?:mode\\s*=\\s*)?[\"']([^\"']*)[\"'])?", "g");
-const WRITES = new RegExp(
-  "\\b(?:to_csv|to_excel|to_parquet|to_json|to_sql|write_csv|write_parquet|write_json|write_ndjson|sink_parquet|sink_csv|" +
-    "write_text|write_bytes|savefig|save|imwrite|savetxt|dump)" + QUOTED,
-  "g",
-);
-const SHELL_WRITES = /(?:>>?|-o|-O|--output|Out-File)\s*["']?([\w./\\-]+\.[A-Za-z0-9]+)/g;
-const SQL_PATHS = /FROM\s+'([^']+\.(?:csv|parquet|json|xlsx))'/gi;
-const MAKES_DIR = /(?:mkdir(?:\s+-p)?|makedirs|md)\s*\(?\s*["']?([\w./\\-]+)|Path\(\s*["']([^"']+)["']\s*\)\.mkdir/g;
 const EXTENSIONS = new Set(
   "csv xlsx xls parquet json jsonl txt png jpg jpeg svg gif db sqlite md py yaml yml toml html pdf zip ndjson".split(" "),
 );
-
-/** @param {string} path */
-function fileName(path) {
-  const parts = path.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
-  return parts[parts.length - 1];
-}
+/** 별표, 서식 자리표시자, URL 이 든 경로는 파일 하나를 가리키지 않는다. */
+const NOT_A_FILE = ["*", "{", "http", "://", "<", ">"];
+/** 폴더를 볼 때는 물음표까지 뺀다. */
+const NOT_A_PATH = [...NOT_A_FILE, "?"];
 
 /** @param {string} path */
 function isDataFile(path) {
-  if (["*", "{", "http", "://", "<", ">"].some((mark) => path.includes(mark))) return false;
-  const name = fileName(path);
-  return name.includes(".") && EXTENSIONS.has(name.split(".").pop()?.toLowerCase() ?? "");
+  if (NOT_A_FILE.some((mark) => path.includes(mark))) return false;
+  const name2 = fileName(path);
+  return name2.includes(".") && EXTENSIONS.has(name2.split(".").pop()?.toLowerCase() ?? "");
 }
 
 /** @param {string} path */
@@ -42,62 +26,33 @@ function directoryOf(path) {
   return parts.length > 1 && !["", ".", ".."].includes(parts[0]) ? parts[0] : null;
 }
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc @param {string} needle @param {number} line */
-function mentionedBefore(doc, needle, line) {
-  return doc.sentences.some((s) => s.line < line && s.text.includes(needle));
-}
-
-/** @param {RegExp} pattern @param {string} text @param {number} group */
-function all(pattern, text, group) {
-  pattern.lastIndex = 0;
-  const found = [];
-  for (const match of text.matchAll(pattern)) if (match[group] !== undefined) found.push(match[group]);
-  return found;
-}
-
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
-  /** @type {Set<string>} */
-  const created = new Set();
-  for (const block of codeBlocksOf(doc)) {
-    /** @type {Set<string>} */
-    const blockWrites = new Set();
-    /** @type {Set<string>} */
-    const blockDirs = new Set();
-    for (const [, code] of block.lines) {
-      for (const name2 of all(WRITES, code, 1)) blockWrites.add(fileName(name2));
-      for (const name2 of all(SHELL_WRITES, code, 1)) blockWrites.add(fileName(name2));
-      OPENS.lastIndex = 0;
-      for (const match of code.matchAll(OPENS)) {
-        const mode = match[2] ?? "r";
-        if ([..."wax"].some((flag) => mode.includes(flag))) blockWrites.add(fileName(match[1]));
-      }
-      MAKES_DIR.lastIndex = 0;
-      for (const match of code.matchAll(MAKES_DIR)) blockDirs.add((match[1] ?? match[2]).replace(/\\/g, "/").split("/")[0]);
-    }
-    for (const dir of blockDirs) created.add(dir);
+  /** 이미 짚은 폴더. 같은 폴더를 두 번 짚지 않는다. @type {Set<string>} */
+  const reported = new Set();
+  for (const block of doc.codeBlocks) {
+    const reader = doc.reader.beforeBlock[block.index];
+    const [blockWrites, blockDirs] = createdIn(block.lines.map(([, line]) => line));
+    // 이 블록이 만드는 폴더는 같은 블록의 읽기에도 미리 센다. 파일은 블록 안에서 쓴 것 (blockWrites) 만 따로 본다.
+    const have = new Set([...reader.files, ...blockDirs, ...reported]);
     for (const [line, code] of block.lines) {
-      OPENS.lastIndex = 0;
-      const reads = [...all(READS, code, 1), ...all(SQL_PATHS, code, 1)];
-      for (const match of code.matchAll(OPENS)) {
-        if (![..."wax"].some((flag) => (match[2] ?? "r").includes(flag))) reads.push(match[1]);
-      }
+      const reads = readsIn(code);
       for (const path of reads) {
         if (!isDataFile(path)) continue;
         const name2 = fileName(path);
-        if (created.has(name2) || blockWrites.has(name2) || mentionedBefore(doc, name2, block.startLine)) continue;
+        if (have.has(name2) || blockWrites.has(name2) || doc.reader.mentionedBefore(block.index, name2)) continue;
         findings.push(finding(name, line, code.trim(), `\`${name2}\` 을 읽는데 글 어디에서도 만들지 않았다. 독자는 여기서 파일 없음 오류로 멈춘다`, null, "error", DOCUMENT, block.index));
       }
-      for (const path of [...all(WRITES, code, 1), ...reads]) {
-        if (["http", "://", "{", "<", ">", "*", "?"].some((mark) => path.includes(mark))) continue;
+      for (const path of [...writeTargets(code), ...reads]) {
+        if (NOT_A_PATH.some((mark) => path.includes(mark))) continue;
         const directory = directoryOf(path);
-        if (!directory || created.has(directory) || mentionedBefore(doc, directory, block.startLine)) continue;
-        created.add(directory);
+        if (!directory || have.has(directory) || doc.reader.mentionedBefore(block.index, directory)) continue;
+        have.add(directory);
+        reported.add(directory);
         findings.push(finding(name, line, code.trim(), `\`${directory}\` 폴더를 쓰는데 글 어디에서도 만들지 않았다. 없으면 파일을 쓰다 멈춘다`, null, NOTICE, DOCUMENT, block.index));
       }
     }
-    for (const write of blockWrites) created.add(write);
   }
   return findings;
 }

package/src/rules/code/installImport.js

@@ -1,9 +1,9 @@
 // @ts-check
 import { loadLines } from "../../data/load.js";
 import { DOCUMENT, NOTICE, finding } from "../finding.js";
-import { codeBlocksOf } from "../shared/codeBlocks.js";
 
 export const name = "installImport";
+export const mechanism = "contrast";
 
 const INSTALL = /(?:pip\s+install|uv\s+add|uv\s+pip\s+install|conda\s+install|poetry\s+add)\s+([^\n#|&;]+)/g;
 const IMPORT = /^\s*(?:import\s+([\w.]+(?:\s*,\s*[\w.]+)*)|from\s+([\w.]+)\s+import\b)/;
@@ -49,7 +49,7 @@ function normalize(value) {
 
 /** 설치 줄이 말한 패키지 → extras. 설치 줄이 하나도 없으면 null. @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 function installed(doc) {
-  const texts = [...codeBlocksOf(doc).flatMap((b) => b.lines.map(([, line]) => line)), ...doc.sentences.map((s) => s.text)];
+  const texts = [...doc.codeBlocks.flatMap((b) => b.lines.map(([, line]) => line)), ...doc.sentences.map((s) => s.text)];
   /** @type {Map<string, Set<string>>} */
   const packages = new Map();
   let seen = false;
@@ -80,7 +80,7 @@ function localModules(doc) {
     PY_FILE.lastIndex = 0;
     for (const match of sentence.text.matchAll(PY_FILE)) names.add(match[1]);
   }
-  for (const block of codeBlocksOf(doc)) {
+  for (const block of doc.codeBlocks) {
     for (const [, line] of block.lines) {
       PY_FILE.lastIndex = 0;
       for (const match of line.matchAll(PY_FILE)) names.add(match[1]);
@@ -95,7 +95,7 @@ export function run(doc) {
   if (packages === null) return [];
   const local = localModules(doc);
   const findings = [];
-  for (const block of codeBlocksOf(doc)) {
+  for (const block of doc.codeBlocks) {
     if (!["python", "py"].includes(block.language)) continue;
     for (const [line, code] of block.lines) {
       const match = IMPORT.exec(code);

package/src/rules/code/platformApi.js

@@ -1,17 +1,18 @@
 // @ts-check
 import { loadLines } from "../../data/load.js";
 import { DOCUMENT, NOTICE, finding } from "../finding.js";
-import { codeBlocksOf } from "../shared/codeBlocks.js";
 
 export const name = "platformApi";
+export const mechanism = "dictionary";
 
-/** @type {[RegExp, string, string][] | null} */
+/** @type {[RegExp, string, string, string][] | null} */
 let cache = null;
 function platformApis() {
   if (!cache) {
     cache = loadLines("platformApis.txt").map((line) => {
       const [pattern, platform, alternative] = line.split("\t");
-      return /** @type {[RegExp, string, string]} */ ([new RegExp(pattern), platform, alternative]);
+      // 지적문에는 정규식 원문을 적는다. V8 의 RegExp.source 는 / 를 \/ 로 돌려줘 파이썬의 pattern.pattern 과 갈린다.
+      return /** @type {[RegExp, string, string, string]} */ ([new RegExp(pattern), pattern, platform, alternative]);
     });
   }
   return cache;
@@ -20,13 +21,13 @@ function platformApis() {
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
-  for (const block of codeBlocksOf(doc)) {
+  for (const block of doc.codeBlocks) {
     if (block.isOutput) continue;
     for (const [line, code] of block.lines) {
-      for (const [pattern, platform, alternative] of platformApis()) {
+      for (const [pattern, source, platform, alternative] of platformApis()) {
         pattern.lastIndex = 0;
         if (pattern.test(code)) {
-          findings.push(finding(name, line, code.trim(), `\`${pattern.source}\` 은 ${platform} 전용이다. 다른 운영체제 독자는 여기서 멈춘다. ${alternative}`, null, NOTICE, DOCUMENT, block.index));
+          findings.push(finding(name, line, code.trim(), `\`${source}\` 은 ${platform} 전용이다. 다른 운영체제 독자는 여기서 멈춘다. ${alternative}`, null, NOTICE, DOCUMENT, block.index));
           break;
         }
       }