Regex simple matcher comparison.

Author: Moderocky

src/main/java/org/byteskript/skript/compiler/SkriptLangSpec.java

@@ -175,6 +175,7 @@ private SkriptLangSpec() {
             new NotEqual(),
             new IsEqual(),
             new Contains(),
+            new Matches(),
             new TernaryOtherwiseExpression(),
             new BinaryOtherwiseExpression(),
             new StringLiteral(),

src/main/java/org/byteskript/skript/lang/syntax/comparison/Matches.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2021 ByteSkript org (Moderocky)
+ * View the full licence information and permissions:
+ * https://github.com/Moderocky/ByteSkript/blob/master/LICENSE
+ */
+
+package org.byteskript.skript.lang.syntax.comparison;
+
+import mx.kenzie.foundation.MethodBuilder;
+import mx.kenzie.foundation.Type;
+import mx.kenzie.foundation.WriteInstruction;
+import org.byteskript.skript.api.syntax.RelationalExpression;
+import org.byteskript.skript.compiler.*;
+import org.byteskript.skript.lang.element.StandardElements;
+import org.byteskript.skript.runtime.internal.OperatorHandler;
+
+import java.lang.reflect.Method;
+
+public class Matches extends RelationalExpression {
+    
+    public Matches() {
+        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "%String% matches %Pattern%");
+    }
+    
+    @Override
+    public Pattern.Match match(String thing, Context context) {
+        if (!thing.contains(" matches ")) return null;
+        return super.match(thing, context);
+    }
+    
+    @Override
+    public void compile(Context context, Pattern.Match match) {
+        try {
+            final MethodBuilder method = context.getMethod();
+            assert method != null;
+            final Method target = OperatorHandler.class.getDeclaredMethod("matches", Object.class, Object.class);
+            method.writeCode(WriteInstruction.invokeStatic(target));
+            context.setState(CompileState.STATEMENT);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+    
+    @Override
+    public Type getReturnType() {
+        return CommonTypes.BOOLEAN;
+    }
+    
+    @Override
+    public String description() {
+        return """
+            Check whether the first string matches the given RegEx pattern.""";
+    }
+    
+}

src/main/java/org/byteskript/skript/runtime/internal/OperatorHandler.java

@@ -9,6 +9,7 @@
 import org.byteskript.skript.error.ScriptRuntimeError;
 
 import java.util.*;
+import java.util.regex.Pattern;
 
 public class OperatorHandler {
 
@@ -209,6 +210,13 @@ public static Boolean contains(Object a, Object b) {
         if (a instanceof Map<?, ?> map) return map.containsKey(b) || map.containsValue(b);
         return (a + "").contains(b + "");
     }
+    
+    public static Boolean matches(Object a, Object b) {
+        if (a == null) return false;
+        if (b == null) return false;
+        if (!(b instanceof Pattern pattern)) return equals(a, b); // probably a mistaken use?
+        return pattern.matcher(a + "").matches();
+    }
     //endregion
 
 }

src/test/resources/generic.bsk

@@ -19,8 +19,10 @@ function generic_expressions:
         assert newline is a string: "New line is not a string."
         set {regex} to /hello there/
         assert {regex} exists: "Regex literal failed to load."
+        assert "hello there" matches {regex}: "Regex failed to match exact."
         set {regex} to /.+/
         assert {regex} exists: "Regex literal failed to load."
+        assert "blob blob" matches {regex}: "Regex failed to match anything."
 
 
 function test_system: