30638110943

Committed 31 Jul 2026 02:19PM UTC coverage: 72.649% (+0.008%) from 72.641%

Build # 30638110943

Build Type

Pull #2144

github

Committed by

web-flow

Commit Message

Merge 57128bd73 into 468118d46

Pull Request Pull Request #2144: #1976: extend tool commandlet installation logic

Coverage Stats

5048 of 7683 branches covered (65.7%)

Branch coverage included in aggregate %.

13102 of 17300 relevant lines covered (75.73%)

3.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.95

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

package com.devonfw.tools.ide.tool;

import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.devonfw.tools.ide.cli.CliException;
import com.devonfw.tools.ide.cli.CliOfflineException;
import com.devonfw.tools.ide.common.Tag;
import com.devonfw.tools.ide.context.IdeContext;
import com.devonfw.tools.ide.io.FileAccess;
import com.devonfw.tools.ide.log.IdeLogLevel;
import com.devonfw.tools.ide.process.ProcessContext;
import com.devonfw.tools.ide.step.Step;
import com.devonfw.tools.ide.tool.repository.ToolRepository;
import com.devonfw.tools.ide.url.model.file.json.ToolDependency;
import com.devonfw.tools.ide.version.GenericVersionRange;
import com.devonfw.tools.ide.version.VersionIdentifier;
import com.devonfw.tools.ide.version.VersionRange;

/**
 * {@link ToolCommandlet} that is installed locally into the IDEasy.
 */
public abstract class LocalToolCommandlet extends ToolCommandlet {

  private static final Logger LOG = LoggerFactory.getLogger(LocalToolCommandlet.class);

  /**
   * The constructor.
   *
   * @param context the {@link IdeContext}.
   * @param tool the {@link #getName() tool name}.
   * @param tags the {@link #getTags() tags} classifying the tool. Should be created via {@link Set#of(Object) Set.of} method.
   */
  public LocalToolCommandlet(IdeContext context, String tool, Set<Tag> tags) {

    super(context, tool, tags);
  }

  /**
   * @return the {@link Path} where the tool is located (installed).
   */
  @Override
  public Path getToolPath() {
    if (this.context.getSoftwarePath() == null) {
      return null;
    }
    return this.context.getSoftwarePath().resolve(getName());
  }

  /**
   * @return the {@link Path} where the executables of the tool can be found. Typically, a "bin" folder inside {@link #getToolPath() tool path}.
   */
  public Path getToolBinPath() {

    Path toolPath = getToolPath();
    if (toolPath == null) {
      return null;
    }
    Path binPath = toolPath.resolve(IdeContext.FOLDER_BIN);
    if (Files.isDirectory(binPath)) {
      return binPath;
    }
    return toolPath;
  }

  /**
   * @return {@code true} to ignore a missing {@link IdeContext#FILE_SOFTWARE_VERSION software version file} in an installation, {@code false} delete the broken
   *     installation (default).
   */
  protected boolean isIgnoreMissingSoftwareVersionFile() {

    return false;
  }


  @Override
  protected ToolInstallation doInstall(ToolInstallRequest request) {

    Step step = request.getStep();
    if (step == null) {
      return doInstallStep(request);
    } else {
      return step.call(() -> doInstallStep(request),
          () -> createExistingToolInstallation(request));
    }
  }

  private ToolInstallation doInstallStep(ToolInstallRequest request) {

    if (request.isIgnoreProject() && isIgnoreSoftwareRepo()) {
      throw new CliException(
          "The tool " + this.tool
              + " does not support the software repository and therefore cannot be installed with --ignore-project.");
    }

    // install configured version of our tool in the software repository if not already installed
    ToolInstallation installation = installTool(request);

    // check if we already have this version installed (linked) locally in IDE_HOME/software
    VersionIdentifier resolvedVersion = installation.resolvedVersion();
    if (request.isAlreadyInstalled()) {
      return installation;
    } else {
      LOG.debug("Installation from {} to {}.", request.getInstalled(), request.getRequested());
    }
    FileAccess fileAccess = this.context.getFileAccess();
    boolean ignoreSoftwareRepo = isIgnoreSoftwareRepo();
    Path toolPath = request.getToolPath();
    if (!ignoreSoftwareRepo && !request.isIgnoreProject() && toolPath != null) {
      // we need to link the version or update the link.
      if (Files.exists(toolPath, LinkOption.NOFOLLOW_LINKS)) {
        fileAccess.backup(toolPath);
      }
      fileAccess.mkdirs(toolPath.getParent());
      fileAccess.symlink(installation.linkDir(), toolPath);
    } else {
      LOG.debug("Skipping symlink creation for tool {} as it is installed in standalone/global mode (ignoreSoftwareRepo={}, ignoreProject={}, toolPath={}).",
          this.tool, ignoreSoftwareRepo, request.isIgnoreProject(), toolPath);
    }
    if (!request.isExtraInstallation() && (installation.binDir() != null)) {
      this.context.getPath().setPath(this.tool, installation.binDir());
    }
    postInstall(request);
    ToolEditionAndVersion installed = request.getInstalled();
    GenericVersionRange installedVersion = null;
    if (installed != null) {
      installedVersion = installed.getVersion();
    }
    ToolEditionAndVersion requested = request.getRequested();
    ToolEdition toolEdition = requested.getEdition();
    Step step = request.getStep();
    if (installedVersion == null) {
      IdeLogLevel.SUCCESS.log(LOG, "Successfully installed {} in version {} at {}", toolEdition, resolvedVersion, toolPath);
    } else {
      IdeLogLevel.SUCCESS.log(LOG, "Successfully installed {} in version {} replacing previous version {} of {} at {}", toolEdition,
          resolvedVersion, installedVersion, installed.getEdition(), toolPath);
    }
    if (step != null) {
      step.success(true);
    }
    return installation;
  }

  /**
   * Determines whether this tool should be installed directly in the software folder or in the software repository.
   *
   * @return {@code true} if the tool should be installed directly in the software folder, ignoring the central software repository; {@code false} if the tool
   *     should be installed in the central software repository (default behavior).
   */
  protected boolean isIgnoreSoftwareRepo() {

    return false;
  }

  /**
   * Performs the installation of the {@link #getName() tool} together with the environment context  managed by this
   * {@link com.devonfw.tools.ide.commandlet.Commandlet}.
   *
   * @param request the {@link ToolInstallRequest}.
   * @return the resulting {@link ToolInstallation}.
   */
  public ToolInstallation installTool(ToolInstallRequest request) {

    completeRequest(request); // most likely already done, but if installTool was called directly and not from install
    if (request.isInstallLoop()) {
      return toolAlreadyInstalled(request);
    }
    ToolEditionAndVersion requested = request.getRequested();
    ToolEdition toolEdition = requested.getEdition();
    assert (toolEdition.tool().equals(this.tool)) : "Mismatch " + this.tool + " != " + toolEdition.tool();
    String edition = toolEdition.edition();
    VersionIdentifier resolvedVersion = cveCheck(request);
    installToolDependencies(request);
    // cveCheck might have changed resolvedVersion so let us re-check...
    if (request.isAlreadyInstalled()) {
      return toolAlreadyInstalled(request);
    } else {
      ToolEditionAndVersion installed = request.getInstalled();
      LOG.debug("Installation from {} to {}.", installed, requested);
    }
    Path installationPath = getInstallationPath(edition, resolvedVersion);

    ProcessContext processContext = request.getProcessContext();
    boolean additionalInstallation = request.isAdditionalInstallation();
    boolean ignoreSoftwareRepo = isIgnoreSoftwareRepo();
    Path toolVersionFile = installationPath.resolve(IdeContext.FILE_SOFTWARE_VERSION);
    FileAccess fileAccess = this.context.getFileAccess();
    if (Files.isDirectory(installationPath)) {
      if (Files.exists(toolVersionFile)) {
        if (!ignoreSoftwareRepo) {
          assert resolvedVersion.equals(getInstalledVersion(installationPath)) :
              "Found version " + getInstalledVersion(installationPath) + " in " + toolVersionFile + " but expected " + resolvedVersion;
          LOG.debug("Version {} of tool {} is already installed at {}", resolvedVersion, toolEdition, installationPath);
          return createToolInstallation(installationPath, resolvedVersion, false, processContext, additionalInstallation);
        }
      } else {
        // Makes sure that IDEasy will not delete itself
        if (this.tool.equals(IdeasyCommandlet.TOOL_NAME)) {
          LOG.warn("Your IDEasy installation is missing the version file at {}", toolVersionFile);
          return createToolInstallation(installationPath, resolvedVersion, false, processContext, additionalInstallation);
        } else if (!isIgnoreMissingSoftwareVersionFile()) {
          LOG.warn("Deleting corrupted installation at {}", installationPath);
          fileAccess.delete(installationPath);
        }
      }
    }
    VersionIdentifier actualInstalledVersion = resolvedVersion;
    try {
      performToolInstallation(request, installationPath);
    } catch (CliOfflineException e) {
      // If we are offline and cannot download, check if we can continue with an existing installation
      ToolEditionAndVersion installed = request.getInstalled();
      if ((installed != null) && (installed.getResolvedVersion() != null)) {
        LOG.warn("Cannot download {} in version {} because we are offline. Continuing with already installed version {}.", this.tool,
            resolvedVersion, installed.getResolvedVersion());
        // If offline and could not download, actualInstalledVersion will be the old version, not resolvedVersion
        // In that case, we need to recalculate the installation path for the actually installed version
        actualInstalledVersion = installed.getResolvedVersion();
        installationPath = getInstallationPath(edition, actualInstalledVersion);
      } else {
        // No existing installation available, re-throw the exception
        throw e;
      }
    }
    return createToolInstallation(installationPath, actualInstalledVersion, true, processContext, additionalInstallation);
  }

  /**
   * Performs the installation of the {@link #getName() tool} by using {@link #installDownloadedToolPayload(ToolInstallRequest, Path, Path)} for tool-specific
   * logic, backing up any existing installation, and writing the version file.
   * <p>
   * This method assumes that the version has already been resolved and dependencies installed. It handles the final steps of placing the tool into the
   * appropriate installation directory.
   *
   * @param request the {@link ToolInstallRequest}.
   * @param installationPath the target {@link Path} where the {@link #getName() tool} should be installed.
   */
  protected void performToolInstallation(ToolInstallRequest request, Path installationPath) {

    FileAccess fileAccess = this.context.getFileAccess();
    ToolEditionAndVersion requested = request.getRequested();
    VersionIdentifier resolvedVersion = requested.getResolvedVersion();
    Path downloadedToolFile = downloadTool(requested.getEdition().edition(), resolvedVersion);

    if (Files.isDirectory(installationPath)) {
      if (this.tool.equals(IdeasyCommandlet.TOOL_NAME)) {
        LOG.warn("Your IDEasy installation is missing the version file.");
      } else {
        fileAccess.backup(installationPath);
      }
    }
    fileAccess.mkdirs(installationPath.getParent());

    installDownloadedToolPayload(request, installationPath, downloadedToolFile);

    this.context.writeVersionFile(resolvedVersion, installationPath);
    // fix macOS Gatekeeper blocking - must run after version file is written but before any executables are launched
    getMacOsHelper().removeQuarantineAttribute(installationPath);
    LOG.debug("Installed {} in version {} at {}", this.tool, resolvedVersion, installationPath);
  }

  /**
   * Performs the actual installation of the tool bits.
   *
   * @param request the {@link ToolInstallRequest}.
   * @param installationPath the target {@link Path} where the tool should be installed.
   * @param downloadedToolFile the {@link Path} to the downloaded tool file.
   */
  protected void installDownloadedToolPayload(ToolInstallRequest request, Path installationPath, Path downloadedToolFile) {

    boolean extract = isExtract();
    if (!extract) {
      LOG.trace("Extraction is disabled for '{}' hence just moving the downloaded file {}.", this.tool, downloadedToolFile);
    }
    this.context.getFileAccess().extract(downloadedToolFile, installationPath, this::postExtract, extract);
  }

  /**
   * @param edition the {@link #getConfiguredEdition() tool edition} to download.
   * @param resolvedVersion the resolved {@link VersionIdentifier version} to download.
   * @return the {@link Path} to the downloaded release file.
   */
  protected Path downloadTool(String edition, VersionIdentifier resolvedVersion) {
    return getToolRepository().download(this.tool, edition, resolvedVersion, this);
  }

  /**
   * Install this tool as dependency of another tool.
   *
   * @param versionRange the required {@link VersionRange}. See {@link ToolDependency#versionRange()}.
   * @param parentRequest the {@link ToolInstallRequest} of the tool causing this dependency.
   * @return the corresponding {@link ToolInstallation}.
   */
  public ToolInstallation installAsDependency(VersionRange versionRange, ToolInstallRequest parentRequest) {
    ToolInstallRequest request = new ToolInstallRequest(parentRequest);
    ToolEditionAndVersion requested = new ToolEditionAndVersion(getToolWithConfiguredEdition());
    request.setRequested(requested);

    // If we are not inside a project or if we should ignore the project, do not try to use the configured version
    // but instead just use the version range from the dependency.
    boolean ignoreProject = request.isIgnoreProject() || this.context.getIdeHome() == null;
    VersionIdentifier configuredVersion = ignoreProject ? null : getConfiguredVersion();
    if (!ignoreProject && (configuredVersion != null) && versionRange.contains(configuredVersion)) {
      // prefer configured version if contained in version range
      requested.setVersion(configuredVersion);
      // return install(true, configuredVersion, processContext, null);
      return install(request);
    } else {
      if (ignoreProject) {
        LOG.debug("Ignoring project for dependency {} of tool {}, using version range {}", this.tool, parentRequest.getRequested(), versionRange);
      } else if (isIgnoreSoftwareRepo()) {
        throw new IllegalStateException(
            "Cannot satisfy dependency to " + this.tool + " in version " + versionRange + " for " + parentRequest.getRequested()
                + " since it is conflicting with configured version "
                + configuredVersion
                + " and this tool does not support the software repository.");
      } else {
        LOG.info(
            "The tool {} requires {} in the version range {}, but your project uses version {}, which does not match."
                + " Therefore, we install a compatible version in that range.",
            parentRequest.getRequested().getEdition(), this.tool, versionRange, configuredVersion);
      }
      requested.setVersion(versionRange);
      return installTool(request);
    }
  }

  /**
   * Installs the tool dependencies for the current tool.
   *
   * @param request the {@link ToolInstallRequest}.
   */
  protected void installToolDependencies(ToolInstallRequest request) {

    ToolEditionAndVersion requested = request.getRequested();
    VersionIdentifier version = requested.getResolvedVersion();
    ToolEdition toolEdition = requested.getEdition();
    Collection<ToolDependency> dependencies = getToolRepository().findDependencies(this.tool, toolEdition.edition(), version);
    int size = dependencies.size();
    LOG.debug("Tool {} has {} other tool(s) as dependency", toolEdition, size);
    for (ToolDependency dependency : dependencies) {
      LOG.trace("Ensuring dependency {} for tool {}", dependency.tool(), toolEdition);
      LocalToolCommandlet dependencyTool = this.context.getCommandletManager().getRequiredLocalToolCommandlet(dependency.tool());
      dependencyTool.installAsDependency(dependency.versionRange(), request);
    }
  }

  /**
   * Post-extraction hook that can be overridden to add custom processing after unpacking and before moving to the final destination folder.
   *
   * @param extractedDir the {@link Path} to the folder with the unpacked tool.
   */
  protected void postExtract(Path extractedDir) {

  }

  @Override
  public VersionIdentifier getInstalledVersion() {

    return getInstalledVersion(getToolPath());
  }

  /**
   * @param toolPath the installation {@link Path} where to find the version file.
   * @return the currently installed {@link VersionIdentifier version} of this tool or {@code null} if not installed.
   */
  protected VersionIdentifier getInstalledVersion(Path toolPath) {

    if (isToolNotInstalled(toolPath)) {
      return null;
    }
    Path versionLookupPath = getInstalledSoftwareRepoPath(toolPath, false);
    if (versionLookupPath == null) {
      versionLookupPath = toolPath;
    }
    Path toolVersionFile = versionLookupPath.resolve(IdeContext.FILE_SOFTWARE_VERSION);
    if (!Files.exists(toolVersionFile)) {
      Path legacyToolVersionFile = versionLookupPath.resolve(IdeContext.FILE_LEGACY_SOFTWARE_VERSION);
      if (Files.exists(legacyToolVersionFile)) {
        toolVersionFile = legacyToolVersionFile;
      } else {
        LOG.warn("Tool {} is missing version file in {}", getName(), toolVersionFile);
        return null;
      }
    }
    String version = this.context.getFileAccess().readFileContent(toolVersionFile).trim();
    return VersionIdentifier.of(version);
  }

  @Override
  public String getInstalledEdition() {

    return getInstalledEdition(getToolPath());
  }

  /**
   * @param toolPath the installation {@link Path} where to find currently installed tool. The name of the parent directory of the real path corresponding
   *     to the passed {@link Path path} must be the name of the edition.
   * @return the installed edition of this tool or {@code null} if not installed.
   */
  protected String getInstalledEdition(Path toolPath) {
    if (isToolNotInstalled(toolPath)) {
      return null;
    }
    Path realPath = this.context.getFileAccess().toRealPath(toolPath);
    // if the realPath changed, a link has been resolved
    if (realPath.equals(toolPath)) {
      if (!isIgnoreSoftwareRepo()) {
        LOG.warn("Tool {} is not installed via software repository (maybe from devonfw-ide). Please consider reinstalling it.", this.tool);
      }
      // I do not see any reliable way how we could determine the edition of a tool that does not use software repo or that was installed by devonfw-ide
      return getConfiguredEdition();
    }
    Path toolRepoFolder = context.getSoftwareRepositoryPath().resolve(ToolRepository.ID_DEFAULT).resolve(this.tool);
    String edition = getEdition(toolRepoFolder, realPath);
    if (edition == null) {
      edition = this.tool;
    }
    if (!getToolRepository().getSortedEditions(this.tool).contains(edition)) {
      LOG.warn("Undefined edition {} of tool {}", edition, this.tool);
    }
    return edition;
  }

  private String getEdition(Path toolRepoFolder, Path toolInstallFolder) {

    int toolRepoNameCount = toolRepoFolder.getNameCount();
    int toolInstallNameCount = toolInstallFolder.getNameCount();
    if (toolRepoNameCount < toolInstallNameCount) {
      // ensure toolInstallFolder starts with $IDE_ROOT/_ide/software/default/«tool»
      for (int i = 0; i < toolRepoNameCount; i++) {
        if (!toolRepoFolder.getName(i).toString().equals(toolInstallFolder.getName(i).toString())) {
          return null;
        }
      }
      return toolInstallFolder.getName(toolRepoNameCount).toString();
    }
    return null;
  }

  private Path getInstalledSoftwareRepoPath(Path toolPath) {
    return getInstalledSoftwareRepoPath(toolPath, false);
  }

  private Path getInstalledSoftwareRepoPath(Path toolPath, boolean logIfNotSoftwareRepo) {
    if (isToolNotInstalled(toolPath)) {
      return null;
    }
    Path installPath = this.context.getFileAccess().toRealPath(toolPath);
    // if the installPath changed, a link has been resolved
    if (installPath.equals(toolPath)) {
      if (logIfNotSoftwareRepo && !isIgnoreSoftwareRepo()) {
        LOG.warn("Tool {} is not installed via software repository (maybe from devonfw-ide). Please consider reinstalling it.", this.tool);
      }
      // I do not see any reliable way how we could determine the edition of a tool that does not use software repo or that was installed by devonfw-ide
      return null;
    }
    installPath = getValidInstalledSoftwareRepoPath(installPath, context.getSoftwareRepositoryPath());
    return installPath;
  }

  Path getValidInstalledSoftwareRepoPath(Path installPath, Path softwareRepoPath) {
    int softwareRepoNameCount = softwareRepoPath.getNameCount();
    int toolInstallNameCount = installPath.getNameCount();
    int targetToolInstallNameCount = softwareRepoNameCount + 4;

    // installPath can't be shorter than softwareRepoPath
    if (toolInstallNameCount < softwareRepoNameCount) {
      LOG.warn("The installation path is not located within the software repository {}.", installPath);
      return null;
    }
    // ensure installPath starts with $IDE_ROOT/_ide/software/
    for (int i = 0; i < softwareRepoNameCount; i++) {
      if (!softwareRepoPath.getName(i).toString().equals(installPath.getName(i).toString())) {
        LOG.warn("The installation path is not located within the software repository {}.", installPath);
        return null;
      }
    }
    // return $IDE_ROOT/_ide/software/«id»/«tool»/«edition»/«version»
    if (toolInstallNameCount == targetToolInstallNameCount) {
      return installPath;
    } else if (toolInstallNameCount > targetToolInstallNameCount) {
      Path validInstallPath = installPath;
      for (int i = 0; i < toolInstallNameCount - targetToolInstallNameCount; i++) {
        validInstallPath = validInstallPath.getParent();
      }
      return validInstallPath;
    } else {
      LOG.warn("The installation path is faulty {}.", installPath);
      return null;
    }
  }

  private boolean isToolNotInstalled(Path toolPath) {

    if ((toolPath == null) || !Files.isDirectory(toolPath)) {
      LOG.debug("Tool {} not installed in {}", this.tool, toolPath);
      return true;
    }
    return false;
  }

  @Override
  public void uninstall() {
    try {
      Path toolPath = getToolPath();
      if (!Files.exists(toolPath)) {
        LOG.warn("An installed version of {} does not exist.", this.tool);
        return;
      }
      if (this.context.isForceMode() && !isIgnoreSoftwareRepo()) {
        LOG.warn(
            "You triggered an uninstall of {} in version {} with force mode!\n"
                + "This will physically delete the currently installed version including its plugins from the machine.\n"
                + "This may cause issues with other projects, that use the same version of that tool."
            , this.tool, getInstalledVersion());
        uninstallPluginsOfTool();
        uninstallFromSoftwareRepository(toolPath);
      }
      performUninstall(toolPath);
      IdeLogLevel.SUCCESS.log(LOG, "Successfully uninstalled {}", this.tool);
    } catch (Exception e) {
      LOG.error("Failed to uninstall {}", this.tool, e);
    }
  }

  /**
   * Performs the actual uninstallation of this tool.
   *
   * @param toolPath the current {@link #getToolPath() tool path}.
   */
  protected void performUninstall(Path toolPath) {
    this.context.getFileAccess().delete(toolPath);
  }

  /**
   * Deletes the installed version of the tool from the shared software repository.
   */
  private void uninstallFromSoftwareRepository(Path toolPath) {
    Path repoPath = getInstalledSoftwareRepoPath(toolPath, true);
    if ((repoPath == null) || !Files.exists(repoPath)) {
      LOG.warn("An installed version of {} does not exist in software repository.", this.tool);
      return;
    }
    LOG.info("Physically deleting {} as requested by the user via force mode.", repoPath);
    this.context.getFileAccess().delete(repoPath);
    IdeLogLevel.SUCCESS.log(LOG, "Successfully deleted {} from your computer.", repoPath);
  }

  /**
   * Deletes the installed plugins of the tool from the plugins path.
   */
  private void uninstallPluginsOfTool() {

    Path toolPluginsPath = this.context.getPluginsPath().resolve(this.tool);
    if (!Files.exists(toolPluginsPath)) {
      LOG.info("There are no plugins of {} present to delete.", this.tool);
      return;
    }
    LOG.info("Physically deleting {} as requested by the user via force mode.", toolPluginsPath);
    this.context.getFileAccess().delete(toolPluginsPath);
    IdeLogLevel.SUCCESS.log(LOG, "Successfully deleted {} from your computer.", toolPluginsPath);
  }

  @Override
  protected Path getInstallationPath(String edition, VersionIdentifier resolvedVersion) {
    Path installationPath;
    if (isIgnoreSoftwareRepo()) {
      installationPath = getToolPath();
    } else {
      Path softwareRepositoryPath = this.context.getSoftwareRepositoryPath();
      if (softwareRepositoryPath == null) {
        return null;
      }
      Path softwareRepoPath = softwareRepositoryPath.resolve(getToolRepository().getId()).resolve(this.tool).resolve(edition);
      installationPath = softwareRepoPath.resolve(resolvedVersion.toString());
    }
    return installationPath;
  }

  /**
   * @return {@link VersionIdentifier} with latest version of the tool}.
   */
  public VersionIdentifier getLatestToolVersion() {

    return this.context.getDefaultToolRepository().resolveVersion(this.tool, getConfiguredEdition(), VersionIdentifier.LATEST, this);
  }


  /**
   * Searches for a wrapper file in valid projects (containing a build file f.e. build.gradle or pom.xml) and returns its path.
   *
   * @param wrapperFileName the name of the wrapper file
   * @return Path of the wrapper file or {@code null} if none was found.
   */
  protected Path findWrapper(String wrapperFileName) {
    Path dir = this.context.getCwd();
    // traverse the cwd directory containing a build descriptor up till a wrapper file was found
    while ((dir != null) && (findBuildDescriptor(dir) != null)) {
      Path wrapper = dir.resolve(wrapperFileName);
      if (Files.exists(wrapper)) {
        LOG.debug("Using wrapper: {}", wrapper);
        return wrapper;
      }
      dir = dir.getParent();
    }
    return null;
  }

  /**
   * @param directory the {@link Path} to the build directory.
   * @return the build configuration file for this tool or {@code null} if not found (or this is not a build tool).
   */
  public Path findBuildDescriptor(Path directory) {
    return null;
  }

  /**
   * @return Bash completion command for this tool or {@code null} if this tool does not provide Bash completion.
   */
  public String getBashCompletion() {

    return null;
  }
}

devonfw / IDEasy / 30638110943

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous