add a text replace expression

src/main/java/ch/njol/skript/expressions/ExprReplace.java

@@ -0,0 +1,144 @@
+package ch.njol.skript.expressions;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.SkriptConfig;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.SyntaxStringBuilder;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+import ch.njol.util.StringUtils;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ExprReplace extends SimpleExpression<String> {
+
+	static {
+		Skript.registerExpression(ExprReplace.class, String.class, ExpressionType.SIMPLE,
+			"replace [(all|every)|first:[the] first] %strings% in %strings% with %string% [case:with case sensitivity]",
+			"replace [(all|every)|first:[the] first] %strings% with %string% in %strings% [case:with case sensitivity]",
+			"(replace [with|using] regex|regex replace) %strings% in %strings% with %string%",
+			"(replace [with|using] regex|regex replace) %strings% with %string% in %strings%");
+	}
+
+	@Override
+	public Class<? extends String> getReturnType() {
+		return String.class;
+	}
+
+	public boolean isSingle() {
+		return false;
+	}
+	public boolean canBeSingle() {
+		return true;
+	}
+
+	private Expression<String> needleExpr;
+	private Expression<String> haystackExpr;
+	private Expression<String> replacementExpr;
+
+	private boolean isRegex;
+	private boolean isFirst;
+	private boolean isCaseSensitive = false;
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public boolean init(Expression<?>[] expr, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+
+		if (matchedPattern == 0 || matchedPattern == 2) {
+			haystackExpr = (Expression<String>) expr[1];
+			replacementExpr = (Expression<String>) expr[2];
+		} else {
+			haystackExpr = (Expression<String>) expr[2];
+			replacementExpr = (Expression<String>) expr[1];
+		}
+
+		needleExpr = (Expression<String>) expr[0];
+
+		isRegex = matchedPattern == 2 || matchedPattern == 3;
+		isFirst = parseResult.hasTag("first");
+
+		if (SkriptConfig.caseSensitive.value() || parseResult.hasTag("case")) {
+			isCaseSensitive = true;
+		}
+		return true;
+	}
+
+	@Override
+	@Nullable
+	protected String[] get(Event event) {
+		String replacement = replacementExpr.getSingle(event);
+		String[] needles = needleExpr.getAll(event);
+		String[] haystacks = haystackExpr.getAll(event);
+
+		if (replacement == null) {
+			return haystacks;
+		}
+
+		List<String> result = new ArrayList<>(haystacks.length);
+
+		if (isRegex) {
+			List<Pattern> patterns = new ArrayList<>(needles.length);
+			for (String needle : needles) {
+				try { // Pre compile regex for use with multiple haystacks
+					patterns.add(Pattern.compile(needle));
+				} catch (Exception ignored) {
+				}
+			}
+
+			for (String haystack : haystacks) {
+				for (Pattern pattern : patterns) {
+					Matcher matcher = pattern.matcher(haystack);
+					if (isFirst) {
+						haystack = matcher.replaceFirst(replacement);
+					} else {
+						haystack = matcher.replaceAll(replacement);
+					}
+				}
+				result.add(haystack);
+			}
+		} else {
+			for (String haystack : haystacks) {
+				for (String needle : needles) {
+					if (isFirst) {
+						haystack = StringUtils.replaceFirst(haystack, needle, replacement, isCaseSensitive);
+					} else {
+						haystack = StringUtils.replace(haystack, needle, replacement, isCaseSensitive);
+					}
+				}
+				result.add(haystack);
+			}
+		}
+
+		return result.toArray(new String[0]);
+
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
+
+		builder.append("replace");
+
+		if (isFirst) {
+			builder.append("first");
+		}
+		if (isRegex) {
+			builder.append("regex");
+		}
+
+		builder.append(needleExpr, "in", haystackExpr, "with", replacementExpr);
+
+		if (isCaseSensitive) {
+			builder.append("with case sensitivity");
+		}
+
+		return builder.toString();
+	}
+}

src/test/skript/tests/syntaxes/expressions/ExprReplace.sk

@@ -0,0 +1,24 @@
+test "replace expression":
+
+	assert replace "hello" in "hello this is a test" with "goodbye" is "goodbye this is a test" with "replace"
+
+	assert regex replace "[lsa]" in "hello this is a test" with "!" is "he!!o thi! i! ! te!t" with "regex replace"
+
+
+	set {_test::*} to "hello", "this", "is", "a", "test"
+
+	assert replace "hello" in {_test::*} with "goodbye" is ("goodbye", "this", "is", "a", "test") with "replace list"
+
+	assert regex replace "[lsa]" in {_test::*} with "!" is ("he!!o", "thi!", "i!", "!", "te!t") with "regex replace list"
+
+
+	assert replace "hello", "test" in {_test::*} with "!" is ("!", "this", "is", "a", "!") with "multi replace list"
+
+	assert regex replace "[hl]", "[ts]" in {_test::*} with "!" is ("!e!!o", "!!i!", "i!", "a", "!e!!") with "multi regex replace list"
+
+
+	assert replace "hello", "test" in "hello this is a test" with "!" is "! this is a !" with "multi replace"
+
+	assert regex replace "[hl]", "[ts]" in "hello this is a test" with "!" is "!e!!o !!i! i! a !e!!" with "multi regex replace"
+
+	assert replace "A" in "aaAAAbbB" with "!" with case sensitivity is "aa!!!bbB" with "case sensitivity"