#989: allow expressions in template variable definitions

CHANGELOG.adoc

@@ -6,6 +6,7 @@ This file documents all notable changes to https://github.com/devonfw/IDEasy[IDE
 
 Release with new features and bugfixes:
 
+* https://github.com/devonfw/IDEasy/issues/989[#989]: Allow expressions in template variable definitions
 
 The full list of changes for this release can be found in https://github.com/devonfw/IDEasy/milestone/49?closed=1[milestone 2026.08.002].
 

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

@@ -1104,6 +1104,31 @@ public String askForInput(String message, String defaultValue) {
     }
   }
 
+  @Override
+  public String askForSecret(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 = readSecretLine().trim();
+      if (!input.isEmpty()) {
+        return input;
+      } else {
+        if (defaultValue != null) {
+          return defaultValue;
+        }
+      }
+    }
+  }
+
   @Override
   public <O> O question(O[] options, String question, Object... args) {
 
@@ -1171,6 +1196,15 @@ private static String computeOptionKey(String option) {
    */
   protected abstract String readLine();
 
+  /**
+   * @return the secret input from the end-user (e.g. read from the console without echoing it). The default implementation simply delegates to
+   *     {@link #readLine()} so that sub-classes without a secure console (e.g. in tests) work out of the box.
+   */
+  protected String readSecretLine() {
+
+    return readLine();
+  }
+
   private static <O> void addMapping(Map<String, O> mapping, String key, O option) {
 
     O duplicate = mapping.put(key, option);

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

@@ -277,6 +277,26 @@ default String askForInput(String message) {
     return askForInput(message, null);
   }
 
+  /**
+   * Asks the user for a single secret input (e.g. a password or API token). Unlike {@link #askForInput(String, String)} the input is not echoed to the console
+   * if a secure console is available.
+   *
+   * @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 secret input from the user, or the default value if no input is provided.
+   */
+  String askForSecret(String message, String defaultValue);
+
+  /**
+   * Asks the user for a single secret input (e.g. a password or API token).
+   *
+   * @param message The information message to display.
+   * @return The secret input from the user.
+   */
+  default String askForSecret(String message) {
+    return askForSecret(message, null);
+  }
+
   /**
    * @param question the question to ask.
    * @param args arguments for filling the templates

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

@@ -52,6 +52,21 @@ protected String readLine() {
     }
   }
 
+  @Override
+  protected String readSecretLine() {
+
+    if (this.scanner == null) {
+      char[] password = System.console().readPassword();
+      if (password == null) {
+        return "";
+      }
+      return new String(password);
+    } else {
+      LOG.warn("System console not available - secret input will be visible while typing.");
+      return this.scanner.nextLine();
+    }
+  }
+
   @Override
   public IdeProgressBar newProgressBar(String title, long size, String unitName, long unitSize) {
 

cli/src/main/java/com/devonfw/tools/ide/environment/AbstractEnvironmentVariables.java

@@ -12,6 +12,9 @@
 import org.slf4j.event.Level;
 
 import com.devonfw.tools.ide.context.IdeContext;
+import com.devonfw.tools.ide.expression.ExpressionContext;
+import com.devonfw.tools.ide.expression.ExpressionFunctionManager;
+import com.devonfw.tools.ide.expression.ExpressionParser;
 import com.devonfw.tools.ide.variable.IdeVariables;
 import com.devonfw.tools.ide.variable.VariableDefinition;
 import com.devonfw.tools.ide.variable.VariableSyntax;
@@ -34,6 +37,8 @@ public abstract class AbstractEnvironmentVariables implements EnvironmentVariabl
 
   private static final int MAX_RECURSION = 9;
 
+  private static final ExpressionParser EXPRESSION_PARSER = new ExpressionParser(ExpressionFunctionManager.get());
+
   /**
    * @see #getParent()
    */
@@ -206,14 +211,16 @@ private String resolveRecursive(String value, Object source, int recursion, Abst
     }
     recursion++;
 
+    String value2 = EXPRESSION_PARSER.resolve(value, new EnvironmentExpressionContext(source, recursion, resolvedVars, context));
+
     String resolved;
     if (context.syntax == null) {
-      resolved = resolveWithSyntax(value, source, recursion, resolvedVars, context, VariableSyntax.SQUARE);
+      resolved = resolveWithSyntax(value2, source, recursion, resolvedVars, context, VariableSyntax.SQUARE);
       if (context.legacySupport) {
         resolved = resolveWithSyntax(resolved, source, recursion, resolvedVars, context, VariableSyntax.CURLY);
       }
     } else {
-      resolved = resolveWithSyntax(value, source, recursion, resolvedVars, context, context.syntax);
+      resolved = resolveWithSyntax(value2, source, recursion, resolvedVars, context, context.syntax);
     }
     return resolved;
   }
@@ -357,6 +364,65 @@ public String toString() {
     return getSource().toString();
   }
 
+  /**
+   * Implementation of {@link ExpressionContext} that connects an {@link com.devonfw.tools.ide.expression.ExpressionFunction} with this
+   * {@link EnvironmentVariables} hierarchy.
+   */
+  private final class EnvironmentExpressionContext implements ExpressionContext {
+
+    private final Object src;
+
+    private final int recursion;
+
+    private final AbstractEnvironmentVariables resolvedVars;
+
+    private final ResolveContext context;
+
+    private EnvironmentExpressionContext(Object src, int recursion, AbstractEnvironmentVariables resolvedVars, ResolveContext context) {
+
+      super();
+      this.src = src;
+      this.recursion = recursion;
+      this.resolvedVars = resolvedVars;
+      this.context = context;
+    }
+
+    @Override
+    public IdeContext getIdeContext() {
+
+      return AbstractEnvironmentVariables.this.context;
+    }
+
+    @Override
+    public String resolve(String value) {
+
+      return this.resolvedVars.resolveRecursive(value, this.src, this.recursion, this.resolvedVars, this.context);
+    }
+
+    @Override
+    public String getVariable(String name) {
+
+      return this.resolvedVars.getValue(name, false);
+    }
+
+    @Override
+    public void setVariable(String name, String value) {
+
+      EnvironmentVariables conf = getByType(EnvironmentVariablesType.CONF);
+      if (conf instanceof EnvironmentVariablesPropertiesFile propertiesFile) {
+        propertiesFile.set(name, value);
+        propertiesFile.save();
+      } else {
+        LOG.warn("Cannot persist variable {} since no configuration file is available.", name);
+      }
+    }
+
+    @Override
+    public boolean isPersistent() {
+      return true;
+    }
+  }
+
   /**
    * Simple record for the immutable arguments of recursive resolve methods.
    *

cli/src/main/java/com/devonfw/tools/ide/expression/ExpressionContext.java

@@ -0,0 +1,47 @@
+package com.devonfw.tools.ide.expression;
+
+import com.devonfw.tools.ide.context.IdeContext;
+
+/**
+ * Interface for the context available to an {@link ExpressionFunction} while an expression is evaluated.
+ */
+public interface ExpressionContext {
+
+  /**
+   * @return the {@link IdeContext}.
+   */
+  IdeContext getIdeContext();
+
+  /**
+   * Resolves variables in the given value. Used to resolve arguments of a function that may themselves contain
+   * variables or nested expressions (e.g. {@code @path('$[IDE_HOME]/software/node')}).
+   *
+   * @param value the value to resolve.
+   * @return the given value with variables and nested expressions resolved.
+   */
+  String resolve(String value);
+
+  /**
+   * @param name the name of the variable.
+   * @return the value of the variable or {@code null} if not defined in any level of the hierarchy.
+   */
+  String getVariable(String name);
+
+  /**
+   * Persists the given variable to the user local {@code conf/ide.properties} so the user is not asked again.
+   * <p>
+   * Only has an effect if {@link #isPersistent()} returns {@code true}.
+   *
+   * @param name the name of the variable.
+   * @param value the value to persist.
+   */
+  void setVariable(String name, String value);
+
+  /**
+   * @return {@code true} if values acquired from the user should be {@link #setVariable(String, String) persisted}.
+   *     This is the case for workspace templates that are re-applied on every {@code ide update}. For settings
+   *     templates that are only instantiated once, this is {@code false}.
+   */
+  boolean isPersistent();
+
+}

cli/src/main/java/com/devonfw/tools/ide/expression/ExpressionFunction.java

@@ -0,0 +1,39 @@
+package com.devonfw.tools.ide.expression;
+
+import java.util.List;
+
+/**
+ * Interface for a function that can be used in an expression of a template variable definition.
+ * <p>
+ * The syntax of an expression is {@code @«function-name»([«arg»[,«arg»]*])}. Implementations are registered in the
+ * {@link ExpressionFunctionManager}.
+ *
+ * @see ExpressionFunctionManager
+ */
+public interface ExpressionFunction {
+
+  /**
+   * @return the name of this function as used in the expression syntax (e.g. "path" for {@code @path(...)}). Has to match
+   *     {@code [a-z][a-z0-9-]*}.
+   */
+  String getName();
+
+  /**
+   * @return the minimum number of arguments required by this function.
+   */
+  int getMinArgs();
+
+  /**
+   * @return the maximum number of arguments supported by this function or {@code -1} for an unlimited number.
+   */
+  int getMaxArgs();
+
+  /**
+   * @param args the {@link List} of arguments. Already trimmed, unquoted and with variables resolved. Guaranteed to
+   *     satisfy {@link #getMinArgs()} and {@link #getMaxArgs()}.
+   * @param context the {@link ExpressionContext}.
+   * @return the result of this function that will replace the entire expression.
+   */
+  String apply(List<String> args, ExpressionContext context);
+
+}

cli/src/main/java/com/devonfw/tools/ide/expression/ExpressionFunctionManager.java

@@ -0,0 +1,72 @@
+package com.devonfw.tools.ide.expression;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.devonfw.tools.ide.expression.function.AskFunction;
+import com.devonfw.tools.ide.expression.function.IfOsFunction;
+import com.devonfw.tools.ide.expression.function.PathFunction;
+
+/**
+ * Manager where all {@link ExpressionFunction}s are registered so they can be looked up by
+ * {@link #getFunction(String) name} while an expression is resolved.
+ * <p>
+ * With new IDEasy releases additional functions can simply be registered here.
+ */
+public class ExpressionFunctionManager {
+
+  private static final ExpressionFunctionManager DEFAULT = createDefault();
+
+  private final Map<String, ExpressionFunction> functions;
+
+  /**
+   * The constructor.
+   */
+  public ExpressionFunctionManager() {
+
+    super();
+    this.functions = new HashMap<>();
+  }
+
+  /**
+   * @param function the {@link ExpressionFunction} to register.
+   */
+  public void register(ExpressionFunction function) {
+
+    ExpressionFunction duplicate = this.functions.put(function.getName(), function);
+    if (duplicate != null) {
+      throw new IllegalStateException("Duplicate expression function @" + function.getName());
+    }
+  }
+
+  /**
+   * @param name the {@link ExpressionFunction#getName() name} of the requested function.
+   * @return the {@link ExpressionFunction} or {@code null} if no function is registered for the given name. A
+   *     {@code null} result is not an error: the expression is then left untouched.
+   */
+  public ExpressionFunction getFunction(String name) {
+
+    return this.functions.get(name);
+  }
+
+  /**
+   * @return the default instance with all standard functions registered.
+   */
+  public static ExpressionFunctionManager get() {
+
+    return DEFAULT;
+  }
+
+  private static ExpressionFunctionManager createDefault() {
+
+    ExpressionFunctionManager manager = new ExpressionFunctionManager();
+    manager.register(new PathFunction());
+    manager.register(AskFunction.ofVariable());
+    manager.register(AskFunction.ofSecret());
+    for (IfOsFunction function : IfOsFunction.all()) {
+      manager.register(function);
+    }
+    return manager;
+  }
+
+}