#2178: Make Release commandlet build-tool independent

CHANGELOG.adoc

@@ -44,6 +44,7 @@ The full list of changes for this release can be found in https://github.com/dev
 
 Release with new features and bugfixes:
 
+* https://github.com/devonfw/IDEasy/issues/2178[#2178]: Make ReleaseCommandlet independent of specific build commandlet
 * https://github.com/devonfw/IDEasy/issues/2197[#2197]: Fix broken python integration
 * https://github.com/devonfw/IDEasy/issues/2131[#2131]: Improve `ide upgrade --mode=` auto-completion
 * https://github.com/devonfw/IDEasy/issues/1870[#1870]: Add generic get-version implementation for global tools under windows

cli/src/main/java/com/devonfw/tools/ide/commandlet/BuildCommandlet.java

@@ -50,23 +50,35 @@ protected void doRun() {
       throw new CliException("Missing current working directory!");
     }
 
+    LocalToolCommandlet commandlet = findBuildCommandlet(this.context, buildPath);
+    if (commandlet == null) {
+      throw new CliException("Could not find a build descriptor in " + buildPath + " - no supported build tool detected.");
+    }
     List<String> args = this.arguments.asList();
-    LocalToolCommandlet commandlet = null;
+    if (args.isEmpty()) {
+      String variableName = commandlet.getName().toUpperCase(Locale.ROOT) + "_BUILD_OPTS";
+      args = getDefaultToolOptions(variableName);
+    }
+    commandlet.runTool(args);
+  }
+
+  /**
+   * Detects the applicable build tool for the given {@code buildPath} by {@link LocalToolCommandlet#findBuildDescriptor(Path) querying} the available build
+   * commandlets (in order of priority) for a matching build descriptor (e.g. {@code pom.xml}, {@code build.gradle} or {@code package.json}).
+   *
+   * @param context the {@link IdeContext}.
+   * @param buildPath the {@link Path} to the directory to build.
+   * @return the applicable build {@link LocalToolCommandlet} or {@code null} if no build descriptor was found.
+   */
+  static LocalToolCommandlet findBuildCommandlet(IdeContext context, Path buildPath) {
+
     for (Class<? extends LocalToolCommandlet> toolClass : BUILD_TOOLS) {
-      LocalToolCommandlet toolCommandlet = this.context.getCommandletManager().getCommandlet(toolClass);
-      Path buildDescriptor = toolCommandlet.findBuildDescriptor(buildPath);
-      if (buildDescriptor != null) {
-        commandlet = toolCommandlet;
-        if (args.isEmpty()) {
-          String variableName = commandlet.getName().toUpperCase(Locale.ROOT) + "_BUILD_OPTS";
-          args = getDefaultToolOptions(variableName);
-        }
+      LocalToolCommandlet toolCommandlet = context.getCommandletManager().getCommandlet(toolClass);
+      if (toolCommandlet.findBuildDescriptor(buildPath) != null) {
+        return toolCommandlet;
       }
     }
-    if (commandlet == null) {
-      throw new CliException("Could not find build descriptor - no pom.xml, build.gradle, or package.json found!");
-    }
-    commandlet.runTool(args);
+    return null;
   }
 
   private List<String> getDefaultToolOptions(String buildOptionName) {

cli/src/main/java/com/devonfw/tools/ide/commandlet/ReleaseCommandlet.java

@@ -1,6 +1,5 @@
 package com.devonfw.tools.ide.commandlet;
 
-import java.nio.file.Files;
 import java.nio.file.Path;
 
 import org.slf4j.Logger;
@@ -11,7 +10,8 @@
 import com.devonfw.tools.ide.git.GitContext;
 import com.devonfw.tools.ide.process.ProcessResult;
 import com.devonfw.tools.ide.property.StringProperty;
-import com.devonfw.tools.ide.tool.mvn.Mvn;
+import com.devonfw.tools.ide.tool.BuildTool;
+import com.devonfw.tools.ide.tool.LocalToolCommandlet;
 import com.devonfw.tools.ide.version.VersionIdentifier;
 
 /**
@@ -41,15 +41,23 @@ protected void doRun() {
 
     Path projectPath = this.context.getCwd();
     GitContext git = this.context.getGitContext();
-    Mvn buildTool = this.context.getCommandletManager().getCommandlet(Mvn.class);
+
+    LocalToolCommandlet commandlet = BuildCommandlet.findBuildCommandlet(this.context, projectPath);
+    if (commandlet == null) {
+      throw new CliException("Could not find a build descriptor in " + projectPath + ". There is nothing to release here.");
+    }
+    if (!(commandlet instanceof BuildTool buildTool)) {
+      throw new CliException("The build tool " + commandlet.getName() + " detected in " + projectPath + " does not support releasing.");
+    }
 
     if (git.hasUntrackedFiles(projectPath)) {
       throw new CliException("Your local git repository has uncommitted changes. Please use 'git stash' and rerun on clean repo.");
     }
     if (warnIfFork(git, projectPath)) {
-      confirmWarning("You seem to work on a fork. Releases should be done on the original repository!\nWe strongly recommend to abort and rerun on original repository.");
+      confirmWarning("You seem to work on a fork. Releases should be done on the original repository!\n"
+          + "We strongly recommend to abort and rerun on original repository.");
     }
-    if (!this.context.isForceMode() && !isTopLevelProject(projectPath)) {
+    if (!this.context.isForceMode() && !isTopLevelProject(commandlet, projectPath)) {
       throw new CliException("Release has to be performed from the top-level project or using force option.");
     }
 
@@ -94,14 +102,15 @@ private boolean warnIfFork(GitContext git, Path projectPath) {
     return false;
   }
 
-  private boolean isTopLevelProject(Path projectPath) {
+  private boolean isTopLevelProject(LocalToolCommandlet buildTool, Path projectPath) {
 
-    // returns false in case there's no pom.xml present or if parent directory has a pom.xml
-    return Files.exists(projectPath.resolve("pom.xml"))
-        && !Files.exists(projectPath.getParent().resolve("pom.xml"));
+    // top-level if a build descriptor is present here but not in the parent directory
+    Path parent = projectPath.getParent();
+    return (buildTool.findBuildDescriptor(projectPath) != null)
+        && ((parent == null) || (buildTool.findBuildDescriptor(parent) == null));
   }
 
-  private void buildAndDeploy(Mvn buildTool) {
+  private void buildAndDeploy(BuildTool buildTool) {
 
     while (true) {
       ProcessResult result = buildTool.buildAndDeploy(this.arguments.asList());

cli/src/test/java/com/devonfw/tools/ide/commandlet/BuildCommandletTest.java

@@ -2,6 +2,8 @@
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.nio.file.Path;
+
 import org.junit.jupiter.api.Test;
 
 import com.devonfw.tools.ide.cli.CliException;
@@ -11,6 +13,10 @@
 import com.devonfw.tools.ide.log.IdeLogLevel;
 import com.devonfw.tools.ide.os.SystemInfo;
 import com.devonfw.tools.ide.os.SystemInfoMock;
+import com.devonfw.tools.ide.tool.gradle.Gradle;
+import com.devonfw.tools.ide.tool.mvn.Mvn;
+import com.devonfw.tools.ide.tool.npm.Npm;
+import com.devonfw.tools.ide.tool.yarn.Yarn;
 import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
 import com.github.tomakehurst.wiremock.junit5.WireMockTest;
 
@@ -118,4 +124,22 @@ void testBuildWithNoBuildFile() {
     context.setCwd(context.getWorkspacePath().resolve("empty"), context.getWorkspacePath().toString(), context.getIdeHome());
     assertThrows(CliException.class, buildCommandlet::run);
   }
+
+  /**
+   * Tests {@link BuildCommandlet#findBuildCommandlet(com.devonfw.tools.ide.context.IdeContext, Path)} detecting the applicable build tool by its build
+   * descriptor and preferring {@link Yarn} over {@link Npm} when a {@code yarn.lock} is present.
+   */
+  @Test
+  void testFindBuildCommandlet() {
+
+    IdeTestContext context = newContext(PROJECT_BUILD);
+    Path workspace = context.getWorkspacePath();
+
+    assertThat(BuildCommandlet.findBuildCommandlet(context, workspace.resolve("mvn"))).isInstanceOf(Mvn.class);
+    assertThat(BuildCommandlet.findBuildCommandlet(context, workspace.resolve("gradle"))).isInstanceOf(Gradle.class);
+    assertThat(BuildCommandlet.findBuildCommandlet(context, workspace.resolve("npm"))).isInstanceOf(Npm.class);
+    // both npm and yarn match package.json, but yarn.lock is present so yarn must take precedence over npm
+    assertThat(BuildCommandlet.findBuildCommandlet(context, workspace.resolve("yarn"))).isInstanceOf(Yarn.class);
+    assertThat(BuildCommandlet.findBuildCommandlet(context, workspace.resolve("empty"))).isNull();
+  }
 }

cli/src/test/java/com/devonfw/tools/ide/commandlet/ReleaseCommandletTest.java

@@ -91,6 +91,22 @@ void testReleaseWithoutBuildDescriptor() {
     context.setCwd(context.getWorkspacePath().resolve("empty"), context.getWorkspacePath().toString(), context.getIdeHome());
     ReleaseCommandlet releaseCommandlet = context.getCommandletManager().getCommandlet(ReleaseCommandlet.class);
 
-    assertThrows(CliException.class, releaseCommandlet::run);
+    CliException exception = assertThrows(CliException.class, releaseCommandlet::run);
+    assertThat(exception).hasMessageContaining("Could not find a build descriptor");
+  }
+
+  /**
+   * Tests that the release fails gracefully if a build descriptor is found but its build tool does not support releasing (does not implement
+   * {@link com.devonfw.tools.ide.tool.BuildTool}), e.g. a gradle project (only maven currently supports releasing).
+   */
+  @Test
+  void testReleaseWithUnsupportedBuildToolThrowsException() {
+
+    IdeTestContext context = newReleaseContext(false);
+    context.setCwd(context.getWorkspacePath().resolve("gradle"), context.getWorkspacePath().toString(), context.getIdeHome());
+    ReleaseCommandlet releaseCommandlet = context.getCommandletManager().getCommandlet(ReleaseCommandlet.class);
+
+    CliException exception = assertThrows(CliException.class, releaseCommandlet::run);
+    assertThat(exception).hasMessageContaining("gradle").hasMessageContaining("does not support releasing");
   }
 }