@tallyrelease/core 0.2.0 → 0.3.0

package/dist/version-files.js

@@ -0,0 +1,247 @@
+import { changelogPath, changelogSection, updateChangelog, } from "./changelog.js";
+import { normalizeRoot } from "./discover.js";
+import { TallyError } from "./errors.js";
+import { runHook } from "./plugins.js";
+import { schemeRegistry } from "./schemes.js";
+const TOKEN = /\{([^{}]*)\}/gu;
+const SPECIAL = /[\\^$.*+?()[\]{}|/]/gu;
+const CORE_TOKENS = ["major", "minor", "patch"];
+const VERSION = "\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?";
+const ALNUM = /[0-9A-Za-z]/u;
+const escape = (text) => text.replace(SPECIAL, "\\$&");
+const configError = (pattern, unit, problem) => new TallyError("E_CONFIG", `version file pattern "${pattern}" of unit "${unit}" ${problem}`, { unit, pattern });
+/**
+ * Compiles a template pattern: literal parts escaped, `{id}` literal, version
+ * tokens captured. An edge that is a token or an alphanumeric literal must not
+ * touch another alphanumeric, and the end must not be followed by `.<digit>`.
+ * Throws `E_CONFIG` for an unknown token, no version token, `{version}` mixed
+ * with `{major}`, `{minor}` or `{patch}` (their values could disagree), or no
+ * literal text.
+ */
+const compileTemplate = (pattern, unit) => {
+    const tokens = [];
+    let source = "";
+    let literal = false;
+    let last = 0;
+    for (const m of pattern.matchAll(TOKEN)) {
+        const text = pattern.slice(last, m.index);
+        literal ||= text !== "";
+        source += escape(text);
+        last = m.index + m[0].length;
+        const token = m[1] ?? "";
+        if (token === "id") {
+            source += escape(unit);
+        }
+        else if (token === "version") {
+            tokens.push(token);
+            source += `(${VERSION})`;
+        }
+        else if (CORE_TOKENS.includes(token)) {
+            tokens.push(token);
+            source += "(\\d+)";
+        }
+        else {
+            throw configError(pattern, unit, `uses unknown token "${m[0]}"; use {id}, {version}, {major}, {minor} or {patch}`);
+        }
+    }
+    const tail = pattern.slice(last);
+    literal ||= tail !== "";
+    source += escape(tail);
+    if (tokens.length === 0) {
+        throw configError(pattern, unit, "has no version token");
+    }
+    if (tokens.includes("version") && tokens.some((t) => t !== "version")) {
+        throw configError(pattern, unit, "mixes {version} with {major}, {minor} or {patch}");
+    }
+    if (!literal) {
+        throw configError(pattern, unit, "has no literal text");
+    }
+    const bounded = (edge, brace) => edge === brace || ALNUM.test(edge ?? "");
+    const before = bounded(pattern.at(0), "{") ? "(?<![0-9A-Za-z])" : "";
+    const after = bounded(pattern.at(-1), "}")
+        ? "(?![0-9A-Za-z]|\\.\\d)"
+        : "(?!\\.\\d)";
+    return { re: new RegExp(`${before}${source}${after}`, "gu"), tokens };
+};
+/**
+ * Replaces each match of `pattern` whose captured values render a version `v`
+ * with `from <= v < next` (compared over the tokens present) by the rendering
+ * of `next`. `hit` is false when the pattern matches nothing.
+ */
+const applyTemplate = (content, { pattern, unit, from, next, scheme, }) => {
+    const { re, tokens } = compileTemplate(pattern, unit);
+    const low = scheme.parse(from);
+    const high = scheme.parse(next);
+    if (low === undefined || high === undefined) {
+        throw new Error(`"${from}" or "${next}" is not a version of the scheme`);
+    }
+    const present = CORE_TOKENS.filter((t) => tokens.includes(t));
+    const key = (v) => present.map((t) => scheme.core(v)[t]);
+    const compareKeys = (a, b) => a.reduce((c, n, i) => c || n - (b[i] ?? 0), 0);
+    const rendered = pattern.replace(TOKEN, (_, token) => token === "id"
+        ? unit
+        : token === "version"
+            ? next
+            : String(scheme.core(high)[token]));
+    let hit = false;
+    const replaced = content.replace(re, (match, ...groups) => {
+        const values = new Map();
+        for (const [i, token] of tokens.entries()) {
+            const value = String(groups[i]);
+            if ((values.get(token) ?? value) !== value) {
+                return match;
+            }
+            values.set(token, value);
+        }
+        const raw = values.get("version");
+        const v = raw === undefined ? undefined : scheme.parse(raw);
+        if (raw !== undefined && v === undefined) {
+            return match;
+        }
+        hit = true;
+        const found = () => present.map((t) => Number(values.get(t)));
+        const inRange = v === undefined
+            ? compareKeys(found(), key(low)) >= 0 &&
+                compareKeys(found(), key(high)) < 0
+            : scheme.compare(v, low) >= 0 && scheme.compare(v, high) < 0;
+        return inRange ? rendered : match;
+    });
+    return { content: replaced, hit };
+};
+/** Repo-relative template file; `E_CONFIG` for `.`, absolute or `..` paths. */
+const templateFile = (file, unit) => {
+    const invalid = () => new TallyError("E_CONFIG", `version file "${file}" of unit "${unit}" must be a repo-relative file without ".." segments`, { unit, file });
+    let path;
+    try {
+        path = normalizeRoot(file);
+    }
+    catch {
+        throw invalid();
+    }
+    if (path === ".") {
+        throw invalid();
+    }
+    return path;
+};
+/** Checks template files and patterns (`E_CONFIG`); runs no plugin hook. */
+export const validateTemplates = (workspace) => {
+    for (const [id, templates] of workspace.release.templates) {
+        for (const { file, pattern } of templates) {
+            templateFile(file, id);
+            compileTemplate(pattern, id);
+        }
+    }
+};
+/**
+ * Plugin version files by unit id. Throws `E_VERSION_FILE_CLAIM` when a path
+ * is a plugin version file of two units or also a template. Templates may
+ * share a file.
+ */
+export const versionFileClaims = async (workspace) => {
+    const files = await workspace.versionFiles();
+    const claims = new Map();
+    for (const [id, list] of files) {
+        for (const { path } of list) {
+            const prior = claims.get(path);
+            if (prior !== undefined) {
+                throw new TallyError("E_VERSION_FILE_CLAIM", `version file "${path}" is claimed by units "${prior}" and "${id}"`, { path, units: [prior, id] });
+            }
+            claims.set(path, id);
+        }
+    }
+    for (const [id, templates] of workspace.release.templates) {
+        for (const { file } of templates) {
+            const path = templateFile(file, id);
+            const owner = claims.get(path);
+            if (owner !== undefined) {
+                throw new TallyError("E_VERSION_FILE_CLAIM", `version file template of unit "${id}" targets "${path}", a version file of unit "${owner}"`, { path, units: [owner, id] });
+            }
+        }
+    }
+    return files;
+};
+/**
+ * Files of a release of `items` (stable `next`): plugin version files,
+ * templates and `<root>/CHANGELOG.md` per unit, read through `fs`. Returns
+ * only files whose content changes, and each unit's changelog section;
+ * checks claims first. Templates skip first releases and warn
+ * `W_VERSION_FILE_NO_MATCH` without any match; a missing version file is
+ * `E_VERSION_FILE_MISSING`.
+ */
+export const releaseFiles = async (workspace, plan, opts) => {
+    const { fs, items, repoUrl, date } = opts;
+    const pluginFiles = await versionFileClaims(workspace);
+    const schemes = schemeRegistry(workspace.schemes);
+    const units = new Map(workspace.units.map((u) => [u.id, u]));
+    const planned = new Map(plan.units.map((u) => [u.id, u]));
+    const versions = new Map(items.flatMap((i) => i.units.map((id) => [id, i.version])));
+    const pr = (item) => item.mode === "shared" ? "shared" : item.name;
+    const files = new Map();
+    const sections = new Map();
+    const warnings = [];
+    const read = (path) => files.get(path) ?? fs.read(path);
+    const required = (path, unit) => {
+        const content = read(path);
+        if (content === undefined) {
+            throw new TallyError("E_VERSION_FILE_MISSING", `version file "${path}" of unit "${unit}" does not exist`, { path, unit });
+        }
+        return content;
+    };
+    for (const item of items) {
+        const prUnits = items
+            .filter((i) => pr(i) === pr(item))
+            .flatMap((i) => i.units);
+        for (const id of item.units) {
+            const unit = units.get(id);
+            const entry = planned.get(id);
+            const scheme = unit && schemes.get(unit.scheme);
+            if (!unit || !entry || !scheme) {
+                continue;
+            }
+            const ctx = { unit, units: workspace.units, versions };
+            for (const file of pluginFiles.get(id) ?? []) {
+                const content = required(file.path, id);
+                // eslint-disable-next-line no-await-in-loop -- files are written in order
+                const written = await runHook(unit.plugin, "write", () => file.write(content, item.version, ctx));
+                files.set(file.path, written);
+            }
+            const { from } = entry;
+            const templates = from === null ? [] : (workspace.release.templates.get(id) ?? []);
+            for (const template of templates) {
+                const { pattern } = template;
+                const file = templateFile(template.file, id);
+                const result = applyTemplate(required(file, id), {
+                    pattern,
+                    unit: id,
+                    from: from ?? "",
+                    next: item.version,
+                    scheme,
+                });
+                files.set(file, result.content);
+                if (!result.hit) {
+                    warnings.push({
+                        code: "W_VERSION_FILE_NO_MATCH",
+                        message: `version file pattern "${pattern}" of unit "${id}" matches nothing in "${file}"`,
+                        unit: id,
+                    });
+                }
+            }
+            const section = changelogSection(workspace, plan, {
+                id,
+                repoUrl,
+                date,
+                prUnits,
+            });
+            if (section !== undefined) {
+                sections.set(id, section);
+                const path = changelogPath(unit);
+                files.set(path, updateChangelog(read(path), section, { baseVersion: from, scheme }));
+            }
+        }
+    }
+    return {
+        files: new Map([...files].filter(([path, c]) => fs.read(path) !== c)),
+        sections,
+        warnings,
+    };
+};

package/dist/workspace.d.ts

@@ -1,7 +1,7 @@
 import type { Warning } from "./errors.js";
 import type { Graph } from "./graph.js";
 import type { Group } from "./groups.js";
-import type { IntentSource, Unit } from "./plugin.js";
+import type { IntentSource, Unit, VersionFile } from "./plugin.js";
 import type { PluginEnv } from "./plugins.js";
 import type { ReleaseSettings } from "./release.js";
 import type { SchemeEntry } from "./schemes.js";
@@ -33,6 +33,8 @@ export interface Workspace {
     readonly release: ReleaseSettings;
     /** Fixed groups, sorted by name. */
     readonly groups: readonly Group[];
+    /** Plugin version files of released units by unit id; runs the hooks once. */
+    readonly versionFiles: () => Promise<ReadonlyMap<string, readonly VersionFile[]>>;
 }
 /** Runs plugin hooks sequentially in config order and builds the graph. */
 export declare const loadWorkspace: (input: WorkspaceInput) => Promise<Workspace>;

package/dist/workspace.js

@@ -43,6 +43,29 @@ const collectGlobalInputs = async (active, config, configFile) => {
     }
     return uniqueSorted(globs);
 };
+/**
+ * Plugin version files of released units with version source `file`, by unit
+ * id; hooks run on the first call only.
+ */
+const versionFilesOf = (active, units) => {
+    let files;
+    const collect = async () => {
+        const found = new Map();
+        for (const { plugin, ctx } of active) {
+            const hook = plugin.versionFiles?.bind(plugin);
+            for (const unit of units) {
+                if (!hook || unit.plugin !== plugin.name || unit.version !== "file") {
+                    continue;
+                }
+                // eslint-disable-next-line no-await-in-loop -- hooks run sequentially in config order
+                const list = await runHook(plugin.name, "versionFiles", () => hook(ctx, unit));
+                found.set(unit.id, list);
+            }
+        }
+        return found;
+    };
+    return async () => await (files ??= collect());
+};
 /** Runs plugin hooks sequentially in config order and builds the graph. */
 export const loadWorkspace = async (input) => {
     const warnings = [];
@@ -68,7 +91,8 @@ export const loadWorkspace = async (input) => {
         warnings: [...warnings, ...graph.warnings],
         schemes: collectSchemes(active),
         intents,
-        release: releaseSettings(input.config),
+        release: releaseSettings(input.config, units),
         groups,
+        versionFiles: versionFilesOf(active, units),
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyrelease/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pure planning core of tallyrelease",
   "repository": {
     "type": "git",