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;
  });