feat(gradle): Support for gradle consistent versions plugin

docs/usage/java.md

@@ -35,6 +35,7 @@ Renovate can update:
 - dependencies whose version is defined in a `*.properties` file
 - `*.versions.toml` files in any directory or `*.toml` files inside the `gradle`
   directory ([Gradle Version Catalogs docs](https://docs.gradle.org/current/userguide/platforms.html))
+- `versions.props` from [gradle-consistent-versions](https://github.com/palantir/gradle-consistent-versions) plugin
 
 Renovate does not support:
 

lib/modules/manager/gradle/artifacts.ts

@@ -21,8 +21,17 @@ import {
   prepareGradleCommand,
 } from '../gradle-wrapper/utils';
 import type { UpdateArtifact, UpdateArtifactsResult } from '../types';
+import {
+  isGcvLockFile,
+  isGcvPropsFile,
+} from './extract/consistent-versions-plugin';
 import { isGradleBuildFile } from './utils';
 
+// .lockfile is gradle default lockfile, /versions.lock is gradle-consistent-versions plugin lockfile
+function isLockFile(fileName: string): boolean {
+  return fileName.endsWith('.lockfile') || isGcvLockFile(fileName);
+}
+
 async function getUpdatedLockfiles(
   oldLockFileContentMap: Record<string, string | null>
 ): Promise<UpdateArtifactsResult[]> {
@@ -31,7 +40,7 @@ async function getUpdatedLockfiles(
   const status = await getRepoStatus();
 
   for (const modifiedFile of status.modified) {
-    if (modifiedFile.endsWith('.lockfile')) {
+    if (isLockFile(modifiedFile)) {
       const newContent = await readLocalFile(modifiedFile, 'utf8');
       if (oldLockFileContentMap[modifiedFile] !== newContent) {
         res.push({
@@ -90,7 +99,7 @@ export async function updateArtifacts({
   logger.debug(`gradle.updateArtifacts(${packageFileName})`);
 
   const fileList = await getFileList();
-  const lockFiles = fileList.filter((file) => file.endsWith('.lockfile'));
+  const lockFiles = fileList.filter((file) => isLockFile(file));
   if (!lockFiles.length) {
     logger.debug('No Gradle dependency lockfiles found - skipping update');
     return null;
@@ -147,7 +156,7 @@ export async function updateArtifacts({
       .map(quote)
       .join(' ')}`;
 
-    if (config.isLockFileMaintenance) {
+    if (config.isLockFileMaintenance || isGcvPropsFile(packageFileName)) {
       cmd += ' --write-locks';
     } else {
       const updatedDepNames = updatedDeps

lib/modules/manager/gradle/extract.spec.ts

@@ -1,6 +1,12 @@
+import { stripIndent } from 'common-tags';
 import { Fixtures } from '../../../../test/fixtures';
 import { fs, logger } from '../../../../test/util';
 import type { ExtractConfig } from '../types';
+import {
+  parseLockFile,
+  parsePropsFile,
+  usesGcv,
+} from './extract/consistent-versions-plugin';
 import * as parser from './parser';
 import { extractAllPackageFiles } from '.';
 
@@ -841,4 +847,257 @@ describe('modules/manager/gradle/extract', () => {
       },
     ]);
   });
+
+  // Tests for gradle-consistent-version plugin
+  it('gradle-consistent-versions parse versions files', async () => {
+    const fsMock = {
+      'build.gradle': '(this file contains) com.palantir.consistent-versions',
+      'versions.props': `org.apache.lucene:* = 1.2.3`,
+      'versions.lock': stripIndent`
+        org.apache.lucene:lucene-core:1.2.3 (10 constraints: 95be0c15)
+        org.apache.lucene:lucene-codecs:1.2.3 (5 constraints: 1231231)`,
+    };
+
+    mockFs(fsMock);
+
+    const res = await extractAllPackageFiles(
+      {} as ExtractConfig,
+      Object.keys(fsMock)
+    );
+
+    expect(res).toMatchObject([
+      {
+        packageFile: 'versions.lock',
+      },
+      {
+        packageFile: 'versions.props',
+        deps: [
+          {
+            depName: 'org.apache.lucene:lucene-core',
+            depType: 'dependencies',
+            fileReplacePosition: 22,
+            groupName: 'org.apache.lucene:*',
+            lockedVersion: '1.2.3',
+            managerData: {
+              fileReplacePosition: 22,
+              packageFile: 'versions.props',
+            },
+            registryUrls: [],
+          },
+          {
+            depName: 'org.apache.lucene:lucene-codecs',
+            depType: 'dependencies',
+            fileReplacePosition: 22,
+            groupName: 'org.apache.lucene:*',
+            lockedVersion: '1.2.3',
+            managerData: {
+              fileReplacePosition: 22,
+              packageFile: 'versions.props',
+            },
+            registryUrls: [],
+          },
+        ],
+      },
+      {
+        packageFile: 'build.gradle',
+      },
+    ]);
+  });
+
+  it('gradle-consistent-versions plugin not used due to plugin not defined', async () => {
+    const fsMock = {
+      'build.gradle': 'no plugin defined here',
+      'versions.props': `org.apache.lucene:* = 1.2.3`,
+      'versions.lock': `org.apache.lucene:lucene-core:1.2.3`,
+    };
+    mockFs(fsMock);
+
+    const res = await extractAllPackageFiles(
+      {} as ExtractConfig,
+      Object.keys(fsMock)
+    );
+    expect(res).toBeNull();
+  });
+
+  it('gradle-consistent-versions plugin not used due to lockfile missing', async () => {
+    const fsMock = {
+      'build.gradle': '(this file contains) com.palantir.consistent-versions',
+      'versions.props': `org.apache.lucene:* = 1.2.3`,
+    };
+    mockFs(fsMock);
+
+    const res = await extractAllPackageFiles(
+      {} as ExtractConfig,
+      Object.keys(fsMock)
+    );
+    expect(res).toBeNull();
+  });
+
+  it('gradle-consistent-versions plugin works for sub folders', () => {
+    const fsMock = {
+      'mysub/build.gradle.kts': `(this file contains) 'com.palantir.consistent-versions'`,
+      'mysub/versions.props': `org.apache.lucene:* = 1.2.3`,
+      'mysub/versions.lock': `org.apache.lucene:lucene-core:1.2.3`,
+      'othersub/build.gradle.kts': `nothing here`,
+    };
+    mockFs(fsMock);
+
+    expect(usesGcv('mysub/versions.props', fsMock)).toBeTrue();
+    expect(usesGcv('othersub/versions.props', fsMock)).toBeFalse();
+  });
+
+  it('gradle-consistent-versions multi levels of glob', async () => {
+    const fsMock = {
+      'build.gradle': '(this file contains) com.palantir.consistent-versions',
+      'versions.props': stripIndent`
+        org.apache.* = 4
+        org.apache.lucene:* = 3
+        org.apache.lucene:a.* = 2
+        org.apache.lucene:a.b = 1
+      `,
+      'versions.lock': stripIndent`
+        org.apache.solr:x.y:1 (10 constraints: 95be0c15)
+        org.apache.lucene:a.b:1 (10 constraints: 95be0c15)
+        org.apache.lucene:a.c:1 (10 constraints: 95be0c15)
+        org.apache.lucene:a.d:1 (10 constraints: 95be0c15)
+        org.apache.lucene:d:1 (10 constraints: 95be0c15)
+        org.apache.lucene:e.f:1 (10 constraints: 95be0c15)
+      `,
+    };
+    mockFs(fsMock);
+
+    const res = await extractAllPackageFiles(
+      {} as ExtractConfig,
+      Object.keys(fsMock)
+    );
+
+    // Each lock dep is only present once, with highest prio for exact prop match, then globs from longest to shortest
+    expect(res).toMatchObject([
+      {
+        packageFile: 'versions.lock',
+        datasource: 'maven',
+        deps: [],
+      },
+      {
+        packageFile: 'versions.props',
+        datasource: 'maven',
+        deps: [
+          {
+            managerData: {
+              packageFile: 'versions.props',
+              fileReplacePosition: 91,
+            },
+            packageName: 'org.apache.lucene:a.b',
+            currentValue: '1',
+            currentVersion: '1',
+            lockedVersion: '1',
+            fileReplacePosition: 91,
+            registryUrls: [],
+            depType: 'dependencies',
+          },
+          {
+            managerData: {
+              packageFile: 'versions.props',
+              fileReplacePosition: 65,
+            },
+            depName: 'org.apache.lucene:a.c',
+            currentValue: '2',
+            currentVersion: '2',
+            lockedVersion: '1',
+            groupName: 'org.apache.lucene:a.*',
+            fileReplacePosition: 65,
+            registryUrls: [],
+            depType: 'dependencies',
+          },
+          {
+            managerData: {
+              packageFile: 'versions.props',
+              fileReplacePosition: 65,
+            },
+            depName: 'org.apache.lucene:a.d',
+            currentValue: '2',
+            currentVersion: '2',
+            lockedVersion: '1',
+            groupName: 'org.apache.lucene:a.*',
+            fileReplacePosition: 65,
+            registryUrls: [],
+            depType: 'dependencies',
+          },
+          {
+            managerData: {
+              packageFile: 'versions.props',
+              fileReplacePosition: 39,
+            },
+            depName: 'org.apache.lucene:d',
+            currentValue: '3',
+            currentVersion: '3',
+            lockedVersion: '1',
+            groupName: 'org.apache.lucene:*',
+            fileReplacePosition: 39,
+            registryUrls: [],
+            depType: 'dependencies',
+          },
+          {
+            managerData: {
+              packageFile: 'versions.props',
+              fileReplacePosition: 39,
+            },
+            depName: 'org.apache.lucene:e.f',
+            currentValue: '3',
+            currentVersion: '3',
+            lockedVersion: '1',
+            groupName: 'org.apache.lucene:*',
+            fileReplacePosition: 39,
+            registryUrls: [],
+            depType: 'dependencies',
+          },
+        ],
+      },
+      {
+        packageFile: 'build.gradle',
+        datasource: 'maven',
+        deps: [],
+      },
+    ]);
+  });
+
+  it('gradle-consistent-versions plugin correct position for CRLF and LF', () => {
+    const crlfProps2ndLine = parsePropsFile(`a.b:c.d=1\r\na.b:c.e=2`)[0].get(
+      'a.b:c.e'
+    );
+    const lfProps2ndLine =
+      parsePropsFile(`a.b:c.d=1\na.b:c.e=2`)[0].get('a.b:c.e');
+
+    expect(crlfProps2ndLine?.filePos).toBe(19);
+    expect(lfProps2ndLine?.filePos).toBe(18);
+  });
+
+  it('gradle-consistent-versions plugin test bogus input lines', () => {
+    const parsedProps = parsePropsFile(stripIndent`
+      # comment:foo.bar = 1
+      123.foo:bar = 2
+      this has:spaces = 3
+       starts.with:space = 4
+      contains(special):chars = 5
+      a* = 6
+      this.is:valid.dep = 7
+      valid.glob:* = 8
+    `);
+
+    expect(parsedProps[0]?.size).toBe(1); // no 7 is valid exact dep
+    expect(parsedProps[1]?.size).toBe(1); // no 8 is valid glob dep
+
+    // lockfile
+    const parsedLock = parseLockFile(stripIndent`
+      # comment:foo.bar:1 (10 constraints: 95be0c15)
+      123.foo:bar:2 (10 constraints: 95be0c15)
+      this has:spaces:3 (10 constraints: 95be0c15)
+       starts.with:space:4 (10 constraints: 95be0c15)
+      contains(special):chars:5 (10 constraints: 95be0c15)
+      no.colon:6 (10 constraints: 95be0c15)
+      this.is:valid.dep:7 (10 constraints: 95be0c15)
+    `);
+
+    expect(parsedLock.size).toBe(1); // no 7 is valid exact dep
+  });
 });

lib/modules/manager/gradle/extract.ts

@@ -4,6 +4,12 @@ import { getFileContentMap } from '../../../util/fs';
 import { MavenDatasource } from '../../datasource/maven';
 import type { ExtractConfig, PackageDependency, PackageFile } from '../types';
 import { parseCatalog } from './extract/catalog';
+import {
+  isGcvLockFile,
+  isGcvPropsFile,
+  parseGcv,
+  usesGcv,
+} from './extract/consistent-versions-plugin';
 import { parseGradle, parseProps } from './parser';
 import type {
   GradleManagerData,
@@ -70,6 +76,13 @@ export async function extractAllPackageFiles(
       } else if (isTOMLFile(packageFile)) {
         const updatesFromCatalog = parseCatalog(packageFile, content);
         extractedDeps.push(...updatesFromCatalog);
+      } else if (isGcvLockFile(packageFile)) {
+        // Skip and do not trigger parsing, wait for VERSIONS_PROPS
+      } else if (isGcvPropsFile(packageFile)) {
+        if (usesGcv(packageFile, fileContents)) {
+          const updatesFromGcv = parseGcv(packageFile, fileContents);
+          extractedDeps.push(...updatesFromGcv);
+        } // else skip silently since this is just a name collision
       } else {
         const vars = getVars(registry, dir);
         const {