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

Reply via email to