Add case sensitivity support to ExprIndicesOf & Cleanup (#7997)

Burbulinis · web-flow · commit c9b22223a9db · 2025-07-08T10:30:45.000-04:00
diff --git a/src/main/java/ch/njol/skript/expressions/ExprIndicesOfValue.java b/src/main/java/ch/njol/skript/expressions/ExprIndicesOfValue.java
@@ -1,24 +1,26 @@
 package ch.njol.skript.expressions;
 
+import ch.njol.skript.SkriptConfig;
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Example;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
 import ch.njol.skript.lang.*;
 import ch.njol.skript.lang.simplification.SimplifiedLiteral;
 import ch.njol.skript.util.LiteralUtils;
+import ch.njol.util.StringUtils;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
 
 import ch.njol.skript.Skript;
-import ch.njol.skript.doc.Description;
-import ch.njol.skript.doc.Examples;
-import ch.njol.skript.doc.Name;
-import ch.njol.skript.doc.Since;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.lang.util.SimpleExpression;
 import ch.njol.util.Kleenean;
 
 import java.lang.reflect.Array;
 import java.util.*;
 
-@Name("Indices Of")
+@Name("Indices of Value")
 @Description({
 	"Get the first, last or all positions of a character (or text) in another text using "
 		+ "'positions of %text% in %text%'. Nothing is returned when the value does not occur in the text. "
@@ -30,45 +32,51 @@
 		+ "and will return the string indices of the given value. "
 		+ "Positions can be used with any list and will return "
 		+ "the numerical position of the value in the list, counting up from 1. "
-		+ "As well, nothing is returned if the value is not found in the list."
-})
-@Examples({
-	"set {_first} to the first position of \"@\" in the text argument",
-	"if {_s} contains \"abc\":",
-		"\tset {_s} to the first (position of \"abc\" in {_s} + 3) characters of {_s}",
-		"\t# removes everything after the first \"abc\" from {_s}",
-	"",
-	"set {_list::*} to 1, 2, 3, 1, 2, 3",
-	"set {_indices::*} to indices of the value 1 in {_list::*}",
-	"# {_indices::*} is now \"1\" and \"4\"",
-	"",
-	"set {_indices::*} to all indices of the value 2 in {_list::*}",
-	"# {_indices::*} is now \"2\" and \"5\"",
+		+ "Additionally, nothing is returned if the value is not found in the list.",
 	"",
-	"set {_positions::*} to all positions of the value 3 in {_list::*}",
-	"# {_positions::*} is now 3 and 6",
-	"",
-	"set {_otherlist::bar} to 100",
-	"set {_otherlist::hello} to \"hi\"",
-	"set {_otherlist::burb} to 100",
-	"set {_otherlist::tud} to \"hi\"",
-	"set {_otherlist::foo} to 100",
-	"",
-	"set {_indices::*} to the first index of the value 100 in {_otherlist::*}",
-	"# {_indices::*} is now \"bar\"",
-	"set {_indices::*} to the last index of the value 100 in {_otherlist::*}",
-	"# {_indices::*} is now \"foo\"",
-	"",
-	"set {_positions::*} to all positions of the value 100 in {_otherlist::*}",
-	"# {_positions::*} is now 1, 3 and 5",
-	"set {_positions::*} to all positions of the value \"hi\" in {_otherlist::*}",
-	"# {_positions::*} is now 2 and 4"
+	"Whether string comparison is case-sensitive or not can be configured in Skript's config file.",
 })
+@Example("""
+	set {_first} to the first position of "@" in the text argument
+	if {_s} contains "abc":
+		set {_s} to the first (position of "abc" in {_s} + 3) characters of {_s}
+		# removes everything after the first "abc" from {_s}
+	""")
+@Example("""
+	set {_list::*} to 1, 2, 3, 1, 2, 3
+	set {_indices::*} to indices of the value 1 in {_list::*}
+	# {_indices::*} is now "1" and "4"
+
+	set {_indices::*} to all indices of the value 2 in {_list::*}
+	# {_indices::*} is now "2" and "5"
+
+	set {_positions::*} to all positions of the value 3 in {_list::*}
+	# {_positions::*} is now 3 and 6
+	""")
+@Example("""
+	set {_otherlist::bar} to 100
+	set {_otherlist::hello} to "hi"
+	set {_otherlist::burb} to 100
+	set {_otherlist::tud} to "hi"
+	set {_otherlist::foo} to 100
+
+	set {_indices::*} to the first index of the value 100 in {_otherlist::*}
+	# {_indices::*} is now "bar"
+
+	set {_indices::*} to the last index of the value 100 in {_otherlist::*}
+	# {_indices::*} is now "foo"
+
+	set {_positions::*} to all positions of the value 100 in {_otherlist::*}
+	# {_positions::*} is now 1, 3 and 5
+
+	set {_positions::*} to all positions of the value "hi" in {_otherlist::*}
+	# {_positions::*} is now 2 and 4
+	""")
 @Since("2.1, 2.12 (indices, positions of list)")
-public class ExprIndicesOf extends SimpleExpression<Object> {
+public class ExprIndicesOfValue extends SimpleExpression<Object> {
 
 	static {
-		Skript.registerExpression(ExprIndicesOf.class, Object.class, ExpressionType.COMBINED,
+		Skript.registerExpression(ExprIndicesOfValue.class, Object.class, ExpressionType.COMBINED,
 			"[the] [1:first|2:last|3:all] (position[mult:s]|mult:indices|index[mult:es]) of [[the] value] %string% in %string%",
 			"[the] [1:first|2:last|3:all] position[mult:s] of [[the] value] %object% in %~objects%",
 			"[the] [1:first|2:last|3:all] (mult:indices|index[mult:es]) of [[the] value] %object% in %~objects%"
@@ -129,27 +137,31 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 	}
 
 	private Long[] getStringPositions(String haystack, String needle) {
+		boolean caseSensitive = SkriptConfig.caseSensitive.value();
+
 		List<Long> positions = new ArrayList<>();
-		long position = haystack.indexOf(needle);
+		long position = StringUtils.indexOf(haystack, needle, caseSensitive);
 
 		if (position == -1)
 			return new Long[0];
 
 		if (indexType == IndexType.ALL) {
 			while (position != -1) {
 				positions.add(position + 1);
-				position = haystack.indexOf(needle, (int) position + 1);
+				position = StringUtils.indexOf(haystack, needle, (int) position + 1, caseSensitive);
 			}
-			return positions.toArray(new Long[0]);
+			return positions.toArray(Long[]::new);
 		}
 
 		if (indexType == IndexType.LAST)
-			position = haystack.lastIndexOf(needle);
+			position = StringUtils.lastIndexOf(haystack, needle, caseSensitive);
 
 		return new Long[]{position + 1};
 	}
 
 	private Long[] getListPositions(Expression<?> list, Object value, Event event) {
+		boolean caseSensitive = SkriptConfig.caseSensitive.value();
+
 		Iterator<?> iterator = list.iterator(event);
 		if (iterator == null)
 			return new Long[0];
@@ -160,7 +172,7 @@ private Long[] getListPositions(Expression<?> list, Object value, Event event) {
 		while (iterator.hasNext()) {
 			position++;
 
-			if (!iterator.next().equals(value))
+			if (!equals(iterator.next(), value, caseSensitive))
 				continue;
 
 			if (indexType == IndexType.FIRST)
@@ -176,6 +188,8 @@ private Long[] getListPositions(Expression<?> list, Object value, Event event) {
 	}
 
 	private String[] getIndices(KeyProviderExpression<?> expression, Object value, Event event) {
+		boolean caseSensitive = SkriptConfig.caseSensitive.value();
+
 		Iterator<? extends KeyedValue<?>> iterator = expression.keyedIterator(event);
 		if (iterator == null)
 			return new String[0];
@@ -185,7 +199,7 @@ private String[] getIndices(KeyProviderExpression<?> expression, Object value, E
 		while (iterator.hasNext()) {
 			var keyedValue = iterator.next();
 
-			if (!keyedValue.value().equals(value))
+			if (!equals(keyedValue.value(), value, caseSensitive))
 				continue;
 			if (indexType == IndexType.FIRST)
 				return new String[]{keyedValue.key()};
@@ -202,6 +216,12 @@ private String[] getIndices(KeyProviderExpression<?> expression, Object value, E
 		return indices.toArray(String[]::new);
 	}
 
+	private boolean equals(Object key, Object value, boolean caseSensitive) {
+		if (key instanceof String keyString && value instanceof String valueString)
+			return StringUtils.equals(keyString, valueString, caseSensitive);
+		return key.equals(value);
+	}
+
 	@Override
 	public boolean isSingle() {
 		return indexType == IndexType.FIRST || indexType == IndexType.LAST;
diff --git a/src/main/java/ch/njol/util/StringUtils.java b/src/main/java/ch/njol/util/StringUtils.java
@@ -174,6 +174,58 @@ private static int indexOf(final char[] s, final int start, final char... cs) {
 		return -1;
 	}
 
+	/**
+	 * Returns the index of the first occurrence of the needle in the haystack.
+	 * @param haystack the string to search in
+	 * @param needle the string to search for
+	 * @param caseSensitive whether the search should be case-sensitive
+	 * @return the index of the first occurrence of the needle in the haystack, or -1 if not found
+	 */
+	public static int indexOf(String haystack, String needle, boolean caseSensitive) {
+		if (caseSensitive) {
+			haystack = haystack.toLowerCase(Locale.ENGLISH);
+			needle = needle.toLowerCase(Locale.ENGLISH);
+		}
+
+		return haystack.indexOf(needle);
+	}
+
+	/**
+	 * Returns the index of the first occurrence of the needle in the haystack, starting from the specified index.
+	 * @param haystack the string to search in
+	 * @param needle the string to search for
+	 * @param fromIndex the index to start searching from
+	 * @param caseSensitive whether the search should be case-sensitive
+	 * @return the index of the first occurrence of the needle in the haystack, or -1 if not found
+	 */
+	public static int indexOf(String haystack, String needle, int fromIndex, boolean caseSensitive) {
+		if (fromIndex < 0 || fromIndex >= haystack.length())
+			return -1;
+
+		if (caseSensitive) {
+			haystack = haystack.toLowerCase(Locale.ENGLISH);
+			needle = needle.toLowerCase(Locale.ENGLISH);
+		}
+
+		return haystack.indexOf(needle, fromIndex);
+	}
+
+	/**
+	 * Returns the index of the last occurrence of the needle in the haystack.
+	 * @param haystack the string to search in
+	 * @param needle the string to search for
+	 * @param caseSensitive whether the search should be case-sensitive
+	 * @return the index of the last occurrence of the needle in the haystack, or -1 if not found
+	 */
+	public static int lastIndexOf(String haystack, String needle, boolean caseSensitive) {
+		if (caseSensitive) {
+			haystack = haystack.toLowerCase(Locale.ENGLISH);
+			needle = needle.toLowerCase(Locale.ENGLISH);
+		}
+
+		return haystack.lastIndexOf(needle);
+	}
+
 	/**
 	 * Shorthand for <tt>{@link #numberAt(CharSequence, int, boolean) numberAt}(s, index, true)</tt>
 	 *
diff --git a/src/main/resources/config.sk b/src/main/resources/config.sk
@@ -150,7 +150,7 @@ maximum target block distance: 100
 
 case sensitive: false
 # Whether Skript's functions should be case sensitive or not.
-# This e.g. applies to the effect 'replace' and the conditions 'contains' and 'is/is not'.
+# This e.g. applies to the effect 'replace', expression 'indices of value' and the conditions 'contains' and 'is/is not'.
 # Variable names are case-insensitive irrespective of this setting.
 
 case-insensitive variables: true
diff --git a/src/test/skript/tests/syntaxes/expressions/ExprIndicesOfValue.sk b/src/test/skript/tests/syntaxes/expressions/ExprIndicesOfValue.sk
