chaffjs 0.6.0 → 0.8.0

package/src/run.ts

@@ -2,6 +2,8 @@ import { DETECTORS } from "./detectors/index.ts";
 import { resolve } from "./levels.ts";
 import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
+import { REASONS, type Reasons } from "./reasons.ts";
+import { uiLanguageOf } from "./ui.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
 
@@ -22,7 +24,7 @@ const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolea
   return "normal";
 };
 
-const CAPABILITY_NAME: Readonly<Record<string, string>> = { pos: "品詞解析", lemma: "原形" };
+const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.language)];
 
 /** 知らない要求は満たされていないものとして扱う。黙って無視すると、要求なしで動いてしまう。 */
 const has = (capabilities: ProseDocument["capabilities"], need: string): boolean => {
@@ -42,13 +44,19 @@ const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 ||
 
 /** 要求を満たさない rule は動かせない。満たさないまま動かすと「指摘 0 件」が保証に見える。 */
 const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
-  if (rule.languages !== undefined && !rule.languages.includes(doc.language)) return `${doc.language} 向けの rule ではないため`;
+  if (rule.languages !== undefined && !rule.languages.includes(doc.language)) return reasonsFor(doc).otherLanguage(doc.language);
   const missing = rule.requires.filter((need) => need !== "structure").find((need) => !has(doc.capabilities, need));
-  if (missing !== undefined) return `この言語では${CAPABILITY_NAME[missing] ?? missing}が使えないため`;
-  if (rule.requires.some((need) => need === "pos" || need === "lemma") && !hasTokens(doc)) return "アダプタが品詞を返さなかったため";
+  if (missing !== undefined) return reasonsFor(doc).noCapability(missing);
   return undefined;
 };
 
+/**
+ * 品詞は、動かす rule があるときだけ用意する（neededBy）。だから「品詞が無い」は、段階を見た後でしか言えない。
+ * 先に聞くと、止めている rule まで「アダプタが品詞を返さなかった」と、違う理由で出る。
+ */
+const untagged = (rule: RuleDefinition, doc: ProseDocument): string | undefined =>
+  rule.requires.some((need) => need === "pos" || need === "lemma") && !hasTokens(doc) ? reasonsFor(doc).noTags : undefined;
+
 const forGenre = (rules: readonly RuleDefinition[], genre: string): RuleDefinition[] =>
   rules.filter((rule) => rule.use_for.some((target) => genre.startsWith(target)));
 
@@ -92,7 +100,19 @@ const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: num
   ];
 };
 
-export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string): RunResult => {
+/** chaff.yaml の rules に数値で書いた上限。段階の表より先に効く。 */
+export type Limits = Readonly<Record<string, number>>;
+
+const limitFor = (rule: RuleDefinition, level: Level, genre: string, limits: Limits): number => limits[rule.id] ?? resolve(rule, level, genre).limit;
+
+export const runRules = (
+  doc: ProseDocument,
+  rules: readonly RuleDefinition[],
+  settings: Settings,
+  experimental: boolean,
+  genre: string,
+  limits: Limits = {},
+): RunResult => {
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
   const forced = applicable
@@ -102,32 +122,35 @@ export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], s
     (acc, rule) => {
       // L4 は意味を読む検査。chaff test が扱う。ここで「検出器が無い」と言わせない。
       if (rule.layer === "L4") {
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: "意味を読む検査のため（npx chaff test で動きます）" }] };
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).semantic }] };
       }
       const blocked = unmet(rule, doc);
       if (blocked !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: blocked }] };
       const level = levelFor(rule, settings, experimental);
       if (level === "off") {
-        const why = rule.status === "experimental" && settings[rule.id] === undefined ? "まだ試験中のため" : "設定で止めているため";
+        const why = rule.status === "experimental" && settings[rule.id] === undefined ? reasonsFor(doc).experimental : reasonsFor(doc).turnedOff;
         return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why }] };
       }
+      const noTags = untagged(rule, doc);
+      if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
       // 段階を見た後で聞く。doc.structure は触れたときに木を作るので、止めている rule のために作らない。
       if (rule.requires.includes("structure") && doc.structure === undefined) {
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: `${doc.language} のパッケージは文書の構造を読めないため` }] };
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noStructure(doc.language) }] };
       }
       // 複合シグナルは二段目で扱う。一段目では「検出器が無い」と言わせない。
       if (rule.from.length > 0) return acc;
       const detector = DETECTORS[rule.how_to_find];
-      if (detector === undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: `検出器 ${rule.how_to_find} がないため` }] };
+      if (detector === undefined)
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noDetector(rule.how_to_find) }] };
       const options = {
-        limit: resolve(rule, level, genre).limit,
+        limit: limitFor(rule, level, genre, limits),
         lexicon: rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list],
         where: rule.where,
       };
       // 語彙表を要求する rule で、その言語に語彙表が無ければ動かせない。黙って通さない。
       if (rule.word_list !== undefined && options.lexicon === undefined) {
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: `${doc.language} の語彙表 ${rule.word_list} が無いため` }] };
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noLexicon(doc.language, rule.word_list) }] };
       }
       const found = detector(doc, options).map((finding) => place(starts, { ...finding, rule: rule.id, severity: rule.severity }));
       return { findings: [...acc.findings, ...found], skipped: acc.skipped };
@@ -136,7 +159,7 @@ export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], s
   );
   const composites = applicable
     .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental) !== "off")
-    .flatMap((rule) => compositeOf(rule, outcome.findings, resolve(rule, levelFor(rule, settings, experimental), genre).limit, starts));
+    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts));
   const all = [...outcome.findings, ...composites];
   return { ...outcome, findings: [...all].sort((left, right) => left.line - right.line), forcedExperimental: forced };
 };

package/src/structure/build.ts

@@ -1,4 +1,5 @@
 import type { Heading } from "../document.ts";
+import { atxHeadingText, headingText } from "../heading-text.ts";
 import { maskSpans } from "../mask.ts";
 import type { Mention, NumberedLine, NumberingContext, Span, StructureKind, StructureNode, StructurePatterns } from "../plugin.ts";
 import { lineNumberAt, linesOf, type Line } from "./lines.ts";
@@ -14,6 +15,8 @@ type Draft = {
   readonly attrs: Readonly<Record<string, string | number>>;
   readonly children: Draft[];
   readonly ordinal?: number | undefined;
+  readonly level?: number | undefined;
+  readonly ordinalTo?: number | undefined;
 };
 
 /** 開いている節点。rank の大きいものほど内側。 */
@@ -87,7 +90,12 @@ const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingD
   const rank = headingDepth ?? NUMBERED_RANK + numbered.depth;
   // 番地は、自分と同じか内側を閉じてから決める。閉じる前だと、同じ深さの前の条を親と取り違える。
   while (state.stack.length > 1 && top(state).rank >= rank) state.stack.pop();
-  const draft = { ...draftOf(numbered.kind, addressOf(state, numbered), line, attrs), ordinal: numbered.ordinal };
+  const draft = {
+    ...draftOf(numbered.kind, addressOf(state, numbered), line, attrs),
+    ordinal: numbered.ordinal,
+    level: numbered.depth,
+    ordinalTo: numbered.ordinalTo,
+  };
   open(state, { draft, rank, numbered });
 };
 
@@ -135,6 +143,8 @@ const freeze = (draft: Draft): StructureNode => ({
   attrs: draft.attrs,
   children: draft.children.map(freeze),
   ...(draft.ordinal === undefined ? {} : { ordinal: draft.ordinal }),
+  ...(draft.level === undefined ? {} : { level: draft.level }),
+  ...(draft.ordinalTo === undefined ? {} : { ordinalTo: draft.ordinalTo }),
 });
 
 /** Markdown から取った手がかり。見出しと、中を読まない範囲（コード）。.txt はどちらも空。 */
@@ -155,18 +165,18 @@ const headingsByLine = (lines: readonly Line[], headings: readonly Heading[]): M
     }),
   );
 
-/** 見出しの行から「#」の印を外した文字列。コードを覆った後の行から取るので、見出しの中のコードも読まない。 */
-const atxText = (text: string): string => {
-  const body = text
-    .trim()
-    .replace(/^#{1,6}(?=[ \t]|$)/u, "")
-    .trim();
-  const closing = body.search(/[ \t]#+$/u);
-  return (closing === -1 ? body : body.slice(0, closing)).trim();
+/**
+ * 見出しの行から見出しの言葉を取る。コードを覆った後の行から取るので、見出しの中のコードも読まない。
+ * ATX（行頭が #）なら印と閉じの # を外す。setext（下線で書く見出し）の末尾の # は言葉なので残す。
+ */
+const headingLineText = (text: string): string => {
+  const line = text.trim();
+  if (!line.startsWith("#")) return headingText(line);
+  return atxHeadingText(line.replace(/^#{1,6}(?=[ \t]|$)/u, "").trim());
 };
 
 const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined): void => {
-  const text = heading === undefined ? line.text : atxText(line.text);
+  const text = heading === undefined ? line.text : headingLineText(line.text);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
   const numbered = patterns.numbered(text, context) ?? universalNumber(patterns, text, context);

package/src/structure/cite.ts

@@ -100,7 +100,9 @@ export const checkCitations = (source: string, tree: StructureNode, citations: r
   const whole = normalize(source);
   const starts = lineStarts(source);
   return citations.map((citation): CitationResult => {
-    const candidates = byAddress.get(citation.address) ?? [];
+    // 第 1 項に番号の無い書き方では、「12.1」は第12条そのもの。参照の fallback と同じに読む。
+    const firstParagraph = citation.address.endsWith(".1") ? byAddress.get(citation.address.slice(0, -2)) : undefined;
+    const candidates = byAddress.get(citation.address) ?? firstParagraph ?? [];
     const first = candidates[0];
     if (first === undefined) return { citation, status: "missing-address" };
     const key = normalize(citation.quote).text;

package/src/structure/issues.ts

@@ -34,30 +34,49 @@ const resolves = (node: StructureNode, addresses: ReadonlySet<string>): boolean
 
 /**
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
- * 番号付きのまとまりを 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
+ * 条を 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
  */
 export const danglingReferences = (tree: StructureNode): StructureIssue[] => {
   const nodes = inDocumentOrder(tree);
+  // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
+  if (!nodes.some((node) => node.kind === "article")) return [];
   const addresses = new Set(nodes.filter((node) => NUMBERED.includes(node.kind)).map((node) => node.address));
-  if (addresses.size === 0) return [];
   return nodes
     .filter((node) => node.kind === "reference" && node.attrs["document"] === undefined)
     .filter((node) => !resolves(node, addresses))
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 
-/** 同じ語の二度目以降の定義。どちらが正しいかは決めず、両方の場所を示す。 */
+type Definition = { readonly node: StructureNode; readonly article: string };
+
+/** 定義を文書の順に、それが置かれた条の番地と一緒に並べる。範囲を限った定義は、その条の中でだけ比べるため。 */
+const definitionsInOrder = (tree: StructureNode): Definition[] => {
+  const found: Definition[] = [];
+  const pending: Definition[] = [{ node: tree, article: "" }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current === undefined) break;
+    if (current.node.kind === "definition") found.push(current);
+    const article = current.node.kind === "article" ? current.node.address : current.article;
+    [...current.node.children].reverse().forEach((child) => pending.push({ node: child, article }));
+  }
+  return found;
+};
+
+/**
+ * 同じ語の二度目以降の定義。どちらが正しいかは決めず、両方の場所を示す。
+ * 範囲を限った定義（この条において「X」とは）は、同じ条の中でだけ比べる。別の条で定義し直すのは正しい書き方。
+ */
 export const duplicateDefinitions = (tree: StructureNode): StructureIssue[] => {
   const first = new Map<string, StructureNode>();
-  return inDocumentOrder(tree)
-    .filter((node) => node.kind === "definition")
-    .flatMap((node) => {
-      const term = textOf(node, "term");
-      const earlier = first.get(term);
-      if (earlier === undefined) {
-        first.set(term, node);
-        return [];
-      }
-      return [{ offset: node.span.start, values: { term, first: earlier.line } }];
-    });
+  return definitionsInOrder(tree).flatMap(({ node, article }) => {
+    const term = textOf(node, "term");
+    const key = node.attrs["scope"] === "local" ? `${article}\u0000${term}` : term;
+    const earlier = first.get(key);
+    if (earlier === undefined) {
+      first.set(key, node);
+      return [];
+    }
+    return [{ offset: node.span.start, values: { term, first: earlier.line } }];
+  });
 };

package/src/structure/numbering.ts

@@ -3,17 +3,21 @@ import { inDocumentOrder, type StructureIssue } from "./issues.ts";
 
 const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? node.address);
 
-type Ordered = { readonly node: StructureNode; readonly ordinal: number };
+type Ordered = { readonly node: StructureNode; readonly ordinal: number; readonly last: number };
 
-/** 同じ親の子のうち、番号の付いたものを種類ごとに分ける。条と項は別の並び。 */
+/**
+ * 同じ親の子のうち、番号の付いたものを種類と深さごとに分ける。条と項は別の並び、項と号も別の並び。
+ * 法令の第 1 項は番号が無いので、その号（一、二）と第 2 項（２）は同じ条の直下に並ぶ。深さで分けないと「二の次が２」に見える。
+ */
 const sequencesOf = (parent: StructureNode): Ordered[][] => {
   const groups = new Map<string, Ordered[]>();
   parent.children.forEach((node) => {
     if (node.ordinal === undefined) return;
+    const key = `${node.kind}/${String(node.level ?? "")}`;
     // 配列を作り直さずに足す。条が何千もある法令で二乗にしない。
-    const group = groups.get(node.kind) ?? [];
-    group.push({ node, ordinal: node.ordinal });
-    groups.set(node.kind, group);
+    const group = groups.get(key) ?? [];
+    group.push({ node, ordinal: node.ordinal, last: node.ordinalTo ?? node.ordinal });
+    groups.set(key, group);
   });
   return [...groups.values()];
 };
@@ -23,11 +27,12 @@ const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
   sequence.flatMap((current, index) => {
     const previous = sequence[index - 1];
     // 1 に戻ったら新しい並び。一つの条に (a)(b) の箇条書きが二つある、附則が第1条から振り直す、のどちらも誤りではない。
-    if (previous === undefined || current.ordinal === previous.ordinal + 1 || current.ordinal === 1) return [];
+    // 範囲をまとめた行（第四十三条から第五十五条まで）の次は、範囲の最後から数える。
+    if (previous === undefined || current.ordinal === previous.last + 1 || current.ordinal === 1) return [];
     return [
       {
         offset: current.node.span.start,
-        values: { previous: labelOf(previous.node), label: labelOf(current.node), expected: previous.ordinal + 1, found: current.ordinal },
+        values: { previous: labelOf(previous.node), label: labelOf(current.node), expected: previous.last + 1, found: current.ordinal },
       },
     ];
   });

package/src/ui.ts

@@ -0,0 +1,23 @@
+/**
+ * The language chaff speaks in. Japanese for Japanese, English for everything else: English is the language a
+ * reader of any other language is likeliest to read, and every message has an English text.
+ */
+export type UiLanguage = "ja" | "en";
+
+export const uiLanguageOf = (language: string | undefined): UiLanguage => (language === "ja" ? "ja" : "en");
+
+/** Locale variables in the order POSIX gives them precedence. */
+const LOCALE_VARIABLES: readonly string[] = ["LC_ALL", "LC_MESSAGES", "LANG"];
+
+/**
+ * The language for output that is not about one document (--help, genres, init, explain, relax, warnings):
+ * the language `chaff.yaml` sets, else the terminal's locale, else English. Pure: `env` is passed in.
+ */
+export const hostLanguage = (configLanguage: string | undefined, env: Readonly<Record<string, string | undefined>>): UiLanguage => {
+  if (configLanguage !== undefined) return uiLanguageOf(configLanguage);
+  const locale = LOCALE_VARIABLES.map((name) => env[name]).find((value) => value !== undefined && value !== "");
+  return locale !== undefined && locale.toLowerCase().startsWith("ja") ? "ja" : "en";
+};
+
+/** Text in both languages. Each module keeps its own, next to where it is used. */
+export type Texts<T> = Readonly<Record<UiLanguage, T>>;

package/src/watch.ts

@@ -15,7 +15,7 @@ const total = (snapshot: Snapshot): number => Object.values(snapshot).reduce((su
  * 差分だけを出す。書いている最中に全件を出し直されると、何が変わったのか分からない。
  * workflow spec §11。
  */
-export const describeChange = (before: Snapshot, after: Snapshot): string | undefined => {
+export const describeChange = (before: Snapshot, after: Snapshot, unit = " 件"): string | undefined => {
   const rules = [...new Set([...Object.keys(before), ...Object.keys(after)])];
   const moved = rules
     .map((rule) => ({ rule, delta: (after[rule] ?? 0) - (before[rule] ?? 0) }))
@@ -24,7 +24,7 @@ export const describeChange = (before: Snapshot, after: Snapshot): string | unde
   if (moved.length === 0) return undefined;
   const detail = moved.map((entry) => `${entry.delta > 0 ? "+" : ""}${entry.delta} ${entry.rule}`).join(", ");
   const mark = total(after) < total(before) ? "✓" : "✗";
-  return `${mark} ${total(before)} → ${total(after)} 件   (${detail})`;
+  return `${mark} ${total(before)} → ${total(after)}${unit}   (${detail})`;
 };
 
 export const clock = (): string => new Date().toTimeString().slice(0, 8);