30450098251

Committed 29 Jul 2026 12:04PM UTC coverage: 72.632% (+0.04%) from 72.593%

Build # 30450098251

Build Type

Pull #2232

github

Committed by

web-flow

Commit Message

Merge d7bac434a into ec264ffca

Pull Request Pull Request #2232: #1135: Add PowerShell environment initialization

Coverage Stats

5016 of 7635 branches covered (65.7%)

Branch coverage included in aggregate %.

12922 of 17062 relevant lines covered (75.74%)

3.21 hits per line

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

76.27

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

package com.devonfw.tools.ide.tool;

import java.io.Reader;
import java.io.Writer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

import com.devonfw.tools.ide.cli.CliException;
import com.devonfw.tools.ide.commandlet.UpgradeMode;
import com.devonfw.tools.ide.common.SimpleSystemPath;
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.io.ini.IniFile;
import com.devonfw.tools.ide.io.ini.IniSection;
import com.devonfw.tools.ide.log.IdeLogLevel;
import com.devonfw.tools.ide.os.WindowsHelper;
import com.devonfw.tools.ide.os.WindowsPathSyntax;
import com.devonfw.tools.ide.process.ProcessMode;
import com.devonfw.tools.ide.process.ProcessResult;
import com.devonfw.tools.ide.tool.mvn.MvnArtifact;
import com.devonfw.tools.ide.tool.mvn.MvnBasedLocalToolCommandlet;
import com.devonfw.tools.ide.tool.mvn.MvnRepository;
import com.devonfw.tools.ide.variable.IdeVariables;
import com.devonfw.tools.ide.version.IdeVersion;
import com.devonfw.tools.ide.version.VersionIdentifier;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

/**
 * {@link MvnBasedLocalToolCommandlet} for IDEasy (ide-cli).
 */
public class IdeasyCommandlet extends MvnBasedLocalToolCommandlet {

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

  /** The {@link MvnArtifact} for IDEasy. */
  public static final MvnArtifact ARTIFACT = MvnArtifact.ofIdeasyCli("*!", "tar.gz", "${os}-${arch}");

  private static final String BASH_CODE_SOURCE_FUNCTIONS = "source \"$IDE_ROOT/_ide/installation/functions\"";

  private static final String POWERSHELL_CODE_SOURCE_FUNCTIONS =
      ". \"$env:IDE_ROOT\\_ide\\installation\\functions.ps1\"";

  /** The {@link #getName() tool name}. */
  public static final String TOOL_NAME = "ideasy";
  public static final String BASHRC = ".bashrc";
  public static final String ZSHRC = ".zshrc";
  public static final String IDE_BIN = "\\_ide\\bin";
  public static final String IDE_INSTALLATION_BIN = "\\_ide\\installation\\bin";


  private static final Map<String, Boolean> REQUIRED_INSTALLATION_ARTIFACTS = Map.of(
      //artifactName: String, required: boolean
      "bin", true,
      "functions", true,
      "functions.ps1", true,
      "internal", true,
      "gui", true,
      "system", true,
      "IDEasy.pdf", true,
      "setup", true,
      "setup.bat", false
  );

  private final UpgradeMode mode;

  /** Pattern for IDEasy SNAPSHOT versions built locally. */
  // ..............................................................................1..........................2........3........4
  private static final Pattern PATTERN_IDEASY_SNAPSHOT_VERSION = Pattern.compile("^(\\d{4}\\.\\d{2}\\.\\d{3})-(\\d{2})_(\\d{2})_(\\d{2}).*-SNAPSHOT$");

  /** Pattern for Maven/Nexus SNAPSHOT versions from downloads . */
  // .............................................................................1..........................2.......3.......4..........5
  private static final Pattern PATTERN_MAVEN_SNAPSHOT_VERSION = Pattern.compile("^(\\d{4}\\.\\d{2}\\.\\d{3})-(\\d{4})(\\d{2})(\\d{2})\\.(\\d{2})\\d{4}.*$");

  // Group numbers for PATTERN_IDEASY_SNAPSHOT_VERSION
  private static final int GROUP_IDEASY_BASE = 1;
  private static final int GROUP_IDEASY_MONTH = 2;
  private static final int GROUP_IDEASY_DAY = 3;
  private static final int GROUP_IDEASY_HOUR = 4;

  // Group numbers for PATTERN_MAVEN_SNAPSHOT_VERSION
  private static final int GROUP_MAVEN_BASE = 1;
  private static final int GROUP_MAVEN_YEAR = 2;
  private static final int GROUP_MAVEN_MONTH = 3;
  private static final int GROUP_MAVEN_DAY = 4;
  private static final int GROUP_MAVEN_HOUR = 5;

  /**
   * The constructor.
   *
   * @param context the {@link IdeContext}.
   */
  public IdeasyCommandlet(IdeContext context) {
    this(context, UpgradeMode.STABLE);
  }

  /**
   * The constructor.
   *
   * @param context the {@link IdeContext}.
   * @param mode the {@link UpgradeMode}.
   */
  public IdeasyCommandlet(IdeContext context, UpgradeMode mode) {

    super(context, TOOL_NAME, ARTIFACT, Set.of(Tag.PRODUCTIVITY, Tag.IDE));
    this.mode = mode;
  }

  @Override
  public VersionIdentifier getInstalledVersion() {

    return IdeVersion.getVersionIdentifier();
  }

  @Override
  public String getInstalledEdition() {

    return this.tool;
  }

  @Override
  public String getConfiguredEdition() {

    return this.tool;
  }

  @Override
  public VersionIdentifier getConfiguredVersion() {

    UpgradeMode upgradeMode = this.mode;
    if (upgradeMode == null) {
      if (IdeVersion.isSnapshot()) {
        upgradeMode = UpgradeMode.SNAPSHOT;
      } else {
        if (IdeVersion.getVersionIdentifier().getDevelopmentPhase().isStable()) {
          upgradeMode = UpgradeMode.STABLE;
        } else {
          upgradeMode = UpgradeMode.UNSTABLE;
        }
      }
    }
    return upgradeMode.getVersion();
  }

  @Override
  public Path getToolPath() {

    return this.context.getIdeInstallationPath();
  }

  @Override
  protected ToolInstallation doInstall(ToolInstallRequest request) {

    this.context.requireOnline("upgrade of IDEasy", true);

    if (IdeVersion.isUndefined() && !this.context.isForceMode()) {
      VersionIdentifier version = IdeVersion.getVersionIdentifier();
      LOG.warn("You are using IDEasy version {} which indicates local development - skipping upgrade.", version);
      return toolAlreadyInstalled(request);
    }
    return super.doInstall(request);
  }

  /**
   * @return the latest released {@link VersionIdentifier version} of IDEasy.
   */
  public VersionIdentifier getLatestVersion() {

    if (!this.context.isForceMode()) {
      VersionIdentifier currentVersion = IdeVersion.getVersionIdentifier();
      if (IdeVersion.isUndefined()) {
        return currentVersion;
      }
    }
    VersionIdentifier configuredVersion = getConfiguredVersion();
    return getToolRepository().resolveVersion(this.tool, getConfiguredEdition(), configuredVersion, this);
  }

  /**
   * Checks if an update is available and logs according information.
   *
   * @return {@code true} if an update is available, {@code false} otherwise.
   */
  public boolean checkIfUpdateIsAvailable() {
    VersionIdentifier installedVersion = getInstalledVersion();
    IdeLogLevel.SUCCESS.log(LOG, "Your version of IDEasy is {}.", installedVersion);
    if (IdeVersion.isSnapshot()) {
      LOG.warn("You are using a SNAPSHOT version of IDEasy. For stability consider switching to a stable release via 'ide upgrade --mode=stable'");
    }
    if (this.context.isOffline()) {
      LOG.warn("Skipping check for newer version of IDEasy because you are offline.");
      return false;
    }
    VersionIdentifier latestVersion = getLatestVersion();
    if (IdeVersion.isSnapshot()) {
      if (isSameSnapshotVersion(installedVersion.toString(), latestVersion.toString())) {
        IdeLogLevel.SUCCESS.log(LOG, "Your are using the latest snapshot version of IDEasy and no update is available.");
        return false;
      }
    } else if (installedVersion.equals(latestVersion)) {
      IdeLogLevel.SUCCESS.log(LOG, "Your are using the latest stable version of IDEasy and no update is available.");
      return false;
    }
    IdeLogLevel.INTERACTION.log(LOG,
        "Your version of IDEasy is {} but version {} is available. Please run the following command to upgrade to the latest version:\n"
            + "ide upgrade", installedVersion, latestVersion);
    return true;
  }

  /**
   * Checks if two snapshot versions represent the version
   *
   * @param installed the installed version string
   * @param latest the latest available version string
   * @return {@code true} if both versions represent the same version, {@code false} otherwise.
   */
  private boolean isSameSnapshotVersion(String installed, String latest) {
    if (installed == null || latest == null) {
      return false;
    }

    Matcher installedMatcher = PATTERN_IDEASY_SNAPSHOT_VERSION.matcher(installed);
    Matcher latestMatcher = PATTERN_MAVEN_SNAPSHOT_VERSION.matcher(latest);

    if (!installedMatcher.matches() || !latestMatcher.matches()) {
      return false;
    }

    // Compare base versions
    String baseInstalled = installedMatcher.group(GROUP_IDEASY_BASE);
    String baseLatest = latestMatcher.group(GROUP_MAVEN_BASE);
    if (!baseInstalled.equals(baseLatest)) {
      return false;
    }

    // Compare year
    String yearLatest = latestMatcher.group(GROUP_MAVEN_YEAR);
    String baseYear = baseInstalled.split("\\.")[0];
    if (!baseYear.equals(yearLatest)) {
      return false;
    }

    // Compare MMDD.HH for both versions
    String keyInstalled =
        installedMatcher.group(GROUP_IDEASY_MONTH) + installedMatcher.group(GROUP_IDEASY_DAY) + "." + installedMatcher.group(GROUP_IDEASY_HOUR);
    String keyLatest = latestMatcher.group(GROUP_MAVEN_MONTH) + latestMatcher.group(GROUP_MAVEN_DAY) + "." + latestMatcher.group(GROUP_MAVEN_HOUR);

    return keyInstalled.equals(keyLatest);
  }

  /**
   * Initial installation of IDEasy.
   *
   * @param cwd the {@link Path} to the current working directory.
   * @see com.devonfw.tools.ide.commandlet.InstallCommandlet
   */
  public void installIdeasy(Path cwd) {
    Path ideRoot = determineIdeRoot(cwd);
    // During a fresh (MSI) installation the IDE_ROOT environment variable is not yet available, so context.getIdeRoot() would return null for the whole run.
    // The installation target is already known here, so we make the context consistent for any downstream code reading context.getIdeRoot() (see #1517).
    this.context.setIdeRoot(ideRoot);
    Path idePath = ideRoot.resolve(IdeContext.FOLDER_UNDERSCORE_IDE);
    Path installationPath = idePath.resolve(IdeContext.FOLDER_INSTALLATION);
    Path ideasySoftwarePath = idePath.resolve(IdeContext.FOLDER_SOFTWARE).resolve(MvnRepository.ID).resolve(IdeasyCommandlet.TOOL_NAME)
        .resolve(IdeasyCommandlet.TOOL_NAME);
    Path ideasyVersionPath = ideasySoftwarePath.resolve(IdeVersion.getVersionString());
    FileAccess fileAccess = this.context.getFileAccess();
    if (Files.isDirectory(ideasyVersionPath)) {
      LOG.error("IDEasy is already installed at {} - if your installation is broken, delete it manually and rerun setup!", ideasyVersionPath);
    } else {
      List<Path> installationArtifacts = new ArrayList<>();
      for (Map.Entry<String, Boolean> artifactEntry : REQUIRED_INSTALLATION_ARTIFACTS.entrySet()) {
        String artifactName = artifactEntry.getKey();
        boolean required = artifactEntry.getValue();
        boolean success = addInstallationArtifact(cwd, artifactName, required, installationArtifacts);
        if (!success) {
          throw new CliException("IDEasy release is inconsistent at %s [artifact=%s]".formatted(cwd, artifactName));
        }
      }

      fileAccess.mkdirs(ideasyVersionPath);
      for (Path installationArtifact : installationArtifacts) {
        fileAccess.copy(installationArtifact, ideasyVersionPath);
      }
      this.context.writeVersionFile(IdeVersion.getVersionIdentifier(), ideasyVersionPath);
    }
    fileAccess.symlink(ideasyVersionPath, installationPath);
    addToShellRc(BASHRC, ideRoot, null);
    addToShellRc(ZSHRC, ideRoot, "autoload -U +X bashcompinit && bashcompinit");
    installIdeasyWindowsEnv(ideRoot, installationPath);
    installPowerShellProfile();
    IdeLogLevel.SUCCESS.log(LOG, "IDEasy has been installed successfully on your system.");
    LOG.warn("IDEasy has been setup for new shells but it cannot work in your current shell(s).\n"
        + "To use it here, reload your shell configuration (e.g. 'source ~/.bashrc' in bash "
        + "or '. $PROFILE.CurrentUserAllHosts' in PowerShell). Otherwise, open a new terminal or reboot.");
  }

  private void installIdeasyWindowsEnv(Path ideRoot, Path installationPath) {
    if (!this.context.getSystemInfo().isWindows()) {
      return;
    }
    WindowsHelper helper = WindowsHelper.get(this.context);
    helper.setUserEnvironmentValue(IdeVariables.IDE_ROOT.getName(), ideRoot.toString());
    String userPath = helper.getUserEnvironmentValue(IdeVariables.PATH.getName());
    if (userPath == null) {
      LOG.error("Could not read user PATH from registry!");
    } else {
      LOG.info("Found user PATH={}", userPath);
      Path ideasyBinPath = installationPath.resolve("bin");
      SimpleSystemPath path = SimpleSystemPath.of(userPath, ';');
      if (path.getEntries().isEmpty()) {
        LOG.warn("ATTENTION:\n"
            + "Your user specific PATH variable seems to be empty.\n"
            + "You can double check this by pressing [Windows][r] and launch the program SystemPropertiesAdvanced.\n"
            + "Then click on 'Environment variables' and check if 'PATH' is set in the 'user variables' from the upper list.\n"
            + "In case 'PATH' is defined there non-empty and you get this message, please abort and give us feedback:\n"
            + "https://github.com/devonfw/IDEasy/issues\n"
            + "Otherwise all is correct and you can continue.");
        this.context.askToContinue("Are you sure you want to override your PATH?");
      } else {
        path.removeEntries(s -> s.endsWith(IDE_INSTALLATION_BIN));
      }
      path.getEntries().add(ideasyBinPath.toString());
      helper.setUserEnvironmentValue(IdeVariables.PATH.getName(), path.toString());
      setGitLongpaths();
    }
  }

  private void installPowerShellProfile() {

    modifyPowerShellProfiles(true);
  }

  private void uninstallPowerShellProfile() {

    modifyPowerShellProfiles(false);
  }

  private void modifyPowerShellProfiles(boolean add) {

    if (!this.context.getSystemInfo().isWindows()) {
      return;
    }

    // Windows PowerShell 5.x and PowerShell 7+ have different profile locations.
    modifyPowerShellProfile("powershell", add);
    modifyPowerShellProfile("pwsh", add);
  }

  private void modifyPowerShellProfile(String executable, boolean add) {

    Path profilePath = getPowerShellProfilePath(executable);
    if (profilePath == null) {
      return;
    }

    if (add) {
      LOG.info("Configuring IDEasy in PowerShell profile {}", profilePath);
    } else {
      LOG.info("Removing IDEasy from PowerShell profile {}", profilePath);
    }

    FileAccess fileAccess = this.context.getFileAccess();
    List<String> lines = fileAccess.readFileLines(profilePath);

    if (lines == null) {
      if (!add) {
        return;
      }
      lines = new ArrayList<>();
    } else {
      lines = new ArrayList<>(lines);
    }

    Iterator<String> iterator = lines.iterator();
    boolean alreadyConfigured = false;

    while (iterator.hasNext()) {
      String line = iterator.next().trim();

      if (line.equals(POWERSHELL_CODE_SOURCE_FUNCTIONS)) {
        if (add) {
          alreadyConfigured = true;
        } else {
          iterator.remove();
        }
      }
    }

    if (add && !alreadyConfigured) {
      lines.add(POWERSHELL_CODE_SOURCE_FUNCTIONS);
    }

    Path parent = profilePath.getParent();
    if (parent != null) {
      fileAccess.mkdirs(parent);
    }

    fileAccess.writeFileLines(lines, profilePath);
    LOG.debug("Successfully updated PowerShell profile {}", profilePath);
  }

  private Path getPowerShellProfilePath(String executable) {

    try {
      ProcessResult result = this.context.newProcess()
          .executable(executable)
          .addArgs("-NoProfile", "-Command", "$PROFILE.CurrentUserAllHosts")
          .run(ProcessMode.DEFAULT_CAPTURE);

      if (!result.isSuccessful()) {
        LOG.debug("{} is not available or its profile could not be determined.", executable);
        return null;
      }

      List<String> output = result.getOut();
      if (output == null || output.isEmpty()) {
        LOG.debug("{} returned no PowerShell profile path.", executable);
        return null;
      }

      String profilePath = output.stream()
          .map(String::strip)
          .filter(line -> !line.isEmpty())
          .findFirst()
          .orElse(null);

      if (profilePath == null) {
        LOG.debug("{} returned no PowerShell profile path.", executable);
        return null;
      }

      return Path.of(profilePath);

    } catch (Exception e) {
      // pwsh is optional. Windows PowerShell normally exists on supported Windows versions.
      LOG.debug("Could not determine profile for {}: {}", executable, e.getMessage());
      return null;
    }
  }

  private void setGitLongpaths() {
    this.context.getGitContext().findGitRequired();
    Path configPath = this.context.getUserHome().resolve(".gitconfig");
    FileAccess fileAccess = this.context.getFileAccess();
    IniFile iniFile = fileAccess.readIniFile(configPath);
    IniSection coreSection = iniFile.getOrCreateSection("core");
    coreSection.setProperty("longpaths", "true");
    fileAccess.writeIniFile(iniFile, configPath);
  }

  /**
   * Sets up Windows Terminal with Git Bash integration.
   */
  public void setupWindowsTerminal() {
    if (!this.context.getSystemInfo().isWindows()) {
      return;
    }
    if (!isWindowsTerminalInstalled()) {
      try {
        installWindowsTerminal();
      } catch (Exception e) {
        LOG.error("Failed to install Windows Terminal!", e);
      }
    }
    configureWindowsTerminalGitBash();
  }

  /**
   * Checks if Windows Terminal is installed.
   *
   * @return {@code true} if Windows Terminal is installed, {@code false} otherwise.
   */
  private boolean isWindowsTerminalInstalled() {
    try {
      ProcessResult result = this.context.newProcess()
          .executable("powershell")
          .addArgs("-Command", "Get-AppxPackage -Name Microsoft.WindowsTerminal")
          .run(ProcessMode.DEFAULT_CAPTURE);
      return result.isSuccessful() && !result.getOut().isEmpty();
    } catch (Exception e) {
      LOG.debug("Failed to check Windows Terminal installation.", e);
      return false;
    }
  }

  /**
   * Installs Windows Terminal using winget.
   */
  private void installWindowsTerminal() {
    try {
      LOG.info("Installing Windows Terminal...");
      ProcessResult result = this.context.newProcess()
          .executable("winget")
          .addArgs("install", "Microsoft.WindowsTerminal")
          .run(ProcessMode.DEFAULT);
      if (result.isSuccessful()) {
        IdeLogLevel.SUCCESS.log(LOG, "Windows Terminal has been installed successfully.");
      } else {
        LOG.warn("Failed to install Windows Terminal. Please install it manually from Microsoft Store.");
      }
    } catch (Exception e) {
      LOG.warn("Failed to install Windows Terminal: {}. Please install it manually from Microsoft Store.", e.toString());
    }
  }

  /**
   * Configures Git Bash integration in Windows Terminal.
   */
  protected void configureWindowsTerminalGitBash() {
    Path settingsPath = getWindowsTerminalSettingsPath();
    if (settingsPath == null || !Files.exists(settingsPath)) {
      LOG.warn("Windows Terminal settings file not found. Cannot configure Git Bash integration.");
      return;
    }

    try {
      Path bashPath = this.context.findBash();
      if (bashPath == null) {
        LOG.warn("Git Bash not found. Cannot configure Windows Terminal integration.");
        return;
      }

      configureGitBashProfile(settingsPath, bashPath.toString());
      IdeLogLevel.SUCCESS.log(LOG, "Git Bash has been configured in Windows Terminal.");
    } catch (Exception e) {
      LOG.warn("Failed to configure Git Bash in Windows Terminal: {}", e.getMessage());
    }
  }

  /**
   * Gets the Windows Terminal settings file path.
   *
   * @return the {@link Path} to the Windows Terminal settings file, or {@code null} if not found.
   */
  protected Path getWindowsTerminalSettingsPath() {
    Path localAppData = this.context.getUserHome().resolve("AppData").resolve("Local");
    Path packagesPath = localAppData.resolve("Packages");

    // Try the new Windows Terminal package first
    Path newTerminalPath = packagesPath.resolve("Microsoft.WindowsTerminal_8wekyb3d8bbwe")
        .resolve("LocalState").resolve("settings.json");
    if (Files.exists(newTerminalPath)) {
      return newTerminalPath;
    }

    // Try the old Windows Terminal Preview package
    Path previewPath = packagesPath.resolve("Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe")
        .resolve("LocalState").resolve("settings.json");
    if (Files.exists(previewPath)) {
      return previewPath;
    }

    return null;
  }

  /**
   * Configures Git Bash profile in Windows Terminal settings.
   *
   * @param settingsPath the {@link Path} to the Windows Terminal settings file.
   * @param bashPath the path to the Git Bash executable.
   */
  private void configureGitBashProfile(Path settingsPath, String bashPath) throws Exception {

    ObjectMapper mapper = new ObjectMapper();
    ObjectNode root;
    try (Reader reader = Files.newBufferedReader(settingsPath)) {
      JsonNode rootNode = mapper.readTree(reader);
      root = (ObjectNode) rootNode;
    }

    // Get or create profiles object
    ObjectNode profiles = (ObjectNode) root.get("profiles");
    if (profiles == null) {
      profiles = mapper.createObjectNode();
      root.set("profiles", profiles);
    }

    // Get or create list array of profiles object
    JsonNode profilesList = profiles.get("list");
    if (profilesList == null || !profilesList.isArray()) {
      profilesList = mapper.createArrayNode();
      profiles.set("list", profilesList);
    }

    // Check if Git Bash profile already exists
    boolean gitBashProfileExists = false;
    for (JsonNode profile : profilesList) {
      if (profile.has("name") && profile.get("name").asText().equals("Git Bash")) {
        gitBashProfileExists = true;
        break;
      }
    }

    // Add Git Bash profile if it doesn't exist
    if (gitBashProfileExists) {
      LOG.info("Git Bash profile already exists in {}.", settingsPath);
    } else {
      ObjectNode gitBashProfile = mapper.createObjectNode();
      String newGuid = "{2ece5bfe-50ed-5f3a-ab87-5cd4baafed2b}";
      String iconPath = getGitBashIconPath(bashPath);
      Path startingDirectory = Objects.requireNonNullElse(this.context.getIdeRoot(), this.context.getUserHome());

      gitBashProfile.put("guid", newGuid);
      gitBashProfile.put("name", "Git Bash");
      gitBashProfile.put("commandline", bashPath);
      gitBashProfile.put("icon", iconPath);
      gitBashProfile.put("startingDirectory", startingDirectory.toString());

      ((ArrayNode) profilesList).add(gitBashProfile);

      // Set Git Bash as default profile
      root.put("defaultProfile", newGuid);

      // Write back to file
      try (Writer writer = Files.newBufferedWriter(settingsPath)) {
        mapper.writerWithDefaultPrettyPrinter().writeValue(writer, root);
      }
    }
  }

  private String getGitBashIconPath(String bashPathString) {
    Path bashPath = Path.of(bashPathString);
    // "C:\\Program Files\\Git\\bin\\bash.exe"
    // "C:\\Program Files\\Git\\mingw64\\share\\git\\git-for-windows.ico"
    Path parent = bashPath.getParent();
    if (parent != null) {
      Path iconPath = parent.resolve("mingw64/share/git/git-for-windows.ico");
      if (Files.exists(iconPath)) {
        LOG.debug("Found git-bash icon at {}", iconPath);
        return iconPath.toString();
      }
      LOG.debug("Git Bash icon not found at {}. Using default icon.", iconPath);
    }
    return "ms-appx:///ProfileIcons/{0caa0dad-35be-5f56-a8ff-afceeeaa6101}.png";
  }

  static String removeObsoleteEntryFromWindowsPath(String userPath) {
    return removeEntryFromWindowsPath(userPath, IDE_BIN);
  }

  static String removeEntryFromWindowsPath(String userPath, String suffix) {
    int len = userPath.length();
    int start = 0;
    while ((start >= 0) && (start < len)) {
      int end = userPath.indexOf(';', start);
      if (end < 0) {
        end = len;
      }
      String entry = userPath.substring(start, end);
      if (entry.endsWith(suffix)) {
        String prefix = "";
        int offset = 1;
        if (start > 0) {
          prefix = userPath.substring(0, start - 1);
          offset = 0;
        }
        if (end == len) {
          return prefix;
        } else {
          return removeEntryFromWindowsPath(prefix + userPath.substring(end + offset), suffix);
        }
      }
      start = end + 1;
    }
    return userPath;
  }

  /**
   * Adds ourselves to the shell RC (run-commands) configuration file.
   *
   * @param filename the name of the RC file.
   * @param ideRoot the IDE_ROOT {@link Path}.
   */
  private void addToShellRc(String filename, Path ideRoot, String extraLine) {

    modifyShellRc(filename, ideRoot, true, extraLine);
  }

  private void removeFromShellRc(String filename, Path ideRoot) {

    modifyShellRc(filename, ideRoot, false, null);
  }

  /**
   * Adds ourselves to the shell RC (run-commands) configuration file.
   *
   * @param filename the name of the RC file.
   * @param ideRoot the IDE_ROOT {@link Path}.
   */
  private void modifyShellRc(String filename, Path ideRoot, boolean add, String extraLine) {

    if (add) {
      LOG.info("Configuring IDEasy in {}", filename);
    } else {
      LOG.info("Removing IDEasy from {}", filename);
    }
    Path rcFile = this.context.getUserHome().resolve(filename);
    FileAccess fileAccess = this.context.getFileAccess();
    List<String> lines = fileAccess.readFileLines(rcFile);
    if (lines == null) {
      if (!add) {
        return;
      }
      lines = new ArrayList<>();
    } else {
      // since it is unspecified if the returned List may be immutable we want to get sure
      lines = new ArrayList<>(lines);
    }
    Iterator<String> iterator = lines.iterator();
    int removeCount = 0;
    while (iterator.hasNext()) {
      String line = iterator.next();
      line = line.trim();
      if (isObsoleteRcLine(line)) {
        LOG.info("Removing obsolete line from {}: {}", filename, line);
        iterator.remove();
        removeCount++;
      } else if (line.equals(extraLine)) {
        extraLine = null;
      }
    }
    if (add) {
      if (extraLine != null) {
        lines.add(extraLine);
      }
      if (!this.context.getSystemInfo().isWindows()) {
        lines.add("export IDE_ROOT=\"" + WindowsPathSyntax.MSYS.format(ideRoot) + "\"");
      }
      lines.add(BASH_CODE_SOURCE_FUNCTIONS);
    }
    fileAccess.writeFileLines(lines, rcFile);
    LOG.debug("Successfully updated {}", filename);
  }

  private static boolean isObsoleteRcLine(String line) {
    if (line.startsWith("alias ide=")) {
      return true;
    } else if (line.startsWith("export IDE_ROOT=")) {
      return true;
    } else if (line.equals("ide")) {
      return true;
    } else if (line.equals("ide init")) {
      return true;
    } else if (line.startsWith("source \"$IDE_ROOT/_ide/")) {
      return true;
    }
    return false;
  }

  private boolean addInstallationArtifact(Path cwd, String artifactName, boolean required, List<Path> installationArtifacts) {

    Path artifactPath = cwd.resolve(artifactName);
    if (Files.exists(artifactPath)) {
      installationArtifacts.add(artifactPath);
    } else if (required) {
      LOG.error("Missing required file {}", artifactName);
      return false;
    }
    return true;
  }

  private Path determineIdeRoot(Path cwd) {
    Path ideRoot = this.context.getIdeRoot();
    if (ideRoot == null) {
      Path home = this.context.getUserHome();
      Path installRoot = home;
      if (this.context.getSystemInfo().isWindows()) {
        if (!cwd.startsWith(home)) {
          installRoot = cwd.getRoot();
        }
      }
      ideRoot = installRoot.resolve(IdeContext.FOLDER_PROJECTS);
    } else {
      assert (Files.isDirectory(ideRoot)) : "IDE_ROOT directory does not exist!";
    }
    return ideRoot;
  }

  /**
   * Uninstalls IDEasy entirely from the system.
   */
  public void uninstallIdeasy() {

    Path ideRoot = this.context.getIdeRoot();
    removeFromShellRc(BASHRC, ideRoot);
    removeFromShellRc(ZSHRC, ideRoot);
    Path idePath = this.context.getIdePath();
    uninstallIdeasyWindowsEnv(ideRoot);
    uninstallPowerShellProfile();
    uninstallIdeasyIdePath(idePath);
    deleteDownloadCache();
    IdeLogLevel.SUCCESS.log(LOG, "IDEasy has been uninstalled from your system.");
    IdeLogLevel.INTERACTION.log(LOG, "ATTENTION:\n"
        + "In order to prevent data-loss, we do not delete your projects and git repositories!\n"
        + "To entirely get rid of IDEasy, also check your IDE_ROOT folder at:\n"
        + "{}", ideRoot);
  }

  private void deleteDownloadCache() {
    Path downloadPath = this.context.getDownloadPath();
    LOG.info("Deleting download cache from {}", downloadPath);
    tryDeleteDownloadCache(downloadPath);
    // older versions kept the cache under ~/Downloads/ide - clean that up too if it's still around
    Path legacy = this.context.getUserHome().resolve("Downloads/ide");
    if (!legacy.equals(downloadPath) && Files.exists(legacy)) {
      LOG.info("Deleting legacy download cache from {}", legacy);
      tryDeleteDownloadCache(legacy);
    }
  }

  private void tryDeleteDownloadCache(Path path) {
    try {
      this.context.getFileAccess().delete(path);
    } catch (IllegalStateException e) {
      // best effort - on macOS ~/Downloads can deny access (EPERM), don't fail the whole uninstallation over it
      String cause = (e.getCause() != null) ? e.getCause().getMessage() : e.getMessage();
      LOG.warn("Could not delete download cache at {} ({}). The folder will be left in place; you can remove it manually via Finder.", path, cause);
    }
  }

  private void uninstallIdeasyIdePath(Path idePath) {
    if (this.context.getSystemInfo().isWindows()) {
      Path bash = this.context.findBash();
      if (bash == null) {
        LOG.warn("Could not find bash for asynchronous deletion of {}. Falling back to direct deletion.", idePath);
        this.context.getFileAccess().delete(idePath);
        return;
      }
      this.context.newProcess().executable(bash).addArgs("-c",
          "sleep 10 && rm -rf \"" + WindowsPathSyntax.MSYS.format(idePath) + "\"").run(ProcessMode.BACKGROUND);
      IdeLogLevel.INTERACTION.log(LOG,
          "To prevent windows file locking errors, we perform an asynchronous deletion of {} in background now.\n"
              + "Please close all terminals and wait a minute for the deletion to complete before running other commands.", idePath);
    } else {
      LOG.info("Finally deleting {}", idePath);
      this.context.getFileAccess().delete(idePath);
    }
  }

  private void uninstallIdeasyWindowsEnv(Path ideRoot) {
    if (!this.context.getSystemInfo().isWindows()) {
      return;
    }
    WindowsHelper helper = WindowsHelper.get(this.context);
    helper.removeUserEnvironmentValue(IdeVariables.IDE_ROOT.getName());
    String userPath = helper.getUserEnvironmentValue(IdeVariables.PATH.getName());
    if (userPath == null) {
      LOG.error("Could not read user PATH from registry!");
    } else {
      LOG.info("Found user PATH={}", userPath);
      String newUserPath = userPath;
      if (!userPath.isEmpty()) {
        SimpleSystemPath path = SimpleSystemPath.of(userPath, ';');
        path.removeEntries(s -> s.endsWith(IDE_BIN) || s.endsWith(IDE_INSTALLATION_BIN));
        newUserPath = path.toString();
      }
      if (newUserPath.equals(userPath)) {
        LOG.error("Could not find IDEasy in PATH:\n{}", userPath);
      } else {
        helper.setUserEnvironmentValue(IdeVariables.PATH.getName(), newUserPath);
      }
    }
  }
}

devonfw / IDEasy / 30450098251

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