Implement the uninstall command on Linux (#25)

Author: patrickfreed

Sources/LinuxPlatform/Linux.swift

@@ -57,7 +57,10 @@ public struct Linux: Platform {
         }
     }
 
-    public func uninstall(version _: ToolchainVersion) throws {}
+    public func uninstall(_ toolchain: ToolchainVersion) throws {
+        let toolchainDir = SwiftlyCore.toolchainsDir.appendingPathComponent(toolchain.name)
+        try FileManager.default.removeItem(at: toolchainDir)
+    }
 
     public func use(_ toolchain: ToolchainVersion) throws {
         let toolchainBinURL = SwiftlyCore.toolchainsDir
@@ -86,10 +89,6 @@ public struct Linux: Platform {
         }
     }
 
-    public func listToolchains(selector _: ToolchainSelector?) -> [ToolchainVersion] {
-        []
-    }
-
     public func listAvailableSnapshots(version _: String?) async -> [Snapshot] {
         []
     }

Sources/Swiftly/Uninstall.swift

@@ -29,43 +29,83 @@ struct Uninstall: SwiftlyCommand {
 
             $ swiftly uninstall main-snapshot
             $ swiftly uninstall 5.7-snapshot
+
+        The latest installed stable release can be uninstalled by specifying  'latest':
+
+            $ swiftly uninstall latest
         """
     ))
     var toolchain: String
 
+    @Flag(
+        name: [.long, .customShort("y")],
+        help: "Uninstall all selected toolchains without prompting for confirmation."
+    )
+    var assumeYes: Bool = false
+
     mutating func run() async throws {
         let selector = try ToolchainSelector(parsing: self.toolchain)
         let config = try Config.load()
         let toolchains = config.listInstalledToolchains(selector: selector)
 
         guard !toolchains.isEmpty else {
-            print("no toolchains matched \"\(self.toolchain)\"")
+            SwiftlyCore.print("No toolchains matched \"\(self.toolchain)\"")
             return
         }
 
-        print("The following toolchains will be uninstalled:")
+        if !self.assumeYes {
+            SwiftlyCore.print("The following toolchains will be uninstalled:")
 
-        for toolchain in toolchains {
-            print("  \(toolchain)")
-        }
-
-        print("Proceed? (y/n)", terminator: ": ")
-        let proceed = readLine(strippingNewline: true) ?? "n"
+            for toolchain in toolchains {
+                SwiftlyCore.print("  \(toolchain)")
+            }
+            let proceed = SwiftlyCore.readLine(prompt: "Proceed? (y/n)") ?? "n"
 
-        guard proceed == "y" else {
-            print("aborting uninstall")
-            return
+            guard proceed == "y" else {
+                SwiftlyCore.print("Aborting uninstall")
+                return
+            }
         }
 
-        print()
+        SwiftlyCore.print()
 
         for toolchain in toolchains {
-            print("Uninstalling \(toolchain)...", terminator: "")
-            try Swiftly.currentPlatform.uninstall(version: toolchain)
-            print("done")
+            SwiftlyCore.print("Uninstalling \(toolchain)...", terminator: "")
+            try Swiftly.currentPlatform.uninstall(toolchain)
+            try Config.update { config in
+                config.installedToolchains.remove(toolchain)
+            }
+            SwiftlyCore.print("done")
         }
 
-        print()
-        print("\(toolchains.count) toolchain(s) successfully uninstalled")
+        SwiftlyCore.print()
+        SwiftlyCore.print("\(toolchains.count) toolchain(s) successfully uninstalled")
+
+        var latestConfig = try Config.load()
+
+        // If the in-use toolchain was one of the uninstalled toolchains, use the latest installed
+        // toolchain.
+        if let previouslyInUse = latestConfig.inUse, toolchains.contains(previouslyInUse) {
+            let selector: ToolchainSelector
+            switch previouslyInUse {
+            case let .stable(sr):
+                // If a.b.c was previously in use, switch to the latest a.b toolchain.
+                selector = .stable(major: sr.major, minor: sr.minor, patch: nil)
+            case let .snapshot(s):
+                // If a snapshot was previously in use, switch to the latest snapshot associated with that branch.
+                selector = .snapshot(branch: s.branch, date: nil)
+            }
+
+            if let toUse = latestConfig.listInstalledToolchains(selector: selector).max()
+                ?? latestConfig.listInstalledToolchains(selector: .latest).max()
+                ?? latestConfig.installedToolchains.max()
+            {
+                try await Use.execute(toUse)
+            } else {
+                // If there are no more toolchains installed, clear the inUse config entry.
+                latestConfig.inUse = nil
+                try latestConfig.save()
+            }
+        }
     }
 }

Sources/Swiftly/Update.swift

@@ -57,7 +57,7 @@ struct Update: SwiftlyCommand {
 
         print("updating \(oldToolchain) -> \(newToolchain)")
         try await Install.execute(version: newToolchain)
-        try Swiftly.currentPlatform.uninstall(version: oldToolchain)
+        try Swiftly.currentPlatform.uninstall(oldToolchain)
         print("successfully updated \(oldToolchain) -> \(newToolchain)")
     }
 

Sources/SwiftlyCore/Platform.swift

@@ -29,7 +29,7 @@ public protocol Platform {
 
     /// Uninstalls a toolchain associated with the given version.
     /// If this version is in use, the next latest version will be used afterwards.
-    func uninstall(version: ToolchainVersion) throws
+    func uninstall(_ version: ToolchainVersion) throws
 
     /// Select the toolchain associated with the given version.
     func use(_ version: ToolchainVersion) throws

Sources/SwiftlyCore/SwiftlyCore.swift

@@ -56,10 +56,28 @@ 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) {
+public func print(_ string: String = "", terminator: String? = nil) {
     guard let handler = SwiftlyCore.outputHandler else {
-        Swift.print(string)
+        if let terminator {
+            Swift.print(string, terminator: terminator)
+        } else {
+            Swift.print(string)
+        }
         return
     }
-    handler.handleOutputLine(string)
+    handler.handleOutputLine(string + (terminator ?? ""))
+}
+
+public protocol InputProvider {
+    func readLine() -> String?
+}
+
+public var inputProvider: (any InputProvider)?
+
+public func readLine(prompt: String) -> String? {
+    print(prompt, terminator: ": ")
+    guard let provider = SwiftlyCore.inputProvider else {
+        return Swift.readLine(strippingNewline: true)
+    }
+    return provider.readLine()
 }

Sources/SwiftlyCore/ToolchainVerison.swift

@@ -91,7 +91,7 @@ public enum ToolchainVersion {
     }
 
     static let stableRegex: Regex<(Substring, Substring, Substring, Substring)> =
-        try! Regex("^(\\d+)\\.(\\d+)\\.(\\d+)$")
+        try! Regex("^(?:Swift )?(\\d+)\\.(\\d+)\\.(\\d+)$")
 
     static let mainSnapshotRegex: Regex<(Substring, Substring)> =
         try! Regex("^main-snapshot-(\\d{4}-\\d{2}-\\d{2})$")

Tests/SwiftlyTests/ListTests.swift

@@ -6,26 +6,6 @@ import XCTest
 final class ListTests: SwiftlyTests {
     static let homeName = "useTests"
 
-    // Below are some constants indicating which versions are installed during setup.
-
-    static let oldStable = ToolchainVersion(major: 5, minor: 6, patch: 0)
-    static let oldStableNewPatch = ToolchainVersion(major: 5, minor: 6, patch: 3)
-    static let newStable = ToolchainVersion(major: 5, minor: 7, patch: 0)
-    static let oldMainSnapshot = ToolchainVersion(snapshotBranch: .main, date: "2022-09-10")
-    static let newMainSnapshot = ToolchainVersion(snapshotBranch: .main, date: "2022-10-22")
-    static let oldReleaseSnapshot = ToolchainVersion(snapshotBranch: .release(major: 5, minor: 7), date: "2022-08-27")
-    static let newReleaseSnapshot = ToolchainVersion(snapshotBranch: .release(major: 5, minor: 7), date: "2022-08-30")
-
-    static let allToolchains: [ToolchainVersion] = [
-        ListTests.oldStable,
-        ListTests.oldStableNewPatch,
-        ListTests.newStable,
-        ListTests.oldMainSnapshot,
-        ListTests.newMainSnapshot,
-        ListTests.oldReleaseSnapshot,
-        ListTests.newReleaseSnapshot,
-    ]
-
     static let sortedReleaseToolchains: [ToolchainVersion] = [
         ListTests.newStable,
         ListTests.oldStableNewPatch,
@@ -63,7 +43,7 @@ final class ListTests: SwiftlyTests {
         }
 
         var list = try self.parseCommand(List.self, args)
-        let output = try await list.runWithOutput()
+        let output = try await list.runWithMockedIO()
 
         let parsedToolchains = output.compactMap { outputLine in
             Self.allToolchains.first {
@@ -145,7 +125,7 @@ final class ListTests: SwiftlyTests {
                 listArgs.append(selector)
             }
             var list = try self.parseCommand(List.self, listArgs)
-            let output = try await list.runWithOutput()
+            let output = try await list.runWithMockedIO()
 
             let inUse = output.filter { $0.contains("in use") }
             XCTAssertEqual(inUse, ["\(toolchain) (in use)"])