From 35a52fe96125b18d2539801cb9fcc4efe035ec61 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Sun, 4 Feb 2024 14:33:17 -0600 Subject: [PATCH 01/23] Add CondChange --- .../btk5h/skriptmirror/skript/CondChange.java | 112 ++++++++++++++++++ .../com/btk5h/skriptmirror/skript/Types.java | 26 ++++ 2 files changed, 138 insertions(+) create mode 100644 src/main/java/com/btk5h/skriptmirror/skript/CondChange.java diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java new file mode 100644 index 0000000..28a2d48 --- /dev/null +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -0,0 +1,112 @@ +package com.btk5h.skriptmirror.skript; + +import ch.njol.skript.Skript; +import ch.njol.skript.classes.Changer.ChangeMode; +import ch.njol.skript.classes.ClassInfo; +import ch.njol.skript.lang.Condition; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.util.Patterns; +import ch.njol.util.Kleenean; +import org.bukkit.event.Event; +import org.eclipse.jdt.annotation.Nullable; + +import java.util.Collection; +import java.util.Set; +import java.util.stream.Collectors; + + +public class CondChange extends Condition { + + private static final Patterns PATTERNS = new Patterns<>(new Object[][] { + {"%classinfos% can be added to %expressions%", ChangeMode.ADD}, + {"%expressions% can be set to %classinfos%", ChangeMode.SET}, + {"%classinfos% can be removed from %expressions%", ChangeMode.REMOVE}, + {"all %classinfos% can be removed from %expressions%", ChangeMode.REMOVE_ALL}, + {"%expressions% can be deleted", ChangeMode.DELETE}, + {"%expressions% can be reset", ChangeMode.RESET} + }); + + static { + Skript.registerCondition(CondChange.class, PATTERNS.getPatterns()); + } + + private ChangeMode desiredChangeMode; + private Expression> desiredTypes; + private Expression> expressions; + + @SuppressWarnings("unchecked") + @Override + public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + desiredChangeMode = PATTERNS.getInfo(matchedPattern); + switch (desiredChangeMode) { + case ADD: + case REMOVE: + case REMOVE_ALL: + desiredTypes = (Expression>) exprs[0]; + expressions = (Expression>) exprs[1]; + break; + case SET: + expressions = (Expression>) exprs[0]; + desiredTypes = (Expression>) exprs[1]; + break; + case RESET: + case DELETE: + expressions = (Expression>) exprs[0]; + } + return true; + } + + @Override + public boolean check(Event event) { + if (desiredChangeMode == ChangeMode.DELETE || desiredChangeMode == ChangeMode.RESET) { + //noinspection ConstantValue + return expressions.check(event, expr -> expr.acceptChange(desiredChangeMode) != null); + } + return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, getDesiredTypes(event))); + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + String expressionsString = expressions.toString(event, debug); + String desiredTypesString = desiredTypes == null ? null : desiredTypes.toString(event, debug); + switch (desiredChangeMode) { + case ADD: + return desiredTypesString + " can be added to " + expressionsString; + case SET: + return expressionsString + " can be set to " + desiredTypesString; + case RESET: + return expressionsString + " can be reset"; + case DELETE: + return expressionsString + " can be deleted"; + case REMOVE: + return desiredTypesString + " can be removed from " + expressionsString; + case REMOVE_ALL: + return "all " + desiredTypesString + " can be removed from " + expressionsString; + default: + throw new IllegalStateException(); + } + } + + private boolean acceptsChange(Expression expression, ChangeMode desiredChangeMode, Collection> desiredTypes) { + Class[] acceptableTypes = expression.acceptChange(desiredChangeMode); + for (Class desiredType : desiredTypes) { + boolean multipleDesired = desiredType.isArray(); + if (multipleDesired) + desiredType = desiredType.getComponentType(); + for (Class acceptableType : acceptableTypes) { + if (acceptableType.isArray() + && acceptableType.getComponentType().isAssignableFrom(desiredType)) { + return true; + } else if (!multipleDesired && acceptableType.isAssignableFrom(desiredType)) + return true; + } + } + return false; + } + + private Set> getDesiredTypes(Event event) { + return desiredTypes.stream(event).map(ClassInfo::getC).collect(Collectors.toSet()); + } + +} diff --git a/src/main/java/com/btk5h/skriptmirror/skript/Types.java b/src/main/java/com/btk5h/skriptmirror/skript/Types.java index 8110068..608c9d6 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/Types.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/Types.java @@ -3,6 +3,7 @@ import ch.njol.skript.classes.ClassInfo; import ch.njol.skript.classes.Parser; import ch.njol.skript.classes.Serializer; +import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.ParseContext; import ch.njol.skript.registrations.Classes; import ch.njol.yggdrasil.Fields; @@ -214,6 +215,31 @@ public String getVariableNamePattern() { Classes.registerClass(new ClassInfo<>(Section.class, "section") .user("sections?") ); + + Classes.registerClass(new ClassInfo<>(Expression.class, "expression") + .user("expressions?") + .parser(new Parser>() { + @Override + public boolean canParse(ParseContext context) { + return false; + } + + @Override + public String getDebugMessage(Expression expression) { + return expression.toString(null, true); + } + + @Override + public String toString(Expression expression, int i) { + return expression.toString(null, false); + } + + @Override + public String toVariableNameString(Expression expression) { + return toString(expression, 0); + } + })); + } } From c232cde8ac2bea8c8f04c458987e07a908c333db Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Sun, 4 Feb 2024 14:33:17 -0600 Subject: [PATCH 02/23] Add CondChange --- .../btk5h/skriptmirror/skript/CondChange.java | 112 ++++++++++++++++++ .../com/btk5h/skriptmirror/skript/Types.java | 26 ++++ 2 files changed, 138 insertions(+) create mode 100644 src/main/java/com/btk5h/skriptmirror/skript/CondChange.java diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java new file mode 100644 index 0000000..28a2d48 --- /dev/null +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -0,0 +1,112 @@ +package com.btk5h.skriptmirror.skript; + +import ch.njol.skript.Skript; +import ch.njol.skript.classes.Changer.ChangeMode; +import ch.njol.skript.classes.ClassInfo; +import ch.njol.skript.lang.Condition; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.util.Patterns; +import ch.njol.util.Kleenean; +import org.bukkit.event.Event; +import org.eclipse.jdt.annotation.Nullable; + +import java.util.Collection; +import java.util.Set; +import java.util.stream.Collectors; + + +public class CondChange extends Condition { + + private static final Patterns PATTERNS = new Patterns<>(new Object[][] { + {"%classinfos% can be added to %expressions%", ChangeMode.ADD}, + {"%expressions% can be set to %classinfos%", ChangeMode.SET}, + {"%classinfos% can be removed from %expressions%", ChangeMode.REMOVE}, + {"all %classinfos% can be removed from %expressions%", ChangeMode.REMOVE_ALL}, + {"%expressions% can be deleted", ChangeMode.DELETE}, + {"%expressions% can be reset", ChangeMode.RESET} + }); + + static { + Skript.registerCondition(CondChange.class, PATTERNS.getPatterns()); + } + + private ChangeMode desiredChangeMode; + private Expression> desiredTypes; + private Expression> expressions; + + @SuppressWarnings("unchecked") + @Override + public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + desiredChangeMode = PATTERNS.getInfo(matchedPattern); + switch (desiredChangeMode) { + case ADD: + case REMOVE: + case REMOVE_ALL: + desiredTypes = (Expression>) exprs[0]; + expressions = (Expression>) exprs[1]; + break; + case SET: + expressions = (Expression>) exprs[0]; + desiredTypes = (Expression>) exprs[1]; + break; + case RESET: + case DELETE: + expressions = (Expression>) exprs[0]; + } + return true; + } + + @Override + public boolean check(Event event) { + if (desiredChangeMode == ChangeMode.DELETE || desiredChangeMode == ChangeMode.RESET) { + //noinspection ConstantValue + return expressions.check(event, expr -> expr.acceptChange(desiredChangeMode) != null); + } + return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, getDesiredTypes(event))); + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + String expressionsString = expressions.toString(event, debug); + String desiredTypesString = desiredTypes == null ? null : desiredTypes.toString(event, debug); + switch (desiredChangeMode) { + case ADD: + return desiredTypesString + " can be added to " + expressionsString; + case SET: + return expressionsString + " can be set to " + desiredTypesString; + case RESET: + return expressionsString + " can be reset"; + case DELETE: + return expressionsString + " can be deleted"; + case REMOVE: + return desiredTypesString + " can be removed from " + expressionsString; + case REMOVE_ALL: + return "all " + desiredTypesString + " can be removed from " + expressionsString; + default: + throw new IllegalStateException(); + } + } + + private boolean acceptsChange(Expression expression, ChangeMode desiredChangeMode, Collection> desiredTypes) { + Class[] acceptableTypes = expression.acceptChange(desiredChangeMode); + for (Class desiredType : desiredTypes) { + boolean multipleDesired = desiredType.isArray(); + if (multipleDesired) + desiredType = desiredType.getComponentType(); + for (Class acceptableType : acceptableTypes) { + if (acceptableType.isArray() + && acceptableType.getComponentType().isAssignableFrom(desiredType)) { + return true; + } else if (!multipleDesired && acceptableType.isAssignableFrom(desiredType)) + return true; + } + } + return false; + } + + private Set> getDesiredTypes(Event event) { + return desiredTypes.stream(event).map(ClassInfo::getC).collect(Collectors.toSet()); + } + +} diff --git a/src/main/java/com/btk5h/skriptmirror/skript/Types.java b/src/main/java/com/btk5h/skriptmirror/skript/Types.java index 8110068..608c9d6 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/Types.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/Types.java @@ -3,6 +3,7 @@ import ch.njol.skript.classes.ClassInfo; import ch.njol.skript.classes.Parser; import ch.njol.skript.classes.Serializer; +import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.ParseContext; import ch.njol.skript.registrations.Classes; import ch.njol.yggdrasil.Fields; @@ -214,6 +215,31 @@ public String getVariableNamePattern() { Classes.registerClass(new ClassInfo<>(Section.class, "section") .user("sections?") ); + + Classes.registerClass(new ClassInfo<>(Expression.class, "expression") + .user("expressions?") + .parser(new Parser>() { + @Override + public boolean canParse(ParseContext context) { + return false; + } + + @Override + public String getDebugMessage(Expression expression) { + return expression.toString(null, true); + } + + @Override + public String toString(Expression expression, int i) { + return expression.toString(null, false); + } + + @Override + public String toVariableNameString(Expression expression) { + return toString(expression, 0); + } + })); + } } From 3d6168899d4c1cd94ab1ae32ba75845d019453a7 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 7 Feb 2024 18:36:42 -0600 Subject: [PATCH 03/23] Try adding initial tests --- src/test/scripts/CondChange.sk | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 src/test/scripts/CondChange.sk diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk new file mode 100644 index 0000000..c915883 --- /dev/null +++ b/src/test/scripts/CondChange.sk @@ -0,0 +1,2 @@ +test "CondChange": + assert (raw {_v}) can be set to a string with "a variable can be set a string" From a2ccb488ce87d638b1b6eca5ef7e4340ab77188a Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 14 Feb 2024 22:04:23 -0600 Subject: [PATCH 04/23] Add some more testing --- .github/workflows/gradle.yml | 2 +- .../btk5h/skriptmirror/skript/CondChange.java | 55 +++++++++---------- .../btk5h/skriptmirror/util/SkriptUtil.java | 2 +- src/test/scripts/CondChange.sk | 22 +++++++- 4 files changed, 49 insertions(+), 32 deletions(-) diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml index aba4c91..e78392b 100644 --- a/.github/workflows/gradle.yml +++ b/.github/workflows/gradle.yml @@ -39,5 +39,5 @@ jobs: uses: SkriptLang/skript-test-action@v1.0 with: test_script_directory: src/test/scripts - skript_repo_ref: 2.8.2 + skript_repo_ref: dev/patch extra_plugins_directory: extra-plugins/ diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index 28a2d48..df7b6df 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -6,23 +6,21 @@ import ch.njol.skript.lang.Condition; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.UnparsedLiteral; import ch.njol.skript.util.Patterns; +import ch.njol.skript.util.Utils; import ch.njol.util.Kleenean; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; -import java.util.Collection; -import java.util.Set; -import java.util.stream.Collectors; - public class CondChange extends Condition { private static final Patterns PATTERNS = new Patterns<>(new Object[][] { - {"%classinfos% can be added to %expressions%", ChangeMode.ADD}, - {"%expressions% can be set to %classinfos%", ChangeMode.SET}, - {"%classinfos% can be removed from %expressions%", ChangeMode.REMOVE}, - {"all %classinfos% can be removed from %expressions%", ChangeMode.REMOVE_ALL}, + {"%classinfo% can be added to %expressions%", ChangeMode.ADD}, + {"%expressions% can be set to %classinfo%", ChangeMode.SET}, + {"%classinfo% can be removed from %expressions%", ChangeMode.REMOVE}, + {"all %classinfo% can be removed from %expressions%", ChangeMode.REMOVE_ALL}, {"%expressions% can be deleted", ChangeMode.DELETE}, {"%expressions% can be reset", ChangeMode.RESET} }); @@ -32,44 +30,50 @@ public class CondChange extends Condition { } private ChangeMode desiredChangeMode; - private Expression> desiredTypes; + private boolean typeIsPlural; + private Expression> desiredType; private Expression> expressions; @SuppressWarnings("unchecked") @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { desiredChangeMode = PATTERNS.getInfo(matchedPattern); + Expression desiredType = null; switch (desiredChangeMode) { case ADD: case REMOVE: case REMOVE_ALL: - desiredTypes = (Expression>) exprs[0]; + desiredType = exprs[0]; expressions = (Expression>) exprs[1]; break; case SET: expressions = (Expression>) exprs[0]; - desiredTypes = (Expression>) exprs[1]; + desiredType = exprs[1]; break; case RESET: case DELETE: expressions = (Expression>) exprs[0]; } + if (desiredType instanceof UnparsedLiteral) { + UnparsedLiteral unparsedDesiredType = (UnparsedLiteral) desiredType; + typeIsPlural = Utils.getEnglishPlural(unparsedDesiredType.getData()).getSecond(); + } + this.desiredType = (Expression>) desiredType; return true; } @Override public boolean check(Event event) { - if (desiredChangeMode == ChangeMode.DELETE || desiredChangeMode == ChangeMode.RESET) { - //noinspection ConstantValue - return expressions.check(event, expr -> expr.acceptChange(desiredChangeMode) != null); - } - return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, getDesiredTypes(event))); + ClassInfo desiredType = this.desiredType.getSingle(event); + if (desiredType == null) + return false; + return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), typeIsPlural)); } @Override public String toString(@Nullable Event event, boolean debug) { String expressionsString = expressions.toString(event, debug); - String desiredTypesString = desiredTypes == null ? null : desiredTypes.toString(event, debug); + String desiredTypesString = desiredType == null ? null : desiredType.toString(event, debug); switch (desiredChangeMode) { case ADD: return desiredTypesString + " can be added to " + expressionsString; @@ -88,25 +92,20 @@ public String toString(@Nullable Event event, boolean debug) { } } - private boolean acceptsChange(Expression expression, ChangeMode desiredChangeMode, Collection> desiredTypes) { + private boolean acceptsChange(Expression expression, ChangeMode desiredChangeMode, Class desiredType, boolean typeIsPlural) { Class[] acceptableTypes = expression.acceptChange(desiredChangeMode); - for (Class desiredType : desiredTypes) { - boolean multipleDesired = desiredType.isArray(); - if (multipleDesired) - desiredType = desiredType.getComponentType(); + //noinspection ConstantValue + if (acceptableTypes != null) { for (Class acceptableType : acceptableTypes) { if (acceptableType.isArray() && acceptableType.getComponentType().isAssignableFrom(desiredType)) { return true; - } else if (!multipleDesired && acceptableType.isAssignableFrom(desiredType)) + } else if (!typeIsPlural && acceptableType.isAssignableFrom(desiredType)) return true; } + return false; } - return false; - } - - private Set> getDesiredTypes(Event event) { - return desiredTypes.stream(event).map(ClassInfo::getC).collect(Collectors.toSet()); + return desiredChangeMode == ChangeMode.DELETE || desiredChangeMode == ChangeMode.RESET; } } diff --git a/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java b/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java index 17df4f7..1b9d167 100644 --- a/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java +++ b/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java @@ -143,7 +143,7 @@ public static ClassInfo getUserClassInfo(String name) { } /** - * @return the pair of the {@link ClassInfo} in the given string, and whether is is singular. + * @return the pair of the {@link ClassInfo} in the given string, and whether it is singular. */ public static NonNullPair, Boolean> getUserClassInfoAndPlural(String name) { NonNullPair wordData = Utils.getEnglishPlural(name); diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index c915883..03ce4af 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -1,2 +1,20 @@ -test "CondChange": - assert (raw {_v}) can be set to a string with "a variable can be set a string" +test "CondChange - set": + assert raw ({_v}) can be set to a string with "a variable should be settable to a string" + assert raw (location of {_v}) can't be set to a string with "the location expression shouldn't be settable to a string" + assert raw (name of {_v}) can be set to a string with "the name expression should be settable to a string" + assert raw (name of {_v}) can't be set to an integer with "the name expression shouldn't be settable to an integer" + assert raw (name of {_v}) can't be set to strings with "the name expression shouldn't be settable to multiple strings" + assert raw ({_v}) can be set to strings with "a variable should be settable to multiple strings" + +test "CondChange - reset": + assert raw (uppercase "") can't be reset with "the uppercase expression shouldn't be resettable" + assert raw (portal cooldown of {_v}) can be reset with "the portal cooldown expression should be resettable" + +test "CondChange - delete": + assert raw ({_v}) can be deleted with "a variable should be deletable" + assert raw (uppercase "") can't be deleted with "the uppercase expression shouldn't be deletable" + +test "CondChange - add": + assert an integer can be added to raw ({_v}) with "an integer should be addable to a variable" + assert integers can be added to raw ({_v}) with "multiple integers should be addable to a variable" + assert a string can't be added to raw (all players) with "a string shouldn't be addable to all players" From f3d7cdabf681137fa861bf8932223ee2d790c489 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 14 Feb 2024 22:41:16 -0600 Subject: [PATCH 05/23] Try to fix exception --- .../btk5h/skriptmirror/skript/CondChange.java | 21 +++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index df7b6df..95b86b0 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -10,6 +10,7 @@ import ch.njol.skript.util.Patterns; import ch.njol.skript.util.Utils; import ch.njol.util.Kleenean; +import ch.njol.util.NonNullPair; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; @@ -18,11 +19,17 @@ public class CondChange extends Condition { private static final Patterns PATTERNS = new Patterns<>(new Object[][] { {"%classinfo% can be added to %expressions%", ChangeMode.ADD}, + {"%classinfo% (can't|cannot) be added to %expressions%", ChangeMode.ADD}, {"%expressions% can be set to %classinfo%", ChangeMode.SET}, + {"%expressions% (can't|cannot) be set to %classinfo%", ChangeMode.SET}, {"%classinfo% can be removed from %expressions%", ChangeMode.REMOVE}, + {"%classinfo% (can't|cannot) be removed from %expressions%", ChangeMode.REMOVE}, {"all %classinfo% can be removed from %expressions%", ChangeMode.REMOVE_ALL}, + {"all %classinfo% (can't|cannot) be removed from %expressions%", ChangeMode.REMOVE_ALL}, {"%expressions% can be deleted", ChangeMode.DELETE}, - {"%expressions% can be reset", ChangeMode.RESET} + {"%expressions% (can't|cannot) be deleted", ChangeMode.DELETE}, + {"%expressions% can be reset", ChangeMode.RESET}, + {"%expressions% (can't|cannot) be reset", ChangeMode.RESET} }); static { @@ -37,6 +44,7 @@ public class CondChange extends Condition { @SuppressWarnings("unchecked") @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + setNegated((matchedPattern % 2) != 0); desiredChangeMode = PATTERNS.getInfo(matchedPattern); Expression desiredType = null; switch (desiredChangeMode) { @@ -56,6 +64,9 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye } if (desiredType instanceof UnparsedLiteral) { UnparsedLiteral unparsedDesiredType = (UnparsedLiteral) desiredType; + desiredType = unparsedDesiredType.getConvertedExpression(ClassInfo.class); + if (desiredType == null) + return false; typeIsPlural = Utils.getEnglishPlural(unparsedDesiredType.getData()).getSecond(); } this.desiredType = (Expression>) desiredType; @@ -64,10 +75,13 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye @Override public boolean check(Event event) { + if (desiredChangeMode == ChangeMode.DELETE || desiredChangeMode == ChangeMode.RESET) + //noinspection ConstantValue + return expressions.check(event, expressions -> expressions.acceptChange(desiredChangeMode) != null, isNegated()); ClassInfo desiredType = this.desiredType.getSingle(event); if (desiredType == null) return false; - return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), typeIsPlural)); + return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), typeIsPlural), isNegated()); } @Override @@ -103,9 +117,8 @@ private boolean acceptsChange(Expression expression, ChangeMode desiredChange } else if (!typeIsPlural && acceptableType.isAssignableFrom(desiredType)) return true; } - return false; } - return desiredChangeMode == ChangeMode.DELETE || desiredChangeMode == ChangeMode.RESET; + return false; } } From bd02300612ab77c8919e00883a29e9dc5d933e2c Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 14 Feb 2024 22:48:04 -0600 Subject: [PATCH 06/23] Try to fix set test --- src/main/java/com/btk5h/skriptmirror/skript/CondChange.java | 1 - src/test/scripts/CondChange.sk | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index 95b86b0..35967c8 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -10,7 +10,6 @@ import ch.njol.skript.util.Patterns; import ch.njol.skript.util.Utils; import ch.njol.util.Kleenean; -import ch.njol.util.NonNullPair; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index 03ce4af..7272ab9 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -1,6 +1,6 @@ test "CondChange - set": assert raw ({_v}) can be set to a string with "a variable should be settable to a string" - assert raw (location of {_v}) can't be set to a string with "the location expression shouldn't be settable to a string" + assert raw (location of (random player out of all players)) can't be set to a string with "the location expression shouldn't be settable to a string" assert raw (name of {_v}) can be set to a string with "the name expression should be settable to a string" assert raw (name of {_v}) can't be set to an integer with "the name expression shouldn't be settable to an integer" assert raw (name of {_v}) can't be set to strings with "the name expression shouldn't be settable to multiple strings" From 69232f62f2ae882e096269a028f4946c1ccc6f1a Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 16:08:08 -0600 Subject: [PATCH 07/23] Add debug output --- src/main/java/com/btk5h/skriptmirror/skript/CondChange.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index 35967c8..ff2cf1d 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -10,6 +10,7 @@ import ch.njol.skript.util.Patterns; import ch.njol.skript.util.Utils; import ch.njol.util.Kleenean; +import org.bukkit.Bukkit; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; @@ -80,6 +81,10 @@ public boolean check(Event event) { ClassInfo desiredType = this.desiredType.getSingle(event); if (desiredType == null) return false; + Bukkit.getConsoleSender().sendMessage(toString(event, true)); + Bukkit.getConsoleSender().sendMessage("- plural: " + typeIsPlural); + Bukkit.getConsoleSender().sendMessage("- change mode: " + desiredChangeMode.name()); + Bukkit.getConsoleSender().sendMessage("- desired type: " + desiredType.getC().getCanonicalName()); return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), typeIsPlural), isNegated()); } From 1c96e0cb061d8f4c2a5bb9f630b7ade6f7514d7d Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 16:23:54 -0600 Subject: [PATCH 08/23] Add debug output --- src/main/java/com/btk5h/skriptmirror/skript/CondChange.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index ff2cf1d..01a2574 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -40,10 +40,12 @@ public class CondChange extends Condition { private boolean typeIsPlural; private Expression> desiredType; private Expression> expressions; + private String rawForm; @SuppressWarnings("unchecked") @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + rawForm = parseResult.expr; setNegated((matchedPattern % 2) != 0); desiredChangeMode = PATTERNS.getInfo(matchedPattern); Expression desiredType = null; @@ -82,6 +84,7 @@ public boolean check(Event event) { if (desiredType == null) return false; Bukkit.getConsoleSender().sendMessage(toString(event, true)); + Bukkit.getConsoleSender().sendMessage("- raw: " + rawForm); Bukkit.getConsoleSender().sendMessage("- plural: " + typeIsPlural); Bukkit.getConsoleSender().sendMessage("- change mode: " + desiredChangeMode.name()); Bukkit.getConsoleSender().sendMessage("- desired type: " + desiredType.getC().getCanonicalName()); From b3d712ada2a14ea8a8c37d094c7235840cb94b51 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 17:00:04 -0600 Subject: [PATCH 09/23] Add debug output --- src/main/java/com/btk5h/skriptmirror/skript/CondChange.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index 01a2574..8bbef38 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -41,6 +41,7 @@ public class CondChange extends Condition { private Expression> desiredType; private Expression> expressions; private String rawForm; + private boolean wasUnparsed; @SuppressWarnings("unchecked") @Override @@ -65,6 +66,7 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye expressions = (Expression>) exprs[0]; } if (desiredType instanceof UnparsedLiteral) { + wasUnparsed = true; UnparsedLiteral unparsedDesiredType = (UnparsedLiteral) desiredType; desiredType = unparsedDesiredType.getConvertedExpression(ClassInfo.class); if (desiredType == null) @@ -85,6 +87,7 @@ public boolean check(Event event) { return false; Bukkit.getConsoleSender().sendMessage(toString(event, true)); Bukkit.getConsoleSender().sendMessage("- raw: " + rawForm); + Bukkit.getConsoleSender().sendMessage("- was unparsed: " + wasUnparsed); Bukkit.getConsoleSender().sendMessage("- plural: " + typeIsPlural); Bukkit.getConsoleSender().sendMessage("- change mode: " + desiredChangeMode.name()); Bukkit.getConsoleSender().sendMessage("- desired type: " + desiredType.getC().getCanonicalName()); From 6a04554e8617a42fab43528e077ccf4da6f3cb24 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 17:11:54 -0600 Subject: [PATCH 10/23] Try making the classinfo expression literal --- src/main/java/com/btk5h/skriptmirror/skript/CondChange.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index 8bbef38..60e59dc 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -20,8 +20,8 @@ public class CondChange extends Condition { private static final Patterns PATTERNS = new Patterns<>(new Object[][] { {"%classinfo% can be added to %expressions%", ChangeMode.ADD}, {"%classinfo% (can't|cannot) be added to %expressions%", ChangeMode.ADD}, - {"%expressions% can be set to %classinfo%", ChangeMode.SET}, - {"%expressions% (can't|cannot) be set to %classinfo%", ChangeMode.SET}, + {"%expressions% can be set to %*classinfo%", ChangeMode.SET}, + {"%expressions% (can't|cannot) be set to %*classinfo%", ChangeMode.SET}, {"%classinfo% can be removed from %expressions%", ChangeMode.REMOVE}, {"%classinfo% (can't|cannot) be removed from %expressions%", ChangeMode.REMOVE}, {"all %classinfo% can be removed from %expressions%", ChangeMode.REMOVE_ALL}, From 12bc1f22f936248621dca9f56ad0e7da4cae3d3e Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:12:58 -0600 Subject: [PATCH 11/23] Try calling getSource --- .../btk5h/skriptmirror/skript/CondChange.java | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index 60e59dc..b2978a8 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -20,8 +20,8 @@ public class CondChange extends Condition { private static final Patterns PATTERNS = new Patterns<>(new Object[][] { {"%classinfo% can be added to %expressions%", ChangeMode.ADD}, {"%classinfo% (can't|cannot) be added to %expressions%", ChangeMode.ADD}, - {"%expressions% can be set to %*classinfo%", ChangeMode.SET}, - {"%expressions% (can't|cannot) be set to %*classinfo%", ChangeMode.SET}, + {"%expressions% can be set to %classinfo%", ChangeMode.SET}, + {"%expressions% (can't|cannot) be set to %classinfo%", ChangeMode.SET}, {"%classinfo% can be removed from %expressions%", ChangeMode.REMOVE}, {"%classinfo% (can't|cannot) be removed from %expressions%", ChangeMode.REMOVE}, {"all %classinfo% can be removed from %expressions%", ChangeMode.REMOVE_ALL}, @@ -37,7 +37,7 @@ public class CondChange extends Condition { } private ChangeMode desiredChangeMode; - private boolean typeIsPlural; + private boolean desiredTypeIsPlural; private Expression> desiredType; private Expression> expressions; private String rawForm; @@ -65,15 +65,15 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye case DELETE: expressions = (Expression>) exprs[0]; } - if (desiredType instanceof UnparsedLiteral) { - wasUnparsed = true; - UnparsedLiteral unparsedDesiredType = (UnparsedLiteral) desiredType; - desiredType = unparsedDesiredType.getConvertedExpression(ClassInfo.class); - if (desiredType == null) - return false; - typeIsPlural = Utils.getEnglishPlural(unparsedDesiredType.getData()).getSecond(); + if (desiredType != null) { + Expression desiredTypeSource = desiredType.getSource(); + if (desiredTypeSource instanceof UnparsedLiteral) { + wasUnparsed = true; + UnparsedLiteral unparsedDesiredType = (UnparsedLiteral) desiredTypeSource; + desiredTypeIsPlural = Utils.getEnglishPlural(unparsedDesiredType.getData()).getSecond(); + } + this.desiredType = (Expression>) desiredType; } - this.desiredType = (Expression>) desiredType; return true; } @@ -88,10 +88,10 @@ public boolean check(Event event) { Bukkit.getConsoleSender().sendMessage(toString(event, true)); Bukkit.getConsoleSender().sendMessage("- raw: " + rawForm); Bukkit.getConsoleSender().sendMessage("- was unparsed: " + wasUnparsed); - Bukkit.getConsoleSender().sendMessage("- plural: " + typeIsPlural); + Bukkit.getConsoleSender().sendMessage("- plural: " + desiredTypeIsPlural); Bukkit.getConsoleSender().sendMessage("- change mode: " + desiredChangeMode.name()); Bukkit.getConsoleSender().sendMessage("- desired type: " + desiredType.getC().getCanonicalName()); - return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), typeIsPlural), isNegated()); + return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), desiredTypeIsPlural), isNegated()); } @Override From 6be065bf13e3f10e62d6f6983c3e60156514ef74 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:19:45 -0600 Subject: [PATCH 12/23] Fix tests --- src/test/scripts/CondChange.sk | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index 7272ab9..e8e81df 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -4,7 +4,8 @@ test "CondChange - set": assert raw (name of {_v}) can be set to a string with "the name expression should be settable to a string" assert raw (name of {_v}) can't be set to an integer with "the name expression shouldn't be settable to an integer" assert raw (name of {_v}) can't be set to strings with "the name expression shouldn't be settable to multiple strings" - assert raw ({_v}) can be set to strings with "a variable should be settable to multiple strings" + assert raw ({_v::*}) can be set to strings with "a list variable should be settable to multiple strings" + assert raw ({_v}) can't be set to strings with "a non-list variable should not be settable to multiple strings" test "CondChange - reset": assert raw (uppercase "") can't be reset with "the uppercase expression shouldn't be resettable" From 685c3014b5b79c8e8dbf391b6b60f55136313e05 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:22:37 -0600 Subject: [PATCH 13/23] Remove debug code --- .../com/btk5h/skriptmirror/skript/CondChange.java | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java index b2978a8..cc3d3c3 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java @@ -10,7 +10,6 @@ import ch.njol.skript.util.Patterns; import ch.njol.skript.util.Utils; import ch.njol.util.Kleenean; -import org.bukkit.Bukkit; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; @@ -40,13 +39,10 @@ public class CondChange extends Condition { private boolean desiredTypeIsPlural; private Expression> desiredType; private Expression> expressions; - private String rawForm; - private boolean wasUnparsed; @SuppressWarnings("unchecked") @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - rawForm = parseResult.expr; setNegated((matchedPattern % 2) != 0); desiredChangeMode = PATTERNS.getInfo(matchedPattern); Expression desiredType = null; @@ -68,7 +64,6 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye if (desiredType != null) { Expression desiredTypeSource = desiredType.getSource(); if (desiredTypeSource instanceof UnparsedLiteral) { - wasUnparsed = true; UnparsedLiteral unparsedDesiredType = (UnparsedLiteral) desiredTypeSource; desiredTypeIsPlural = Utils.getEnglishPlural(unparsedDesiredType.getData()).getSecond(); } @@ -85,12 +80,6 @@ public boolean check(Event event) { ClassInfo desiredType = this.desiredType.getSingle(event); if (desiredType == null) return false; - Bukkit.getConsoleSender().sendMessage(toString(event, true)); - Bukkit.getConsoleSender().sendMessage("- raw: " + rawForm); - Bukkit.getConsoleSender().sendMessage("- was unparsed: " + wasUnparsed); - Bukkit.getConsoleSender().sendMessage("- plural: " + desiredTypeIsPlural); - Bukkit.getConsoleSender().sendMessage("- change mode: " + desiredChangeMode.name()); - Bukkit.getConsoleSender().sendMessage("- desired type: " + desiredType.getC().getCanonicalName()); return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), desiredTypeIsPlural), isNegated()); } From 5dd95dc4c97864e468cb2684397236c767657c95 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:26:59 -0600 Subject: [PATCH 14/23] Add remove tests --- src/test/scripts/CondChange.sk | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index e8e81df..69ccb07 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -19,3 +19,12 @@ test "CondChange - add": assert an integer can be added to raw ({_v}) with "an integer should be addable to a variable" assert integers can be added to raw ({_v}) with "multiple integers should be addable to a variable" assert a string can't be added to raw (all players) with "a string shouldn't be addable to all players" + +test "CondChange - remove": + assert an integer can be removed from raw ({_v::*}) with "an integer should be removable from a variable" + assert integers can be removed from to raw ({_v::*}}) with "multiple integers should be removable from a variable" + assert integers can be removed from to raw ({_v::*}}) with "multiple integers should be removable from a variable" + assert a string can't be removed from raw (all players) with "a string shouldn't be removable all players" + assert an item can be removed from raw (inventory of {_v}) with "an item should be removable from an inventory" + + From 65d034aa1e976a17bf59d9c158f001a3e60ceaf2 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:36:27 -0600 Subject: [PATCH 15/23] Add remove all tests --- src/test/scripts/CondChange.sk | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index 69ccb07..7dc595f 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -22,9 +22,14 @@ test "CondChange - add": test "CondChange - remove": assert an integer can be removed from raw ({_v::*}) with "an integer should be removable from a variable" - assert integers can be removed from to raw ({_v::*}}) with "multiple integers should be removable from a variable" - assert integers can be removed from to raw ({_v::*}}) with "multiple integers should be removable from a variable" + assert integers can be removed from raw ({_v::*}}) with "multiple integers should be removable from a variable" + assert integers can be removed from raw ({_v::*}}) with "multiple integers should be removable from a variable" assert a string can't be removed from raw (all players) with "a string shouldn't be removable all players" - assert an item can be removed from raw (inventory of {_v}) with "an item should be removable from an inventory" + assert an integer can be removed from raw (durability of {_v}) with "an integer should be removable from the durability expression" +test "CondChange - remove all": + assert all integer can be removed from raw ({_v::*}) with "all integer should be removable from a variable" + assert all integers can be removed from to raw ({_v::*}}) with "all integers should be removable from a variable" + assert all integers can't be removed from raw (name of {_v}) with "all integers shouldn't be removable from the name expression" + assert all integer can't be removed from raw (name of {_v}) with "all integers shouldn't be removable from the name expression" From 9f8dbfc57416eeb8f4da34ed53c319c95610a311 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:44:11 -0600 Subject: [PATCH 16/23] Fix tests --- src/test/scripts/CondChange.sk | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index 7dc595f..cd7c789 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -21,15 +21,13 @@ test "CondChange - add": assert a string can't be added to raw (all players) with "a string shouldn't be addable to all players" test "CondChange - remove": - assert an integer can be removed from raw ({_v::*}) with "an integer should be removable from a variable" - assert integers can be removed from raw ({_v::*}}) with "multiple integers should be removable from a variable" - assert integers can be removed from raw ({_v::*}}) with "multiple integers should be removable from a variable" - assert a string can't be removed from raw (all players) with "a string shouldn't be removable all players" - assert an integer can be removed from raw (durability of {_v}) with "an integer should be removable from the durability expression" - + assert a player can be removed from raw ({_v::*}) with "a player should be removable from a variable" + assert players can be removed from raw ({_v::*}}) with "multiple players should be removable from a variable" + assert a player can't be removed from raw (block at {_v}) with "a player shouldn't be removable the block expression" + assert a integer can be removed from raw (durability of {_v}) with "an integer should be removable from the durability expression" test "CondChange - remove all": - assert all integer can be removed from raw ({_v::*}) with "all integer should be removable from a variable" - assert all integers can be removed from to raw ({_v::*}}) with "all integers should be removable from a variable" - assert all integers can't be removed from raw (name of {_v}) with "all integers shouldn't be removable from the name expression" - assert all integer can't be removed from raw (name of {_v}) with "all integers shouldn't be removable from the name expression" + assert all player can be removed from raw ({_v::*}) with "all integer should be removable from a variable" + assert all players can be removed from to raw ({_v::*}}) with "all integers should be removable from a variable" + assert all strings can't be removed from raw (name of {_v}) with "all strings shouldn't be removable from the name expression" + assert all players can't be removed from raw (name of {_v}) with "all players shouldn't be removable from the name expression" From 45e32819c9ecab4cd467235e8770a91db71cf6cf Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:49:32 -0600 Subject: [PATCH 17/23] Fix test errors --- src/test/scripts/CondChange.sk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index cd7c789..fbf597e 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -28,6 +28,6 @@ test "CondChange - remove": test "CondChange - remove all": assert all player can be removed from raw ({_v::*}) with "all integer should be removable from a variable" - assert all players can be removed from to raw ({_v::*}}) with "all integers should be removable from a variable" + assert all players can be removed from raw ({_v::*}) with "all integers should be removable from a variable" assert all strings can't be removed from raw (name of {_v}) with "all strings shouldn't be removable from the name expression" assert all players can't be removed from raw (name of {_v}) with "all players shouldn't be removable from the name expression" From 919891b8ff6977d580b2fa7a52ec1a1579998448 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:50:11 -0600 Subject: [PATCH 18/23] Rename CondChange to CondAcceptsChange --- .../skript/{CondChange.java => CondAcceptsChange.java} | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) rename src/main/java/com/btk5h/skriptmirror/skript/{CondChange.java => CondAcceptsChange.java} (97%) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java similarity index 97% rename from src/main/java/com/btk5h/skriptmirror/skript/CondChange.java rename to src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java index cc3d3c3..5145cd5 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java @@ -14,7 +14,7 @@ import org.eclipse.jdt.annotation.Nullable; -public class CondChange extends Condition { +public class CondAcceptsChange extends Condition { private static final Patterns PATTERNS = new Patterns<>(new Object[][] { {"%classinfo% can be added to %expressions%", ChangeMode.ADD}, @@ -32,7 +32,7 @@ public class CondChange extends Condition { }); static { - Skript.registerCondition(CondChange.class, PATTERNS.getPatterns()); + Skript.registerCondition(CondAcceptsChange.class, PATTERNS.getPatterns()); } private ChangeMode desiredChangeMode; From cd466ac92082c8e28d7a61df46017539a59e3829 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Fri, 23 Feb 2024 18:55:15 -0600 Subject: [PATCH 19/23] Fix another test error --- src/test/scripts/CondChange.sk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/scripts/CondChange.sk b/src/test/scripts/CondChange.sk index fbf597e..bbb970d 100644 --- a/src/test/scripts/CondChange.sk +++ b/src/test/scripts/CondChange.sk @@ -22,7 +22,7 @@ test "CondChange - add": test "CondChange - remove": assert a player can be removed from raw ({_v::*}) with "a player should be removable from a variable" - assert players can be removed from raw ({_v::*}}) with "multiple players should be removable from a variable" + assert players can be removed from raw ({_v::*}) with "multiple players should be removable from a variable" assert a player can't be removed from raw (block at {_v}) with "a player shouldn't be removable the block expression" assert a integer can be removed from raw (durability of {_v}) with "an integer should be removable from the durability expression" From 16d01c5c9036e24e582b3852dd04c75e68c7a462 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 28 Feb 2024 18:32:12 -0600 Subject: [PATCH 20/23] Try implementing ClassInfoReference --- .../skript/CondAcceptsChange.java | 16 ++-- .../skriptmirror/util/ClassInfoReference.java | 92 +++++++++++++++++++ .../btk5h/skriptmirror/util/SkriptUtil.java | 29 +++++- 3 files changed, 127 insertions(+), 10 deletions(-) create mode 100644 src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java index 5145cd5..711ec85 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java @@ -10,6 +10,8 @@ import ch.njol.skript.util.Patterns; import ch.njol.skript.util.Utils; import ch.njol.util.Kleenean; +import com.btk5h.skriptmirror.util.ClassInfoReference; +import com.btk5h.skriptmirror.util.SkriptUtil; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; @@ -37,7 +39,7 @@ public class CondAcceptsChange extends Condition { private ChangeMode desiredChangeMode; private boolean desiredTypeIsPlural; - private Expression> desiredType; + private Expression desiredType; private Expression> expressions; @SuppressWarnings("unchecked") @@ -62,12 +64,7 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye expressions = (Expression>) exprs[0]; } if (desiredType != null) { - Expression desiredTypeSource = desiredType.getSource(); - if (desiredTypeSource instanceof UnparsedLiteral) { - UnparsedLiteral unparsedDesiredType = (UnparsedLiteral) desiredTypeSource; - desiredTypeIsPlural = Utils.getEnglishPlural(unparsedDesiredType.getData()).getSecond(); - } - this.desiredType = (Expression>) desiredType; + this.desiredType = ClassInfoReference.getFromClassInfoExpression((Expression>) desiredType); } return true; } @@ -77,10 +74,11 @@ public boolean check(Event event) { if (desiredChangeMode == ChangeMode.DELETE || desiredChangeMode == ChangeMode.RESET) //noinspection ConstantValue return expressions.check(event, expressions -> expressions.acceptChange(desiredChangeMode) != null, isNegated()); - ClassInfo desiredType = this.desiredType.getSingle(event); + ClassInfoReference desiredType = this.desiredType.getSingle(event); if (desiredType == null) return false; - return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getC(), desiredTypeIsPlural), isNegated()); + boolean isPlural = desiredType.isSpecific() && desiredType.isPlural(); + return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getClassInfo().getC(), isPlural), isNegated()); } @Override diff --git a/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java new file mode 100644 index 0000000..786c0b2 --- /dev/null +++ b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java @@ -0,0 +1,92 @@ +package com.btk5h.skriptmirror.util; + +import ch.njol.skript.classes.ClassInfo; +import ch.njol.skript.expressions.base.WrapperExpression; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.util.Kleenean; +import org.bukkit.event.Event; +import org.eclipse.jdt.annotation.Nullable; + +import java.util.Objects; + +public class ClassInfoReference { + + private ClassInfo classInfo; + private boolean plural; + private boolean specific; + + /** + * Creates a non-specific ClassInfoReference + * @param classInfo the classinfo referenced + */ + public ClassInfoReference(ClassInfo classInfo) { + this.classInfo = classInfo; + } + + /** + * Creates a specific ClassInfoReference + * @param classInfo the classinfo referenced + * @param plural whether the reference to the classinfo is plural + */ + public ClassInfoReference(ClassInfo classInfo, boolean plural) { + this.classInfo = classInfo; + this.plural = plural; + this.specific = true; + } + + public ClassInfo getClassInfo() { + return classInfo; + } + + public boolean isSpecific() { + return specific; + } + + private void ensureIsSpecific() { + if (!isSpecific()) { + throw new IllegalStateException("Cannot get specific attributes from a non-specific " + getClass().getName()); + } + } + + public boolean isPlural() { + ensureIsSpecific(); + return plural; + } + + public static Expression getFromClassInfoExpression(Expression> expression) { + ClassInfoReference parsedReference = SkriptUtil.getClassInfoReference(expression); + return new WrapperExpression() { + + @Override + protected ClassInfoReference[] get(Event event) { + if (parsedReference != null) { + return new ClassInfoReference[] { parsedReference }; + } else if (isSingle()) { + ClassInfo classInfo = expression.getSingle(event); + if (classInfo == null) { + return new ClassInfoReference[0]; + } + return new ClassInfoReference[] { new ClassInfoReference(classInfo) }; + } else { + return expression.stream(event) + .filter(Objects::nonNull) + .map(ClassInfoReference::new) + .toArray(ClassInfoReference[]::new); + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + return getExpr().toString(event, debug); + } + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + return getExpr().init(expressions, matchedPattern, isDelayed, parseResult); + } + + }; + } + +} diff --git a/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java b/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java index 1b9d167..37b9c79 100644 --- a/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java +++ b/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java @@ -18,6 +18,7 @@ import ch.njol.skript.registrations.DefaultClasses; import ch.njol.skript.util.Utils; import ch.njol.util.NonNullPair; +import ch.njol.util.Pair; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.NonNull; import org.skriptlang.skript.lang.script.Script; @@ -120,6 +121,23 @@ public static Script getCurrentScript() { .orElse(null); } + /** + * Gets the UnparsedLiteral an expression was converted from + * @param expression the expression to get the UnparsedLiteral of + * @return the source UnparsedLiteral or null if there is no such source + */ + public static UnparsedLiteral getSourceUnparsedLiteral(Expression expression) { + Expression sourceExpression = expression.getSource(); + while (!(sourceExpression instanceof UnparsedLiteral)) { + Expression nextSourceExpression = sourceExpression.getSource(); + if (nextSourceExpression == sourceExpression) { + return null; + } + sourceExpression = nextSourceExpression; + } + return (UnparsedLiteral) sourceExpression; + } + /** * Gets the {@link ClassInfo} by first converting the given string to a singular. * Returns {@code Object.class}'s if no {@link ClassInfo} can be found for the given type. @@ -152,6 +170,15 @@ public static NonNullPair, Boolean> getUserClassInfoAndPlural(Strin return new NonNullPair<>(ci, wordData.getSecond()); } + public static ClassInfoReference getClassInfoReference(Expression> sourceExpression) { + UnparsedLiteral sourceUnparsedLiteral = getSourceUnparsedLiteral(sourceExpression); + if (sourceUnparsedLiteral == null) { + return null; + } + Pair, Boolean> classInfoAndPlural = getUserClassInfoAndPlural(sourceUnparsedLiteral.getData()); + return new ClassInfoReference(classInfoAndPlural.getFirst(), classInfoAndPlural.getSecond()); + } + /** * @return the singular form of the given string type, * converted back to plural if it was plural in the first place. @@ -166,7 +193,7 @@ public static String replaceUserInputPatterns(String name) { /** * {@return} a {@link Function} to get a {@link Expression}'s value, - * using {@link Expression#getSingle(Event)} if {@link Expression#getSingle(Event)} + * using {@link Expression#getSingle(Event)} if {@link Expression#isSingle()} * returns {@code true}, otherwise returning {@link Expression#getArray(Event)}. */ public static Function, Object> unwrapWithEvent(Event e) { From 6aa719a914dd25a4033a3f1488cf9432a87a81db Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 28 Feb 2024 18:38:49 -0600 Subject: [PATCH 21/23] Try fixing ClassInfoReference --- .../btk5h/skriptmirror/skript/CondAcceptsChange.java | 9 ++++----- .../btk5h/skriptmirror/util/ClassInfoReference.java | 11 ++--------- 2 files changed, 6 insertions(+), 14 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java index 711ec85..01e9a7a 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java @@ -77,8 +77,7 @@ public boolean check(Event event) { ClassInfoReference desiredType = this.desiredType.getSingle(event); if (desiredType == null) return false; - boolean isPlural = desiredType.isSpecific() && desiredType.isPlural(); - return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType.getClassInfo().getC(), isPlural), isNegated()); + return expressions.check(event, expression -> acceptsChange(expression, desiredChangeMode, desiredType), isNegated()); } @Override @@ -103,15 +102,15 @@ public String toString(@Nullable Event event, boolean debug) { } } - private boolean acceptsChange(Expression expression, ChangeMode desiredChangeMode, Class desiredType, boolean typeIsPlural) { + private boolean acceptsChange(Expression expression, ChangeMode desiredChangeMode, ClassInfoReference desiredType) { Class[] acceptableTypes = expression.acceptChange(desiredChangeMode); //noinspection ConstantValue if (acceptableTypes != null) { for (Class acceptableType : acceptableTypes) { if (acceptableType.isArray() - && acceptableType.getComponentType().isAssignableFrom(desiredType)) { + && acceptableType.getComponentType().isAssignableFrom(desiredType.getClassInfo().getC())) { return true; - } else if (!typeIsPlural && acceptableType.isAssignableFrom(desiredType)) + } else if (desiredType.isPlural() && acceptableType.isAssignableFrom(desiredType.getClassInfo().getC())) return true; } } diff --git a/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java index 786c0b2..98b7239 100644 --- a/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java +++ b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java @@ -43,14 +43,7 @@ public boolean isSpecific() { return specific; } - private void ensureIsSpecific() { - if (!isSpecific()) { - throw new IllegalStateException("Cannot get specific attributes from a non-specific " + getClass().getName()); - } - } - public boolean isPlural() { - ensureIsSpecific(); return plural; } @@ -78,12 +71,12 @@ protected ClassInfoReference[] get(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { - return getExpr().toString(event, debug); + return expression.toString(event, debug); } @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - return getExpr().init(expressions, matchedPattern, isDelayed, parseResult); + return expression.init(expressions, matchedPattern, isDelayed, parseResult); } }; From 26adb393eb7ea78e8e104171e3751820c702f228 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 28 Feb 2024 18:50:45 -0600 Subject: [PATCH 22/23] Goodbye WrapperExpression --- .../skriptmirror/util/ClassInfoReference.java | 24 +++++++++++++++---- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java index 98b7239..f931118 100644 --- a/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java +++ b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java @@ -4,6 +4,7 @@ import ch.njol.skript.expressions.base.WrapperExpression; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.util.SimpleExpression; import ch.njol.util.Kleenean; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; @@ -49,7 +50,12 @@ public boolean isPlural() { public static Expression getFromClassInfoExpression(Expression> expression) { ClassInfoReference parsedReference = SkriptUtil.getClassInfoReference(expression); - return new WrapperExpression() { + return new SimpleExpression() { + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + return expression.init(expressions, matchedPattern, isDelayed, parseResult); + } @Override protected ClassInfoReference[] get(Event event) { @@ -69,14 +75,22 @@ protected ClassInfoReference[] get(Event event) { } } + public Class getReturnType() { + return ClassInfoReference.class; + } + @Override - public String toString(@Nullable Event event, boolean debug) { - return expression.toString(event, debug); + public boolean isSingle() { + return expression.isSingle(); } + @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - return expression.init(expressions, matchedPattern, isDelayed, parseResult); + public String toString(@Nullable Event event, boolean debug) { + if (debug) { + return expression.toString(event, true) + " (wrapped by ClassInfoReference)"; + } + return expression.toString(event, false); } }; From 5ecc948ad225840119bce303de3df982f7a634f5 Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Wed, 28 Feb 2024 19:22:57 -0600 Subject: [PATCH 23/23] Refactor ClassInfoReference --- .../skript/CondAcceptsChange.java | 6 +- .../skriptmirror/util/ClassInfoReference.java | 48 ------------ .../btk5h/skriptmirror/util/SkriptUtil.java | 73 +++++++++++++++++-- 3 files changed, 68 insertions(+), 59 deletions(-) diff --git a/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java index 01e9a7a..f805433 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java @@ -6,9 +6,7 @@ import ch.njol.skript.lang.Condition; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser; -import ch.njol.skript.lang.UnparsedLiteral; import ch.njol.skript.util.Patterns; -import ch.njol.skript.util.Utils; import ch.njol.util.Kleenean; import com.btk5h.skriptmirror.util.ClassInfoReference; import com.btk5h.skriptmirror.util.SkriptUtil; @@ -64,9 +62,9 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye expressions = (Expression>) exprs[0]; } if (desiredType != null) { - this.desiredType = ClassInfoReference.getFromClassInfoExpression((Expression>) desiredType); + this.desiredType = SkriptUtil.wrapClassInfoExpression((Expression>) desiredType); } - return true; + return SkriptUtil.canInitSafely(desiredType); } @Override diff --git a/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java index f931118..c0d57ba 100644 --- a/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java +++ b/src/main/java/com/btk5h/skriptmirror/util/ClassInfoReference.java @@ -48,52 +48,4 @@ public boolean isPlural() { return plural; } - public static Expression getFromClassInfoExpression(Expression> expression) { - ClassInfoReference parsedReference = SkriptUtil.getClassInfoReference(expression); - return new SimpleExpression() { - - @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - return expression.init(expressions, matchedPattern, isDelayed, parseResult); - } - - @Override - protected ClassInfoReference[] get(Event event) { - if (parsedReference != null) { - return new ClassInfoReference[] { parsedReference }; - } else if (isSingle()) { - ClassInfo classInfo = expression.getSingle(event); - if (classInfo == null) { - return new ClassInfoReference[0]; - } - return new ClassInfoReference[] { new ClassInfoReference(classInfo) }; - } else { - return expression.stream(event) - .filter(Objects::nonNull) - .map(ClassInfoReference::new) - .toArray(ClassInfoReference[]::new); - } - } - - public Class getReturnType() { - return ClassInfoReference.class; - } - - @Override - public boolean isSingle() { - return expression.isSingle(); - } - - - @Override - public String toString(@Nullable Event event, boolean debug) { - if (debug) { - return expression.toString(event, true) + " (wrapped by ClassInfoReference)"; - } - return expression.toString(event, false); - } - - }; - } - } diff --git a/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java b/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java index 37b9c79..7507f179 100644 --- a/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java +++ b/src/main/java/com/btk5h/skriptmirror/util/SkriptUtil.java @@ -9,18 +9,21 @@ import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.ExpressionList; import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser; import ch.njol.skript.lang.TriggerItem; import ch.njol.skript.lang.UnparsedLiteral; import ch.njol.skript.lang.parser.ParserInstance; +import ch.njol.skript.lang.util.SimpleExpression; import ch.njol.skript.log.RetainingLogHandler; import ch.njol.skript.log.SkriptLogger; import ch.njol.skript.registrations.Classes; import ch.njol.skript.registrations.DefaultClasses; import ch.njol.skript.util.Utils; +import ch.njol.util.Kleenean; import ch.njol.util.NonNullPair; -import ch.njol.util.Pair; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; import org.skriptlang.skript.lang.script.Script; import java.io.File; @@ -170,13 +173,69 @@ public static NonNullPair, Boolean> getUserClassInfoAndPlural(Strin return new NonNullPair<>(ci, wordData.getSecond()); } - public static ClassInfoReference getClassInfoReference(Expression> sourceExpression) { - UnparsedLiteral sourceUnparsedLiteral = getSourceUnparsedLiteral(sourceExpression); - if (sourceUnparsedLiteral == null) { - return null; + /** + * Wraps a ClassInfo expression into a ClassInfoReference expression + * If possible, specific attributes of ClassInfoReference may be filled in. + * @param sourceExpression the ClassInfo expression + * @return the ClassInfoReference expression + */ + public static Expression wrapClassInfoExpression(Expression> sourceExpression) { + ClassInfoReference parsedReference = null; + if (sourceExpression instanceof Literal) { + UnparsedLiteral sourceUnparsedLiteral = getSourceUnparsedLiteral(sourceExpression); + if (sourceUnparsedLiteral == null) { + return null; + } + boolean plural = Utils.getEnglishPlural(sourceUnparsedLiteral.getData()).getSecond(); + ClassInfo classInfo = ((Literal>) sourceExpression).getSingle(); + if (classInfo != null) { + parsedReference = new ClassInfoReference(classInfo, plural); + } } - Pair, Boolean> classInfoAndPlural = getUserClassInfoAndPlural(sourceUnparsedLiteral.getData()); - return new ClassInfoReference(classInfoAndPlural.getFirst(), classInfoAndPlural.getSecond()); + ClassInfoReference finalParsedReference = parsedReference; + return new SimpleExpression() { + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + return sourceExpression.init(expressions, matchedPattern, isDelayed, parseResult); + } + + @Override + protected ClassInfoReference[] get(Event event) { + if (finalParsedReference != null) { + return new ClassInfoReference[] { finalParsedReference }; + } else if (isSingle()) { + ClassInfo classInfo = sourceExpression.getSingle(event); + if (classInfo == null) { + return new ClassInfoReference[0]; + } + return new ClassInfoReference[] { new ClassInfoReference(classInfo) }; + } else { + return sourceExpression.stream(event) + .filter(Objects::nonNull) + .map(ClassInfoReference::new) + .toArray(ClassInfoReference[]::new); + } + } + + public Class getReturnType() { + return ClassInfoReference.class; + } + + @Override + public boolean isSingle() { + return sourceExpression.isSingle(); + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + if (debug) { + return sourceExpression.toString(event, true) + " (wrapped by ClassInfoReference)"; + } + return sourceExpression.toString(event, false); + } + + }; } /**