add version parsing to API

Author: FalsePattern

src/main/java/com/falsepattern/lib/dependencies/Version.java

@@ -21,6 +21,8 @@
  */
 package com.falsepattern.lib.dependencies;
 
+import com.falsepattern.lib.internal.impl.dependencies.DependencyLoaderImpl;
+
 public abstract class Version implements Comparable<Version> {
     protected Version() {
     }
@@ -36,4 +38,12 @@ public boolean equals(Object obj) {
     public boolean equals(Version other) {
         return compareTo(other) == 0;
     }
+
+    /**
+     *
+     * @since 1.7.0
+     */
+    public static Version parse(String versionString) {
+        return DependencyLoaderImpl.parseVersion(versionString);
+    }
 }

src/main/java/com/falsepattern/lib/internal/impl/dependencies/DependencyLoaderImpl.java

@@ -367,10 +367,11 @@ private static <A, B, C> Stream<Pair<A, B>> flatMap(Pair<A, C> pair, Function<C,
     }
 
     private static final Pattern VERSION_PATTERN =
-            Pattern.compile("(0|[1-9]\\d*)(?:\\.(0|[1-9]\\d*))?(?:\\.(0|[1-9]\\d*))?"
-                            + "(?:-((?:(?:[0-9]+[a-zA-Z-][\\w-]*)|(?:[a-zA-Z][\\w-]*)|(?:[1-9]\\d*)|0)"
-                            + "(?:\\.(?:(?:[0-9]+[a-zA-Z-][\\w-]*)|(?:[a-zA-Z][\\w-]*)|(?:[1-9]\\d*)|0))*))?"
-                            + "(?:\\+([\\w-]+(\\.[\\w-]+)*))?");
+            Pattern.compile("(0|[1-9]\\d*)" +
+                            "(?:\\.(0|[1-9]\\d*))?" +
+                            "(?:\\.(0|[1-9]\\d*))?" +
+                            "(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?" +
+                            "(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?");
 
     private enum DependencySide {
         COMMON,
@@ -505,23 +506,7 @@ private static void scanDeps() {
                                            }
                                            val groupId = parts[0];
                                            val artifactId = parts[1];
-                                           Version version;
-                                           try {
-                                               val matcher = VERSION_PATTERN.matcher(parts[2]);
-                                               if (!matcher.matches()) {
-                                                   throw new IllegalArgumentException("Invalid version: " + parts[2]);
-                                               }
-                                               val major = Integer.parseInt(matcher.group(1));
-                                               val minor = matcher.group(2) == null ? -1
-                                                                                    : Integer.parseInt(matcher.group(2));
-                                               val patch = matcher.group(3) == null ? -1
-                                                                                    : Integer.parseInt(matcher.group(3));
-                                               val preRelease = matcher.group(4);
-                                               val build = matcher.group(5);
-                                               version = new SemanticVersion(major, minor, patch, preRelease, build);
-                                           } catch (IllegalArgumentException e) {
-                                               version = new RawVersion(parts[2]);
-                                           }
+                                           Version version = parseVersion(parts[2]);
                                            final String classifier = parts.length > 3 ? parts[3] : null;
                                            if (classifier != null) {
                                                LOG.info("Found dependency: {}:{}:{}:{} from {}",
@@ -552,6 +537,25 @@ private static void scanDeps() {
         tasks = new ArrayList<>(artifacts);
     }
 
+    public static Version parseVersion(String versionString) {
+        try {
+            val matcher = VERSION_PATTERN.matcher(versionString);
+            if (!matcher.matches()) {
+                return new RawVersion(versionString);
+            }
+            val major = Integer.parseInt(matcher.group(1));
+            val minor = matcher.group(2) == null ? -1
+                                                 : Integer.parseInt(matcher.group(2));
+            val patch = matcher.group(3) == null ? -1
+                                                 : Integer.parseInt(matcher.group(3));
+            val preRelease = matcher.group(4);
+            val build = matcher.group(5);
+            return new SemanticVersion(major, minor, patch, preRelease, build);
+        } catch (Exception e) {
+            return new RawVersion(versionString);
+        }
+    }
+
     private static class SideAwareAssistant {
         static ScopeSide current() {
             return new ScopeSide(Share.DEV_ENV ? DependencyScope.DEV : DependencyScope.OBF, FMLLaunchHandler.side() == Side.CLIENT ? DependencySide.CLIENT : DependencySide.SERVER);