Added support for including multiple (same) EntryData within a single EntryContainer (#8035)

* added support for single entry data to be included multiple times within a section node

* added test for entry data being included multiple times within a single entry container

* added missing constructors

* made list returned by EntryContainer#getAll unmodifiable

* fixed incorrect package name in the test

* Update src/main/java/ch/njol/skript/test/runner/StructTestEntryContainer.java

* fixed the test

* fixed the test

Author: Pesekjak

src/main/java/ch/njol/skript/test/runner/StructTestEntryContainer.java

@@ -23,17 +23,20 @@ public class StructTestEntryContainer extends Structure {
 			Skript.registerStructure(StructTestEntryContainer.class,
 				EntryValidator.builder()
 					.addSection("has entry", true)
+					.addSection("has multiple entries", true, true)
 					.build(),
 				"test entry container");
 	}
 
 	private EntryContainer entryContainer;
 
 	@Override
-	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult, @Nullable EntryContainer entryContainer) {
+	public boolean init(
+		Literal<?>[] args, int matchedPattern, ParseResult parseResult, @Nullable EntryContainer entryContainer
+	) {
 		assert entryContainer != null;
 		this.entryContainer = entryContainer;
-		if (entryContainer.hasEntry("has entry")) {
+		if (entryContainer.hasEntry("has entry") && entryContainer.hasEntry("has multiple entries")) {
 			return true;
 		}
 		assert false;
@@ -47,6 +50,16 @@ public boolean load() {
 		Script script = getParser().getCurrentScript();
 		Trigger trigger = new Trigger(script, "entry container test", null, triggerItems);
 		trigger.execute(new SkriptTestEvent());
+
+		List<SectionNode> multipleSections = entryContainer.getAll(
+			"has multiple entries", SectionNode.class, false
+		);
+		for (SectionNode multipleSection : multipleSections) {
+			triggerItems = ScriptLoader.loadItems(multipleSection);
+			trigger = new Trigger(script, "entry container test", null, triggerItems);
+			trigger.execute(new SkriptTestEvent());
+		}
+
 		return true;
 	}
 

src/main/java/org/skriptlang/skript/lang/entry/ContainerEntryData.java

@@ -25,6 +25,18 @@ public ContainerEntryData(String key, boolean optional, EntryValidatorBuilder va
 		this.entryValidator = validatorBuilder.build();
 	}
 
+	public ContainerEntryData(String key, boolean optional, boolean multiple, EntryValidator entryValidator) {
+		super(key, null, optional, multiple);
+		this.entryValidator = entryValidator;
+	}
+
+	public ContainerEntryData(
+		String key, boolean optional, boolean multiple, EntryValidatorBuilder validatorBuilder
+	) {
+		super(key, null, optional, multiple);
+		this.entryValidator = validatorBuilder.build();
+	}
+
 	public EntryValidator getEntryValidator() {
 		return entryValidator;
 	}
@@ -44,8 +56,7 @@ public boolean canCreateWith(Node node) {
 		key = ScriptLoader.replaceOptions(key);
 		if (!getKey().equalsIgnoreCase(key))
 			return false;
-		EntryContainer container = entryValidator.validate(sectionNode);
-		entryContainer = container;
+		entryContainer = entryValidator.validate(sectionNode);
 		return true;
 	}
 

src/main/java/org/skriptlang/skript/lang/entry/EntryContainer.java

@@ -5,25 +5,23 @@
 import ch.njol.skript.lang.parser.ParserInstance;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * An EntryContainer is a data container for obtaining the values of the entries of a {@link SectionNode}.
  */
 public class EntryContainer {
 
 	private final SectionNode source;
-	@Nullable
-	private final EntryValidator entryValidator;
-	@Nullable
-	private final Map<String, Node> handledNodes;
+	private final @Nullable EntryValidator entryValidator;
+	private final @Nullable Map<String, Collection<Node>> handledNodes;
 	private final List<Node> unhandledNodes;
 
 	EntryContainer(
-		SectionNode source, @Nullable EntryValidator entryValidator, @Nullable Map<String, Node> handledNodes, List<Node> unhandledNodes
+		SectionNode source, @Nullable EntryValidator entryValidator,
+		@Nullable Map<String, Collection<Node>> handledNodes, List<Node> unhandledNodes
 	) {
 		this.source = source;
 		this.entryValidator = entryValidator;
@@ -60,11 +58,72 @@ public List<Node> getUnhandledNodes() {
 		return unhandledNodes;
 	}
 
+	/**
+	 * A method for obtaining a typed entry values.
+	 * @param key The key associated with the entry.
+	 * @param expectedType The class representing the expected type of the entry's values.
+	 * @param useDefaultValue Whether the default value should be used if parsing failed.
+	 * @return The entry's values. May be empty list if the entry is missing or a parsing error occurred.
+	 * @throws RuntimeException If the entry's value is not of the expected type.
+	 */
+	@SuppressWarnings("unchecked")
+	public <E, R extends E> @Unmodifiable List<R> getAll(String key, Class<E> expectedType, boolean useDefaultValue) {
+		List<?> parsed = getAll(key, useDefaultValue);
+		for (Object object : parsed) {
+			if (!expectedType.isInstance(object))
+				throw new RuntimeException("Expected entry with key '" + key + "' to be '" +
+					expectedType + "', but got '" + object.getClass() + "'");
+		}
+		return (List<R>) parsed;
+	}
+
+	/**
+	 * A method for obtaining an entry values with an unknown type.
+	 * @param key The key associated with the entry.
+	 * @param useDefaultValue Whether the default value should be used if parsing failed.
+	 * @return The entry's values. May be empty list if the entry is missing or a parsing error occurred.
+	 */
+	public @Unmodifiable List<Object> getAll(String key, boolean useDefaultValue) {
+		if (entryValidator == null || handledNodes == null)
+			return Collections.emptyList();
+
+		EntryData<?> entryData = entryValidator.getEntryData().stream()
+			.filter(data -> data.getKey().equals(key))
+			.findFirst()
+			.orElse(null);
+		if (entryData == null)
+			return Collections.emptyList();
+
+		Collection<Node> nodes = handledNodes.get(key);
+		if (nodes == null || nodes.isEmpty()) {
+			Object defaultValue = entryData.getDefaultValue();
+			return defaultValue != null
+				? Collections.singletonList(defaultValue)
+				: Collections.emptyList();
+		}
+
+		List<Object> values = new LinkedList<>();
+		ParserInstance parser = ParserInstance.get();
+		Node oldNode = parser.getNode();
+		for (Node node : nodes) {
+			parser.setNode(node);
+			Object value = entryData.getValue(node);
+			if (value == null && useDefaultValue)
+				value = entryData.getDefaultValue();
+			if (value != null)
+				values.add(value);
+		}
+		parser.setNode(oldNode);
+
+		return Collections.unmodifiableList(values);
+	}
+
 	/**
 	 * A method for obtaining a non-null, typed entry value.
 	 * This method should ONLY be called if there is no way the entry could return null.
-	 * In general, this means that the entry has a default value (and 'useDefaultValue' is true). This is because even
-	 *  though an entry may be required, parsing errors may occur that mean no value can be returned.
+	 * In general, this means that the entry has a default value (and 'useDefaultValue' is true).
+	 * This is because even though an entry may be required, parsing errors may occur that
+	 * mean no value can be returned.
 	 * It can also mean that the entry data is simple enough such that it will never return a null value.
 	 * @param key The key associated with the entry.
 	 * @param expectedType The class representing the expected type of the entry's value.
@@ -73,28 +132,29 @@ public List<Node> getUnhandledNodes() {
 	 * @throws RuntimeException If the entry's value is null, or if it is not of the expected type.
 	 */
 	public <E, R extends E> R get(String key, Class<E> expectedType, boolean useDefaultValue) {
-		R value = getOptional(key, expectedType, useDefaultValue);
-		if (value == null)
+		List<R> all = getAll(key, expectedType, useDefaultValue);
+		if (all.isEmpty())
 			throw new RuntimeException("Null value for asserted non-null value");
-		return value;
+		return all.get(0); // always present
 	}
 
 	/**
 	 * A method for obtaining a non-null entry value with an unknown type.
 	 * This method should ONLY be called if there is no way the entry could return null.
-	 * In general, this means that the entry has a default value (and 'useDefaultValue' is true). This is because even
-	 *  though an entry may be required, parsing errors may occur that mean no value can be returned.
+	 * In general, this means that the entry has a default value (and 'useDefaultValue' is true).
+	 * This is because even though an entry may be required, parsing errors may occur that
+	 * mean no value can be returned.
 	 * It can also mean that the entry data is simple enough such that it will never return a null value.
 	 * @param key The key associated with the entry.
 	 * @param useDefaultValue Whether the default value should be used if parsing failed.
 	 * @return The entry's value.
 	 * @throws RuntimeException If the entry's value is null.
 	 */
 	public Object get(String key, boolean useDefaultValue) {
-		Object parsed = getOptional(key, useDefaultValue);
-		if (parsed == null)
+		List<Object> all = getAll(key, useDefaultValue);
+		if (all.isEmpty())
 			throw new RuntimeException("Null value for asserted non-null value");
-		return parsed;
+		return all.get(0); // always present
 	}
 
 	/**
@@ -105,15 +165,9 @@ public Object get(String key, boolean useDefaultValue) {
 	 * @return The entry's value. May be null if the entry is missing or a parsing error occurred.
 	 * @throws RuntimeException If the entry's value is not of the expected type.
 	 */
-	@Nullable
-	@SuppressWarnings("unchecked")
-	public <E, R extends E> R getOptional(String key, Class<E> expectedType, boolean useDefaultValue) {
-		Object parsed = getOptional(key, useDefaultValue);
-		if (parsed == null)
-			return null;
-		if (!expectedType.isInstance(parsed))
-			throw new RuntimeException("Expected entry with key '" + key + "' to be '" + expectedType + "', but got '" + parsed.getClass() + "'");
-		return (R) parsed;
+	public <E, R extends E> @Nullable R getOptional(String key, Class<E> expectedType, boolean useDefaultValue) {
+		List<R> all = getAll(key, expectedType, useDefaultValue);
+		return all.isEmpty() ? null : all.get(0);
 	}
 
 	/**
@@ -122,35 +176,9 @@ public <E, R extends E> R getOptional(String key, Class<E> expectedType, boolean
 	 * @param useDefaultValue Whether the default value should be used if parsing failed.
 	 * @return The entry's value. May be null if the entry is missing or a parsing error occurred.
 	 */
-	@Nullable
-	public Object getOptional(String key, boolean useDefaultValue) {
-		if (entryValidator == null || handledNodes == null)
-			return null;
-
-		EntryData<?> entryData = null;
-		for (EntryData<?> data : entryValidator.getEntryData()) {
-			if (data.getKey().equals(key)) {
-				entryData = data;
-				break;
-			}
-		}
-		if (entryData == null)
-			return null;
-
-		Node node = handledNodes.get(key);
-		if (node == null)
-			return entryData.getDefaultValue();
-
-		// Update ParserInstance node for parsing
-		ParserInstance parser = ParserInstance.get();
-		Node oldNode = parser.getNode();
-		parser.setNode(node);
-		Object value = entryData.getValue(node);
-		if (value == null && useDefaultValue)
-			value = entryData.getDefaultValue();
-		parser.setNode(oldNode);
-
-		return value;
+	public @Nullable Object getOptional(String key, boolean useDefaultValue) {
+		List<Object> all = getAll(key, useDefaultValue);
+		return all.isEmpty() ? null : all.get(0);
 	}
 
 	/**
@@ -159,7 +187,7 @@ public Object getOptional(String key, boolean useDefaultValue) {
 	 * @return true if an entry data with the matching key was used.
 	 */
 	public boolean hasEntry(@NotNull String key) {
-		return handledNodes.containsKey(key);
+		return handledNodes != null && handledNodes.containsKey(key);
 	}
 
 }

src/main/java/org/skriptlang/skript/lang/entry/EntryData.java

@@ -30,11 +30,17 @@ public abstract class EntryData<T> {
 	private final String key;
 	private final @Nullable T defaultValue;
 	private final boolean optional;
+	private final boolean multiple;
 
 	public EntryData(String key, @Nullable T defaultValue, boolean optional) {
+		this(key, defaultValue, optional, false);
+	}
+
+	public EntryData(String key, @Nullable T defaultValue, boolean optional, boolean multiple) {
 		this.key = key;
 		this.defaultValue = defaultValue;
 		this.optional = optional;
+		this.multiple = multiple;
 	}
 
 	/**
@@ -59,6 +65,13 @@ public boolean isOptional() {
 		return optional;
 	}
 
+	/**
+	 * @return Whether this entry data can be included repeatedly within a {@link SectionNode}.
+	 */
+	public boolean supportsMultiple() {
+		return multiple;
+	}
+
 	/**
 	 * Obtains a value from the provided node using the methods of this entry data.
 	 * @param node The node to obtain a value from.