Issue #74: Add display-extension-updates

pom.xml

@@ -126,6 +126,7 @@
     <maven.compiler.source>${mojo.java.target}</maven.compiler.source>
     <junitBomVersion>5.9.1</junitBomVersion>
     <mavenVersion>3.2.5</mavenVersion>
+    <mavenEmbedderVersion>3.3.9</mavenEmbedderVersion>
     <doxiaVersion>1.12.0</doxiaVersion>
     <doxia-sitetoolsVersion>1.11.1</doxia-sitetoolsVersion>
     <pluginVersion>${project.version}</pluginVersion>
@@ -177,6 +178,12 @@
         <artifactId>maven-compat</artifactId>
         <version>${mavenVersion}</version>
       </dependency>
+      <dependency>
+        <groupId>org.apache.maven</groupId>
+        <artifactId>maven-embedder</artifactId>
+        <version>${mavenEmbedderVersion}</version>
+        <scope>provided</scope>
+      </dependency>
 
       <dependency>
         <groupId>org.apache.maven.enforcer</groupId>

versions-common/pom.xml

@@ -50,6 +50,10 @@
       <groupId>org.apache.maven</groupId>
       <artifactId>maven-settings</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-embedder</artifactId>
+    </dependency>
     <dependency>
       <groupId>com.fasterxml.woodstox</groupId>
       <artifactId>woodstox-core</artifactId>

versions-common/src/main/java/org/codehaus/mojo/versions/api/DefaultVersionsHelper.java

@@ -45,6 +45,7 @@
 import java.util.concurrent.Future;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
@@ -89,6 +90,7 @@
 import org.eclipse.aether.resolution.VersionRangeRequest;
 import org.eclipse.aether.resolution.VersionRangeResolutionException;
 
+import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 import static java.util.Optional.empty;
 import static java.util.Optional.of;
@@ -172,12 +174,35 @@ public Log getLog() {
     public ArtifactVersions lookupArtifactVersions(
             Artifact artifact, VersionRange versionRange, boolean usePluginRepositories)
             throws VersionRetrievalException {
+        return lookupArtifactVersions(artifact, versionRange, usePluginRepositories, !usePluginRepositories);
+    }
+
+    @Override
+    public ArtifactVersions lookupArtifactVersions(
+            Artifact artifact, VersionRange versionRange, boolean usePluginRepositories, boolean useProjectRepositories)
+            throws VersionRetrievalException {
         try {
             Collection<IgnoreVersion> ignoredVersions = getIgnoredVersions(artifact);
             if (!ignoredVersions.isEmpty() && getLog().isDebugEnabled()) {
                 getLog().debug("Found ignored versions: "
                         + ignoredVersions.stream().map(IgnoreVersion::toString).collect(Collectors.joining(", ")));
             }
+
+            final List<RemoteRepository> repositories;
+            if (usePluginRepositories && !useProjectRepositories) {
+                repositories = mavenSession.getCurrentProject().getRemotePluginRepositories();
+            } else if (!usePluginRepositories && useProjectRepositories) {
+                repositories = mavenSession.getCurrentProject().getRemoteProjectRepositories();
+            } else if (usePluginRepositories) {
+                repositories = Stream.concat(
+                                mavenSession.getCurrentProject().getRemoteProjectRepositories().stream(),
+                                mavenSession.getCurrentProject().getRemotePluginRepositories().stream())
+                        .distinct()
+                        .collect(Collectors.toList());
+            } else {
+                // testing?
+                repositories = emptyList();
+            }
             return new ArtifactVersions(
                     artifact,
                     aetherRepositorySystem
@@ -191,13 +216,7 @@ public ArtifactVersions lookupArtifactVersions(
                                                                     .findFirst()
                                                                     .map(Restriction::toString))
                                                             .orElse("(,)")),
-                                            usePluginRepositories
-                                                    ? mavenSession
-                                                            .getCurrentProject()
-                                                            .getRemotePluginRepositories()
-                                                    : mavenSession
-                                                            .getCurrentProject()
-                                                            .getRemoteProjectRepositories(),
+                                            repositories,
                                             "lookupArtifactVersions"))
                             .getVersions()
                             .stream()
@@ -428,16 +447,20 @@ public ArtifactVersion createArtifactVersion(String version) {
         return DefaultArtifactVersionCache.of(version);
     }
 
-    @Override
     public Map<Dependency, ArtifactVersions> lookupDependenciesUpdates(
-            Set<Dependency> dependencies, boolean usePluginRepositories, boolean allowSnapshots)
+            Set<Dependency> dependencies,
+            boolean usePluginRepositories,
+            boolean useProjectRepositories,
+            boolean allowSnapshots)
             throws VersionRetrievalException {
         ExecutorService executor = Executors.newFixedThreadPool(LOOKUP_PARALLEL_THREADS);
         try {
             Map<Dependency, ArtifactVersions> dependencyUpdates = new TreeMap<>(DependencyComparator.INSTANCE);
             List<Future<? extends Pair<Dependency, ArtifactVersions>>> futures = dependencies.stream()
                     .map(dependency -> executor.submit(() -> new ImmutablePair<>(
-                            dependency, lookupDependencyUpdates(dependency, usePluginRepositories, allowSnapshots))))
+                            dependency,
+                            lookupDependencyUpdates(
+                                    dependency, usePluginRepositories, useProjectRepositories, allowSnapshots))))
                     .collect(Collectors.toList());
             for (Future<? extends Pair<Dependency, ArtifactVersions>> details : futures) {
                 Pair<Dependency, ArtifactVersions> pair = details.get();
@@ -453,12 +476,22 @@ dependency, lookupDependencyUpdates(dependency, usePluginRepositories, allowSnap
         }
     }
 
+    @Override
+    public Map<Dependency, ArtifactVersions> lookupDependenciesUpdates(
+            Set<Dependency> dependencies, boolean usePluginRepositories, boolean allowSnapshots)
+            throws VersionRetrievalException {
+        return lookupDependenciesUpdates(dependencies, usePluginRepositories, !usePluginRepositories, allowSnapshots);
+    }
+
     @Override
     public ArtifactVersions lookupDependencyUpdates(
-            Dependency dependency, boolean usePluginRepositories, boolean allowSnapshots)
+            Dependency dependency,
+            boolean usePluginRepositories,
+            boolean useProjectRepositories,
+            boolean allowSnapshots)
             throws VersionRetrievalException {
-        ArtifactVersions allVersions =
-                lookupArtifactVersions(createDependencyArtifact(dependency), usePluginRepositories);
+        ArtifactVersions allVersions = lookupArtifactVersions(
+                createDependencyArtifact(dependency), null, usePluginRepositories, useProjectRepositories);
         return new ArtifactVersions(
                 allVersions.getArtifact(),
                 Arrays.stream(allVersions.getAllUpdates(allowSnapshots)).collect(Collectors.toList()),

versions-common/src/main/java/org/codehaus/mojo/versions/api/VersionsHelper.java

@@ -152,7 +152,7 @@ Artifact createDependencyArtifact(
      * <b>The resulting {@link ArtifactVersions} instance will contain all versions, including snapshots.</b>
      *
      * @param artifact The artifact to look for versions of.
-     * @param usePluginRepositories <code>true</code> will consult the pluginRepositories, while <code>false</code> will
+     * @param usePluginRepositories {@code true} will consult the pluginRepositories, while {@code false} will
      *            consult the repositories for normal dependencies.
      * @return The details of the available artifact versions.
      * @throws VersionRetrievalException thrown if version resolution fails
@@ -167,7 +167,24 @@ ArtifactVersions lookupArtifactVersions(Artifact artifact, boolean usePluginRepo
      * <b>The resulting {@link ArtifactVersions} instance will contain all versions, including snapshots.</b>
      *
      * @param artifact The artifact to look for versions of.
-     * @param versionRange versionRange to restrict the search
+     * @param versionRange versionRange to restrict the search, may be {@code null}
+     * @param usePluginRepositories {@code true} will consult the pluginRepositories
+     * @param useProjectRepositories {@code true} will consult regular project repositories
+     * @return The details of the available artifact versions.
+     * @throws VersionRetrievalException thrown if version resolution fails
+     * @since 2.15.0
+     */
+    ArtifactVersions lookupArtifactVersions(
+            Artifact artifact, VersionRange versionRange, boolean usePluginRepositories, boolean useProjectRepositories)
+            throws VersionRetrievalException;
+
+    /**
+     * Looks up the versions of the specified artifact that are available in either the local repository, or the
+     * appropriate remote repositories.
+     * <b>The resulting {@link ArtifactVersions} instance will contain all versions, including snapshots.</b>
+     *
+     * @param artifact The artifact to look for versions of.
+     * @param versionRange versionRange to restrict the search, may be {@code null}
      * @param usePluginRepositories <code>true</code> will consult the pluginRepositories, while <code>false</code> will
      *            consult the repositories for normal dependencies.
      * @return The details of the available artifact versions.
@@ -190,18 +207,39 @@ Map<Dependency, ArtifactVersions> lookupDependenciesUpdates(
             Set<Dependency> dependencies, boolean usePluginRepositories, boolean allowSnapshots)
             throws VersionRetrievalException;
 
+    /**
+     * Returns a map of all possible updates per dependency. The lookup is done in parallel using
+     * {@code LOOKUP_PARALLEL_THREADS} threads.
+     *
+     * @param dependencies The set of {@link Dependency} instances to look up.
+     * @param usePluginRepositories Search the plugin repositories.
+     * @param useProjectRepositories whether to use regular project repositories
+     * @param allowSnapshots whether snapshots should be included
+     * @return map containing the ArtifactVersions object per dependency
+     */
+    Map<Dependency, ArtifactVersions> lookupDependenciesUpdates(
+            Set<Dependency> dependencies,
+            boolean usePluginRepositories,
+            boolean useProjectRepositories,
+            boolean allowSnapshots)
+            throws VersionRetrievalException;
+
     /**
      * Creates an {@link org.codehaus.mojo.versions.api.ArtifactVersions} instance from a dependency.
      *
      * @param dependency The dependency.
      * @param usePluginRepositories Search the plugin repositories.
+     * @param useProjectRepositories whether to use regular project repositories
      * @param allowSnapshots whether snapshots should be included
      * @return The details of updates to the dependency.
      * @throws VersionRetrievalException thrown if version resolution fails
      * @since 1.0-beta-1
      */
     ArtifactVersions lookupDependencyUpdates(
-            Dependency dependency, boolean usePluginRepositories, boolean allowSnapshots)
+            Dependency dependency,
+            boolean usePluginRepositories,
+            boolean useProjectRepositories,
+            boolean allowSnapshots)
             throws VersionRetrievalException;
 
     /**

versions-common/src/main/java/org/codehaus/mojo/versions/filtering/DependencyFilter.java

@@ -66,10 +66,14 @@ public Set<Dependency> removingFrom(Collection<Dependency> dependencies) {
         return filterBy(dependencies, not(this::matchersMatch));
     }
 
-    private boolean matchersMatch(Dependency dependency) {
+    public boolean matchersMatch(Dependency dependency) {
         return matchers.stream().anyMatch(m -> m.test(dependency));
     }
 
+    public boolean matchersDontMatch(Dependency dependency) {
+        return !matchersMatch(dependency);
+    }
+
     private TreeSet<Dependency> filterBy(Collection<Dependency> dependencies, Predicate<Dependency> predicate) {
         return dependencies.stream()
                 .filter(predicate)

versions-common/src/main/java/org/codehaus/mojo/versions/utils/CoreExtensionUtils.java

@@ -0,0 +1,64 @@
+package org.codehaus.mojo.versions.utils;
+
+/*
+ * Copyright MojoHaus and Contributors
+ *
+ * Licensed 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.
+ */
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
+
+import org.apache.maven.cli.internal.extension.model.io.xpp3.CoreExtensionsXpp3Reader;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.model.Extension;
+import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
+
+/**
+ * Utilities for reading and handling core extensions.
+ *
+ * @author Andrzej Jarmoniuk
+ * @since 2.15.0
+ */
+public final class CoreExtensionUtils {
+    /**
+     * Reads the core extensions (not build extensions) configured for the given project
+     * from the {@code ${project}/.mvn/extensions.xml} file.
+     *
+     * @param session {@link MavenSession} instance
+     * @return stream of core extensions defined in the {@code ${project}/.mvn/extensions.xml} file
+     * @throws IOException thrown if a file I/O operation fails
+     * @throws XmlPullParserException thrown if the file cannot be parsed
+     * @since 2.15.0
+     */
+    public static Stream<Extension> getCoreExtensions(MavenSession session) throws IOException, XmlPullParserException {
+        Path extensionsFile = session.getCurrentProject().getBasedir().toPath().resolve(".mvn/extensions.xml");
+        if (!Files.isRegularFile(extensionsFile)) {
+            return Stream.empty();
+        }
+
+        try (Reader reader = new BufferedReader(new InputStreamReader(Files.newInputStream(extensionsFile)))) {
+            return new CoreExtensionsXpp3Reader()
+                    .read(reader).getExtensions().stream().map(ex -> ExtensionBuilder.newBuilder()
+                            .withGroupId(ex.getGroupId())
+                            .withArtifactId(ex.getArtifactId())
+                            .withVersion(ex.getVersion())
+                            .build());
+        }
+    }
+}

versions-common/src/main/java/org/codehaus/mojo/versions/utils/DependencyBuilder.java

@@ -136,7 +136,9 @@ public static DependencyBuilder newBuilder() {
      * @param artifactId artifactId of the dependency
      * @param version version of the dependency
      * @return new instance of {@linkplain Dependency}
+     * @deprecated please use the {@link #newBuilder()} method instead
      */
+    @Deprecated
     public static Dependency dependencyWith(String groupId, String artifactId, String version) {
         return newBuilder()
                 .withGroupId(groupId)
@@ -154,7 +156,9 @@ public static Dependency dependencyWith(String groupId, String artifactId, Strin
      * @param classifier classifier of the dependency
      * @param scope scope of the dependency
      * @return new instance of {@linkplain Dependency}
+     * @deprecated please use the {@link #newBuilder()} method instead
      */
+    @Deprecated
     public static Dependency dependencyWith(
             String groupId, String artifactId, String version, String type, String classifier, String scope) {
         return newBuilder()