This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a commit to branch maven-4.0.x
in repository https://gitbox.apache.org/repos/asf/maven.git
The following commit(s) were added to refs/heads/maven-4.0.x by this push:
new 66f08bb89e [Backport maven-4.0.x] #12771: Fix #12770: do not resolve
unversioned plugins to pre-releases (#13991)
66f08bb89e is described below
commit 66f08bb89e5a88d1ea9093cf92f8c9ad8237d7fa
Author: Guillaume Nodet <[email protected]>
AuthorDate: Mon Nov 16 15:27:57 2026 +0100
[Backport maven-4.0.x] #12771: Fix #12770: do not resolve unversioned
plugins to pre-releases (#13991)
Port of #12771 to maven-4.0.x.
DefaultPluginVersionResolver.selectVersion() on 4.0.x had no pre-release
awareness: it partitioned available versions only into RELEASE and SNAPSHOT
buckets, so a plugin whose latest 'release' metadata entry pointed at e.g.
3.0.0-beta-2 would be selected even when 2.1.0 (a stable release) existed.
Changes applied:
- Add isPreRelease(version) using GenericQualifiers.qualifier() (available
since maven-resolver 2.0.21, already on 4.0.x at 2.0.25)
- Add hasStableVersion(versions) to detect whether a stable fallback exists
- Add isParseable(version) for the stable-version filter
- Add selectCompatible(request, candidates, kind) helper to deduplicate the
RELEASE/PRE-RELEASE/SNAPSHOT selection loop
- In selectVersion(), skip a pre-release RELEASE/LATEST metadata entry when
a stable version is available; partition the fallback search into three
buckets (RELEASE > PRE-RELEASE > SNAPSHOT)
- Add DefaultPluginVersionResolverTest covering all classifier cases
Cherry-pick equivalent of merge commit
7dc59176c0b0cb09198bef11425b97ece582c606.
---
.../internal/DefaultPluginVersionResolver.java | 122 ++++++++++----
.../internal/DefaultPluginVersionResolverTest.java | 186 +++++++++++++++++++++
2 files changed, 280 insertions(+), 28 deletions(-)
diff --git
a/impl/maven-core/src/main/java/org/apache/maven/plugin/version/internal/DefaultPluginVersionResolver.java
b/impl/maven-core/src/main/java/org/apache/maven/plugin/version/internal/DefaultPluginVersionResolver.java
index b2afbb073e..6d7b294bc0 100644
---
a/impl/maven-core/src/main/java/org/apache/maven/plugin/version/internal/DefaultPluginVersionResolver.java
+++
b/impl/maven-core/src/main/java/org/apache/maven/plugin/version/internal/DefaultPluginVersionResolver.java
@@ -58,6 +58,7 @@
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.MetadataRequest;
import org.eclipse.aether.resolution.MetadataResult;
+import org.eclipse.aether.util.version.GenericQualifiers;
import org.eclipse.aether.version.InvalidVersionSpecificationException;
import org.eclipse.aether.version.Version;
import org.eclipse.aether.version.VersionScheme;
@@ -172,7 +173,8 @@ private PluginVersionResult
resolveFromRepository(PluginVersionRequest request)
return result;
}
- private void selectVersion(DefaultPluginVersionResult result,
PluginVersionRequest request, Versions versions)
+ // package-private for testing
+ void selectVersion(DefaultPluginVersionResult result, PluginVersionRequest
request, Versions versions)
throws PluginVersionResolutionException {
String version = null;
ArtifactRepository repo = null;
@@ -186,6 +188,21 @@ private void selectVersion(DefaultPluginVersionResult
result, PluginVersionReque
version = versions.latestVersion;
repo = versions.latestRepository;
}
+ // A pre-release (alpha/beta/milestone/rc) is a "release" as far as
repository metadata is
+ // concerned, but it is not what a user asking for an unversioned
plugin expects: such
+ // versions are typically built against unstable APIs. Prefer a stable
version whenever the
+ // repository offers one, and fall back to the pre-release only when
it does not.
+ if (version != null && isPreRelease(version) &&
hasStableVersion(versions)) {
+ logger.info(
+ "Metadata of plugin {}:{} points at pre-release version
{}, looking for a stable version",
+ request.getGroupId(),
+ request.getArtifactId(),
+ version);
+ version = null;
+ repo = null;
+ searchPerformed = true;
+ }
+
if (version != null && !isCompatible(request, version)) {
logger.info(
"Latest version of plugin {}:{} failed compatibility
check",
@@ -198,6 +215,7 @@ private void selectVersion(DefaultPluginVersionResult
result, PluginVersionReque
if (version == null) {
TreeSet<Version> releases = new
TreeSet<>(Collections.reverseOrder());
+ TreeSet<Version> preReleases = new
TreeSet<>(Collections.reverseOrder());
TreeSet<Version> snapshots = new
TreeSet<>(Collections.reverseOrder());
for (String ver : versions.versions.keySet()) {
@@ -206,6 +224,8 @@ private void selectVersion(DefaultPluginVersionResult
result, PluginVersionReque
if (ver.endsWith("-SNAPSHOT")) {
snapshots.add(v);
+ } else if (isPreRelease(ver)) {
+ preReleases.add(v);
} else {
releases.add(v);
}
@@ -214,34 +234,15 @@ private void selectVersion(DefaultPluginVersionResult
result, PluginVersionReque
}
}
- if (!releases.isEmpty()) {
- logger.info(
- "Looking for compatible RELEASE version of plugin
{}:{}",
- request.getGroupId(),
- request.getArtifactId());
- for (Version v : releases) {
- String ver = v.toString();
- if (isCompatible(request, ver)) {
- version = ver;
- repo = versions.versions.get(version);
- break;
- }
- }
+ version = selectCompatible(request, releases, "RELEASE");
+ if (version == null) {
+ version = selectCompatible(request, preReleases,
"PRE-RELEASE");
}
-
- if (version == null && !snapshots.isEmpty()) {
- logger.info(
- "Looking for compatible SNAPSHOT version of plugin
{}:{}",
- request.getGroupId(),
- request.getArtifactId());
- for (Version v : snapshots) {
- String ver = v.toString();
- if (isCompatible(request, ver)) {
- version = ver;
- repo = versions.versions.get(version);
- break;
- }
- }
+ if (version == null) {
+ version = selectCompatible(request, snapshots, "SNAPSHOT");
+ }
+ if (version != null) {
+ repo = versions.versions.get(version);
}
}
@@ -270,6 +271,71 @@ private void selectVersion(DefaultPluginVersionResult
result, PluginVersionReque
}
}
+ /**
+ * Returns the newest version of {@code candidates} that passes {@link
#isCompatible}, or {@code null}.
+ */
+ private String selectCompatible(PluginVersionRequest request,
TreeSet<Version> candidates, String kind) {
+ if (candidates.isEmpty()) {
+ return null;
+ }
+ logger.info(
+ "Looking for compatible {} version of plugin {}:{}",
+ kind,
+ request.getGroupId(),
+ request.getArtifactId());
+ for (Version v : candidates) {
+ String ver = v.toString();
+ if (isCompatible(request, ver)) {
+ return ver;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Does the repository offer at least one version that is neither a
snapshot nor a pre-release?
+ */
+ // package-private for testing
+ boolean hasStableVersion(Versions versions) {
+ for (String ver : versions.versions.keySet()) {
+ if (!ver.endsWith("-SNAPSHOT") && !isPreRelease(ver) &&
isParseable(ver)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Only versions the scheme can parse are selectable, so only those may
count as a stable fallback.
+ */
+ private boolean isParseable(String version) {
+ try {
+ versionScheme.parseVersion(version);
+ return true;
+ } catch (InvalidVersionSpecificationException e) {
+ return false;
+ }
+ }
+
+ /**
+ * Is this an unstable precursor of its base version, such as {@code
4.0.0-beta-1},
+ * {@code 1.0-alpha-2} or {@code 1.0-SNAPSHOT}?
+ * <p>
+ * Delegates to the version scheme's own qualifier table: a negative
qualifier shift marks a
+ * preview version (alpha, beta, milestone, rc/cr, snapshot), zero a final
one (ga, final,
+ * release) and a positive one a service pack. Versions without a
recognised qualifier -- and
+ * that includes build or vendor qualifiers such as {@code 33.7.0-jre} --
are not pre-releases.
+ * Snapshots satisfy this too; callers classify them first, so they never
reach the pre-release
+ * bucket.
+ *
+ * @param version the version to inspect, may carry no qualifier at all
+ * @return {@code true} if the version is an unstable precursor of its
base version
+ */
+ // package-private for testing
+ boolean isPreRelease(String version) {
+ return
GenericQualifiers.qualifier(version).orElse(GenericQualifiers.QUALIFIER_ZERO) <
0;
+ }
+
private boolean isCompatible(PluginVersionRequest request, String version)
{
Plugin plugin = new Plugin();
plugin.setGroupId(request.getGroupId());
diff --git
a/impl/maven-core/src/test/java/org/apache/maven/plugin/version/internal/DefaultPluginVersionResolverTest.java
b/impl/maven-core/src/test/java/org/apache/maven/plugin/version/internal/DefaultPluginVersionResolverTest.java
new file mode 100644
index 0000000000..f995b4ddc1
--- /dev/null
+++
b/impl/maven-core/src/test/java/org/apache/maven/plugin/version/internal/DefaultPluginVersionResolverTest.java
@@ -0,0 +1,186 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.plugin.version.internal;
+
+import org.apache.maven.plugin.MavenPluginManager;
+import org.apache.maven.plugin.descriptor.PluginDescriptor;
+import org.apache.maven.plugin.version.DefaultPluginVersionRequest;
+import org.eclipse.aether.util.version.GenericVersionScheme;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.Mockito;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Which versions are excluded when a plugin is resolved without a declared
version.
+ */
+class DefaultPluginVersionResolverTest {
+
+ private final DefaultPluginVersionResolver resolver =
+ new DefaultPluginVersionResolver(null, null, null, new
GenericVersionScheme());
+
+ /**
+ * A resolver for which every candidate passes the compatibility check, so
the tests observe the
+ * selection order alone.
+ */
+ private static DefaultPluginVersionResolver
resolverAcceptingEveryVersion() throws Exception {
+ MavenPluginManager pluginManager =
Mockito.mock(MavenPluginManager.class);
+ Mockito.when(pluginManager.getPluginDescriptor(Mockito.any(),
Mockito.any(), Mockito.any()))
+ .thenReturn(new PluginDescriptor());
+ return new DefaultPluginVersionResolver(null, null, pluginManager, new
GenericVersionScheme());
+ }
+
+ private static DefaultPluginVersionResolver.Versions versions(String
release, String... available) {
+ DefaultPluginVersionResolver.Versions versions = new
DefaultPluginVersionResolver.Versions();
+ versions.releaseVersion = release;
+ for (String version : available) {
+ versions.versions.put(version, null);
+ }
+ return versions;
+ }
+
+ private static DefaultPluginVersionResolver.Versions
versionsWithLatest(String latest, String... available) {
+ DefaultPluginVersionResolver.Versions versions = new
DefaultPluginVersionResolver.Versions();
+ versions.latestVersion = latest;
+ for (String version : available) {
+ versions.versions.put(version, null);
+ }
+ return versions;
+ }
+
+ private static String select(DefaultPluginVersionResolver resolver,
DefaultPluginVersionResolver.Versions versions)
+ throws Exception {
+ DefaultPluginVersionResult result = new DefaultPluginVersionResult();
+ resolver.selectVersion(
+ result,
+ new DefaultPluginVersionRequest()
+ .setGroupId("org.apache.maven.plugins")
+ .setArtifactId("maven-it-plugin"),
+ versions);
+ return result.getVersion();
+ }
+
+ @ParameterizedTest
+ @ValueSource(
+ strings = {
+ "1.0-alpha-1",
+ "1.0-alpha1",
+ "1.0-beta-1",
+ "4.0.0-beta-1",
+ "1.0-milestone-1",
+ "1.0-M1",
+ "1.0-rc-1",
+ "1.0-rc1",
+ "1.0-cr1",
+ "1.0-b2", // short form, as GenericQualifiers reads it
+ "1.0.beta.1", // the scheme treats '.' and '-' as the same
separator
+ "1.0_alpha_1",
+ "1.0-SNAPSHOT"
+ })
+ void preReleaseQualifiersAreExcluded(String version) {
+ assertTrue(resolver.isPreRelease(version), version + " should count as
a pre-release");
+ }
+
+ @ParameterizedTest
+ @ValueSource(
+ strings = {
+ "1.0",
+ "1.0.1",
+ "3.15.0",
+ "4.0.0",
+ "33.7.0-jre", // vendor/classifier qualifier, not a pre-release
+ "1.0-arc", // contains "rc" but is not a release candidate
+ "1.0-sp1", // service pack: sorts *after* the release
+ "1.0-final", // alias of the release itself
+ "1.0-ga"
+ })
+ void releasesAreNotExcluded(String version) {
+ assertFalse(resolver.isPreRelease(version), version + " should not
count as a pre-release");
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"", "-", "not-a-version"})
+ void unparseableVersionsAreNotExcluded(String version) {
+ assertFalse(resolver.isPreRelease(version), version + " should not
count as a pre-release");
+ }
+
+ @Test
+ void stableVersionIsDetectedAmongPreReleases() {
+ DefaultPluginVersionResolver.Versions versions = new
DefaultPluginVersionResolver.Versions();
+ versions.versions.put("2.0-beta-1", null);
+ versions.versions.put("2.0-beta-2", null);
+ assertFalse(resolver.hasStableVersion(versions), "only pre-releases
available");
+
+ versions.versions.put("1.0-SNAPSHOT", null);
+ assertFalse(resolver.hasStableVersion(versions), "snapshots are not a
stable fallback either");
+
+ versions.versions.put("1.0", null);
+ assertTrue(resolver.hasStableVersion(versions), "1.0 is a stable
fallback");
+ }
+
+ @Test
+ void aStableVersionWinsOverThePreReleaseNamedByTheMetadata() throws
Exception {
+ assertEquals(
+ "1.0",
+ select(resolverAcceptingEveryVersion(), versions("2.0-beta-1",
"1.0", "2.0-beta-1")),
+ "metadata says 2.0-beta-1 is the RELEASE, but 1.0 is the
newest stable one");
+ }
+
+ @Test
+ void theNewestStableVersionIsSelected() throws Exception {
+ assertEquals(
+ "1.2", select(resolverAcceptingEveryVersion(),
versions("2.0-beta-1", "1.0", "1.2", "2.0-beta-1")));
+ }
+
+ @Test
+ void aPreReleaseIsUsedWhenNoStableVersionExists() throws Exception {
+ assertEquals(
+ "2.0-beta-2",
+ select(resolverAcceptingEveryVersion(), versions("2.0-beta-2",
"2.0-beta-1", "2.0-beta-2")),
+ "a plugin that only ever published pre-releases must still
resolve");
+ }
+
+ @Test
+ void aSnapshotIsTheLastResort() throws Exception {
+ assertEquals(
+ "1.0-SNAPSHOT",
+ select(resolverAcceptingEveryVersion(), versions("",
"1.0-SNAPSHOT")),
+ "snapshots rank below pre-releases");
+ }
+
+ @Test
+ void aStableReleaseVersionIsTakenAsIs() throws Exception {
+ assertEquals(
+ "2.0",
+ select(resolverAcceptingEveryVersion(), versions("2.0", "1.0",
"2.0")),
+ "no search is needed when the metadata already names a stable
version");
+ }
+
+ @Test
+ void latestVersionIsUsedWhenReleaseVersionIsAbsent() throws Exception {
+ assertEquals(
+ "1.0",
+ select(resolverAcceptingEveryVersion(),
versionsWithLatest("1.0", "1.0")),
+ "latestVersion is the fallback when releaseVersion is not
set");
+ }
+}