29803149984

Committed 21 Jul 2026 05:08AM UTC coverage: 72.439% (-0.04%) from 72.476%

Build # 29803149984

Build Type

Pull #2179

github

Committed by

web-flow

Commit Message

Merge c6c1d1813 into 3221b7580

Pull Request Pull Request #2179: Feature/2165 interactive template variables

Coverage Stats

4961 of 7574 branches covered (65.5%)

Branch coverage included in aggregate %.

12804 of 16950 relevant lines covered (75.54%)

3.2 hits per line

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

78.57

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

package com.devonfw.tools.ide.context;

import java.nio.file.Files;
import java.nio.file.Path;

import com.devonfw.tools.ide.cli.CliAbortException;
import com.devonfw.tools.ide.cli.CliException;
import com.devonfw.tools.ide.cli.CliOfflineException;
import com.devonfw.tools.ide.commandlet.CommandletManager;
import com.devonfw.tools.ide.common.SystemPath;
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.git.GitContext;
import com.devonfw.tools.ide.io.FileAccess;
import com.devonfw.tools.ide.io.IdeProgressBar;
import com.devonfw.tools.ide.io.IdeProgressBarNone;
import com.devonfw.tools.ide.log.IdeLogLevel;
import com.devonfw.tools.ide.merge.DirectoryMerger;
import com.devonfw.tools.ide.network.NetworkStatus;
import com.devonfw.tools.ide.os.SystemInfo;
import com.devonfw.tools.ide.os.WindowsPathSyntax;
import com.devonfw.tools.ide.process.ProcessContext;
import com.devonfw.tools.ide.step.Step;
import com.devonfw.tools.ide.tool.corepack.Corepack;
import com.devonfw.tools.ide.tool.custom.CustomToolRepository;
import com.devonfw.tools.ide.tool.gradle.Gradle;
import com.devonfw.tools.ide.tool.mvn.Mvn;
import com.devonfw.tools.ide.tool.mvn.MvnRepository;
import com.devonfw.tools.ide.tool.npm.Npm;
import com.devonfw.tools.ide.tool.npm.NpmRepository;
import com.devonfw.tools.ide.tool.pip.PipRepository;
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.variable.IdeVariables;
import com.devonfw.tools.ide.version.IdeVersion;
import com.devonfw.tools.ide.version.VersionIdentifier;

/**
 * Interface for the context of IDEasy and the potential current project. Central constants for names of files and folders are defined here and should be
 * referenced instead of duplicating such string literals across the code-base. All central components can be accessed from here such as:
 * <ul>
 * <li>{@link #getPath() system path} (abstraction of PATH environment variable)</li>
 * <li>{@link #getCommandletManager() commandlet manager} (access {@link com.devonfw.tools.ide.commandlet.Commandlet}s)</li>
 * <li>{@link #getFileAccess() file access} (file and I/O operations on a higher level of abstraction)</li>
 * <li>{@link #getNetworkStatus() network status} (determine if we are online or offline)</li>
 * <li>{@link #newProcess() process context} (start external programs as process including logging, error handling, background and output processing)</li>
 * <li>{@link #newStep(String) step} creation (a sub-task that may fail without stopping the overall process)</li>
 * <li>{@link #newProgressBar(String, long, String, long) progress bar} (to display long-running progress for UX)</li>
 * <li>{@link #getGitContext() git context} (for git operations like clone, fetch, pull, etc.)</li>
 * <li>{@link #getSystemInfo() system info} (for information about OS and CPU architecture)</li>
 * <li>{@link #getVariables() environment variables} (to access and modify IDEasy variables according to our configuration layout)</li>
 *
 * <li>{@link #question(Object[], String, Object...) question} (for interaction to let the end-user decide)</li>
 * <li>{@link #getUrls() url metadata} (access ide-urls to find versions, download URLs, dependency and security metadata)</li>
 * <li>{@link #getDefaultToolRepository() tool repository} (for abstraction of version resolution and download of tools)</li>
 * <li>{@link #getSystem() ide system} (abstraction of {@link java.lang.System} for system environment variables)</li>
 * </ul>
 */
public interface IdeContext extends IdeStartContext {

  /**
   * The default settings URL.
   *
   * @see com.devonfw.tools.ide.commandlet.AbstractUpdateCommandlet
   */
  String DEFAULT_SETTINGS_REPO_URL = "https://github.com/devonfw/ide-settings.git";

  /** The name of the workspaces folder. */
  String FOLDER_WORKSPACES = "workspaces";

  /** The name of the {@link #getSettingsPath() settings} folder. */
  String FOLDER_SETTINGS = "settings";

  /** The name of the {@link #getSoftwarePath() software} folder. */
  String FOLDER_SOFTWARE = "software";

  /** The name of the {@link #getUrlsPath() urls} folder. */
  String FOLDER_URLS = "urls";

  /** The name of the conf folder for project specific user configurations. */
  String FOLDER_CONF = "conf";

  /**
   * The name of the folder inside IDE_ROOT reserved for IDEasy. Intentionally starting with an underscore and not a dot to prevent effects like OS hiding,
   * maven filtering, .gitignore and to distinguish from {@link #FOLDER_DOT_IDE}.
   *
   * @see #getIdePath()
   */
  String FOLDER_UNDERSCORE_IDE = "_ide";

  /**
   * The name of the folder inside {@link #FOLDER_UNDERSCORE_IDE} with the current IDEasy installation.
   *
   * @see #getIdeInstallationPath()
   */
  String FOLDER_INSTALLATION = "installation";

  /**
   * The name of the hidden folder for IDE configuration in the users home directory or status information in the IDE_HOME directory.
   *
   * @see #getUserHomeIde()
   */
  String FOLDER_DOT_IDE = ".ide";

  /** The name of the updates folder for temporary data and backup. */
  String FOLDER_UPDATES = "updates";

  /** The name of the volume folder for mounting archives like *.dmg. */
  String FOLDER_VOLUME = "volume";

  /** The name of the backups folder for backup. */
  String FOLDER_BACKUPS = "backups";

  /** The name of the logs folder for log-files (in {@link #FOLDER_UNDERSCORE_IDE}). */
  String FOLDER_LOGS = "logs";

  /** The name of the downloads folder. */
  String FOLDER_DOWNLOADS = "Downloads";

  /** The name of the bin folder where executable files are found by default. */
  String FOLDER_BIN = "bin";

  /** The name of the repositories folder where properties files are stores for each repository */
  String FOLDER_REPOSITORIES = "repositories";

  /** The name of the repositories folder where properties files are stores for each repository */
  String FOLDER_LEGACY_REPOSITORIES = "projects";

  /** The name of the Contents folder inside a MacOS app. */
  String FOLDER_CONTENTS = "Contents";

  /** The name of the Resources folder inside a MacOS app. */
  String FOLDER_RESOURCES = "Resources";

  /** The name of the app folder inside a MacOS app. */
  String FOLDER_APP = "app";

  /** The name of the extra folder inside the software folder */
  String FOLDER_EXTRA = "extra";

  /**
   * The name of the {@link #getPluginsPath() plugins folder} and also the plugins folder inside the IDE folders of {@link #getSettingsPath() settings} (e.g.
   * settings/eclipse/plugins).
   */
  String FOLDER_PLUGINS = "plugins";

  /**
   * The name of the workspace folder inside the IDE specific {@link #FOLDER_SETTINGS settings} containing the configuration templates in #FOLDER_SETUP
   * #FOLDER_UPDATE.
   */
  String FOLDER_WORKSPACE = "workspace";

  /**
   * The name of the setup folder inside the {@link #FOLDER_WORKSPACE workspace} folder containing the templates for the configuration templates for the initial
   * setup of a workspace. This is closely related with the {@link #FOLDER_UPDATE update} folder.
   */
  String FOLDER_SETUP = "setup";

  /**
   * The name of the update folder inside the {@link #FOLDER_WORKSPACE workspace} folder containing the templates for the configuration templates for the update
   * of a workspace. Configurations in this folder will be applied every time the IDE is started. They will override the settings the user may have manually
   * configured every time. This is only for settings that have to be the same for every developer in the project. An example would be the number of spaces used
   * for indentation and other code-formatting settings. If all developers in a project team use the same formatter settings, this will actively prevent
   * diff-wars. However, the entire team needs to agree on these settings.<br> Never configure aspects inside this update folder that may be of personal flavor
   * such as the color theme. Otherwise developers will hate you as you actively take away their freedom to customize the IDE to their personal needs and
   * wishes. Therefore do all "biased" or "flavored" configurations in {@link #FOLDER_SETUP setup} so these are only pre-configured but can be changed by the
   * user as needed.
   */
  String FOLDER_UPDATE = "update";

  /**
   * The name of the folder inside {@link #FOLDER_UNDERSCORE_IDE _ide} folder containing internal resources and scripts of IDEasy.
   */
  String FOLDER_INTERNAL = "internal";

  /** The file where the installed software version is written to as plain text. */
  String FILE_SOFTWARE_VERSION = ".ide.software.version";

  /** The file where the installed software version is written to as plain text. */
  String FILE_LEGACY_SOFTWARE_VERSION = ".devon.software.version";

  /** The file for the license agreement. */
  String FILE_LICENSE_AGREEMENT = ".license.agreement";

  /** The file extension for a {@link java.util.Properties} file. */
  String EXT_PROPERTIES = ".properties";

  /** The default for {@link #getWorkspaceName()}. */
  String WORKSPACE_MAIN = "main";

  /** The folder with the configuration template files from the settings. */
  String FOLDER_TEMPLATES = "templates";

  /** Legacy folder name used as compatibility fallback if {@link #FOLDER_TEMPLATES} does not exist. */
  String FOLDER_LEGACY_TEMPLATES = "devon";

  /** The default folder name for {@link #getIdeRoot() IDE_ROOT}. */
  String FOLDER_PROJECTS = "projects";

  /**
   * file containing the current local commit hash of the settings repository.
   */
  String SETTINGS_COMMIT_ID = ".commit.id";

  /** The IDEasy ASCII logo. */
  String LOGO = """
      __       ___ ___  ___
      ╲ ╲     |_ _|   ╲| __|__ _ ____ _
       > >     | || |) | _|/ _` (_-< || |
      /_/ ___ |___|___/|___╲__,_/__/╲_, |
         |___|                       |__/
      """.replace('╲', '\\');

  /**
   * The keyword for project name convention.
   */
  String SETTINGS_REPOSITORY_KEYWORD = "settings";
  String IS_NOT_INSTALLED_BUT_REQUIRED = "is not installed on your computer but required by IDEasy.";
  String WINDOWS_GIT_DOWNLOAD_URL = "https://git-scm.com/download/";
  String PLEASE_DOWNLOAD_AND_INSTALL_GIT = "Please download and install git";

  /**
   * @return the {@link NetworkStatus} for online check and related operations.
   */
  NetworkStatus getNetworkStatus();

  /**
   * @return {@code true} if {@link #isOfflineMode() offline mode} is active or we are NOT {@link #isOnline() online}, {@code false} otherwise.
   * @deprecated use {@link #getNetworkStatus()}
   */
  default boolean isOffline() {

    return getNetworkStatus().isOffline();
  }

  /**
   * @return {@code true} if we are currently online (Internet access is available), {@code false} otherwise.
   * @deprecated use {@link #getNetworkStatus()}
   */
  default boolean isOnline() {

    return getNetworkStatus().isOnline();
  }

  /**
   * Print the IDEasy {@link #LOGO logo}.
   */
  default void printLogo() {

    AbstractIdeContext.LOG.info(LOGO);
  }

  /**
   * Asks the user for a single string input.
   *
   * @param message The information message to display.
   * @param defaultValue The default value to return when no input is provided or {@code null} to keep asking until the user entered a non empty value.
   * @return The string input from the user, or the default value if no input is provided.
   */
  String askForInput(String message, String defaultValue);

  /**
   * Asks the user for a single string input.
   *
   * @param message The information message to display.
   * @return The string input from the user.
   */
  default String askForInput(String message) {
    return askForInput(message, null);
  }

  /**
   * Asks the user for a secret value (e.g. a password or API token). Unlike {@link #askForInput(String)} the input will not be echoed to the console while
   * typing (if supported by the underlying terminal).
   *
   * @param message The information message to display.
   * @return The secret input from the user.
   */
  String askForSecret(String message);

  /**
   * @param question the question to ask.
   * @param args arguments for filling the templates
   * @return {@code true} if the user answered with "yes", {@code false} otherwise ("no").
   */
  default boolean question(String question, Object... args) {

    String yes = "yes";
    String option = question(new String[] { yes, "no" }, question, args);
    if (yes.equals(option)) {
      return true;
    }
    return false;
  }

  /**
   * @param <O> type of the option. E.g. {@link String}.
   * @param options the available options for the user to answer. There should be at least two options given as otherwise the question cannot make sense.
   * @param question the question to ask.
   * @return the option selected by the user as answer.
   */
  @SuppressWarnings("unchecked")
  <O> O question(O[] options, String question, Object... args);

  /**
   * Will ask the given question. If the user answers with "yes" the method will return and the process can continue. Otherwise if the user answers with "no" an
   * exception is thrown to abort further processing.
   *
   * @param questionTemplate the yes/no question to {@link #question(String, Object...) ask}.
   * @param args the arguments to fill the placeholders in the question template.
   * @throws CliAbortException if the user answered with "no" and further processing shall be aborted.
   */
  default void askToContinue(String questionTemplate, Object... args) {
    boolean yesContinue = question(questionTemplate, args);
    if (!yesContinue) {
      throw new CliAbortException();
    }
  }

  /**
   * @param purpose the purpose why Internet connection is required.
   * @param explicitOnlineCheck if {@code true}, perform an explicit {@link #isOffline()} check; if {@code false} use {@link #isOfflineMode()}.
   * @throws CliException if you are {@link #isOffline() offline}.
   */
  default void requireOnline(String purpose, boolean explicitOnlineCheck) {

    if (explicitOnlineCheck) {
      if (isOffline()) {
        throw CliOfflineException.ofPurpose(purpose);
      }
    } else {
      if (isOfflineMode()) {
        throw CliOfflineException.ofPurpose(purpose);
      }
    }
  }

  /**
   * @return the {@link SystemInfo}.
   */
  SystemInfo getSystemInfo();

  /**
   * @return the {@link EnvironmentVariables} with full inheritance.
   */
  EnvironmentVariables getVariables();

  /**
   * @return the {@link FileAccess}.
   */
  FileAccess getFileAccess();

  /**
   * @return the {@link CommandletManager}.
   */
  CommandletManager getCommandletManager();

  /**
   * @return the default {@link ToolRepository}.
   */
  ToolRepository getDefaultToolRepository();

  /**
   * @return the {@link CustomToolRepository}.
   */
  CustomToolRepository getCustomToolRepository();

  /**
   * @return the {@link MvnRepository}.
   */
  MvnRepository getMvnRepository();

  /**
   * @return the {@link NpmRepository}.
   */
  NpmRepository getNpmRepository();

  /**
   * @return the {@link PipRepository}.
   */
  PipRepository getPipRepository();

  /**
   * @return the {@link UvRepository}.
   */
  UvRepository getUvRepository();

  /**
   * @return the {@link Path} to the IDE instance directory. You can have as many IDE instances on the same computer as independent tenants for different
   *     isolated projects.
   * @see com.devonfw.tools.ide.variable.IdeVariables#IDE_HOME
   */
  Path getIdeHome();

  /**
   * @return the name of the current project.
   * @see com.devonfw.tools.ide.variable.IdeVariables#PROJECT_NAME
   */
  String getProjectName();

  /**
   * @return the IDEasy version the {@link #getIdeHome() current project} was created with or migrated to.
   */
  VersionIdentifier getProjectVersion();

  /**
   * @param version the new value of {@link #getProjectVersion()}.
   */
  void setProjectVersion(VersionIdentifier version);

  /**
   * @return the {@link Path} to the IDE installation root directory. This is the top-level folder where the {@link #getIdeHome() IDE instances} are located as
   *     sub-folder. There is a reserved ".ide" folder where central IDE data is stored such as the {@link #getUrlsPath() download metadata} and the central
   *     software repository.
   * @see com.devonfw.tools.ide.variable.IdeVariables#IDE_ROOT
   */
  Path getIdeRoot();

  /**
   * @param ideRoot the new value of {@link #getIdeRoot() IDE_ROOT}. Typically detected automatically from the environment and working directory, but may need
   *     to be set explicitly (e.g. during the initial installation where the {@code IDE_ROOT} environment variable is not yet available but the installation
   *     target is already known).
   */
  void setIdeRoot(Path ideRoot);

  /**
   * @return the {@link Path} to the {@link #FOLDER_UNDERSCORE_IDE}.
   * @see #getIdeRoot()
   * @see #FOLDER_UNDERSCORE_IDE
   */
  Path getIdePath();

  /**
   * @return the {@link Path} to the {@link #FOLDER_INSTALLATION installation} folder of IDEasy. This is a link to the (latest) installed release of IDEasy. On
   *     upgrade a new release is installed and the link is switched to the new release.
   */
  default Path getIdeInstallationPath() {

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

  /**
   * @return the current working directory ("user.dir"). This is the directory where the user's shell was located when the IDE CLI was invoked.
   */
  Path getCwd();

  /**
   * @return the {@link Path} for the temporary directory to use. Will be different from the OS specific temporary directory (java.io.tmpDir).
   */
  Path getTempPath();

  /**
   * @return the {@link Path} for the temporary download directory to use.
   */
  Path getTempDownloadPath();

  /**
   * @return the {@link Path} to the download metadata (ide-urls). Here a git repository is cloned and updated (pulled) to always have the latest metadata to
   *     download tools.
   * @see com.devonfw.tools.ide.url.model.folder.UrlRepository
   */
  Path getUrlsPath();

  /**
   * @return the {@link UrlMetadata}. Will be lazily instantiated and thereby automatically be cloned or pulled (by default).
   */
  UrlMetadata getUrls();

  /**
   * @return the {@link Path} to the download cache. All downloads will be placed here using a unique naming pattern that allows to reuse these artifacts. So if
   *     the same artifact is requested again it will be taken from the cache to avoid downloading it again.
   */
  Path getDownloadPath();

  /**
   * @return the {@link Path} to the software folder inside {@link #getIdeHome() IDE_HOME}. All tools for that IDE instance will be linked here from the
   *     {@link #getSoftwareRepositoryPath() software repository} as sub-folder named after the according tool.
   */
  Path getSoftwarePath();

  /**
   * @return the {@link Path} to the extra folder inside software folder inside {@link #getIdeHome() IDE_HOME}. All tools for that IDE instance will be linked
   *     here from the {@link #getSoftwareRepositoryPath() software repository} as sub-folder named after the according tool.
   */
  Path getSoftwareExtraPath();

  /**
   * @return the {@link Path} to the global software repository. This is the central directory where the tools are extracted physically on the local disc. Those
   *     are shared among all IDE instances (see {@link #getIdeHome() IDE_HOME}) via symbolic links (see {@link #getSoftwarePath()}). Therefore this repository
   *     follows the sub-folder structure {@code «repository»/«tool»/«edition»/«version»/}. So multiple versions of the same tool exist here as different
   *     folders. Further, such software may not be modified so e.g. installation of plugins and other kind of changes to such tool need to happen strictly out
   *     of the scope of this folders.
   */
  Path getSoftwareRepositoryPath();

  /**
   * @return the {@link Path} to the {@link #FOLDER_PLUGINS plugins folder} inside {@link #getIdeHome() IDE_HOME}. All plugins of the IDE instance will be
   *     stored here. For each tool that supports plugins a sub-folder with the tool name will be created where the plugins for that tool get installed.
   */
  Path getPluginsPath();

  /**
   * @return the {@link Path} to the central tool repository. All tools will be installed in this location using the directory naming schema of
   *     {@code «repository»/«tool»/«edition»/«version»/}. Actual {@link #getIdeHome() IDE instances} will only contain symbolic links to the physical tool
   *     installations in this repository. This allows to share and reuse tool installations across multiple {@link #getIdeHome() IDE instances}. The variable
   *     {@code «repository»} is typically {@code default} for the tools from our standard {@link #getUrlsPath() ide-urls download metadata} but this will
   *     differ for custom tools from a private repository.
   */
  Path getToolRepositoryPath();

  /**
   * @return the {@link Path} to the users home directory. Typically initialized via the {@link System#getProperty(String) system property} "user.home".
   * @see com.devonfw.tools.ide.variable.IdeVariables#HOME
   */
  Path getUserHome();

  /**
   * @return the {@link Path} to the ".ide" subfolder in the {@link #getUserHome() users home directory}.
   */
  Path getUserHomeIde();

  /**
   * @return the {@link Path} to the {@link #FOLDER_SETTINGS settings} folder with the cloned git repository containing the project configuration.
   */
  Path getSettingsPath();

  /**
   * @return the {@link Path} to the {@link #FOLDER_REPOSITORIES repositories} folder with legacy fallback if not present or {@code null} if not found.
   */
  default Path getRepositoriesPath() {

    Path settingsPath = getSettingsPath();
    if (settingsPath == null) {
      return null;
    }
    Path repositoriesPath = settingsPath.resolve(IdeContext.FOLDER_REPOSITORIES);
    if (Files.isDirectory(repositoriesPath)) {
      return repositoriesPath;
    }
    Path legacyRepositoriesPath = settingsPath.resolve(IdeContext.FOLDER_LEGACY_REPOSITORIES);
    if (Files.isDirectory(legacyRepositoriesPath)) {
      return legacyRepositoriesPath;
    }
    return null;
  }

  /**
   * @return the {@link Path} to the {@code settings} folder with the cloned git repository containing the project configuration only if the settings repository
   *     is in fact a git repository.
   */
  Path getSettingsGitRepository();

  /**
   * @return {@code true} if the settings repository is a symlink or a junction to a code-repository.
   */
  boolean isSettingsCodeRepository();

  /**
   * @return the {@link Path} to the file containing the last tracked commit Id of the settings repository.
   */
  Path getSettingsCommitIdPath();

  /**
   * @return the {@link Path} to the templates folder inside the {@link #getSettingsPath() settings}. The relative directory structure in this templates folder
   *     is to be applied to {@link #getIdeHome() IDE_HOME} when the project is set up.
   */
  default Path getSettingsTemplatePath() {
    Path settingsFolder = getSettingsPath();
    Path templatesFolder = settingsFolder.resolve(IdeContext.FOLDER_TEMPLATES);
    if (!Files.isDirectory(templatesFolder)) {
      Path templatesFolderLegacy = settingsFolder.resolve(IdeContext.FOLDER_LEGACY_TEMPLATES);
      if (Files.isDirectory(templatesFolderLegacy)) {
        templatesFolder = templatesFolderLegacy;
      } else {
        AbstractIdeContext.LOG.warn("No templates found in settings git repo neither in {} nor in {} - configuration broken", templatesFolder,
            templatesFolderLegacy);
        return null;
      }
    }
    return templatesFolder;
  }

  /**
   * @return the {@link Path} to the {@code conf} folder with instance specific tool configurations and the
   *     {@link EnvironmentVariablesType#CONF user specific project configuration}.
   */
  Path getConfPath();

  /**
   * @return the {@link Path} to the workspaces base folder containing the individual {@link #getWorkspacePath(String) workspaces}.
   * @see #getWorkspacePath(String)
   */
  Path getWorkspacesBasePath();

  /**
   * @return the {@link Path} to the workspace.
   * @see #getWorkspaceName()
   */
  Path getWorkspacePath();

  /**
   * @param workspace the specific workspace name.
   * @return the {@link Path} to the specified workspace.
   */
  Path getWorkspacePath(String workspace);

  /**
   * @return the name of the workspace. Defaults to {@link #WORKSPACE_MAIN}.
   */
  String getWorkspaceName();

  /**
   * @return the value of the system {@link IdeVariables#PATH PATH} variable. It is automatically extended according to the tools available in
   *     {@link #getSoftwarePath() software path} unless {@link #getIdeHome() IDE_HOME} was not found.
   */
  SystemPath getPath();

  /**
   * @return a new {@link ProcessContext} to {@link ProcessContext#run() run} external commands.
   */
  ProcessContext newProcess();

  /**
   * @param title the {@link IdeProgressBar#getTitle() title}.
   * @param size the {@link IdeProgressBar#getMaxSize() expected maximum size}.
   * @param unitName the {@link IdeProgressBar#getUnitName() unit name}.
   * @param unitSize the {@link IdeProgressBar#getUnitSize() unit size}.
   * @return the new {@link IdeProgressBar} to use.
   */
  IdeProgressBar newProgressBar(String title, long size, String unitName, long unitSize);

  /**
   * @param title the {@link IdeProgressBar#getTitle() title}.
   * @param size the {@link IdeProgressBar#getMaxSize() expected maximum size} in bytes.
   * @return the new {@link IdeProgressBar} to use.
   */
  default IdeProgressBar newProgressBarInMib(String title, long size) {

    if ((size > 0) && (size < 1024)) {
      return new IdeProgressBarNone(title, size, IdeProgressBar.UNIT_NAME_MB, IdeProgressBar.UNIT_SIZE_MB);
    }
    return newProgressBar(title, size, IdeProgressBar.UNIT_NAME_MB, IdeProgressBar.UNIT_SIZE_MB);
  }

  /**
   * @param size the {@link IdeProgressBar#getMaxSize() expected maximum size} in bytes.
   * @return the new {@link IdeProgressBar} for copy.
   */
  default IdeProgressBar newProgressBarForDownload(long size) {

    return newProgressBarInMib(IdeProgressBar.TITLE_DOWNLOADING, size);
  }

  /**
   * @param size the {@link IdeProgressBar#getMaxSize() expected maximum size} in bytes.
   * @return the new {@link IdeProgressBar} for extracting.
   */
  default IdeProgressBar newProgressbarForExtracting(long size) {

    return newProgressBarInMib(IdeProgressBar.TITLE_EXTRACTING, size);
  }

  /**
   * @param size the {@link IdeProgressBar#getMaxSize() expected maximum size} in bytes.
   * @return the new {@link IdeProgressBar} for copy.
   */
  default IdeProgressBar newProgressbarForCopying(long size) {

    return newProgressBarInMib(IdeProgressBar.TITLE_COPYING, size);
  }

  /**
   * @param size the {@link IdeProgressBar#getMaxSize() expected maximum} plugin count.
   * @return the new {@link IdeProgressBar} to use.
   */
  default IdeProgressBar newProgressBarForPlugins(long size) {
    return newProgressBar(IdeProgressBar.TITLE_INSTALL_PLUGIN, size, IdeProgressBar.UNIT_NAME_PLUGIN, IdeProgressBar.UNIT_SIZE_PLUGIN);
  }

  /**
   * @return the {@link DirectoryMerger} used to configure and merge the workspace for an {@link com.devonfw.tools.ide.tool.ide.IdeToolCommandlet IDE}.
   */
  DirectoryMerger getWorkspaceMerger();

  /**
   * @return the {@link Path} to the working directory from where the command is executed.
   */
  Path getDefaultExecutionDirectory();

  /**
   * @return the {@link IdeSystem} instance wrapping {@link System}.
   */
  IdeSystem getSystem();

  /**
   * @return the {@link GitContext} used to run several git commands.
   */
  GitContext getGitContext();

  /**
   * @return the String value for the variable MAVEN_ARGS, or null if called outside an IDEasy installation.
   */
  default String getMavenArgs() {

    if (getIdeHome() == null) {
      return null;
    }
    Mvn mvn = getCommandletManager().getCommandlet(Mvn.class);
    return mvn.getMavenArgs();
  }

  /**
   * @return the path for the variable GRADLE_USER_HOME, or null if called outside an IDEasy installation.
   */
  default Path getGradleUserHome() {

    if (getIdeHome() == null) {
      return null;
    }
    Gradle gradle = getCommandletManager().getCommandlet(Gradle.class);
    return gradle.getOrCreateGradleConfFolder();
  }

  /**
   * @return the {@link Path} pointing to the maven configuration directory (where "settings.xml" or "settings-security.xml" are located).
   */
  default Path getMavenConfigurationFolder() {

    if (getIdeHome() == null) {
      // fallback to USER_HOME/.m2 folder if called outside an IDEasy project
      return getUserHome().resolve(Mvn.MVN_CONFIG_LEGACY_FOLDER);
    }
    Mvn mvn = getCommandletManager().getCommandlet(Mvn.class);
    return mvn.getMavenConfigurationFolder();
  }

  /**
   * Updates the current working directory (CWD) and configures the environment paths according to the specified parameters. This method is central to changing
   * the IDE's notion of where it operates, affecting where configurations, workspaces, settings, and other resources are located or loaded from.
   *
   * @return the current {@link Step} of processing.
   */
  Step getCurrentStep();

  /**
   * @param name the {@link Step#getName() name} of the new {@link Step}.
   * @return the new {@link Step} that has been created and started.
   */
  default Step newStep(String name) {

    return newStep(name, Step.NO_PARAMS);
  }

  /**
   * @param name the {@link Step#getName() name} of the new {@link Step}.
   * @param parameters the {@link Step#getParameter(int) parameters} of the {@link Step}.
   * @return the new {@link Step} that has been created and started.
   */
  default Step newStep(String name, Object... parameters) {

    return newStep(false, name, parameters);
  }

  /**
   * @param silent the {@link Step#isSilent() silent flag}.
   * @param name the {@link Step#getName() name} of the new {@link Step}.
   * @param parameters the {@link Step#getParameter(int) parameters} of the {@link Step}.
   * @return the new {@link Step} that has been created and started.
   */
  Step newStep(boolean silent, String name, Object... parameters);

  /**
   * @param lambda the {@link Runnable} to {@link Runnable#run() run} while the {@link com.devonfw.tools.ide.log.IdeLogger logging} is entirely disabled.
   *     After this the logging will be enabled again. Collected log messages will then be logged at the end.
   */
  default void runWithoutLogging(Runnable lambda) {

    runWithoutLogging(lambda, IdeLogLevel.TRACE);
  }

  /**
   * @param lambda the {@link Runnable} to {@link Runnable#run() run} while the {@link com.devonfw.tools.ide.log.IdeLogger logging} is entirely disabled.
   *     After this the logging will be enabled again. Collected log messages will then be logged at the end.
   * @param threshold the {@link IdeLogLevel} to use as threshold for filtering logs while logging is disabled and log messages are collected. Use
   *     {@link IdeLogLevel#TRACE} to collect all logs and ensure nothing gets lost (will still not log anything that is generally not active in regular
   *     logging) and e.g. use {@link IdeLogLevel#ERROR} to discard all logs except errors.
   */
  void runWithoutLogging(Runnable lambda, IdeLogLevel threshold);

  /**
   * Updates the current working directory (CWD) and configures the environment paths according to the specified parameters. This method is central to changing
   * the IDE's notion of where it operates, affecting where configurations, workspaces, settings, and other resources are located or loaded from.
   *
   * @param ideHome The path to the IDE home directory.
   */
  default void setIdeHome(Path ideHome) {

    setCwd(ideHome, WORKSPACE_MAIN, ideHome);
  }

  /**
   * Updates the current working directory (CWD) and configures the environment paths according to the specified parameters. This method is central to changing
   * the IDE's notion of where it operates, affecting where configurations, workspaces, settings, and other resources are located or loaded from.
   *
   * @param userDir The path to set as the current working directory.
   * @param workspace The name of the workspace within the IDE's environment.
   * @param ideHome The path to the IDE home directory.
   */
  void setCwd(Path userDir, String workspace, Path ideHome);

  /**
   * Finds the path to the Bash executable.
   *
   * @return the {@link Path} to the Bash executable, or {@code null} if Bash is not found.
   */
  Path findBash();

  /**
   * Finds the path to the Bash executable.
   *
   * @return the {@link Path} to the Bash executable. Throws a {@link CliException} if no bash was found.
   */
  default Path findBashRequired() {
    Path bash = findBash();
    if (bash == null) {
      String message = "Bash " + IS_NOT_INSTALLED_BUT_REQUIRED;
      if (getSystemInfo().isWindows()) {
        message += " " + PLEASE_DOWNLOAD_AND_INSTALL_GIT + ":\n " + WINDOWS_GIT_DOWNLOAD_URL;
        throw new CliException(message);
      }
      bash = Path.of("bash");
    }

    return bash;
  }

  /**
   * @return the {@link WindowsPathSyntax} used for {@link Path} conversion or {@code null} for no such conversion (typically if not on Windows).
   */
  WindowsPathSyntax getPathSyntax();

  /**
   * logs the status of {@link #getIdeHome() IDE_HOME} and {@link #getIdeRoot() IDE_ROOT}.
   */
  void logIdeHomeAndRootStatus();

  /**
   * @param version the {@link VersionIdentifier} to write.
   * @param installationPath the {@link Path directory} where to write the version to a {@link #FILE_SOFTWARE_VERSION version file}.
   */
  void writeVersionFile(VersionIdentifier version, Path installationPath);

  /**
   * Verifies that current {@link IdeVersion} satisfies {@link IdeVariables#IDE_MIN_VERSION}.
   *
   * @param throwException whether to throw a {@link CliException} or just log a warning.
   */
  void verifyIdeMinVersion(boolean throwException);

  /**
   * @return the path for the variable COREPACK_HOME, or null if called outside an IDEasy installation.
   */
  default Path getCorePackHome() {
    if (getIdeHome() == null) {
      return null;
    }
    Corepack corepack = getCommandletManager().getCommandlet(Corepack.class);
    return corepack.getOrCreateCorepackHomeFolder();
  }

  /**
   * @return the path for the variable NPM_CONFIG_USERCONFIG, or null if called outside an IDEasy installation.
   */
  default Path getNpmConfigUserConfig() {
    if (getIdeHome() == null) {
      return null;
    }
    Npm npm = getCommandletManager().getCommandlet(Npm.class);
    return npm.getOrCreateNpmConfigUserConfig();
  }

}

devonfw / IDEasy / 29803149984

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