revert to old charsreplacer 1.0.7

src/main/java/at/helpch/placeholderapi/replacer/CharsReplacer.java

@@ -24,6 +24,7 @@ import java.util.Locale;
 import java.util.function.Function;
 
 import at.helpch.placeholderapi.expansion.PlaceholderExpansion;
+import com.hypixel.hytale.server.core.entity.entities.Player;
 import com.hypixel.hytale.server.core.universe.PlayerRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -37,116 +38,101 @@ public final class CharsReplacer implements Replacer {
         this.closure = closure;
     }
 
-    /**
+
-     * Translates placeholders within the provided text using a high-performance
-     * character-scanning approach.
-     * * <p>The method identifies placeholders delimited by the defined {@link Closure}
-     * (e.g., %identifier_params% or {identifier_params}). If a placeholder is
-     * successfully identified, the provided lookup function is used to fetch the
-     * corresponding {@link PlaceholderExpansion}.</p>
-     *
-     * @param text   The raw text containing potential placeholders to be replaced.
-     * @param player The {@link PlayerRef} to contextually parse the placeholders against.
-     * May be {@code null} if no player context is available.
-     * @param lookup A function that maps a lowercase identifier string to a registered
-     * {@link PlaceholderExpansion}.
-     * @return A string with all valid placeholders replaced by their respective values.
-     * Returns the original text if no placeholders are found.
-     */
     @NotNull
     @Override
     public String apply(@NotNull final String text, @Nullable final PlayerRef player,
                         @NotNull final Function<String, @Nullable PlaceholderExpansion> lookup) {
-        final char head = closure.head;
+        final char[] chars = text.toCharArray();
-        int startPlaceholder = text.indexOf(head);
+        final StringBuilder builder = new StringBuilder(text.length());
 
-        if (startPlaceholder == -1) {
+        final StringBuilder identifier = new StringBuilder();
-            return text;
+        final StringBuilder parameters = new StringBuilder();
-        }
 
-        final int length = text.length();
+        for (int i = 0; i < chars.length; i++) {
-        final StringBuilder builder = new StringBuilder(length + (length >> 3));
+            final char l = chars[i];
-        int cursor = 0;
 
-        final char tail = closure.tail;
+            if (l != closure.head || i + 1 >= chars.length) {
-
+                builder.append(l);
-        loop: do {
-            // Append plain text preceding the placeholder
-            if (startPlaceholder > cursor) {
-                builder.append(text, cursor, startPlaceholder);
-            }
-
-            final int endPlaceholder = text.indexOf(tail, startPlaceholder + 1);
-
-            if (endPlaceholder == -1) {
-                builder.append(text, startPlaceholder, length);
-                return builder.toString();
-            }
-
-            int underscoreIndex = -1;
-
-            for (int i = startPlaceholder + 1; i < endPlaceholder; i++) {
-                final char current = text.charAt(i);
-
-                if (current == ' ') {
-                    // Invalid placeholder (contains space).
-                    // Treat the opening symbol as literal text and search for the next one.
-                    builder.append(head);
-                    cursor = startPlaceholder + 1;
-                    startPlaceholder = text.indexOf(head, cursor);
-
-                    // Safety check: If no more placeholders exist, break to finalize
-                    if (startPlaceholder == -1) {
-                        break loop;
-                    }
-                    continue loop;
-                }
-
-                if (current == '_' && underscoreIndex == -1) {
-                    underscoreIndex = i;
-                }
-            }
-
-            if (underscoreIndex == -1) {
-                builder.append(text, startPlaceholder, endPlaceholder + 1);
-                cursor = endPlaceholder + 1;
-                startPlaceholder = text.indexOf(head, cursor);
                 continue;
             }
 
-            String identifier = text.substring(startPlaceholder + 1, underscoreIndex);
+            boolean identified = false;
-            String parameters = "";
+            boolean invalid = true;
+            boolean hadSpace = false;
 
-            if (underscoreIndex + 1 < endPlaceholder) {
+            while (++i < chars.length) {
-                parameters = text.substring(underscoreIndex + 1, endPlaceholder);
+                final char p = chars[i];
+
+                if (p == ' ' && !identified) {
+                    hadSpace = true;
+                    break;
+                }
+                if (p == closure.tail) {
+                    invalid = false;
+                    break;
+                }
+
+                if (p == '_' && !identified) {
+                    identified = true;
+                    continue;
+                }
+
+                if (identified) {
+                    parameters.append(p);
+                } else {
+                    identifier.append(p);
+                }
             }
 
-            final PlaceholderExpansion expansion = lookup.apply(identifier.toLowerCase(Locale.ROOT));
+            final String identifierString = identifier.toString();
-            String replacement = null;
+            final String lowercaseIdentifierString = identifierString.toLowerCase(Locale.ROOT);
+            final String parametersString = parameters.toString();
 
-            if (expansion != null) {
+            identifier.setLength(0);
-                replacement = expansion.onPlaceholderRequest(player, parameters);
+            parameters.setLength(0);
+
+            if (invalid) {
+                builder.append(closure.head).append(identifierString);
+
+                if (identified) {
+                    builder.append('_').append(parametersString);
+                }
+
+                if (hadSpace) {
+                    builder.append(' ');
+                }
+                continue;
             }
 
-            if (replacement != null) {
+            final PlaceholderExpansion placeholder = lookup.apply(lowercaseIdentifierString);
-                builder.append(replacement);
+            if (placeholder == null) {
-            } else {
+                builder.append(closure.head).append(identifierString);
-                // Fallback: Restore original placeholder format
+
-                builder.append(head).append(identifier);
+                if (identified) {
-                builder.append('_').append(parameters);
+                    builder.append('_');
-                builder.append(tail);
+                }
+
+                builder.append(parametersString).append(closure.tail);
+                continue;
             }
 
-            cursor = endPlaceholder + 1;
+            final String replacement = placeholder.onPlaceholderRequest(player, parametersString);
-            startPlaceholder = text.indexOf(head, cursor);
+            if (replacement == null) {
+                builder.append(closure.head).append(identifierString);
 
-        } while (startPlaceholder != -1);
+                if (identified) {
+                    builder.append('_');
+                }
 
-        if (cursor < length) {
+                builder.append(parametersString).append(closure.tail);
-            builder.append(text, cursor, length);
+                continue;
+            }
+
+            builder.append(replacement);
         }
 
         return builder.toString();
     }
 
-}
+}