Component support !?!

paper/src/main/java/me/clip/placeholderapi/PAPIComponents.java

@@ -0,0 +1,162 @@
+package me.clip.placeholderapi;
+
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.clip.placeholderapi.expansion.Relational;
+import me.clip.placeholderapi.replacer.ExactReplacer;
+import me.clip.placeholderapi.replacer.RelationalExactReplacer;
+import me.clip.placeholderapi.replacer.Replacer;
+import net.kyori.adventure.text.Component;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static me.clip.placeholderapi.PlaceholderAPI.RELATIONAL_PLACEHOLDER_PATTERN;
+
+public final class PAPIComponents {
+    private static final Replacer PERCENT_EXACT_REPLACER = new ExactReplacer('%', '%');
+    private static final Replacer BRACKET_EXACT_REPLACER = new ExactReplacer('{', '}');
+    private static final RelationalExactReplacer RELATIONAL_EXACT_REPLACER = new RelationalExactReplacer();
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal %<identifier>_<params>%}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param component Component to set the placeholder values in
+     * @return Component containing all translated placeholders
+     */
+    @NotNull
+    public static Component setPlaceholders(final OfflinePlayer player, @NotNull final Component component) {
+        // TODO: explore a custom TextReplacementRenderer which doesn't use regex for performance benefits i.e. merge CharsReplacer with kyori TextReplacementRenderer
+        return component.replaceText(config -> config.match(PlaceholderAPI.PLACEHOLDER_PATTERN).replacement((result, builder) ->
+                builder.content(PERCENT_EXACT_REPLACER.apply(result.group(), player, PlaceholderAPIPlugin.getInstance().getLocalExpansionManager()::getExpansion))));
+    }
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal %<identifier>_<params>%}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param components List of Components to set the placeholder values in
+     * @return List of Components containing all translated placeholders
+     */
+    @NotNull
+    public static List<Component> setPlaceholders(final OfflinePlayer player, @NotNull final List<Component> components) {
+        return components.stream().map(component -> setPlaceholders(player, component)).collect(Collectors.toList());
+    }
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal %<identifier>_<params>%}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param component Component to set the placeholder values in
+     * @return Component containing all translated placeholders
+     */
+    @NotNull
+    public static Component setPlaceholders(final Player player, @NotNull final Component component) {
+        return setPlaceholders((OfflinePlayer) player, component);
+    }
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal %<identifier>_<params>%}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param components List of Components to set the placeholder values in
+     * @return List of components containing all translated placeholders
+     */
+    @NotNull
+    public static List<Component> setPlaceholders(final Player player, @NotNull final List<Component> components) {
+        return setPlaceholders((OfflinePlayer) player, components);
+    }
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal {<identifier>_<params>}}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param component Component to set the placeholder values in
+     * @return Component containing all translated placeholders
+     */
+    @NotNull
+    public static Component setBracketPlaceholders(final OfflinePlayer player, @NotNull final Component component) {
+        return component.replaceText(config -> config.match(PlaceholderAPI.BRACKET_PLACEHOLDER_PATTERN).replacement((result, builder) ->
+                builder.content(BRACKET_EXACT_REPLACER.apply(result.group(), player, PlaceholderAPIPlugin.getInstance().getLocalExpansionManager()::getExpansion))));
+    }
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal {<identifier>_<params>}}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param components List of Components to set the placeholder values in
+     * @return List of Components containing all translated placeholders
+     */
+    @NotNull
+    public static List<Component> setBracketPlaceholders(final OfflinePlayer player, @NotNull final List<Component> components) {
+        return components.stream().map(component -> setBracketPlaceholders(player, component)).collect(Collectors.toList());
+    }
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal {<identifier>_<params>}}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param component Component to set the placeholder values in
+     * @return Component containing all translated placeholders
+     */
+    @NotNull
+    public static Component setBracketPlaceholders(final Player player, @NotNull final Component component) {
+        return setBracketPlaceholders((OfflinePlayer) player, component);
+    }
+
+    /**
+     * Translates all placeholders into their corresponding values.
+     * <br>The pattern of a valid placeholder is {@literal {<identifier>_<params>}}.
+     *
+     * @param player Player to parse the placeholders against
+     * @param components List of Components to set the placeholder values in
+     * @return List of Components containing all translated placeholders
+     */
+    @NotNull
+    public static List<Component> setBracketPlaceholders(final Player player, @NotNull final List<Component> components) {
+        return setBracketPlaceholders((OfflinePlayer) player, components);
+    }
+
+    /**
+     * set relational placeholders in the text specified placeholders are matched with the pattern
+     * {@literal %<rel_(identifier)_(params)>%} when set with this method
+     *
+     * @param one First player to compare
+     * @param two Second player to compare
+     * @param component Component to parse the placeholders in
+     * @return The Component containing the parsed relational placeholders
+     */
+    public static Component setRelationalPlaceholders(Player one, Player two, Component component) {
+        return component.replaceText(config -> config.match(RELATIONAL_PLACEHOLDER_PATTERN).replacement((result, builder) ->
+                builder.content(RELATIONAL_EXACT_REPLACER.apply(result.group(2), one, two, PlaceholderAPIPlugin.getInstance().getLocalExpansionManager()::getExpansion))));
+    }
+
+    /**
+     * Translate placeholders in the provided List based on the relation of the two provided players.
+     * <br>The pattern of a valid placeholder is {@literal %rel_<identifier>_<param>%}.
+     *
+     * @param one Player to compare
+     * @param two Player to compare
+     * @param components List of Components to parse the placeholder values to
+     * @return The List of Components containing the parsed relational placeholders
+     */
+    public static List<Component> setRelationalPlaceholders(Player one, Player two, List<Component> components) {
+        return components.stream().map(line -> setRelationalPlaceholders(one, two, line))
+                .collect(Collectors.toList());
+    }
+
+    // kyori doesn't seem to have a method that can do a contains with regex, we don't want to do a more expensive replace
+//    public static boolean containsPlaceholders(@Nullable final Component text) {
+//        return text != null && text.replaceText()
+//    }
+}

paper/src/main/java/me/clip/placeholderapi/replacer/ExactReplacer.java

@@ -0,0 +1,56 @@
+package me.clip.placeholderapi.replacer;
+
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
+import java.util.regex.Pattern;
+
+public final class ExactReplacer implements Replacer {
+    private static final Pattern DELIMITER = Pattern.compile("_");
+
+    private final char start;
+    private final char end;
+
+    public ExactReplacer(final char start, final char end) {
+        this.start = start;
+        this.end = end;
+    }
+
+    @NotNull
+    @Override
+    public String apply(@NotNull String text, @Nullable final OfflinePlayer player,
+                        @NotNull final Function<String, @Nullable PlaceholderExpansion> lookup) {
+        text = text.substring(1, text.length() - 1);
+        final String[] parts = DELIMITER.split(text);
+        final PlaceholderExpansion expansion;
+
+        if (parts.length == 0) {
+            expansion = lookup.apply(text);
+        } else {
+            expansion = lookup.apply(parts[0]);
+        }
+
+        if (expansion == null) {
+            return start + text + end;
+        }
+
+        final String params;
+
+        if (text.endsWith("_")) {
+            params = "";
+        } else {
+            params = text.substring(text.indexOf('_') + 1);
+        }
+
+        final String result = expansion.onRequest(player, params);
+
+        if (result == null) {
+            return start + text + end;
+        }
+
+        return result;
+    }
+}

paper/src/main/java/me/clip/placeholderapi/replacer/RelationalExactReplacer.java

@@ -0,0 +1,53 @@
+package me.clip.placeholderapi.replacer;
+
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.clip.placeholderapi.expansion.Relational;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
+import java.util.regex.Pattern;
+
+public final class RelationalExactReplacer {
+    private static final Pattern DELIMITER = Pattern.compile("_");
+
+    @NotNull
+    public String apply(@NotNull String text, @Nullable final Player player1,
+                        @Nullable final Player player2, @NotNull final Function<String,
+                        @Nullable PlaceholderExpansion> lookup) {
+        final String[] parts = DELIMITER.split(text);
+        final PlaceholderExpansion expansion;
+
+        if (parts.length == 0) {
+            expansion = lookup.apply(text);
+        } else {
+            expansion = lookup.apply(parts[0]);
+        }
+
+        if (expansion == null) {
+            return "%rel_" + text + '%';
+        }
+
+        if (!(expansion instanceof Relational)) {
+            return "%rel_" + text + '%';
+        }
+
+        final String params;
+
+        if (text.endsWith("_")) {
+            params = "";
+        } else {
+            params = text.substring(text.indexOf('_') + 1);
+        }
+
+        final String result = ((Relational) expansion).onPlaceholderRequest(player1, player2, params);
+
+        if (result == null) {
+            return "%rel_" + text + '%';
+        }
+
+        return result;
+    }
+}