Complete the list command implementation on Linux (#23)

Author: patrickfreed

Sources/LinuxPlatform/Linux.swift

@@ -41,7 +41,7 @@ public struct Linux: Platform {
             try FileManager.default.createDirectory(at: toolchainsDir, withIntermediateDirectories: false)
         }
 
-        print("Extracting toolchain...")
+        SwiftlyCore.print("Extracting toolchain...")
         let toolchainDir = toolchainsDir.appendingPathComponent(version.name)
 
         if toolchainDir.fileExists() {

Sources/Swiftly/Install.swift

@@ -62,10 +62,10 @@ struct Install: SwiftlyCommand {
 
     internal static func execute(version: ToolchainVersion) async throws {
         guard try !Config.load().installedToolchains.contains(version) else {
-            print("\(version) is already installed, exiting.")
+            SwiftlyCore.print("\(version) is already installed, exiting.")
             return
         }
-        print("Installing \(version)")
+        SwiftlyCore.print("Installing \(version)")
 
         let tmpFile = Swiftly.currentPlatform.getTempFilePath()
         FileManager.default.createFile(atPath: tmpFile.path, contents: nil)
@@ -133,7 +133,7 @@ struct Install: SwiftlyCommand {
                 }
             )
         } catch _ as HTTP.DownloadNotFoundError {
-            print("\(version) does not exist, exiting")
+            SwiftlyCore.print("\(version) does not exist, exiting")
             return
         } catch {
             animation.complete(success: false)
@@ -153,15 +153,15 @@ struct Install: SwiftlyCommand {
             try await Use.execute(version)
         }
 
-        print("\(version) installed successfully!")
+        SwiftlyCore.print("\(version) installed successfully!")
     }
 
     /// Utilize the GitHub API along with the provided selector to select a toolchain for install.
     /// TODO: update this to use an official swift.org API
     func resolve(selector: ToolchainSelector) async throws -> ToolchainVersion {
         switch selector {
         case .latest:
-            print("Fetching the latest stable Swift release...")
+            SwiftlyCore.print("Fetching the latest stable Swift release...")
 
             guard let release = try await HTTP.getReleaseToolchains(limit: 1).first else {
                 throw Error(message: "couldn't get latest releases")
@@ -179,7 +179,7 @@ struct Install: SwiftlyCommand {
                 return .stable(ToolchainVersion.StableRelease(major: major, minor: minor, patch: patch))
             }
 
-            print("Fetching the latest stable Swift \(major).\(minor) release...")
+            SwiftlyCore.print("Fetching the latest stable Swift \(major).\(minor) release...")
             // If a patch was not provided, perform a lookup to get the latest patch release
             // of the provided major/minor version pair.
             let toolchain = try await HTTP.getReleaseToolchains(limit: 1) { release in
@@ -197,7 +197,7 @@ struct Install: SwiftlyCommand {
                 return ToolchainVersion(snapshotBranch: branch, date: date)
             }
 
-            print("Fetching the latest \(branch) branch snapshot...")
+            SwiftlyCore.print("Fetching the latest \(branch) branch snapshot...")
             // If a date was not provided, perform a lookup to find the most recent snapshot
             // for the given branch.
             let snapshot = try await HTTP.getSnapshotToolchains(limit: 1) { snapshot in

Sources/Swiftly/List.swift

@@ -40,15 +40,15 @@ struct List: SwiftlyCommand {
 
         let config = try Config.load()
 
-        let toolchains = config.listInstalledToolchains(selector: selector)
+        let toolchains = config.listInstalledToolchains(selector: selector).sorted { $0 > $1 }
         let activeToolchain = config.inUse
 
         let printToolchain = { (toolchain: ToolchainVersion) in
             var message = "\(toolchain)"
             if toolchain == activeToolchain {
                 message += " (in use)"
             }
-            print(message)
+            SwiftlyCore.print(message)
         }
 
         if let selector {
@@ -68,22 +68,25 @@ struct List: SwiftlyCommand {
                 modifier = "matching"
             }
 
-            let message = "installed \(modifier) toolchains"
-            print(message)
-            print(String(repeating: "-", count: message.utf8.count))
+            let message = "Installed \(modifier) toolchains"
+            SwiftlyCore.print(message)
+            SwiftlyCore.print(String(repeating: "-", count: message.utf8.count))
             for toolchain in toolchains {
                 printToolchain(toolchain)
             }
         } else {
-            print("installed release toolchains")
-            print("----------------------------")
-            for toolchain in toolchains where toolchain.isStableRelease() {
+            SwiftlyCore.print("Installed release toolchains")
+            SwiftlyCore.print("----------------------------")
+            for toolchain in toolchains {
+                guard toolchain.isStableRelease() else {
+                    continue
+                }
                 printToolchain(toolchain)
             }
 
-            print("")
-            print("installed snapshot toolchains")
-            print("-----------------------------")
+            SwiftlyCore.print("")
+            SwiftlyCore.print("Installed snapshot toolchains")
+            SwiftlyCore.print("-----------------------------")
             for toolchain in toolchains where toolchain.isSnapshot() {
                 printToolchain(toolchain)
             }

Sources/Swiftly/Use.swift

@@ -43,7 +43,7 @@ internal struct Use: SwiftlyCommand {
         let config = try Config.load()
 
         guard let toolchain = config.listInstalledToolchains(selector: selector).max() else {
-            print("No installed toolchains match \"\(self.toolchain)\"")
+            SwiftlyCore.print("No installed toolchains match \"\(self.toolchain)\"")
             return
         }
 
@@ -55,7 +55,7 @@ internal struct Use: SwiftlyCommand {
         let previousToolchain = config.inUse
 
         guard toolchain != previousToolchain else {
-            print("\(toolchain) is already in use")
+            SwiftlyCore.print("\(toolchain) is already in use")
             return
         }
 
@@ -68,6 +68,6 @@ internal struct Use: SwiftlyCommand {
             message += " (was \(previousToolchain))"
         }
 
-        print(message)
+        SwiftlyCore.print(message)
     }
 }

Sources/SwiftlyCore/SwiftlyCore.swift

@@ -44,3 +44,22 @@ public var requiredDirectories: [URL] {
         SwiftlyCore.toolchainsDir,
     ]
 }
+
+/// Protocol defining a handler for information swiftly intends to print to stdout.
+/// This is currently only used to intercept print statements for testing.
+public protocol OutputHandler {
+    func handleOutputLine(_ string: String)
+}
+
+/// The output handler to use, if any.
+public var outputHandler: (any OutputHandler)?
+
+/// Pass the provided string to the set output handler if any.
+/// If no output handler has been set, just print to stdout.
+public func print(_ string: String) {
+    guard let handler = SwiftlyCore.outputHandler else {
+        Swift.print(string)
+        return
+    }
+    handler.handleOutputLine(string)
+}

Sources/SwiftlyCore/ToolchainVerison.swift

@@ -2,7 +2,7 @@ import _StringProcessing
 
 /// Enum representing a fully resolved toolchain version (e.g. 5.6.7 or 5.7-snapshot-2022-07-05).
 public enum ToolchainVersion {
-    public struct Snapshot: Equatable, Hashable, CustomStringConvertible {
+    public struct Snapshot: Equatable, Hashable, CustomStringConvertible, Comparable {
         public enum Branch: Equatable, Hashable, CustomStringConvertible {
             case main
             case release(major: Int, minor: Int)
@@ -15,6 +15,20 @@ public enum ToolchainVersion {
                     return "\(major).\(minor) development"
                 }
             }
+
+            public var major: Int? {
+                guard case let .release(major, _) = self else {
+                    return nil
+                }
+                return major
+            }
+
+            public var minor: Int? {
+                guard case let .release(_, minor) = self else {
+                    return nil
+                }
+                return minor
+            }
         }
 
         public let branch: Branch
@@ -33,6 +47,10 @@ public enum ToolchainVersion {
                 return "\(major).\(minor)-snapshot-\(self.date)"
             }
         }
+
+        public static func < (lhs: Self, rhs: Self) -> Bool {
+            lhs.date < rhs.date
+        }
     }
 
     public struct StableRelease: Equatable, Comparable, Hashable, CustomStringConvertible {
@@ -177,10 +195,12 @@ extension ToolchainVersion: Comparable {
         switch (lhs, rhs) {
         case let (.stable(lhsRelease), .stable(rhsRelease)):
             return lhsRelease < rhsRelease
-        case let (.snapshot(lhsRelease), .snapshot(rhsRelease)):
-            return lhsRelease.branch == rhsRelease.branch && lhsRelease.date < rhsRelease.date
-        default:
+        case let (.snapshot(lhsSnapshot), .snapshot(rhsSnapshot)):
+            return lhsSnapshot < rhsSnapshot
+        case (.snapshot, .stable):
             return false
+        case (.stable, .snapshot):
+            return !(rhs < lhs)
         }
     }
 }