[conf] Add limited shell-style variable expansion

Ported from the DNF 5 implementation here:
rpm-software-management/dnf5#800.

Adds support for ${variable:-word} and ${variable:+word}
POSIX-shell-like expansions of vars.

${variable:-word} means if `variable` is unset or empty, the expansion
of `word` is substituted. Otherwise, the value of `variable` is
substituted.

${variable:+word} means if `variable` is unset or empty, nothing is
substituted. Otherwise, the expansion of `word` is substituted.

Zypper supports these expansions, see here:
https://doc.opensuse.org/projects/libzypp/HEAD/structzypp_1_1repo_1_1RepoVarExpand.html

For: https://bugzilla.redhat.com/show_bug.cgi?id=1789346

libdnf/conf/ConfigParser.cpp

@@ -29,40 +29,177 @@ namespace libdnf {
 void ConfigParser::substitute(std::string & text,
  const std::map<std::string, std::string> & substitutions)
 {
- auto start = text.find_first_of("$");
- while (start != text.npos)
- {
- auto variable = start + 1;
- if (variable >= text.length())
- break;
- bool bracket;
- if (text[variable] == '{') {
- bracket = true;
- if (++variable >= text.length())
+ text = ConfigParser::substitute_expression(text, substitutions, 0).first;
+}
+
+const unsigned int MAXIMUM_EXPRESSION_DEPTH = 32;
+
+std::pair<std::string, size_t> ConfigParser::substitute_expression(const std::string & text,
+ const std::map<std::string, std::string> & substitutions,
+ unsigned int depth) {
+ if (depth > MAXIMUM_EXPRESSION_DEPTH) {
+ return std::make_pair(std::string(text), text.length());
+ }
+ std::string res{text};
+
+ // The total number of characters read in the replacee
+ size_t total_scanned = 0;
+
+ size_t pos = 0;
+ while (pos < res.length()) {
+ if (res[pos] == '}' && depth > 0) {
+ return std::make_pair(res.substr(0, pos), total_scanned);
+ }
+
+ if (res[pos] == '\\') {
+ // Escape the next character (if there is one)
+ if (pos + 1 >= res.length()) {
  break;
- } else
- bracket = false;
- auto it = std::find_if_not(text.begin()+variable, text.end(),
- [](char c){return std::isalnum(c) || c=='_';});
- if (bracket && it == text.end())
- break;
- auto pastVariable = std::distance(text.begin(), it);
- if (bracket && *it != '}') {
- start = text.find_first_of("$", pastVariable);
+ }
+ res.erase(pos, 1);
+ total_scanned += 2;
+ pos += 1;
  continue;
  }
- auto subst = substitutions.find(text.substr(variable, pastVariable - variable));
- if (subst != substitutions.end()) {
- if (bracket)
- ++pastVariable;
- text.replace(start, pastVariable - start, subst->second);
- start = text.find_first_of("$", start + subst->second.length());
+ if (res[pos] == '$') {
+ // variable expression starts after the $ and includes the braces
+ // ${variable:-word}
+ // ^-- pos_variable_expression
+ size_t pos_variable_expression = pos + 1;
+ if (pos_variable_expression >= res.length()) {
+ break;
+ }
+
+ // Does the variable expression use braces? If so, the variable name
+ // starts one character after the start of the variable_expression
+ bool has_braces;
+ size_t pos_variable;
+ if (res[pos_variable_expression] == '{') {
+ has_braces = true;
+ pos_variable = pos_variable_expression + 1;
+ if (pos_variable >= res.length()) {
+ break;
+ }
+ } else {
+ has_braces = false;
+ pos_variable = pos_variable_expression;
+ }
+
+ // Find the end of the variable name
+ auto it = std::find_if_not(res.begin() + static_cast<long>(pos_variable), res.end(), [](char c) {
+ return std::isalnum(c) != 0 || c == '_';
+ });
+ auto pos_after_variable = static_cast<size_t>(std::distance(res.begin(), it));
+
+ // Find the substituting string and the end of the variable expression
+ auto variable_mapping = substitutions.find(res.substr(pos_variable, pos_after_variable - pos_variable));
+ const std::string * subst_str = nullptr;
+
+ size_t pos_after_variable_expression;
+
+ if (has_braces) {
+ if (pos_after_variable >= res.length()) {
+ break;
+ }
+ if (res[pos_after_variable] == ':') {
+ if (pos_after_variable + 1 >= res.length()) {
+ break;
+ }
+ char expansion_mode = res[pos_after_variable + 1];
+ size_t pos_word = pos_after_variable + 2;
+ if (pos_word >= res.length()) {
+ break;
+ }
+
+ // Expand the default/alternate expression
+ auto word_str = res.substr(pos_word);
+ auto word_substitution = substitute_expression(word_str, substitutions, depth + 1);
+ auto expanded_word = word_substitution.first;
+ auto scanned = word_substitution.second;
+ auto pos_after_word = pos_word + scanned;
+ if (pos_after_word >= res.length()) {
+ break;
+ }
+ if (res[pos_after_word] != '}') {
+ // The variable expression doesn't end in a '}',
+ // continue after the word and don't expand it
+ total_scanned += pos_after_word - pos;
+ pos = pos_after_word;
+ continue;
+ }
+
+ if (expansion_mode == '-') {
+ // ${variable:-word} (default value)
+ // If variable is unset or empty, the expansion of word is
+ // substituted. Otherwise, the value of variable is
+ // substituted.
+ if (variable_mapping == substitutions.end() || variable_mapping->second.empty()) {
+ subst_str = &expanded_word;
+ } else {
+ subst_str = &variable_mapping->second;
+ }
+ } else if (expansion_mode == '+') {
+ // ${variable:+word} (alternate value)
+ // If variable is unset or empty nothing is substituted.
+ // Otherwise, the expansion of word is substituted.
+ if (variable_mapping == substitutions.end() || variable_mapping->second.empty()) {
+ const std::string empty{};
+ subst_str = &empty;
+ } else {
+ subst_str = &expanded_word;
+ }
+ } else {
+ // Unknown expansion mode, continue after the ':'
+ pos = pos_after_variable + 1;
+ continue;
+ }
+ pos_after_variable_expression = pos_after_word + 1;
+ } else if (res[pos_after_variable] == '}') {
+ // ${variable}
+ if (variable_mapping != substitutions.end()) {
+ subst_str = &variable_mapping->second;
+ }
+ // Move past the closing '}'
+ pos_after_variable_expression = pos_after_variable + 1;
+ } else {
+ // Variable expression doesn't end in a '}', continue after the variable
+ pos = pos_after_variable;
+ continue;
+ }
+ } else {
+ // No braces, we have a $variable
+ if (variable_mapping != substitutions.end()) {
+ subst_str = &variable_mapping->second;
+ }
+ pos_after_variable_expression = pos_after_variable;
+ }
+
+ // If there is no substitution to make, move past the variable expression and continue.
+ if (subst_str == nullptr) {
+ total_scanned += pos_after_variable_expression - pos;
+ pos = pos_after_variable_expression;
+ continue;
+ }
+
+ res.replace(pos, pos_after_variable_expression - pos, *subst_str);
+ total_scanned += pos_after_variable_expression - pos;
+ pos += subst_str->length();
  } else {
- start = text.find_first_of("$", pastVariable);
+ total_scanned += 1;
+ pos += 1;
  }
  }
+
+ // We have reached the end of the text
+ if (depth > 0) {
+ // If we are in a subexpression and we didn't find a closing '}', make no substitutions.
+ return std::make_pair(std::string{text}, text.length());
+ }
+
+ return std::make_pair(res, text.length());
 }
 
+
 static void read(ConfigParser & cfgParser, IniParser & parser)
 {
  IniParser::ItemType readedType;

libdnf/conf/ConfigParser.hpp

@@ -147,6 +147,18 @@ struct ConfigParser {
  int itemNumber{0};
  std::string header;
  std::map<std::string, std::string> rawItems;
+
+ /**
+ * @brief Expand variables in a subexpression
+ *
+ * @param text String with variable expressions
+ * @param substitutions Substitution map
+ * @param depth The recursive depth
+ * @return Pair of the resulting string and the number of characters scanned in `text`
+ */
+ static std::pair<std::string, size_t> substitute_expression(const std::string & text,
+ const std::map<std::string, std::string> & substitutions,
+ unsigned int depth);
 };
 
 inline void ConfigParser::setSubstitutions(const std::map<std::string, std::string> & substitutions)