@jpeakai/prose-gates 0.1.1 → 0.2.0

package/src/rules/pg004-em-dash.ts

@@ -1,117 +0,0 @@
-// PG004: an em-dash in prose. Code is exempt by construction, since only
-// text nodes are read. The fix is deliberately narrow: a pair of dashes
-// around an aside becomes parentheses, a lone dash becomes a colon, and
-// anything else stays reported for a human.
-
-import { matchesIn } from "../fix/spans.ts";
-import type { DocModel, Range, TextView } from "../model.ts";
-import { type Edit, RULE, type Rule } from "./types.ts";
-
-// Any horizontal space around the dash belongs to it, including no-break and
-// zero-width spaces, or the swap strands one in front of the colon.
-const DASH = /[\p{Zs}\t\u200b]*—[\p{Zs}\t\u200b]*/u;
-
-// An aside that reads as an enumeration marker, "(b)", would plant a PG007
-// marker and hide the word from the content fingerprint.
-const MARKER_LIKE = /^(?:[a-z]|[ivx]+|\d+)$/i;
-
-interface Dash {
-  range: Range; // the dash with its surrounding spaces
-  text: TextView;
-}
-
-const fix = (doc: DocModel): Edit[] => {
-  const { src } = doc;
-  const byBlock = new Map<unknown, { texts: TextView[]; dashes: Dash[]; refused: boolean }>();
-  for (const t of doc.texts) {
-    if (t.block === undefined || t.start === undefined || t.end === undefined) continue;
-    const entry = byBlock.get(t.block) ?? { texts: [], dashes: [], refused: false };
-    byBlock.set(t.block, entry);
-    entry.texts.push(t);
-    const found = matchesIn(src, { value: t.value, start: t.start, end: t.end }, DASH);
-    if (found === null) entry.refused = true;
-    else entry.dashes.push(...found.map((range) => ({ range, text: t })));
-  }
-
-  const edits: Edit[] = [];
-  for (const { texts, dashes, refused } of byBlock.values()) {
-    if (refused || dashes.length === 0) continue;
-    // Sentence terminals and colons, read only from prose text in this block.
-    const terminals: number[] = [];
-    const colons: number[] = [];
-    for (const t of texts) {
-      const slice = src.slice(t.start, t.end);
-      for (const m of slice.matchAll(/[.!?](?=\s)/g)) terminals.push((t.start as number) + (m.index ?? 0));
-      for (const m of slice.matchAll(/:/g)) colons.push((t.start as number) + (m.index ?? 0));
-    }
-    const sentenceOf = (offset: number): number => terminals.filter((x) => x < offset).length;
-    const groups = new Map<number, Dash[]>();
-    for (const d of dashes) {
-      const key = sentenceOf(d.range[0]);
-      groups.set(key, [...(groups.get(key) ?? []), d]);
-    }
-
-    for (const [sentence, group] of groups) {
-      const edit = rewrite(src, group, sentence, sentenceOf, colons);
-      if (edit) edits.push(edit);
-    }
-  }
-  return edits;
-};
-
-const rewrite = (
-  src: string,
-  group: Dash[],
-  sentence: number,
-  sentenceOf: (offset: number) => number,
-  colons: number[],
-): Edit | null => {
-  const first = group[0] as Dash;
-  const last = group[group.length - 1] as Dash;
-  // A dash touching a line break, the edge of its text node, or punctuation
-  // that already ends or opens a clause has no clear neighbours to join.
-  const touchesEdge = (d: Dash): boolean =>
-    d.range[0] === d.text.start ||
-    d.range[1] === d.text.end ||
-    /[\r\n.!?:;,(\\]/.test(src[d.range[0] - 1] ?? "\n") ||
-    /[\r\n.!?:;,)]/.test(src[d.range[1]] ?? "\n");
-  if (group.some(touchesEdge)) return null;
-
-  let text: string;
-  if (group.length === 2) {
-    const inner = src.slice(first.range[1], last.range[0]);
-    if (MARKER_LIKE.test(inner.trim())) return null;
-    text = ` (${inner}) `;
-  } else if (group.length === 1) {
-    // A numeric range like 1—2 or 2020 — 2021 wants an en-dash, not a colon,
-    // and a sentence that already has a colon would read as two labels.
-    if (/\d/.test(src[first.range[0] - 1] ?? "") && /\d/.test(src[first.range[1]] ?? "")) return null;
-    if (colons.some((c) => sentenceOf(c) === sentence)) return null;
-    text = ": ";
-  } else {
-    return null;
-  }
-  return {
-    rule: RULE.EM_DASH,
-    start: first.range[0],
-    end: last.range[1],
-    text,
-    expect: { kind: "same-shape" },
-  };
-};
-
-export const pg004: Rule = {
-  id: RULE.EM_DASH,
-  category: "punctuation",
-  summary: "em-dash U+2014 in prose",
-  check: ({ doc, file }) =>
-    doc.texts
-      .filter((t) => t.value.includes("—"))
-      .map((t) => ({
-        file,
-        line: t.line,
-        rule: RULE.EM_DASH,
-        message: "em-dash in prose; use comma, colon, parentheses, or two sentences",
-      })),
-  fix,
-};

package/src/rules/pg005-interpunct.ts

@@ -1,43 +0,0 @@
-// PG005: a stray interpunct in prose. One inside a reported run is left to
-// PG006 or PG009. The fix swaps a spaced interpunct for a comma; a glyph
-// with no space on either side (a product name, a unit) is left alone.
-
-import { matchesIn } from "../fix/spans.ts";
-import { type DocModel, inRanges } from "../model.ts";
-import { interpunctRuns } from "./interpunct.ts";
-import { type Edit, RULE, type Rule } from "./types.ts";
-
-const fix = (doc: DocModel): Edit[] => {
-  const runs = interpunctRuns(doc).map((r) => r.range);
-  const edits: Edit[] = [];
-  for (const t of doc.texts) {
-    if (t.start === undefined || t.end === undefined || !t.value.includes("·")) continue;
-    if (inRanges(t.start, runs)) continue;
-    const text = { value: t.value, start: t.start, end: t.end };
-    const glyphs = matchesIn(doc.src, text, /·/);
-    const spaced = matchesIn(doc.src, text, /[ \t]+·[ \t]+/);
-    if (glyphs === null || spaced === null || glyphs.length !== spaced.length) continue;
-    for (const [start, end] of spaced) {
-      edits.push({ rule: RULE.INTERPUNCT, start, end, text: ", ", expect: { kind: "same-shape" } });
-    }
-  }
-  return edits;
-};
-
-export const pg005: Rule = {
-  id: RULE.INTERPUNCT,
-  category: "punctuation",
-  summary: "interpunct U+00B7 in prose",
-  check: ({ doc, file, runs }) => {
-    const suppressed = runs.map((r) => r.range);
-    return doc.texts
-      .filter((t) => t.value.includes("·") && !(t.offset != null && inRanges(t.offset, suppressed)))
-      .map((t) => ({
-        file,
-        line: t.line,
-        rule: RULE.INTERPUNCT,
-        message: "interpunct in prose; use a comma, slash, or a list",
-      }));
-  },
-  fix,
-};

package/src/rules/pg006-interpunct-run.ts

@@ -1,84 +0,0 @@
-// PG006: a single-line interpunct-joined run is a disguised flat list. The
-// fix promotes it to bullets, taking a colon before the run as the lead-in.
-// Without a colon the run must be the whole paragraph, or there is no way to
-// tell where the first item starts.
-
-import { cleanItem, cleanLeadIn, promote } from "../fix/promote.ts";
-import { escaped, matchesInAll, sentenceSpan, within } from "../fix/spans.ts";
-import type { DocModel, Range } from "../model.ts";
-import { interpunctRuns } from "./interpunct.ts";
-import { type Edit, RULE, type Rule } from "./types.ts";
-
-// A last item this much longer than every other is a sentence that happens
-// to follow the list, not a member of it. Without a colon, a first item
-// longer than the rest ("Built with Bun") carries a clause the list would
-// strip of its meaning.
-const words = (s: string): number => s.split(/\s+/).filter(Boolean).length;
-const tailIsProse = (items: string[]): boolean => {
-  const last = words(items[items.length - 1] ?? "");
-  const others = Math.max(...items.slice(0, -1).map(words));
-  return last > Math.max(8, 3 * others);
-};
-const headIsProse = (items: string[]): boolean => {
-  const first = words(items[0] ?? "");
-  return first > Math.max(...items.slice(1).map(words));
-};
-
-const fix = (doc: DocModel): Edit[] => {
-  const { src } = doc;
-  const edits: Edit[] = [];
-  const runs = interpunctRuns(doc).filter((r) => r.lines === 1);
-  for (const view of doc.paragraphs) {
-    if (!runs.some((r) => r.range[0] === view.startOffset)) continue;
-    const seps = matchesInAll(src, view.directTexts, /[ \t]*·[ \t]*/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
-    // Every separator the check counted must be one a fixer can split on.
-    if (
-      seps === null ||
-      colons === null ||
-      seps.length !== (view.prose.match(/·/g) ?? []).length ||
-      seps.some(([s]) => escaped(src, s))
-    )
-      continue;
-    const first = seps[0] as Range;
-    const last = seps[seps.length - 1] as Range;
-    const span = sentenceSpan(src, view, first[0], last[1]);
-    const colon = colons.filter((c) => within(c, span) && c[1] <= first[0]).pop();
-    if (!colon && (span[0] !== view.startOffset || span[1] !== view.endOffset)) continue;
-
-    const cuts: Range[] = [colon ?? [span[0], span[0]], ...seps];
-    const items = cuts.map((cut, i) => {
-      const end = i + 1 < cuts.length ? (cuts[i + 1] as Range)[0] : span[1];
-      return cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length });
-    });
-    if (tailIsProse(items) || (!colon && headIsProse(items))) continue;
-
-    const edit = promote({
-      rule: RULE.INTERPUNCT_RUN,
-      src,
-      view,
-      span,
-      leadIn: colon ? cleanLeadIn(src.slice(span[0], colon[0])) : null,
-      items: items.map((text) => ({ text })),
-      ordered: false,
-    });
-    if (edit) edits.push(edit);
-  }
-  return edits;
-};
-
-export const pg006: Rule = {
-  id: RULE.INTERPUNCT_RUN,
-  category: "list",
-  summary: "interpunct-joined inline list (2+ separators)",
-  check: ({ file, runs }) =>
-    runs
-      .filter((r) => r.lines < 2)
-      .map((r) => ({
-        file,
-        line: r.line,
-        rule: RULE.INTERPUNCT_RUN,
-        message: `interpunct-joined inline list (${r.separators + 1} items); promote to a bullet list`,
-      })),
-  fix,
-};

package/src/rules/pg007-inline-enum.ts

@@ -1,119 +0,0 @@
-// PG007: parenthesised enumerators inlined in one paragraph are a hidden
-// list. Requiring the first two members of a family keeps citations and a
-// lone "(a)" reference from firing. The fix only trusts a clean sequence:
-// every marker in order, none skipped, none from another family.
-
-import { cleanItem, cleanLeadIn, promote } from "../fix/promote.ts";
-import { sentenceSpan } from "../fix/spans.ts";
-import type { DocModel, Range } from "../model.ts";
-import { type Edit, type Finding, RULE, type Rule } from "./types.ts";
-
-const ENUM_FAMILIES: Array<[string, string]> = [
-  ["(a)", "(b)"],
-  ["(1)", "(2)"],
-  ["(i)", "(ii)"],
-];
-
-const ROMAN = ["i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x", "xi", "xii"];
-const LETTERS = [..."abcdefghijklmnopqrstuvwxyz"];
-
-// The expected nth marker for the family the first marker opens.
-const sequenceFor = (first: string): string[] | null => {
-  if (first === "a") return LETTERS;
-  if (first === "1") return Array.from({ length: 99 }, (_, i) => String(i + 1));
-  if (first === "i") return ROMAN;
-  return null;
-};
-
-const MARKER = /\(([a-z]|[ivx]+|\d{1,2})\)(?=\s)/g;
-
-interface Marker {
-  range: Range;
-  label: string;
-}
-
-// Markers that open an item: preceded by whitespace or the start of a direct
-// text node, and followed by whitespace. The parsed value must agree with the
-// source, or an escape is hiding somewhere and the fixer refuses.
-const markersIn = (src: string, texts: DocModel["paragraphs"][number]["directTexts"]): Marker[] | null => {
-  const out: Marker[] = [];
-  for (const t of texts) {
-    const slice = src.slice(t.start, t.end);
-    const opening = (s: string): RegExpMatchArray[] =>
-      [...s.matchAll(MARKER)].filter((m) => (m.index ?? 0) === 0 || /\s/.test(s[(m.index ?? 0) - 1] as string));
-    const inSlice = opening(slice);
-    if (inSlice.length !== opening(t.value).length) return null;
-    for (const m of inSlice) {
-      const start = t.start + (m.index ?? 0);
-      out.push({ range: [start, start + m[0].length], label: m[1] as string });
-    }
-  }
-  return out;
-};
-
-const fix = (doc: DocModel): Edit[] => {
-  const { src } = doc;
-  const edits: Edit[] = [];
-  for (const view of doc.paragraphs) {
-    const markers = markersIn(src, view.directTexts);
-    if (markers === null || markers.length < 2) continue;
-    const sequence = sequenceFor((markers[0] as Marker).label);
-    if (sequence === null || markers.some((m, i) => m.label !== sequence[i])) continue;
-
-    const first = markers[0] as Marker;
-    const last = markers[markers.length - 1] as Marker;
-    // Markers split across sentences are two references, not one list.
-    const between = view.directTexts.map((t) =>
-      src.slice(Math.max(t.start, first.range[1]), Math.min(t.end, last.range[0])),
-    );
-    if (between.some((s) => /[.!?]\s/.test(s))) continue;
-    const span = sentenceSpan(src, view, first.range[0], last.range[1]);
-    // Two markers joined only by a conjunction, with no colon to announce
-    // them, read as cross-references ("see (a) above and (b) below").
-    const announced = /:\s*$/.test(src.slice(span[0], first.range[0]));
-    const separated = /[,;]\s*$/.test(src.slice((markers[0] as Marker).range[1], (markers[1] as Marker).range[0]));
-    if (markers.length === 2 && !announced && !separated) continue;
-    const items = markers.map((m, i) => {
-      const end = i + 1 < markers.length ? (markers[i + 1] as Marker).range[0] : span[1];
-      return { text: cleanItem(src.slice(m.range[1], end), { last: i + 1 === markers.length }) };
-    });
-    const edit = promote({
-      rule: RULE.INLINE_ENUM,
-      src,
-      view,
-      span,
-      leadIn: cleanLeadIn(src.slice(span[0], first.range[0])),
-      items,
-      ordered: true,
-    });
-    if (edit) edits.push(edit);
-  }
-  return edits;
-};
-
-const check: Rule["check"] = ({ doc, file }) => {
-  const findings: Finding[] = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable) continue;
-    for (const [first, second] of ENUM_FAMILIES) {
-      if (p.prose.includes(first) && p.prose.includes(second)) {
-        findings.push({
-          file,
-          line: p.line,
-          rule: RULE.INLINE_ENUM,
-          message: `enumeration ${first} ${second} ... inlined in prose; promote to a bullet list`,
-        });
-        break;
-      }
-    }
-  }
-  return findings;
-};
-
-export const pg007: Rule = {
-  id: RULE.INLINE_ENUM,
-  category: "list",
-  summary: "enumeration markers (a)/(b) or (1)/(2) inlined in prose",
-  check,
-  fix,
-};

package/src/rules/pg008-labelled-run.ts

@@ -1,94 +0,0 @@
-// PG008: one sentence stringing 3+ comma-separated segments each led by a
-// label (an inline-code span, or an identifier like PG001 / MD025 / S4)
-// WITH content after it is a hidden list of labelled items. Bare labels
-// ("A, B, and C are interchangeable") are a subject enumeration, not a
-// list. An optional "Rules: " style intro on the first segment, and a
-// joining "and"/"or", are tolerated.
-//
-// The check counts labelled segments; the fix is stricter and needs every
-// segment of the sentence to be one, so no stray clause becomes a bullet.
-
-import { cleanItem, cleanLeadIn, promote } from "../fix/promote.ts";
-import { collapse, matchesInAll, sentenceSpans, within } from "../fix/spans.ts";
-import { type DocModel, type ParagraphView, type Range, sentences } from "../model.ts";
-import { type Edit, type Finding, RULE, type Rule } from "./types.ts";
-
-const LABELLED_SEGMENT = /^(?:and\s+|or\s+)?(?:[A-Za-z][\w\s-]{0,24}:\s*)?(?:CODE|[A-Z][A-Za-z]*\d[\w/-]*)\s+\S/;
-
-// A source slice as the check sees it: code spans become one CODE token.
-const asProse = (src: string, view: ParagraphView, range: Range): string => {
-  let out = "";
-  let at = range[0];
-  for (const [a, b] of view.codeRanges) {
-    if (b <= range[0] || a >= range[1]) continue;
-    out += `${src.slice(at, a)}CODE`;
-    at = b;
-  }
-  return collapse(out + src.slice(at, range[1])).trim();
-};
-
-const fix = (doc: DocModel): Edit[] => {
-  const { src } = doc;
-  const edits: Edit[] = [];
-  for (const view of doc.paragraphs) {
-    const commas = matchesInAll(src, view.directTexts, /,(?=\s)/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
-    if (commas === null || colons === null) continue;
-    for (const span of sentenceSpans(src, view)) {
-      const inside = commas.filter((r) => within(r, span));
-      if (inside.length < 2) continue;
-      const bounds: Range[] = inside.map((c, i) => [i === 0 ? span[0] : (inside[i - 1] as Range)[1], c[0]]);
-      bounds.push([(inside[inside.length - 1] as Range)[1], span[1]]);
-      if (!bounds.every((b) => LABELLED_SEGMENT.test(asProse(src, view, b)))) continue;
-
-      // An intro colon in the first segment, before its label, is the lead-in.
-      const firstBound = bounds[0] as Range;
-      const colon = colons.find((c) => within(c, firstBound));
-      const intro = colon && /^[A-Za-z][\w\s-]{0,24}$/.test(collapse(src.slice(span[0], colon[0])).trim());
-      if (intro && colon) firstBound[0] = colon[1];
-
-      const items = bounds.map((b, i) => ({
-        text: cleanItem(src.slice(b[0], b[1]), { last: i + 1 === bounds.length }),
-      }));
-      const edit = promote({
-        rule: RULE.LABELLED_RUN,
-        src,
-        view,
-        span,
-        leadIn: intro && colon ? cleanLeadIn(src.slice(span[0], colon[0])) : null,
-        items,
-        ordered: false,
-      });
-      if (edit) edits.push(edit);
-      break;
-    }
-  }
-  return edits;
-};
-
-const check: Rule["check"] = ({ doc, file }) => {
-  const findings: Finding[] = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable) continue;
-    for (const s of sentences(p.prose)) {
-      const labelled = s.split(/,\s+/).filter((seg) => LABELLED_SEGMENT.test(seg)).length;
-      if (labelled >= 3) {
-        findings.push({
-          file,
-          line: p.line,
-          rule: RULE.LABELLED_RUN,
-          message: `comma-joined run of ${labelled} labelled items; promote to a bullet list`,
-        });
-      }
-    }
-  }
-  return findings;
-};
-
-export const pg008: Rule = {
-  id: RULE.LABELLED_RUN,
-  category: "list",
-  summary: "comma-joined labelled run (3+ labelled segments)",
-  check,
-  fix,
-};

package/src/rules/pg009-stacked-runs.ts

@@ -1,79 +0,0 @@
-// PG009: interpunct runs stacked on 2+ source lines of one paragraph are a
-// two-level structure, so PG009 replaces PG006 for that paragraph. The fix
-// needs every line to read `Label: a · b · c`, and builds one parent bullet
-// per label with the items nested beneath it.
-
-import { cleanItem, type PromotedItem, promote } from "../fix/promote.ts";
-import { collapse, escaped, matchesInAll, within } from "../fix/spans.ts";
-import type { DocModel, Range } from "../model.ts";
-import { interpunctRuns } from "./interpunct.ts";
-import { type Edit, RULE, type Rule } from "./types.ts";
-
-const fix = (doc: DocModel): Edit[] => {
-  const { src } = doc;
-  const edits: Edit[] = [];
-  const runs = interpunctRuns(doc).filter((r) => r.lines >= 2);
-  for (const view of doc.paragraphs) {
-    if (!runs.some((r) => r.range[0] === view.startOffset)) continue;
-    const seps = matchesInAll(src, view.directTexts, /[ \t]*·[ \t]*/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
-    if (
-      seps === null ||
-      colons === null ||
-      seps.length !== (view.prose.match(/·/g) ?? []).length ||
-      seps.some(([s]) => escaped(src, s))
-    )
-      continue;
-
-    // Source lines of the paragraph, as absolute ranges.
-    const lines: Range[] = [];
-    let at = view.startOffset;
-    for (const line of view.raw.split("\n")) {
-      lines.push([at, at + line.length]);
-      at += line.length + 1;
-    }
-
-    const parents: PromotedItem[] = [];
-    for (const line of lines) {
-      const lineSeps = seps.filter((s) => within(s, line));
-      const colon = colons.find((c) => within(c, line));
-      if (lineSeps.length === 0 || !colon || colon[1] > (lineSeps[0] as Range)[0]) break;
-      const label = collapse(src.slice(line[0], colon[0])).trim();
-      const cuts: Range[] = [colon, ...lineSeps];
-      const children = cuts.map((cut, i) => {
-        const end = i + 1 < cuts.length ? (cuts[i + 1] as Range)[0] : line[1];
-        return cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length });
-      });
-      parents.push({ text: label, children });
-    }
-    if (parents.length !== lines.length) continue;
-
-    const edit = promote({
-      rule: RULE.STACKED_RUNS,
-      src,
-      view,
-      span: [view.startOffset, view.endOffset],
-      leadIn: null,
-      items: parents,
-      ordered: false,
-    });
-    if (edit) edits.push(edit);
-  }
-  return edits;
-};
-
-export const pg009: Rule = {
-  id: RULE.STACKED_RUNS,
-  category: "list",
-  summary: "interpunct runs stacked on several lines (nested list)",
-  check: ({ file, runs }) =>
-    runs
-      .filter((r) => r.lines >= 2)
-      .map((r) => ({
-        file,
-        line: r.line,
-        rule: RULE.STACKED_RUNS,
-        message: `interpunct runs stacked on ${r.lines} lines; promote to a nested list`,
-      })),
-  fix,
-};