#131: Support for tool dependencies

cli/src/main/java/com/devonfw/tools/ide/tool/LocalToolCommandlet.java

@@ -4,21 +4,35 @@
 import com.devonfw.tools.ide.context.IdeContext;
 import com.devonfw.tools.ide.io.FileAccess;
 import com.devonfw.tools.ide.io.FileCopyMode;
+import com.devonfw.tools.ide.json.mapping.JsonMapping;
 import com.devonfw.tools.ide.log.IdeLogLevel;
 import com.devonfw.tools.ide.repo.ToolRepository;
+import com.devonfw.tools.ide.url.model.file.dependencyJson.DependencyInfo;
+import com.devonfw.tools.ide.url.model.file.dependencyJson.DependencyJson;
 import com.devonfw.tools.ide.version.VersionIdentifier;
+import com.devonfw.tools.ide.version.VersionRange;
+import com.fasterxml.jackson.databind.ObjectMapper;
 
+import java.io.BufferedReader;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.util.Set;
+import java.util.List;
+import java.util.Map;
+import java.util.Iterator;
+import java.util.stream.Stream;
 
 /**
  * {@link ToolCommandlet} that is installed locally into the IDE.
  */
 public abstract class LocalToolCommandlet extends ToolCommandlet {
 
+  private static final ObjectMapper MAPPER = JsonMapping.create();
+
+  private static final String dependencyFileName = "dependencies.json";
+
   /**
    * The constructor.
    *
@@ -32,7 +46,6 @@ public LocalToolCommandlet(IdeContext context, String tool, Set<String> tags) {
     super(context, tool, tags);
   }
 
-
   /**
    * @return the {@link Path} where the tool is located (installed).
    */
@@ -63,6 +76,12 @@ protected boolean doInstall(boolean silent) {
     // install configured version of our tool in the software repository if not already installed
     ToolInstallation installation = installInRepo(configuredVersion);
 
+    if (Files.exists(getDependencyJsonPath())) {
+      installDependency();
+    } else {
+      this.context.info("No Dependencies file found");
+    }
+
     // check if we already have this version installed (linked) locally in IDE_HOME/software
     VersionIdentifier installedVersion = getInstalledVersion();
     VersionIdentifier resolvedVersion = installation.resolvedVersion();
@@ -182,4 +201,128 @@ private boolean isInstalledVersion(VersionIdentifier expectedVersion, VersionIde
     return false;
   }
 
+  /**
+   * Method to get the Path of the dependencies Json file
+   * 
+   * @return the {@link Path} of the dependencies file for the tool
+   */
+  private Path getDependencyJsonPath() {
+
+    Path URLspath = this.context.getUrlsPath();
+    Path toolPath = URLspath.resolve(getName()).resolve(getEdition());
+    return toolPath.resolve(dependencyFileName);
+  }
+
+  private void installDependency() {
+
+    List<DependencyInfo> dependencies = readJson();
+
+    try {
+      for (DependencyInfo dependencyInfo : dependencies) {
+        VersionRange dependencyVersionRangeFound = VersionRange.of(dependencyInfo.getVersionRange());
+        String dependencyName = dependencyInfo.getDependency();
+        ToolCommandlet dependencyTool = this.context.getCommandletManager().getToolCommandlet(dependencyName);
+        VersionIdentifier dependencyVersionToInstall = findDependencyVersionToInstall(dependencyVersionRangeFound,
+            dependencyName);
+
+        String DefaultToolRepositoryID = this.context.getDefaultToolRepository().getId();
+        Path dependencyRepository = this.context.getSoftwareRepositoryPath().resolve(DefaultToolRepositoryID)
+            .resolve(dependencyName).resolve(dependencyTool.getEdition());
+
+        if (versionExistsInRepository(dependencyRepository, dependencyVersionRangeFound)) {
+          this.context.info("Necessary version of the dependency {} is already installed in repository",
+              dependencyName);
+        } else {
+          this.context.info("The version {} of the dependency {} is being installed", dependencyVersionToInstall,
+              dependencyName);
+          LocalToolCommandlet dependencyLocal = (LocalToolCommandlet) dependencyTool;
+          dependencyLocal.installInRepo(dependencyVersionToInstall);
+          this.context.info("The version {} of the dependency {} was successfully installed",
+              dependencyVersionToInstall, dependencyName);
+        }
+      }
+    } catch (Exception e) {
+      this.context.error("Error occurred: {}", e);
+    }
+  }
+
+  private List<DependencyInfo> readJson() {
+
+    Path dependencyJsonPath = getDependencyJsonPath();
+
+    try (BufferedReader reader = Files.newBufferedReader(dependencyJsonPath)) {
+      DependencyJson dependencyJson = MAPPER.readValue(reader, DependencyJson.class);
+      return findDependenciesFromJson(dependencyJson.getDependencies(), getConfiguredVersion());
+    } catch (Exception e) {
+      throw new IllegalStateException("Failed to load " + dependencyJsonPath, e);
+    }
+  }
+
+  /**
+   * Method to search the List of versions available in the ide and find the right version to install
+   *
+   * @param dependencyVersionRangeFound the {@link VersionRange} of the dependency that was found that needs to be
+   *        installed
+   * @param dependency the {@link String} of the dependency tool
+   *
+   * @return {@link VersionIdentifier} of the dependency that is to be installed
+   */
+  private VersionIdentifier findDependencyVersionToInstall(VersionRange dependencyVersionRangeFound,
+      String dependency) {
+
+    String dependencyEdition = this.context.getVariables().getToolEdition(dependency);
+
+    List<VersionIdentifier> versions = this.context.getUrls().getSortedVersions(dependency, dependencyEdition);
+
+    for (VersionIdentifier vi : versions) {
+      if (dependencyVersionRangeFound.contains(vi)) {
+        return vi;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Method to check if in the repository of the dependency there is a Version greater or equal to the version to be
+   * installed
+   *
+   * @param dependencyRepositoryPath the {@link Path} of the dependency repository
+   * @param dependencyVersionRangeFound the {@link VersionRange} of the dependency version to be installed
+   *
+   * @return the {@code true} if such version exists in repository already, or {@code false} otherwise
+   */
+  private boolean versionExistsInRepository(Path dependencyRepositoryPath,
+      VersionRange dependencyVersionRangeFound) {
+
+    try (Stream<Path> versions = Files.list(dependencyRepositoryPath)) {
+      Iterator<Path> versionsIterator = versions.iterator();
+      while (versionsIterator.hasNext()) {
+        VersionIdentifier versionFound = VersionIdentifier.of(versionsIterator.next().getFileName().toString());
+        if (dependencyVersionRangeFound.contains(versionFound)) {
+          return true;
+        }
+      }
+    } catch (IOException e) {
+      throw new IllegalStateException("Failed to iterate through " + dependencyRepositoryPath, e);
+    }
+    return false;
+  }
+
+  private List<DependencyInfo> findDependenciesFromJson(Map<String, List<DependencyInfo>> dependencies,
+      VersionIdentifier toolVersionToCheck) {
+
+    for (Map.Entry<String, List<DependencyInfo>> map : dependencies.entrySet()) {
+
+      String versionKey = map.getKey();
+      VersionIdentifier foundToolVersion = VersionIdentifier.of(versionKey);
+
+      // if a newer (greater) version is available, that is not already in the Json file
+      if (toolVersionToCheck.getStart().compareVersion(foundToolVersion.getStart()).isGreater()) {
+        return null;
+      } else if (foundToolVersion.matches(toolVersionToCheck)) {
+        return map.getValue();
+      }
+    }
+    return null;
+  }
 }

cli/src/main/java/com/devonfw/tools/ide/url/model/file/dependencyJson/DependencyInfo.java

@@ -0,0 +1,15 @@
+package com.devonfw.tools.ide.url.model.file.dependencyJson;
+
+public final class DependencyInfo {
+  private String dependency;
+  private String versionRange;
+
+  public String getDependency() {
+    return dependency;
+  }
+
+  public String getVersionRange() {
+    return versionRange;
+  }
+
+}

cli/src/main/java/com/devonfw/tools/ide/url/model/file/dependencyJson/DependencyJson.java

@@ -0,0 +1,19 @@
+package com.devonfw.tools.ide.url.model.file.dependencyJson;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class DependencyJson {
+  private final Map<String, List<DependencyInfo>> dependencies;
+
+  public DependencyJson() {
+
+    this.dependencies = new LinkedHashMap<>();
+  }
+
+  public Map<String, List<DependencyInfo>> getDependencies() {
+
+    return this.dependencies;
+  }
+}