Code polish, better handling for version info

src/dorkbox/gradle/GetVersionInfoTask.kt

@@ -29,19 +29,38 @@ import kotlin.concurrent.write
 
 open class
 GetVersionInfoTask : DefaultTask() {
-    private data class VersionHolder(var release: Version?, val versions: MutableList<Version>) {
+    private data class VersionHolder(var release: String?, val versions: MutableSet<String>) {
         fun updateReleaseVersion(version: String) {
+            if (release == null) {
+                release = version
+            } else {
+                // there can be errors when parsing version info, since not versions follow loose-semantic versioning
+                try {
+                    val currentVersion = Version.from(release)
                     val releaseVer = Version.from(version)
 
-            if (release == null) {
+                    if (releaseVer.greaterThan(currentVersion)) {
-                release = releaseVer
+                        release = version
-            } else if (releaseVer.greaterThan(release)) {
+                    }
-                release = releaseVer
+                } catch (e: Exception) {
+                    // ignored
+                }
             }
         }
 
         fun addVersion(ver: String) {
-            versions.add(Version.from(ver))
+            versions.add(ver)
+        }
+
+        fun getVersionOptions(currentVersion: String): List<String> {
+            // there can be errors when parsing version info, since not versions follow loose-semantic versioning
+            val myVersionIndex = versions.indexOfFirst { it == currentVersion }
+
+            return if (myVersionIndex >= 0) {
+                return versions.filterIndexed { index, _ -> index <= myVersionIndex }
+            } else {
+                versions.toList()
+            }
         }
     }
 
@@ -69,7 +88,7 @@ GetVersionInfoTask : DefaultTask() {
                 // version info is per dependency
                 val depVersionInfo = downloadLock.write {
                     mergedVersionInfo.getOrPut(DependencyScanner.Maven(mergedDep.group, mergedDep.name)) {
-                        VersionHolder(null, mutableListOf())
+                        VersionHolder(null, mutableSetOf())
                     }
                 }
 
@@ -105,10 +124,12 @@ GetVersionInfoTask : DefaultTask() {
                 futures.add(future)
             }
 
+            if (mergedDeps.isNotEmpty()) {
                 println("\tGetting version data for ${mergedDeps.size} dependencies...")
                 futures.forEach {
                     it.get()
                 }
+            }
 
             downloadLock.write {
                 // println("SIZE: " + mergedVersionInfo)
@@ -144,42 +165,46 @@ GetVersionInfoTask : DefaultTask() {
             mergedDeps.forEach { (mergedDep, existingVersions) ->
                 val latestInfo: VersionHolder = mergedVersionInfo[mergedDep]!!
                 existingVersions.forEach { dep ->
-                    if (latestInfo.release != null) {
+                    if (latestInfo.release == null) {
-                        if (Version.from(dep.version) == latestInfo.release) {
+                        unknownVersionInfo.add(dep)
+                    } else {
+                        if (dep.version == latestInfo.release) {
                             latestVersionInfo.add(dep)
                         } else {
                             oldVersionInfo.add(Pair(dep, latestInfo))
                         }
-                    } else {
-                        unknownVersionInfo.add(dep)
                     }
                 }
             }
 
+            val hasLatest = latestVersionInfo.isNotEmpty()
+            val hasOld = oldVersionInfo.isNotEmpty()
+            val hasUnknown = unknownVersionInfo.isNotEmpty()
+
+            if (hasLatest || hasOld || hasUnknown) {
                 println("\t------------------------------------------------------------")
+
+                if (hasLatest) {
                     println("\tThe following build script dependencies are using the latest release version:")
                     latestVersionInfo.forEach { dep ->
                         println("\t - ${dep.group}:${dep.version}")
                     }
+                }
 
-            if (oldVersionInfo.isNotEmpty()) {
+                if (hasOld) {
                     println()
                     println("\tThe following build script dependencies need updates:")
 
                     oldVersionInfo.forEach { (dep, versionHolder) ->
                         // list release version AND all other versions greater than my version
-                    val depVersion = Version.from(dep.version)
+                        val versionOptions = versionHolder.getVersionOptions(dep.version)
-                    val possibleVersionChoices = versionHolder.versions.filter { it.greaterThan(depVersion) }.toSet()
 
                         // BUILD SCRIPT DEPS HAVE FUNNY NOTATION!
-                    println("\t - ${dep.group} [${dep.version} -> ${versionHolder.release}]")
+                        println("\t - ${dep.group}:${dep.version} -> $versionOptions")
-                    if (possibleVersionChoices.size > 1) {
-                        println("\t\t$possibleVersionChoices")
-                    }
                     }
                 }
 
-            if (unknownVersionInfo.isNotEmpty()) {
+                if (hasUnknown) {
                     println()
                     println("\tThe following build script dependencies have unknown updates:")
                     unknownVersionInfo.forEach { dep ->
@@ -188,27 +213,13 @@ GetVersionInfoTask : DefaultTask() {
                     }
                 }
             }
-
-        private fun projectDependencies(staticMethodsAndTools: StaticMethodsAndTools, project: Project) {
-            // collect ALL projected + children projects.
-            val projects = mutableListOf<Project>()
-            val recursive = LinkedList<Project>()
-            recursive.add(project)
-
-
-            var next: Project
-            while (recursive.isNotEmpty()) {
-                next = recursive.poll()
-                projects.add(next)
-                recursive.addAll(next.childProjects.values)
         }
 
-
+        private fun projectDependencies(staticMethodsAndTools: StaticMethodsAndTools, project: Project) {
             val mergedDeps = mutableMapOf<DependencyScanner.Maven, MutableSet<DependencyScanner.Maven>>()
             val mergedRepos = mutableSetOf<String>()
 
-
+            project.allprojects.forEach { subProject ->
-            projects.forEach { subProject ->
                 staticMethodsAndTools.resolveAllDeclaredDependencies(subProject).forEach { dep ->
                     val deps = mergedDeps.getOrPut(DependencyScanner.Maven(dep.group, dep.name)) { mutableSetOf() }
                     deps.add(DependencyScanner.Maven(dep.group, dep.name, dep.version))
@@ -228,9 +239,8 @@ GetVersionInfoTask : DefaultTask() {
             val unknownVersionInfo = mutableListOf<DependencyScanner.Maven>()
 
 
-
             // now for project dependencies!
-            projects.forEach { subProject ->
+            project.allprojects.forEach { subProject ->
                 mergedDeps.clear()
                 latestVersionInfo.clear()
                 oldVersionInfo.clear()
@@ -248,7 +258,7 @@ GetVersionInfoTask : DefaultTask() {
                     val latestInfo: VersionHolder = mergedVersionInfo[mergedDep]!!
                     existingVersions.forEach { dep ->
                         if (latestInfo.release != null) {
-                            if (Version.from(dep.version) == latestInfo.release) {
+                            if (dep.version == latestInfo.release) {
                                 latestVersionInfo.add(dep)
                             } else {
                                 oldVersionInfo.add(Pair(dep, latestInfo))
@@ -267,29 +277,36 @@ GetVersionInfoTask : DefaultTask() {
                 }
 
 
+                val hasLatest = latestVersionInfo.isNotEmpty()
+                val hasOld = oldVersionInfo.isNotEmpty()
+                val hasUnknown = unknownVersionInfo.isNotEmpty()
+
+                if (hasLatest || hasOld || hasUnknown) {
                     println("\t------------------------------------------------------------")
+
+                    if (hasLatest) {
                         println("\tThe following project$projectName dependencies are using the latest release version:")
                         latestVersionInfo.forEach { dep ->
                             println("\t - ${dep.group}:${dep.name}:${dep.version}")
                         }
+                    }
 
-                if (oldVersionInfo.isNotEmpty()) {
+
+                    if (hasOld) {
                         println()
                         println("\tThe following project$projectName dependencies need updates:")
 
                         oldVersionInfo.forEach { (dep, versionHolder) ->
                             // list release version AND all other versions greater than my version
-                        val depVersion = Version.from(dep.version)
+                            val possibleVersionChoices = versionHolder.getVersionOptions(dep.version)
-                        val possibleVersionChoices = versionHolder.versions.filter { it.greaterThan(depVersion) }.toSet()
 
-                        println("\t - ${dep.group}:${dep.name} [${dep.version} -> ${versionHolder.release}]")
+                            println("\t - ${dep.group}:${dep.name}:${dep.version} -> ${versionHolder.release}")
-                        if (possibleVersionChoices.size > 1) {
+                            println("\t - ${dep.group}:${dep.name}:${dep.version} -> ${versionHolder.versions}")
-                            println("\t\t$possibleVersionChoices")
+                            println("\t - ${dep.group}:${dep.name}:${dep.version} -> $possibleVersionChoices")
-                        }
                         }
                     }
 
-                if (unknownVersionInfo.isNotEmpty()) {
+                    if (hasUnknown) {
                         println()
                         println("\tThe following project$projectName dependencies have unknown updates:")
                         unknownVersionInfo.forEach { dep ->
@@ -299,6 +316,7 @@ GetVersionInfoTask : DefaultTask() {
                 }
             }
         }
+    }
 
     @TaskAction
     fun run() {