Update to the latest Minecraft version with Velocity migration

.github/workflows/build.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        java: [ '17' ]
+        java: [ '21' ]
     steps:
       - if: ${{ github.event_name == 'push' }}
         uses: actions/checkout@v4

build.gradle.kts

@@ -40,6 +40,12 @@ subprojects {
         compileOnly(rootProject.libs.jda)
     }
 
+    sourceSets {
+        main {
+            java.srcDir(project(":common").sourceSets.main.get().java.srcDirs)
+        }
+    }
+
     tasks {
         compileJava {
             options.encoding = utf8

common/build.gradle.kts

@@ -0,0 +1,27 @@
+plugins {
+    `java-library`
+    alias(libs.plugins.shadow)
+}
+
+dependencies {
+    api(libs.adventure.api)
+    api(libs.adventure.ansi)
+    api(libs.adventure.gson)
+    api(libs.adventure.legacy)
+    api(libs.adventure.plain)
+    api(libs.adventure.minimessage)
+    api(libs.netty.buffer)
+}
+
+tasks {
+    shadowJar {
+        destinationDirectory.set(file("$rootDir/build"))
+
+        archiveBaseName.set(rootProject.name + "-" + project.name)
+        archiveVersion.set(project.version.toString())
+    }
+
+    build {
+        dependsOn(shadowJar)
+    }
+}

common/src/main/java/com/minersstudios/whomine/api/annotation/Key.java → common/src/main/java/com/minersstudios/whomine/api/annotation/Path.java

@@ -1,6 +1,6 @@
 package com.minersstudios.whomine.api.annotation;
 
-import com.minersstudios.whomine.api.throwable.InvalidRegexException;
+import com.minersstudios.whomine.api.throwable.InvalidResourceException;
 import org.intellij.lang.annotations.RegExp;
 import org.intellij.lang.annotations.Subst;
 import org.jetbrains.annotations.Contract;
@@ -14,11 +14,11 @@
 import static java.lang.annotation.ElementType.*;
 
 /**
- * Annotation used to mark the key.
+ * Annotation used to mark the path.
  * <br>
- * The key must match the {@link #REGEX regex} pattern.
+ * The path must match the {@link #REGEX regex} pattern.
  *
- * @see Key.Validator
+ * @see Path.Validator
  */
 @Documented
 @Retention(RetentionPolicy.CLASS)
@@ -28,14 +28,14 @@
         METHOD,
         PARAMETER
 })
-@org.intellij.lang.annotations.Pattern(Key.REGEX)
-public @interface Key {
-    /** The regex pattern that a valid key must match */
+@org.intellij.lang.annotations.Pattern(Path.REGEX)
+public @interface Path {
+    /** The regex pattern that a valid path must match */
     @RegExp String REGEX = "[a-z0-9/._-]*";
 
     /**
-     * Validator class for the {@link Key} annotation to check whether the
-     * key matches the {@link #REGEX regex}
+     * Validator class for the {@link Path} annotation to check whether the
+     * path matches the {@link #REGEX regex}
      *
      * @see #matches(String)
      * @see #validate(String)
@@ -48,18 +48,18 @@ private Validator() throws AssertionError {
         }
 
         /**
-         * Checks whether the key matches the {@link #REGEX regex}
+         * Checks whether the path matches the {@link #REGEX regex}
          *
-         * @param key The key
-         * @return Whether the key matches the {@link #REGEX regex}
+         * @param path The path
+         * @return Whether the path matches the {@link #REGEX regex}
          */
-        public static boolean matches(final @Subst("key") @Key @Nullable String key) {
-            if (key == null) {
+        public static boolean matches(final @Subst("path") @Path @Nullable String path) {
+            if (path == null) {
                 return true;
             }
 
-            for(int i = 0; i < key.length(); ++i) {
-                final char character = key.charAt(i);
+            for(int i = 0; i < path.length(); ++i) {
+                final char character = path.charAt(i);
 
                 switch (character) {
                     case '_', '-', '.', '/' -> {}
@@ -77,16 +77,16 @@ public static boolean matches(final @Subst("key") @Key @Nullable String key) {
         }
 
         /**
-         * Validates the key
+         * Validates the path
          *
-         * @param key The key
-         * @throws InvalidRegexException If the key does not match the
-         *                               {@link #REGEX regex}
+         * @param path The path
+         * @throws InvalidResourceException If the path does not match the
+         *                                  {@link #REGEX regex}
          * @see #matches(String)
          */
-        public static void validate(final @Subst("key") @Key @Nullable String key) throws InvalidRegexException {
-            if (!matches(key)) {
-                throw new InvalidRegexException("Key must match regex: " + REGEX);
+        public static void validate(final @Subst("path") @Path @Nullable String path) throws InvalidResourceException {
+            if (!matches(path)) {
+                throw new InvalidResourceException("Path must match regex: " + REGEX);
             }
         }
     }

common/src/main/java/com/minersstudios/whomine/api/annotation/Resource.java

@@ -0,0 +1,104 @@
+package com.minersstudios.whomine.api.annotation;
+
+import com.minersstudios.whomine.api.throwable.InvalidResourceException;
+import org.intellij.lang.annotations.RegExp;
+import org.intellij.lang.annotations.Subst;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * Annotation used to mark the resource.
+ * <br>
+ * The resource must match the {@link #REGEX regex} pattern.
+ *
+ * @see Resource.Validator
+ */
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({
+        FIELD,
+        LOCAL_VARIABLE,
+        METHOD,
+        PARAMETER
+})
+@org.intellij.lang.annotations.Pattern(Resource.REGEX)
+public @interface Resource {
+    /** The regex pattern that a valid resource must match */
+    @RegExp String REGEX = "[a-z0-9._-]*";
+
+    /** The empty resource */
+    @Resource String EMPTY = "";
+    /** The Minecraft resource */
+    @Resource String MINECRAFT = "minecraft";
+    /** The Realms resource */
+    @Resource String REALMS = "realms";
+    /** The Paper resource */
+    @Resource String PAPER = "paper";
+    /** The WhoMine resource */
+    @Resource String WHOMINE = "whomine";
+
+    /**
+     * Validator class for the {@link Resource} annotation to check whether the
+     * resource matches the {@link #REGEX regex}
+     *
+     * @see #matches(String)
+     * @see #validate(String)
+     */
+    final class Validator {
+
+        @Contract(" -> fail")
+        private Validator() throws AssertionError {
+            throw new AssertionError("Utility class");
+        }
+
+        /**
+         * Checks whether the resource matches the {@link #REGEX regex}
+         *
+         * @param resource The resource
+         * @return Whether the resource matches the {@link #REGEX regex}
+         */
+        public static boolean matches(final @Subst("resource") @Resource @Nullable String resource) {
+            if (resource == null) {
+                return false;
+            }
+
+            for(int i = 0; i < resource.length(); ++i) {
+                final char character = resource.charAt(i);
+
+                switch (character) {
+                    case '_', '-', '.' -> {}
+                    default -> {
+                        if (character < 'a' || character > 'z') {
+                            if (character < '0' || character > '9') {
+                                return false;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        /**
+         * Validates the resource
+         *
+         * @param resource The resource
+         * @throws InvalidResourceException If the resource does not match the
+         *                                  {@link #REGEX regex}
+         * @see #matches(String)
+         */
+        public static void validate(final @Subst("resource") @Resource @Nullable String resource) throws InvalidResourceException {
+            if (!matches(resource)) {
+                throw new InvalidResourceException("Resource must match regex: " + REGEX);
+            }
+        }
+    }
+}