versionary 0.3.0 → 0.5.0

package/dist/domain/strategy/rust.js

@@ -0,0 +1,477 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustVersionStrategy = void 0;
+exports.applyRustWorkspaceDependencyUpdates = applyRustWorkspaceDependencyUpdates;
+exports.detectRustDependencyImpact = detectRustDependencyImpact;
+exports.toCargoManifestPath = toCargoManifestPath;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const toml_1 = __importDefault(require("@iarna/toml"));
+const ROOT_DEPENDENCY_SECTIONS = new Set([
+    "dependencies",
+    "dev-dependencies",
+    "build-dependencies",
+]);
+function normalizeSlashPath(input) {
+    return input.replaceAll("\\", "/");
+}
+function hasGlobPattern(pattern) {
+    return /[*?]/u.test(pattern);
+}
+function escapeRegex(input) {
+    return input.replace(/[.+^${}()|\\]/gu, "\\$&");
+}
+function globToRegex(pattern) {
+    const normalized = normalizeSlashPath(pattern);
+    let source = "^";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const current = normalized[index] ?? "";
+        const next = normalized[index + 1] ?? "";
+        if (current === "*" && next === "*") {
+            source += ".*";
+            index += 1;
+            continue;
+        }
+        if (current === "*") {
+            source += "[^/]*";
+            continue;
+        }
+        if (current === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += escapeRegex(current);
+    }
+    source += "$";
+    return new RegExp(source, "u");
+}
+function findCargoManifestDirectories(rootDir) {
+    const results = new Set();
+    const queue = [rootDir];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = node_fs_1.default.readdirSync(currentDir, {
+            withFileTypes: true,
+        });
+        let hasCargoManifest = false;
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isFile() && entry.name === "Cargo.toml") {
+                hasCargoManifest = true;
+                continue;
+            }
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+        }
+        if (hasCargoManifest) {
+            const rel = normalizeSlashPath(node_path_1.default.relative(rootDir, currentDir));
+            results.add(rel === "" ? "." : rel);
+        }
+    }
+    return [...results].sort((a, b) => a.localeCompare(b));
+}
+function collectAllCrateManifests(cwd) {
+    const manifests = [];
+    const cargoDirs = findCargoManifestDirectories(cwd);
+    for (const dir of cargoDirs) {
+        const manifest = dir === "."
+            ? "Cargo.toml"
+            : normalizeSlashPath(node_path_1.default.posix.join(dir, "Cargo.toml"));
+        const manifestPath = node_path_1.default.join(cwd, manifest);
+        if (!node_fs_1.default.existsSync(manifestPath)) {
+            continue;
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        if (!isCrateManifest(manifest, cargoTomlRaw)) {
+            continue;
+        }
+        manifests.push(manifest);
+    }
+    return manifests.sort((a, b) => a.localeCompare(b));
+}
+function parseCargoManifest(versionFile, cargoTomlRaw) {
+    let parsed;
+    try {
+        parsed = toml_1.default.parse(cargoTomlRaw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse ${versionFile}: ${message}`);
+    }
+    const parsedRecord = parsed;
+    const packageTable = parsedRecord.package && typeof parsedRecord.package === "object"
+        ? parsedRecord.package
+        : null;
+    const workspaceTable = parsedRecord.workspace && typeof parsedRecord.workspace === "object"
+        ? parsedRecord.workspace
+        : null;
+    return { packageTable, workspaceTable };
+}
+function isCrateManifest(versionFile, cargoTomlRaw) {
+    const parsed = parseCargoManifest(versionFile, cargoTomlRaw);
+    return parsed.packageTable !== null;
+}
+function readWorkspaceMemberPatterns(workspaceTable) {
+    if (!workspaceTable) {
+        return [];
+    }
+    const members = workspaceTable.members;
+    if (!Array.isArray(members)) {
+        return [];
+    }
+    return members
+        .filter((member) => typeof member === "string")
+        .map((member) => normalizeSlashPath(member.trim()))
+        .filter((member) => member.length > 0);
+}
+function readWorkspaceExcludes(workspaceTable) {
+    if (!workspaceTable) {
+        return [];
+    }
+    const excludes = workspaceTable.exclude;
+    if (!Array.isArray(excludes)) {
+        return [];
+    }
+    return excludes
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => normalizeSlashPath(entry.trim()))
+        .filter((entry) => entry.length > 0);
+}
+function resolveWorkspaceMemberManifests(rootDir, workspaceTable) {
+    const memberPatterns = readWorkspaceMemberPatterns(workspaceTable);
+    if (memberPatterns.length === 0) {
+        return [];
+    }
+    const excludes = readWorkspaceExcludes(workspaceTable);
+    const excludeRegexes = excludes.map((pattern) => globToRegex(pattern));
+    const cargoDirs = findCargoManifestDirectories(rootDir);
+    const manifests = new Set();
+    for (const pattern of memberPatterns) {
+        if (hasGlobPattern(pattern)) {
+            const regex = globToRegex(pattern);
+            for (const dir of cargoDirs) {
+                if (regex.test(dir)) {
+                    manifests.add(normalizeSlashPath(node_path_1.default.posix.join(dir, "Cargo.toml")));
+                }
+            }
+            continue;
+        }
+        const candidateDir = normalizeSlashPath(pattern);
+        if (excludeRegexes.some((regex) => regex.test(candidateDir))) {
+            continue;
+        }
+        const cargoPath = node_path_1.default.join(rootDir, candidateDir, "Cargo.toml");
+        if (node_fs_1.default.existsSync(cargoPath)) {
+            manifests.add(normalizeSlashPath(node_path_1.default.posix.join(candidateDir, "Cargo.toml")));
+        }
+    }
+    const filtered = [...manifests].filter((manifestPath) => {
+        const dir = normalizeSlashPath(node_path_1.default.posix.dirname(manifestPath));
+        return !excludeRegexes.some((regex) => regex.test(dir));
+    });
+    return filtered.sort((a, b) => a.localeCompare(b));
+}
+function collectRustTargetManifests(cwd, versionFile, includeWorkspaceMembers) {
+    if (node_path_1.default.basename(versionFile) !== "Cargo.toml") {
+        throw new Error(`Rust strategy requires "version-file" to point to a Cargo.toml manifest (received "${versionFile}").`);
+    }
+    const rootManifestPath = node_path_1.default.join(cwd, versionFile);
+    if (!node_fs_1.default.existsSync(rootManifestPath)) {
+        throw new Error(`Versionary requires ${versionFile} to exist.`);
+    }
+    const rootRaw = node_fs_1.default.readFileSync(rootManifestPath, "utf8");
+    const parsedRoot = parseCargoManifest(versionFile, rootRaw);
+    const rootIsCrate = parsedRoot.packageTable !== null;
+    const rootDir = node_path_1.default.dirname(rootManifestPath);
+    const workspaceMembers = includeWorkspaceMembers
+        ? resolveWorkspaceMemberManifests(rootDir, parsedRoot.workspaceTable)
+        : [];
+    if (rootIsCrate) {
+        const relRoot = normalizeSlashPath(node_path_1.default.relative(cwd, rootManifestPath));
+        return [...new Set([relRoot, ...workspaceMembers])].sort((a, b) => a.localeCompare(b));
+    }
+    if (workspaceMembers.length > 0) {
+        return workspaceMembers;
+    }
+    throw new Error(`Configured rust target "${versionFile}" is not a Rust crate manifest. Expected [package].version or [workspace].members with crate Cargo.toml files.`);
+}
+function readCargoVersion(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    const rawVersion = packageTable.version;
+    if (rawVersion === undefined) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    if (typeof rawVersion !== "string" || rawVersion.trim().length === 0) {
+        throw new Error(`${versionFile} has invalid [package].version. Expected a non-empty SemVer string.`);
+    }
+    return rawVersion.trim();
+}
+function readCargoPackageName(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        throw new Error(`${versionFile} is missing [package].name. Add [package] with a crate name.`);
+    }
+    const rawName = packageTable.name;
+    if (typeof rawName !== "string" || rawName.trim().length === 0) {
+        throw new Error(`${versionFile} has invalid [package].name. Expected a non-empty crate name.`);
+    }
+    return rawName.trim();
+}
+function writeCargoVersion(cargoTomlRaw, versionFile, version) {
+    const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
+    const lines = cargoTomlRaw.split(/\r?\n/u);
+    let inPackageSection = false;
+    let foundPackageSection = false;
+    let replacedVersion = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            const section = sectionMatch[1]?.trim();
+            inPackageSection = section === "package";
+            if (inPackageSection) {
+                foundPackageSection = true;
+            }
+            continue;
+        }
+        if (!inPackageSection) {
+            continue;
+        }
+        const versionMatch = line.match(/^(\s*version\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+        if (!versionMatch) {
+            continue;
+        }
+        const [, prefix = "", quote = '"', , , suffix = ""] = versionMatch;
+        lines[index] = `${prefix}${quote}${version}${quote}${suffix}`;
+        replacedVersion = true;
+        break;
+    }
+    if (!foundPackageSection) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    if (!replacedVersion) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+function isDependencySection(section) {
+    if (ROOT_DEPENDENCY_SECTIONS.has(section)) {
+        return true;
+    }
+    if (!section.startsWith("target.")) {
+        return false;
+    }
+    return (section.endsWith(".dependencies") ||
+        section.endsWith(".dev-dependencies") ||
+        section.endsWith(".build-dependencies"));
+}
+function parseDependencyName(line) {
+    const match = line.match(/^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*=/u);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function writeInternalDependencyVersionInLine(line, dependencyName, versionByDependency) {
+    const nextVersion = versionByDependency.get(dependencyName);
+    if (!nextVersion) {
+        return line;
+    }
+    const stringVersionMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+    if (stringVersionMatch) {
+        const [, prefix = "", quote = '"', , , suffix = ""] = stringVersionMatch;
+        return `${prefix}${quote}${nextVersion}${quote}${suffix}`;
+    }
+    const inlineTableMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*\{)(.*)(\}\s*(?:#.*)?)$/u);
+    if (!inlineTableMatch) {
+        return line;
+    }
+    const [, prefix = "", tableBody = "", suffix = ""] = inlineTableMatch;
+    const updatedTableBody = tableBody.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, `$1$2${nextVersion}$4`);
+    if (updatedTableBody === tableBody) {
+        return line;
+    }
+    return `${prefix}${updatedTableBody}${suffix}`;
+}
+function writeInternalDependencyVersions(cargoTomlRaw, internalCrates, version) {
+    if (internalCrates.size === 0) {
+        return cargoTomlRaw;
+    }
+    const versionByDependency = new Map();
+    for (const crateName of internalCrates) {
+        versionByDependency.set(crateName, version);
+    }
+    return writeMappedDependencyVersions(cargoTomlRaw, versionByDependency);
+}
+function writeMappedDependencyVersions(cargoTomlRaw, versionByDependency) {
+    if (versionByDependency.size === 0) {
+        return cargoTomlRaw;
+    }
+    const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
+    const lines = cargoTomlRaw.split(/\r?\n/u);
+    let currentSection = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1]?.trim() ?? null;
+            continue;
+        }
+        if (!currentSection || !isDependencySection(currentSection)) {
+            continue;
+        }
+        const dependencyName = parseDependencyName(line);
+        if (!dependencyName) {
+            continue;
+        }
+        lines[index] = writeInternalDependencyVersionInLine(line, dependencyName, versionByDependency);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+function readPackageNameForManifest(cwd, manifest) {
+    const manifestPath = node_path_1.default.join(cwd, manifest);
+    const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+    if (!isCrateManifest(manifest, cargoTomlRaw)) {
+        throw new Error(`Configured rust target "${manifest}" is not a Rust crate manifest to update.`);
+    }
+    return readCargoPackageName(cargoTomlRaw, manifest);
+}
+function applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion) {
+    const versionByDependency = new Map();
+    for (const [manifest, version] of Object.entries(manifestToVersion)) {
+        if (!version) {
+            continue;
+        }
+        const crateName = readPackageNameForManifest(cwd, manifest);
+        versionByDependency.set(crateName, version);
+    }
+    if (versionByDependency.size === 0) {
+        return [];
+    }
+    const updatedFiles = [];
+    const manifests = collectAllCrateManifests(cwd);
+    for (const manifest of manifests) {
+        const manifestPath = node_path_1.default.join(cwd, manifest);
+        if (!node_fs_1.default.existsSync(manifestPath)) {
+            continue;
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        if (!isCrateManifest(manifest, cargoTomlRaw)) {
+            continue;
+        }
+        const next = writeMappedDependencyVersions(cargoTomlRaw, versionByDependency);
+        if (next !== cargoTomlRaw) {
+            node_fs_1.default.writeFileSync(manifestPath, next, "utf8");
+            updatedFiles.push(manifest);
+        }
+    }
+    return updatedFiles;
+}
+function detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests) {
+    const versionByDependency = new Map();
+    for (const [manifest, version] of Object.entries(manifestToVersion)) {
+        if (!version) {
+            continue;
+        }
+        const crateName = readPackageNameForManifest(cwd, manifest);
+        versionByDependency.set(crateName, version);
+    }
+    if (versionByDependency.size === 0) {
+        return [];
+    }
+    const impacted = [];
+    for (const manifest of [...new Set(candidateManifests)].sort((a, b) => a.localeCompare(b))) {
+        const manifestPath = node_path_1.default.join(cwd, manifest);
+        if (!node_fs_1.default.existsSync(manifestPath)) {
+            continue;
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        if (!isCrateManifest(manifest, cargoTomlRaw)) {
+            continue;
+        }
+        const next = writeMappedDependencyVersions(cargoTomlRaw, versionByDependency);
+        if (next !== cargoTomlRaw) {
+            impacted.push(manifest);
+        }
+    }
+    return impacted;
+}
+function toCargoManifestPath(packagePath) {
+    return packagePath === "."
+        ? "Cargo.toml"
+        : normalizeSlashPath(node_path_1.default.posix.join(packagePath, "Cargo.toml"));
+}
+exports.rustVersionStrategy = {
+    name: "rust",
+    getVersionFile(config) {
+        return config["version-file"] ?? "Cargo.toml";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
+        const selectedManifest = manifests[0];
+        if (!selectedManifest) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, selectedManifest), "utf8");
+        return readCargoVersion(cargoTomlRaw, selectedManifest);
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
+        const updatedFiles = [];
+        const internalCrates = new Set();
+        for (const manifest of manifests) {
+            const versionPath = node_path_1.default.join(cwd, manifest);
+            if (!node_fs_1.default.existsSync(versionPath)) {
+                continue;
+            }
+            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            if (!isCrateManifest(manifest, cargoTomlRaw)) {
+                continue;
+            }
+            internalCrates.add(readCargoPackageName(cargoTomlRaw, manifest));
+        }
+        for (const manifest of manifests) {
+            const versionPath = node_path_1.default.join(cwd, manifest);
+            if (!node_fs_1.default.existsSync(versionPath)) {
+                continue;
+            }
+            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            if (!isCrateManifest(manifest, cargoTomlRaw)) {
+                continue;
+            }
+            readCargoVersion(cargoTomlRaw, manifest);
+            const updatedCargoToml = writeInternalDependencyVersions(writeCargoVersion(cargoTomlRaw, manifest, version), internalCrates, version);
+            node_fs_1.default.writeFileSync(versionPath, updatedCargoToml, "utf8");
+            updatedFiles.push(manifest);
+        }
+        if (updatedFiles.length === 0) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest to update.`);
+        }
+        return updatedFiles.sort((a, b) => a.localeCompare(b));
+    },
+};

package/dist/verify/verify-project.js

@@ -7,6 +7,7 @@ exports.verifyProject = verifyProject;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
+const package_context_js_1 = require("../domain/strategy/package-context.js");
 const resolve_js_1 = require("../domain/strategy/resolve.js");
 function verifyProject(cwd = process.cwd()) {
     const checks = [];
@@ -25,7 +26,7 @@ function verifyProject(cwd = process.cwd()) {
         details: exists ? "Version file exists" : `Missing ${versionFile}`,
     });
     if (config.config.packages) {
-        for (const pkgPathRaw of Object.keys(config.config.packages)) {
+        for (const [pkgPathRaw, packageConfig] of Object.entries(config.config.packages)) {
             const pkgPath = node_path_1.default.join(cwd, pkgPathRaw);
             const exists = node_fs_1.default.existsSync(pkgPath);
             checks.push({
@@ -33,6 +34,18 @@ function verifyProject(cwd = process.cwd()) {
                 ok: exists,
                 details: exists ? "Path exists" : `Missing path: ${pkgPathRaw}`,
             });
+            if (exists) {
+                const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(config.config, pkgPathRaw, packageConfig);
+                const packageVersionFile = packageContext.versionFile;
+                const packageVersionExists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, packageVersionFile));
+                checks.push({
+                    name: `version-file:${packageVersionFile}`,
+                    ok: packageVersionExists,
+                    details: packageVersionExists
+                        ? "Version file exists"
+                        : `Missing ${packageVersionFile}`,
+                });
+            }
         }
     }
     const ok = checks.every((c) => c.ok);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -27,9 +27,10 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@octokit/rest": "^22.0.0",
     "@iarna/toml": "^2.2.5",
+    "@octokit/rest": "^22.0.0",
     "jsonc-parser": "^3.3.1",
+    "yaml": "^2.8.3",
     "zod": "^4.1.12"
   },
   "devDependencies": {