From bcf6a4d95a9486f53ef0ada8c34c063ae7c70ddd Mon Sep 17 00:00:00 2001 From: Pikachu920 <28607612+Pikachu920@users.noreply.github.com> Date: Sat, 18 Jan 2025 13:05:30 -0600 Subject: [PATCH] Registration API Compatibility (#130) --- .github/workflows/gradle.yml | 4 +- build.gradle | 6 +- .../skriptmirror/ParseOrderWorkarounds.java | 50 +++++++++--- .../skriptmirror/skript/ExprArrayAccess.java | 5 +- .../btk5h/skriptmirror/skript/ExprPlugin.java | 22 +++--- .../btk5h/skriptmirror/skript/ExprSpread.java | 5 +- .../com/btk5h/skriptmirror/skript/Types.java | 3 +- .../skript/custom/ExprExpression.java | 5 +- .../skript/custom/ExprRawExpression.java | 2 +- .../skript/reflect/ExprJavaCall.java | 19 +++-- .../skriptmirror/util/SkriptReflection.java | 48 +----------- .../elements/structures/StructImport.java | 76 +++---------------- .../reflect/syntax/CustomSyntaxStructure.java | 31 +++++++- .../condition/elements/CustomCondition.java | 5 ++ .../elements/StructCustomCondition.java | 13 +++- .../syntax/effect/elements/CustomEffect.java | 5 ++ .../effect/elements/StructCustomEffect.java | 12 ++- .../syntax/event/elements/CustomEvent.java | 5 ++ .../event/elements/StructCustomEvent.java | 14 +++- .../expression/elements/CustomExpression.java | 10 ++- .../expression/elements/ExprChangeValue.java | 6 +- .../elements/StructCustomConstant.java | 19 +++-- .../elements/StructCustomExpression.java | 21 +++-- src/test/scripts/custom/custom condition.sk | 26 +++++++ src/test/scripts/custom/custom constants.sk | 7 ++ src/test/scripts/custom/custom effects.sk | 8 ++ src/test/scripts/custom/custom events.sk | 47 ++++++++++++ src/test/scripts/custom/custom expressions.sk | 24 ++++++ src/test/scripts/reflect/EffImport.sk | 13 ++++ .../scripts/{ => reflect}/ExprJavaCall.sk | 0 src/test/scripts/reflect/StructImport.sk | 7 ++ 31 files changed, 322 insertions(+), 196 deletions(-) create mode 100644 src/test/scripts/custom/custom condition.sk create mode 100644 src/test/scripts/custom/custom constants.sk create mode 100644 src/test/scripts/custom/custom effects.sk create mode 100644 src/test/scripts/custom/custom events.sk create mode 100644 src/test/scripts/custom/custom expressions.sk create mode 100644 src/test/scripts/reflect/EffImport.sk rename src/test/scripts/{ => reflect}/ExprJavaCall.sk (100%) create mode 100644 src/test/scripts/reflect/StructImport.sk diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml index c02a1e4..f59cad1 100644 --- a/.github/workflows/gradle.yml +++ b/.github/workflows/gradle.yml @@ -15,7 +15,7 @@ jobs: - name: Set up JDK 11 uses: actions/setup-java@v1 with: - java-version: 11 + java-version: 17 - name: Grant execute permission for gradlew run: chmod +x gradlew - name: Build with Gradle @@ -36,7 +36,7 @@ jobs: path: extra-plugins/ merge-multiple: true - name: Run tests - uses: SkriptLang/skript-test-action@v1.1 + uses: SkriptLang/skript-test-action@v1.2 with: test_script_directory: src/test/scripts extra_plugins_directory: extra-plugins/ diff --git a/build.gradle b/build.gradle index 693302c..dc43bce 100644 --- a/build.gradle +++ b/build.gradle @@ -28,13 +28,13 @@ processResources { } compileJava { - sourceCompatibility = '11' - targetCompatibility = '11' + sourceCompatibility = '17' + targetCompatibility = '17' options.encoding = 'UTF-8' } dependencies { implementation 'org.spigotmc:spigot-api:1.13.2-R0.1-SNAPSHOT' - implementation 'com.github.SkriptLang:Skript:2.9.0' + implementation 'com.github.SkriptLang:Skript:2.10.0' implementation 'org.eclipse.jdt:org.eclipse.jdt.annotation:1.1.0' } diff --git a/src/main/java/com/btk5h/skriptmirror/ParseOrderWorkarounds.java b/src/main/java/com/btk5h/skriptmirror/ParseOrderWorkarounds.java index d924153..66a4182 100644 --- a/src/main/java/com/btk5h/skriptmirror/ParseOrderWorkarounds.java +++ b/src/main/java/com/btk5h/skriptmirror/ParseOrderWorkarounds.java @@ -2,16 +2,25 @@ import ch.njol.skript.Skript; import ch.njol.skript.effects.EffReturn; -import ch.njol.util.Checker; +import org.skriptlang.reflect.syntax.CustomSyntaxStructure; import org.skriptlang.reflect.syntax.condition.elements.CustomCondition; +import org.skriptlang.reflect.syntax.condition.elements.StructCustomCondition; import org.skriptlang.reflect.syntax.effect.elements.CustomEffect; +import org.skriptlang.reflect.syntax.effect.elements.StructCustomEffect; import org.skriptlang.reflect.syntax.expression.elements.CustomExpression; import com.btk5h.skriptmirror.skript.EffExpressionStatement; import com.btk5h.skriptmirror.skript.custom.ExprMatchedPattern; import com.btk5h.skriptmirror.util.SkriptReflection; +import org.skriptlang.reflect.syntax.expression.elements.StructCustomExpression; +import org.skriptlang.skript.bukkit.registration.BukkitRegistryKeys; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; +import org.skriptlang.skript.util.Priority; +import javax.naming.ServiceUnavailableException; import java.util.Collection; import java.util.Optional; +import java.util.function.Predicate; /** * Explicitly declares the relative parse orders of different statement types. Classes at the start of the list should @@ -20,7 +29,11 @@ * This class should only be used to guarantee that skript-mirror's syntax is parsed before other addons. It cannot * guarantee that another addon's syntax will be parsed before skript-reflect. */ +@SuppressWarnings("UnstableApiUsage") public class ParseOrderWorkarounds { + + private static final Priority POSITION = Priority.before(SyntaxInfo.PATTERN_MATCHES_EVERYTHING); + private static final String[] PARSE_ORDER = { EffExpressionStatement.class.getCanonicalName(), CustomEffect.class.getCanonicalName(), @@ -38,22 +51,37 @@ public class ParseOrderWorkarounds { public static void reorderSyntax() { for (String c : PARSE_ORDER) { - ensureLast(Skript.getStatements(), o -> o.getElementClass().getName().equals(c)); - ensureLast(Skript.getConditions(), o -> o.getElementClass().getName().equals(c)); - ensureLast(Skript.getEffects(), o -> o.getElementClass().toString().equals(c)); - ensureLast(SkriptReflection.getExpressions(), o -> o.getElementClass().getName().equals(c)); - ensureLast(Skript.getEvents(), o -> o.getElementClass().getName().equals(c)); + ensureLast(SyntaxRegistry.CONDITION, o -> o.type().getName().equals(c)); + ensureLast(SyntaxRegistry.EFFECT, o -> o.type().getName().equals(c)); + ensureLast(SyntaxRegistry.EXPRESSION, o -> o.type().getName().equals(c)); + ensureLast(BukkitRegistryKeys.EVENT, o -> o.type().getName().equals(c)); + ensureLast(SyntaxRegistry.STRUCTURE, o -> o.type().getName().equals(c)); } } - private static void ensureLast(Collection elements, Checker checker) { - Optional optionalE = elements.stream() - .filter(checker::check) + private static void ensureLast(SyntaxRegistry.Key> elementKey, Predicate> checker) { + SyntaxRegistry syntaxRegistry = SkriptMirror.getAddonInstance().syntaxRegistry(); + Optional> optionalE = syntaxRegistry.syntaxes(elementKey).stream() + .filter(checker) .findFirst(); optionalE.ifPresent(value -> { - elements.remove(value); - elements.add(value); + syntaxRegistry.unregister((SyntaxRegistry.Key) elementKey, value); + var newInfo = value.toBuilder().priority(POSITION).build(); + syntaxRegistry.register((SyntaxRegistry.Key) elementKey, newInfo); + + // need to update custom syntax references + CustomSyntaxStructure.DataTracker tracker = null; + if (elementKey == (SyntaxRegistry.Key) SyntaxRegistry.EFFECT) { + tracker = StructCustomEffect.dataTracker; + } else if (elementKey == (SyntaxRegistry.Key) SyntaxRegistry.CONDITION) { + tracker = StructCustomCondition.dataTracker; + } else if (elementKey == (SyntaxRegistry.Key) SyntaxRegistry.EXPRESSION) { + tracker = StructCustomExpression.dataTracker; + } + if (tracker != null && tracker.getInfo() == value) { + tracker.setInfo(newInfo); + } }); } diff --git a/src/main/java/com/btk5h/skriptmirror/skript/ExprArrayAccess.java b/src/main/java/com/btk5h/skriptmirror/skript/ExprArrayAccess.java index c859c5b..35e7fb4 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/ExprArrayAccess.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/ExprArrayAccess.java @@ -17,6 +17,7 @@ import java.lang.reflect.Array; import java.util.Iterator; +import java.util.function.Predicate; public class ExprArrayAccess implements Expression { @@ -106,12 +107,12 @@ public boolean isSingle() { } @Override - public boolean check(Event e, Checker c, boolean negated) { + public boolean check(Event e, Predicate c, boolean negated) { return SimpleExpression.check(getAll(e), c, negated, getAnd()); } @Override - public boolean check(Event e, Checker c) { + public boolean check(Event e, Predicate c) { return SimpleExpression.check(getAll(e), c, false, getAnd()); } diff --git a/src/main/java/com/btk5h/skriptmirror/skript/ExprPlugin.java b/src/main/java/com/btk5h/skriptmirror/skript/ExprPlugin.java index 107d4ed..33b3601 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/ExprPlugin.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/ExprPlugin.java @@ -4,6 +4,7 @@ import ch.njol.skript.expressions.base.SimplePropertyExpression; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.ExpressionType; +import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser; import ch.njol.util.Kleenean; import com.btk5h.skriptmirror.JavaType; @@ -22,15 +23,19 @@ public class ExprPlugin extends SimplePropertyExpression @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - super.init(exprs, matchedPattern, isDelayed, parseResult); + if (!super.init(exprs, matchedPattern, isDelayed, parseResult)) { + return false; + } - if (exprs[0] instanceof StructImport.ImportHandler) { - JavaType javaType = ((StructImport.ImportHandler) exprs[0]).getJavaType(); - Class clazz = javaType.getJavaClass(); + if (getExpr() instanceof Literal literal) { + Object literalValue = literal.getSingle(); + if (literalValue instanceof JavaType javaType) { + Class clazz = javaType.getJavaClass(); - if (!JavaPlugin.class.isAssignableFrom(clazz) || JavaPlugin.class.equals(clazz)) { - Skript.error("The class " + clazz.getSimpleName() + " is not a plugin class"); - return false; + if (!JavaPlugin.class.isAssignableFrom(clazz) || JavaPlugin.class.equals(clazz)) { + Skript.error("The class " + clazz.getSimpleName() + " is not a plugin class"); + return false; + } } } @@ -39,8 +44,7 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye @Override public ObjectWrapper convert(Object plugin) { - if (plugin instanceof String) { - String pluginName = (String) plugin; + if (plugin instanceof String pluginName) { for (Plugin pluginInstance : Bukkit.getPluginManager().getPlugins()) { if (pluginInstance.getName().equalsIgnoreCase(pluginName)) { return ObjectWrapper.create(pluginInstance); diff --git a/src/main/java/com/btk5h/skriptmirror/skript/ExprSpread.java b/src/main/java/com/btk5h/skriptmirror/skript/ExprSpread.java index 7a4e283..fa8ec71 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/ExprSpread.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/ExprSpread.java @@ -20,6 +20,7 @@ import java.util.Collection; import java.util.Iterator; import java.util.List; +import java.util.function.Predicate; import java.util.stream.Stream; public class ExprSpread implements Expression { @@ -97,12 +98,12 @@ public boolean isSingle() { } @Override - public boolean check(Event e, Checker c, boolean negated) { + public boolean check(Event e, Predicate c, boolean negated) { return SimpleExpression.check(getAll(e), c, negated, getAnd()); } @Override - public boolean check(Event e, Checker c) { + public boolean check(Event e, Predicate c) { return SimpleExpression.check(getAll(e), c, false, getAnd()); } diff --git a/src/main/java/com/btk5h/skriptmirror/skript/Types.java b/src/main/java/com/btk5h/skriptmirror/skript/Types.java index 8110068..97ba8d8 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/Types.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/Types.java @@ -63,8 +63,7 @@ public JavaType parse(String s, ParseContext context) { @Override public boolean canParse(ParseContext context) { - // default context handled in StructImport$ImportHandler - return context != ParseContext.DEFAULT; + return true; } @Override diff --git a/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprExpression.java b/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprExpression.java index 9e8ebb7..cbe3355 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprExpression.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprExpression.java @@ -22,6 +22,7 @@ import org.skriptlang.skript.lang.converter.Converters; import java.util.Iterator; +import java.util.function.Predicate; public class ExprExpression implements Expression { static { @@ -123,12 +124,12 @@ public boolean isSingle() { } @Override - public boolean check(Event e, Checker c, boolean negated) { + public boolean check(Event e, Predicate c, boolean negated) { return SimpleExpression.check(getAll(e), c, negated, getAnd()); } @Override - public boolean check(Event e, Checker c) { + public boolean check(Event e, Predicate c) { return SimpleExpression.check(getAll(e), c, false, getAnd()); } diff --git a/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprRawExpression.java b/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprRawExpression.java index b55da9d..5dd0117 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprRawExpression.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/custom/ExprRawExpression.java @@ -15,7 +15,7 @@ public class ExprRawExpression extends SimpleExpression { static { Skript.registerExpression(ExprRawExpression.class, Expression.class, ExpressionType.COMBINED, - "[the] raw %objects%"); + "[the] raw [expression] %objects%"); } private Expression expr; diff --git a/src/main/java/com/btk5h/skriptmirror/skript/reflect/ExprJavaCall.java b/src/main/java/com/btk5h/skriptmirror/skript/reflect/ExprJavaCall.java index bf52619..415eae5 100644 --- a/src/main/java/com/btk5h/skriptmirror/skript/reflect/ExprJavaCall.java +++ b/src/main/java/com/btk5h/skriptmirror/skript/reflect/ExprJavaCall.java @@ -2,10 +2,7 @@ import ch.njol.skript.Skript; import ch.njol.skript.classes.Changer; -import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.ExpressionList; -import ch.njol.skript.lang.ExpressionType; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.*; import ch.njol.skript.lang.util.SimpleExpression; import ch.njol.skript.registrations.Classes; import ch.njol.skript.util.Utils; @@ -49,6 +46,7 @@ import java.util.List; import java.util.Objects; import java.util.Optional; +import java.util.function.Predicate; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -165,10 +163,11 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye } if (staticDescriptor.getJavaClass() == null - && rawTarget instanceof StructImport.ImportHandler) { - staticDescriptor = staticDescriptor.orDefaultClass( - ((StructImport.ImportHandler) rawTarget).getJavaType().getJavaClass() - ); + && rawTarget instanceof Literal literal) { + Object rawTargetValue = literal.getSingle(); + if (rawTargetValue instanceof JavaType) { + staticDescriptor = staticDescriptor.orDefaultClass(((JavaType) rawTargetValue).getJavaClass()); + } } if (staticDescriptor.getParameterTypes() != null && type.equals(CallType.FIELD)) { @@ -253,12 +252,12 @@ public boolean isSingle() { } @Override - public boolean check(Event e, Checker c, boolean negated) { + public boolean check(Event e, Predicate c, boolean negated) { return SimpleExpression.check(getAll(e), c, negated, getAnd()); } @Override - public boolean check(Event e, Checker c) { + public boolean check(Event e, Predicate c) { return SimpleExpression.check(getAll(e), c, false, getAnd()); } diff --git a/src/main/java/com/btk5h/skriptmirror/util/SkriptReflection.java b/src/main/java/com/btk5h/skriptmirror/util/SkriptReflection.java index 6c6f41d..3a60170 100644 --- a/src/main/java/com/btk5h/skriptmirror/util/SkriptReflection.java +++ b/src/main/java/com/btk5h/skriptmirror/util/SkriptReflection.java @@ -15,8 +15,11 @@ import ch.njol.skript.variables.Variables; import com.btk5h.skriptmirror.SkriptMirror; import org.bukkit.event.Event; +import org.skriptlang.reflect.syntax.CustomSyntaxStructure; import org.skriptlang.reflect.syntax.event.elements.ExprReplacedEventValue; import org.skriptlang.skript.lang.script.Script; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; @@ -29,28 +32,17 @@ @SuppressWarnings("unchecked") public class SkriptReflection { - private static Field PATTERNS; private static Field LOCAL_VARIABLES; private static Field NODES; private static Method VARIABLES_MAP_COPY; private static Field DEFAULT_EXPRESSION; private static Field PARSED_VALUE; - private static Field EXPRESSIONS; private static Field OPTIONS; static { Field _FIELD; Method _METHOD; - try { - _FIELD = SyntaxElementInfo.class.getDeclaredField("patterns"); - _FIELD.setAccessible(true); - PATTERNS = _FIELD; - } catch (NoSuchFieldException e) { - warning("Skript's pattern info field could not be resolved. " + - "Custom syntax and imports will not work."); - } - try { _FIELD = Variables.class.getDeclaredField("localVariables"); _FIELD.setAccessible(true); @@ -99,15 +91,6 @@ public class SkriptReflection { "therefore and/or warnings won't be suppressed"); } - try { - _FIELD = Skript.class.getDeclaredField("expressions"); - _FIELD.setAccessible(true); - EXPRESSIONS = _FIELD; - } catch (NoSuchFieldException e) { - warning("Skript's expressions field could not be resolved, " + - "therefore you might get syntax conflict problems"); - } - try { _FIELD = StructOptions.OptionsData.class.getDeclaredField("options"); _FIELD.setAccessible(true); @@ -121,17 +104,6 @@ private static void warning(String message) { SkriptMirror.getInstance().getLogger().warning(message); } - public static void setPatterns(SyntaxElementInfo info, String[] patterns) { - if (PATTERNS == null) - return; - - try { - PATTERNS.set(info, patterns); - } catch (IllegalAccessException e) { - e.printStackTrace(); - } - } - /** * Sets the local variables of an {@link Event} to the given local variables. */ @@ -271,20 +243,6 @@ public static void disableAndOrWarnings() { } } - /** - * {@return} a list of all of Skript's registered {@link ch.njol.skript.lang.Expression}s. - */ - public static List> getExpressions() { - if (EXPRESSIONS == null) - return new ArrayList<>(); - - try { - return (List>) EXPRESSIONS.get(null); - } catch (IllegalAccessException e) { - throw new RuntimeException(e); - } - } - /** * Gets the modifiable options map from an options data object. * diff --git a/src/main/java/org/skriptlang/reflect/java/elements/structures/StructImport.java b/src/main/java/org/skriptlang/reflect/java/elements/structures/StructImport.java index 50cd8c4..d01bfb3 100644 --- a/src/main/java/org/skriptlang/reflect/java/elements/structures/StructImport.java +++ b/src/main/java/org/skriptlang/reflect/java/elements/structures/StructImport.java @@ -5,17 +5,12 @@ import ch.njol.skript.command.EffectCommandEvent; import ch.njol.skript.lang.Effect; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.ExpressionType; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.skript.lang.SyntaxElementInfo; -import ch.njol.skript.lang.util.SimpleExpression; import ch.njol.util.Kleenean; import com.btk5h.skriptmirror.JavaType; import com.btk5h.skriptmirror.LibraryLoader; import com.btk5h.skriptmirror.util.SkriptMirrorUtil; -import com.btk5h.skriptmirror.util.SkriptReflection; -import com.btk5h.skriptmirror.util.SkriptUtil; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; import org.skriptlang.skript.lang.entry.EntryContainer; @@ -25,29 +20,19 @@ import java.util.HashMap; import java.util.Map; import java.util.Optional; -import java.util.Spliterator; -import java.util.Spliterators; import java.util.regex.Matcher; import java.util.regex.Pattern; -import java.util.stream.StreamSupport; public class StructImport extends Structure { public static final Priority PRIORITY = new Priority(150); private static final Pattern IMPORT_STATEMENT = Pattern.compile("(" + SkriptMirrorUtil.PACKAGE + ")(?:\\s+as (" + SkriptMirrorUtil.IDENTIFIER + "))?"); - private static final SyntaxElementInfo thisInfo; private static final Map> imports = new HashMap<>(); static { Skript.registerStructure(StructImport.class, "import"); Skript.registerEffect(EffImport.class, "import <" + IMPORT_STATEMENT.pattern() + ">"); - - // TODO try replacing ImportHandler with JavaType's literal parsing - Skript.registerExpression(ImportHandler.class, JavaType.class, ExpressionType.SIMPLE); - thisInfo = StreamSupport.stream(Spliterators.spliteratorUnknownSize(Skript.getExpressions(), Spliterator.ORDERED), false) - .filter(expressionInfo -> ImportHandler.class.equals(expressionInfo.getElementClass())) - .findFirst().orElseThrow(RuntimeException::new); // Should never be null } private Script script; @@ -55,10 +40,10 @@ public class StructImport extends Structure { @Override public boolean init(Literal[] args, int matchedPattern, ParseResult parseResult, EntryContainer entryContainer) { this.script = getParser().getCurrentScript(); - getEntryContainer().getSource().forEach(node -> registerImport(Optional.ofNullable(node.getKey()) + assert entryContainer != null; // entryContainer will always be non-null as this is not a simple structure + entryContainer.getSource().forEach(node -> registerImport(Optional.ofNullable(node.getKey()) .map(ScriptLoader::replaceOptions) .orElse(null), script)); - updateImports(); return true; } @@ -70,7 +55,6 @@ public boolean load() { @Override public void unload() { imports.remove(script); - updateImports(); } @Override @@ -83,6 +67,12 @@ public String toString(@Nullable Event e, boolean debug) { return "import"; } + /** + * Registers an import + * @param rawStatement the raw statement representing the string to import + * @param script the script this import belongs to + * @return whether the import was registered successfully + */ private static boolean registerImport(String rawStatement, @Nullable Script script) { Matcher statement = IMPORT_STATEMENT.matcher(ScriptLoader.replaceOptions(rawStatement)); if (!statement.matches()) { @@ -124,50 +114,6 @@ private static boolean registerImport(String rawStatement, @Nullable Script scri return true; } - private static void updateImports() { - String[] patterns = imports.values().stream() - .flatMap(m -> m.keySet().stream()) - .distinct() - .toArray(String[]::new); - SkriptReflection.setPatterns(thisInfo, patterns); - } - - public static class ImportHandler extends SimpleExpression { - - private JavaType type; - - @Override - protected JavaType[] get(Event e) { - return new JavaType[]{type}; - } - - @Override - public boolean isSingle() { - return true; - } - - @Override - public Class getReturnType() { - return JavaType.class; - } - - @Override - public String toString(Event e, boolean debug) { - return type.getJavaClass().getName(); - } - - @Override - public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { - type = lookup(SkriptUtil.getCurrentScript(), parseResult.expr); - return type != null; - } - - public JavaType getJavaType() { - return type; - } - - } - public static JavaType lookup(Script script, String identifier) { Map localImports = imports.get(script); @@ -190,13 +136,11 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye } className = parseResult.regexes.get(0).group(); - - return registerImport(className, null); + return registerImport(className, null); // No script in an effect command } @Override - protected void execute(Event e) { - updateImports(); + protected void execute(Event event) { } @Override diff --git a/src/main/java/org/skriptlang/reflect/syntax/CustomSyntaxStructure.java b/src/main/java/org/skriptlang/reflect/syntax/CustomSyntaxStructure.java index c2ae3de..15258cc 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/CustomSyntaxStructure.java +++ b/src/main/java/org/skriptlang/reflect/syntax/CustomSyntaxStructure.java @@ -5,6 +5,7 @@ import ch.njol.skript.config.SectionNode; import ch.njol.skript.lang.SyntaxElementInfo; import ch.njol.skript.lang.VariableString; +import com.btk5h.skriptmirror.SkriptMirror; import org.skriptlang.reflect.java.elements.structures.StructImport; import org.skriptlang.reflect.syntax.event.elements.CustomEvent; import org.skriptlang.reflect.syntax.event.EventSyntaxInfo; @@ -18,6 +19,8 @@ import org.skriptlang.skript.lang.entry.EntryValidator; import org.skriptlang.skript.lang.script.Script; import org.skriptlang.skript.lang.structure.Structure; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.ArrayList; import java.util.HashMap; @@ -30,6 +33,7 @@ public abstract class CustomSyntaxStructure extends Structure { + public static final String DEFAULT_PATTERN = "this is here because at least one pattern is required"; public static final Priority PRIORITY = new Priority(350); public static class CustomSyntaxEvent extends Event { @@ -48,7 +52,8 @@ public DataTracker() { private List patterns = new ArrayList<>(); private final Map> primaryData = new HashMap<>(); private final List> managedData = new ArrayList<>(); - private SyntaxElementInfo info; + private SyntaxRegistry.Key syntaxKey; + private SyntaxInfo info; public List getPatterns() { return patterns; @@ -62,7 +67,7 @@ public Map> getPrimaryData() { return managedData; } - public SyntaxElementInfo getInfo() { + public SyntaxInfo getInfo() { return info; } @@ -72,13 +77,14 @@ public void recomputePatterns() { .flatMap(Set::stream) .distinct() .collect(Collectors.toList()); + patterns.add(0, DEFAULT_PATTERN); // registration api compatibility workaround } public void addManaged(Map data) { managedData.add(data); } - public void setInfo(SyntaxElementInfo info) { + public void setInfo(SyntaxInfo info) { this.info = info; } @@ -101,6 +107,14 @@ public final T lookup(Script script, int matchedPattern) { return globalSyntax.get(originalSyntax); } + + public SyntaxRegistry.Key getSyntaxKey() { + return syntaxKey; + } + + public void setSyntaxKey(SyntaxRegistry.Key syntaxKey) { + this.syntaxKey = syntaxKey; + } } public abstract static class SyntaxData { @@ -178,7 +192,16 @@ public String toString(Event e, boolean debug) { private void update() { getDataTracker().recomputePatterns(); - SkriptReflection.setPatterns(getDataTracker().getInfo(), getDataTracker().getPatterns().toArray(new String[0])); + SyntaxRegistry syntaxRegistry = SkriptMirror.getAddonInstance().syntaxRegistry(); + SyntaxInfo oldSyntaxInfo = getDataTracker().getInfo(); + // an angel weeps + syntaxRegistry.unregister((SyntaxRegistry.Key) getDataTracker().getSyntaxKey(), (SyntaxInfo) oldSyntaxInfo); + SyntaxInfo newSyntaxInfo = oldSyntaxInfo.toBuilder() + .clearPatterns() + .addPatterns(getDataTracker().getPatterns()) + .build(); + syntaxRegistry.register((SyntaxRegistry.Key) getDataTracker().getSyntaxKey(), newSyntaxInfo); + getDataTracker().setInfo(newSyntaxInfo); } protected final void register(T data) { diff --git a/src/main/java/org/skriptlang/reflect/syntax/condition/elements/CustomCondition.java b/src/main/java/org/skriptlang/reflect/syntax/condition/elements/CustomCondition.java index 104fe16..d6aa285 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/condition/elements/CustomCondition.java +++ b/src/main/java/org/skriptlang/reflect/syntax/condition/elements/CustomCondition.java @@ -74,6 +74,11 @@ public String toString(Event e, boolean debug) { @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + // prevent the user from using the placeholder pattern we register in order to satisfy the registration requirements + if (matchedPattern == 0) { + return false; + } + which = StructCustomCondition.lookup(SkriptUtil.getCurrentScript(), matchedPattern); if (which == null) { diff --git a/src/main/java/org/skriptlang/reflect/syntax/condition/elements/StructCustomCondition.java b/src/main/java/org/skriptlang/reflect/syntax/condition/elements/StructCustomCondition.java index 9caaf67..f72d94a 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/condition/elements/StructCustomCondition.java +++ b/src/main/java/org/skriptlang/reflect/syntax/condition/elements/StructCustomCondition.java @@ -12,13 +12,17 @@ import ch.njol.skript.lang.util.SimpleEvent; import ch.njol.skript.log.SkriptLogger; import ch.njol.skript.util.Utils; +import com.btk5h.skriptmirror.SkriptMirror; import com.btk5h.skriptmirror.skript.custom.SyntaxParseEvent; +import com.btk5h.skriptmirror.util.SkriptReflection; import com.btk5h.skriptmirror.util.SkriptUtil; import org.skriptlang.reflect.syntax.CustomSyntaxStructure; import org.skriptlang.reflect.syntax.condition.ConditionCheckEvent; import org.skriptlang.reflect.syntax.condition.ConditionSyntaxInfo; import org.skriptlang.skript.lang.entry.EntryContainer; import org.skriptlang.skript.lang.script.Script; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.Arrays; import java.util.HashMap; @@ -45,7 +49,7 @@ public class StructCustomCondition extends CustomSyntaxStructure dataTracker = new DataTracker<>(); + public static final DataTracker dataTracker = new DataTracker<>(); static final Map conditionHandlers = new HashMap<>(); static final Map parserHandlers = new HashMap<>(); @@ -53,11 +57,12 @@ public class StructCustomCondition extends CustomSyntaxStructure parseSectionLoaded = new HashMap<>(); static { - Skript.registerCondition(CustomCondition.class); - Optional> info = Skript.getConditions().stream() - .filter(i -> i.getElementClass() == CustomCondition.class) + Skript.registerCondition(CustomCondition.class, DEFAULT_PATTERN); + Optional> info = SkriptMirror.getAddonInstance().syntaxRegistry().syntaxes(SyntaxRegistry.CONDITION).stream() + .filter(i -> i.type() == CustomCondition.class) .findFirst(); info.ifPresent(dataTracker::setInfo); + dataTracker.setSyntaxKey(SyntaxRegistry.CONDITION); dataTracker.addManaged(conditionHandlers); dataTracker.addManaged(parserHandlers); diff --git a/src/main/java/org/skriptlang/reflect/syntax/effect/elements/CustomEffect.java b/src/main/java/org/skriptlang/reflect/syntax/effect/elements/CustomEffect.java index 7aa8e4b..3aa2034 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/effect/elements/CustomEffect.java +++ b/src/main/java/org/skriptlang/reflect/syntax/effect/elements/CustomEffect.java @@ -72,6 +72,11 @@ public String toString(Event e, boolean debug) { @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + // prevent the user from using the placeholder pattern we register in order to satisfy the registration requirements + if (matchedPattern == 0) { + return false; + } + which = StructCustomEffect.lookup(SkriptUtil.getCurrentScript(), matchedPattern); if (which == null) { diff --git a/src/main/java/org/skriptlang/reflect/syntax/effect/elements/StructCustomEffect.java b/src/main/java/org/skriptlang/reflect/syntax/effect/elements/StructCustomEffect.java index 78e6846..ae66550 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/effect/elements/StructCustomEffect.java +++ b/src/main/java/org/skriptlang/reflect/syntax/effect/elements/StructCustomEffect.java @@ -10,6 +10,7 @@ import ch.njol.skript.lang.TriggerItem; import ch.njol.skript.lang.util.SimpleEvent; import ch.njol.skript.log.SkriptLogger; +import com.btk5h.skriptmirror.SkriptMirror; import com.btk5h.skriptmirror.skript.custom.SyntaxParseEvent; import com.btk5h.skriptmirror.util.SkriptUtil; import org.skriptlang.reflect.syntax.CustomSyntaxStructure; @@ -17,6 +18,8 @@ import org.skriptlang.reflect.syntax.effect.EffectTriggerEvent; import org.skriptlang.skript.lang.entry.EntryContainer; import org.skriptlang.skript.lang.script.Script; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.HashMap; import java.util.List; @@ -40,7 +43,7 @@ public class StructCustomEffect extends CustomSyntaxStructure ); } - private static final DataTracker dataTracker = new DataTracker<>(); + public static final DataTracker dataTracker = new DataTracker<>(); static final Map effectHandlers = new HashMap<>(); static final Map parserHandlers = new HashMap<>(); @@ -48,12 +51,13 @@ public class StructCustomEffect extends CustomSyntaxStructure static final Map parseSectionLoaded = new HashMap<>(); static { - Skript.registerEffect(CustomEffect.class); - Optional> info = Skript.getEffects().stream() - .filter(i -> i.getElementClass() == CustomEffect.class) + Skript.registerEffect(CustomEffect.class, DEFAULT_PATTERN); + Optional> info = SkriptMirror.getAddonInstance().syntaxRegistry().syntaxes(SyntaxRegistry.EFFECT).stream() + .filter(i -> i.type() == CustomEffect.class) .findFirst(); info.ifPresent(dataTracker::setInfo); + dataTracker.setSyntaxKey(SyntaxRegistry.EFFECT); dataTracker.addManaged(effectHandlers); dataTracker.addManaged(parserHandlers); dataTracker.addManaged(usableSuppliers); diff --git a/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java b/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java index dbc515c..9e52f5a 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java +++ b/src/main/java/org/skriptlang/reflect/syntax/event/elements/CustomEvent.java @@ -34,6 +34,11 @@ public class CustomEvent extends SkriptEvent { @Override public boolean init(Literal[] args, int matchedPattern, SkriptParser.ParseResult parseResult) { + // prevent the user from using the placeholder pattern we register in order to satisfy the registration requirements + if (matchedPattern == 0) { + return false; + } + which = StructCustomEvent.lookup(SkriptUtil.getCurrentScript(), matchedPattern); if (which == null) { diff --git a/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java b/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java index d526ff1..14bd87d 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java +++ b/src/main/java/org/skriptlang/reflect/syntax/event/elements/StructCustomEvent.java @@ -10,6 +10,7 @@ import ch.njol.skript.lang.TriggerItem; import ch.njol.skript.lang.util.SimpleEvent; import ch.njol.skript.log.SkriptLogger; +import com.btk5h.skriptmirror.SkriptMirror; import com.btk5h.skriptmirror.skript.custom.SyntaxParseEvent; import com.btk5h.skriptmirror.util.SkriptReflection; import com.btk5h.skriptmirror.util.SkriptUtil; @@ -18,8 +19,14 @@ import org.skriptlang.reflect.syntax.event.EventSyntaxInfo; import org.skriptlang.reflect.syntax.event.EventTriggerEvent; import org.skriptlang.reflect.syntax.event.EventValuesEntryData; +import org.skriptlang.skript.bukkit.registration.BukkitRegistryKeys; +import org.skriptlang.skript.bukkit.registration.BukkitSyntaxInfos; import org.skriptlang.skript.lang.entry.EntryContainer; import org.skriptlang.skript.lang.script.Script; +import org.skriptlang.skript.lang.structure.Structure; +import org.skriptlang.skript.registration.DefaultSyntaxInfos; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.Collections; import java.util.HashMap; @@ -55,12 +62,13 @@ public boolean canCreateWith(String node) { static final Map parseSectionLoaded = new HashMap<>(); static { - Skript.registerEvent("custom event", CustomEvent.class, BukkitCustomEvent.class); - Optional> info = Skript.getEvents().stream() - .filter(i -> i.getElementClass() == CustomEvent.class) + Skript.registerEvent("custom event", CustomEvent.class, BukkitCustomEvent.class, DEFAULT_PATTERN); + Optional> info = SkriptMirror.getAddonInstance().syntaxRegistry().syntaxes(BukkitRegistryKeys.EVENT).stream() + .filter(i -> i.type() == CustomEvent.class) .findFirst(); info.ifPresent(dataTracker::setInfo); + dataTracker.setSyntaxKey(BukkitRegistryKeys.EVENT); dataTracker.addManaged(nameValues); dataTracker.addManaged(eventValueTypes); dataTracker.addManaged(parserHandlers); diff --git a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/CustomExpression.java b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/CustomExpression.java index 50d60fc..f31fe71 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/CustomExpression.java +++ b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/CustomExpression.java @@ -29,6 +29,7 @@ import java.util.Iterator; import java.util.List; import java.util.Objects; +import java.util.function.Predicate; import java.util.function.Supplier; @@ -152,12 +153,12 @@ public boolean isSingle() { } @Override - public boolean check(Event e, Checker c, boolean negated) { + public boolean check(Event e, Predicate c, boolean negated) { return SimpleExpression.check(getAll(e), c, negated, getAnd()); } @Override - public boolean check(Event e, Checker c) { + public boolean check(Event e, Predicate c) { return SimpleExpression.check(getAll(e), c, false, getAnd()); } @@ -258,6 +259,11 @@ public void change(Event e, Object[] delta, Changer.ChangeMode mode) { @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + // prevent the user from using the placeholder pattern we register in order to satisfy the registration requirements + if (matchedPattern == 0) { + return false; + } + which = StructCustomExpression.lookup(SkriptUtil.getCurrentScript(), matchedPattern); if (which == null) { diff --git a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/ExprChangeValue.java b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/ExprChangeValue.java index 7685f7c..41dda05 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/ExprChangeValue.java +++ b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/ExprChangeValue.java @@ -8,7 +8,6 @@ import ch.njol.skript.lang.util.SimpleExpression; import ch.njol.skript.log.ErrorQuality; import ch.njol.skript.util.Utils; -import ch.njol.util.Checker; import ch.njol.util.Kleenean; import ch.njol.util.coll.iterator.ArrayIterator; import com.btk5h.skriptmirror.util.JavaUtil; @@ -17,6 +16,7 @@ import org.skriptlang.skript.lang.converter.Converters; import java.util.Iterator; +import java.util.function.Predicate; public class ExprChangeValue implements Expression { static { @@ -79,12 +79,12 @@ public boolean isSingle() { } @Override - public boolean check(Event e, Checker c, boolean negated) { + public boolean check(Event e, Predicate c, boolean negated) { return SimpleExpression.check(getAll(e), c, negated, getAnd()); } @Override - public boolean check(Event e, Checker c) { + public boolean check(Event e, Predicate c) { return SimpleExpression.check(getAll(e), c, false, getAnd()); } diff --git a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomConstant.java b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomConstant.java index 09ee778..3f0d815 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomConstant.java +++ b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomConstant.java @@ -2,15 +2,11 @@ import ch.njol.skript.Skript; import ch.njol.skript.config.SectionNode; -import ch.njol.skript.lang.ExpressionInfo; -import ch.njol.skript.lang.ExpressionType; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser; -import ch.njol.skript.lang.Trigger; -import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.*; import ch.njol.skript.lang.parser.ParserInstance; import ch.njol.skript.lang.util.SimpleEvent; import ch.njol.util.StringUtils; +import com.btk5h.skriptmirror.SkriptMirror; import org.skriptlang.reflect.syntax.CustomSyntaxStructure; import com.btk5h.skriptmirror.util.SkriptReflection; import com.btk5h.skriptmirror.util.SkriptUtil; @@ -18,6 +14,8 @@ import org.skriptlang.reflect.syntax.expression.ConstantSyntaxInfo; import org.skriptlang.skript.lang.entry.EntryContainer; import org.skriptlang.skript.lang.entry.EntryValidator; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.List; import java.util.Optional; @@ -41,12 +39,13 @@ public class StructCustomConstant extends CustomSyntaxStructure> info = StreamSupport.stream( - Spliterators.spliteratorUnknownSize(Skript.getExpressions(), Spliterator.ORDERED), false) - .filter(i -> i.getElementClass() == CustomExpression.class) + Skript.registerExpression(CustomExpression.class, Object.class, ExpressionType.SIMPLE, DEFAULT_PATTERN); + Optional> info = SkriptMirror.getAddonInstance().syntaxRegistry().elements().stream() + .filter(i -> Expression.class.isAssignableFrom(i.type())) + .filter(i -> i.type() == CustomExpression.class) .findFirst(); info.ifPresent(dataTracker::setInfo); + dataTracker.setSyntaxKey(SyntaxRegistry.EXPRESSION); } @Override diff --git a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomExpression.java b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomExpression.java index 7b15df1..5d91e3a 100644 --- a/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomExpression.java +++ b/src/main/java/org/skriptlang/reflect/syntax/expression/elements/StructCustomExpression.java @@ -4,18 +4,14 @@ import ch.njol.skript.classes.Changer.ChangeMode; import ch.njol.skript.classes.ClassInfo; import ch.njol.skript.config.SectionNode; -import ch.njol.skript.lang.ExpressionInfo; -import ch.njol.skript.lang.ExpressionType; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser; -import ch.njol.skript.lang.Trigger; -import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.*; import ch.njol.skript.lang.util.SimpleEvent; import ch.njol.skript.log.SkriptLogger; import ch.njol.skript.registrations.Classes; import ch.njol.skript.util.Utils; import ch.njol.util.NonNullPair; import ch.njol.util.StringUtils; +import com.btk5h.skriptmirror.SkriptMirror; import org.skriptlang.reflect.syntax.CustomSyntaxStructure; import com.btk5h.skriptmirror.skript.custom.SyntaxParseEvent; import com.btk5h.skriptmirror.util.SkriptUtil; @@ -28,6 +24,8 @@ import org.skriptlang.skript.lang.entry.EntryValidator; import org.skriptlang.skript.lang.entry.KeyValueEntryData; import org.skriptlang.skript.lang.script.Script; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.ArrayList; import java.util.Arrays; @@ -76,7 +74,7 @@ protected Class getValue(String value) { Skript.registerStructure(StructCustomExpression.class, builder.build(), syntax); } - private static final DataTracker dataTracker = new DataTracker<>(); + public static final DataTracker dataTracker = new DataTracker<>(); static final Map> returnTypes = new HashMap<>(); static final Map expressionHandlers = new HashMap<>(); @@ -90,13 +88,14 @@ protected Class getValue(String value) { static { // noinspection unchecked - Skript.registerExpression(CustomExpression.class, Object.class, ExpressionType.PATTERN_MATCHES_EVERYTHING); - Optional> info = StreamSupport.stream( - Spliterators.spliteratorUnknownSize(Skript.getExpressions(), Spliterator.ORDERED), false) - .filter(i -> i.getElementClass() == CustomExpression.class) + Skript.registerExpression(CustomExpression.class, Object.class, ExpressionType.PATTERN_MATCHES_EVERYTHING, DEFAULT_PATTERN); + Optional> info = SkriptMirror.getAddonInstance().syntaxRegistry().elements().stream() + .filter(i -> Expression.class.isAssignableFrom(i.type())) + .filter(i -> i.type() == CustomExpression.class) .findFirst(); info.ifPresent(dataTracker::setInfo); + dataTracker.setSyntaxKey(SyntaxRegistry.EXPRESSION); dataTracker.addManaged(returnTypes); dataTracker.addManaged(expressionHandlers); dataTracker.addManaged(hasChanger); diff --git a/src/test/scripts/custom/custom condition.sk b/src/test/scripts/custom/custom condition.sk new file mode 100644 index 0000000..777a4ff --- /dev/null +++ b/src/test/scripts/custom/custom condition.sk @@ -0,0 +1,26 @@ +condition test true condition: + check: + continue + +condition test false condition: + check: + stop + +condition test input based condition %boolean%: + check: + continue if expr-1 is true + +boolean property condition test property condition: + check: + continue if expr-1 is true + +test "custom conditions": + assert test true condition with "Failed true condition" + + assert test false condition to fail with "Failed false condition" + + assert test input based condition (true) with "Failed input based true condition" + assert test input based condition (false) to fail with "Failed input based false condition" + + assert true is test property condition with "Failed input based true property condition" + assert false isn't test property condition with "Failed input based false property condition" diff --git a/src/test/scripts/custom/custom constants.sk b/src/test/scripts/custom/custom constants.sk new file mode 100644 index 0000000..27193ab --- /dev/null +++ b/src/test/scripts/custom/custom constants.sk @@ -0,0 +1,7 @@ +option test constant value: + get: + return "test constant value" + + +test "custom constants": + assert "{@test constant value}" is "test constant value" with "Failed to get constant" diff --git a/src/test/scripts/custom/custom effects.sk b/src/test/scripts/custom/custom effects.sk new file mode 100644 index 0000000..2e94598 --- /dev/null +++ b/src/test/scripts/custom/custom effects.sk @@ -0,0 +1,8 @@ +effect skript-reflect test set var %string%: + trigger: + set {%expr-1%} to true + +test "custom effects": + delete {skript-reflect.tests.custom effects} + skript-reflect test set var "skript-reflect.tests.custom effects" + assert {skript-reflect.tests.custom effects} is set with "Failed custom effect" diff --git a/src/test/scripts/custom/custom events.sk b/src/test/scripts/custom/custom events.sk new file mode 100644 index 0000000..8f7e033 --- /dev/null +++ b/src/test/scripts/custom/custom events.sk @@ -0,0 +1,47 @@ +event "test custom event": + pattern: test custom event + +event "test custom event with check": + pattern: test custom event with check + check: + continue if {skript-reflect::tests::custom events::run test with check} is set + +event "test custom event with event values": + pattern: test custom event with event values + event-values: string + +event "test custom event with event data": + pattern: test custom event with event data + event-values: string + +on test custom event: + set {skript-reflect::tests::custom events::ran custom event} to true + +on test custom event with check: + set {skript-reflect::tests::custom events::ran custom event with check} to true + +on test custom event with event values: + set {skript-reflect::tests::custom events::event-string} to event-string + +on test custom event with event data: + set {skript-reflect::tests::custom events::provided data} to data "data" + +on script load: + delete {skript-reflect::tests::custom events::*} + + call custom event "test custom event" + assert {skript-reflect::tests::custom events::ran custom event} is set with "Failed to run custom event" + + call custom event "test custom event with check" + assert {skript-reflect::tests::custom events::ran custom event with check} is not set with "Ran custom event when check did not continue" + set {skript-reflect::tests::custom events::run test with check} to true + call custom event "test custom event with check" + assert {skript-reflect::tests::custom events::ran custom event with check} is set with "Did not run custom event when check continued" + + set {_data::data} to "this is the value" + call custom event "test custom event with event data" with data {_data::*} + assert {skript-reflect::tests::custom events::provided data} is {_data::data} with "Failed to get event data" + + set {_event values::string} to "this is the event value" + call custom event "test custom event with event values" with event-values {_event values::*} + assert {skript-reflect::tests::custom events::event-string} is {_event values::string} with "Failed to get event-string" diff --git a/src/test/scripts/custom/custom expressions.sk b/src/test/scripts/custom/custom expressions.sk new file mode 100644 index 0000000..7dae2b9 --- /dev/null +++ b/src/test/scripts/custom/custom expressions.sk @@ -0,0 +1,24 @@ +expression test custom expression: + get: + return true + +plural expression test plural custom expression: + get: + return true and true + +world property test property expression: + get: + return 5 + +test "custom expressions": + assert test custom expression is true with "Failed to get custom expression" + assert (raw expression (test custom expression)).isSingle() is true with "Custom expression is incorrectly non-single" + + assert test plural custom expression is (true and true) with "Failed to get custom expression" + assert (raw expression (test plural custom expression)).isSingle() is false with "Custom expression is incorrectly single" + + set {_world} to random world out of all worlds + assert test property expression of {_world} is 5 with "Failed to get custom property expression (single)" + assert test property expression of ({_world} and {_world}) is 5 with "Failed to get custom property expression (multiple)" + assert (raw expression (test property expression of {_world})).isSingle() is true with "Custom property expression is incorrectly non-single" + assert (raw expression (test property expression of ({_world} and {_world}))).isSingle() is false with "Custom property expression is incorrectly single" diff --git a/src/test/scripts/reflect/EffImport.sk b/src/test/scripts/reflect/EffImport.sk new file mode 100644 index 0000000..80077f0 --- /dev/null +++ b/src/test/scripts/reflect/EffImport.sk @@ -0,0 +1,13 @@ +import: + ch.njol.skript.SkriptConfig + +function runEffectCommand(effect: string): + set {_effect command token} to SkriptConfig.effectCommandToken.value() + execute console command "%{_effect command token}%%{_effect}%" + +test "import from effect": + delete {tests::EffImport::byte size} + runEffectCommand("import java.lang.Byte") + runEffectCommand("set {tests::EffImport::byte size} to Byte.SIZE") + assert {tests::EffImport::byte size} is set with "Failed to use import from effect" + delete {tests::EffImport::byte size} diff --git a/src/test/scripts/ExprJavaCall.sk b/src/test/scripts/reflect/ExprJavaCall.sk similarity index 100% rename from src/test/scripts/ExprJavaCall.sk rename to src/test/scripts/reflect/ExprJavaCall.sk diff --git a/src/test/scripts/reflect/StructImport.sk b/src/test/scripts/reflect/StructImport.sk new file mode 100644 index 0000000..ff7b335 --- /dev/null +++ b/src/test/scripts/reflect/StructImport.sk @@ -0,0 +1,7 @@ +import: + java.lang.Math + java.lang.Math as AliasForMath + +test "import from structure": + assert Math.PI is set with "Failed to use import from structure" + assert AliasForMath.PI is set with "Failed to use import alias from structure"