Add accepts change condition

.github/workflows/gradle.yml

@@ -39,5 +39,5 @@ jobs:
         uses: SkriptLang/[email protected]
         with:
           test_script_directory: src/test/scripts
-          skript_repo_ref: 2.8.2
+          skript_repo_ref: dev/patch
           extra_plugins_directory: extra-plugins/

src/main/java/com/btk5h/skriptmirror/skript/CondAcceptsChange.java

@@ -0,0 +1,123 @@
+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.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;
+
+
+public class CondAcceptsChange extends Condition {
+
+  private static final Patterns<ChangeMode> 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't|cannot) be deleted", ChangeMode.DELETE},
+      {"%expressions% can be reset", ChangeMode.RESET},
+      {"%expressions% (can't|cannot) be reset", ChangeMode.RESET}
+  });
+
+  static {
+    Skript.registerCondition(CondAcceptsChange.class, PATTERNS.getPatterns());
+  }
+
+  private ChangeMode desiredChangeMode;
+  private boolean desiredTypeIsPlural;
+  private Expression<ClassInfo<?>> desiredType;
+  private Expression<Expression<?>> expressions;
+
+  @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) {
+      case ADD:
+      case REMOVE:
+      case REMOVE_ALL:
+        desiredType = exprs[0];
+        expressions = (Expression<Expression<?>>) exprs[1];
+        break;
+      case SET:
+        expressions = (Expression<Expression<?>>) exprs[0];
+        desiredType =  exprs[1];
+        break;
+      case RESET:
+      case DELETE:
+        expressions = (Expression<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<ClassInfo<?>>) desiredType;
+    }
+    return true;
+  }
+
+  @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(), desiredTypeIsPlural), isNegated());
+  }
+
+  @Override
+  public String toString(@Nullable Event event, boolean debug) {
+    String expressionsString = expressions.toString(event, debug);
+    String desiredTypesString = desiredType == null ? null : desiredType.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, Class<?> desiredType, boolean typeIsPlural) {
+    Class<?>[] acceptableTypes = expression.acceptChange(desiredChangeMode);
+    //noinspection ConstantValue
+    if (acceptableTypes != null) {
+      for (Class<?> acceptableType : acceptableTypes) {
+        if (acceptableType.isArray()
+            && acceptableType.getComponentType().isAssignableFrom(desiredType)) {
+          return true;
+        } else if (!typeIsPlural && acceptableType.isAssignableFrom(desiredType))
+          return true;
+      }
+    }
+    return false;
+  }
+
+}

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<Expression<?>>() {
+          @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);
+          }
+        }));
+
   }
 
 }

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<ClassInfo<?>, Boolean> getUserClassInfoAndPlural(String name) {
     NonNullPair<String, Boolean> wordData = Utils.getEnglishPlural(name);

src/test/scripts/CondChange.sk

@@ -0,0 +1,33 @@
+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 (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"
+  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"
+  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"
+
+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 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 player can be removed from raw ({_v::*}) with "all integer 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"