implement more logic in TemplateConfig

Author: HSGamer

src/main/java/me/hsgamer/bettergui/config/TemplateConfig.java

@@ -4,7 +4,7 @@
 import io.github.projectunified.minelib.plugin.postenable.PostEnable;
 import me.hsgamer.bettergui.BetterGUI;
 import me.hsgamer.bettergui.builder.ConfigBuilder;
-import me.hsgamer.bettergui.util.StringReplacerApplier;
+import me.hsgamer.bettergui.util.MapTemplate;
 import me.hsgamer.hscore.common.MapUtils;
 
 import java.io.File;
@@ -17,34 +17,13 @@ public class TemplateConfig implements Loadable, PostEnable {
   private final File templateFolder;
   private final Map<String, Map<String, Object>> templateMap = new HashMap<>();
 
-  public TemplateConfig(File templateFolder) {
-    this.templateFolder = templateFolder;
-  }
-
   public TemplateConfig(BetterGUI plugin) {
-    this(new File(plugin.getDataFolder(), "template"));
+    this.templateFolder = new File(plugin.getDataFolder(), "template");
     if (!templateFolder.exists() && templateFolder.mkdirs()) {
       plugin.saveResource("template" + File.separator + "example-template.yml", false);
     }
   }
 
-  /**
-   * Replace the variables in the object
-   *
-   * @param obj         the object
-   * @param variableMap the variable map
-   *
-   * @return the replaced object
-   */
-  private static Object replaceVariables(Object obj, Map<String, String> variableMap) {
-    return StringReplacerApplier.replace(obj, string -> {
-      for (Map.Entry<String, String> entry : variableMap.entrySet()) {
-        string = string.replace("{" + entry.getKey() + "}", entry.getValue());
-      }
-      return string;
-    });
-  }
-
   /**
    * Set up the list
    */
@@ -97,23 +76,7 @@ public Map<String, Object> getValues(Map<String, Object> settingMap, List<String
       .map(String::valueOf)
       .flatMap(this::get)
       .ifPresent(finalMap::putAll);
-    Map<String, String> variableMap = new HashMap<>();
-    // noinspection unchecked
-    Optional.ofNullable(keys.get("variable"))
-      .filter(Map.class::isInstance)
-      .map(Map.class::cast)
-      .ifPresent(map -> map.forEach((k, v) -> {
-        String variable = String.valueOf(k);
-        String value;
-        if (v instanceof List) {
-          List<String> list = new ArrayList<>();
-          ((List<?>) v).forEach(o -> list.add(String.valueOf(o)));
-          value = String.join("\n", list);
-        } else {
-          value = String.valueOf(v);
-        }
-        variableMap.put(variable, value);
-      }));
+    Map<String, Object> variableMap = MapUtils.castOptionalStringObjectMap(keys.get("variable")).orElse(Collections.emptyMap());
     keys.entrySet()
       .stream()
       .filter(entry ->
@@ -122,11 +85,10 @@ public Map<String, Object> getValues(Map<String, Object> settingMap, List<String
           && !ignoreKeyList.contains(entry.getKey().toLowerCase())
       )
       .forEach(entry -> finalMap.put(entry.getKey(), entry.getValue()));
-    if (!variableMap.isEmpty()) {
-      finalMap.replaceAll((s, o) -> replaceVariables(o, variableMap));
-    }
+    return variableMap.isEmpty()
+      ? finalMap
+      : MapUtils.castOptionalStringObjectMap(MapTemplate.apply(finalMap, variableMap), false).orElse(Collections.emptyMap());
 
-    return finalMap;
   }
 
   /**

src/main/java/me/hsgamer/bettergui/util/MapTemplate.java

@@ -0,0 +1,102 @@
+package me.hsgamer.bettergui.util;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class MapTemplate {
+  public static final String START_VARIABLE = "{";
+  public static final String END_VARIABLE = "}";
+
+  private static Object getVariableValue(String string, Map<String, Object> variableMap) {
+    int startVariableIndex = string.indexOf(START_VARIABLE);
+    int endVariableIndex = string.lastIndexOf(END_VARIABLE);
+    if (startVariableIndex != 0 || endVariableIndex != string.length() - END_VARIABLE.length()) {
+      return null;
+    }
+    String variable = string.substring(startVariableIndex + START_VARIABLE.length(), endVariableIndex);
+    Object variableValue = variableMap.get(variable);
+    if (variableValue == null) {
+      return null;
+    }
+    return apply(variableValue, variableMap);
+  }
+
+  public static Collection<?> apply(Collection<?> collection, Map<String, Object> variableMap) {
+    Stream<Object> stream = collection.stream()
+      .flatMap(obj -> {
+        if (!(obj instanceof String)) {
+          return Stream.of(obj);
+        }
+        String string = (String) obj;
+        Object variableValue = getVariableValue(string, variableMap);
+        if (variableValue == null) {
+          return Stream.of(obj);
+        }
+        if (variableValue instanceof Collection) {
+          return ((Collection<?>) variableValue).stream();
+        }
+        return Stream.of(variableValue);
+      });
+    if (collection instanceof List) {
+      return stream.collect(Collectors.toList());
+    } else if (collection instanceof Set) {
+      return stream.collect(Collectors.toSet());
+    } else {
+      return stream.collect(Collectors.toCollection(ArrayList::new));
+    }
+  }
+
+  public static Map<?, ?> apply(Map<?, ?> map, Map<String, Object> variableMap) {
+    Stream<Map.Entry<?, ?>> stream = map.entrySet().stream()
+      .flatMap(entry -> {
+        Object key = entry.getKey();
+        if (!(key instanceof String)) {
+          return Stream.of(new AbstractMap.SimpleEntry<>(key, apply(entry.getValue(), variableMap)));
+        }
+        String string = (String) key;
+        Object variableValue = getVariableValue(string, variableMap);
+        if (variableValue == null) {
+          return Stream.of(new AbstractMap.SimpleEntry<>(key, apply(entry.getValue(), variableMap)));
+        }
+        if (variableValue instanceof Map) {
+          return ((Map<?, ?>) variableValue).entrySet().stream();
+        }
+        return Stream.empty();
+      });
+    if (map instanceof ConcurrentMap) {
+      return stream.collect(Collectors.toConcurrentMap(Map.Entry::getKey, Map.Entry::getValue));
+    } else if (map instanceof LinkedHashMap) {
+      return stream.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a, LinkedHashMap::new));
+    } else {
+      return stream.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a));
+    }
+  }
+
+  public static Object apply(Object obj, Map<String, Object> variableMap) {
+    if (variableMap == null || variableMap.isEmpty()) {
+      return obj;
+    }
+    if (obj instanceof Collection) {
+      return apply((Collection<?>) obj, variableMap);
+    }
+    if (obj instanceof Map) {
+      return apply((Map<?, ?>) obj, variableMap);
+    }
+    if (obj instanceof String) {
+      String result = (String) obj;
+      StringBuilder sb = new StringBuilder(result);
+      for (Map.Entry<String, Object> entry : variableMap.entrySet()) {
+        String placeholder = START_VARIABLE + entry.getKey() + END_VARIABLE;
+        String replacement = Objects.toString(entry.getValue());
+        int index;
+        while ((index = sb.indexOf(placeholder)) != -1) {
+          sb.replace(index, index + placeholder.length(), replacement);
+        }
+      }
+      return sb.toString();
+    }
+    return obj;
+  }
+}