Allow addons to use the %classinfo% value property expression. (#7359)

Moderocky · web-flow · commit 469927abd4fe · 2025-01-15T10:20:36.000Z
* Add support for more value types.

* Use proper array types.

* Remove old node value class.

* Clean up some bad imports.
diff --git a/src/main/java/ch/njol/skript/ScriptLoader.java b/src/main/java/ch/njol/skript/ScriptLoader.java
@@ -9,24 +9,22 @@
 import ch.njol.skript.lang.SkriptParser;
 import ch.njol.skript.lang.Statement;
 import ch.njol.skript.lang.TriggerItem;
-import ch.njol.skript.lang.TriggerSection;
-import ch.njol.skript.lang.function.EffFunctionCall;
 import ch.njol.skript.lang.parser.ParserInstance;
-import ch.njol.skript.log.*;
-import ch.njol.skript.sections.SecLoop;
+import ch.njol.skript.log.CountingLogHandler;
+import ch.njol.skript.log.LogEntry;
+import ch.njol.skript.log.RetainingLogHandler;
+import ch.njol.skript.log.SkriptLogger;
 import ch.njol.skript.structures.StructOptions.OptionsData;
 import ch.njol.skript.test.runner.TestMode;
 import ch.njol.skript.util.ExceptionUtils;
 import ch.njol.skript.util.SkriptColor;
 import ch.njol.skript.util.Task;
 import ch.njol.skript.util.Timespan;
 import ch.njol.skript.variables.TypeHints;
-import ch.njol.util.Kleenean;
 import ch.njol.util.NonNullPair;
 import ch.njol.util.OpenCloseable;
 import ch.njol.util.StringUtils;
 import org.bukkit.Bukkit;
-import org.bukkit.event.Event;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.lang.script.Script;
@@ -41,11 +39,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.*;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
diff --git a/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java b/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java
@@ -16,6 +16,7 @@
 import ch.njol.skript.lang.util.common.AnyAmount;
 import ch.njol.skript.lang.util.common.AnyContains;
 import ch.njol.skript.lang.util.common.AnyNamed;
+import ch.njol.skript.lang.util.common.AnyValued;
 import ch.njol.skript.localization.Noun;
 import ch.njol.skript.localization.RegexMessage;
 import ch.njol.skript.registrations.Classes;
@@ -899,6 +900,14 @@ public String toVariableNameString(DynamicFunctionReference<?> function) {
 				.since("2.10")
 		);
 
+		Classes.registerClass(new AnyInfo<>(AnyValued.class, "valued")
+			.name("Any Valued Thing")
+			.description("Something that has a value.")
+			.usage("")
+			.examples("the text of {node}")
+			.since("INSERT VERSION")
+		);
+
 		Classes.registerClass(new AnyInfo<>(AnyContains.class, "containing")
 				.user("any container")
 				.name("Anything with Contents")
diff --git a/src/main/java/ch/njol/skript/config/EntryNode.java b/src/main/java/ch/njol/skript/config/EntryNode.java
@@ -4,13 +4,15 @@
 import java.util.Map.Entry;
 import java.util.Objects;
 
+import ch.njol.skript.lang.util.common.AnyValued;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnknownNullability;
 
 /**
  * @author Peter Güttinger
  */
-public class EntryNode extends Node implements Entry<String, String> {
+public class EntryNode extends Node implements Entry<String, String>, AnyValued<String> {
 
 	private String value;
 
@@ -35,6 +37,11 @@ public String getValue() {
 		return value;
 	}
 
+	@Override
+	public @UnknownNullability String value() {
+		return this.getValue();
+	}
+
 	@Override
 	public String setValue(final @Nullable String v) {
 		if (v == null)
@@ -44,6 +51,21 @@ public String setValue(final @Nullable String v) {
 		return r;
 	}
 
+	@Override
+	public void changeValue(String value) throws UnsupportedOperationException {
+		this.setValue(value);
+	}
+
+	@Override
+	public Class<String> valueType() {
+		return String.class;
+	}
+
+	@Override
+	public boolean supportsValueChange() {
+		return false; // todo editable configs soon
+	}
+
 	@Override
 	String save_i() {
 		return key + config.getSaveSeparator() + value;
diff --git a/src/main/java/ch/njol/skript/expressions/ExprValue.java b/src/main/java/ch/njol/skript/expressions/ExprValue.java
@@ -3,8 +3,6 @@
 import ch.njol.skript.Skript;
 import ch.njol.skript.classes.Changer.ChangeMode;
 import ch.njol.skript.classes.ClassInfo;
-import ch.njol.skript.classes.Parser;
-import ch.njol.skript.config.EntryNode;
 import ch.njol.skript.config.Node;
 import ch.njol.skript.doc.Description;
 import ch.njol.skript.doc.Examples;
@@ -14,20 +12,19 @@
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.ExpressionType;
 import ch.njol.skript.lang.Literal;
-import ch.njol.skript.lang.ParseContext;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.util.common.AnyValued;
 import ch.njol.skript.registrations.Feature;
 import ch.njol.util.Kleenean;
-import ch.njol.util.coll.CollectionUtils;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.lang.reflect.Array;
 
-@Name("Value (Experimental)")
+@Name("Value")
 @Description({
-	"Returns the value of a node in a loaded config.",
+	"Returns the value of something that has a value, e.g. a node in a config.",
 	"The value is automatically converted to the specified type (e.g. text, number) where possible."
 })
 @Examples({
@@ -44,86 +41,99 @@
 		# timespan value of {_node} = 12 hours (duration)""",
 
 })
-@Since("2.10")
-public class ExprNodeValue extends SimplePropertyExpression<Node, Object> {
+@Since("2.10 (Nodes), INSERT VERSION (Any)")
+public class ExprValue extends SimplePropertyExpression<Object, Object> {
 
 	static {
-		Skript.registerExpression(ExprNodeValue.class, Object.class, ExpressionType.PROPERTY,
-				"[the] %*classinfo% value [at] %string% (from|in) %node%",
-				"[the] %*classinfo% value of %node%",
-				"[the] %*classinfo% values of %nodes%",
-				"%node%'s %*classinfo% value",
-				"%nodes%'[s] %*classinfo% values"
+		Skript.registerExpression(ExprValue.class, Object.class, ExpressionType.PROPERTY,
+			"[the] %*classinfo% value [at] %string% (from|in) %node%",
+			"[the] %*classinfo% value of %valued%",
+			"[the] %*classinfo% values of %valueds%",
+			"%valued%'s %*classinfo% value",
+			"%valueds%'[s] %*classinfo% values"
 		);
 	}
 
 	private boolean isSingle;
 	private ClassInfo<?> classInfo;
-	private Parser<?> parser;
 	private @Nullable Expression<String> pathExpression;
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public boolean init(Expression<?>[] expressions, int pattern, Kleenean isDelayed, ParseResult parseResult) {
-		if (!this.getParser().hasExperiment(Feature.SCRIPT_REFLECTION))
-			return false;
 		@NotNull Literal<ClassInfo<?>> format;
 		switch (pattern) {
 			case 0:
+				if (!this.getParser().hasExperiment(Feature.SCRIPT_REFLECTION))
+					return false;
 				this.isSingle = true;
 				format = (Literal<ClassInfo<?>>) expressions[0];
 				this.pathExpression = (Expression<String>) expressions[1];
-				this.setExpr((Expression<? extends Node>) expressions[2]);
-			break;
+				this.setExpr(expressions[2]);
+				break;
 			case 1:
 				this.isSingle = true;
 			case 2:
 				format = (Literal<ClassInfo<?>>) expressions[0];
-				this.setExpr((Expression<? extends Node>) expressions[1]);
+				this.setExpr(expressions[1]);
 				break;
 			case 3:
 				this.isSingle = true;
 			default:
 				format = (Literal<ClassInfo<?>>) expressions[1];
-				this.setExpr((Expression<? extends Node>) expressions[0]);
+				this.setExpr(expressions[0]);
 		}
 		this.classInfo = format.getSingle();
-		if (classInfo.getC() == String.class) // don't bother with parser
-			return true;
-		this.parser = classInfo.getParser();
-		if (this.parser == null || !this.parser.canParse(ParseContext.CONFIG)) {
-			Skript.error("The type '" + classInfo.getName() + "' cannot be used to parse config values.");
-			return false;
-		}
 		return true;
 	}
 
 	@Override
-
-	public @Nullable Object convert(@Nullable Node node) {
-		if (!(node instanceof EntryNode entryNode))
+	public @Nullable Object convert(@Nullable Object object) {
+		if (object == null)
 			return null;
-		String string = entryNode.getValue();
-		if (classInfo.getC() == String.class)
-			return string;
-		return parser.parse(string, ParseContext.CONFIG);
+		if (object instanceof AnyValued<?> valued)
+			return valued.convertedValue(classInfo);
+		return null;
 	}
 
 	@Override
-	protected Object[] get(Event event, Node[] source) {
+	protected Object[] get(Event event, Object[] source) {
 		if (pathExpression != null) {
+			if (!(source[0] instanceof Node main))
+				return (Object[]) Array.newInstance(this.getReturnType(), 0);
 			String path = pathExpression.getSingle(event);
-			Node node = source[0].getNodeAt(path);
+			Node node = main.getNodeAt(path);
 			Object[] array = (Object[]) Array.newInstance(this.getReturnType(), 1);
-			array[0] = this.convert(node);
+			if (!(node instanceof AnyValued<?> valued))
+				return (Object[]) Array.newInstance(this.getReturnType(), 0);
+			array[0] = this.convert(valued);
 			return array;
 		}
 		return super.get(source, this);
 	}
 
 	@Override
 	public Class<?> @Nullable [] acceptChange(ChangeMode mode) {
-		return null; // todo editable configs in future
+		if (pathExpression != null) // todo editable configs soon
+			return null;
+		return switch (mode) {
+			case SET -> new Class<?>[] {Object.class};
+			case RESET, DELETE -> new Class<?>[0];
+			default -> null;
+		};
+	}
+
+	@Override
+	public void change(Event event, Object @Nullable [] delta, ChangeMode mode) {
+		if (pathExpression != null)
+			return;
+		Object newValue = delta != null ? delta[0] : null;
+		for (Object object : getExpr().getArray(event)) {
+			if (!(object instanceof AnyValued<?> valued))
+				continue;
+			if (valued.supportsValueChange())
+				valued.changeValueSafely(newValue);
+		}
 	}
 
 	@Override
diff --git a/src/main/java/ch/njol/skript/lang/util/common/AnyValued.java b/src/main/java/ch/njol/skript/lang/util/common/AnyValued.java
@@ -0,0 +1,110 @@
+package ch.njol.skript.lang.util.common;
+
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.lang.ParseContext;
+import ch.njol.skript.registrations.Classes;
+import ch.njol.skript.util.StringMode;
+import com.sun.jdi.request.StepRequest;
+import org.jetbrains.annotations.UnknownNullability;
+import org.skriptlang.skript.lang.converter.Converters;
+
+/**
+ * A provider for anything with a value.
+ * Anything implementing this (or convertible to this) can be used by the {@link ch.njol.skript.expressions.ExprValue}
+ * property expression.
+ *
+ * @see AnyProvider
+ */
+public interface AnyValued<Type> extends AnyProvider {
+
+	/**
+	 * @return This thing's value
+	 */
+	@UnknownNullability
+	Type value();
+
+	default <Converted> Converted convertedValue(ClassInfo<Converted> expected) {
+		Type value = value();
+		if (value == null)
+			return null;
+		if (expected.getC().isInstance(value))
+			return expected.getC().cast(value);
+
+		// For strings, it is probably better to use toString/Parser in either
+		// direction, instead of a converter
+
+		if (expected.getC() == String.class)
+			//noinspection unchecked
+			return (Converted) Classes.toString(value, StringMode.MESSAGE);
+		if (value instanceof String string
+			&& expected.getParser() != null
+			&& expected.getParser().canParse(ParseContext.CONFIG)) {
+			return expected.getParser().parse(string, ParseContext.CONFIG);
+		}
+
+		return Converters.convert(value, expected.getC());
+	}
+
+	/**
+	 * This is called before {@link #changeValue(Object)}.
+	 * If the result is false, setting the value will never be attempted.
+	 *
+	 * @return Whether this supports being set
+	 */
+	default boolean supportsValueChange() {
+		return false;
+	}
+
+	/**
+	 * The behaviour for changing this thing's value, if possible.
+	 * If not possible, then {@link #supportsValueChange()} should return false and this
+	 * may throw an error.
+	 *
+	 * @param value The new value
+	 * @throws UnsupportedOperationException If this is impossible
+	 */
+	default void changeValue(Type value) throws UnsupportedOperationException {
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 *
+	 * @return The type of values this accepts (or provides)
+	 */
+	Class<Type> valueType();
+
+	/**
+	 * A default implementation of 'resetting' the value (setting it to null).
+	 * Implementations should override this if different behaviour is required.
+	 *
+	 * @throws UnsupportedOperationException If changing is not supported
+	 */
+	default void resetValue() throws UnsupportedOperationException {
+		this.changeValueSafely(null);
+	}
+
+	/**
+	 * This method can be overridden to filter out bad values (e.g. null, objects of the wrong type, etc.)
+	 * and make sure {@link #changeValue(Object)} is not called with a bad parameter.
+	 *
+	 * @param value The (unchecked) new value
+	 */
+	default void changeValueSafely(Object value) throws UnsupportedOperationException {
+		Class<Type> typeClass = this.valueType();
+		ClassInfo<? super Type> classInfo = Classes.getSuperClassInfo(typeClass);
+		if (value == null) {
+			this.changeValue(null);
+		} else if (typeClass == String.class) {
+			this.changeValue(typeClass.cast(Classes.toString(value, StringMode.MESSAGE)));
+		} else if (value instanceof String string
+			&& classInfo.getParser() != null
+			&& classInfo.getParser().canParse(ParseContext.CONFIG)) {
+			Type convert = (Type) classInfo.getParser().parse(string, ParseContext.CONFIG);
+			this.changeValue(convert);
+		} else {
+			Type convert = Converters.convert(value, typeClass);
+			this.changeValue(convert);
+		}
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/registrations/Classes.java b/src/main/java/ch/njol/skript/registrations/Classes.java
diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang
