chaffjs 0.26.0 → 0.27.0

package/src/structure/percent-sum-prose.ts

@@ -0,0 +1,54 @@
+// A breakdown written in one sentence (「構成比は、Aが50%、Bが30%、Cが20%」, "By product, A made up 50% of sales, B 30% and
+// C 20%") whose shares do not add up to 100%. The table and list form is structure/percent-sum.ts; the words are the same.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import type { Amount } from "./total.ts";
+import type { ShareWords } from "./percent-sum.ts";
+
+const WHOLE = 100;
+/** A sentence names two shares in passing (「AとBで50%」); a breakdown in prose names at least three parts. */
+const MIN_PARTS = 3;
+/**
+ * How far from 100% a sentence may add up and still read as one whole broken down. Far below it, the sentence names only the
+ * larger parts (「Aが50%、Bが20%、Cが10%など」); far above it, the percentages are of different wholes ("55% of directors,
+ * 48% of managers") or of two periods ("45% (40% last year)"), or the total is among them (「合計100%」).
+ */
+const BAND = 10;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+const DECIMALS = /\.(\d+)/u;
+/** A sign before the number (+3%, ▲2%): a change, not a part. */
+const SIGNS = "-+−▲△";
+
+const includesAny = (text: string, words: readonly string[]): boolean => {
+  const lowered = text.toLowerCase();
+  return words.some((word) => lowered.includes(word.toLowerCase()));
+};
+
+const decimalsOf = (source: string, amount: Amount): number => DECIMALS.exec(source.slice(amount.offset, amount.end))?.[1]?.length ?? 0;
+
+const isSigned = (source: string, amount: Amount): boolean => SIGNS.includes(source.slice(0, amount.offset).trimEnd().at(-1) ?? " ");
+
+/** The rounding the parts allow: half the last digit each, at least one point. */
+const toleranceOf = (source: string, shares: readonly Amount[]): number =>
+  Math.max(1, shares.length * HALF * DECIMAL_BASE ** -Math.max(0, ...shares.map((share) => decimalsOf(source, share))));
+
+const isBroken = (sum: number, tolerance: number): boolean => Math.abs(sum - WHOLE) > tolerance && Math.abs(sum - WHOLE) <= BAND;
+
+const issueIn = (source: string, sentence: Span, percents: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  const text = source.slice(sentence.start, sentence.end);
+  if (!includesAny(text, words.labels) || includesAny(text, words.exceptions)) return [];
+  const shares = percents.filter((amount) => amount.offset >= sentence.start && amount.end <= sentence.end);
+  if (shares.length < MIN_PARTS || shares.some((share) => isSigned(source, share))) return [];
+  const sum = shares.reduce((total, share) => total + share.value, 0);
+  const decimals = Math.max(0, ...shares.map((share) => decimalsOf(source, share)));
+  if (!isBroken(sum, toleranceOf(source, shares))) return [];
+  return [{ offset: shares[0]?.offset ?? sentence.start, values: { sum: `${sum.toFixed(decimals)}${shares[0]?.unit ?? ""}` } }];
+};
+
+/** Each sentence that names a share word and three or more unsigned percentages whose sum misses 100% by more than rounding, and by no more than BAND. */
+export const proseShareMismatches = (source: string, sentences: readonly Span[], amounts: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  if (words.labels.length === 0) return [];
+  const percents = amounts.filter((amount) => words.units.includes(amount.unit));
+  return sentences.flatMap((sentence) => issueIn(source, sentence, percents, words));
+};

package/src/structure/version-mismatch.ts

@@ -0,0 +1,103 @@
+// A version written in the lead-in to a code block ("Install version 2.3.0 from npm:") that the block itself does not
+// show (npm install tidyq@2.4.0). Pure: reads the source, the code blocks, and the prose with code covered.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * A dotted version of three parts (2.4.0, v1.12.3, 3.0.0-beta.2). Two parts (22.04, 3.1) are too often a decimal, and a
+ * first part of four digits is too often a date (2024.01.15).
+ */
+const VERSION = /(?<![\w.])v?(\d{1,3}\.\d{1,4}\.\d{1,4}(?:-[0-9A-Za-z.]+)?)(?![\w.]|\.\d)/gu;
+
+/** A word that makes a version a bound or a starting point, not the version installed: 「2.3.0 から」 "from 2.3.0", "20.0.0 or later". */
+export type RangeWord = { readonly word: string; readonly position: "before" | "after" };
+
+/** What tells which versions are the block's: the bound words, and the Latin words that lead to the version installed. */
+export type VersionWords = { readonly ranges: readonly RangeWord[]; readonly versionWords: readonly string[] };
+
+/** One code block: where it starts and the text between its fences. */
+export type CodeBlock = { readonly start: number; readonly code: string };
+
+/** How far a range word may stand from the version (a space, a "v"). */
+const RANGE_GAP = 2;
+
+type Found = { readonly start: number; readonly end: number; readonly version: string };
+
+const versionsIn = (text: string, offset = 0): Found[] =>
+  [...text.matchAll(VERSION)].map((match) => ({ start: offset + match.index, end: offset + match.index + match[0].length, version: match[1] ?? "" }));
+
+const isBound = (prose: string, found: Span, words: readonly RangeWord[]): boolean =>
+  words.some(({ word, position }) => {
+    if (word === "") return false;
+    const near =
+      position === "after"
+        ? prose.slice(found.end, found.end + RANGE_GAP + word.length)
+        : prose.slice(Math.max(0, found.start - RANGE_GAP - word.length), found.start);
+    return near.toLowerCase().includes(word.toLowerCase());
+  });
+
+/** The names a block pins its version to: tidyq in tidyq@2.4.0, tidyq==2.4.0, tidyq=2.4.0, tidyq:2.4.0, "tidyq": "2.4.0". */
+const PINNED = /^([\w.-]+)(?:@|==|=|:)[v^~]?\d/u;
+const QUOTES = /["']/gu;
+const OPENS_WITH_NUMBER = /^[v^~]?\d/u;
+
+/** Each whitespace-separated word of the code, quotes dropped; "tidyq": "2.4.0" is read as tidyq:2.4.0. */
+const codeWords = (code: string): string[] => {
+  const words = code.split(/\s+/u).map((word) => word.replaceAll(QUOTES, "").replace(/,$/u, ""));
+  return words.map((word, index) => (word.endsWith(":") && OPENS_WITH_NUMBER.test(words[index + 1] ?? "") ? `${word}${words[index + 1] ?? ""}` : word));
+};
+
+const pinnedNames = (code: string): Set<string> => new Set(codeWords(code).flatMap((word) => PINNED.exec(word)?.[1]?.toLowerCase() ?? []));
+
+const LATIN = /^[A-Za-z]/u;
+const WORD_CHAR = /[\w.+-]/u;
+/** How far back the word before a version is looked for. */
+const WORD_REACH = 40;
+
+/** The Latin word right before a position, if the word there is Latin: "Node.js" in "Requires Node.js 18.17.0". */
+const latinWordBefore = (text: string): string | undefined => {
+  const last = [...(text.trimEnd().split(/\s/u).at(-1) ?? "")];
+  const word = last.slice(0, last.findLastIndex((char) => WORD_CHAR.test(char)) + 1).join("");
+  return LATIN.test(word) ? word.toLowerCase() : undefined;
+};
+
+/**
+ * Whether a lead-in version is about the block's software. A Latin word right before it must be one of the words that lead
+ * to the version installed (version, release, install; lexicon version-lead) or the pinned software: "Requires Node.js
+ * 18.17.0" over `npm install pkg@2.4.0` names another program. A version after no Latin word (「npm から 2.3.0」) is the block's.
+ */
+const isAboutBlock = (prose: string, found: Found, names: ReadonlySet<string>, versionWords: readonly string[]): boolean => {
+  const word = latinWordBefore(prose.slice(Math.max(0, found.start - WORD_REACH), found.start));
+  return word === undefined || names.has(word) || versionWords.some((name) => name.toLowerCase() === word);
+};
+
+const BLANK_LINE = /\r?\n[ \t]*\r?\n/gu;
+const NOT_PROSE = /^\s*(?:#|[-*+]\s|\d{1,3}[.)]\s|```|~~~|\|)/u;
+const LETTER = /\p{L}/u;
+
+/** The paragraph right above a code block: the lines up to the blank line before it. A heading, a list item, a table or a bare version above is not a lead-in. */
+const leadInOf = (source: string, blockStart: number): Span | undefined => {
+  const lines = source.slice(0, blockStart).trimEnd();
+  const last = [...lines.matchAll(BLANK_LINE)].at(-1);
+  const start = last === undefined ? 0 : last.index + last[0].length;
+  const text = lines.slice(start);
+  const words = text.replace(VERSION, "");
+  return text === "" || NOT_PROSE.test(text) || !LETTER.test(words) ? undefined : { start, end: lines.length };
+};
+
+/**
+ * Each version in a code block's lead-in that differs from the one version the block shows. A block with no version, or
+ * with two (an upgrade from one to the other), says nothing to compare; a version marked as a bound, or named after another
+ * program, is not the one installed.
+ */
+export const versionMismatches = (source: string, prose: string, blocks: readonly CodeBlock[], words: VersionWords): StructureIssue[] =>
+  blocks.flatMap((block) => {
+    const shown = [...new Set(versionsIn(block.code).map((found) => found.version))];
+    const leadIn = leadInOf(source, block.start);
+    const [code] = shown;
+    if (shown.length !== 1 || code === undefined || leadIn === undefined) return [];
+    const names = pinnedNames(block.code);
+    return versionsIn(prose.slice(leadIn.start, leadIn.end), leadIn.start)
+      .filter((found) => found.version !== code && !isBound(prose, found, words.ranges) && isAboutBlock(prose, found, names, words.versionWords))
+      .map((found) => ({ offset: found.start, values: { written: found.version, code } }));
+  });

package/src/structure/weekday.ts

@@ -5,6 +5,7 @@ import { inDocumentOrder } from "./issues.ts";
 // 日付と、その横に書いた曜日の食い違い。暦で決まるので、両方読めれば誤りは機械で言える。
 
 const FULL_DATE = /^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/u;
+const MONTH_DAY = /^(?<m>\d{2})-(?<d>\d{2})$/u;
 
 /** 暦の曜日。日曜日が 0。存在しない日（2月30日）は undefined。 */
 export const weekdayOf = (value: string): number | undefined => {
@@ -15,11 +16,87 @@ export const weekdayOf = (value: string): number | undefined => {
   return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? date.getUTCDay() : undefined;
 };
 
-/** 年まで書いた日付で、書いた曜日が暦と違うもの。年の無い日付は曜日を決められないので見ない。 */
-export const weekdayMismatches = (tree: StructureNode): StructureIssue[] =>
-  inDocumentOrder(tree).flatMap((node) => {
+const DAY_MS = 86_400_000;
+/** 年を書いた日付から 5 か月以内なら、前後の年のどれか一つだけがそこに収まる。半年を超えると、どちらの年とも読める。 */
+const YEAR_REACH_DAYS = 153;
+
+const timeOf = (value: string): number | undefined => {
+  const groups = FULL_DATE.exec(value)?.groups;
+  return groups === undefined || weekdayOf(value) === undefined ? undefined : Date.UTC(Number(groups["y"]), Number(groups["m"]) - 1, Number(groups["d"]));
+};
+
+/**
+ * 年の無い月日（「10-09」）に、年を書いた日付（anchor、「2026-10-06」）の前後の年のうち、anchor から 5 か月以内に収まる年を付ける。
+ * メールや議事録は、文書の日付の年を書いて、そのあとの日付の年を省く。12月の文書の「1月5日」は翌年。どの年も収まらなければ undefined。
+ */
+export const withNearestYear = (monthDay: string, anchor: string): string | undefined => {
+  const groups = MONTH_DAY.exec(monthDay)?.groups;
+  const anchorYear = FULL_DATE.exec(anchor)?.groups?.["y"];
+  const anchorTime = timeOf(anchor);
+  if (groups === undefined || anchorYear === undefined || anchorTime === undefined) return undefined;
+  return [-1, 0, 1]
+    .map((offset) => `${String(Number(anchorYear) + offset)}-${groups["m"] ?? ""}-${groups["d"] ?? ""}`)
+    .find((candidate) => {
+      const time = timeOf(candidate);
+      return time !== undefined && Math.abs(time - anchorTime) <= YEAR_REACH_DAYS * DAY_MS;
+    });
+};
+
+/**
+ * 年の無い日付の年を決める手がかり。stamp は文書の日付（「更新日：」の段落など）、sectionStarts は見出しで分けた節の始まり、
+ * yearHeadings はそのうち見出しが年を名指す節（「## 2024年度」）の始まり。anchorable は、年を決めるのに使ってよい日付か
+ * （引用符で日付だけを挙げた例は使わない）。
+ */
+export type YearContext = {
+  readonly stamp?: string | undefined;
+  readonly sectionStarts: readonly number[];
+  readonly yearHeadings?: readonly number[];
+  readonly anchorable?: (node: StructureNode) => boolean;
+};
+
+const sectionOf = (starts: readonly number[], offset: number): number => starts.filter((start) => start <= offset).length;
+
+/** 文書の書き出し: 最初の見出しより前と、最初の見出しの節。メールや議事録の頭の日付（日付：、日時：）が書かれる所。 */
+const OPENING_SECTIONS = 1;
+
+/**
+ * 年の無い日付の年を決める、年を書いた日付。同じ節のすぐ前のもの（前に無ければ後ろの最初のもの）。節に無ければ文書の日付、
+ * それも無ければ書き出しの最初の日付。年度ごとの見出しの下の「1月24日（火）」はその節の年で読み、別の節の日付の年では読まない。
+ */
+const anchorOf = (dated: readonly StructureNode[], node: StructureNode, context: YearContext): string | undefined => {
+  const section = sectionOf(context.sectionStarts, node.span.start);
+  const inSection = dated.filter((other) => sectionOf(context.sectionStarts, other.span.start) === section);
+  const nearest = inSection.findLast((other) => other.span.start < node.span.start) ?? inSection[0];
+  // 見出しが年を名指す節（「## 2024年度」）の日付は、その年の中にある。節の外の日付からは決めない。
+  const sectionStart = context.sectionStarts[section - 1];
+  if (nearest === undefined && sectionStart !== undefined && (context.yearHeadings ?? []).includes(sectionStart)) return undefined;
+  const opening = dated.find((other) => sectionOf(context.sectionStarts, other.span.start) <= OPENING_SECTIONS);
+  const stamp = context.stamp !== undefined && FULL_DATE.test(context.stamp) ? context.stamp : undefined;
+  const fromTree = (found: StructureNode | undefined): string | undefined => (found === undefined ? undefined : String(found.attrs["value"]));
+  return fromTree(nearest) ?? stamp ?? fromTree(opening);
+};
+
+/** 日付の年月日。年の無い日付は、近くの年を書いた日付から年を決めて付ける。決まらなければ undefined。 */
+const fullValueOf = (dated: readonly StructureNode[], node: StructureNode, context: YearContext): string | undefined => {
+  const value = String(node.attrs["value"]);
+  if (!MONTH_DAY.test(value)) return value;
+  const anchor = anchorOf(dated, node, context);
+  return anchor === undefined ? undefined : withNearestYear(value, anchor);
+};
+
+/**
+ * 書いた曜日が暦と違う日付。年の無い日付は、年を書いた日付（anchorOf）から 5 か月以内に収まる年として比べる。
+ * 年を書いた日付が文書に無いか、どの年も収まらなければ、曜日を決められないので見ない。
+ */
+export const weekdayMismatches = (tree: StructureNode, context: YearContext = { sectionStarts: [] }): StructureIssue[] => {
+  const dates = inDocumentOrder(tree).filter((node) => node.kind === "date");
+  const anchorable = context.anchorable ?? (() => true);
+  const dated = dates.filter((node) => timeOf(String(node.attrs["value"])) !== undefined && anchorable(node));
+  return dates.flatMap((node) => {
     const written = node.attrs["weekday"];
-    if (node.kind !== "date" || typeof written !== "number") return [];
-    const actual = weekdayOf(String(node.attrs["value"]));
-    return actual === undefined || actual === written ? [] : [{ offset: node.span.start, values: { date: String(node.attrs["value"]), written, actual } }];
+    if (typeof written !== "number") return [];
+    const value = fullValueOf(dated, node, context);
+    const actual = value === undefined ? undefined : weekdayOf(value);
+    return value === undefined || actual === undefined || actual === written ? [] : [{ offset: node.span.start, values: { date: value, written, actual } }];
   });
+};