29998786930

Committed 23 Jul 2026 10:18AM UTC coverage: 72.545% (+0.05%) from 72.496%

Build # 29998786930

Build Type

Pull #2204

github

Committed by

web-flow

Commit Message

Merge b7d5ee787 into 5b6cc3011

Pull Request Pull Request #2204: #2192-support-for-auto-completion-synonyms

Coverage Stats

4986 of 7598 branches covered (65.62%)

Branch coverage included in aggregate %.

12850 of 16988 relevant lines covered (75.64%)

3.2 hits per line

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

70.76

cli/src/main/java/com/devonfw/tools/ide/context/AbstractIdeContext.java

package com.devonfw.tools.ide.context;

import static com.devonfw.tools.ide.variable.IdeVariables.IDE_MIN_VERSION;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import java.util.function.Predicate;
import java.util.logging.FileHandler;
import java.util.logging.LogManager;
import java.util.logging.SimpleFormatter;

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

import com.devonfw.tools.ide.cli.CliAbortException;
import com.devonfw.tools.ide.cli.CliArgument;
import com.devonfw.tools.ide.cli.CliArguments;
import com.devonfw.tools.ide.cli.CliException;
import com.devonfw.tools.ide.cli.CliSuggester;
import com.devonfw.tools.ide.commandlet.Commandlet;
import com.devonfw.tools.ide.commandlet.CommandletManager;
import com.devonfw.tools.ide.commandlet.CommandletManagerImpl;
import com.devonfw.tools.ide.commandlet.ContextCommandlet;
import com.devonfw.tools.ide.commandlet.EnvironmentCommandlet;
import com.devonfw.tools.ide.commandlet.UpdateCommandlet;
import com.devonfw.tools.ide.commandlet.UpgradeCommandlet;
import com.devonfw.tools.ide.common.SystemPath;
import com.devonfw.tools.ide.completion.CompletionCandidate;
import com.devonfw.tools.ide.completion.CompletionCandidateCollector;
import com.devonfw.tools.ide.completion.CompletionCandidateCollectorDefault;
import com.devonfw.tools.ide.environment.AbstractEnvironmentVariables;
import com.devonfw.tools.ide.environment.EnvironmentVariables;
import com.devonfw.tools.ide.environment.EnvironmentVariablesType;
import com.devonfw.tools.ide.environment.IdeSystem;
import com.devonfw.tools.ide.environment.IdeSystemImpl;
import com.devonfw.tools.ide.git.GitContext;
import com.devonfw.tools.ide.git.GitContextImpl;
import com.devonfw.tools.ide.git.GitUrl;
import com.devonfw.tools.ide.io.FileAccess;
import com.devonfw.tools.ide.io.FileAccessImpl;
import com.devonfw.tools.ide.log.IdeLogArgFormatter;
import com.devonfw.tools.ide.log.IdeLogLevel;
import com.devonfw.tools.ide.log.IdeLogListener;
import com.devonfw.tools.ide.log.JulConsoleHandler;
import com.devonfw.tools.ide.merge.DirectoryMerger;
import com.devonfw.tools.ide.migration.IdeMigrator;
import com.devonfw.tools.ide.network.NetworkStatus;
import com.devonfw.tools.ide.network.NetworkStatusImpl;
import com.devonfw.tools.ide.os.SystemInfo;
import com.devonfw.tools.ide.os.SystemInfoImpl;
import com.devonfw.tools.ide.os.WindowsHelper;
import com.devonfw.tools.ide.os.WindowsHelperImpl;
import com.devonfw.tools.ide.os.WindowsPathSyntax;
import com.devonfw.tools.ide.process.ProcessContext;
import com.devonfw.tools.ide.process.ProcessContextImpl;
import com.devonfw.tools.ide.process.ProcessResult;
import com.devonfw.tools.ide.property.KeywordProperty;
import com.devonfw.tools.ide.property.Property;
import com.devonfw.tools.ide.step.Step;
import com.devonfw.tools.ide.step.StepImpl;
import com.devonfw.tools.ide.tool.custom.CustomToolRepository;
import com.devonfw.tools.ide.tool.custom.CustomToolRepositoryImpl;
import com.devonfw.tools.ide.tool.mvn.MvnRepository;
import com.devonfw.tools.ide.tool.npm.NpmRepository;
import com.devonfw.tools.ide.tool.pip.PipRepository;
import com.devonfw.tools.ide.tool.python.PythonRepository;
import com.devonfw.tools.ide.tool.repository.DefaultToolRepository;
import com.devonfw.tools.ide.tool.repository.ToolRepository;
import com.devonfw.tools.ide.tool.uv.UvRepository;
import com.devonfw.tools.ide.url.model.UrlMetadata;
import com.devonfw.tools.ide.util.DateTimeUtil;
import com.devonfw.tools.ide.util.PrivacyUtil;
import com.devonfw.tools.ide.validation.ValidationResult;
import com.devonfw.tools.ide.validation.ValidationResultValid;
import com.devonfw.tools.ide.validation.ValidationState;
import com.devonfw.tools.ide.variable.IdeVariables;
import com.devonfw.tools.ide.version.IdeVersion;
import com.devonfw.tools.ide.version.VersionIdentifier;

/**
 * Abstract base implementation of {@link IdeContext}.
 */
public abstract class AbstractIdeContext implements IdeContext, IdeLogArgFormatter {

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

  /** The default shell bash (Bourne Again SHell). */
  public static final String BASH = "bash";

  private static final GitUrl IDE_URLS_GIT = new GitUrl("https://github.com/devonfw/ide-urls.git", null);

  private static final String LICENSE_URL = "https://github.com/devonfw/IDEasy/blob/main/documentation/LICENSE.adoc";

  private static final String DEFAULT_WINDOWS_GIT_PATH = "C:\\Program Files\\Git\\bin\\bash.exe";

  private static final String OPTION_DETAILS_START = "([";

  private final IdeStartContextImpl startContext;

  private Path ideHome;

  private Path ideRoot;

  private Path confPath;

  protected Path settingsPath;

  private Path settingsCommitIdPath;

  protected Path pluginsPath;

  private Path workspacePath;

  private Path workspacesBasePath;

  private String workspaceName;

  private Path cwd;

  private Path downloadPath;

  private Path userHome;

  private Path userHomeIde;

  private SystemPath path;

  private WindowsPathSyntax pathSyntax;

  private final SystemInfo systemInfo;

  private EnvironmentVariables variables;

  private final FileAccess fileAccess;

  protected CommandletManager commandletManager;

  protected ToolRepository defaultToolRepository;

  private CustomToolRepository customToolRepository;

  private MvnRepository mvnRepository;

  private NpmRepository npmRepository;

  private PipRepository pipRepository;

  private UvRepository uvRepository;

  private PythonRepository pythonRepository;

  private DirectoryMerger workspaceMerger;

  protected UrlMetadata urlMetadata;

  protected Path defaultExecutionDirectory;

  private StepImpl currentStep;

  private NetworkStatus networkStatus;

  protected IdeSystem system;

  private WindowsHelper windowsHelper;

  private final Map<String, String> privacyMap;

  private Path bash;

  private boolean julConfigured;

  private Path logfile;

  private CliSuggester cliSuggester;

  /**
   * The constructor.
   *
   * @param startContext the {@link IdeStartContextImpl}.
   * @param workingDirectory the optional {@link Path} to current working directory.
   */
  public AbstractIdeContext(IdeStartContextImpl startContext, Path workingDirectory) {

    super();
    this.startContext = startContext;
    this.startContext.setArgFormatter(this);
    this.privacyMap = new HashMap<>();
    this.systemInfo = SystemInfoImpl.INSTANCE;
    if (isTest()) {
      configureJavaUtilLogging(null);
    }
    this.commandletManager = new CommandletManagerImpl(this);
    this.fileAccess = new FileAccessImpl(this);
    String userHomeProperty = getSystem().getProperty("user.home");
    if (userHomeProperty != null) {
      this.userHome = Path.of(userHomeProperty);
    }
    if (workingDirectory == null) {
      workingDirectory = Path.of(System.getProperty("user.dir"));
    }
    workingDirectory = workingDirectory.toAbsolutePath();
    if (Files.isDirectory(workingDirectory)) {
      workingDirectory = this.fileAccess.toCanonicalPath(workingDirectory);
    } else {
      LOG.warn("Current working directory does not exist: {}", workingDirectory);
    }
    this.cwd = workingDirectory;
    // detect IDE_HOME and WORKSPACE
    String workspace = null;
    Path ideHomeDir = null;
    IdeHomeAndWorkspace ideHomeAndWorkspace = findIdeHome(workingDirectory);
    if (ideHomeAndWorkspace != null) {
      ideHomeDir = ideHomeAndWorkspace.home();
      workspace = ideHomeAndWorkspace.workspace();
    }

    // detection completed, initializing variables
    this.ideRoot = findIdeRoot(ideHomeDir);

    setCwd(workingDirectory, workspace, ideHomeDir);

    if (this.ideRoot != null) {
      Path tempDownloadPath = getTempDownloadPath();
      if (Files.isDirectory(tempDownloadPath)) {
        // TODO delete all files older than 1 day here...
      } else {
        this.fileAccess.mkdirs(tempDownloadPath);
      }
    }
    this.defaultToolRepository = new DefaultToolRepository(this);
  }

  /**
   * Searches for the IDE home directory by traversing up the directory tree from the given working directory. This method can be overridden in test contexts to
   * add additional validation or boundary checks.
   *
   * @param workingDirectory the starting directory for the search.
   * @return an instance of {@link IdeHomeAndWorkspace} where the IDE_HOME was found or {@code null} if not found.
   */
  protected IdeHomeAndWorkspace findIdeHome(Path workingDirectory) {

    Path currentDir = workingDirectory;
    String name1 = "";
    String name2 = "";
    String workspace = WORKSPACE_MAIN;
    Path ideRootPath = getIdeRootPathFromEnv(false);

    while (currentDir != null) {
      LOG.trace("Looking for IDE_HOME in {}", currentDir);
      if (isIdeHome(currentDir)) {
        if (FOLDER_WORKSPACES.equals(name1) && !name2.isEmpty()) {
          workspace = name2;
        }
        break;
      }
      name2 = name1;
      int nameCount = currentDir.getNameCount();
      if (nameCount >= 1) {
        name1 = currentDir.getName(nameCount - 1).toString();
      }
      currentDir = currentDir.getParent();
      if ((ideRootPath != null) && (ideRootPath.equals(currentDir))) {
        // prevent that during tests we traverse to the real IDE project of IDEasy developer
        currentDir = null;
      }
    }

    return new IdeHomeAndWorkspace(currentDir, workspace);
  }

  /**
   * @return a new {@link MvnRepository}
   */
  protected MvnRepository createMvnRepository() {
    return new MvnRepository(this);
  }

  /**
   * @return a new {@link NpmRepository}
   */
  protected NpmRepository createNpmRepository() {
    return new NpmRepository(this);
  }

  /**
   * @return a new {@link PipRepository}
   */
  protected PipRepository createPipRepository() {
    return new PipRepository(this);
  }

  /**
   * @return a new {@link UvRepository}
   */
  protected UvRepository createUvRepository() {
    return new UvRepository(this);
  }

  /**
   * @return a new {@link PythonRepository}
   */
  protected PythonRepository createPythonRepository() {
    return new PythonRepository(this);
  }

  private Path findIdeRoot(Path ideHomePath) {

    Path ideRootPath = null;
    if (ideHomePath != null) {
      Path ideRootPathFromEnv = getIdeRootPathFromEnv(true);
      ideRootPath = ideHomePath.getParent();
      if ((ideRootPathFromEnv != null) && !ideRootPath.toString().equals(ideRootPathFromEnv.toString())) {
        LOG.warn(
            "Variable IDE_ROOT is set to '{}' but for your project '{}' the path '{}' would have been expected.\n"
                + "Please check your 'user.dir' or working directory setting and make sure that it matches your IDE_ROOT variable.",
            ideRootPathFromEnv,
            ideHomePath.getFileName(), ideRootPath);
      }
    } else if (!isTest()) {
      ideRootPath = getIdeRootPathFromEnv(true);
    }
    return ideRootPath;
  }

  /**
   * @return the {@link #getIdeRoot() IDE_ROOT} from the system environment.
   */
  protected Path getIdeRootPathFromEnv(boolean withSanityCheck) {

    String root = getSystem().getEnv(IdeVariables.IDE_ROOT.getName());
    if (root != null) {
      Path rootPath = Path.of(root);
      if (Files.isDirectory(rootPath)) {
        Path absoluteRootPath = getFileAccess().toCanonicalPath(rootPath);
        if (withSanityCheck) {
          int nameCount = rootPath.getNameCount();
          int absoluteNameCount = absoluteRootPath.getNameCount();
          int delta = absoluteNameCount - nameCount;
          if (delta >= 0) {
            for (int nameIndex = 0; nameIndex < nameCount; nameIndex++) {
              String rootName = rootPath.getName(nameIndex).toString();
              String absoluteRootName = absoluteRootPath.getName(nameIndex + delta).toString();
              if (!rootName.equals(absoluteRootName)) {
                LOG.warn("IDE_ROOT is set to {} but was expanded to absolute path {} and does not match for segment {} and {} - fix your IDEasy installation!",
                    rootPath, absoluteRootPath, rootName, absoluteRootName);
                break;
              }
            }
          } else {
            LOG.warn("IDE_ROOT is set to {} but was expanded to a shorter absolute path {}", rootPath,
                absoluteRootPath);
          }
        }
        return absoluteRootPath;
      } else if (withSanityCheck) {
        LOG.warn("IDE_ROOT is set to {} that is not an existing directory - fix your IDEasy installation!", rootPath);
      }
    }
    return null;
  }

  @Override
  public void setCwd(Path userDir, String workspace, Path ideHome) {

    this.cwd = userDir;
    this.workspaceName = workspace;
    this.ideHome = ideHome;
    if (ideHome == null) {
      this.workspacesBasePath = null;
      this.workspacePath = null;
      this.confPath = null;
      this.settingsPath = null;
      this.pluginsPath = null;
    } else {
      this.workspacesBasePath = this.ideHome.resolve(FOLDER_WORKSPACES);
      this.workspacePath = this.workspacesBasePath.resolve(this.workspaceName);
      this.confPath = this.ideHome.resolve(FOLDER_CONF);
      this.settingsPath = this.ideHome.resolve(FOLDER_SETTINGS);
      this.settingsCommitIdPath = this.ideHome.resolve(IdeContext.SETTINGS_COMMIT_ID);
      this.pluginsPath = this.ideHome.resolve(FOLDER_PLUGINS);
    }
    if (isTest()) {
      // only for testing...
      if (this.ideHome == null) {
        this.userHome = Path.of("/non-existing-user-home-for-testing");
      } else {
        this.userHome = this.ideHome.resolve("home");
      }
    }
    this.userHomeIde = this.userHome.resolve(FOLDER_DOT_IDE);
    this.downloadPath = computeDownloadPath(this.userHome);
    resetPrivacyMap();
    this.path = computeSystemPath();
  }

  /**
   * On macOS, {@code ~/Downloads} is protected by the OS (TCC) and the CLI may not be allowed to delete it, so we put the cache under {@code ~/Library/Caches}
   * instead. Tests still use {@code ~/Downloads/ide} so existing fixtures keep working.
   */
  private Path computeDownloadPath(Path home) {

    if (!isTest() && this.systemInfo.isMac()) {
      return home.resolve("Library/Caches/IDEasy/downloads");
    }
    return home.resolve("Downloads/ide");
  }

  private String getMessageIdeHomeFound() {

    String wks = this.workspaceName;
    if (isPrivacyMode() && !WORKSPACE_MAIN.equals(wks)) {
      wks = "*".repeat(wks.length());
    }
    return "IDE environment variables have been set for " + formatArgument(this.ideHome) + " in workspace " + wks;
  }

  private String getMessageNotInsideIdeProject() {

    return "You are not inside an IDE project: " + formatArgument(this.cwd);
  }

  private String getMessageIdeRootNotFound() {

    String root = getSystem().getEnv("IDE_ROOT");
    if (root == null) {
      return "The environment variable IDE_ROOT is undefined. Please reinstall IDEasy or manually repair IDE_ROOT variable.";
    } else {
      return "The environment variable IDE_ROOT is pointing to an invalid path " + formatArgument(root)
          + ". Please reinstall IDEasy or manually repair IDE_ROOT variable.";
    }
  }

  /**
   * @return {@code true} if this is a test context for JUnits, {@code false} otherwise.
   */
  public boolean isTest() {

    return false;
  }

  protected SystemPath computeSystemPath() {

    return new SystemPath(this);
  }

  /**
   * Checks if the given directory is a valid IDE home by verifying it contains both 'workspaces' and 'settings' directories.
   *
   * @param dir the directory to check.
   * @return {@code true} if the directory is a valid IDE home, {@code false} otherwise.
   */
  protected boolean isIdeHome(Path dir) {

    if (!Files.isDirectory(dir.resolve("workspaces"))) {
      return false;
    } else if (!Files.isDirectory(dir.resolve("settings"))) {
      return false;
    }
    return true;
  }

  private EnvironmentVariables createVariables() {

    AbstractEnvironmentVariables system = createSystemVariables();
    AbstractEnvironmentVariables user = system.extend(this.userHomeIde, EnvironmentVariablesType.USER);
    AbstractEnvironmentVariables settings = user.extend(this.settingsPath, EnvironmentVariablesType.SETTINGS);
    AbstractEnvironmentVariables workspace = settings.extend(this.workspacePath, EnvironmentVariablesType.WORKSPACE);
    AbstractEnvironmentVariables conf = workspace.extend(this.confPath, EnvironmentVariablesType.CONF);
    return conf.resolved();
  }

  protected AbstractEnvironmentVariables createSystemVariables() {

    return EnvironmentVariables.ofSystem(this);
  }

  @Override
  public SystemInfo getSystemInfo() {

    return this.systemInfo;
  }

  @Override
  public FileAccess getFileAccess() {

    return this.fileAccess;
  }

  @Override
  public CommandletManager getCommandletManager() {

    return this.commandletManager;
  }

  @Override
  public ToolRepository getDefaultToolRepository() {

    return this.defaultToolRepository;
  }

  @Override
  public MvnRepository getMvnRepository() {
    if (this.mvnRepository == null) {
      this.mvnRepository = createMvnRepository();
    }
    return this.mvnRepository;
  }

  @Override
  public NpmRepository getNpmRepository() {
    if (this.npmRepository == null) {
      this.npmRepository = createNpmRepository();
    }
    return this.npmRepository;
  }

  @Override
  public PipRepository getPipRepository() {
    if (this.pipRepository == null) {
      this.pipRepository = createPipRepository();
    }
    return this.pipRepository;
  }

  @Override
  public UvRepository getUvRepository() {
    if (this.uvRepository == null) {
      this.uvRepository = createUvRepository();
    }
    return this.uvRepository;
  }

  @Override
  public PythonRepository getPythonRepository() {
    if (this.pythonRepository == null) {
      this.pythonRepository = createPythonRepository();
    }
    return this.pythonRepository;
  }

  @Override
  public CustomToolRepository getCustomToolRepository() {

    if (this.customToolRepository == null) {
      this.customToolRepository = CustomToolRepositoryImpl.of(this);
    }
    return this.customToolRepository;
  }

  @Override
  public Path getIdeHome() {

    return this.ideHome;
  }

  @Override
  public String getProjectName() {

    if (this.ideHome != null) {
      return this.ideHome.getFileName().toString();
    }
    return "";
  }

  @Override
  public VersionIdentifier getProjectVersion() {

    if (this.ideHome != null) {
      Path versionFile = this.ideHome.resolve(IdeContext.FILE_SOFTWARE_VERSION);
      if (Files.exists(versionFile)) {
        String version = this.fileAccess.readFileContent(versionFile).trim();
        return VersionIdentifier.of(version);
      }
    }
    return IdeMigrator.START_VERSION;
  }

  @Override
  public void setProjectVersion(VersionIdentifier version) {

    if (this.ideHome == null) {
      throw new IllegalStateException("IDE_HOME not available!");
    }
    Objects.requireNonNull(version);
    Path versionFile = this.ideHome.resolve(IdeContext.FILE_SOFTWARE_VERSION);
    this.fileAccess.writeFileContent(version.toString(), versionFile);
  }

  @Override
  public Path getIdeRoot() {

    return this.ideRoot;
  }

  @Override
  public void setIdeRoot(Path ideRoot) {

    this.ideRoot = ideRoot;
  }

  @Override
  public Path getIdePath() {

    Path myIdeRoot = getIdeRoot();
    if (myIdeRoot == null) {
      return null;
    }
    return myIdeRoot.resolve(FOLDER_UNDERSCORE_IDE);
  }

  @Override
  public Path getCwd() {

    return this.cwd;
  }

  @Override
  public Path getTempPath() {

    Path idePath = getIdePath();
    if (idePath == null) {
      return null;
    }
    return idePath.resolve("tmp");
  }

  @Override
  public Path getTempDownloadPath() {

    Path tmp = getTempPath();
    if (tmp == null) {
      return null;
    }
    return tmp.resolve(FOLDER_DOWNLOADS);
  }

  @Override
  public Path getUserHome() {

    return this.userHome;
  }

  /**
   * This method should only be used for tests to mock user home.
   *
   * @param userHome the new value of {@link #getUserHome()}.
   */
  protected void setUserHome(Path userHome) {

    this.userHome = userHome;
    this.userHomeIde = userHome.resolve(FOLDER_DOT_IDE);
    this.downloadPath = computeDownloadPath(userHome);
    this.variables = null;
    resetPrivacyMap();
  }

  @Override
  public Path getUserHomeIde() {

    return this.userHomeIde;
  }

  @Override
  public Path getSettingsPath() {

    return this.settingsPath;
  }

  @Override
  public Path getSettingsGitRepository() {

    Path settingsPath = getSettingsPath();
    // check whether the settings path has a .git folder only if its not a symbolic link or junction
    if ((settingsPath != null) && !Files.exists(settingsPath.resolve(".git")) && !isSettingsCodeRepository()) {
      LOG.error("Settings repository exists but is not a git repository.");
      return null;
    }
    return settingsPath;
  }

  @Override
  public boolean isSettingsCodeRepository() {

    Path settingsPath = getSettingsPath();
    if (settingsPath != null) {
      boolean settingsIsLink = Files.isSymbolicLink(settingsPath) || getFileAccess().isJunction(settingsPath);
      if (settingsIsLink) {
        Path realPath = getFileAccess().toRealPath(this.settingsPath);
        if (realPath != null) {
          return getGitContext().isGitRepo(realPath.getParent());
        }
        return true;
      }
    }
    return false;
  }

  @Override
  public Path getSettingsCommitIdPath() {

    return this.settingsCommitIdPath;
  }

  @Override
  public Path getConfPath() {

    return this.confPath;
  }

  @Override
  public Path getSoftwarePath() {

    if (this.ideHome == null) {
      return null;
    }
    return this.ideHome.resolve(FOLDER_SOFTWARE);
  }

  @Override
  public Path getSoftwareExtraPath() {

    Path softwarePath = getSoftwarePath();
    if (softwarePath == null) {
      return null;
    }
    return softwarePath.resolve(FOLDER_EXTRA);
  }

  @Override
  public Path getSoftwareRepositoryPath() {

    Path idePath = getIdePath();
    if (idePath == null) {
      return null;
    }
    return idePath.resolve(FOLDER_SOFTWARE);
  }

  @Override
  public Path getPluginsPath() {

    return this.pluginsPath;
  }

  @Override
  public String getWorkspaceName() {

    return this.workspaceName;
  }

  @Override
  public Path getWorkspacesBasePath() {

    return this.workspacesBasePath;
  }

  @Override
  public Path getWorkspacePath() {

    return this.workspacePath;
  }

  @Override
  public Path getWorkspacePath(String workspace) {

    if (this.workspacesBasePath == null) {
      throw new IllegalStateException("Failed to access workspace " + workspace + " without IDE_HOME in " + this.cwd);
    }
    return this.workspacesBasePath.resolve(workspace);
  }

  @Override
  public Path getDownloadPath() {

    return this.downloadPath;
  }

  @Override
  public Path getUrlsPath() {

    Path idePath = getIdePath();
    if (idePath == null) {
      return null;
    }
    return idePath.resolve(FOLDER_URLS);
  }

  @Override
  public Path getToolRepositoryPath() {

    Path idePath = getIdePath();
    if (idePath == null) {
      return null;
    }
    return idePath.resolve(FOLDER_SOFTWARE);
  }

  @Override
  public SystemPath getPath() {

    return this.path;
  }

  @Override
  public EnvironmentVariables getVariables() {

    if (this.variables == null) {
      this.variables = createVariables();
    }
    return this.variables;
  }

  @Override
  public UrlMetadata getUrls() {

    if (this.urlMetadata == null) {
      if (!isTest()) {
        getGitContext().pullOrCloneAndResetIfNeeded(IDE_URLS_GIT, getUrlsPath(), null);
      }
      this.urlMetadata = new UrlMetadata(this);
    }
    return this.urlMetadata;
  }

  @Override
  public boolean isQuietMode() {

    return this.startContext.isQuietMode();
  }

  @Override
  public boolean isBatchMode() {

    return this.startContext.isBatchMode();
  }

  @Override
  public boolean isForceMode() {

    return this.startContext.isForceMode();
  }

  @Override
  public boolean isForcePull() {

    return this.startContext.isForcePull();
  }

  @Override
  public boolean isForcePlugins() {

    return this.startContext.isForcePlugins();
  }

  @Override
  public boolean isForceRepositories() {

    return this.startContext.isForceRepositories();
  }

  @Override
  public boolean isOfflineMode() {

    return this.startContext.isOfflineMode();
  }

  @Override
  public boolean isPrivacyMode() {
    return this.startContext.isPrivacyMode();
  }

  @Override
  public boolean isSkipUpdatesMode() {

    return this.startContext.isSkipUpdatesMode();
  }

  @Override
  public boolean isNoColorsMode() {

    return this.startContext.isNoColorsMode();
  }

  @Override
  public NetworkStatus getNetworkStatus() {

    if (this.networkStatus == null) {
      this.networkStatus = new NetworkStatusImpl(this);
    }
    return this.networkStatus;
  }

  @Override
  public Locale getLocale() {

    Locale locale = this.startContext.getLocale();
    if (locale == null) {
      locale = Locale.getDefault();
    }
    return locale;
  }

  @Override
  public DirectoryMerger getWorkspaceMerger() {

    if (this.workspaceMerger == null) {
      this.workspaceMerger = new DirectoryMerger(this);
    }
    return this.workspaceMerger;
  }

  /**
   * @return the default execution directory in which a command process is executed.
   */
  @Override
  public Path getDefaultExecutionDirectory() {

    return this.defaultExecutionDirectory;
  }

  /**
   * @param defaultExecutionDirectory new value of {@link #getDefaultExecutionDirectory()}.
   */
  public void setDefaultExecutionDirectory(Path defaultExecutionDirectory) {

    if (defaultExecutionDirectory != null) {
      this.defaultExecutionDirectory = defaultExecutionDirectory;
    }
  }

  @Override
  public GitContext getGitContext() {

    return new GitContextImpl(this);
  }

  @Override
  public ProcessContext newProcess() {

    ProcessContext processContext = createProcessContext();
    if (this.defaultExecutionDirectory != null) {
      processContext.directory(this.defaultExecutionDirectory);
    }
    return processContext;
  }

  @Override
  public IdeSystem getSystem() {

    if (this.system == null) {
      this.system = new IdeSystemImpl();
    }
    return this.system;
  }

  /**
   * @return a new instance of {@link ProcessContext}.
   * @see #newProcess()
   */
  protected ProcessContext createProcessContext() {

    return new ProcessContextImpl(this);
  }

  @Override
  public IdeLogLevel getLogLevelConsole() {

    return this.startContext.getLogLevelConsole();
  }

  @Override
  public IdeLogLevel getLogLevelLogger() {

    return this.startContext.getLogLevelLogger();
  }

  @Override
  public IdeLogListener getLogListener() {

    return this.startContext.getLogListener();
  }

  @Override
  public void logIdeHomeAndRootStatus() {
    if (this.ideRoot != null) {
      IdeLogLevel.SUCCESS.log(LOG, "IDE_ROOT is set to {}", this.ideRoot);
    }
    if (this.ideHome == null) {
      LOG.warn(getMessageNotInsideIdeProject());
    } else {
      IdeLogLevel.SUCCESS.log(LOG, "IDE_HOME is set to {}", this.ideHome);
    }
  }

  @Override
  public String formatArgument(Object argument) {

    if (argument == null) {
      return null;
    }
    String result = argument.toString();
    if (isPrivacyMode()) {
      if ((this.ideRoot != null) && this.privacyMap.isEmpty()) {
        initializePrivacyMap(this.userHome, "~");
        String projectName = getProjectName();
        if (!projectName.isEmpty()) {
          this.privacyMap.put(projectName, "project");
        }
      }
      for (Entry<String, String> entry : this.privacyMap.entrySet()) {
        result = result.replace(entry.getKey(), entry.getValue());
      }
      result = PrivacyUtil.removeSensitivePathInformation(result);
    }
    return result;
  }

  /**
   * @param path the sensitive {@link Path} to
   * @param replacement the replacement to mask the {@link Path} in log output.
   */
  protected void initializePrivacyMap(Path path, String replacement) {

    if (path == null) {
      return;
    }
    if (this.systemInfo.isWindows()) {
      this.privacyMap.put(WindowsPathSyntax.WINDOWS.format(path), replacement);
      this.privacyMap.put(WindowsPathSyntax.MSYS.format(path), replacement);
    } else {
      this.privacyMap.put(path.toString(), replacement);
    }
  }

  /**
   * Resets the privacy map in case fundamental values have changed.
   */
  private void resetPrivacyMap() {

    this.privacyMap.clear();
  }


  @Override
  public String askForInput(String message, String defaultValue) {

    while (true) {
      if (!message.isBlank()) {
        IdeLogLevel.INTERACTION.log(LOG, message);
      }
      if (isBatchMode()) {
        if (isForceMode()) {
          return defaultValue;
        } else {
          throw new CliAbortException();
        }
      }
      String input = readLine().trim();
      if (!input.isEmpty()) {
        return input;
      } else {
        if (defaultValue != null) {
          return defaultValue;
        }
      }
    }
  }

  @Override
  public <O> O question(O[] options, String question, Object... args) {

    assert (options.length > 0);
    IdeLogLevel.INTERACTION.log(LOG, question, args);
    LOG.warn(question, args);
    return displayOptionsAndGetAnswer(options);
  }

  private <O> O displayOptionsAndGetAnswer(O[] options) {
    Map<String, O> mapping = new HashMap<>(options.length);
    int i = 0;
    for (O option : options) {
      i++;
      String title = "" + option;
      String key = computeOptionKey(title);
      addMapping(mapping, key, option);
      String numericKey = Integer.toString(i);
      if (numericKey.equals(key)) {
        LOG.trace("Options should not be numeric: {}", key);
      } else {
        addMapping(mapping, numericKey, option);
      }
      IdeLogLevel.INTERACTION.log(LOG, "Option {}: {}", numericKey, title);
    }
    if (options.length == 1) {
      mapping.put("", options[0]);
    }
    O option = null;
    if (isBatchMode()) {
      if (isForceMode()) {
        option = options[0];
        IdeLogLevel.INTERACTION.log(LOG, "" + option);
      }
    } else {
      while (option == null) {
        String answer = readLine();
        option = mapping.get(answer);
        if (option == null) {
          LOG.warn("Invalid answer: '{}' - please try again.", answer);
        }
      }
    }
    return option;
  }

  private static String computeOptionKey(String option) {
    String key = option;
    int index = -1;
    for (char c : OPTION_DETAILS_START.toCharArray()) {
      int currentIndex = key.indexOf(c);
      if (currentIndex != -1) {
        if ((index == -1) || (currentIndex < index)) {
          index = currentIndex;
        }
      }
    }
    if (index > 0) {
      key = key.substring(0, index).trim();
    }
    return key;
  }

  /**
   * @return the input from the end-user (e.g. read from the console).
   */
  protected abstract String readLine();

  private static <O> void addMapping(Map<String, O> mapping, String key, O option) {

    O duplicate = mapping.put(key, option);
    if (duplicate != null) {
      throw new IllegalArgumentException("Duplicated option " + key);
    }
  }

  @Override
  public Step getCurrentStep() {

    return this.currentStep;
  }

  @Override
  public StepImpl newStep(boolean silent, String name, Object... parameters) {

    this.currentStep = new StepImpl(this, this.currentStep, name, silent, parameters);
    return this.currentStep;
  }

  /**
   * Internal method to end the running {@link Step}.
   *
   * @param step the current {@link Step} to end.
   */
  public void endStep(StepImpl step) {

    if (step == this.currentStep) {
      this.currentStep = this.currentStep.getParent();
    } else {
      String currentStepName = "null";
      if (this.currentStep != null) {
        currentStepName = this.currentStep.getName();
      }
      LOG.warn("endStep called with wrong step '{}' but expected '{}'", step.getName(), currentStepName);
    }
  }

  /**
   * Finds the matching {@link Commandlet} to run, applies {@link CliArguments} to its {@link Commandlet#getProperties() properties} and will execute it.
   *
   * @param arguments the {@link CliArgument}.
   * @return the return code of the execution.
   */
  public int run(CliArguments arguments) {

    CliArgument current = arguments.current();
    if (current.isStart()) {
      arguments.next();
      current = arguments.current();
    }
    assert (this.currentStep == null);
    boolean supressStepSuccess = false;
    StepImpl step = newStep(true, "ide", (Object[]) current.asArray());
    Iterator<Commandlet> commandletIterator = this.commandletManager.findCommandlet(arguments, null);
    Commandlet cmd = null;
    ValidationResult result = null;
    try {
      while (commandletIterator.hasNext()) {
        cmd = commandletIterator.next();
        result = applyAndRun(arguments.copy(), cmd);
        if (result.isValid()) {
          supressStepSuccess = cmd.isSuppressStepSuccess();
          step.success();
          return ProcessResult.SUCCESS;
        }
      }
      activateLogging(cmd);
      String commandKey = current.getKey();

      if (commandKey == null || commandKey.isBlank()) {
        return 0;
      }
      Commandlet commandletByName = this.commandletManager.getCommandlet(commandKey);
      // Missing commandlet
      if (commandletByName == null) {
        if (getCliSuggester().isMissingCommandletHandled(commandKey, step)) {
          return 1;
        }
        return 0;
      }
      // Missing project context
      if (getCliSuggester().isMissingProjectContextHandled(commandletByName, step)) {
        return 1;
      }
      // Only validate options/arguments if same commandlet and proper type
      if (cmd != commandletByName || !(result instanceof ValidationState validationState)) {
        return 0;
      }
      // Invalid option
      if (getCliSuggester().isInvalidOptionHandled(validationState, commandletByName, step)) {
        return 1;
      }
      // Invalid argument
      if (getCliSuggester().isInvalidArgumentHandled(validationState, commandletByName)) {
        return 1;
      }
      LOG.error(result.getErrorMessage());
      step.error("Invalid arguments: {}", current.getArgs());
      IdeLogLevel.INTERACTION.log(LOG, "For additional details run ide help {}", cmd == null ? "" : cmd.getName());
      return 1;
    } catch (Throwable t) {
      activateLogging(cmd);
      step.error(t, true);
      if (this.logfile != null) {
        // point the user to the logfile directly (does not make sense via logger)
        System.err.println("Logfile can be found at " + this.logfile); // checkstyle:ignore SystemOut
      }
      throw t;
    } finally {
      step.close();
      assert (this.currentStep == null);
      step.logSummary(supressStepSuccess);
    }
  }


  /**
   * @return the {@link CliSuggester} for CLI suggestions.
   */
  private CliSuggester getCliSuggester() {
    if (this.cliSuggester == null) {
      this.cliSuggester = new CliSuggester(this);
    }
    return this.cliSuggester;
  }

  /**
   * Ensure the logging system is initialized.
   */
  private void activateLogging(Commandlet cmd) {

    configureJavaUtilLogging(cmd);
    this.startContext.activateLogging();
  }

  /**
   * Configures the logging system (JUL).
   *
   * @param cmd the {@link Commandlet} to be called. May be {@code null}.
   */
  public void configureJavaUtilLogging(Commandlet cmd) {

    if (this.julConfigured) {
      return;
    }
    boolean writeLogfile = isWriteLogfile(cmd);
    this.startContext.setWriteLogfile(writeLogfile);
    Properties properties = createJavaUtilLoggingProperties(writeLogfile, cmd);
    try {
      ByteArrayOutputStream out = new ByteArrayOutputStream(512);
      properties.store(out, null);
      out.flush();
      ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
      LogManager.getLogManager().readConfiguration(in);
      this.julConfigured = true;
      this.startContext.activateLogging();
    } catch (IOException e) {
      LOG.error("Failed to configure logging: {}", e.toString(), e);
    }
  }

  protected boolean isWriteLogfile(Commandlet cmd) {
    if ((cmd == null) || !cmd.isWriteLogFile()) {
      return false;
    }
    Boolean writeLogfile = IdeVariables.IDE_WRITE_LOGFILE.get(this);
    return Boolean.TRUE.equals(writeLogfile);
  }

  private Properties createJavaUtilLoggingProperties(boolean writeLogfile, Commandlet cmd) {

    Path idePath = getIdePath();
    if (writeLogfile && (idePath == null)) {
      writeLogfile = false;
      LOG.error("Cannot enable log-file since IDE_ROOT is undefined.");
    }
    Properties properties = new Properties();
    // prevent 3rd party (e.g. java.lang.ProcessBuilder) logging into our console via JUL
    // see JulLogLevel for the trick we did to workaround JUL flaws
    properties.setProperty(".level", "SEVERE");
    if (writeLogfile) {
      this.startContext.setLogLevelLogger(IdeLogLevel.TRACE);
      String fileHandlerName = FileHandler.class.getName();
      properties.setProperty("handlers", JulConsoleHandler.class.getName() + "," + fileHandlerName);
      properties.setProperty(fileHandlerName + ".formatter", SimpleFormatter.class.getName());
      properties.setProperty(fileHandlerName + ".encoding", "UTF-8");
      this.logfile = createLogfilePath(idePath, cmd);
      getFileAccess().mkdirs(this.logfile.getParent());
      properties.setProperty(fileHandlerName + ".pattern", this.logfile.toString());
    } else {
      properties.setProperty("handlers", JulConsoleHandler.class.getName());
    }
    properties.setProperty(SimpleFormatter.class.getName() + ".format", "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS.%1$tL [%4$s] [%3$s] %5$s%6$s%n");
    return properties;
  }

  private Path createLogfilePath(Path idePath, Commandlet cmd) {
    LocalDateTime now = LocalDateTime.now();
    Path logsPath = idePath.resolve(FOLDER_LOGS).resolve(DateTimeUtil.formatDate(now, true));
    StringBuilder sb = new StringBuilder(32);
    if (this.ideHome == null || ((cmd != null) && !cmd.isIdeHomeRequired())) {
      sb.append("_ide-");
    } else {
      sb.append(this.ideHome.getFileName().toString());
      sb.append('-');
    }
    sb.append("ide-");
    if (cmd != null) {
      sb.append(cmd.getName());
      sb.append('-');
    }
    sb.append(DateTimeUtil.formatTime(now));
    sb.append(".log");
    return logsPath.resolve(sb.toString());
  }

  @Override
  public void runWithoutLogging(Runnable lambda, IdeLogLevel threshold) {

    this.startContext.deactivateLogging(threshold);
    lambda.run();
    this.startContext.activateLogging();
  }

  /**
   * @param cmd the potential {@link Commandlet} to {@link #apply(CliArguments, Commandlet) apply} and {@link Commandlet#run() run}.
   * @return {@code true} if the given {@link Commandlet} matched and did {@link Commandlet#run() run} successfully, {@code false} otherwise (the
   *     {@link Commandlet} did not match and we have to try a different candidate).
   */
  private ValidationResult applyAndRun(CliArguments arguments, Commandlet cmd) {

    IdeLogLevel previousLogLevel = null;
    cmd.reset();
    ValidationResult result = apply(arguments, cmd);
    if (result.isValid()) {
      result = cmd.validate();
    }
    if (result.isValid()) {
      LOG.debug("Running commandlet {}", cmd);
      if (cmd.isIdeHomeRequired() && (this.ideHome == null)) {
        throw new CliException(getMessageNotInsideIdeProject(), ProcessResult.NO_IDE_HOME);
      } else if (cmd.isIdeRootRequired() && (this.ideRoot == null)) {
        throw new CliException(getMessageIdeRootNotFound(), ProcessResult.NO_IDE_ROOT);
      }
      try {
        if (cmd.isProcessableOutput()) {
          if (!isLogLevelEnabled(IdeLogLevel.DEBUG)) {
            // unless --debug or --trace was supplied, processable output commandlets will disable all log-levels except INFO to prevent other logs interfere
            previousLogLevel = this.startContext.setLogLevelConsole(IdeLogLevel.PROCESSABLE);
          }
        } else {
          if (cmd.isIdeHomeRequired()) {
            LOG.debug(getMessageIdeHomeFound());
          }
          if (!(cmd instanceof UpgradeCommandlet)) {
            verifyIdeMinVersion(false);
          }
          Path settingsRepository = getSettingsGitRepository();
          if (settingsRepository != null) {
            if (getGitContext().isRepositoryUpdateAvailable(settingsRepository, getSettingsCommitIdPath()) || (
                getGitContext().fetchIfNeeded(settingsRepository) && getGitContext().isRepositoryUpdateAvailable(
                    settingsRepository, getSettingsCommitIdPath()))) {

              // Inform the user that an update is available. The update message is suppressed if we are already running the update
              String msg = determineSettingsUpdateMessage(cmd);
              if (msg != null) {
                IdeLogLevel.INTERACTION.log(LOG, msg);
              }
            }
          }
        }
        boolean success = ensureLicenseAgreement(cmd);
        if (!success) {
          return ValidationResultValid.get();
        }
        cmd.run();
      } finally {
        if (previousLogLevel != null) {
          this.startContext.setLogLevelConsole(previousLogLevel);
        }
      }
    } else {
      LOG.trace("Commandlet did not match");
    }
    return result;
  }


  /**
   * When an update is available for the settings repository, we log a message to the console, reminding the user to run {@code ide update}. This method
   * determines the correct message to log, depending on whether the settings repository is a symlink/junction, or not. Should the user already be running the
   * appropriate {@code ide update} command, the message is suppressed to avoid confusion.
   *
   * @param cmd the {@link Commandlet}.
   * @return {@code msg} to log to the console. {@code null} if the message is suppressed.
   */
  private String determineSettingsUpdateMessage(Commandlet cmd) {
    boolean update = cmd instanceof UpdateCommandlet;
    if (isSettingsCodeRepository()) {
      if (update && (isForceMode() || isForcePull())) {
        return null;
      }
      return "Updates are available for the settings repository. Please pull the latest changes by yourself or by calling \"ide -f update\" to apply them.";
    } else {
      if (update) {
        return null;
      }
      return "Updates are available for the settings repository. If you want to apply the latest changes, call \"ide update\"";
    }
  }

  private boolean ensureLicenseAgreement(Commandlet cmd) {

    if (isTest()) {
      return true; // ignore for tests
    }
    getFileAccess().mkdirs(this.userHomeIde);
    Path licenseAgreement = this.userHomeIde.resolve(FILE_LICENSE_AGREEMENT);
    if (Files.isRegularFile(licenseAgreement)) {
      return true; // success, license already accepted
    }
    if (cmd instanceof EnvironmentCommandlet) {
      // if the license was not accepted, "$(ideasy env --bash)" that is written into a variable prevents the user from seeing the question he is asked
      // in such situation the user could not open a bash terminal anymore and gets blocked what would really annoy the user so we exit here without doing or
      // printing anything anymore in such case.
      return false;
    }
    activateLogging(cmd);
    IdeLogLevel oldLogLevel = this.startContext.getLogLevelConsole();
    IdeLogLevel newLogLevel = oldLogLevel;
    if (oldLogLevel.ordinal() > IdeLogLevel.INFO.ordinal()) {
      newLogLevel = IdeLogLevel.INFO;
      this.startContext.setLogLevelConsole(newLogLevel);
    }
    StringBuilder sb = new StringBuilder(1180);
    sb.append(LOGO).append("""
        Welcome to IDEasy!
        This product (with its included 3rd party components) is open-source software and can be used free (also commercially).
        It supports automatic download and installation of arbitrary 3rd party tools.
        By default only open-source 3rd party tools are used (downloaded, installed, executed).
        But if explicitly configured, also commercial software that requires an additional license may be used.
        This happens e.g. if you configure "ultimate" edition of IntelliJ or "docker" edition of Docker (Docker Desktop).
        You are solely responsible for all risks implied by using this software.
        Before using IDEasy you need to read and accept the license agreement with all involved licenses.
        You will be able to find it online under the following URL:
        """).append(LICENSE_URL);
    if (this.ideRoot != null) {
      sb.append("\n\nAlso it is included in the documentation that you can find here:\n").
          append(getIdePath().resolve("IDEasy.pdf").toString()).append("\n");
    }
    LOG.info(sb.toString());
    askToContinue("Do you accept these terms of use and all license agreements?");

    sb.setLength(0);
    LocalDateTime now = LocalDateTime.now();
    sb.append("On ").append(DateTimeUtil.formatDate(now, false)).append(" at ").append(DateTimeUtil.formatTime(now))
        .append(" you accepted the IDEasy license.\n").append(LICENSE_URL);
    try {
      Files.writeString(licenseAgreement, sb);
    } catch (Exception e) {
      throw new RuntimeException("Failed to save license agreement!", e);
    }
    if (oldLogLevel != newLogLevel) {
      this.startContext.setLogLevelConsole(oldLogLevel);
    }
    return true;
  }

  @Override
  public void verifyIdeMinVersion(boolean throwException) {
    VersionIdentifier minVersion = IDE_MIN_VERSION.get(this);
    if (minVersion == null) {
      return;
    }
    VersionIdentifier versionIdentifier = IdeVersion.getVersionIdentifier();
    if (versionIdentifier.compareVersion(minVersion).isLess() && !IdeVersion.isUndefined()) {
      String warning = String.format("Your version of IDEasy is currently %s\n"
          + "However, this is too old as your project requires at latest version %s", versionIdentifier, minVersion);
      String interaction = "Please run the following command to update to the latest version of IDEasy and fix the problem:\n"
          + "ide upgrade";
      if (throwException) {
        throw new CliException(warning + "\n" + interaction);
      } else {
        LOG.warn(warning);
        IdeLogLevel.INTERACTION.log(LOG, interaction);
      }
    }
  }

  /**
   * @param arguments the {@link CliArguments#ofCompletion(String...) completion arguments}.
   * @param includeContextOptions to include the options of {@link ContextCommandlet}.
   * @return the {@link List} of {@link CompletionCandidate}s to suggest.
   */
  public List<CompletionCandidate> complete(CliArguments arguments, boolean includeContextOptions) {

    CompletionCandidateCollector collector = new CompletionCandidateCollectorDefault(this);
    if (arguments.current().isStart()) {
      arguments.next();
    }
    if (includeContextOptions) {
      ContextCommandlet cc = new ContextCommandlet();
      for (Property<?> property : cc.getProperties()) {
        assert (property.isOption());
        property.apply(arguments, this, cc, collector);
      }
    }
    Iterator<Commandlet> commandletIterator = this.commandletManager.findCommandlet(arguments, collector);
    CliArgument current = arguments.current();
    if (current.isCompletion() && current.isCombinedShortOption()) {
      collector.add(current.get(), null, null, null);
    }
    arguments.next();
    while (commandletIterator.hasNext()) {
      Commandlet cmd = commandletIterator.next();
      if (!arguments.current().isEnd()) {
        completeCommandlet(arguments.copy(), cmd, collector);
      }
    }
    return collector.getSortedCandidates();
  }

  /**
   * Gets the next value property and applies its implicit end-options behavior if required.
   *
   * @param valueIterator the iterator over the commandlet value properties
   * @param arguments the CLI arguments whose option parsing state may be updated
   * @return the next value property or {@code null} if no further value property exists
   */
  private Property<?> nextValueProperty(Iterator<Property<?>> valueIterator, CliArguments arguments) {

    if (!valueIterator.hasNext()) {
      return null;
    }

    Property<?> valueProperty = valueIterator.next();
    if (valueProperty.isEndOptions()) {
      // Tool argument properties should accept values starting with "-" so stop option parsing here
      arguments.endOptions();
    }
    return valueProperty;
  }

  private void completeCommandlet(CliArguments arguments, Commandlet cmd, CompletionCandidateCollector collector) {

    LOG.trace("Trying to match arguments for auto-completion for commandlet {}", cmd.getName());

    // Collect all already-provided arguments (non-completion) to filter out synonyms
    Set<String> alreadyProvided = new HashSet<>();
    CliArguments argsCopy = arguments.copy();
    while (!argsCopy.current().isEnd()) {
      CliArgument arg = argsCopy.current();
      if (!arg.isCompletion()) {
        alreadyProvided.add(arg.get());
      }
      argsCopy.next();
    }
    collector.setAlreadyProvided(alreadyProvided);

    Iterator<Property<?>> valueIterator = cmd.getValues().iterator();
    valueIterator.next(); // skip first property since this is the keyword property that already matched to find the commandlet
    Property<?> currentValueProperty = nextValueProperty(valueIterator, arguments);
    List<Property<?>> properties = cmd.getProperties();
    // we are creating our own list of options and remove them when matched to avoid duplicate suggestions
    List<Property<?>> optionProperties = new ArrayList<>(properties.size());
    for (Property<?> property : properties) {
      if (property.isOption()) {
        optionProperties.add(property);
      }
    }
    CliArgument currentArgument = arguments.current();
    while (!currentArgument.isEnd()) {
      LOG.trace("Trying to match argument '{}'", currentArgument);
      if (currentArgument.isOption() && !arguments.isEndOptions()) {
        if (currentArgument.isCompletion()) {
          Iterator<Property<?>> optionIterator = optionProperties.iterator();
          while (optionIterator.hasNext()) {
            Property<?> option = optionIterator.next();
            boolean success = option.apply(arguments, this, cmd, collector);
            if (success) {
              optionIterator.remove();
              arguments.next();
            }
          }
        } else {
          Property<?> option = cmd.getOption(currentArgument.get());
          if (option != null) {
            arguments.next();
            boolean removed = optionProperties.remove(option);
            if (!removed) {
              option = null;
            }
          }
          if (option == null) {
            LOG.trace("No such option was found.");
            return;
          }
        }
      } else {
        if (currentValueProperty != null) {
          boolean success = currentValueProperty.apply(arguments, this, cmd, collector);
          if (!success) {
            LOG.trace("Completion cannot match any further.");
            return;
          }
          if (!currentValueProperty.isMultiValued()) {
            currentValueProperty = nextValueProperty(valueIterator, arguments);
          }
        } else {
          LOG.trace("No value left for completion.");
          return;
        }
      }
      currentArgument = arguments.current();
    }
  }

  /**
   * @param arguments the {@link CliArguments} to apply. Will be {@link CliArguments#next() consumed} as they are matched. Consider passing a
   *     {@link CliArguments#copy() copy} as needed.
   * @param cmd the potential {@link Commandlet} to match.
   * @return the {@link ValidationResult} telling if the {@link CliArguments} can be applied successfully or if validation errors ocurred.
   */
  public ValidationResult apply(CliArguments arguments, Commandlet cmd) {

    LOG.trace("Trying to match arguments to commandlet {}", cmd.getName());
    CliArgument currentArgument = arguments.current();
    Iterator<Property<?>> propertyIterator = cmd.getValues().iterator();
    Property<?> property = null;
    if (propertyIterator.hasNext()) {
      property = propertyIterator.next();
    }
    while (!currentArgument.isEnd()) {
      LOG.trace("Trying to match argument '{}'", currentArgument);
      Property<?> currentProperty = property;
      if (!arguments.isEndOptions()) {
        Property<?> option = cmd.getOption(currentArgument.getKey());
        if (option != null) {
          currentProperty = option;
        } else {
          boolean allowDashedValue = (property != null) && property.isValue()
              && (property.isMultiValued() || "-".equals(currentArgument.get()));
          boolean allowKeywordOption = (currentProperty instanceof KeywordProperty keywordProperty) && keywordProperty.matches(currentArgument.getKey());
          if (!allowDashedValue && !allowKeywordOption && currentArgument.isOption()) {
            ValidationState state = new ValidationState(null);
            state.addInvalidOption(currentArgument.getKey());
            state.addErrorMessage("Invalid option \"" + currentArgument.getKey() + "\"");
            return state;
          }
        }
      }
      if (currentProperty == null) {
        LOG.trace("No option or next value found");
        ValidationState state = new ValidationState(null);
        state.addErrorMessage("No matching property found");
        return state;
      }
      LOG.trace("Next property candidate to match argument is {}", currentProperty);
      if (currentProperty == property) {
        if (!property.isMultiValued()) {
          if (propertyIterator.hasNext()) {
            property = propertyIterator.next();
          } else {
            property = null;
          }
        }
        if ((property != null) && property.isValue() && property.isMultiValued()) {
          arguments.endOptions();
        }
      }
      boolean matches = currentProperty.apply(arguments, this, cmd, null);
      if (!matches) {
        String invalidValue = currentProperty.getLastInvalidValue();
        if (invalidValue != null) {
          ValidationState state = new ValidationState(null);
          state.addInvalidArgument(invalidValue, currentProperty.getNameOrAlias());
          state.addErrorMessage(
              "Invalid CLI argument '" + invalidValue + "' for property '" + currentProperty.getNameOrAlias() + "' of commandlet '" + cmd.getName() + "'");
          currentProperty.clearLastInvalidValue();
          return state;
        }
        ValidationState state = new ValidationState(null);
        state.addErrorMessage("No matching property found");
        return state;
      }
      currentArgument = arguments.current();
    }
    return ValidationResultValid.get();
  }

  @Override
  public Path findBash() {
    if (this.bash != null) {
      return this.bash;
    }
    Path bashPath = findBashOnBashPath();
    if (bashPath == null) {
      bashPath = findBashInPath();
      if (bashPath == null && (getSystemInfo().isWindows() || SystemInfoImpl.INSTANCE.isWindows())) {
        bashPath = findBashOnWindowsDefaultGitPath();
        if (bashPath == null) {
          bashPath = findBashInWindowsRegistry();
        }
      }
    }
    if (bashPath == null) {
      LOG.error("No bash executable could be found on your system.");
    } else {
      this.bash = bashPath;
    }
    return bashPath;
  }

  private Path findBashOnBashPath() {
    LOG.trace("Trying to find BASH_PATH environment variable.");
    Path bash;
    String bashPathVariableName = IdeVariables.BASH_PATH.getName();
    String bashVariable = getVariables().get(bashPathVariableName);
    if (bashVariable != null) {
      bash = Path.of(bashVariable);
      if (Files.exists(bash)) {
        LOG.debug("{} environment variable was found and points to: {}", bashPathVariableName, bash);
        return bash;
      } else {
        LOG.error("The environment variable {} points to a non existing file: {}", bashPathVariableName, bash);
        return null;
      }
    } else {
      LOG.debug("{} environment variable was not found", bashPathVariableName);
      return null;
    }
  }

  /**
   * @param path the path to check.
   * @param toIgnore the String sequence which needs to be checked and ignored.
   * @return {@code true} if the sequence to ignore was not found, {@code false} if the path contained the sequence to ignore.
   */
  private boolean checkPathToIgnoreLowercase(Path path, String toIgnore) {
    String s = path.toAbsolutePath().toString().toLowerCase(Locale.ROOT);
    return !s.contains(toIgnore);
  }

  /**
   * Tries to find the bash.exe within the PATH environment variable.
   *
   * @return Path to bash.exe if found in PATH environment variable, {@code null} if bash.exe was not found.
   */
  private Path findBashInPath() {
    LOG.trace("Trying to find bash in PATH environment variable.");
    Path bash;
    String pathVariableName = IdeVariables.PATH.getName();
    if (pathVariableName != null) {
      Path plainBash = Path.of(BASH);
      Predicate<Path> pathsToIgnore = p -> checkPathToIgnoreLowercase(p, "\\appdata\\local\\microsoft\\windowsapps") && checkPathToIgnoreLowercase(p,
          "\\windows\\system32");
      Path bashPath = getPath().findBinary(plainBash, pathsToIgnore);
      bash = bashPath.toAbsolutePath();
      if (bashPath.equals(plainBash)) {
        LOG.warn("No usable bash executable was found in your PATH environment variable!");
        bash = null;
      } else {
        if (Files.exists(bashPath)) {
          LOG.debug("A proper bash executable was found in your PATH environment variable at: {}", bash);
        } else {
          bash = null;
          LOG.error("A path to a bash executable was found in your PATH environment variable at: {} but the file is not existing.", bash);
        }
      }
    } else {
      bash = null;
      // this should never happen...
      LOG.error("PATH environment variable was not found");
    }
    return bash;
  }

  /**
   * Tries to find the bash.exe within the Windows registry.
   *
   * @return Path to bash.exe if found in registry, {@code null} if bash.exe was found.
   */
  protected Path findBashInWindowsRegistry() {
    LOG.trace("Trying to find bash in Windows registry");
    // If not found in the default location, try the registry query
    String[] bashVariants = { "GitForWindows", "Cygwin\\setup" };
    String[] registryKeys = { "HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER" };
    for (String bashVariant : bashVariants) {
      LOG.trace("Trying to find bash variant: {}", bashVariant);
      for (String registryKey : registryKeys) {
        LOG.trace("Trying to find bash from registry key: {}", registryKey);
        String toolValueName = ("GitForWindows".equals(bashVariant)) ? "InstallPath" : "rootdir";
        String registryPath = registryKey + "\\Software\\" + bashVariant;

        String path = getWindowsHelper().getRegistryValue(registryPath, toolValueName);
        if (path != null) {
          Path bashPath = Path.of(path + "\\bin\\bash.exe");
          if (Files.exists(bashPath)) {
            LOG.debug("Found bash at: {}", bashPath);
            return bashPath;
          } else {
            LOG.error("Found bash at: {} but it is not pointing to an existing file", bashPath);
            return null;
          }
        } else {
          LOG.info("No bash executable could be found in the Windows registry.");
        }
      }
    }
    // no bash found
    return null;
  }

  private Path findBashOnWindowsDefaultGitPath() {
    // Check if Git Bash exists in the default location
    LOG.trace("Trying to find bash on the Windows default git path.");
    Path defaultPath = Path.of(getDefaultWindowsGitPath());
    if (!defaultPath.toString().isEmpty() && Files.exists(defaultPath)) {
      LOG.trace("Found default path to git bash on Windows at: {}", getDefaultWindowsGitPath());
      return defaultPath;
    }
    LOG.debug("No bash was found on the Windows default git path.");
    return null;
  }

  @Override
  public WindowsPathSyntax getPathSyntax() {

    return this.pathSyntax;
  }

  /**
   * @param pathSyntax new value of {@link #getPathSyntax()}.
   */
  public void setPathSyntax(WindowsPathSyntax pathSyntax) {

    this.pathSyntax = pathSyntax;
  }

  /**
   * @return the {@link IdeStartContextImpl}.
   */
  public IdeStartContextImpl getStartContext() {

    return startContext;
  }

  /**
   * @return the {@link WindowsHelper}.
   */
  public final WindowsHelper getWindowsHelper() {

    if (this.windowsHelper == null) {
      this.windowsHelper = createWindowsHelper();
    }
    return this.windowsHelper;
  }

  /**
   * @return the new {@link WindowsHelper} instance.
   */
  protected WindowsHelper createWindowsHelper() {

    return new WindowsHelperImpl(this);
  }

  /**
   * Reloads this context and re-initializes the {@link #getVariables() variables}.
   */
  public void reload() {

    this.variables = null;
    this.customToolRepository = null;
  }

  @Override
  public void writeVersionFile(VersionIdentifier version, Path installationPath) {

    assert (Files.isDirectory(installationPath));
    Path versionFile = installationPath.resolve(FILE_SOFTWARE_VERSION);
    getFileAccess().writeFileContent(version.toString(), versionFile);
  }

  /*
   * @param home the IDE_HOME directory.
   * @param workspace the name of the active workspace folder.
   */
  protected static record IdeHomeAndWorkspace(Path home, String workspace) {

  }

  /**
   * Returns the default git path on Windows. Required to be overwritten in tests.
   *
   * @return default path to git on Windows.
   */
  public String getDefaultWindowsGitPath() {
    return DEFAULT_WINDOWS_GIT_PATH;
  }

}

devonfw / IDEasy / 29998786930

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