Implement recursive option for xmvn-resolve CLI

Author: mizdebsk

xmvn-tools/xmvn-resolve/src/main/java/org/fedoraproject/xmvn/tools/resolve/ResolverCli.java

@@ -17,11 +17,23 @@
 
 import io.kojan.xml.XMLException;
 import java.io.IOException;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Queue;
+import java.util.Set;
 import java.util.stream.Collectors;
 import org.fedoraproject.xmvn.artifact.Artifact;
+import org.fedoraproject.xmvn.config.Configuration;
+import org.fedoraproject.xmvn.config.Configurator;
+import org.fedoraproject.xmvn.config.ResolverSettings;
 import org.fedoraproject.xmvn.logging.Logger;
+import org.fedoraproject.xmvn.metadata.ArtifactMetadata;
+import org.fedoraproject.xmvn.metadata.Dependency;
+import org.fedoraproject.xmvn.metadata.MetadataRequest;
+import org.fedoraproject.xmvn.metadata.MetadataResolver;
+import org.fedoraproject.xmvn.metadata.MetadataResult;
 import org.fedoraproject.xmvn.resolver.ResolutionRequest;
 import org.fedoraproject.xmvn.resolver.ResolutionResult;
 import org.fedoraproject.xmvn.resolver.Resolver;
@@ -41,12 +53,19 @@
  */
 public class ResolverCli {
     private final Logger logger;
-
     private final Resolver resolver;
-
-    public ResolverCli(Logger logger, Resolver resolver) {
+    private final Configurator configurator;
+    private final MetadataResolver metadataResolver;
+
+    public ResolverCli(
+            Logger logger,
+            Resolver resolver,
+            Configurator configurator,
+            MetadataResolver metadataResolver) {
         this.logger = logger;
         this.resolver = resolver;
+        this.configurator = configurator;
+        this.metadataResolver = metadataResolver;
     }
 
     private List<ResolutionRequest> parseRequests(ResolverCliRequest cli)
@@ -92,16 +111,59 @@ public int run(ResolverCliRequest cliRequest) throws IOException, XMLException {
         try {
             boolean error = false;
 
-            List<ResolutionRequest> requests = parseRequests(cliRequest);
+            Queue<ResolutionRequest> requestsQueue = new ArrayDeque<>(parseRequests(cliRequest));
             List<ResolutionResult> results = new ArrayList<>();
 
-            for (ResolutionRequest request : requests) {
+            Set<Artifact> requestedArtifacts = new LinkedHashSet<>();
+            for (ResolutionRequest request : requestsQueue) {
+                requestedArtifacts.add(request.getArtifact());
+            }
+
+            MetadataResult metadataResult = null;
+            if (cliRequest.isRecursive()) {
+                Configuration configuration = configurator.getConfiguration();
+                ResolverSettings resolverSettings = configuration.getResolverSettings();
+                List<String> metadataRepositories = resolverSettings.getMetadataRepositories();
+                MetadataRequest metadataRequest = new MetadataRequest(metadataRepositories);
+                metadataResult = metadataResolver.resolveMetadata(metadataRequest);
+            }
+
+            while (!requestsQueue.isEmpty()) {
+                ResolutionRequest request = requestsQueue.remove();
                 ResolutionResult result = resolver.resolve(request);
                 results.add(result);
 
                 if (result.getArtifactPath() == null) {
                     error = true;
                     logger.error("Unable to resolve artifact {}", request.getArtifact());
+                    continue;
+                }
+
+                if (cliRequest.isRecursive()) {
+                    Artifact requestedArtifact = request.getArtifact();
+                    String resolvedVersion = result.getCompatVersion();
+                    Artifact resolvedArtifact = requestedArtifact.withVersion(resolvedVersion);
+                    ArtifactMetadata artifactMetadata =
+                            metadataResult.getMetadataFor(resolvedArtifact);
+                    for (Dependency dependency : artifactMetadata.getDependencies()) {
+                        Artifact dependencyArtifact =
+                                Artifact.of(
+                                        dependency.getGroupId(),
+                                        dependency.getArtifactId(),
+                                        dependency.getExtension(),
+                                        dependency.getClassifier(),
+                                        dependency.getResolvedVersion());
+                        logger.debug(
+                                "Also resolving artifact {} as a dependency of {}",
+                                dependencyArtifact,
+                                requestedArtifact);
+                        if (requestedArtifacts.add(dependencyArtifact)) {
+                            ResolutionRequest dependencyRequest =
+                                    new ResolutionRequest(dependencyArtifact);
+                            dependencyRequest.setPersistentFileNeeded(true);
+                            requestsQueue.add(dependencyRequest);
+                        }
+                    }
                 }
             }
 

xmvn-tools/xmvn-resolve/src/main/java/org/fedoraproject/xmvn/tools/resolve/ResolverCliRequest.java

@@ -22,9 +22,11 @@
 import java.util.Properties;
 import java.util.TreeMap;
 import java.util.concurrent.Callable;
+import org.fedoraproject.xmvn.config.Configurator;
 import org.fedoraproject.xmvn.locator.ServiceLocator;
 import org.fedoraproject.xmvn.locator.ServiceLocatorFactory;
 import org.fedoraproject.xmvn.logging.Logger;
+import org.fedoraproject.xmvn.metadata.MetadataResolver;
 import org.fedoraproject.xmvn.resolver.Resolver;
 import picocli.CommandLine.Command;
 import picocli.CommandLine.IVersionProvider;
@@ -53,6 +55,12 @@ final class ResolverCliRequest implements Callable<Integer>, IVersionProvider {
             description = "Use colon instead of new line to separate resolved artifacts.")
     private boolean classpath;
 
+    @Option(
+            names = {"-r", "--recursive"},
+            description =
+                    "Also include all runtime dependencies of specified artifacts, recursively.")
+    private boolean recursive;
+
     @Option(
             names = {"--raw-request"},
             description =
@@ -85,17 +93,21 @@ public Integer call() {
             System.setProperty("xmvn.debug", "true");
         }
 
-        if (raw && (classpath || !parameters.isEmpty())) {
+        if (raw && (classpath || !parameters.isEmpty() || recursive)) {
             throw new IllegalArgumentException("--raw-request must be used alone");
         }
 
-        for (String param : defines.keySet()) System.setProperty(param, defines.get(param));
+        for (String param : defines.keySet()) {
+            System.setProperty(param, defines.get(param));
+        }
 
         ServiceLocator locator = new ServiceLocatorFactory().createServiceLocator();
         Logger logger = locator.getService(Logger.class);
         Resolver resolver = locator.getService(Resolver.class);
+        Configurator configurator = locator.getService(Configurator.class);
+        MetadataResolver metadataResolver = locator.getService(MetadataResolver.class);
 
-        ResolverCli cli = new ResolverCli(logger, resolver);
+        ResolverCli cli = new ResolverCli(logger, resolver, configurator, metadataResolver);
 
         try {
             return cli.run(this);
@@ -130,6 +142,14 @@ public void setClasspath(boolean classpath) {
         this.classpath = classpath;
     }
 
+    public boolean isRecursive() {
+        return recursive;
+    }
+
+    public void setRecursive(boolean recursive) {
+        this.recursive = recursive;
+    }
+
     public boolean isRaw() {
         return raw;
     }