chore: ensure versioning/versioningApi used consistently (#31856)

lib/util/exec/containerbase.ts

@@ -259,14 +259,14 @@ export function isDynamicInstall(
 
 function isStable(
   version: string,
-  versioning: allVersioning.VersioningApi,
+  versioningApi: allVersioning.VersioningApi,
   latest?: string,
 ): boolean {
-  if (!versioning.isStable(version)) {
+  if (!versioningApi.isStable(version)) {
     return false;
   }
   if (is.string(latest)) {
-    if (versioning.isGreaterThan(version, latest)) {
+    if (versioningApi.isGreaterThan(version, latest)) {
       return false;
     }
   }

lib/util/exec/docker/index.ts

@@ -3,7 +3,7 @@ import { GlobalConfig } from '../../../config/global';
 import { SYSTEM_INSUFFICIENT_MEMORY } from '../../../constants/error-messages';
 import { logger } from '../../../logger';
 import { getPkgReleases } from '../../../modules/datasource';
-import * as versioning from '../../../modules/versioning';
+import * as allVersioning from '../../../modules/versioning';
 import { newlineRegex, regEx } from '../../regex';
 import { uniq } from '../../uniq';
 import { rawExec } from '../common';
@@ -76,41 +76,45 @@ function prepareCommands(commands: Opt<string>[]): string[] {
 export async function getDockerTag(
   packageName: string,
   constraint: string,
-  scheme: string,
+  versioning: string,
 ): Promise<string> {
-  const ver = versioning.get(scheme);
+  const versioningApi = allVersioning.get(versioning);
 
-  if (!ver.isValid(constraint)) {
+  if (!versioningApi.isValid(constraint)) {
     logger.warn(
-      { scheme, constraint },
+      { versioning, constraint },
       `Invalid Docker image version constraint`,
     );
     return 'latest';
   }
 
   logger.debug(
-    { packageName, scheme, constraint },
+    { packageName, versioning, constraint },
     `Found version constraint - checking for a compatible image to use`,
   );
   const imageReleases = await getPkgReleases({
     datasource: 'docker',
     packageName,
-    versioning: scheme,
+    versioning,
   });
   if (imageReleases?.releases) {
     let versions = imageReleases.releases.map((release) => release.version);
     versions = versions.filter(
-      (version) => ver.isVersion(version) && ver.matches(version, constraint),
+      (version) =>
+        versioningApi.isVersion(version) &&
+        versioningApi.matches(version, constraint),
     );
     // Prefer stable versions over unstable, even if the range satisfies both types
-    if (!versions.every((version) => ver.isStable(version))) {
+    if (!versions.every((version) => versioningApi.isStable(version))) {
       logger.debug('Filtering out unstable versions');
-      versions = versions.filter((version) => ver.isStable(version));
+      versions = versions.filter((version) => versioningApi.isStable(version));
     }
-    const version = versions.sort(ver.sortVersions.bind(ver)).pop();
+    const version = versions
+      .sort(versioningApi.sortVersions.bind(versioningApi))
+      .pop();
     if (version) {
       logger.debug(
-        { packageName, scheme, constraint, version },
+        { packageName, versioning, constraint, version },
         `Found compatible image version`,
       );
       return version;
@@ -120,7 +124,7 @@ export async function getDockerTag(
     return 'latest';
   }
   logger.warn(
-    { packageName, constraint, scheme },
+    { packageName, constraint, versioning },
     'Failed to find a tag satisfying constraint, using "latest" tag instead',
   );
   return 'latest';

lib/util/package-rules/current-version.ts

@@ -20,7 +20,7 @@ export class CurrentVersionMatcher extends Matcher {
     }
     const isUnconstrainedValue =
       !!lockedVersion && is.nullOrUndefined(currentValue);
-    const version = allVersioning.get(versioning);
+    const versioningApi = allVersioning.get(versioning);
     const matchCurrentVersionStr = matchCurrentVersion.toString();
     const matchCurrentVersionPred = getRegexPredicate(matchCurrentVersionStr);
 
@@ -31,29 +31,29 @@ export class CurrentVersionMatcher extends Matcher {
         matchCurrentVersionPred(compareVersion)
       );
     }
-    if (version.isVersion(matchCurrentVersionStr)) {
+    if (versioningApi.isVersion(matchCurrentVersionStr)) {
       try {
         return (
           isUnconstrainedValue ||
           !!(
             currentValue &&
-            version.isValid(currentValue) &&
-            version.matches(matchCurrentVersionStr, currentValue)
+            versioningApi.isValid(currentValue) &&
+            versioningApi.matches(matchCurrentVersionStr, currentValue)
           )
         );
       } catch {
         return false;
       }
     }
 
-    const compareVersion = version.isVersion(currentValue)
+    const compareVersion = versioningApi.isVersion(currentValue)
       ? currentValue // it's a version so we can match against it
       : (lockedVersion ?? currentVersion); // need to match against this currentVersion, if available
     if (is.nullOrUndefined(compareVersion)) {
       return false;
     }
-    if (version.isVersion(compareVersion)) {
-      return version.matches(compareVersion, matchCurrentVersion);
+    if (versioningApi.isVersion(compareVersion)) {
+      return versioningApi.matches(compareVersion, matchCurrentVersion);
     }
     logger.debug(
       { matchCurrentVersionStr, currentValue },

lib/workers/repository/init/vulnerability.ts

@@ -120,11 +120,11 @@ export async function detectVulnerabilityAlerts(
       };
       const alertDetails = combinedAlerts[fileName][datasource][depName];
       alertDetails.advisories.push(advisory);
-      const version = allVersioning.get(versionings[datasource]);
-      if (version.isVersion(firstPatchedVersion)) {
+      const versioningApi = allVersioning.get(versionings[datasource]);
+      if (versioningApi.isVersion(firstPatchedVersion)) {
         if (
           !alertDetails.firstPatchedVersion ||
-          version.isGreaterThan(
+          versioningApi.isGreaterThan(
             firstPatchedVersion,
             alertDetails.firstPatchedVersion,
           )

lib/workers/repository/process/lookup/bucket.ts

@@ -11,7 +11,7 @@ export function getBucket(
   config: BucketConfig,
   currentVersion: string,
   newVersion: string,
-  versioning: VersioningApi,
+  versioningApi: VersioningApi,
 ): string | null {
   const {
     separateMajorMinor,
@@ -22,8 +22,8 @@ export function getBucket(
   if (!separateMajorMinor) {
     return 'latest';
   }
-  const fromMajor = versioning.getMajor(currentVersion);
-  const toMajor = versioning.getMajor(newVersion);
+  const fromMajor = versioningApi.getMajor(currentVersion);
+  const toMajor = versioningApi.getMajor(newVersion);
 
   // istanbul ignore if: error case
   if (toMajor === null) {
@@ -41,8 +41,8 @@ export function getBucket(
 
   // If we reach here then we know it's non-major
 
-  const fromMinor = versioning.getMinor(currentVersion);
-  const toMinor = versioning.getMinor(newVersion);
+  const fromMinor = versioningApi.getMinor(currentVersion);
+  const toMinor = versioningApi.getMinor(newVersion);
 
   // istanbul ignore if: error case
   if (fromMinor === null || toMinor === null) {
@@ -66,7 +66,7 @@ export function getBucket(
 
   /* future option
   if (separateMultiplePatch) {
-    const toPatch = versioning.getPatch(newVersion);
+    const toPatch = versioningApi.getPatch(newVersion);
     if (toPatch !== null && separateMultiplePatch) {
       return `v${toMajor}.${toMinor}.${toPatch}`;
     }

lib/workers/repository/process/lookup/current.ts

@@ -6,7 +6,7 @@ import { regEx } from '../../../../util/regex';
 export function getCurrentVersion(
   currentValue: string,
   lockedVersion: string,
-  versioning: VersioningApi,
+  versioningApi: VersioningApi,
   rangeStrategy: string,
   latestVersion: string,
   allVersions: string[],
@@ -20,39 +20,39 @@ export function getCurrentVersion(
     return currentValue;
   }
   let useVersions = allVersions.filter((v) =>
-    versioning.matches(v, currentValue),
+    versioningApi.matches(v, currentValue),
   );
   if (useVersions.length === 1) {
     return useVersions[0];
   }
-  if (latestVersion && versioning.matches(latestVersion, currentValue)) {
+  if (latestVersion && versioningApi.matches(latestVersion, currentValue)) {
     useVersions = useVersions.filter(
-      (v) => !versioning.isGreaterThan(v, latestVersion),
+      (v) => !versioningApi.isGreaterThan(v, latestVersion),
     );
   }
   if (rangeStrategy === 'pin') {
     return (
       lockedVersion ||
-      versioning.getSatisfyingVersion(useVersions, currentValue)
+      versioningApi.getSatisfyingVersion(useVersions, currentValue)
     );
   }
   if (rangeStrategy === 'bump') {
     // Use the lowest version in the current range
-    return versioning.minSatisfyingVersion(useVersions, currentValue);
+    return versioningApi.minSatisfyingVersion(useVersions, currentValue);
   }
   // Use the highest version in the current range
-  const satisfyingVersion = versioning.getSatisfyingVersion(
+  const satisfyingVersion = versioningApi.getSatisfyingVersion(
     useVersions,
     currentValue,
   );
   if (satisfyingVersion) {
     return satisfyingVersion;
   }
 
-  if (versioning.isVersion(currentValue)) {
+  if (versioningApi.isVersion(currentValue)) {
     return currentValue;
   }
-  if (versioning.isSingleVersion(currentValue)) {
+  if (versioningApi.isSingleVersion(currentValue)) {
     return currentValue.replace(regEx(/=/g), '').trim();
   }
 

lib/workers/repository/process/lookup/filter-checks.ts

@@ -24,7 +24,7 @@ export interface InternalChecksResult {
 
 export async function filterInternalChecks(
   config: Partial<LookupUpdateConfig & UpdateResult>,
-  versioning: VersioningApi,
+  versioningApi: VersioningApi,
   bucket: string,
   sortedReleases: Release[],
 ): Promise<InternalChecksResult> {
@@ -43,7 +43,7 @@ export async function filterInternalChecks(
       // calculate updateType and then apply it
       releaseConfig.updateType = getUpdateType(
         releaseConfig,
-        versioning,
+        versioningApi,
         // TODO #22198
         currentVersion!,
         candidateRelease.version,

lib/workers/repository/process/lookup/filter.ts

@@ -9,8 +9,11 @@ import * as poetryVersioning from '../../../../modules/versioning/poetry';
 import { getRegexPredicate } from '../../../../util/string-match';
 import type { FilterConfig } from './types';
 
-function isReleaseStable(release: Release, versioning: VersioningApi): boolean {
-  if (!versioning.isStable(release.version)) {
+function isReleaseStable(
+  release: Release,
+  versioningApi: VersioningApi,
+): boolean {
+  if (!versioningApi.isStable(release.version)) {
     return false;
   }
 
@@ -26,7 +29,7 @@ export function filterVersions(
   currentVersion: string,
   latestVersion: string,
   releases: Release[],
-  versioning: VersioningApi,
+  versioningApi: VersioningApi,
 ): Release[] {
   const { ignoreUnstable, ignoreDeprecated, respectLatest, allowedVersions } =
     config;
@@ -39,17 +42,17 @@ export function filterVersions(
   // Leave only versions greater than current
   let filteredReleases = releases.filter(
     (r) =>
-      versioning.isVersion(r.version) &&
-      versioning.isGreaterThan(r.version, currentVersion),
+      versioningApi.isVersion(r.version) &&
+      versioningApi.isGreaterThan(r.version, currentVersion),
   );
 
   const currentRelease = releases.find(
     (r) =>
-      versioning.isValid(r.version) &&
-      versioning.isVersion(r.version) &&
-      versioning.isValid(currentVersion) &&
-      versioning.isVersion(currentVersion) &&
-      versioning.equals(r.version, currentVersion),
+      versioningApi.isValid(r.version) &&
+      versioningApi.isVersion(r.version) &&
+      versioningApi.isValid(currentVersion) &&
+      versioningApi.isVersion(currentVersion) &&
+      versioningApi.equals(r.version, currentVersion),
   );
 
   // Don't upgrade from non-deprecated to deprecated
@@ -71,9 +74,9 @@ export function filterVersions(
       filteredReleases = filteredReleases.filter(({ version }) =>
         isAllowedPred(version),
       );
-    } else if (versioning.isValid(allowedVersions)) {
+    } else if (versioningApi.isValid(allowedVersions)) {
       filteredReleases = filteredReleases.filter((r) =>
-        versioning.matches(r.version, allowedVersions),
+        versioningApi.matches(r.version, allowedVersions),
       );
     } else if (
       config.versioning !== npmVersioning.id &&
@@ -122,42 +125,42 @@ export function filterVersions(
   if (
     respectLatest &&
     latestVersion &&
-    !versioning.isGreaterThan(currentVersion, latestVersion)
+    !versioningApi.isGreaterThan(currentVersion, latestVersion)
   ) {
     filteredReleases = filteredReleases.filter(
-      (r) => !versioning.isGreaterThan(r.version, latestVersion),
+      (r) => !versioningApi.isGreaterThan(r.version, latestVersion),
     );
   }
 
   if (!ignoreUnstable) {
     return filteredReleases;
   }
 
-  if (currentRelease && isReleaseStable(currentRelease, versioning)) {
-    return filteredReleases.filter((r) => isReleaseStable(r, versioning));
+  if (currentRelease && isReleaseStable(currentRelease, versioningApi)) {
+    return filteredReleases.filter((r) => isReleaseStable(r, versioningApi));
   }
 
-  const currentMajor = versioning.getMajor(currentVersion);
-  const currentMinor = versioning.getMinor(currentVersion);
-  const currentPatch = versioning.getPatch(currentVersion);
+  const currentMajor = versioningApi.getMajor(currentVersion);
+  const currentMinor = versioningApi.getMinor(currentVersion);
+  const currentPatch = versioningApi.getPatch(currentVersion);
 
   return filteredReleases.filter((r) => {
-    if (isReleaseStable(r, versioning)) {
+    if (isReleaseStable(r, versioningApi)) {
       return true;
     }
 
-    const major = versioning.getMajor(r.version);
+    const major = versioningApi.getMajor(r.version);
 
     if (major !== currentMajor) {
       return false;
     }
 
-    if (versioning.allowUnstableMajorUpgrades) {
+    if (versioningApi.allowUnstableMajorUpgrades) {
       return true;
     }
 
-    const minor = versioning.getMinor(r.version);
-    const patch = versioning.getPatch(r.version);
+    const minor = versioningApi.getMinor(r.version);
+    const patch = versioningApi.getPatch(r.version);
 
     return minor === currentMinor && patch === currentPatch;
   });