Move logic for config format into ConfigStringUtils

src/main/java/com/gmail/nossr50/util/text/ConfigStringUtils.java

@@ -0,0 +1,81 @@
+package com.gmail.nossr50.util.text;
+
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.datatypes.skills.SuperAbilityType;
+import org.bukkit.Material;
+import org.bukkit.entity.EntityType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
+import static com.gmail.nossr50.util.text.StringUtils.getCapitalized;
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Utility class for String operations, including formatting and caching deterministic results to improve performance.
+ */
+public class ConfigStringUtils {
+    public static final String UNDERSCORE = "_";
+    public static final String SPACE = " ";
+
+    // Using concurrent hash maps to avoid concurrency issues (Folia)
+    private static final Map<EntityType, String> configEntityStrings = new ConcurrentHashMap<>();
+    private static final Map<SuperAbilityType, String> configSuperAbilityStrings = new ConcurrentHashMap<>();
+    private static final Map<Material, String> configMaterialStrings = new ConcurrentHashMap<>();
+    private static final Map<PartyFeature, String> configPartyFeatureStrings = new ConcurrentHashMap<>();
+    
+    public static String getConfigSuperAbilityString(SuperAbilityType superAbilityType) {
+        requireNonNull(superAbilityType, "superAbilityType cannot be null");
+        return configSuperAbilityStrings.computeIfAbsent(superAbilityType,
+                ConfigStringUtils::createConfigFriendlyString);
+    }
+
+    public static String getMaterialConfigString(Material material) {
+        return configMaterialStrings.computeIfAbsent(material, ConfigStringUtils::createConfigFriendlyString);
+    }
+
+    public static String getConfigEntityTypeString(EntityType entityType) {
+        return configEntityStrings.computeIfAbsent(entityType, ConfigStringUtils::createConfigFriendlyString);
+    }
+
+    public static String getConfigPartyFeatureString(PartyFeature partyFeature) {
+        return configPartyFeatureStrings.computeIfAbsent(partyFeature,
+                // For whatever dumb reason, party feature enums got formatted like this...
+                pf -> createConfigFriendlyString(pf.name()).replace(UNDERSCORE, ""));
+    }
+
+    private static String createConfigFriendlyString(String baseString) {
+        return CONFIG_FRIENDLY_STRING_FORMATTER.apply(baseString);
+    }
+
+    private static final Function<String, String> CONFIG_FRIENDLY_STRING_FORMATTER = baseString -> {
+        if (baseString.contains(UNDERSCORE) && !baseString.contains(SPACE)) {
+            return asConfigFormat(baseString.split(UNDERSCORE));
+        } else {
+            if(baseString.contains(SPACE)) {
+                return asConfigFormat(baseString.split(SPACE));
+            } else{
+                return getCapitalized(baseString);
+            }
+        }
+    };
+
+    private static @NotNull String asConfigFormat(String[] substrings) {
+        final StringBuilder configString = new StringBuilder();
+
+        for (int i = 0; i < substrings.length; i++) {
+            configString.append(getCapitalized(substrings[i]));
+            if (i < substrings.length - 1) {
+                configString.append(UNDERSCORE);
+            }
+        }
+
+        return configString.toString();
+    }
+
+    private static String createConfigFriendlyString(Object object) {
+        return createConfigFriendlyString(object.toString());
+    }
+}

src/main/java/com/gmail/nossr50/util/text/StringUtils.java

@@ -1,16 +1,14 @@
 package com.gmail.nossr50.util.text;
 
-import com.gmail.nossr50.datatypes.party.PartyFeature;
 import com.gmail.nossr50.datatypes.skills.SuperAbilityType;
 import org.bukkit.Material;
-import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.EntityType;
 import org.jetbrains.annotations.NotNull;
 
 import java.text.DecimalFormat;
-import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
 import static java.util.Objects.requireNonNull;
@@ -24,10 +22,9 @@ public class StringUtils {
     protected static final DecimalFormat shortDecimal = new DecimalFormat("##0.0");
 
     // Using concurrent hash maps to avoid concurrency issues (Folia)
-    private static final Map<EntityType, String> formattedEntityStrings = new HashMap<>();
-    private static final Map<SuperAbilityType, String> formattedSuperAbilityStrings = new HashMap<>();
-    private static final Map<Material, String> formattedMaterialStrings = new HashMap<>();
-    private static final Map<PartyFeature, String> prettyPartyFeatureStringCache = new HashMap<>();
+    private static final Map<EntityType, String> formattedEntityStrings = new ConcurrentHashMap<>();
+    private static final Map<SuperAbilityType, String> formattedSuperAbilityStrings = new ConcurrentHashMap<>();
+    private static final Map<Material, String> formattedMaterialStrings = new ConcurrentHashMap<>();
 
     /**
      * Gets a capitalized version of the target string.
@@ -73,7 +70,10 @@ public class StringUtils {
      * @return The "trimmed" string
      */
     public static String buildStringAfterNthElement(@NotNull String @NotNull [] args, int index) {
-        StringBuilder trimMessage = new StringBuilder();
+        if (index < 0)
+            throw new IllegalArgumentException("Index must be greater than or equal to 0");
+
+        final StringBuilder trimMessage = new StringBuilder();
 
         for (int i = index; i < args.length; i++) {
             if (i > index) {
@@ -92,7 +92,7 @@ public class StringUtils {
      * @param material Material to convert
      * @return Pretty string representation of the Material
      */
-    public static String getFormattedMaterialString(Material material) {
+    public static String getPrettyMaterialString(Material material) {
         return formattedMaterialStrings.computeIfAbsent(material, StringUtils::createPrettyString);
     }
 
@@ -107,39 +107,6 @@ public class StringUtils {
         return formattedEntityStrings.computeIfAbsent(entityType, StringUtils::createPrettyString);
     }
 
-    /**
-     * Gets a wildcard configuration string for BlockData.
-     * Results are cached to improve performance.
-     *
-     * @param blockData BlockData to convert
-     * @return Wildcard configuration string
-     */
-    public static String getWildcardConfigBlockDataString(BlockData blockData) {
-        return getFormattedMaterialString(blockData.getMaterial());
-    }
-
-    /**
-     * Gets an explicit configuration string for BlockData.
-     * Results are cached to improve performance.
-     *
-     * @param data BlockData to convert
-     * @return Explicit configuration string
-     */
-    public static String getExplicitConfigBlockDataString(BlockData data) {
-        return getFormattedMaterialString(data.getMaterial());
-    }
-
-    /**
-     * Gets a pretty string representation of a PartyFeature.
-     * Results are cached to improve performance.
-     *
-     * @param partyFeature PartyFeature to convert
-     * @return Pretty string representation
-     */
-    public static String getPrettyPartyFeatureString(PartyFeature partyFeature) {
-        return prettyPartyFeatureStringCache.computeIfAbsent(partyFeature, StringUtils::createPrettyString);
-    }
-
     /**
      * Creates a pretty string from a base string by splitting underscores and capitalizing words.
      *