chaffjs 0.7.0 → 0.9.0

package/src/document.ts

@@ -7,7 +7,7 @@ import { atxHeadingText, headingText } from "./heading-text.ts";
 import { maskSpans } from "./mask.ts";
 import { buildTree, NO_OUTLINE, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
-import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode } from "./plugin.ts";
+import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
 type Node = {
@@ -253,7 +253,13 @@ export const teamRules = (config: {
   requiredSections: config.requiredSections,
 });
 
-export const buildDocument = (path: string, source: string, adapter: LanguageAdapter, team: TeamRules = EMPTY_TEAM): ProseDocument => {
+export const buildDocument = (
+  path: string,
+  source: string,
+  adapter: LanguageAdapter,
+  team: TeamRules = EMPTY_TEAM,
+  profile: DocumentProfile | undefined = undefined,
+): ProseDocument => {
   const root = parse(source);
   // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
   // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
@@ -289,9 +295,11 @@ export const buildDocument = (path: string, source: string, adapter: LanguageAda
       tree.value ??=
         patterns === undefined
           ? null
-          : buildTree({ path, source, language: adapter.id, outline: isMarkdownPath(path) ? outlineOf(root, source) : NO_OUTLINE }, patterns);
+          : buildTree({ path, source, language: adapter.id, outline: isMarkdownPath(path) ? outlineOf(root, source) : NO_OUTLINE, profile }, patterns);
       return tree.value ?? undefined;
     },
+    profile,
+    prose,
   };
 };
 

package/src/feedback/draft.ts

@@ -0,0 +1,102 @@
+import type { Texts, UiLanguage } from "../ui.ts";
+import type { Excerpt } from "./excerpt.ts";
+
+export type FeedbackKind = "false-positive" | "missed";
+
+export type ReportedFinding = { readonly rule: string; readonly line: number; readonly message: string };
+
+export type FeedbackInput = {
+  readonly kind: FeedbackKind;
+  readonly version: string;
+  readonly runtime: string;
+  readonly fileName: string;
+  readonly language: string;
+  readonly genre: string;
+  readonly findings: readonly ReportedFinding[];
+  /** The line the person reported: the finding's line, or for a miss the line they named. */
+  readonly line: number;
+  readonly excerpts: readonly Excerpt[];
+  readonly config: string | undefined;
+};
+
+export type FeedbackDraft = { readonly title: string; readonly body: string };
+
+const TEXT: Texts<{
+  readonly titleFalse: (rule: string, message: string) => string;
+  readonly titleMissed: (fileName: string, line: number) => string;
+  readonly what: Readonly<Record<FeedbackKind, string>>;
+  readonly environment: string;
+  readonly findings: string;
+  readonly excerpt: string;
+  readonly config: string;
+  readonly expected: string;
+  readonly expectedHint: Readonly<Record<FeedbackKind, string>>;
+  readonly lines: (from: number, to: number) => string;
+}> = {
+  ja: {
+    titleFalse: (rule, message) => `誤検出: ${rule} — ${message}`,
+    titleMissed: (fileName, line) => `見逃し: ${fileName} の ${String(line)} 行目`,
+    what: { "false-positive": "この指摘は誤りだと思います。", missed: "ここで chaff は何か言うべきだと思います。" },
+    environment: "環境",
+    findings: "指摘",
+    excerpt: "文書の該当箇所（この部分だけを載せています）",
+    config: "chaff.yaml",
+    expected: "期待すること",
+    expectedHint: {
+      "false-positive": "<!-- なぜ誤りか、本来どう読むべきかを書いてください -->",
+      missed: "<!-- 何が問題で、どの rule が言うべきだったかを書いてください -->",
+    },
+    lines: (from, to) => `${String(from)}〜${String(to)} 行目`,
+  },
+  en: {
+    titleFalse: (rule, message) => `False positive: ${rule} — ${message}`,
+    titleMissed: (fileName, line) => `Missed: ${fileName} line ${String(line)}`,
+    what: { "false-positive": "I think this finding is wrong.", missed: "I think chaff should say something here." },
+    environment: "Environment",
+    findings: "Findings",
+    excerpt: "The part of the document (only these lines are included)",
+    config: "chaff.yaml",
+    expected: "What I expected",
+    expectedHint: {
+      "false-positive": "<!-- Why it is wrong, and how the text should be read -->",
+      missed: "<!-- What is wrong in the text, and which rule should have said so -->",
+    },
+    lines: (from, to) => `lines ${String(from)}-${String(to)}`,
+  },
+};
+
+const fence = (content: string, language = ""): string => {
+  const longest = Math.max(2, ...[...content.matchAll(/`+/gu)].map((match) => match[0].length));
+  const ticks = "`".repeat(longest + 1);
+  return [`${ticks}${language}`, content, ticks].join("\n");
+};
+
+/** Pure: the issue title and body for a report. Nothing here reads files or the network. */
+export const feedbackDraft = (input: FeedbackInput, ui: UiLanguage): FeedbackDraft => {
+  const text = TEXT[ui];
+  const first = input.findings[0];
+  const title =
+    input.kind === "false-positive" && first !== undefined ? text.titleFalse(first.rule, first.message) : text.titleMissed(input.fileName, input.line);
+  const body = [
+    text.what[input.kind],
+    "",
+    `## ${text.environment}`,
+    "",
+    `- chaffjs ${input.version}`,
+    `- ${input.runtime}`,
+    `- ${input.fileName} · ${input.language} · ${input.genre}`,
+    ...(input.findings.length === 0
+      ? []
+      : ["", `## ${text.findings}`, "", ...input.findings.map((finding) => `- \`${finding.rule}\` (${String(finding.line)}): ${finding.message}`)]),
+    "",
+    `## ${text.excerpt}`,
+    ...input.excerpts.flatMap((excerpt) => ["", text.lines(excerpt.from, excerpt.to), "", fence(excerpt.lines.join("\n"))]),
+    ...(input.config === undefined ? [] : ["", `## ${text.config}`, "", fence(input.config.trimEnd(), "yaml")]),
+    "",
+    `## ${text.expected}`,
+    "",
+    text.expectedHint[input.kind],
+    "",
+  ].join("\n");
+  return { title, body };
+};

package/src/feedback/excerpt.ts

@@ -0,0 +1,23 @@
+/** Lines around a line of a document, 1-based and inclusive. Only these lines go into a report. */
+export type Excerpt = { readonly from: number; readonly to: number; readonly lines: readonly string[] };
+
+export const EXCERPT_RADIUS = 2;
+
+/** Pure: the excerpts around each line, overlapping ones merged, in document order. Lines outside the document are dropped. */
+export const excerptsAround = (source: string, lines: readonly number[], radius: number = EXCERPT_RADIUS): Excerpt[] => {
+  const all = source.split("\n");
+  const ranges = [...new Set(lines)]
+    .filter((line) => line >= 1 && line <= all.length)
+    .sort((left, right) => left - right)
+    .map((line) => ({ from: Math.max(1, line - radius), to: Math.min(all.length, line + radius) }));
+  const merged = ranges.reduce<{ from: number; to: number }[]>((acc, range) => {
+    const last = acc.at(-1);
+    if (last !== undefined && range.from <= last.to + 1) {
+      last.to = Math.max(last.to, range.to);
+      return acc;
+    }
+    acc.push({ ...range });
+    return acc;
+  }, []);
+  return merged.map(({ from, to }) => ({ from, to, lines: all.slice(from - 1, to) }));
+};

package/src/genre.ts

@@ -1,4 +1,4 @@
-export type GenreGuess = { readonly genre: string; readonly from: string };
+export type GenreGuess = { readonly genre: string; readonly from: "front-matter" | "path" | "content" };
 
 /**
  * 仕様書・README は「読ませる文章」ではなく「間違えさせない文章」。
@@ -27,11 +27,11 @@ const BY_CONTENT: readonly (readonly [RegExp, string])[] = [
 ];
 
 export const guessGenre = (path: string, source: string, front: string | undefined): GenreGuess | undefined => {
-  if (front !== undefined) return { genre: front, from: "front matter" };
+  if (front !== undefined) return { genre: front, from: "front-matter" };
   const byPath = BY_PATH.find(([pattern]) => pattern.test(path));
-  if (byPath !== undefined) return { genre: byPath[1], from: "パス" };
+  if (byPath !== undefined) return { genre: byPath[1], from: "path" };
   const byContent = BY_CONTENT.find(([pattern]) => pattern.test(source));
-  if (byContent !== undefined) return { genre: byContent[1], from: "内容" };
+  if (byContent !== undefined) return { genre: byContent[1], from: "content" };
   return undefined;
 };
 

package/src/init.ts

@@ -1,7 +1,21 @@
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import type { Texts, UiLanguage } from "./ui.ts";
 
-const CONFIG = (genre: string): string => `# chaff.yaml — このチームの文章規範
+const TEXT: Texts<{
+  readonly config: (genre: string) => string;
+  readonly created: string;
+  readonly appended: (lines: readonly string[]) => string;
+  readonly configNote: string;
+  readonly exists: string;
+  readonly createdHeading: string;
+  readonly genreChosen: (genre: string) => string;
+  readonly genreList: string;
+  readonly next: string;
+  readonly nextCheck: string;
+}> = {
+  ja: {
+    config: (genre) => `# chaff.yaml — このチームの文章規範
 #
 # ここに書くのは「既定から変えたもの」だけです。書かなければ既定で動きます。
 # このファイルを消しても chaff は動きます。
@@ -24,7 +38,53 @@ genre: ${genre}
 
 # 既定から変えたものだけを書く。
 rules:
-`;
+`,
+    created: "作成しました",
+    appended: (lines) => `${lines.join(" と ")} を追記しました`,
+    configNote: "規範の宣言。commit してください",
+    exists: "chaff.yaml は既にあります。変更していません。",
+    createdHeading: "作成しました:",
+    genreChosen: (genre) => `ジャンルは ${genre} にしました。違う場合は chaff.yaml の genre を直してください。`,
+    genreList: "  一覧: npx chaff genres",
+    next: "次:",
+    nextCheck: "  npx chaff .            この場所の Markdown を全部見る",
+  },
+  en: {
+    config: (genre) => `# chaff.yaml — this team's writing rules
+#
+# Write only what differs from the defaults; anything left out uses the default.
+# chaff still runs if this file is deleted.
+#
+# A level is one of four words. No numbers needed.
+#
+#   strict    check closely
+#   normal    the default
+#   relaxed   check loosely
+#   off       do not check
+#
+# Commands change it too, and leave the reason as a comment.
+#
+#   npx chaff relax bold-density --why "figure captions use a lot of bold"
+#   npx chaff explain bold-density        read what the rule is for
+#   npx chaff rules --json                give this to an AI that writes the settings
+
+# The kind of document kept here.
+genre: ${genre}
+
+# Only what differs from the defaults.
+rules:
+`,
+    created: "created",
+    appended: (lines) => `added ${lines.join(" and ")}`,
+    configNote: "the team's rules; commit it",
+    exists: "chaff.yaml already exists. Nothing was changed.",
+    createdHeading: "Created:",
+    genreChosen: (genre) => `The genre is ${genre}. If that is wrong, change genre in chaff.yaml.`,
+    genreList: "  List: npx chaff genres",
+    next: "Next:",
+    nextCheck: "  npx chaff .            check every Markdown file here",
+  },
+};
 
 /** 判定のキャッシュと、鍵を書くファイル。どちらも commit しない。 */
 const GITIGNORE_LINES = [".chaff-cache/", ".env*"];
@@ -38,31 +98,30 @@ const writeIfAbsent = (path: string, body: string, note: string): Written | unde
 };
 
 /** 判定のキャッシュと .env は commit しない。init が .gitignore に足す。 */
-const ensureGitignore = (dir: string): Written | undefined => {
+const ensureGitignore = (dir: string, text: (typeof TEXT)["ja"]): Written | undefined => {
   const path = join(dir, ".gitignore");
-  if (!existsSync(path)) return writeIfAbsent(path, `${GITIGNORE_LINES.join("\n")}\n`, "作成しました");
+  if (!existsSync(path)) return writeIfAbsent(path, `${GITIGNORE_LINES.join("\n")}\n`, text.created);
   const body = readFileSync(path, "utf8");
   const missing = GITIGNORE_LINES.filter((line) => !body.split("\n").includes(line));
   if (missing.length === 0) return undefined;
   appendFileSync(path, `${missing.join("\n")}\n`, "utf8");
-  return { path, note: `${missing.join(" と ")} を追記しました` };
+  return { path, note: text.appended(missing) };
 };
 
-export const runInit = (dir: string, genre: string): string[] => {
-  const made = [writeIfAbsent(join(dir, "chaff.yaml"), CONFIG(genre), "規範の宣言。commit してください"), ensureGitignore(dir)].filter(
-    (entry) => entry !== undefined,
-  );
-  if (made.length === 0) return ["chaff.yaml は既にあります。変更していません。"];
+export const runInit = (dir: string, genre: string, ui: UiLanguage = "ja"): string[] => {
+  const text = TEXT[ui];
+  const made = [writeIfAbsent(join(dir, "chaff.yaml"), text.config(genre), text.configNote), ensureGitignore(dir, text)].filter((entry) => entry !== undefined);
+  if (made.length === 0) return [text.exists];
   return [
     "",
-    "作成しました:",
+    text.createdHeading,
     ...made.map((entry) => `  ${entry.path}  ${entry.note}`),
     "",
-    `ジャンルは ${genre} にしました。違う場合は chaff.yaml の genre を直してください。`,
-    "  一覧: npx chaff genres",
+    text.genreChosen(genre),
+    text.genreList,
     "",
-    "次:",
-    "  npx chaff .            この場所の Markdown を全部見る",
+    text.next,
+    text.nextCheck,
     "",
   ];
 };

package/src/orthography.ts

@@ -80,8 +80,23 @@ const leftRunBeside = (chars: readonly string[], last: number, japanese: string
   return kind === "letter" && DIGIT.test(runStart(chars, last) ?? "") ? "after-digit" : kind;
 };
 
+/**
+ * 「第3条」「第4条第2項」の数字は番地の書き方で、空けるか詰めるかの好みではない。数えると、条番号の多い文書では
+ * 「2 か所」のような普通の書き方のほうが少数に見えてしまう。「第」のすぐ後ろの数字の並びは、両側とも数えない。
+ */
+const ORDINAL_PREFIX = "第";
+
+const isOrdinalRun = (chars: readonly string[], index: number): boolean => {
+  let first = index;
+  while (first > 0 && /[\d.]/u.test(chars[first - 1] ?? "")) first -= 1;
+  const before = chars[first - 1] === " " ? first - 2 : first - 1;
+  return chars[before] === ORDINAL_PREFIX;
+};
+
 const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
   const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
+  const numberAfterPrefix = left === ORDINAL_PREFIX && DIGIT.test((right === " " ? after : right) ?? "");
+  if (numberAfterPrefix || (DIGIT.test(left ?? "") && isOrdinalRun(chars, index))) return undefined;
   const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
   if (touching !== undefined) return { kind: touching, spaced: false };
   if (right !== " ") return undefined;

package/src/plugin.ts

@@ -93,6 +93,11 @@ export type NumberedLine = {
   readonly label: string;
   /** 番号に続く見出し。「第3条（支払）」の「支払」。本文しか無ければ空。 */
   readonly heading: string;
+  /**
+   * 番号に付いた語（"section"、"article"）。英米の文書は Section と Article を別のものとして使うので、
+   * 参照の attrs.numbering と比べて、この文書に無い種類の番号への参照（Section で組んだ法令の中の "Article 6"）を見分ける。
+   */
+  readonly numbering?: string | undefined;
   /** 番号の後ろの文字列全部。定義や参照はここから探す。 */
   readonly rest: string;
   /**
@@ -100,6 +105,8 @@ export type NumberedLine = {
    * 枝番号（第3条の2）は並びの外なので付けない。読み方を知っているのは言語パッケージだけなので、core は計算しない。
    */
   readonly ordinal?: number | undefined;
+  /** 一行で番号の範囲をまとめるとき（「第四十三条から第五十五条まで 削除」）の最後の位置。次の番号はここから数える。 */
+  readonly ordinalTo?: number | undefined;
 };
 
 /** 番号を読むときに見える周り。「(i)」がローマ数字か英字かは、開いている番号で決まる。 */
@@ -122,6 +129,16 @@ export type StructurePatterns = {
   readonly obligations: (text: string) => readonly Mention[];
   /** 数量。attrs.value に数、attrs.unit に単位。 */
   readonly quantities: (text: string) => readonly Mention[];
+  /**
+   * 「In this section—」のように、この後の定義はいま開いている条の中でだけ通じると宣言する行なら true。
+   * その条の定義に scope: "local" が付く。定義の並びが次の行から始まるので、定義の行だけを見ても分からない。
+   */
+  readonly opensDefinitionScope?: (text: string) => boolean;
+  /**
+   * 範囲が条より広いまとまり（「In this Part—」）なら、そのまとまりの深さ（NumberedLine.depth）。
+   * そのまとまりの中の定義どうしだけを比べる。無ければ、opensDefinitionScope のとおり条の中。
+   */
+  readonly definitionScopeDepth?: (text: string) => number | undefined;
   /** 日付。attrs.value に "2024-04-01"・"2024-04"・"04-01"・"2024" のどれか。無い言語は日付を読まない。 */
   readonly dates?: (text: string) => readonly Mention[];
   /**
@@ -129,6 +146,8 @@ export type StructurePatterns = {
    * 数字と点だけの通し番号は core が言語を問わず読むので、それを数量と見分けられるのは言語パッケージだけ。
    */
   readonly countedAfter?: (number: string, rest: string) => boolean;
+  /** 数の書き方（「二十二」「3」）を数にする。相対の参照の「前二項」「前条第二項」が使う。 */
+  readonly number?: (text: string) => number | undefined;
 };
 
 export type StructureKind = "doc" | "section" | "chapter" | "article" | "item" | "definition" | "reference" | "obligation" | "quantity" | "date";
@@ -144,6 +163,12 @@ export type StructureNode = {
   readonly children: readonly StructureNode[];
   /** 番号付きのまとまりの、並びの中の位置（NumberedLine.ordinal）。S 式には出さない。 */
   readonly ordinal?: number;
+  /** 番号付きのまとまりの深さ（NumberedLine.depth）。項と号のように、同じ親の下で別の並びを分ける。S 式には出さない。 */
+  readonly level?: number;
+  /** 範囲をまとめた行の最後の位置（NumberedLine.ordinalTo）。S 式には出さない。 */
+  readonly ordinalTo?: number;
+  /** 番号に付いた語（NumberedLine.numbering）。S 式には出さない。 */
+  readonly numbering?: string;
 };
 
 // ───────── 文書モデルと rule ─────────
@@ -169,6 +194,65 @@ export type BulletList = { readonly span: Span; readonly items: readonly number[
  * detector に渡る唯一の入り口。core が I/O を済ませてから呼ぶ。
  * detector は純関数で、fs / network / clock に触れない。spec §6。
  */
+/**
+ * 文書の種類の知識（法令の番地の書き方など）。コードは種類を知らず、profiles/*.yaml に書いたものを読む。
+ * 言語ごとに一つに絞ったもの。正規表現は文字列のまま持ち、使う側が組み立てる。
+ */
+export type DocumentProfile = {
+  readonly id: string;
+  /** 番地の書き方。漢字の連なりにも、数量にも数えない。 */
+  readonly addresses: readonly string[];
+  /** 番地と番地のあいだ、番地の後ろに付く語。 */
+  readonly connectives: readonly string[];
+  /** 番地の並びのすぐ後ろに来てよい文字（正規表現）。無ければどこで終わってもよい。 */
+  readonly addressEnd?: string | undefined;
+  /**
+   * 条の前の行に置く見出しの形（正規表現。最初の括弧の中が見出しの言葉）。法令の「（解雇の予告）」。
+   * すぐ次の行の条が見出しを持たなければ、その条の見出しになる。
+   */
+  readonly caption?: string | undefined;
+  /** 前条・同項のように、書いた場所から番地が決まる参照の読み方。無ければ読まない。 */
+  readonly relative?: RelativeVocabulary | undefined;
+};
+
+/**
+ * 相対の参照の語彙。語の意味（一つ前・一つ後・直前に引いたもの・今いるところ）はコードが知り、どの語がそれに当たるかは種類が決める。
+ * units は単位の語から木の深さ（NumberedLine.depth）への対応。
+ */
+export type RelativeVocabulary = {
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  readonly same: readonly string[];
+  readonly current: readonly string[];
+  /** 「前各項」の「各」。一つ前だけでなく、前の全部。 */
+  readonly every: readonly string[];
+  /** 「前二項」の「二」のような、いくつ分かの数の書き方（正規表現）。数は言語パッケージの number が読む。 */
+  readonly count: string;
+  readonly units: Readonly<Record<string, number>>;
+  /** 「前条第二項」の「第」。後ろに続く番地の書き出し。 */
+  readonly suffixPrefix: string;
+  /**
+   * 最初のものに番号を振らない深さ（法令の項）。あれば「第二条第一号」は 2.1.1、「第四条第一項」は第四条そのものでもある。
+   */
+  readonly implicitFirst: number | undefined;
+  /** すぐ前に来てはいけない文字（正規表現）。「事前条件」の「前条」を参照にしない。 */
+  readonly notAfter: string | undefined;
+  /**
+   * 読み替え（「『前条』とあるのは『…』」）の括弧。中の前条・同項は読み替える先の文の言葉で、ここからは決められないので読まない。
+   * 閉じの直後に after、開きの直前に before のどれかがあるものだけ。
+   */
+  readonly substitution: { readonly open: string; readonly close: string; readonly after: readonly string[]; readonly before: readonly string[] } | undefined;
+  /** 条を書かずにこの単位で始まる番地（法令の「第一項」「第二号」）は、書いた場所を含むまとまりの中を指す。 */
+  readonly inside: readonly string[];
+  /**
+   * 並びをつなぐもの（正規表現。及び・若しくは・から・、・枝番号の「の二」）。すぐ前の参照とのあいだがこれとつなぎの語（connectives）と
+   * 閉じた括弧だけなら、条を書かない番地はその参照の続き。「第三十三条第七項若しくは第九項」の「第九項」は第三十三条の第九項。
+   */
+  readonly joiners: readonly string[];
+  /** 括弧書き（「（…）」）の開きと閉じ。並びの途中に挟まっても、並びを切らない。 */
+  readonly aside: { readonly open: string; readonly close: string } | undefined;
+};
+
 export type ProseDocument = {
   readonly path: string;
   readonly source: string;
@@ -190,6 +274,10 @@ export type ProseDocument = {
   readonly requiredSections: readonly string[];
   /** 番地の付いた木（§27）。adapter が structure を持たない言語では無い。 */
   readonly structure: StructureNode | undefined;
+  /** 文書の種類（法令など）。選ばれなければ無い。 */
+  readonly profile?: DocumentProfile | undefined;
+  /** 本文でないもの（コード・HTML・強調の印）を同じ長さの空白で覆った source。位置は source と同じ。 */
+  readonly prose?: string | undefined;
 };
 
 export type Severity = "error" | "warning" | "info";

package/src/profile/for-file.ts

@@ -0,0 +1,11 @@
+import { applyByPath } from "../config/by-path.ts";
+import type { Config } from "../config/load.ts";
+import type { DocumentProfile } from "../plugin.ts";
+import { loadProfiles } from "./load.ts";
+import { chooseProfile } from "./select.ts";
+
+type ProfileSettings = Pick<Config, "profile" | "byPath" | "baseDir">;
+
+/** 1 ファイルの文書の種類。by_path、chaff.yaml、内容の順に選ぶ。 */
+export const profileFor = (config: ProfileSettings, path: string, source: string, language: string): DocumentProfile | undefined =>
+  chooseProfile(loadProfiles(), { byPath: applyByPath(config.byPath, config.baseDir, path).profile, config: config.profile, source, language })?.profile;

package/src/profile/load.ts

@@ -0,0 +1,26 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+import { parseProfile, type ProfileDefinition } from "./parse.ts";
+
+const PROFILES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "profiles");
+
+const loaded: { value: readonly ProfileDefinition[] | undefined } = { value: undefined };
+
+/** 同梱の profiles/*.yaml。一度だけ読む。 */
+export const loadProfiles = (): readonly ProfileDefinition[] => {
+  loaded.value ??= readdirSync(PROFILES_DIR)
+    .filter((file) => file.endsWith(".yaml"))
+    .sort((left, right) => left.localeCompare(right))
+    .flatMap((file) => {
+      const path = join(PROFILES_DIR, file);
+      try {
+        const definition = parseProfile(parse(readFileSync(path, "utf8")));
+        return definition === undefined ? [] : [definition];
+      } catch (error) {
+        throw new Error(`cannot read the profile ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+      }
+    });
+  return loaded.value;
+};

package/src/profile/parse.ts

@@ -0,0 +1,106 @@
+import type { DocumentProfile, RelativeVocabulary } from "../plugin.ts";
+
+/** profiles/*.yaml を一つ読んだもの。言語ごとの中身と、内容から選ぶための形を持つ。 */
+export type ProfileDefinition = {
+  readonly id: string;
+  readonly name: Readonly<Record<string, string>>;
+  readonly detect: Readonly<Record<string, ProfileDetect>>;
+  readonly languages: Readonly<Record<string, DocumentProfile>>;
+};
+
+/** この形の行が minLines 行以上あれば、その種類の文書として読む。 */
+type ProfileDetect = { readonly line: string; readonly minLines: number };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const strings = (value: unknown): string[] => (Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string" && entry !== "") : []);
+
+const texts = (value: unknown): Record<string, string> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string")) : {};
+
+/** 空でない文字列だけ。空の正規表現は何にでも当たる。 */
+const text = (value: unknown): string | undefined => (typeof value === "string" && value !== "" ? value : undefined);
+
+const detectOf = (value: unknown): ProfileDetect | undefined => {
+  if (!isRecord(value) || typeof value["line"] !== "string") return undefined;
+  const minLines = value["min_lines"];
+  return { line: value["line"], minLines: typeof minLines === "number" && minLines > 0 ? minLines : 1 };
+};
+
+const unitsOf = (value: unknown): Record<string, number> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).filter((entry): entry is [string, number] => entry[0] !== "" && Number.isInteger(entry[1]))) : {};
+
+const asideOf = (value: unknown): RelativeVocabulary["aside"] => {
+  if (!isRecord(value)) return undefined;
+  const [open, close] = [text(value["open"]), text(value["close"])];
+  return open === undefined || close === undefined ? undefined : { open, close };
+};
+
+/** 括弧の開き・閉じと、目印が一つも無ければ読まない。 */
+const substitutionOf = (value: unknown): RelativeVocabulary["substitution"] => {
+  if (!isRecord(value)) return undefined;
+  const [open, close] = [text(value["open"]), text(value["close"])];
+  const [after, before] = [strings(value["after"]), strings(value["before"])];
+  return open === undefined || close === undefined || after.length + before.length === 0 ? undefined : { open, close, after, before };
+};
+
+/** 単位が一つも無ければ読まない。何を指すのか決められない。 */
+const relativeOf = (value: unknown): RelativeVocabulary | undefined => {
+  if (!isRecord(value)) return undefined;
+  const units = unitsOf(value["units"]);
+  if (Object.keys(units).length === 0) return undefined;
+  return {
+    before: strings(value["before"]),
+    after: strings(value["after"]),
+    same: strings(value["same"]),
+    current: strings(value["current"]),
+    every: strings(value["every"]),
+    count: text(value["count"]) ?? "(?!)",
+    units,
+    suffixPrefix: text(value["suffix_prefix"]) ?? "",
+    implicitFirst: typeof value["implicit_first"] === "string" ? units[value["implicit_first"]] : undefined,
+    notAfter: text(value["not_after"]),
+    substitution: substitutionOf(value["substitution"]),
+    inside: strings(value["inside"]).filter((unit) => units[unit] !== undefined),
+    joiners: strings(value["joiners"]),
+    aside: asideOf(value["aside"]),
+  };
+};
+
+const LANGUAGE_KEYS = new Set(["id", "name", "why", "detect"]);
+
+const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, DocumentProfile> =>
+  Object.fromEntries(
+    Object.entries(raw)
+      .filter(([key, value]) => !LANGUAGE_KEYS.has(key) && isRecord(value))
+      .map(([language, value]) => {
+        const section = isRecord(value) ? value : {};
+        const addressEnd = text(section["address_end"]);
+        const caption = text(section["caption"]);
+        const relative = relativeOf(section["relative"]);
+        return [language, { id, addresses: strings(section["addresses"]), connectives: strings(section["connectives"]), addressEnd, caption, relative }];
+      }),
+  );
+
+/** id の無いものは読まない。どの設定から選ばれたのか言えなくなるため。 */
+export const parseProfile = (raw: unknown): ProfileDefinition | undefined => {
+  if (!isRecord(raw) || typeof raw["id"] !== "string" || raw["id"] === "") return undefined;
+  const id = raw["id"];
+  const detect = isRecord(raw["detect"])
+    ? Object.fromEntries(
+        Object.entries(raw["detect"]).flatMap(([language, value]) => {
+          const found = detectOf(value);
+          return found === undefined ? [] : [[language, found] as const];
+        }),
+      )
+    : {};
+  return { id, name: texts(raw["name"]), detect, languages: languagesOf(id, raw) };
+};
+
+/** 行頭から数える。source 全体に m フラグで当てれば、行ごとに分けずに数えられる。 */
+export const detected = (definition: ProfileDefinition, source: string, language: string): boolean => {
+  const detect = definition.detect[language];
+  if (detect === undefined) return false;
+  const count = [...source.matchAll(new RegExp(detect.line, "gmu"))].length;
+  return count >= detect.minLines;
+};

package/src/profile/select.ts

@@ -0,0 +1,35 @@
+import type { DocumentProfile } from "../plugin.ts";
+import { detected, type ProfileDefinition } from "./parse.ts";
+
+/** 設定で書いた「使わない」。内容から選ぶのも止める。 */
+export const NO_PROFILE = "none";
+
+type ProfileSource = "by-path" | "config" | "content";
+
+export type ChosenProfile = { readonly profile: DocumentProfile; readonly from: ProfileSource };
+
+export type ProfileRequest = {
+  readonly byPath: string | undefined;
+  readonly config: string | undefined;
+  readonly source: string;
+  readonly language: string;
+};
+
+const named = (definitions: readonly ProfileDefinition[], id: string, language: string): DocumentProfile | undefined =>
+  definitions.find((definition) => definition.id === id)?.languages[language];
+
+/**
+ * 強いものから: by_path、chaff.yaml の profile、内容。どれかが none と書けばそこで止め、内容からも選ばない。
+ * 名前で選んだ種類にその言語の中身が無ければ選ばない。黙って別の種類にしない。
+ */
+export const chooseProfile = (definitions: readonly ProfileDefinition[], request: ProfileRequest): ChosenProfile | undefined => {
+  const written = request.byPath ?? request.config;
+  if (written === NO_PROFILE) return undefined;
+  if (written !== undefined) {
+    const profile = named(definitions, written, request.language);
+    return profile === undefined ? undefined : { profile, from: request.byPath === undefined ? "config" : "by-path" };
+  }
+  const found = definitions.find((definition) => detected(definition, request.source, request.language));
+  const profile = found?.languages[request.language];
+  return profile === undefined ? undefined : { profile, from: "content" };
+};