rman 2.25.1 → 2.26.0

package/builtins/platforms/node/node-dependency-updater.d.ts

@@ -37,6 +37,12 @@ export declare class NodeDependencyUpdater implements DependencyUpdater {
     /** Fills in what `d` may move to, from its own settings and the rules that do not depend on what
      *  else moves (steps 1-3). */
     protected prepare(d: NodeDependencyUpdater.Decision, info: NpmReleases | undefined): void;
+    /**
+     * The first range of a dependency rman does not move - a pinned `11.7.5`, a `>=2 <3` - that the
+     * registry's newest offerable release falls outside, and that release. `undefined` when every
+     * such range still takes it, which is nothing worth a row.
+     */
+    protected outgrown(d: NodeDependencyUpdater.Decision, releases: readonly NpmRelease[]): NodeDependencyUpdater.Decision['unmovable'];
     /** Whether the registry offers `release` as a move at all: newer than what is declared, not
      *  deprecated, not above the `latest` tag, and not a prerelease unless the range is on one. */
     protected offerable(d: NodeDependencyUpdater.Decision, release: NpmRelease): boolean;
@@ -84,6 +90,15 @@ export declare class NodeDependencyUpdater implements DependencyUpdater {
     /** The in-repo packages `pkg` declares a dependency on. */
     protected siblingsOf(pkg: Package, repoPackages: ReadonlyMap<string, Package>): Package[];
     protected toEntry(d: NodeDependencyUpdater.Decision): DependencyUpdater.Entry;
+    /**
+     * The version of `name` that `pkg` resolves today: the first `node_modules/<name>/package.json`
+     * walking up from its directory, which is Node's own lookup - so a hoisted copy at a monorepo's
+     * root counts, and a nested one under the package wins over it.
+     */
+    protected installedVersion(pkg: Package, name: string): string | undefined;
+    /** The newest release `range` takes, as npm's install would pick it: no prerelease unless the
+     *  range asks for one, nothing above the `latest` tag, a deprecated one only when nothing else is. */
+    protected resolvedVersion(d: NodeDependencyUpdater.Decision, range: string): string | undefined;
     protected manifestFile(pkg: Package): string;
     /** `fn` over `items`, at most `limit` at a time. */
     protected mapConcurrent<T>(items: readonly T[], limit: number, fn: (item: T) => Promise<void>): Promise<void>;
@@ -98,6 +113,16 @@ export declare namespace NodeDependencyUpdater {
         fields: Map<string, string>;
         /** The fields whose range is rewritten. */
         movable: string[];
+        /** The fields holding a valid range rman does not rewrite - a pinned version, `>=a <b`. */
+        fixed: string[];
+        /** Not planned, but listed when a release falls outside a `fixed` range - see `outgrown`. */
+        listed?: boolean;
+        /** That release, and the range it falls outside. */
+        unmovable?: {
+            field: string;
+            range: string;
+            version: string;
+        };
         /** Whether this name is planned at all - rather than only stating rules for the others. */
         wanted: boolean;
         /** What is declared now, as a version: the highest floor among the movable ranges. */

package/builtins/platforms/node/node-dependency-updater.js

@@ -64,7 +64,15 @@ export class NodeDependencyUpdater {
         for (const d of decisions)
             this.prepare(d, registry.get(d.name));
         this.resolve(decisions, ctx);
-        return decisions.filter(d => d.wanted).map(d => this.toEntry(d));
+        return decisions
+            .filter(d => d.wanted || d.unmovable)
+            .map(d => {
+            /** Set on the entry itself, never a copy: `planned` is keyed by that object. */
+            const entry = this.toEntry(d);
+            entry.installed = this.installedVersion(d.pkg, d.name);
+            entry.resolved = this.resolvedVersion(d, entry.current);
+            return entry;
+        });
     }
     async applyPlan(ctx, plan) {
         const originals = new Map();
@@ -142,6 +150,7 @@ export class NodeDependencyUpdater {
                         settings,
                         fields: new Map(),
                         movable: [],
+                        fixed: [],
                         wanted: false,
                         allowed: [],
                         candidates: [],
@@ -150,14 +159,19 @@ export class NodeDependencyUpdater {
                     byName.set(name, d);
                 }
                 d.fields.set(field, range);
-                if (this.movablePattern.test(range) && (!kinds || kinds.includes(field)))
+                if (kinds && !kinds.includes(field))
+                    continue;
+                if (this.movablePattern.test(range))
                     d.movable.push(field);
+                else if (semver.validRange(range))
+                    d.fixed.push(field);
             }
         }
         for (const d of byName.values()) {
             const picked = !options.names?.length || micromatch.isMatch(d.name, options.names);
             const rejected = settings.reject.length > 0 && micromatch.isMatch(d.name, settings.reject);
             d.wanted = d.movable.length > 0 && picked && !rejected;
+            d.listed = !d.wanted && d.fixed.length > 0 && picked && !rejected;
             if (d.wanted) {
                 d.floor = d.movable.map(f => semver.minVersion(d.fields.get(f)).version).sort(semver.rcompare)[0];
             }
@@ -196,6 +210,8 @@ export class NodeDependencyUpdater {
     prepare(d, info) {
         d.releases = new Map((info?.releases ?? []).map(r => [r.version, r]));
         d.latestTag = info?.latest;
+        if (d.listed && info)
+            d.unmovable = this.outgrown(d, info.releases);
         if (!d.wanted)
             return;
         if (!info) {
@@ -220,6 +236,30 @@ export class NodeDependencyUpdater {
         }
         d.index = d.candidates.length ? 0 : -1;
     }
+    /**
+     * The first range of a dependency rman does not move - a pinned `11.7.5`, a `>=2 <3` - that the
+     * registry's newest offerable release falls outside, and that release. `undefined` when every
+     * such range still takes it, which is nothing worth a row.
+     */
+    /* **Listed, never moved.** Only a `^` or `~` range on a plain version is rewritten, since anything
+     * else was written that way on purpose. But leaving such a dependency out of the table entirely
+     * hid it: measured on `panates/hl7v2`, `"mocha": "11.7.5"` with 12.x out appeared nowhere, and a
+     * person reading the table took that for "up to date". A `skipped` row says what is there and why
+     * it stays. */
+    outgrown(d, releases) {
+        for (const field of d.fixed) {
+            const range = d.fields.get(field);
+            const newest = releases
+                .map(r => semver.parse(r.version))
+                .filter((v) => !!v && !v.prerelease.length)
+                .filter(v => !releases.find(r => r.version === v.version)?.deprecated)
+                .filter(v => !d.latestTag || !semver.valid(d.latestTag) || semver.lte(v, d.latestTag))
+                .sort(semver.rcompare)[0];
+            if (newest && !semver.satisfies(newest, range))
+                return { field, range, version: newest.version };
+        }
+        return undefined;
+    }
     /** Whether the registry offers `release` as a move at all: newer than what is declared, not
      *  deprecated, not above the `latest` tag, and not a prerelease unless the range is on one. */
     offerable(d, release) {
@@ -431,6 +471,19 @@ export class NodeDependencyUpdater {
         return [...result];
     }
     toEntry(d) {
+        if (!d.wanted && d.unmovable) {
+            const { field, range, version } = d.unmovable;
+            return {
+                package: d.pkg,
+                name: d.name,
+                types: [field],
+                current: range,
+                status: 'skipped',
+                latest: version,
+                available: version,
+                reason: 'not a ^ or ~ range - rman moves only those',
+            };
+        }
         const entry = {
             package: d.pkg,
             name: d.name,
@@ -461,6 +514,41 @@ export class NodeDependencyUpdater {
         this.planned.set(result, d);
         return result;
     }
+    /**
+     * The version of `name` that `pkg` resolves today: the first `node_modules/<name>/package.json`
+     * walking up from its directory, which is Node's own lookup - so a hoisted copy at a monorepo's
+     * root counts, and a nested one under the package wins over it.
+     */
+    installedVersion(pkg, name) {
+        let dir = pkg.dirname;
+        for (;;) {
+            const file = path.join(dir, 'node_modules', name, 'package.json');
+            if (fs.existsSync(file)) {
+                try {
+                    const version = JSON.parse(fs.readFileSync(file, 'utf-8'))?.version;
+                    return typeof version === 'string' ? version : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return undefined;
+            dir = parent;
+        }
+    }
+    /** The newest release `range` takes, as npm's install would pick it: no prerelease unless the
+     *  range asks for one, nothing above the `latest` tag, a deprecated one only when nothing else is. */
+    resolvedVersion(d, range) {
+        if (!d.releases || !semver.validRange(range))
+            return undefined;
+        const taken = [...d.releases.values()]
+            .filter(r => semver.satisfies(r.version, range))
+            .filter(r => !d.latestTag || !semver.valid(d.latestTag) || semver.lte(r.version, d.latestTag))
+            .sort((a, b) => semver.rcompare(a.version, b.version));
+        return (taken.find(r => !r.deprecated) ?? taken[0])?.version;
+    }
     manifestFile(pkg) {
         return path.join(pkg.dirname, 'package.json');
     }

package/commands/deps.command.js

@@ -182,6 +182,8 @@ function jsonPlan(entries) {
         types: e.types,
         status: e.status,
         current: e.current,
+        installed: e.installed,
+        resolved: e.resolved,
         target: e.target,
         latest: e.latest,
         available: e.available,
@@ -200,30 +202,40 @@ function jsonPlan(entries) {
  * own settings leave the newer version out) or `error`. Moves first, smallest first, then the rest. */
 function printPlan(entries, root) {
     const updated = entries.filter(e => e.status === 'update');
-    const shown = entries.filter(e => e.status !== 'up-to-date');
+    const shown = entries.filter(e => e.status !== 'up-to-date' || reinstall(e));
     /** Said first when nothing moves, so a run whose only rows are majors left behind does not read
      *  as a list of things to do. */
     if (!updated.length) {
-        console.log(colors.green('All dependencies are up to date') +
-            (shown.length ? colors.gray(' - newer versions their settings leave out, or another rule holds back:') : '.'));
+        const why = [
+            ...(shown.some(e => e.status !== 'up-to-date')
+                ? ['newer versions their settings leave out, or another rule holds back']
+                : []),
+            ...(shown.some(reinstall) ? ['installed versions that differ from what the range takes'] : []),
+        ];
+        console.log(colors.green('All dependencies are up to date') + (why.length ? colors.gray(` - ${why.join('; ')}:`) : '.'));
         if (!shown.length)
             return;
     }
-    const header = ['Dependency', 'Current', 'Upgrade', 'Latest', 'Change'];
+    /** The upgrade last before the note, so the row reads from what is there to what it would become. */
+    const header = ['Dependency', 'Current', 'Installed', 'Latest', 'Change', 'Upgrade'];
     const cells = (e) => [
         e.name,
         e.current,
-        e.status === 'update' ? (e.target ?? '') : '-',
-        e.status === 'error' ? '-' : (e.available ?? e.latest ?? ''),
+        e.installed ?? '-',
+        e.status === 'error' ? '-' : (e.available ?? e.latest ?? e.resolved ?? ''),
         changeOf(e),
+        e.status === 'update' ? (e.target ?? '') : '-',
     ];
+    const last = header.length - 1;
     const widths = header.map((h, i) => Math.max(h.length, ...shown.map(e => cells(e)[i].length)));
     /** Padded to the column, except a last value nothing follows - trailing spaces inside a colour
      *  code are past the reach of `trimEnd`. */
     const line = (values, paint = text => text) => '  ' + values.map((v, i) => paint(i === values.length - 1 ? v : v.padEnd(widths[i]), i)).join('  ');
     for (const pkg of [...new Set(shown.map(e => e.package))]) {
         const sizes = pkg.versionScheme.bumpNames;
-        const rank = (e) => e.status === 'update' ? sizes.indexOf(e.bump) : sizes.length + ['held', 'skipped', 'error'].indexOf(e.status);
+        const rank = (e) => e.status === 'update'
+            ? sizes.indexOf(e.bump)
+            : sizes.length + ['held', 'skipped', 'error', 'up-to-date'].indexOf(e.status);
         const rows = shown.filter(e => e.package === pkg).sort((x, y) => rank(x) - rank(y));
         const where = path.relative(root, pkg.dirname);
         console.log(colors.cyan(pkg.name) + (where ? colors.gray(` (${where})`) : ''));
@@ -231,16 +243,17 @@ function printPlan(entries, root) {
         for (const e of rows) {
             const paint = e.status === 'update' ? sizeColor(e.bump, sizes) : changeColor(e.status);
             const values = cells(e);
-            if (e.reason)
-                values[4] = values[4].padEnd(widths[4]);
-            const text = line(values, (v, column) => (column === 2 || column === 4 ? paint(v) : v));
-            if (!e.reason) {
+            const note = e.reason ?? (reinstall(e) ? `"${e.current}" takes ${e.resolved} - install again` : undefined);
+            if (note)
+                values[last] = values[last].padEnd(widths[last]);
+            const text = line(values, (v, column) => (column === 4 || column === 5 ? paint(v) : v));
+            if (!note) {
                 console.log(text);
                 continue;
             }
             const indent = 2 + widths.reduce((sum, w) => sum + w + 2, 0);
-            const note = wrapNote(e.reason, process.stdout.isTTY ? process.stdout.columns - indent : 0);
-            console.log(`${text}  ${note.map(l => colors.gray(l)).join('\n' + ' '.repeat(indent))}`);
+            const wrapped = wrapNote(note, process.stdout.isTTY ? process.stdout.columns - indent : 0);
+            console.log(`${text}  ${wrapped.map(l => colors.gray(l)).join('\n' + ' '.repeat(indent))}`);
         }
     }
 }
@@ -268,8 +281,18 @@ function wrapNote(note, width) {
 }
 /** What the `Change` column says: the size of the move, or why there is none. */
 function changeOf(e) {
+    if (e.status === 'up-to-date')
+        return reinstall(e) ? 'install' : e.status;
     return e.status === 'update' ? (e.bump ?? 'other') : e.status;
 }
+/**
+ * A range already at the newest version, with something else installed - a `node_modules` behind
+ * its manifest. Listed although nothing moves: hidden, it read as up to date while the code ran
+ * against the older version.
+ */
+function reinstall(e) {
+    return e.status === 'up-to-date' && !!e.installed && !!e.resolved && e.installed !== e.resolved;
+}
 /** `held` and `skipped` in yellow, an error in red - a row with no move to colour by size. */
 function changeColor(status) {
     return status === 'error' ? colors.red : colors.yellow;

package/constants.js

@@ -1 +1 @@
-export const version = '2.25.1';
+export const version = '2.26.0';

package/core/interfaces/dependency-updater.d.ts

@@ -76,6 +76,12 @@ export declare namespace DependencyUpdater {
         types: string[];
         /** The range as the manifest declares it. */
         current: string;
+        /** The version installed now, as the package would resolve it - unset when it is not
+         *  installed, or the ecosystem cannot say. */
+        installed?: string;
+        /** The newest version the declared range takes - what an install would put there. An
+         *  `'up-to-date'` entry whose `installed` differs from it is still listed. */
+        resolved?: string;
         status: 'update' | 'held' | 'skipped' | 'up-to-date' | 'error';
         /** The range it is rewritten to, on an `'update'`. */
         target?: string;

package/package.json

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