feat(versioning): same major

lib/modules/versioning/api.ts

@@ -31,6 +31,7 @@ import * as regex from './regex';
 import * as rez from './rez';
 import * as rpm from './rpm';
 import * as ruby from './ruby';
+import * as sameMajor from './same-major';
 import * as semver from './semver';
 import * as semverCoerced from './semver-coerced';
 import * as swift from './swift';
@@ -74,6 +75,7 @@ api.set(regex.id, regex.api);
 api.set(rez.id, rez.api);
 api.set(rpm.id, rpm.api);
 api.set(ruby.id, ruby.api);
+api.set(sameMajor.id, sameMajor.api);
 api.set(semver.id, semver.api);
 api.set(semverCoerced.id, semverCoerced.api);
 api.set(swift.id, swift.api);

lib/modules/versioning/same-major/index.spec.ts

@@ -0,0 +1,57 @@
+import sameMajor from '.';
+
+describe('modules/versioning/same-major/index', () => {
+  describe('.matches(version, range)', () => {
+    it('should return true when version has same major', () => {
+      expect(sameMajor.matches('1.0.1', '1.0.0')).toBeTrue();
+      expect(sameMajor.matches('1.0.1', '^1.0.0')).toBeTrue(); // coverage for when ranges are passed to the function
+    });
+
+    it('should return false when version has different major', () => {
+      expect(sameMajor.matches('2.0.1', '1.0.0')).toBeFalse();
+    });
+
+    it('should return false when version is out of range', () => {
+      expect(sameMajor.matches('1.2.3', '1.2.4')).toBeFalse();
+      expect(sameMajor.matches('2.0.0', '1.2.4')).toBeFalse();
+      expect(sameMajor.matches('3.2.4', '1.2.4')).toBeFalse();
+    });
+
+    it('should return false when version is invalid', () => {
+      expect(sameMajor.matches('1.0.0', 'xxx')).toBeFalse();
+    });
+  });
+
+  describe('.getSatisfyingVersion(versions, range)', () => {
+    it('should return max satisfying version in range', () => {
+      expect(
+        sameMajor.getSatisfyingVersion(
+          ['1.0.0', '1.0.4', '1.3.0', '2.0.0'],
+          '1.0.3',
+        ),
+      ).toBe('1.3.0');
+    });
+  });
+
+  describe('.minSatisfyingVersion(versions, range)', () => {
+    it('should return min satisfying version in range', () => {
+      expect(
+        sameMajor.minSatisfyingVersion(
+          ['1.0.0', '1.0.4', '1.3.0', '2.0.0'],
+          '1.0.3',
+        ),
+      ).toBe('1.0.4');
+    });
+  });
+
+  describe('.isLessThanRange(version, range)', () => {
+    it('should return true', () => {
+      expect(sameMajor.isLessThanRange('2.0.2', '3.0.0')).toBeTrue();
+    });
+
+    it('should return false', () => {
+      expect(sameMajor.isLessThanRange('4.0.0', '3.0.0')).toBeFalse();
+      expect(sameMajor.isLessThanRange('3.1.0', '3.0.0')).toBeFalse();
+    });
+  });
+});

lib/modules/versioning/same-major/index.ts

@@ -0,0 +1,54 @@
+import { api as semverCoerced } from '../semver-coerced';
+import type { VersioningApi } from '../types';
+
+export const id = 'same-major';
+export const displayName = 'Same Major Versioning';
+export const urls = [];
+export const supportsRanges = false;
+
+/**
+ *
+ * Converts input to range if it's a version. eg. X.Y.Z -> '>=X.Y.Z <X+1'
+ * If the input is already a range, it returns the input.
+ */
+function massageVersion(input: string): string {
+  // return the input if it is a range
+  if (!semverCoerced.isSingleVersion(input)) {
+    return input;
+  }
+
+  // we are sure to get a major because of the isSingleVersion check
+  const major = semverCoerced.getMajor(input)!;
+  return `>=${input} <${major + 1}`;
+}
+
+function matches(version: string, range: string): boolean {
+  return semverCoerced.matches(version, massageVersion(range));
+}
+
+function getSatisfyingVersion(
+  versions: string[],
+  range: string,
+): string | null {
+  return semverCoerced.getSatisfyingVersion(versions, massageVersion(range));
+}
+
+function minSatisfyingVersion(
+  versions: string[],
+  range: string,
+): string | null {
+  return semverCoerced.minSatisfyingVersion(versions, massageVersion(range));
+}
+
+function isLessThanRange(version: string, range: string): boolean {
+  return semverCoerced.isLessThanRange!(version, massageVersion(range));
+}
+
+export const api: VersioningApi = {
+  ...semverCoerced,
+  matches,
+  getSatisfyingVersion,
+  minSatisfyingVersion,
+  isLessThanRange,
+};
+export default api;

lib/modules/versioning/same-major/readme.md

@@ -0,0 +1,8 @@
+Renovate's 'Same Major' versioning is specifically designed to address scenarios where version specifications, denoted as X.Y.Z, signify a range of compatibility from greater than or equal to X.Y.Z to less than X+1.
+In essence, each individual version is to be treated as a constraint.
+
+This method is handy when managing dependencies like dotnet-sdk's rollForward settings.
+Let's say a project uses dotnet-sdk version 3.1.0.
+It needs to be compatible with any version in the 3.x.x range but not with versions in the next major version, like 4.x.x.
+
+This process employs Semver-Coerced versioning beneath the surface, wherein single versions (e.g., `X.Y.Z`) are converted to a range like `X+1` and then passed to the corresponding semver-coerced method.