chaffjs 0.14.0 → 0.16.0

package/src/render/friendly.ts

@@ -2,6 +2,7 @@ import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { MARK, localized, messageOf } from "./text.ts";
 import { tally } from "./summary.ts";
+import { counted } from "./plural.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
 
 const RULE = 60;
@@ -13,6 +14,7 @@ const TEXT: Texts<{
   readonly deterministic: string;
   readonly untouched: string;
   readonly forced: (n: number, ids: string) => string;
+  readonly presetOn: (n: number, ids: string) => string;
   readonly notRun: (n: number) => string;
   readonly because: (why: string) => string;
 }> = {
@@ -23,6 +25,7 @@ const TEXT: Texts<{
     deterministic: "              （同じ文章なら何度実行しても同じ結果になります）",
     untouched: "文章は書き換えていません。直すのは書いた人です。",
     forced: (n, ids) => `試験中の rule を ${n} 件、設定により有効にしています: ${ids}`,
+    presetOn: (n, ids) => `試験中の rule を ${n} 件、ジャンルの既定で有効にしています: ${ids}`,
     notRun: (n) => `${n} 件の rule は動いていません:`,
     because: (why) => `（${why}）`,
   },
@@ -32,8 +35,9 @@ const TEXT: Texts<{
     machine: "All judged by machine",
     deterministic: "              (the same text gives the same result every time)",
     untouched: "The text was not changed. Fixing it is the writer's job.",
-    forced: (n, ids) => `${n} experimental rule${n === 1 ? "" : "s"} turned on in the settings: ${ids}`,
-    notRun: (n) => `${n} rule${n === 1 ? "" : "s"} did not run:`,
+    forced: (n, ids) => `${counted(n, "experimental rule")} turned on in the settings: ${ids}`,
+    presetOn: (n, ids) => `${counted(n, "experimental rule")} turned on by the genre: ${ids}`,
+    notRun: (n) => `${counted(n, "rule")} did not run:`,
     because: (why) => ` (${why})`,
   },
 };
@@ -69,14 +73,21 @@ const block = (finding: Finding, rule: RuleDefinition, language: string): string
   "",
 ];
 
-export const renderFriendly = (header: string, result: RunResult, rules: readonly RuleDefinition[], language: string): string => {
+/** notes: lines after the not-run list (the genre chaff suggests when none is set). */
+export const renderFriendly = (
+  header: string,
+  result: RunResult,
+  rules: readonly RuleDefinition[],
+  language: string,
+  notes: readonly string[] = [],
+): string => {
   const byId = new Map(rules.map((rule) => [rule.id, rule]));
   const blocks = result.findings.flatMap((finding) => {
     const rule = byId.get(finding.rule);
     return rule === undefined ? [] : block(finding, rule, language);
   });
   const text = TEXT[uiLanguageOf(language)];
-  const notes = [
+  const closing = [
     "",
     "─".repeat(RULE),
     "",
@@ -85,10 +96,14 @@ export const renderFriendly = (header: string, result: RunResult, rules: readonl
     "",
     `  ${text.untouched}`,
   ];
-  const forced = result.forcedExperimental.length > 0 ? ["", `  ${text.forced(result.forcedExperimental.length, result.forcedExperimental.join(", "))}`] : [];
+  const forced = [
+    ...(result.forcedExperimental.length > 0 ? ["", `  ${text.forced(result.forcedExperimental.length, result.forcedExperimental.join(", "))}`] : []),
+    ...(result.presetExperimental.length > 0 ? ["", `  ${text.presetOn(result.presetExperimental.length, result.presetExperimental.join(", "))}`] : []),
+  ];
   const skipped =
     result.skipped.length > 0
       ? ["", `  ${text.notRun(result.skipped.length)}`, ...result.skipped.map((entry) => `      ${entry.rule}${text.because(entry.why)}`)]
       : [];
-  return ["", header, ...blocks, ...notes, ...forced, ...skipped, ""].join("\n");
+  const after = notes.flatMap((note) => ["", note]);
+  return ["", header, ...blocks, ...closing, ...forced, ...skipped, ...after, ""].join("\n");
 };

package/src/render/genres.ts

@@ -0,0 +1,31 @@
+import type { GenreData } from "../genre-parse.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{ readonly heading: string; readonly usage: readonly string[] }> = {
+  ja: {
+    heading: "  ジャンル（文書の種類）を選ぶと、その種類の書き方に合わせて見ます:",
+    usage: [
+      "  この実行だけ:    npx chaffjs --genre legal/contract 契約書.md",
+      "  この場所に決める: npx chaffjs init --genre legal/contract   （chaff.yaml の genre に書きます）",
+    ],
+  },
+  en: {
+    heading: "  Pick the genre (the kind of document) and chaff checks it the way that kind is written:",
+    usage: [
+      "  For one run:       npx chaffjs --genre legal/contract contract.md",
+      "  For this folder:   npx chaffjs init --genre legal/contract   (writes genre in chaff.yaml)",
+    ],
+  },
+};
+
+/** `chaff genres`: every genre under its group, with what it is for, in the output language. */
+export const renderGenres = (data: GenreData, ui: UiLanguage): string => {
+  const width = Math.max(...data.genres.map((genre) => genre.id.length)) + 2;
+  const groups = data.groups.flatMap((group) => {
+    const members = data.genres.filter((genre) => genre.id.startsWith(`${group.id}/`));
+    return members.length === 0
+      ? []
+      : ["", `  ${group.name[ui] ?? group.id}`, ...members.map((genre) => `    ${genre.id.padEnd(width)}${genre.summary[ui] ?? ""}`)];
+  });
+  return ["", TEXT[ui].heading, ...groups, "", ...TEXT[ui].usage, ""].join("\n");
+};

package/src/render/plural.ts

@@ -0,0 +1,6 @@
+/** English agreement: only exactly one takes the singular ("0 findings", "1 finding", "1.5 findings"). */
+const isOne = (count: number | string): boolean => String(count) === "1";
+
+export const formFor = (count: number | string, singular: string, plural: string): string => (isOne(count) ? singular : plural);
+
+export const counted = (count: number, singular: string, plural = `${singular}s`): string => `${String(count)} ${formFor(count, singular, plural)}`;

package/src/render/rules-json.ts

@@ -2,9 +2,12 @@ import { definedLevels, resolve } from "../levels.ts";
 import type { Config } from "../config/load.ts";
 import type { RuleDefinition } from "../plugin.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
+import { presetLevels } from "../genre-load.ts";
+import type { PresetLevels } from "../genre-parse.ts";
 
 const TEXT: Texts<{
   readonly offBySetting: string;
+  readonly offByGenre: (genre: string) => string;
   readonly offExperimental: string;
   readonly valuesNote: string;
   readonly reason: string;
@@ -12,6 +15,7 @@ const TEXT: Texts<{
 }> = {
   ja: {
     offBySetting: "設定で止めている",
+    offByGenre: (genre) => `ジャンル ${genre} では見ない`,
     offExperimental: "experimental な rule は既定で動かさない",
     valuesNote: "この 4 語のかわりに数字を直接書いてもよい。4 語のほうを勧める。",
     reason: "<理由>",
@@ -19,6 +23,7 @@ const TEXT: Texts<{
   },
   en: {
     offBySetting: "turned off in the settings",
+    offByGenre: (genre) => `the ${genre} genre does not check it`,
     offExperimental: "experimental rules do not run by default",
     valuesNote: "A number may be written instead of these four words. The words are recommended.",
     reason: "<reason>",
@@ -26,8 +31,9 @@ const TEXT: Texts<{
   },
 };
 
-const now = (rule: RuleDefinition, config: Config, genre: string, text: (typeof TEXT)["ja"]): Record<string, unknown> => {
-  const explicit = config.rules[rule.id];
+const now = (rule: RuleDefinition, config: Config, genre: string, text: (typeof TEXT)["ja"], preset: PresetLevels): Record<string, unknown> => {
+  const explicit = config.rules[rule.id] ?? preset[rule.id];
+  if (explicit === "off" && config.rules[rule.id] === undefined) return { level: "off", why_off: text.offByGenre(genre) };
   if (explicit === "off") return { level: "off", why_off: text.offBySetting };
   const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
   if (limit !== undefined) return { level: "normal", limit, set_as: "number" };
@@ -59,6 +65,7 @@ const levelsOf = (rule: RuleDefinition, genre: string): Record<string, unknown>
 /** AI に設定を書かせるときの入口。推測せずに書けるだけの情報を 1 つに入れる。spec §19.3。 */
 export const rulesJson = (rules: readonly RuleDefinition[], config: Config, language: string, genre: string): string => {
   const text = TEXT[uiLanguageOf(language)];
+  const preset = presetLevels(genre);
   return JSON.stringify(
     {
       schema_version: 1,
@@ -77,7 +84,7 @@ export const rulesJson = (rules: readonly RuleDefinition[], config: Config, lang
         ...levelsOf(rule, genre),
         levels_you_can_set: definedLevels(rule),
         your_setting: yourSetting(rule, config),
-        now: now(rule, config, genre, text),
+        now: now(rule, config, genre, text, preset),
       })),
       how_to_change: {
         by_command: ["relax", "strict", "off"].map((command) => `npx chaff ${command} <rule-id> --why "${text.reason}"`),

package/src/render/semantic.ts

@@ -1,35 +1,113 @@
 import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { UserCheck } from "../checks.ts";
+import type { Narrowing } from "../look-at.ts";
 import type { Job as Plan, SemanticResult } from "../run-semantic.ts";
+import { uiLanguageOf, type Texts, type UiLanguage } from "../ui.ts";
 import { MARK, localized } from "./text.ts";
+import { counted, formFor } from "./plural.ts";
 
 const RULE = 60;
 
+const TEXT: Texts<{
+  readonly machineBanner: readonly string[];
+  readonly aiTitle: string;
+  readonly aiNote: readonly string[];
+  readonly read: (asked: number, seen: number) => string;
+  readonly wholeRead: (name: string) => readonly string[];
+  readonly word: (word: string) => string;
+  readonly number: string;
+  readonly narrowedRead: (name: string, what: string, kept: number, total: number) => string;
+  readonly line: (line: number) => string;
+  readonly confidence: (value: string) => string;
+  readonly disagree: readonly string[];
+  readonly silence: (rule: string) => string;
+  readonly relax: (rule: string) => string;
+  readonly notRunChecks: (count: number) => string;
+  readonly byMachine: string;
+  readonly whole: string;
+  readonly containing: (parts: string) => string;
+  readonly planLine: (count: number, name: string, how: string) => string;
+  readonly firstSample: string;
+  readonly planHead: (path: string, sentences: number, asked: number) => string;
+}> = {
+  ja: {
+    machineBanner: ["", `═══ 機械による判定 ${"═".repeat(RULE - 18)}`, "    同じ文章なら何度実行しても同じ結果になります", ""],
+    aiTitle: `═══ AI による判定 ${"═".repeat(RULE - 17)}`,
+    aiNote: ["    文章の意味を読んでいます。実行するたび結果が変わることが", "    あります。おかしいと思ったら、そのまま無視して構いません。"],
+    read: (asked, seen) => `    ${seen} 文のうち ${asked} 箇所を読みました（残りは機械が対象外と判断）`,
+    wholeRead: (name) => [`    ${name}: 見るところを絞れず、全文を読みました`, `      look_at に「」で語を書くと、その語を含む文だけになります`],
+    word: (word) => `「${word}」`,
+    number: "数字",
+    narrowedRead: (name, what, kept, total) => `    ${name}: ${what} を含む ${kept} 文だけを読みました（全 ${total} 文）`,
+    line: (line) => `${line} 行目`,
+    confidence: (value) => `確からしさ ${value}`,
+    disagree: ["     この指摘が違うと思ったら:"],
+    silence: (rule) => `       この箇所だけ黙らせる    <!-- stet: ${rule} — 理由 -->`,
+    relax: (rule) => `       ルールごとゆるめる      npx chaff relax ${rule}`,
+    notRunChecks: (count) => `  ${count} 件の検査は、見るところが無いため動いていません。`,
+    byMachine: "機械で絞り込み済み",
+    whole: "絞り込めず全文",
+    containing: (parts) => `${parts} を含む文`,
+    planLine: (count, name, how) => `    ${String(count).padStart(3)} 箇所  ${name}  （${how}）`,
+    firstSample: "  最初の 1 件に送る文章:",
+    planHead: (path, sentences, asked) => `${path}   全 ${sentences} 文のうち ${asked} 箇所を送ります（API は呼んでいません）`,
+  },
+  en: {
+    machineBanner: ["", `═══ Judged by machine ${"═".repeat(RULE - 21)}`, "    The same text gives the same result every time", ""],
+    aiTitle: `═══ Judged by AI ${"═".repeat(RULE - 16)}`,
+    aiNote: ["    These read the meaning of the text. The result can change", "    from run to run. If one looks wrong, feel free to ignore it."],
+    read: (asked, seen) => `    Read ${counted(asked, "passage")} out of ${counted(seen, "sentence")} (the machine ruled out the rest)`,
+    wholeRead: (name) => [
+      `    ${name}: could not narrow what to read, so read the whole text`,
+      `      Put words in quotes in look_at ("like this") to read only the sentences that contain them`,
+    ],
+    word: (word) => `"${word}"`,
+    number: "a number",
+    narrowedRead: (name, what, kept, total) => `    ${name}: read only the ${counted(kept, "sentence")} containing ${what} (of ${total})`,
+    line: (line) => `line ${line}`,
+    confidence: (value) => `confidence ${value}`,
+    disagree: ["     If you think this finding is wrong:"],
+    silence: (rule) => `       Silence this spot only    <!-- stet: ${rule} — reason -->`,
+    relax: (rule) => `       Relax the whole rule      npx chaff relax ${rule}`,
+    notRunChecks: (count) => `  ${counted(count, "check")} did not run: there was nothing for ${formFor(count, "it", "them")} to look at.`,
+    byMachine: "narrowed by machine",
+    whole: "not narrowed: the whole text",
+    containing: (parts) => `sentences containing ${parts}`,
+    planLine: (count, name, how) => `    ${String(count).padStart(3)} to send  ${name}  (${how})`,
+    firstSample: "  The text sent for the first one:",
+    planHead: (path, sentences, asked) => `${path}   sends ${counted(asked, "passage")} out of ${counted(sentences, "sentence")} (the API was not called)`,
+  },
+};
+
 const indent = (text: string, pad: string): string[] => text.split("\n").map((line) => `${pad}${line}`);
 
-export const MACHINE_BANNER = ["", `═══ 機械による判定 ${"═".repeat(RULE - 18)}`, "    同じ文章なら何度実行しても同じ結果になります", ""];
+/** The banner over a file's machine findings, in the file's language. */
+export const machineBanner = (language: string): readonly string[] => TEXT[uiLanguageOf(language)].machineBanner;
+
+/** The words a narrowing looks for, as the screen names them. */
+const lookedFor = (narrowing: Narrowing, language: UiLanguage): string[] => {
+  const text = TEXT[language];
+  return [...narrowing.words.map((word) => text.word(word)), ...(narrowing.needsNumber ? [text.number] : [])];
+};
 
 /**
  * 自分の書いた検査が、どこまで絞り込めたかを見せる。
  * 絞り込めないまま全文を読んでいることに気づけないと、遅さの原因が分からない。
  */
-const narrowingLines = (result: SemanticResult): string[] =>
+const narrowingLines = (result: SemanticResult, language: UiLanguage): string[] =>
   result.narrowed.flatMap(({ name, narrowing }) => {
-    if (narrowing.words.length === 0 && !narrowing.needsNumber) {
-      return [`    ${name}: 見るところを絞れず、全文を読みました`, `      look_at に「」で語を書くと、その語を含む文だけになります`];
-    }
-    const what = [...narrowing.words.map((word) => `「${word}」`), ...(narrowing.needsNumber ? ["数字"] : [])].join(" ");
-    return [`    ${name}: ${what} を含む ${narrowing.kept} 文だけを読みました（全 ${narrowing.total} 文）`];
+    if (narrowing.words.length === 0 && !narrowing.needsNumber) return [...TEXT[language].wholeRead(name)];
+    const what = lookedFor(narrowing, language).join(language === "ja" ? " " : ", ");
+    return [TEXT[language].narrowedRead(name, what, narrowing.kept, narrowing.total)];
   });
 
-const aiBanner = (result: SemanticResult): string[] => [
+const aiBanner = (result: SemanticResult, language: UiLanguage): string[] => [
   "",
-  `═══ AI による判定 ${"═".repeat(RULE - 17)}`,
-  "    文章の意味を読んでいます。実行するたび結果が変わることが",
-  "    あります。おかしいと思ったら、そのまま無視して構いません。",
+  TEXT[language].aiTitle,
+  ...TEXT[language].aiNote,
   "",
-  `    ${result.sentencesSeen} 文のうち ${result.asked} 箇所を読みました（残りは機械が対象外と判断）`,
-  ...narrowingLines(result),
+  TEXT[language].read(result.asked, result.sentencesSeen),
+  ...narrowingLines(result, language),
   "",
 ];
 
@@ -46,32 +124,37 @@ const nameOf = (rule: string, rules: readonly RuleDefinition[], checks: readonly
  * AI の指摘にだけ確からしさを出し、納得できないときの逃げ道を 2 つ添える。
  * 揺れる判定だと読む人が知らないと、誤検知に振り回される。
  */
-const block = (finding: Finding, named: Named): string[] => {
+const block = (finding: Finding, named: Named, language: UiLanguage): string[] => {
+  const text = TEXT[language];
   const confidence = finding.values["confidence"];
   const reason = String(finding.values["reason"] ?? "");
-  const sure = confidence === undefined ? "" : `            確からしさ ${String(confidence)}`;
+  const sure = confidence === undefined ? "" : `            ${text.confidence(String(confidence))}`;
   const fix = named.howToFix.length > 0 ? ["", ...indent(`→ ${named.howToFix}`, "     ")] : [];
   return [
     "",
-    `─── ${finding.line} 行目 ${"─".repeat(Math.max(0, RULE - String(finding.line).length - 8))}`,
+    // "12 行目" and "line 12" take the same width on a terminal, so the rule ends in the same column in both.
+    `─── ${text.line(finding.line)} ${"─".repeat(Math.max(0, RULE - String(finding.line).length - 8))}`,
     "",
     `  ${MARK[finding.severity] ?? "·"}  ${named.name}${sure}`,
     "",
     ...indent(reason, "     "),
     ...fix,
     "",
-    "     この指摘が違うと思ったら:",
-    `       この箇所だけ黙らせる    <!-- stet: ${finding.rule} — 理由 -->`,
-    `       ルールごとゆるめる      npx chaff relax ${finding.rule}`,
+    ...text.disagree,
+    text.silence(finding.rule),
+    text.relax(finding.rule),
     "",
   ];
 };
 
-export const renderSemantic = (result: SemanticResult, rules: readonly RuleDefinition[], checks: readonly UserCheck[], language: string): string[] => [
-  ...aiBanner(result),
-  ...result.findings.flatMap((finding) => block(finding, nameOf(finding.rule, rules, checks, language))),
-  ...(result.skipped.length > 0 ? [`  ${result.skipped.length} 件の検査は、見るところが無いため動いていません。`, ""] : []),
-];
+export const renderSemantic = (result: SemanticResult, rules: readonly RuleDefinition[], checks: readonly UserCheck[], language: string): string[] => {
+  const ui = uiLanguageOf(language);
+  return [
+    ...aiBanner(result, ui),
+    ...result.findings.flatMap((finding) => block(finding, nameOf(finding.rule, rules, checks, language), ui)),
+    ...(result.skipped.length > 0 ? [TEXT[ui].notRunChecks(result.skipped.length), ""] : []),
+  ];
+};
 
 /**
  * 何が送られるのかを、API を呼ばずに見せる。`chaff test --dry-run`。
@@ -79,19 +162,19 @@ export const renderSemantic = (result: SemanticResult, rules: readonly RuleDefin
  * 鍵が無い環境でも二段構えの 1 段目まで確かめられる。全文が送られようとしていることに
  * 請求書で気づくのでは遅い。spec §14。
  */
-const howNarrowed = (job: Plan): string => {
+const howNarrowed = (job: Plan, language: UiLanguage): string => {
   const narrowing = job.narrowing;
-  if (narrowing === undefined) return "機械で絞り込み済み";
-  const quoted = narrowing.words.map((word) => `「${word}」`);
-  const parts = narrowing.needsNumber ? [...quoted, "数字"] : quoted;
-  if (parts.length === 0) return "絞り込めず全文";
-  return `${parts.join(" ")} を含む文`;
+  if (narrowing === undefined) return TEXT[language].byMachine;
+  const parts = lookedFor(narrowing, language);
+  if (parts.length === 0) return TEXT[language].whole;
+  return TEXT[language].containing(parts.join(language === "ja" ? " " : ", "));
 };
 
-export const renderPlan = (path: string, jobs: readonly Plan[], sentences: number): string[] => {
+export const renderPlan = (path: string, jobs: readonly Plan[], sentences: number, language: string): string[] => {
+  const text = TEXT[uiLanguageOf(language)];
   const asked = jobs.reduce((sum, job) => sum + job.candidates.length, 0);
-  const lines = jobs.map((job) => `    ${String(job.candidates.length).padStart(3)} 箇所  ${job.name}  （${howNarrowed(job)}）`);
+  const lines = jobs.map((job) => text.planLine(job.candidates.length, job.name, howNarrowed(job, uiLanguageOf(language))));
   const first = jobs.find((job) => job.candidates.length > 0);
-  const sample = first === undefined ? [] : ["", "  最初の 1 件に送る文章:", "", ...indent(String(first.candidates[0]?.text ?? "").slice(0, 300), "    ")];
-  return ["", `${path}   全 ${sentences} 文のうち ${asked} 箇所を送ります（API は呼んでいません）`, "", ...lines, ...sample, ""];
+  const sample = first === undefined ? [] : ["", text.firstSample, "", ...indent(String(first.candidates[0]?.text ?? "").slice(0, 300), "    ")];
+  return ["", text.planHead(path, sentences, asked), "", ...lines, ...sample, ""];
 };

package/src/render/summary.ts

@@ -1,5 +1,6 @@
 import type { Finding } from "../plugin.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
+import { counted } from "./plural.ts";
 
 export type FileOutcome = { readonly path: string; readonly findings: readonly Finding[]; readonly notRun: number };
 
@@ -21,9 +22,9 @@ const TEXT: Texts<{
   },
   en: {
     counts: {
-      error: (n) => `${n} error${n === 1 ? "" : "s"}`,
-      warning: (n) => `${n} warning${n === 1 ? "" : "s"}`,
-      info: (n) => `${n} note${n === 1 ? "" : "s"}`,
+      error: (n) => counted(n, "error"),
+      warning: (n) => counted(n, "warning"),
+      info: (n) => counted(n, "note"),
     },
     join: ", ",
     none: "No findings",

package/src/render/suppressions.ts

@@ -1,5 +1,6 @@
 import type { Suppressed, Suppression } from "../stet.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
+import { counted } from "./plural.ts";
 
 const TEXT: Texts<{
   readonly nudge: string;
@@ -23,7 +24,7 @@ const TEXT: Texts<{
   },
   en: {
     nudge: "  <- consider changing the setting instead",
-    more: (n) => ` and ${n} more file${n === 1 ? "" : "s"}`,
+    more: (n) => ` and ${counted(n, "more file")}`,
     count: (n) => `${String(n).padStart(3)}`,
     reasons: (list) => `reasons: ${list}`,
     relaxAll: (rule) => `relax the whole rule: npx chaff relax ${rule} --why "..."`,
@@ -53,7 +54,7 @@ const groupByRule = (files: readonly PerFile[]): Group[] => {
         reasons: [...new Set(mine.flatMap((row) => (row.reason === undefined ? [] : [row.reason])))],
       };
     })
-    .sort((left, right) => right.count - left.count);
+    .toSorted((left, right) => right.count - left.count);
 };
 
 const groupLines = (group: Group, ui: UiLanguage): string[] => {

package/src/render/text.ts

@@ -1,13 +1,28 @@
 import type { Finding, Localized, RuleDefinition } from "../plugin.ts";
+import { formFor } from "./plural.ts";
 
 export const localized = (field: Localized, language: string): string => field[language] ?? field["en"] ?? Object.values(field)[0] ?? "";
 
+/** `{count}` is the value; `{count|word|words}` is the form that agrees with it (English only; Japanese has no plural). */
+const PLACEHOLDER = /\{(\w+)(?:\|([^|{}]*)\|([^|{}]*))?\}/gu;
+
 const fill = (template: string, values: Readonly<Record<string, string | number>>): string =>
-  template.replace(/\{(\w+)\}/gu, (whole, key: string) => {
+  template.replace(PLACEHOLDER, (whole, key: string, singular: string | undefined, plural: string | undefined) => {
     const value = values[key];
-    return value === undefined ? whole : String(value);
+    if (value === undefined) return whole;
+    return singular === undefined || plural === undefined ? String(value) : formFor(value, singular, plural);
   });
 
-export const messageOf = (rule: RuleDefinition, finding: Finding, language: string): string => fill(localized(rule.message, language), finding.values);
+/** A template as the rule reference shows it: each agreeing form as its plural ("{count} such words"). */
+export const templateForReading = (template: string): string =>
+  template.replace(PLACEHOLDER, (whole, _key: string, singular: string | undefined, plural: string | undefined) =>
+    singular === undefined || plural === undefined ? whole : plural,
+  );
+
+const templateOf = (rule: RuleDefinition, finding: Finding): Localized =>
+  (finding.variant === undefined ? undefined : rule.messages[finding.variant]) ?? rule.message;
+
+export const messageOf = (rule: RuleDefinition, finding: Finding, language: string): string =>
+  fill(localized(templateOf(rule, finding), language), finding.values);
 
 export const MARK: Readonly<Record<string, string>> = { error: "✖", warning: "⚠", info: "·" };

package/src/resolve-genre.ts

@@ -0,0 +1,20 @@
+import { applyByPath } from "./config/by-path.ts";
+import type { Config } from "./config/load.ts";
+import type { GenreSource } from "./cli-text.ts";
+import { frontMatterGenre, GENRES, guessGenre } from "./genre.ts";
+import { unknownFrontMatterGenre } from "./genre-check.ts";
+
+/** unread: a genre the front matter wrote that chaff does not know, when the front matter was looked at. */
+type ResolvedGenre = { readonly genre: string; readonly from: GenreSource; readonly unread?: string | undefined };
+
+export const resolveGenre = (path: string, source: string, config: Config, cliGenre?: string): ResolvedGenre => {
+  // コマンドで指定したものが最優先。その実行だけの指定だから、設定より強い。
+  if (cliGenre !== undefined) return { genre: cliGenre, from: "--genre" };
+  // パスごとの上書きが次。「全体はこう、ここだけは違う」を書けるようにする。
+  const override = applyByPath(config.byPath, config.baseDir, path);
+  if (override.genre !== undefined) return { genre: override.genre, from: "by_path" };
+  if (config.genre !== undefined) return { genre: config.genre, from: "config" };
+  const guess = guessGenre(path, source, frontMatterGenre(source));
+  const unread = unknownFrontMatterGenre(source, GENRES);
+  return guess === undefined ? { genre: "blog/tech", from: "default", unread } : { genre: guess.genre, from: guess.from, unread };
+};

package/src/rule-load.ts

@@ -68,6 +68,10 @@ const missingFields = (raw: Record<string, unknown>, levels: LevelTable | undefi
 
 const localizedOf = (value: unknown): Record<string, string> => (isLocalized(value) ? value : {});
 
+/** 見つけ方ごとの message。読めないものは捨てる。 */
+const messagesOf = (value: unknown): Record<string, Record<string, string>> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).flatMap(([variant, text]) => (isLocalized(text) ? [[variant, text]] : []))) : {};
+
 /**
  * severity も言語別に書ける。levels と同じ畳みかた。
  * 記号の許容度は言語で大きく違う（ダッシュは英語では普通、日本語の組版では扱いが難しい）。
@@ -95,6 +99,7 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     why: localizedOf(raw["why"]),
     how_to_fix: localizedOf(raw["how_to_fix"]),
     message: localizedOf(raw["message"]),
+    messages: messagesOf(raw["messages"]),
     levels,
     by_genre: genreTables(raw["by_genre"], language),
     how_to_find: String(raw["how_to_find"]),
@@ -126,5 +131,5 @@ const parseRule = (dir: string, file: string): unknown => {
 export const loadRules = (language: string, dir: string = RULES_DIR): RuleDefinition[] =>
   readdirSync(dir)
     .filter((file) => file.endsWith(".yaml"))
-    .sort((left, right) => left.localeCompare(right, "en"))
+    .toSorted((left, right) => left.localeCompare(right, "en"))
     .map((file) => toRule(parseRule(dir, file), language, file));

package/src/run-semantic.ts

@@ -129,7 +129,7 @@ export const runSemantic = async (
     ),
   );
   return {
-    findings: answers.filter((finding) => finding !== undefined).sort((left, right) => left.line - right.line),
+    findings: answers.filter((finding) => finding !== undefined).toSorted((left, right) => left.line - right.line),
     skipped,
     asked: live.reduce((sum, job) => sum + job.candidates.length, 0),
     sentencesSeen: doc.sentences.length,

package/src/run.ts

@@ -10,6 +10,7 @@ import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { maskSpans } from "./mask.ts";
 import { textOutline } from "./page-furniture.ts";
 import { uiLanguageOf } from "./ui.ts";
+import { presetLevels } from "./genre-load.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
 
@@ -18,18 +19,29 @@ export type RunResult = {
   readonly skipped: readonly Skipped[];
   /** 設定で明示的に有効にした experimental な rule。実行ごとに一度報告する。spec §18.4。 */
   readonly forcedExperimental: readonly string[];
+  /** The experimental rules the genre's preset turns on. Reported apart from forcedExperimental: chaff.yaml did not name them. */
+  readonly presetExperimental: readonly string[];
 };
 
 export type Settings = Readonly<Record<string, Level>>;
 
-const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolean): Level => {
+const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolean, preset: Settings): Level => {
   const explicit = settings[rule.id];
   // 明示設定は status の既定に勝つ。名指しで有効にしたものを黙って無効にしない。
   if (explicit !== undefined) return explicit;
+  // ジャンルの既定は chaff.yaml より弱く、status の既定より強い。--experimental でも、ジャンルが止めたものは止めたまま。
+  const fromPreset = preset[rule.id];
+  if (fromPreset !== undefined) return fromPreset;
   if (rule.status === "experimental" && !experimental) return "off";
   return "normal";
 };
 
+/** Why a rule at off did not run: chaff.yaml turned it off, the genre's preset did, or it is experimental. */
+const offReason = (rule: RuleDefinition, settings: Settings, preset: Settings, genre: string, reasons: Reasons): string => {
+  if (settings[rule.id] !== undefined) return reasons.turnedOff;
+  return preset[rule.id] === undefined ? reasons.experimental : reasons.presetOff(genre);
+};
+
 const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.language)];
 
 /**
@@ -41,11 +53,11 @@ const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.lan
  * 読むので、番号を読めなかった文書でも動く。どちらも capability ではなく、adapter が木を作れるかで決まる。
  */
 const TREE_NEEDS: ReadonlySet<string> = new Set(["structure", "dates", "quantities"]);
-const VALUE_NEEDS: readonly string[] = ["dates", "quantities"];
+const VALUE_NEEDS: ReadonlySet<string> = new Set(["dates", "quantities"]);
 
 const treeNeed = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
   if (rule.requires.includes("structure")) return treeProblem(doc);
-  return rule.requires.some((need) => VALUE_NEEDS.includes(need)) && doc.structure === undefined ? reasonsFor(doc).noStructure(doc.language) : undefined;
+  return rule.requires.some((need) => VALUE_NEEDS.has(need)) && doc.structure === undefined ? reasonsFor(doc).noStructure(doc.language) : undefined;
 };
 
 const treeProblem = (doc: ProseDocument): string | undefined => {
@@ -106,7 +118,7 @@ const forGenre = (rules: readonly RuleDefinition[], genre: string): RuleDefiniti
  */
 export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string, language: string): AdapterNeeds => ({
   pos: forGenre(rules, genre)
-    .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental) !== "off")
+    .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental, presetLevels(genre)) !== "off")
     .filter((rule) => rule.languages === undefined || rule.languages.includes(language))
     .some((rule) => [...rule.requires, ...rule.uses].some((need) => need === "pos" || need === "lemma")),
 });
@@ -153,11 +165,12 @@ export const runRules = (
   genre: string,
   limits: Limits = {},
 ): RunResult => {
+  const preset = presetLevels(genre);
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
-  const forced = applicable
-    .filter((rule) => rule.status === "experimental" && settings[rule.id] !== undefined && settings[rule.id] !== "off")
-    .map((rule) => rule.id);
+  const experimentalOn = applicable.filter((rule) => rule.status === "experimental" && levelFor(rule, settings, experimental, preset) !== "off");
+  const forced = experimentalOn.filter((rule) => settings[rule.id] !== undefined).map((rule) => rule.id);
+  const presetOn = experimentalOn.filter((rule) => settings[rule.id] === undefined && preset[rule.id] !== undefined).map((rule) => rule.id);
   const outcome = applicable.reduce<{ findings: Finding[]; skipped: Skipped[] }>(
     (acc, rule) => {
       // L4 は意味を読む検査。chaff test が扱う。ここで「検出器が無い」と言わせない。
@@ -166,11 +179,9 @@ export const runRules = (
       }
       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 ? reasonsFor(doc).experimental : reasonsFor(doc).turnedOff;
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why }] };
-      }
+      const level = levelFor(rule, settings, experimental, preset);
+      if (level === "off")
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: offReason(rule, settings, preset, genre, reasonsFor(doc)) }] };
       const noTags = untagged(rule, doc);
       if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
@@ -197,8 +208,10 @@ export const runRules = (
     { findings: [], skipped: [] },
   );
   const composites = applicable
-    .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental) !== "off")
-    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts, doc.language));
+    .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental, preset) !== "off")
+    .flatMap((rule) =>
+      compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental, preset), genre, limits), starts, doc.language),
+    );
   const all = [...outcome.findings, ...composites];
-  return { ...outcome, findings: [...all].sort((left, right) => left.line - right.line), forcedExperimental: forced };
+  return { ...outcome, findings: all.toSorted((left, right) => left.line - right.line), forcedExperimental: forced, presetExperimental: presetOn };
 };