Generify the placeholders, introducing server and common split (unfinished)

Author: Patbox

gradle.properties

@@ -11,6 +11,6 @@ loom_version=1.14-SNAPSHOT
 fabric_version=0.140.2+26.1
 
 	# Mod Properties
-	mod_version = 3.0.0-beta.1+26.1-snapshot-1
+	mod_version = 3.0.0-alpha.1+26.1-snapshot-1
 	maven_group = eu.pb4
 	archives_base_name = placeholder-api

src/main/java/eu/pb4/placeholders/api/ArgumentParser.java

@@ -0,0 +1,14 @@
+package eu.pb4.placeholders.api;
+
+import eu.pb4.placeholders.api.arguments.StringArgs;
+import org.jspecify.annotations.Nullable;
+
+import java.util.Objects;
+
+public interface ArgumentParser<Result> {
+    ArgumentParser<String> STRING = x -> Objects.requireNonNullElse(x, "");
+    ArgumentParser<@Nullable String> NULLABLE_STRING = x -> x;
+    ArgumentParser<StringArgs> STRING_ARGS_BASIC = x -> StringArgs.full(x, ' ', ':');
+
+    Result parseArgument(@Nullable String string);
+}

src/main/java/eu/pb4/placeholders/api/ParserContext.java

@@ -1,12 +1,11 @@
 package eu.pb4.placeholders.api;
 
 import eu.pb4.placeholders.api.node.parent.DynamicShadowNode;
-import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.Nullable;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
-import java.util.function.Function;
 import java.util.function.Supplier;
 import net.minecraft.core.HolderLookup;
 
@@ -30,11 +29,19 @@ public static <T> ParserContext of(Key<T> key, T object) {
     }
 
     public <T> ParserContext with(Key<T> key, T object) {
+        if (this.map.get(key) == object) {
+            return this;
+        }
+
         if (this.copyOnWrite) {
             this.map = new HashMap<>(this.map);
             this.copyOnWrite = false;
         }
-        this.map.put(key, object);
+        if (object == null) {
+            this.map.remove(key);
+        } else {
+            this.map.put(key, object);
+        }
         this.hasNodeContext |= key.nodeContext();
         return this;
     }
@@ -87,21 +94,28 @@ public ParserContext copyWithoutNodeContext() {
         return this.copy();
     }
 
-    public record Key<T>(String key, @Nullable Class<T> type, boolean nodeContext) {
-        public Key(String key, @Nullable Class<T> type) {
-            this(key, type, false);
+    public <T> ParserContext withIfNotSet(Key<T> key, T object) {
+        if (this.map.containsKey(key)) {
+            return this;
         }
+        return this.with(key, object);
+    }
 
-
-        public static final Key<Boolean> COMPACT_TEXT = new Key<>("compact_text", Boolean.class);
-        public static final Key<HolderLookup.Provider> WRAPPER_LOOKUP = new Key<>("wrapper_lookup", HolderLookup.Provider.class);
-        public static final Key<DynamicShadowNode.Transformer> DEFAULT_SHADOW_STYLER = Key.ofNode("default_shadow_styler");
+    public record Key<T>(String key, @Nullable Class<T> type, boolean nodeContext) {
+        public static final Key<Boolean> COMPACT_COMPONENT = of("compact_component", Boolean.class);
+        public static final Key<HolderLookup.Provider> HOLDER_LOOKUP = of("holder_lookup", HolderLookup.Provider.class);
+        public static final Key<DynamicShadowNode.Transformer> DEFAULT_SHADOW_STYLER = ofNode("default_shadow_styler", DynamicShadowNode.Transformer.class);
 
         public static <T> Key<T> of(String key, T type) {
             //noinspection unchecked
             return new Key<T>(key, (Class<T>) type.getClass(), false);
         }
 
+        public static <T> Key<T> of(String key, Class<T> type) {
+            //noinspection unchecked
+            return new Key<T>(key, type, false);
+        }
+
         public static <T> Key<T> of(String key) {
             //noinspection unchecked
             return new Key<T>(key, null, false);
@@ -112,6 +126,11 @@ public static <T> Key<T> ofNode(String key, T type) {
             return new Key<T>(key, (Class<T>) type.getClass(), true);
         }
 
+        public static <T> Key<T> ofNode(String key, Class<T> type) {
+            //noinspection unchecked
+            return new Key<T>(key, type, true);
+        }
+
 
         public static <T> Key<T> ofNode(String key) {
             //noinspection unchecked

src/main/java/eu/pb4/placeholders/api/Placeholder.java

@@ -0,0 +1,35 @@
+package eu.pb4.placeholders.api;
+
+import net.minecraft.resources.Identifier;
+import org.jspecify.annotations.Nullable;
+
+public record Placeholder<Ctx, T>(Identifier identifier, ArgumentParser<T> argumentParser, Handler<Ctx, T> handler) {
+
+    public PlaceholderResult onPlaceholderRequest(Ctx context, @Nullable String argument) {
+        return handler.onPlaceholderRequest(context, argumentParser.parseArgument(argument));
+    }
+
+    public ArgumentedHandler<Ctx, T> withArgument(T argument) {
+        return new ArgumentedHandler<>(this, argument);
+    }
+
+    public ArgumentedHandler<Ctx, T> withParsedArgument(@Nullable String argument) {
+        return new ArgumentedHandler<>(this, this.argumentParser.parseArgument(argument));
+    }
+
+    public Placeholder<Ctx, T> withId(Identifier identifier) {
+        return new Placeholder<>(identifier, argumentParser, handler);
+    }
+
+    @FunctionalInterface
+    public interface Handler<Ctx, ArgType> {
+        Handler<?, ?> EMPTY = (ctx, arg) -> PlaceholderResult.invalid();
+        PlaceholderResult onPlaceholderRequest(Ctx context, ArgType argument);
+    }
+
+    public record ArgumentedHandler<Ctx, T>(Placeholder<Ctx, T> placeholder, T argument) {
+        public PlaceholderResult onPlaceholderRequest(Ctx context) {
+            return this.placeholder.handler.onPlaceholderRequest(context, argument);
+        }
+    }
+}

src/main/java/eu/pb4/placeholders/api/PlaceholderContext.java

@@ -1,117 +1,92 @@
 package eu.pb4.placeholders.api;
 
 import com.mojang.authlib.GameProfile;
+import eu.pb4.placeholders.impl.PlaceholderContextImpl;
 import eu.pb4.placeholders.impl.placeholder.ViewObjectImpl;
-import net.minecraft.commands.CommandSource;
 import net.minecraft.commands.CommandSourceStack;
-import net.minecraft.network.chat.Component;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.resources.Identifier;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.server.players.NameAndId;
 import net.minecraft.world.entity.Entity;
-import net.minecraft.world.phys.Vec2;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
 import net.minecraft.world.phys.Vec3;
-import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.Nullable;
+import org.jspecify.annotations.Nullable;
 
-import java.util.function.Supplier;
+import javax.tools.Diagnostic;
 
+public interface PlaceholderContext {
+    ParserContext.Key<PlaceholderContext> COMMON_KEY = ParserContext.Key.of("placeholder_context", PlaceholderContext.class);
 
-public record PlaceholderContext(MinecraftServer server,
-                                 Supplier<CommandSourceStack> lazySource,
-                                 @Nullable ServerLevel world,
-                                 @Nullable ServerPlayer player,
-                                 @Nullable Entity entity,
-                                 @Nullable GameProfile gameProfile,
-                                 ViewObject view
-) {
-
-    public CommandSourceStack source() {
-        return this.lazySource.get();
+    default boolean hasLevel() {
+        return this.level() != null;
     }
 
-    public static ParserContext.Key<PlaceholderContext> KEY = new ParserContext.Key<>("placeholder_context", PlaceholderContext.class);
-
-    public boolean hasWorld() {
-        return this.world != null;
+    default boolean hasPlayer() {
+        return this.player() != null;
     }
 
-    public boolean hasPlayer() {
-        return this.player != null;
+    default boolean hasNameAndId() {
+        return this.nameAndId() != null;
     }
 
-    public boolean hasGameProfile() {
-        return this.gameProfile != null;
+    default boolean hasGameProfile() {
+        return this.gameProfile() != null;
     }
 
-    public boolean hasEntity() {
-        return this.entity != null;
+    default boolean hasEntity() {
+        return this.entity() != null;
     }
 
-    public ParserContext asParserContext() {
-        return ParserContext.of(KEY, this).with(ParserContext.Key.WRAPPER_LOOKUP, this.server.registryAccess());
+    default boolean hasHolderLookup() {
+        return this.holderLookup() != null;
     }
 
-    public PlaceholderContext withView(ViewObject view) {
-        return new PlaceholderContext(this.server, this.lazySource, this.world, this.player, this.entity, this.gameProfile, view);
+    default boolean hasBlockPosition() {
+        return this.blockPosition() != null;
     }
 
-    public void addToContext(ParserContext context) {
-        context.with(KEY, this);
-        context.with(ParserContext.Key.WRAPPER_LOOKUP, this.server.registryAccess());
+    default boolean hasPosition() {
+        return this.position() != null;
     }
 
+    PlaceholderContext withView(PlaceholderContextImpl.ViewObject view);
 
-    public static PlaceholderContext of(MinecraftServer server) {
-        return of(server, ViewObject.DEFAULT);
-    }
-
-    public static PlaceholderContext of(MinecraftServer server, ViewObject view) {
-        return new PlaceholderContext(server, server::createCommandSourceStack, null, null, null, null, view);
-    }
 
-    public static PlaceholderContext of(GameProfile profile, MinecraftServer server) {
-        return of(profile, server, ViewObject.DEFAULT);
+    default ParserContext asParserContext() {
+        return ParserContext.of(COMMON_KEY, this).with(ParserContext.Key.HOLDER_LOOKUP, this.holderLookup());
     }
 
-    public static PlaceholderContext of(GameProfile profile, MinecraftServer server, ViewObject view) {
-        var name = profile.name() != null ? profile.name() : profile.id().toString();
-        return new PlaceholderContext(server, () -> new CommandSourceStack(CommandSource.NULL, Vec3.ZERO, Vec2.ZERO, server.overworld(), server.getProfilePermissions(new NameAndId(profile)), name, Component.literal(name), server, null), null, null, null, profile, view);
+    default void addToContext(ParserContext context) {
+        context.with(COMMON_KEY, this);
+        context.withIfNotSet(ParserContext.Key.HOLDER_LOOKUP, this.holderLookup());
     }
 
-    public static PlaceholderContext of(ServerPlayer player) {
-        return of(player, ViewObject.DEFAULT);
-    }
+    HolderLookup.@Nullable Provider holderLookup();
+    @Nullable
+    Level level();
 
-    public static PlaceholderContext of(ServerPlayer player, ViewObject view) {
-        return new PlaceholderContext(player.level().getServer(), player::createCommandSourceStack, player.level(), player, player, player.getGameProfile(), view);
-    }
+    @Nullable
+    Player player();
+    @Nullable
+    Entity entity();
+    @Nullable
+    NameAndId nameAndId();
+    @Nullable
+    GameProfile gameProfile();
 
-    public static PlaceholderContext of(CommandSourceStack source) {
-        return of(source, ViewObject.DEFAULT);
-    }
-
-    public static PlaceholderContext of(CommandSourceStack source, ViewObject view) {
-        return new PlaceholderContext(source.getServer(), () -> source, source.getLevel(), source.getPlayer(), source.getEntity(), source.getPlayer() != null ? source.getPlayer().getGameProfile() : null, view);
-    }
-
-    public static PlaceholderContext of(Entity entity) {
-        return of(entity, ViewObject.DEFAULT);
-    }
-
-    public static PlaceholderContext of(Entity entity, ViewObject view) {
-        if (entity instanceof ServerPlayer player) {
-            return of(player, view);
-        } else {
-            var world = (ServerLevel) entity.level();
-            return new PlaceholderContext(world.getServer(), () -> entity.createCommandSourceStackForNameResolution(world), world, null, entity, null, view);
-        }
-    }
+    PlaceholderContext.ViewObject view();
 
+    @Nullable
+    BlockPos blockPosition();
+    @Nullable
+    Vec3 position();
 
-    public interface ViewObject {
+    interface ViewObject {
         ViewObject DEFAULT = of(Identifier.fromNamespaceAndPath("placeholder_api", "default"));
 
         static ViewObject of(Identifier identifier) {

src/main/java/eu/pb4/placeholders/api/PlaceholderHandler.java

@@ -1,31 +1,30 @@
 package eu.pb4.placeholders.api;
 
-import eu.pb4.placeholders.api.parsers.TagParser;
 import net.minecraft.ChatFormatting;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.Style;
 
 public final class PlaceholderResult {
-    private final Component text;
+    private final Component component;
     private final boolean valid;
 
     private PlaceholderResult(Component text, String reason) {
         if (text != null) {
-            this.text = text;
+            this.component = text;
             this.valid = true;
         } else {
-            this.text = Component.literal("[" + (reason != null ? reason : "Invalid placeholder!") + "]").setStyle(Style.EMPTY.withColor(ChatFormatting.GRAY).withItalic(true));
+            this.component = Component.literal("[" + (reason != null ? reason : "Invalid placeholder!") + "]").setStyle(Style.EMPTY.withColor(ChatFormatting.GRAY).withItalic(true));
             this.valid = false;
         }
     }
 
     /**
-     * Returns text component from placeholder
+     * Returns component component from placeholder
      *
      * @return Text
      */
-    public Component text() {
-        return this.text;
+    public Component component() {
+        return this.component;
     }
 
     /**
@@ -60,26 +59,17 @@ public static PlaceholderResult invalid() {
      *
      * @return PlaceholderResult
      */
-    public static PlaceholderResult value(Component text) {
-        return new PlaceholderResult(text, null);
+    public static PlaceholderResult value(Component component) {
+        return new PlaceholderResult(component, null);
     }
 
     /**
      * Create result for placeholder
      *
      * @return PlaceholderResult
      */
-    public static PlaceholderResult value(String text) {
-        return new PlaceholderResult(TagParser.DEFAULT.parseComponent(text, ParserContext.of()), null);
-    }
-
-    /**
-     * Create result for placeholder
-     *
-     * @return PlaceholderResult
-     */
-    public static PlaceholderResult value(String text, ParserContext context) {
-        return new PlaceholderResult(TagParser.DEFAULT.parseComponent(text,context), null);
+    public static PlaceholderResult value(String component) {
+        return new PlaceholderResult(Component.literal(component), null);
     }
 }