feat(config): support indexed list insertion (#1081)

Add support for inserting elements at specific positions in config lists
using the syntax "/N+" where N is the insertion index.

Changes:
- Add ParseIndexedAppend() function to parse "/N+" syntax from config keys
- Extend AppendToList() to accept optional insert_pos parameter
- Update IsAppending(), IsMerging(), and StripOperator() to handle indexed insertion
- Add bounds checking for insertion position with error logging
- Support both append and insert operations in EditNode()

Examples:
- "key/0+" inserts at beginning of list
- "key/2+" inserts at index 2
- "key+" continues to append at end (backward compatible)

This enhancement allows more precise control over list element positioning
in RIME configuration files while maintaining backward compatibility.

---------

Co-authored-by: jimmy54 <jimmy54@126.com>

Author: jimmy54

src/rime/config/config_compiler.cc

@@ -1,3 +1,7 @@
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+#include <optional>
 #include <boost/algorithm/string.hpp>
 #include <rime/common.h>
 #include <rime/resource.h>
@@ -101,7 +105,9 @@ static bool AppendToString(an<ConfigItemRef> target, an<ConfigValue> value) {
   return true;
 }
 
-static bool AppendToList(an<ConfigItemRef> target, an<ConfigList> list) {
+static bool AppendToList(an<ConfigItemRef> target,
+                         an<ConfigList> list,
+                         std::optional<size_t> insert_pos = std::nullopt) {
   if (!list)
     return false;
   auto existing_list = As<ConfigList>(**target);
@@ -117,9 +123,20 @@ static bool AppendToList(an<ConfigItemRef> target, an<ConfigList> list) {
   if (list->empty())
     return true;
   auto copy = New<ConfigList>(*existing_list);
+  if (insert_pos && *insert_pos > copy->size()) {
+    LOG(ERROR) << "list insert position out of range: " << *insert_pos;
+    return false;
+  }
+  size_t current_index = insert_pos.value_or(copy->size());
   for (ConfigList::Iterator iter = list->begin(); iter != list->end(); ++iter) {
-    if (!copy->Append(*iter))
-      return false;
+    if (insert_pos) {
+      if (!copy->Insert(current_index, *iter))
+        return false;
+      ++current_index;
+    } else {
+      if (!copy->Append(*iter))
+        return false;
+    }
   }
   *target = copy;
   return true;
@@ -148,25 +165,63 @@ static bool MergeTree(an<ConfigItemRef> target, an<ConfigMap> map) {
 static constexpr const char* ADD_SUFFIX_OPERATOR = "/+";
 static constexpr const char* EQU_SUFFIX_OPERATOR = "/=";
 
-inline static bool IsAppending(const string& key) {
+static std::optional<size_t> ParseIndexedAppend(const string& key) {
+  if (key.empty() || key.back() != '+')
+    return std::nullopt;
+  size_t plus_pos = key.size() - 1;
+  size_t digit_begin = plus_pos;
+  while (digit_begin > 0 &&
+         std::isdigit(static_cast<unsigned char>(key[digit_begin - 1]))) {
+    --digit_begin;
+  }
+  if (digit_begin == plus_pos)
+    return std::nullopt;
+  if (digit_begin > 0 && key[digit_begin - 1] != '/')
+    return std::nullopt;
+  string index_part = key.substr(digit_begin, plus_pos - digit_begin);
+  if (index_part.empty())
+    return std::nullopt;
+  return static_cast<size_t>(std::strtoull(index_part.c_str(), nullptr, 10));
+}
+
+inline static bool IsAppending(const string& key,
+                               const std::optional<size_t>& indexed_append) {
   return key == ConfigCompiler::APPEND_DIRECTIVE ||
-         boost::ends_with(key, ADD_SUFFIX_OPERATOR);
+         boost::ends_with(key, ADD_SUFFIX_OPERATOR) ||
+         indexed_append.has_value();
 }
 inline static bool IsMerging(const string& key,
                              const an<ConfigItem>& value,
-                             bool merge_tree) {
-  return key == ConfigCompiler::MERGE_DIRECTIVE ||
-         boost::ends_with(key, ADD_SUFFIX_OPERATOR) ||
+                             bool merge_tree,
+                             const std::optional<size_t>& indexed_append) {
+  bool has_plain_add_suffix =
+      boost::ends_with(key, ADD_SUFFIX_OPERATOR) && !indexed_append.has_value();
+  return key == ConfigCompiler::MERGE_DIRECTIVE || has_plain_add_suffix ||
          (merge_tree && (!value || Is<ConfigMap>(value)) &&
           !boost::ends_with(key, EQU_SUFFIX_OPERATOR));
 }
 
-inline static string StripOperator(const string& key, bool adding) {
-  return (key == ConfigCompiler::APPEND_DIRECTIVE ||
-          key == ConfigCompiler::MERGE_DIRECTIVE)
-             ? ""
-             : boost::erase_last_copy(
-                   key, adding ? ADD_SUFFIX_OPERATOR : EQU_SUFFIX_OPERATOR);
+inline static string StripOperator(
+    const string& key,
+    bool adding,
+    const std::optional<size_t>& indexed_append) {
+  if (key == ConfigCompiler::APPEND_DIRECTIVE ||
+      key == ConfigCompiler::MERGE_DIRECTIVE) {
+    return "";
+  }
+  if (indexed_append) {
+    auto suffix_with_slash =
+        string("/") + std::to_string(*indexed_append) + "+";
+    if (boost::ends_with(key, suffix_with_slash)) {
+      return key.substr(0, key.size() - suffix_with_slash.size());
+    }
+    auto suffix_plain = std::to_string(*indexed_append) + "+";
+    if (boost::ends_with(key, suffix_plain)) {
+      return key.substr(0, key.size() - suffix_plain.size());
+    }
+  }
+  return boost::erase_last_copy(
+      key, adding ? ADD_SUFFIX_OPERATOR : EQU_SUFFIX_OPERATOR);
 }
 
 // defined in config_data.cc
@@ -180,9 +235,10 @@ static bool EditNode(an<ConfigItemRef> head,
                      const an<ConfigItem>& value,
                      bool merge_tree) {
   DLOG(INFO) << "edit node: " << key << ", merge_tree: " << merge_tree;
-  bool appending = IsAppending(key);
-  bool merging = IsMerging(key, value, merge_tree);
-  string path = StripOperator(key, appending || merging);
+  auto indexed_append = ParseIndexedAppend(key);
+  bool appending = IsAppending(key, indexed_append);
+  bool merging = IsMerging(key, value, merge_tree, indexed_append);
+  string path = StripOperator(key, appending || merging, indexed_append);
   DLOG(INFO) << "appending: " << appending << ", merging: " << merging
              << ", path: " << path;
   auto find_target_node =
@@ -195,8 +251,9 @@ static bool EditNode(an<ConfigItemRef> head,
   if ((appending || merging) && **target) {
     DLOG(INFO) << "writer: editing node";
     return !value ||  // no-op
-           (appending && (AppendToString(target, As<ConfigValue>(value)) ||
-                          AppendToList(target, As<ConfigList>(value)))) ||
+           (appending &&
+            (AppendToString(target, As<ConfigValue>(value)) ||
+             AppendToList(target, As<ConfigList>(value), indexed_append))) ||
            (merging && MergeTree(target, As<ConfigMap>(value)));
   } else {
     DLOG(INFO) << "writer: overwriting node";