Merge pull request #10 from TheNextLvl-net/drop-hangar4j

Drop hangar4j

Author: NonSwag

paper/build.gradle.kts

@@ -16,7 +16,6 @@ version = "1.4.1"
 
 repositories {
     mavenCentral()
-    maven("https://jitpack.io")
     maven("https://repo.papermc.io/repository/maven-public/")
     maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
 }
@@ -27,7 +26,6 @@ dependencies {
     compileOnly(project(":annotations"))
 
     api(project(":version-checker"))
-    api("com.github.xmrafonso:hangar4j:1.2.2")
 
     annotationProcessor("org.projectlombok:lombok:1.18.34")
 }

paper/src/main/java/core/paper/command/CoreArgumentTypes.java

@@ -23,6 +23,7 @@ class CoreArgumentTypes {
         Arrays.stream(Bukkit.getOfflinePlayers())
                 .map(OfflinePlayer::getName)
                 .filter(Objects::nonNull)
+                .filter(s -> s.contains(builder.getRemaining()))
                 .forEach(builder::suggest);
         return builder.buildFuture();
     });
@@ -35,6 +36,7 @@ class CoreArgumentTypes {
             }, (context, builder) -> {
         Bukkit.getOnlinePlayers().stream()
                 .map(Player::getName)
+                .filter(s -> s.contains(builder.getRemaining()))
                 .forEach(builder::suggest);
         return builder.buildFuture();
     });
@@ -47,6 +49,7 @@ class CoreArgumentTypes {
             }, (context, builder) -> {
         Bukkit.getOnlinePlayers().stream()
                 .map(Player::getName)
+                .filter(s -> s.contains(builder.getRemaining()))
                 .forEach(builder::suggest);
         return builder.buildFuture();
     });

paper/src/main/java/core/paper/command/CustomArgumentTypes.java

@@ -5,7 +5,6 @@
 import org.bukkit.entity.Player;
 
 public final class CustomArgumentTypes {
-
     public static ArgumentType<OfflinePlayer> cachedOfflinePlayer() {
         return CoreArgumentTypes.offlinePlayer;
     }

paper/src/main/java/core/paper/version/PaperHangarVersionChecker.java

@@ -4,11 +4,15 @@
 import core.annotation.MethodsReturnNotNullByDefault;
 import core.annotation.ParametersAreNotNullByDefault;
 import core.annotation.TypesAreNotNullByDefault;
-import core.version.HangarVersionChecker;
 import core.version.Version;
-import me.mrafonso.hangar4j.impl.Platform;
-import me.mrafonso.hangar4j.impl.version.HangarVersion;
+import core.version.hangar.HangarVersion;
+import core.version.hangar.HangarVersionChecker;
+import core.version.hangar.Platform;
+import lombok.Getter;
 import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+
+import java.util.Objects;
 
 /**
  * The PaperHangarVersionChecker class is an abstract class that provides methods
@@ -21,8 +25,35 @@
 @MethodsReturnNotNullByDefault
 @ParametersAreNotNullByDefault
 public abstract class PaperHangarVersionChecker<V extends Version> extends HangarVersionChecker<V> {
-    public PaperHangarVersionChecker(String slug) {
+    private final @Getter V versionRunning;
+    private final @Getter String author;
+    private final Plugin plugin;
+
+    @SuppressWarnings("UnstableApiUsage")
+    public PaperHangarVersionChecker(Plugin plugin, String author, String slug) {
         super(slug);
+        this.versionRunning = Objects.requireNonNull(
+                parseVersion(plugin.getPluginMeta().getVersion()),
+                "Failed to parse plugin version running"
+        );
+        this.author = author;
+        this.plugin = plugin;
+    }
+
+    public void checkVersion() {
+        retrieveLatestSupportedVersion().thenAccept(version -> {
+            var logger = plugin.getComponentLogger();
+            if (version.equals(versionRunning)) {
+                logger.info("You are running the latest version of {}", plugin.getName());
+            } else if (version.compareTo(versionRunning) > 0) {
+                logger.warn("An update for {} is available", plugin.getName());
+                logger.warn("You are running version {}, the latest supported version is {}", versionRunning, version);
+                logger.warn("Update at https://hangar.papermc.io/{}/{}", author, getSlug());
+            } else logger.warn("You are running a snapshot version of {}", plugin.getName());
+        }).exceptionally(throwable -> {
+            plugin.getComponentLogger().error("Version check failed", throwable);
+            return null;
+        });
     }
 
     @Override

version-checker/build.gradle.kts

@@ -16,15 +16,14 @@ version = "1.0.1"
 
 repositories {
     mavenCentral()
-    maven("https://jitpack.io")
 }
 
 dependencies {
     compileOnly("org.projectlombok:lombok:1.18.34")
     compileOnly("org.jetbrains:annotations:24.1.0")
     compileOnly(project(":annotations"))
 
-    api("com.github.xmrafonso:hangar4j:1.2.2")
+    api("com.google.code.gson:gson:2.11.0")
 
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")

version-checker/src/main/java/core/version/HangarVersionChecker.java

@@ -26,18 +26,13 @@ public record SemanticVersion(int major, int minor, int patch, @Nullable String
      * @param string the version string to parse
      * @return the parsed SemanticVersion object, or null if it is not a valid SemVer
      */
-    public static @Nullable SemanticVersion parse(String string) {
-        try {
-            if (!string.matches(PATTERN)) return null;
-            var parts = string.split("-", 2);
-            var split = parts[0].split("\\.", 3);
-            var major = Integer.parseInt(split[0]);
-            var minor = Integer.parseInt(split[1]);
-            var patch = Integer.parseInt(split[2]);
-            return new SemanticVersion(major, minor, patch, parts.length == 2 ? parts[1] : null);
-        } catch (Exception ignored) {
-            return null;
-        }
+    public static SemanticVersion parse(String string) {
+        var parts = string.split("-", 2);
+        var split = parts[0].split("\\.", 3);
+        var major = Integer.parseInt(split[0]);
+        var minor = Integer.parseInt(split[1]);
+        var patch = Integer.parseInt(split[2]);
+        return new SemanticVersion(major, minor, patch, parts.length == 2 ? parts[1] : null);
     }
 
     /**

version-checker/src/main/java/core/version/SemanticVersion.java

@@ -1,9 +1,9 @@
 package core.version;
 
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Unmodifiable;
 
-import java.util.Optional;
-import java.util.function.Consumer;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 
 public interface VersionChecker<N, V extends Version> {
     /**
@@ -17,18 +17,16 @@ public interface VersionChecker<N, V extends Version> {
      * Parses a version of type N into a version of type V.
      *
      * @param version the version to parse
-     * @return the parsed version of type V, or null if parsing fails
+     * @return the parsed version of type V
      */
-    @Nullable
     V parseVersion(N version);
 
     /**
      * Parses a version of type String into a version of type V.
      *
      * @param version the version to parse
-     * @return the parsed version of type V, or null if parsing fails
+     * @return the parsed version of type V
      */
-    @Nullable
     V parseVersion(String version);
 
     /**
@@ -40,9 +38,23 @@ public interface VersionChecker<N, V extends Version> {
     boolean isSupported(N version);
 
     /**
-     * Retrieves the latest supported version of the software and passes it to the provided success {@link Consumer}.
+     * Asynchronously retrieves the latest available version.
      *
-     * @param success the consumer that will receive the latest supported version wrapped in an {@link Optional}.
+     * @return a CompletableFuture containing the latest version
      */
-    void retrieveLatestSupportedVersion(Consumer<Optional<V>> success);
+    CompletableFuture<V> retrieveLatestVersion();
+
+    /**
+     * Retrieves all available versions asynchronously.
+     *
+     * @return a CompletableFuture containing a Set of all versions
+     */
+    CompletableFuture<@Unmodifiable Set<V>> retrieveVersions();
+
+    /**
+     * Retrieves the latest supported version of the software asynchronously.
+     *
+     * @return a CompletableFuture containing the latest supported version
+     */
+    CompletableFuture<V> retrieveLatestSupportedVersion();
 }

version-checker/src/main/java/core/version/VersionChecker.java

@@ -0,0 +1,7 @@
+package core.version.hangar;
+
+import java.util.List;
+import java.util.Map;
+
+public record HangarVersion(String name, String author, Map<Platform, List<String>> platformDependencies) {
+}

version-checker/src/main/java/core/version/hangar/HangarVersion.java

@@ -0,0 +1,86 @@
+package core.version.hangar;
+
+import com.google.gson.Gson;
+import core.annotation.FieldsAreNotNullByDefault;
+import core.annotation.MethodsReturnNotNullByDefault;
+import core.annotation.ParametersAreNotNullByDefault;
+import core.annotation.TypesAreNotNullByDefault;
+import core.version.Version;
+import core.version.VersionChecker;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+/**
+ * The HangarVersionChecker class is an abstract class that provides methods
+ * for retrieving and checking the latest supported version of a specific component in a hangar project.
+ *
+ * @param <V> the type parameter for the version
+ */
+@Getter
+@RequiredArgsConstructor
+@TypesAreNotNullByDefault
+@FieldsAreNotNullByDefault
+@MethodsReturnNotNullByDefault
+@ParametersAreNotNullByDefault
+public abstract class HangarVersionChecker<V extends Version> implements VersionChecker<HangarVersion, V> {
+    private static final String API_URL = "https://hangar.papermc.io/api/v1";
+    private static final HttpClient client = HttpClient.newBuilder()
+            .version(HttpClient.Version.HTTP_1_1)
+            .build();
+    private static final Gson gson = new Gson();
+
+    /**
+     * The slug of the project.
+     */
+    private final String slug;
+
+    @Override
+    public CompletableFuture<V> retrieveLatestVersion() {
+        return get("/projects/" + getSlug() + "/latestrelease")
+                .thenApply(HttpResponse::body)
+                .thenApply(this::parseVersion);
+    }
+
+    @Override
+    public CompletableFuture<@Unmodifiable Set<V>> retrieveVersions() {
+        return retrieveHangarVersions().thenApply(versions -> versions.stream()
+                .map(this::parseVersion)
+                .collect(Collectors.toUnmodifiableSet()));
+    }
+
+    @Override
+    public CompletableFuture<V> retrieveLatestSupportedVersion() {
+        return retrieveHangarVersions().thenApply(versions -> versions.stream()
+                .filter(this::isSupported)
+                .map(this::parseVersion)
+                .max(Version::compareTo)
+                .orElseThrow());
+    }
+
+    @Override
+    public V parseVersion(HangarVersion version) {
+        return parseVersion(version.name());
+    }
+
+    public final CompletableFuture<Set<HangarVersion>> retrieveHangarVersions() {
+        return get("/projects/" + getSlug() + "/versions")
+                .thenApply(response -> gson.fromJson(response.body(), HangarVersions.class))
+                .thenApply(HangarVersions::result);
+    }
+
+    private CompletableFuture<HttpResponse<String>> get(String path) {
+        return client.sendAsync(HttpRequest.newBuilder()
+                        .uri(URI.create(API_URL + path))
+                        .build(),
+                HttpResponse.BodyHandlers.ofString());
+    }
+}