Updated to fix the issue when there are versions with "beta" tags

Got rid of legacy code...

Author: RealMangorage

build.gradle

@@ -84,13 +84,26 @@ jar {
         )
     }
 }
+task runInstaler(type: JavaExec) {
+    group = 'Installer Tasks'
+    description = 'Runs the main class in the build/run directory'
+
+    mainClass.set('org.mangorage.installer.Installer') // replace with your actual main class
+    classpath = sourceSets.main.runtimeClasspath
+
+    workingDir = file("$buildDir/run")
+    doFirst {
+        workingDir.mkdirs() // Make sure the directory exists
+    }
+}
 
 shadowJar {
     group "main tasks"
     archiveClassifier.set('')
 
     excludes.remove('module-info.class')
-    relocate('com.google.gson', 'internal.mango.gson')
+    relocate('com.google.gson', 'internal.shaded.com.google.gson')
+    relocate('joptsimple', 'internal.shaded.joptsimple')
 }
 
 publishing {

gradle/wrapper/gradle-wrapper.jar

@@ -1,6 +1,7 @@
-#Wed Oct 25 15:49:45 PDT 2023
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradle/wrapper/gradle-wrapper.properties

@@ -2,6 +2,7 @@
     requires static com.google.gson;
     requires static jopt.simple;
     requires jdk.unsupported;
+    requires java.xml;
 
     uses org.mangorage.installer.Installer;
 }

gradlew

@@ -6,12 +6,10 @@
 import joptsimple.OptionSet;
 import joptsimple.OptionSpec;
 import joptsimple.util.PathConverter;
-import org.mangorage.installer.core.LogUtil;
 import org.mangorage.installer.core.UpdateChecker;
 import org.mangorage.installer.core.data.*;
 import java.io.*;
 import java.lang.reflect.Method;
-import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.nio.file.Path;
@@ -21,14 +19,12 @@
 import java.util.jar.Manifest;
 import java.util.stream.Collectors;
 import java.util.zip.ZipEntry;
-import java.util.zip.ZipInputStream;
 
 public class Installer {
     private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
     private static final ExecutorService TASKS = Executors.newSingleThreadExecutor();
 
     private static final String DEPENDENCIES_PATH = "installer-data/dependencies.json";
-    private static final String SERVICE_PATH = "installer-data/services.launch";
     private static final Path LIBRARIES_PATH = Path.of("libraries/").toAbsolutePath();
 
     public static void main(String[] args) {

gradlew.bat

@@ -29,4 +29,4 @@
  * @param groupId    (io.github.realmangorage)
  * @param artifactId (mangobot)
  */
-public record Maven(String repository, String groupId, String artifactId) { }
+public record Maven(String repository, String groupId, String artifactId) {}

src/main/java/module-info.java

@@ -8,17 +8,11 @@
 public final class Version implements Comparable<Version> {
 
     public static List<Version> parseMetadata(String metadata) {
-        return Version.parseVersions(metadata).stream().map(a -> {
-            if (a.contains("c"))
-                return Version.of(Version.transformVersion(a), a);
-            return Version.of(a);
-        }).toList();
-    }
-
-    public static Version parseVersion(String version) {
-        if (version.contains("c"))
-            return Version.of(Version.transformVersion(version), version);
-        return Version.of(version);
+        return Version.parseVersions(metadata)
+                .stream()
+                .filter(a -> a.matches("\\d+\\.\\d+\\.\\d+")) // Only x.y.z...
+                .map(Version::of)
+                .toList();
     }
 
     public static Version of(String version) {
@@ -27,57 +21,28 @@ public static Version of(String version) {
         return new Version(Integer.parseInt(param[0]), Integer.parseInt(param[1]), Integer.parseInt(param[2]));
     }
 
-    public static Version of(String version, String original) {
-        String[] param = version.split("\\.");
-        if (param.length != 3) throw new IllegalStateException("Version needs to be major.minor.patch");
-        return new Version(Integer.parseInt(param[0]), Integer.parseInt(param[1]), Integer.parseInt(param[2]), original);
-    }
-
-    public static Version getLatestVersion(List<Version> versions, String versionPattern) {
-        Pattern pattern = Pattern.compile(versionPattern.replace(".", "\\.").replace("+", ".*"));
-        return versions.stream()
-                .filter(version -> {
-                    Matcher matcher = pattern.matcher(version.toString());
-                    return matcher.matches();
-                })
-                .max(Version::compareTo)
-                .orElse(null);
-    }
-
     public static List<String> parseVersions(String input) {
         List<String> matchingVersions = new ArrayList<>();
 
-        // Define the pattern
         Pattern regexPattern = Pattern.compile("<version>(.*?)<\\/version>");
-
-        // Create a matcher with the input string
         Matcher matcher = regexPattern.matcher(input);
 
-        // Find all matches in the input string
         while (matcher.find()) {
             matchingVersions.add(matcher.group(1)); // Capture only the version part
         }
 
         return matchingVersions;
     }
 
-    public static String transformVersion(String version) {
-        // Define the pattern
-        Pattern regexPattern = Pattern.compile("(\\d+\\.\\d+\\.\\d+)-c(\\d+)");
-
-        // Create a matcher with the input version
-        Matcher matcher = regexPattern.matcher(version);
-
-        // Check if the pattern matches
-        if (matcher.matches()) {
-            // Combine the matched groups, removing leading zeros from the third part
-            String mainPart = matcher.group(1);
-            String thirdPart = matcher.group(2).replaceFirst("^0+(?!$)", "");
-            return String.format("%s%s", mainPart.substring(0, mainPart.length() - 1), thirdPart);
-        } else {
-            // Return the original version if no match
-            return version;
-        }
+    public static Version getLatestVersion(List<Version> versions, String versionPattern) {
+        Pattern pattern = Pattern.compile(versionPattern.replace(".", "\\.").replace("+", ".*"));
+        return versions.stream()
+                .filter(version -> {
+                    Matcher matcher = pattern.matcher(version.toString());
+                    return matcher.matches();
+                })
+                .max(Version::compareTo)
+                .orElse(null);
     }
 
     private final int major;