rman 2.21.0 → 2.22.0

package/builtins/platforms/node/services/clean.service.js

@@ -119,7 +119,9 @@ async function remove(file, dryRun) {
 function pruneEmptyDirs(dir, includeSelf, dryRun) {
     if (dryRun || !fs.existsSync(dir))
         return;
-    const entries = fg.sync('**', { cwd: dir, onlyDirectories: true, dot: true });
+    /** Not through a link: a link to a directory is not a directory of this one to prune - removing
+     *  it as one is `ENOTDIR`, and walking into it reaches somewhere else entirely. */
+    const entries = fg.sync('**', { cwd: dir, onlyDirectories: true, dot: true, followSymbolicLinks: false });
     entries.sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
     for (const rel of entries) {
         const abs = path.join(dir, rel);
@@ -140,23 +142,48 @@ function pruneEmptyDirs(dir, includeSelf, dryRun) {
  * matching files *inside* an otherwise-deleted directory, leaving the rest of it gone and the
  * protected files (and their now non-empty parent) in place.
  */
+/* **A symbolic link is removed as a link, and never followed.** A build directory routinely holds
+ * one - `build/node_modules/@scope/sibling` pointing at another package's own build - and walking
+ * through it deleted *that* package's output, then failed `rmdir` on the link with `ENOTDIR`.
+ * Measured on `panates/syncbridge`: cleaning `syncbuild` emptied `common/build`, and the run
+ * reported only `0 succeeded, 1 failed`. fast-glob follows links by default, so every glob here
+ * says `followSymbolicLinks: false`. */
 async function cleanGlobs(dirname, include, exclude, dryRun) {
     if (!include.length)
         return [];
-    const matches = await fg(include, { cwd: dirname, ignore: exclude, onlyFiles: false, dot: true, absolute: true });
+    const matches = await fg(include, {
+        cwd: dirname,
+        ignore: exclude,
+        onlyFiles: false,
+        dot: true,
+        absolute: true,
+        followSymbolicLinks: false,
+    });
     const protectedFiles = exclude.length
-        ? new Set(await fg(exclude, { cwd: dirname, onlyFiles: true, dot: true, absolute: true }))
+        ? new Set(await fg(exclude, { cwd: dirname, onlyFiles: true, dot: true, absolute: true, followSymbolicLinks: false }))
         : new Set();
     const removed = [];
     for (const m of matches) {
-        const stat = await fs.promises.stat(m).catch(() => undefined);
+        /** `lstat`, not `stat`: a link is removed as the link it is, and never read as the thing it
+         *  points at. */
+        const stat = await fs.promises.lstat(m).catch(() => undefined);
         if (!stat)
             continue;
         if (stat.isDirectory()) {
-            const filesInside = await fg('**', { cwd: m, onlyFiles: true, dot: true, absolute: true });
-            for (const f of filesInside) {
+            /** Files *and* links inside, and a link never entered - see `cleanGlobs`' own note. */
+            const inside = await fg('**', {
+                cwd: m,
+                onlyFiles: false,
+                dot: true,
+                absolute: true,
+                followSymbolicLinks: false,
+            });
+            for (const f of inside) {
                 if (protectedFiles.has(f))
                     continue;
+                const entry = await fs.promises.lstat(f).catch(() => undefined);
+                if (!entry || entry.isDirectory())
+                    continue;
                 await remove(f, dryRun);
                 removed.push(path.relative(dirname, f));
             }
@@ -208,6 +235,8 @@ async function cleanTsArtifacts(pkg, dryRun) {
         onlyFiles: true,
         dot: true,
         absolute: true,
+        /** A link to a directory elsewhere is not this package's source to sweep. */
+        followSymbolicLinks: false,
     });
     const removed = [];
     for (const f of files) {
@@ -277,6 +306,7 @@ async function cleanTsBuildInfo(dirname, dryRun) {
         onlyFiles: true,
         dot: true,
         absolute: true,
+        followSymbolicLinks: false,
     });
     for (const f of files)
         await remove(f, dryRun);
@@ -310,7 +340,12 @@ async function cleanPackage(pkg, item, panelEnabled, dryRun, logger) {
     }
     catch (e) {
         item.status = 'failed';
-        item.log.push(e?.message ?? String(e));
+        const message = e?.message ?? String(e);
+        item.log.push(message);
+        /** The panel replays `log` in its recap; with no panel nothing does, and the run said only
+         *  `0 succeeded, 1 failed` - which is how the link bug above went unexplained. */
+        if (!panelEnabled)
+            logger.error(colors.red('clean'), colors.cyan(item.name), message);
         throw e;
     }
     finally {

package/commands/list.command.js

@@ -1,6 +1,7 @@
 import colors from 'ansi-colors';
 import EasyTable from 'easy-table';
 import { registerCommand } from '../interfaces/rman-config.interface.js';
+import { fitTable } from '../utils/fit-table.js';
 import { packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
 import { isNamedGroupKey, isSoloGroupKey, ROOT_GROUP_KEY } from '../utils/version-group.js';
 /** `[options...]` is yargs-meaningless - its variadic marker is two dots, and this command declares
@@ -185,7 +186,7 @@ function printTable(items, withRoot) {
         table.cell('Path', it.location);
         table.newRow();
     }
-    console.log(table.toString().trim());
+    console.log(fitTable(table.toString().trim(), process.stdout.isTTY ? process.stdout.columns : undefined));
     console.log('');
     console.log(colors.gray(`${items.length - (withRoot ? 1 : 0)} Package(s) found`));
 }

package/commands/version.command.d.ts

@@ -70,6 +70,11 @@ declare const config: {
      * `--message` is `commitMessage`'s flag and is declared above; the rest are settings a repository
      * states once, not things a single run overrides.
      */
+    skip: {
+        target: "config";
+        describe: string;
+        type: "boolean";
+    };
     commitMessage: {
         target: "config";
         describe: string;
@@ -271,6 +276,11 @@ declare const versionCommand: (app: import("../index.js").RmanApplication) => {
          * `--message` is `commitMessage`'s flag and is declared above; the rest are settings a repository
          * states once, not things a single run overrides.
          */
+        skip: {
+            target: "config";
+            describe: string;
+            type: "boolean";
+        };
         commitMessage: {
             target: "config";
             describe: string;

package/commands/version.command.js

@@ -4,6 +4,7 @@ import EasyTable from 'easy-table';
 import { registerCommand } from '../interfaces/rman-config.interface.js';
 import { VersionPlanService } from '../services/version-plan.service.js';
 import { assertAllowedBranch, branchGuardOptions, readBranchGuardOptions } from '../utils/branch-guard.js';
+import { fitTable } from '../utils/fit-table.js';
 import { packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
 import { isNamedGroupKey, isSoloGroupKey, ROOT_GROUP_KEY } from '../utils/version-group.js';
 /**
@@ -93,6 +94,13 @@ const config = {
      * `--message` is `commitMessage`'s flag and is declared above; the rest are settings a repository
      * states once, not things a single run overrides.
      */
+    skip: {
+        target: 'config',
+        describe: 'Whether this package takes a version at all. Unset, a package kept out of publishing ' +
+            '(publish.skip, or private) is left out; true leaves out one that publishes, false versions ' +
+            'one that does not.',
+        type: 'boolean',
+    },
     commitMessage: {
         target: 'config',
         describe: 'The commit message for each group this run commits - "{version}" is substituted when a ' +
@@ -304,7 +312,7 @@ function printPlan(entries) {
         for (const e of members)
             printPlanRow(table, e);
     }
-    console.log(table.toString().trim());
+    console.log(fitTable(table.toString().trim(), process.stdout.isTTY ? process.stdout.columns : undefined));
 }
 /**
  * The plan, split into the blocks a delimiter is drawn between: the **repository root** first, then

package/constants.js

@@ -1 +1 @@
-export const version = '2.21.0';
+export const version = '2.22.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.21.0",
+  "version": "2.22.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/services/version-plan.service.d.ts

@@ -71,6 +71,12 @@ export declare abstract class VersionPlanService {
      * disagree about which commits are unreleased.
      */
     getPlan(repository: Repository, options?: VersionPlanService.Options): Promise<VersionPlanService.Entry[]>;
+    /**
+     * Why `pkg` takes no version at all, or `undefined` when it does: `.rmanrc "version.skip"` when
+     * it says so, and otherwise whether it has been kept out of publishing - `publish.skip`, or every
+     * target that ships it leaving it out (npm's `private`).
+     */
+    protected notVersionedReason(pkg: Package): string | undefined;
     /**
      * The commit a package's changes are measured **since** - its last release boundary, or
      * `undefined` for a package that has never been released (the caller then reads the whole

package/services/version-plan.service.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { RmanApplication } from '../core/application.js';
 import { assertOneScheme, semverScheme, VersionScheme } from '../core/classes/version-scheme.js';
+import { skipReasonFor, targetsOf } from '../core/interfaces/publish-target.js';
 import { GitHelper } from '../utils/git.js';
 import { filterPackages } from '../utils/package-filter.js';
 import { findLastReleaseVersion, formatCalendarVersion, usesCalendarVersion } from '../utils/release-version.js';
@@ -121,8 +122,27 @@ export class VersionPlanService {
          * `usesCalendarVersion`'s "one line" case, and the root reported `0.0.5 -> 2.1.6` on the
          * *semver* path instead of the calendar version it takes with four.
          */
-        const eligible = options.ignoreDirty ? packages.filter(pkg => !dirty.includes(pkg)) : packages;
-        for (const pkg of options.ignoreDirty ? dirty : []) {
+        /** Not versioned at all - see `notVersionedReason`. Out before `eligible`, for the reason a
+         *  skipped dirty package is: a number its group's other members get cannot come from it. */
+        const unversioned = new Map();
+        for (const pkg of packages) {
+            const reason = this.notVersionedReason(pkg);
+            if (reason)
+                unversioned.set(pkg, reason);
+        }
+        for (const [pkg, reason] of unversioned) {
+            entries.set(pkg.name, {
+                package: pkg,
+                groupKey: this.resolveGroupKey(pkg),
+                group: this.groupLabel(this.resolveGroupKey(pkg)),
+                status: 'skip',
+                from: pkg.version,
+                reason,
+            });
+        }
+        const versioned = packages.filter(pkg => !unversioned.has(pkg));
+        const eligible = options.ignoreDirty ? versioned.filter(pkg => !dirty.includes(pkg)) : versioned;
+        for (const pkg of options.ignoreDirty ? dirty.filter(d => !unversioned.has(d)) : []) {
             entries.set(pkg.name, {
                 package: pkg,
                 groupKey: this.resolveGroupKey(pkg),
@@ -185,7 +205,8 @@ export class VersionPlanService {
         if (!options.ignoreDirty) {
             for (const pkg of dirty) {
                 const entry = entries.get(pkg.name);
-                if (!entry)
+                /** A package that is not versioned has nothing to protect from a dirty tree. */
+                if (!entry || unversioned.has(pkg))
                     continue;
                 entry.status = 'error';
                 entry.reason = entry.reason ? `uncommitted local changes (${entry.reason})` : 'uncommitted local changes';
@@ -193,6 +214,46 @@ export class VersionPlanService {
         }
         return result;
     }
+    /**
+     * Why `pkg` takes no version at all, or `undefined` when it does: `.rmanrc "version.skip"` when
+     * it says so, and otherwise whether it has been kept out of publishing - `publish.skip`, or every
+     * target that ships it leaving it out (npm's `private`).
+     */
+    /* **A version nothing publishes is a number nobody can install**, and that is the user's reason
+     * for reversing the old rule that `version` never reads `publish.skip`. Measured on
+     * `panates/syncbridge`: fourteen packages kept out of publishing were still bumped, tagged and
+     * written into changelogs on every release - tags with nothing on the registry behind them, and a
+     * version line that had jumped by the time publishing was switched back on.
+     *
+     * `version.skip` decides first, both ways: `true` holds back a package that does publish, `false`
+     * versions one that does not - an application deployed by other means, whose number still
+     * matters. A monorepo's root never reaches here; its version is the repository's release
+     * identity, decided by `buildRootEntry`.
+     *
+     * **A package no target ships to is still versioned**, deliberately. Tried the other way first,
+     * and it stopped versioning every package of a repository that has no publish target at all - one
+     * that versions with rman and publishes by other means, or a technology rman has no target for -
+     * which is most of the core's own spec fixtures. Only a package kept out *on purpose* is left
+     * out. */
+    notVersionedReason(pkg) {
+        const declared = pkg.config.version?.skip;
+        if (declared === true)
+            return 'excluded via .rmanrc "version.skip"';
+        if (declared === false)
+            return undefined;
+        if (pkg.config.publish?.skip)
+            return 'not published - .rmanrc "publish.skip"';
+        const app = pkg.repository?.app;
+        if (!app)
+            return undefined;
+        const targets = targetsOf(app, pkg);
+        if (!targets.length)
+            return undefined;
+        const reasons = targets.map(target => skipReasonFor(pkg, target));
+        if (reasons.every(Boolean))
+            return `not published - ${reasons[0]}`;
+        return undefined;
+    }
     /**
      * **Which planner answers for one package: its own technology's.**
      *
@@ -468,7 +529,9 @@ export class VersionPlanService {
             const source = worklist.shift();
             for (const pkg of packages) {
                 const entry = entries.get(pkg.name);
-                if (entry.status === 'bump' || entry.groupKey === source.groupKey)
+                /** A skipped package stays skipped: it is out of the release on purpose (not published, or
+                 *  dirty under `--ignore-dirty`), and a dependency moving does not change that. */
+                if (entry.status === 'bump' || entry.status === 'skip' || entry.groupKey === source.groupKey)
                     continue;
                 if (!pkg.dependencies.includes(source.package))
                     continue;

package/utils/fit-table.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A rendered `easy-table` fitted to a terminal `columns` wide: a row wider than that has its **last
+ * column** continued on further lines, each starting at that column, and a delimiter line is cut at
+ * the edge. Anything that already fits is left exactly as it was.
+ *
+ * `columns` is `undefined` when the output is not a terminal, and then nothing changes - a file or a
+ * pipe has no edge to wrap at, and a reader of one wants each row on one line.
+ */
+export declare function fitTable(text: string, columns: number | undefined): string;

package/utils/fit-table.js

@@ -0,0 +1,92 @@
+/**
+ * A rendered `easy-table` fitted to a terminal `columns` wide: a row wider than that has its **last
+ * column** continued on further lines, each starting at that column, and a delimiter line is cut at
+ * the edge. Anything that already fits is left exactly as it was.
+ *
+ * `columns` is `undefined` when the output is not a terminal, and then nothing changes - a file or a
+ * pipe has no edge to wrap at, and a reader of one wants each row on one line.
+ */
+/* **The terminal wrapping it is what this replaces**, and what that did to a table: measured on
+ * `panates/syncbridge`, `rman version`'s root row carries a 70-character reason, so the row and the
+ * delimiter under the header - as wide as the widest cell - both ran past the edge and continued at
+ * column 0, breaking the table into lines the eye could not follow.
+ *
+ * **Only the last column moves**, because it is the free-text one in every table rman prints
+ * (`Reason`, `Path`) - the columns before it are short, fixed values whose alignment is the point.
+ * Where it starts is read off the first delimiter line easy-table draws, the one place the column
+ * boundaries are spelled out without colour codes in the way.
+ *
+ * A row whose last column would get fewer than `MIN_WIDTH` characters is left alone: wrapping into a
+ * sliver is worse than the terminal's own wrap. */
+export function fitTable(text, columns) {
+    if (!columns)
+        return text;
+    const lines = text.split('\n');
+    const delimiter = lines.find(line => /^[\s-]*-[\s-]*$/.test(line));
+    if (!delimiter)
+        return text;
+    const start = delimiter.search(/-+\s*$/);
+    const width = columns - start;
+    /** Every cell is padded to its column, the last one included, so a row of short text is still as
+     *  wide as the widest - past the edge, those spaces wrapped into a blank line under each row.
+     *  Trimmed and cut even where the last column is too narrow to wrap into. */
+    const trimmed = lines.map(line => (/^[\s-]+$/.test(line) ? line.slice(0, columns) : line.trimEnd()));
+    if (start <= 0 || width < MIN_WIDTH)
+        return trimmed.join('\n');
+    return trimmed
+        .flatMap(line => {
+        if (visibleLength(line) <= columns)
+            return [line];
+        const at = rawIndexOf(line, start);
+        const head = line.slice(0, at);
+        const tail = line.slice(at);
+        /** A cell painted as a whole (`colors.gray(reason)`) keeps its colour on every line. */
+        // eslint-disable-next-line no-control-regex
+        const paint = /^(?:\x1b\[[0-9;]*m)+/.exec(tail)?.[0] ?? '';
+        const chunks = wrapWords(stripAnsi(tail), width);
+        const pad = ' '.repeat(start);
+        return chunks.map((chunk, i) => (i ? pad : head) + (paint ? `${paint}${chunk}\x1b[0m` : chunk));
+    })
+        .join('\n');
+}
+const MIN_WIDTH = 20;
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;]*m/g;
+function stripAnsi(text) {
+    return text.replace(ANSI, '');
+}
+function visibleLength(text) {
+    return stripAnsi(text).length;
+}
+/** The index in `line` of its `visible`-th visible character, colour codes skipped. */
+function rawIndexOf(line, visible) {
+    let seen = 0;
+    let i = 0;
+    while (i < line.length && seen < visible) {
+        if (line[i] === '\x1b') {
+            const end = line.indexOf('m', i);
+            i = end < 0 ? line.length : end + 1;
+            continue;
+        }
+        seen++;
+        i++;
+    }
+    /** Colour codes sitting right at the boundary belong to the cell after it. */
+    return i;
+}
+/** `text` cut at spaces into lines of at most `width` - a word longer than that on a line of its own. */
+function wrapWords(text, width) {
+    const lines = [];
+    let current = '';
+    for (const word of text.trim().split(/\s+/)) {
+        if (current && current.length + 1 + word.length > width) {
+            lines.push(current);
+            current = word;
+        }
+        else
+            current = current ? `${current} ${word}` : word;
+    }
+    if (current)
+        lines.push(current);
+    return lines;
+}