chaffjs 0.18.0 → 0.20.0

package/src/language-sample.ts

@@ -0,0 +1,48 @@
+import { readMarkdown, spansOfType } from "./markdown-read.ts";
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import { maskSpans } from "./mask.ts";
+import type { Span } from "./plugin.ts";
+
+/**
+ * The text the document's language is guessed from: what the writer wrote in it. Fenced code, inline code, HTML tags
+ * and comments, HTML code blocks (`<script>`, `<pre>` and the like), YAML front matter, a site generator's syntax (MDX imports, component lines) and URLs are blanked out.
+ * A technical article in Japanese can hold more Latin letters in its code than kana and kanji in its prose. The text
+ * between HTML tags is kept: a `<details>` block holds prose. Indented code is kept too: in plain text an indented
+ * paragraph is prose, and Markdown would read it as code.
+ */
+
+const FENCE = /^ {0,3}(?:```|~~~)/u;
+const URL_PATTERN = /\b[a-z][a-z\d+.-]*:\/\/[^\s<>"'`)\]]+/giu;
+const NOT_WRITTEN_IN_IT: readonly string[] = ["inlineCode", "yaml"];
+/** HTML whose content is not prose: a comment, or a block that holds code (CommonMark's raw HTML blocks, and `<code>`). */
+const NOT_PROSE_HTML = /^\s*(?:<!--|<(?:script|style|pre|textarea|code)\b)/iu;
+
+const isFenced = (source: string) => (node: MarkdownNode) => {
+  const span = spanOf(node);
+  return span !== undefined && FENCE.test(source.slice(span.start, span.end));
+};
+
+const urlSpans = (source: string): Span[] => [...source.matchAll(URL_PATTERN)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** The tags in an HTML node (`<…>`), found with indexOf so that a stray `<` costs one scan, not a backtrack. */
+const tagSpans = (source: string, node: Span): Span[] => {
+  const spans: Span[] = [];
+  let open = source.indexOf("<", node.start);
+  while (open !== -1 && open < node.end) {
+    const close = source.indexOf(">", open);
+    if (close === -1 || close >= node.end) break;
+    spans.push({ start: open, end: close + 1 });
+    open = source.indexOf("<", close + 1);
+  }
+  return spans;
+};
+
+/** A comment or a code block is blanked whole; any other HTML keeps the text between its tags. */
+const htmlSpans = (source: string, nodes: readonly Span[]): Span[] =>
+  nodes.flatMap((node) => (NOT_PROSE_HTML.test(source.slice(node.start, node.end)) ? [node] : tagSpans(source, node)));
+
+export const languageSample = (source: string): string => {
+  const { root, syntax } = readMarkdown(source);
+  const code = [...spansOfType(root, "code", isFenced(source)), ...NOT_WRITTEN_IN_IT.flatMap((type) => spansOfType(root, type))];
+  return maskSpans(source, [...code, ...htmlSpans(source, spansOfType(root, "html")), ...syntax, ...urlSpans(source)]);
+};

package/src/link-line.ts

@@ -0,0 +1,13 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 行が一つのリンクだけか。前後の空白を除いた行が、どれかのリンクの範囲とちょうど重なる。
+ * 記事の一覧のようにリンクを 1 行ずつ並べた段落では、句点が無くても行ごとに一つの項目と読まれる。
+ * line と links は source の中の位置。
+ */
+export const isLinkLine = (source: string, line: Span, links: readonly Span[]): boolean => {
+  const text = source.slice(line.start, line.end);
+  const start = line.start + text.length - text.trimStart().length;
+  const end = line.end - (text.length - text.trimEnd().length);
+  return links.some((link) => link.start === start && link.end === end);
+};

package/src/link-text.ts

@@ -0,0 +1,46 @@
+// リンクの言葉（`[こちら](url)` の「こちら」）を読む。純粋な関数だけを置く。
+
+/** `[` から、対応する `]` の位置。入れ子の角括弧（`[a [b] c]`）を数える。閉じなければ undefined。 */
+const closingBracket = (written: string): number | undefined => {
+  let depth = 0;
+  for (const [at, char] of [...written].entries()) {
+    if (char === "[") depth += 1;
+    if (char === "]") depth -= 1;
+    if (depth === 0) return at;
+  }
+  return undefined;
+};
+
+/**
+ * インラインのリンク（`[言葉](行き先)`）の言葉。参照の定義（`[1]: url`）と自動リンク（`<https://…>`）は言葉を持たないので undefined。
+ * 位置は字（コードポイント）で数える。
+ */
+export const linkTextOf = (written: string): string | undefined => {
+  if (!written.startsWith("[")) return undefined;
+  const close = closingBracket(written);
+  const chars = [...written];
+  if (close === undefined || chars[close + 1] !== "(") return undefined;
+  return chars.slice(1, close).join("");
+};
+
+/** 言葉を包む強調の印と鉤括弧（前後とも）、終わりの句読点（後ろだけ）。「**こちら**」も「こちら。」も「こちら」と読む。 */
+const LEADING = new Set(" \t\n*_「『\"“'");
+const TRAILING = new Set([...LEADING, ..."」』”。．.、，,!！?？:："]);
+
+const trimmed = (chars: readonly string[]): string => {
+  const start = chars.findIndex((char) => !LEADING.has(char));
+  if (start === -1) return "";
+  return chars.slice(start, chars.findLastIndex((char) => !TRAILING.has(char)) + 1).join("");
+};
+
+/** Markdown の逃がし（`here\\.`）。字はそのまま見えるので、逃がしの印だけを外す。 */
+const ESCAPED = /\\(\p{P})/gu;
+
+/** 見せる形。逃がしの印と、強調と鉤括弧と終わりの句読点を外し、空白をまとめる。コードの印（`）は外さない。コードの言葉は語ではない。 */
+export const bareLinkText = (text: string): string => trimmed([...text.replace(ESCAPED, "$1")]).replace(/\s+/gu, " ");
+
+/** 比べる形。見せる形を小文字にしたもの。 */
+export const comparableLinkText = (text: string): string => bareLinkText(text).toLowerCase();
+
+/** リンクの言葉が、それだけでは行き先を言わない言葉（語彙表の語）そのものか。言葉の一部に含むだけ（「料金表はこちら」）なら違う。 */
+export const isVagueLinkText = (text: string, vague: ReadonlySet<string>): boolean => vague.has(comparableLinkText(text));

package/src/long-vowel.ts

@@ -29,8 +29,11 @@ export type KanaWord = {
   readonly dropped: boolean;
 };
 
-/** The morae of the word written with its final ー: カー is two, コンピューター six. The guidelines count the word that way. */
-export const longFormMorae = (surface: string): number => moraCount(stemOf(surface)) + 1;
+/**
+ * The morae of the word before its final ー: カー is one, カバー two, コンピューター five. JIS Z 8301:2011 Table G.3 counts so:
+ * カバー is its example of a word of two sounds or fewer, which keeps the ー.
+ */
+export const stemMorae = (surface: string): number => moraCount(stemOf(surface));
 
 export type Ending = "consistent" | "drop" | "keep";
 
@@ -81,14 +84,21 @@ const sameWordGroups = (words: readonly KanaWord[]): KanaWord[][] => {
  */
 const inconsistent = (words: readonly KanaWord[]): Odd[] => sameWordGroups(words).flatMap((group) => minorityOf(group, "same-word"));
 
+/** Whether drop reaches the word: its final ー follows one of the kana the guideline drops it after (ア段: -er, -or, -ar). Any, when none are given. */
+const droppable = (word: KanaWord, dropAfter: ReadonlySet<string> | undefined): boolean =>
+  dropAfter === undefined || dropAfter.has(Array.from(stemOf(word.surface)).at(-1) ?? "");
+
 /**
- * The words that go against the chosen way. drop: a word of minMorae or more written with its final ー. keep: a word written
- * without one where the dictionary, or the document itself, has the form with one. consistent: see inconsistent.
- * Words shorter than minMorae are left alone whichever way: the guidelines that drop the ー keep it on them (カー).
+ * The words that go against the chosen way. drop: a word of minMorae or more written with its final ー after a kana of dropAfter.
+ * keep: a word written without one where the dictionary, or the document itself, has the form with one. consistent: see inconsistent.
+ * Words shorter than minMorae are left alone whichever way: the guidelines that drop the ー keep it on them (カー, カバー).
  */
-export const oddLongVowels = (words: readonly KanaWord[], ending: Ending, minMorae: number): Odd[] => {
-  const counted = words.filter((word) => longFormMorae(word.surface) >= minMorae);
-  if (ending === "drop") return counted.filter((word) => word.long).map((word) => ({ word, variant: "drop", preferred: otherForm(word), count: 0, of: 0 }));
+export const oddLongVowels = (words: readonly KanaWord[], ending: Ending, minMorae: number, dropAfter?: ReadonlySet<string>): Odd[] => {
+  const counted = words.filter((word) => stemMorae(word.surface) >= minMorae);
+  if (ending === "drop")
+    return counted
+      .filter((word) => word.long && droppable(word, dropAfter))
+      .map((word) => ({ word, variant: "drop", preferred: otherForm(word), count: 0, of: 0 }));
   if (ending === "keep") {
     const longStems = new Set(counted.filter((word) => word.long).map((word) => stemOf(word.surface)));
     return counted

package/src/markup.ts

@@ -1,5 +1,5 @@
 import { spanOf, type MarkdownNode } from "./markdown-node.ts";
-import { headingText } from "./heading-text.ts";
+import { atxHeadingText, headingText } from "./heading-text.ts";
 import { eachPreOrder } from "./tree-walk.ts";
 import { alertReader } from "./template-syntax.ts";
 import { cutSpans } from "./span-cut.ts";
@@ -84,7 +84,9 @@ const readHeading = (node: MarkdownNode, span: Span, source: string, walk: Walk)
   // 名前は書いたままの行から読む。MDX のコメントの `*` は、解析すると強調の印になって消える。
   const { id } = namedHeading(firstLineOf(source.slice(span.start, span.end)).replace(ATX_CLOSING, ""));
   if (id !== undefined && id !== "") walk.ids.add(id);
-  const text = withoutMdxComment(headingText(plainText(node, source)));
+  // ATX（行頭が #）なら閉じの # も外す。`## Install ## {#install}` の言葉は「Install」。
+  const read = source.startsWith("#", span.start) ? atxHeadingText : headingText;
+  const text = withoutMdxComment(read(plainText(node, source)));
   walk.headings.push({ depth: numberField(node, "depth") ?? 1, text, start: span.start, end: span.end });
 };
 

package/src/name-variants.ts

@@ -0,0 +1,217 @@
+import type { Token } from "./plugin.ts";
+
+// 同じ名前（人・会社・製品）を、文書の中で少しだけ違う形に書いた所。どの形が正しいかは決めず、少ないほうを指す。
+// 三通りで同じ名前と見る。書き方の違いだけ（GitHub と Github、Mac OS と macOS）、読みが同じ（山田太郎 と 山田太朗）、
+// 英字の一字違い（Microsoft と Microsft）。一字違いは別の名前でもありうるので、多いほうが二度以上、少ないほうが一度だけのときに限る。
+
+/** words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。 */
+export type NameMention = { readonly surface: string; readonly offset: number; readonly reading: string | undefined; readonly words: readonly string[] };
+
+export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" };
+
+const NAME = "PROPN";
+/**
+ * 名前の語のあいだに挟まってよい記号（AT&T、Rolls-Royce、ジョン・スミス）。読点は挟まない。
+ * 並べた名前（Zeebrugge, Kerk、Cook, Lisa）を一つの名前にしてしまう。
+ */
+const JOINERS: ReadonlySet<string> = new Set(["&", "-", "・"]);
+const LETTER = /\p{L}/u;
+
+/** 名前の語。字を含むもの。記号だけの語（wiki の '' ）を固有名詞と読む解析器がある。 */
+const isName = (token: Token | undefined): boolean => token?.pos === NAME && LETTER.test(token.surface);
+
+/** 固有名詞の続き。記号一つを挟んで固有名詞が続けば、一つの名前。 */
+const runsOf = (tokens: readonly Token[]): Token[][] => {
+  const runs: Token[][] = [];
+  const current: Token[] = [];
+  const close = (): void => {
+    if (current.length > 0) runs.push(current.splice(0));
+  };
+  tokens.forEach((token, index) => {
+    const bridges = JOINERS.has(token.surface) && current.length > 0 && isName(tokens[index + 1]);
+    if (isName(token) || bridges) current.push(token);
+    else close();
+  });
+  close();
+  return runs;
+};
+
+const LOWER = /\p{Ll}/u;
+const UPPER = /\p{Lu}/u;
+const isUpperOnly = (text: string): boolean => UPPER.test(text) && !LOWER.test(text);
+/** 小文字の英字だけの語（the、issue）。日本語の解析器は英単語を固有名詞と読むので、ふつうの語と名前の区別がつかない。 */
+const LOWER_LATIN_ONLY = /^[a-z\s-]+$/u;
+/** 行末で切った語のハイフン（Internet-⏎Drafts）。空白をまとめると "Internet- Drafts" になる。 */
+const WRAPPED_HYPHEN = /-\s+/gu;
+/** 名前の前後に付いた引用の印（wiki の斜体 ''、Hbase'）。名前の一部ではない。 */
+const QUOTE_MARKS: ReadonlySet<string> = new Set(["'", "’", '"', "“", "”"]);
+
+const withoutEdgeQuotes = (text: string): string => {
+  const chars = [...text];
+  const start = chars.findIndex((char) => !QUOTE_MARKS.has(char));
+  const end = chars.findLastIndex((char) => !QUOTE_MARKS.has(char));
+  return start < 0 ? "" : chars.slice(start, end + 1).join("");
+};
+/**
+ * 名前として比べないもの。@ で始まる SNS のアカウント（@SpaceX は SpaceX の別の書き方ではない）と、一字の語を含むもの
+ * （Attachment S、Appendix B は札で、空白を詰めると Attachments と同じ形になる）。
+ */
+const NOT_COMPARED = /@|(?:^|\s)\p{L}(?:\s|$)/u;
+
+/**
+ * 文の語から、名前の現れ。surface は source の上の書いたまま（折り返しの空白は一つにまとめる）。
+ * 大文字だけの名前（ACME INC、NASA）は外す。契約書の署名欄や略語で、ふつうの書き方の別の形ではない。小文字の英字だけの語も外す。
+ */
+export const mentionsIn = (tokens: readonly Token[], source: string): NameMention[] =>
+  runsOf(tokens).flatMap((run) => {
+    const first = run[0];
+    const last = run.at(-1);
+    if (first === undefined || last === undefined) return [];
+    const written = source.slice(first.span.start, last.span.end).replaceAll(WRAPPED_HYPHEN, "-").replaceAll(/\s+/gu, " ");
+    const surface = withoutEdgeQuotes(written);
+    if (surface === "" || isUpperOnly(surface) || LOWER_LATIN_ONLY.test(surface) || NOT_COMPARED.test(surface)) return [];
+    const words = run.filter((token) => !JOINERS.has(token.surface));
+    const readings = words.map((token) => token.reading);
+    const reading = readings.every((value) => value !== undefined && value !== "") ? readings.join("") : undefined;
+    return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface) }];
+  });
+
+/** 比べる形。幅（ＡＷＳ と AWS）、大文字小文字、空白と記号は名前を変えない。 */
+export const nameKey = (surface: string): string =>
+  surface
+    .normalize("NFKC")
+    .toLowerCase()
+    .replaceAll(/[\s\p{P}\p{S}]/gu, "");
+
+type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number };
+
+const talliesOf = (mentions: readonly NameMention[]): Tally[] => {
+  const tallies = new Map<string, { surface: string; first: NameMention; count: number }>();
+  mentions.forEach((mention) => {
+    const tally = tallies.get(mention.surface);
+    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1 });
+    else tally.count += 1;
+  });
+  return [...tallies.values()];
+};
+
+/** 多いほう。同数なら先に書いたほう。 */
+const usualOf = (group: readonly Tally[]): Tally | undefined =>
+  group.toSorted((left, right) => right.count - left.count || left.first.offset - right.first.offset)[0];
+
+const groupBy = (tallies: readonly Tally[], keysOf: (tally: Tally) => readonly string[]): Tally[][] => {
+  const groups = new Map<string, Tally[]>();
+  tallies.forEach((tally) =>
+    keysOf(tally).forEach((key) => {
+      const group = groups.get(key);
+      if (group === undefined) groups.set(key, [tally]);
+      else group.push(tally);
+    }),
+  );
+  return [...groups.values()].filter((group) => group.length > 1);
+};
+
+/**
+ * 組の中で、それぞれの書き方を、同じ名前と言える相手（alike）のうち多いほうと比べる。組全体で一番多いものとだけ比べると、
+ * 同じ読みの別の名前（山田太郎 と 矢間田多労）が多ければ、本当の書き分け（山田太朗）が隠れる。
+ */
+const variantsIn = (groups: readonly Tally[][], kind: NameVariant["kind"], alike: (tally: Tally, other: Tally) => boolean = () => true): NameVariant[] =>
+  groups.flatMap((group) =>
+    group.flatMap((tally) => {
+      const usual = usualOf([tally, ...group.filter((other) => other !== tally && alike(tally, other))]);
+      return usual === undefined || usual === tally ? [] : [{ mention: tally.first, usual: usual.surface, kind }];
+    }),
+  );
+
+/**
+ * 読みが同じでも、別の名前のことが多い（毅 と 敦士、札幌 と サッポロ）。語が二つ以上あり、違うのが一語だけのとき
+ * （山田太郎 と 山田太朗）に限る。
+ */
+const oneWordApart = (tally: Tally, usual: Tally): boolean => {
+  const words = tally.first.words;
+  const others = usual.first.words;
+  return words.length >= 2 && words.length === others.length && words.filter((word, index) => word !== others[index]).length === 1;
+};
+
+/** 一字違いを比べる語の長さ。短い語（Iran と Iraq、RET と REU、II と VI）は一字違いでも別の語。 */
+const MIN_NEAR_LENGTH = 5;
+const LATIN_WORD = /^[a-z]+$/u;
+
+const wordsOf = (surface: string): string[] => surface.toLowerCase().split(/[\s-]+/u);
+
+/** 一字の置き換えか、隣どうしの入れ替え（Microsfot）。 */
+const isSwapOrReplace = (left: string, right: string): boolean => {
+  const differ = [...left].flatMap((char, index) => (char === right.charAt(index) ? [] : [index]));
+  const [first, second] = differ;
+  if (differ.length === 1) return true;
+  return (
+    differ.length === 2 &&
+    first !== undefined &&
+    second === first + 1 &&
+    left.charAt(first) === right.charAt(second) &&
+    left.charAt(second) === right.charAt(first)
+  );
+};
+
+/**
+ * 語の中の一字の抜け。語の終わりの抜け（Service と Services、America と American）は語の形の違い、頭の抜け（State と XState）は
+ * 別の名前で、書き損じではない。
+ */
+const isInnerDrop = (longer: string, shorter: string): boolean =>
+  [...longer].some((_char, index) => index > 0 && index < longer.length - 1 && longer.slice(0, index) + longer.slice(index + 1) === shorter);
+
+/** 二つの語が一字違いか。英字だけの、長さ 5 以上の語で。 */
+export const isNearWord = (left: string, right: string): boolean => {
+  if (left === right || !LATIN_WORD.test(left) || !LATIN_WORD.test(right) || Math.min(left.length, right.length) < MIN_NEAR_LENGTH) return false;
+  if (left.length === right.length) return isSwapOrReplace(left, right);
+  if (left.length === right.length + 1) return isInnerDrop(left, right);
+  return right.length === left.length + 1 && isInnerDrop(right, left);
+};
+
+/** 語の一つを伏せた形。ほかの語が同じ二つの名前は、同じ形を一つ持つ。 */
+const maskedKeys = (tally: Tally): string[] => {
+  const words = wordsOf(tally.surface);
+  return words.map((_word, index) => words.map((word, at) => (at === index ? "*" : word)).join(" "));
+};
+
+const differingWords = (left: Tally, right: Tally): readonly [string, string] | undefined => {
+  const leftWords = wordsOf(left.surface);
+  const rightWords = wordsOf(right.surface);
+  const at = leftWords.findIndex((word, index) => word !== rightWords[index]);
+  const [leftWord, rightWord] = [leftWords[at], rightWords[at]];
+  return leftWords.length === rightWords.length && leftWord !== undefined && rightWord !== undefined ? [leftWord, rightWord] : undefined;
+};
+
+/** 一語だけが一字違いで、相手が二度以上、こちらが一度だけ。 */
+const isSlipOf = (tally: Tally, other: Tally): boolean => {
+  if (tally.count !== 1 || other.count < 2) return false;
+  const words = differingWords(tally, other);
+  return words !== undefined && isNearWord(...words);
+};
+
+const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf);
+
+/** 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。 */
+export const nameVariants = (mentions: readonly NameMention[]): NameVariant[] => {
+  const tallies = talliesOf(mentions);
+  const found = [
+    ...variantsIn(
+      groupBy(tallies, (tally) => [nameKey(tally.surface)]),
+      "spelling",
+    ),
+    ...variantsIn(
+      groupBy(tallies, (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading])),
+      "reading",
+      oneWordApart,
+    ),
+    ...nearVariants(tallies),
+  ];
+  const reported = new Set<string>();
+  return found
+    .filter((variant) => {
+      if (reported.has(variant.mention.surface)) return false;
+      reported.add(variant.mention.surface);
+      return true;
+    })
+    .toSorted((left, right) => left.mention.offset - right.mention.offset);
+};

package/src/node-version.ts

@@ -0,0 +1,22 @@
+// bin/chaff.js loads this before the CLI, on whatever Node.js the person has. Keep it free of imports and of syntax
+// that old releases cannot parse (`??`, `?.`): running there is its whole job.
+
+type Env = Readonly<Record<string, string | undefined>>;
+
+/** The lowest major version an engines range such as ">=24" names, or undefined for a range of another shape. */
+export const requiredMajorOf = (range: unknown): number | undefined => {
+  const match = /^\s*>=\s*v?(\d+)/u.exec(String(range));
+  return match === null ? undefined : Number(match[1]);
+};
+
+const isJapaneseLocale = (env: Env): boolean => /^ja/iu.test(env["LC_ALL"] || env["LC_MESSAGES"] || env["LANG"] || "");
+
+/** What to print before stopping when this Node.js is older than the engines range; undefined when it is new enough. */
+export const tooOldMessage = (version: string, range: unknown, env: Env): string | undefined => {
+  const required = requiredMajorOf(range);
+  const major = Number(version.split(".")[0]);
+  if (required === undefined || Number.isNaN(major) || major >= required) return undefined;
+  return isJapaneseLocale(env)
+    ? `chaff は Node.js ${String(required)} 以上で動きます。いまは v${version} です。https://nodejs.org/ja から LTS を入れてください。`
+    : `chaff needs Node.js ${String(required)} or later. This is v${version}. Install the LTS from https://nodejs.org/en`;
+};

package/src/not-run.ts

@@ -0,0 +1,16 @@
+import type { Skipped } from "./run.ts";
+
+/** A rule someone asked about that did not run in this check, with why, and whether --experimental would run it. */
+export type NotRun = { readonly rule: string; readonly why: string; readonly needsExperimental: boolean };
+
+/**
+ * Pure: of the rules named in `ruleIds`, those this check skipped. A command that looks a rule's findings up (feedback,
+ * suppressions) says this instead of "none": no findings from a rule that did not run is not "checked and fine".
+ * --experimental is suggested only where it is the reason, not for a rule chaff.yaml or the genre turned off.
+ */
+export const notRunAmong = (ruleIds: readonly string[], skipped: readonly Skipped[]): NotRun[] => {
+  const asked = new Set(ruleIds);
+  return skipped
+    .filter((entry) => asked.has(entry.rule))
+    .map((entry) => ({ rule: entry.rule, why: entry.why, needsExperimental: entry.offUntilExperimental === true }));
+};

package/src/orthography.ts

@@ -152,13 +152,25 @@ export const hyphenGroups = (text: string): string[] => text.split(HYPHEN).filte
 
 const isCodeChar = (char: string | undefined): boolean => DIGIT.test(char ?? "") || isHyphen(char);
 
-const isCode = (chars: readonly string[], digit: number): boolean => {
+/** digit を含む、isPart の字の並び。 */
+const runAround = (chars: readonly string[], digit: number, isPart: (char: string | undefined) => boolean): string => {
   let [first, last] = [digit, digit];
-  while (first > 0 && isCodeChar(chars[first - 1])) first -= 1;
-  while (last < chars.length - 1 && isCodeChar(chars[last + 1])) last += 1;
-  return hyphenGroups(chars.slice(first, last + 1).join("")).length >= MIN_CODE_GROUPS;
+  while (first > 0 && isPart(chars[first - 1])) first -= 1;
+  while (last < chars.length - 1 && isPart(chars[last + 1])) last += 1;
+  return chars.slice(first, last + 1).join("");
 };
 
+const isDottedChar = (char: string | undefined): boolean => DIGIT.test(char ?? "") || char === ".";
+
+/** 「1.0.0」「3.1.2」のように . でつないだ 3 組以上の数字は、版や項目の番号で数量ではない。2 組（「1.5 倍」）は小数なので数える。 */
+const isDottedCode = (chars: readonly string[], digit: number): boolean =>
+  runAround(chars, digit, isDottedChar)
+    .split(".")
+    .filter((group) => group !== "").length >= MIN_CODE_GROUPS;
+
+const isCode = (chars: readonly string[], digit: number): boolean =>
+  hyphenGroups(runAround(chars, digit, isCodeChar)).length >= MIN_CODE_GROUPS || isDottedCode(chars, digit);
+
 /** 日本語との境目にある数字が、数えない書き方（「第3条」の番地、「073-489-5909」の符号）か。 */
 const isUncountedNumber = (chars: readonly string[], index: number): boolean => {
   const [left, right] = [chars[index], chars[index + 1]];
@@ -201,13 +213,30 @@ export const latinBoundaries = (text: string, written: string = text): Boundary[
 };
 
 /**
- * 混ざっているとき、そろえるべき少数派。種類（英字・数字の前・数字の後ろ）ごとに数える。
+ * 二通りの書き方（true と false）が混ざっているとき、そろえるべき少数派。どちらか一方しか無ければ undefined。
  * 同数なら、文書が先に使った書き方をその文書の書き方とみなし、後から出た書き方を少数派にする。
  */
-export const minorityStyle = (boundaries: readonly { readonly spaced: boolean }[]): boolean | undefined => {
-  const spaced = boundaries.filter((boundary) => boundary.spaced).length;
-  const touching = boundaries.length - spaced;
-  if (spaced === 0 || touching === 0) return undefined;
-  if (spaced !== touching) return spaced < touching;
-  return !(boundaries[0]?.spaced ?? false);
+export const minorityOf = (written: readonly boolean[]): boolean | undefined => {
+  const yes = written.filter(Boolean).length;
+  const no = written.length - yes;
+  if (yes === 0 || no === 0) return undefined;
+  if (yes !== no) return yes < no;
+  return !(written[0] ?? false);
 };
+
+const PERCENT = 100;
+
+/**
+ * 二通りに書き分けたもの（side が true か false）のうち、少ないほうのもの。少ないほうが全体の limitPercent パーセントを超えるなら、
+ * 文書が使い分けていると見て空。どちらか一方しか無くても空。
+ */
+export const minorityWithin = <T>(items: readonly T[], side: (item: T) => boolean, limitPercent: number): T[] => {
+  const minority = minorityOf(items.map(side));
+  if (minority === undefined) return [];
+  const odd = items.filter((item) => side(item) === minority);
+  return odd.length * PERCENT > limitPercent * items.length ? [] : odd;
+};
+
+/** 空けるか詰めるかの少数派。種類（英字・数字の前・数字の後ろ）ごとに数える。 */
+export const minorityStyle = (boundaries: readonly { readonly spaced: boolean }[]): boolean | undefined =>
+  minorityOf(boundaries.map((boundary) => boundary.spaced));

package/src/outline/render.ts

@@ -0,0 +1,92 @@
+import type { LengthUnit } from "../plugin.ts";
+import type { Outline, OutlineEntry, Shape } from "./shape.ts";
+import type { OutlineText } from "./text.ts";
+import type { StructureScore } from "../structure-shape/score.ts";
+import { structureChangeLines, structureCompact, structureJson, structureLines } from "./structure-render.ts";
+
+/** One file's outline as `chaff outline` shows it, with its structure measures placed against human articles. */
+export type DocumentOutline = { readonly path: string; readonly language: string; readonly outline: Outline; readonly structure: StructureScore };
+
+type Measure = { readonly name: string; readonly value: (shape: Shape, unit: LengthUnit) => string };
+
+/** The shape's measures in the order they are shown. */
+const measuresOf = (text: OutlineText): readonly Measure[] => [
+  { name: text.headings, value: (shape) => String(shape.headings) },
+  { name: text.averageSection, value: (shape, unit) => text.length(shape.averageSectionLength, unit) },
+  { name: text.lists, value: (shape) => `${String(shape.listPercent)}%` },
+  { name: text.bold, value: (shape) => String(shape.bold) },
+];
+
+/** The shape's measures on one line: 見出し 6、節の平均 120 字、… / headings 6, average section 80 words, … */
+export const shapeMeasures = (shape: Shape, unit: LengthUnit, text: OutlineText): string =>
+  measuresOf(text)
+    .map((measure) => text.measure(measure.name, measure.value(shape, unit)))
+    .join(text.separator);
+
+const shapeLine = (document: DocumentOutline, text: OutlineText): string =>
+  text.shapeOf(document.path, shapeMeasures(document.outline.shape, document.outline.unit, text));
+
+const headingOf = (entry: OutlineEntry, text: OutlineText): string => (entry.depth === 0 ? text.lead : `${"#".repeat(entry.depth)} ${entry.heading}`);
+
+/** A heading indented by its depth, where it is, and how long its own text is. */
+const entryLine = (entry: OutlineEntry, document: DocumentOutline, text: OutlineText): string => {
+  const indent = "  ".repeat(Math.max(entry.depth - 1, 0));
+  const length = text.length(entry.length, document.outline.unit);
+  return `  ${indent}${headingOf(entry, text)}  (${document.path}:${String(entry.line)})  ${length}`;
+};
+
+const outlineBlock = (document: DocumentOutline, text: OutlineText): string[] => [
+  shapeLine(document, text),
+  "",
+  ...document.outline.entries.map((entry) => entryLine(entry, document, text)),
+  "",
+  ...structureLines(document.structure, document.language, document.outline.unit, text.structure),
+];
+
+/** Each measure before and after, so a restructure shows as numbers that moved. */
+const changeBlock = (before: DocumentOutline, after: DocumentOutline, text: OutlineText): string[] => [
+  "",
+  text.changed(before.path, after.path),
+  ...measuresOf(text).map(
+    (measure) => `  ${measure.name}: ${measure.value(before.outline.shape, before.outline.unit)} → ${measure.value(after.outline.shape, after.outline.unit)}`,
+  ),
+  ...structureChangeLines(before.structure, after.structure, [before.outline.unit, after.outline.unit], text.structure),
+];
+
+/** For a person: each file's shape and outline, then, for two files, how each measure moved. */
+export const renderOutlineFriendly = (documents: readonly DocumentOutline[], text: OutlineText): string => {
+  const [before, after] = documents;
+  const outlines = documents.flatMap((document, index) => [...(index > 0 ? [""] : []), ...outlineBlock(document, text)]);
+  return [...outlines, ...(before !== undefined && after !== undefined ? changeBlock(before, after, text) : [])].join("\n");
+};
+
+const COMPACT_UNIT: Readonly<Record<LengthUnit, string>> = { char: "chars", word: "words" };
+
+const compactEntry = (entry: OutlineEntry, document: DocumentOutline): string => {
+  const heading = entry.depth === 0 ? "lead" : `h${String(entry.depth)} ${entry.heading}`;
+  return `${document.path}:${String(entry.line)}: ${heading} (${String(entry.length)} ${COMPACT_UNIT[document.outline.unit]})`;
+};
+
+/** For grep: one section per line, then each file's shape. */
+export const renderOutlineCompact = (documents: readonly DocumentOutline[], text: OutlineText): string =>
+  [
+    ...documents.flatMap((document) => document.outline.entries.map((entry) => compactEntry(entry, document))),
+    ...documents.map((document) => shapeLine(document, text)),
+    ...documents.map((document) => structureCompact(document.path, document.structure)),
+  ].join("\n");
+
+const outlineJson = (document: DocumentOutline): Readonly<Record<string, unknown>> => ({
+  path: document.path,
+  language: document.language,
+  unit: document.outline.unit,
+  shape: document.outline.shape,
+  outline: document.outline.entries,
+  structure: structureJson(document.structure),
+});
+
+/** For an AI: one file's outline and shape, or `before` and `after` for two. */
+export const renderOutlineJson = (documents: readonly DocumentOutline[]): string => {
+  const [before, after] = documents;
+  const body = before !== undefined && after !== undefined ? { before: outlineJson(before), after: outlineJson(after) } : documents.map(outlineJson)[0];
+  return JSON.stringify(body, null, 2);
+};