Refactor config loading, use in use toolchain when linking

plemarquand · plemarquand · commit ac4b4731a6ba · 2025-04-22T13:46:48.000-04:00
diff --git a/Sources/Swiftly/Install.swift b/Sources/Swiftly/Install.swift
@@ -82,9 +82,10 @@ struct Install: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        try await validatedConfig(ctx)
 
         var config = try await Config.load(ctx)
+        let toolchainVersion = try await Self.determineToolchainVersion(ctx, version: self.version, config: &config)
 
         let (postInstallScript, pathChanged) = try await Self.execute(
             ctx,
@@ -106,12 +107,29 @@ struct Install: SwiftlyCommand {
 
         // Fish doesn't cache its path, so this instruction is not necessary.
         if pathChanged && !shell.hasSuffix("fish") {
-            await ctx.print(Messages.refreshShell)
+            await ctx.print(
+                """
+                NOTE: Swiftly has updated some elements in your path and your shell may not yet be
+                aware of the changes. You can update your shell's environment by running
+
+                hash -r
+
+                or restarting your shell.
+
+                """)
         }
 
         if let postInstallScript {
             guard let postInstallFile = self.postInstallFile else {
-                throw SwiftlyError(message: Messages.postInstall(postInstallScript))
+                throw SwiftlyError(
+                    message: """
+
+                    There are some dependencies that should be installed before using this toolchain.
+                    You can run the following script as the system administrator (e.g. root) to prepare
+                    your system:
+
+                    \(postInstallScript)
+                    """)
             }
 
             try Data(postInstallScript.utf8).write(
@@ -129,21 +147,23 @@ struct Install: SwiftlyCommand {
         var pathChanged = false
 
         // Create proxies if we have a location where we can point them
-        if let proxyTo = try? Swiftly.currentPlatform.findSwiftlyBin(ctx) {
+        if let proxyTo = try? await Swiftly.currentPlatform.findSwiftlyBin(ctx) {
             // Ensure swiftly doesn't overwrite any existing executables without getting confirmation first.
             let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(ctx)
             let swiftlyBinDirContents =
-                (try? FileManager.default.contentsOfDirectory(atPath: swiftlyBinDir.path)) ?? [String]()
+                (try? await fs.ls(atPath: swiftlyBinDir)) ?? [String]()
             let toolchainBinDir = Swiftly.currentPlatform.findToolchainBinDir(ctx, version)
-            let toolchainBinDirContents = try FileManager.default.contentsOfDirectory(
-                atPath: toolchainBinDir.path)
+            let toolchainBinDirContents = try await fs.ls(atPath: toolchainBinDir)
 
-            let existingProxies = swiftlyBinDirContents.filter { bin in
+            var existingProxies: [String] = []
+
+            for bin in swiftlyBinDirContents {
                 do {
-                    let linkTarget = try FileManager.default.destinationOfSymbolicLink(
-                        atPath: swiftlyBinDir.appendingPathComponent(bin).path)
-                    return linkTarget == proxyTo
-                } catch { return false }
+                    let linkTarget = try await fs.readlink(atPath: swiftlyBinDir / bin)
+                    if linkTarget == proxyTo {
+                        existingProxies.append(bin)
+                    }
+                } catch { continue }
             }
 
             let overwrite = Set(toolchainBinDirContents).subtracting(existingProxies).intersection(
@@ -152,7 +172,7 @@ struct Install: SwiftlyCommand {
                 await ctx.print("The following existing executables will be overwritten:")
 
                 for executable in overwrite {
-                    await ctx.print("  \(swiftlyBinDir.appendingPathComponent(executable).path)")
+                    await ctx.print("  \(swiftlyBinDir / executable)")
                 }
 
                 guard await ctx.promptForConfirmation(defaultBehavior: false) else {
@@ -168,16 +188,13 @@ struct Install: SwiftlyCommand {
                 overwrite)
 
             for p in proxiesToCreate {
-                let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx).appendingPathComponent(p)
+                let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx) / p
 
-                if proxy.fileExists() {
-                    try FileManager.default.removeItem(at: proxy)
+                if try await fs.exists(atPath: proxy) {
+                    try await fs.remove(atPath: proxy)
                 }
 
-                try FileManager.default.createSymbolicLink(
-                    atPath: proxy.path,
-                    withDestinationPath: proxyTo
-                )
+                try await fs.symlink(atPath: proxy, linkPath: proxyTo)
 
                 pathChanged = true
             }
@@ -327,120 +344,15 @@ struct Install: SwiftlyCommand {
 
             try await Swiftly.currentPlatform.install(ctx, from: tmpFile, version: version, verbose: verbose)
 
-            var pathChanged = false
-
-            // Create proxies if we have a location where we can point them
-            if let proxyTo = try? await Swiftly.currentPlatform.findSwiftlyBin(ctx) {
-                // Ensure swiftly doesn't overwrite any existing executables without getting confirmation first.
-                let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(ctx)
-                let swiftlyBinDirContents =
-                    (try? await fs.ls(atPath: swiftlyBinDir)) ?? [String]()
-                let toolchainBinDir = Swiftly.currentPlatform.findToolchainBinDir(ctx, version)
-                let toolchainBinDirContents = try await fs.ls(atPath: toolchainBinDir)
-
-                var existingProxies: [String] = []
-
-                for bin in swiftlyBinDirContents {
-                    do {
-                        let linkTarget = try await fs.readlink(atPath: swiftlyBinDir / bin)
-                        if linkTarget == proxyTo {
-                            existingProxies.append(bin)
-                        }
-                    } catch { continue }
-                }
-
-                let overwrite = Set(toolchainBinDirContents).subtracting(existingProxies).intersection(
-                    swiftlyBinDirContents)
-                if !overwrite.isEmpty && !assumeYes {
-                    await ctx.print("The following existing executables will be overwritten:")
-
-                    for executable in overwrite {
-                        await ctx.print("  \(swiftlyBinDir / executable)")
-                    }
-
-<<<<<<< HEAD
-                    guard await ctx.promptForConfirmation(defaultBehavior: false) else {
-                        throw SwiftlyError(message: "Toolchain installation has been cancelled")
-                    }
-                }
-
-                if verbose {
-                    await ctx.print("Setting up toolchain proxies...")
-                }
-
-                let proxiesToCreate = Set(toolchainBinDirContents).subtracting(swiftlyBinDirContents).union(
-                    overwrite)
-
-                for p in proxiesToCreate {
-                    let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx) / p
-
-                    if try await fs.exists(atPath: proxy) {
-                        try await fs.remove(atPath: proxy)
-                    }
-
-                    try await fs.symlink(atPath: proxy, linkPath: proxyTo)
-
-                    pathChanged = true
-                }
-            }
-
-            config.installedToolchains.insert(version)
-
-=======
-                    let downloadedMiB = Double(progress.receivedBytes) / (1024.0 * 1024.0)
-                    let totalMiB = Double(progress.totalBytes!) / (1024.0 * 1024.0)
-
-                    lastUpdate = Date()
-
-                    animation.update(
-                        step: progress.receivedBytes,
-                        total: progress.totalBytes!,
-                        text:
-                        "Downloaded \(String(format: "%.1f", downloadedMiB)) MiB of \(String(format: "%.1f", totalMiB)) MiB"
-                    )
-                }
-            )
-        } catch let notFound as DownloadNotFoundError {
-            throw SwiftlyError(message: "\(version) does not exist at URL \(notFound.url), exiting")
-        } catch {
-            animation.complete(success: false)
-            throw error
-        }
-        animation.complete(success: true)
-
-        if verifySignature {
-            try await Swiftly.currentPlatform.verifyToolchainSignature(
+            let pathChanged = try await Self.setupProxies(
                 ctx,
-                toolchainFile: toolchainFile,
-                archive: tmpFile,
-                verbose: verbose
+                version: version,
+                verbose: verbose,
+                assumeYes: assumeYes
             )
-        }
-
-        try await Swiftly.currentPlatform.install(ctx, from: tmpFile, version: version, verbose: verbose)
-
-        let pathChanged = try await Self.setupProxies(
-            ctx,
-            version: version,
-            verbose: verbose,
-            assumeYes: assumeYes
-        )
-
-        config.installedToolchains.insert(version)
 
-        try config.save(ctx)
-
-        // If this is the first installed toolchain, mark it as in-use regardless of whether the
-        // --use argument was provided.
-        if useInstalledToolchain {
-            try await Use.execute(ctx, version, globalDefault: false, &config)
-        }
+            config.installedToolchains.insert(version)
 
-        // We always update the global default toolchain if there is none set. This could
-        //  be the only toolchain that is installed, which makes it the only choice.
-        if config.inUse == nil {
-            config.inUse = version
->>>>>>> 5d7eb2d (Add ability to temporarily disable swiftly)
             try config.save(ctx)
 
             // If this is the first installed toolchain, mark it as in-use regardless of whether the
diff --git a/Sources/Swiftly/Link.swift b/Sources/Swiftly/Link.swift
@@ -23,12 +23,10 @@ struct Link: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try validateSwiftly(ctx)
-
-        var config = try Config.load(ctx)
+        var config = try await validatedConfig(ctx)
         let toolchainVersion = try await Install.determineToolchainVersion(
             ctx,
-            version: nil,
+            version: config.inUse?.name,
             config: &config
         )
 
@@ -40,7 +38,11 @@ struct Link: SwiftlyCommand {
         )
 
         if pathChanged {
-            await ctx.print(Messages.refreshShell)
+            await ctx.print("""
+            Linked swiftly to \(toolchainVersion.name).
+
+            \(Messages.refreshShell)
+            """)
         }
     }
 }
diff --git a/Sources/Swiftly/List.swift b/Sources/Swiftly/List.swift
@@ -38,13 +38,11 @@ struct List: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        var config = try await validatedConfig(ctx)
         let selector = try self.toolchainSelector.map { input in
             try ToolchainSelector(parsing: input)
         }
 
-        var config = try await Config.load(ctx)
-
         let toolchains = config.listInstalledToolchains(selector: selector).sorted { $0 > $1 }
         let (inUse, _) = try await selectToolchain(ctx, config: &config)
 
diff --git a/Sources/Swiftly/ListAvailable.swift b/Sources/Swiftly/ListAvailable.swift
@@ -44,13 +44,11 @@ struct ListAvailable: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        var config = try await validatedConfig(ctx)
         let selector = try self.toolchainSelector.map { input in
             try ToolchainSelector(parsing: input)
         }
 
-        var config = try await Config.load(ctx)
-
         let tc: [ToolchainVersion]
 
         switch selector {
diff --git a/Sources/Swiftly/Run.swift b/Sources/Swiftly/Run.swift
@@ -58,15 +58,13 @@ struct Run: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        var config = try await validatedConfig(ctx)
 
         // Handle the specific case where help is requested of the run subcommand
         if command == ["--help"] {
             throw CleanExit.helpRequest(self)
         }
 
-        var config = try await Config.load(ctx)
-
         let (command, selector) = try Self.extractProxyArguments(command: self.command)
 
         let toolchain: ToolchainVersion?
diff --git a/Sources/Swiftly/SelfUpdate.swift b/Sources/Swiftly/SelfUpdate.swift
@@ -21,7 +21,7 @@ struct SelfUpdate: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        try await validatedConfig(ctx)
 
         let swiftlyBin = Swiftly.currentPlatform.swiftlyBinDir(ctx) / "swiftly"
         guard try await fs.exists(atPath: swiftlyBin) else {
diff --git a/Sources/Swiftly/Swiftly.swift b/Sources/Swiftly/Swiftly.swift
@@ -10,7 +10,7 @@ import SystemPackage
 
 typealias fs = SwiftlyCore.FileSystem
 
-extension FilePath: ExpressibleByArgument {
+extension FilePath: @retroactive ExpressibleByArgument {
     public init?(argument: String) {
         self.init(argument)
     }
@@ -95,7 +95,8 @@ extension Data {
 }
 
 extension SwiftlyCommand {
-    public mutating func validateSwiftly(_ ctx: SwiftlyCoreContext) async throws {
+    @discardableResult
+    public mutating func validatedConfig(_ ctx: SwiftlyCoreContext) async throws -> Config {
         for requiredDir in Swiftly.requiredDirectories(ctx) {
             guard try await fs.exists(atPath: requiredDir) else {
                 do {
@@ -107,7 +108,7 @@ extension SwiftlyCommand {
             }
         }
 
-        // Verify that the configuration exists and can be loaded
-        _ = try await Config.load(ctx)
+        // Verifies that the configuration exists and can be loaded
+        return try await Config.load(ctx)
     }
 }
diff --git a/Sources/Swiftly/Uninstall.swift b/Sources/Swiftly/Uninstall.swift
@@ -48,8 +48,7 @@ struct Uninstall: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
-        let startingConfig = try await Config.load(ctx)
+        let startingConfig = try await validatedConfig(ctx)
 
         let toolchains: [ToolchainVersion]
         if self.toolchain == "all" {
diff --git a/Sources/Swiftly/Unlink.swift b/Sources/Swiftly/Unlink.swift
@@ -1,6 +1,7 @@
 import ArgumentParser
 import Foundation
 import SwiftlyCore
+import SystemPackage
 
 struct Unlink: SwiftlyCommand {
     public static let configuration = CommandConfiguration(
@@ -25,25 +26,25 @@ struct Unlink: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try validateSwiftly(ctx)
+        try await validatedConfig(ctx)
 
         var pathChanged = false
-        if let proxyTo = try? Swiftly.currentPlatform.findSwiftlyBin(ctx) {
+        if let proxyTo = try? await Swiftly.currentPlatform.findSwiftlyBin(ctx) {
             let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(ctx)
-            let swiftlyBinDirContents = (try? FileManager.default.contentsOfDirectory(atPath: swiftlyBinDir.path)) ?? [String]()
+            let swiftlyBinDirContents = (try? FileManager.default.contentsOfDirectory(atPath: swiftlyBinDir.string)) ?? [String]()
 
             let existingProxies = swiftlyBinDirContents.filter { bin in
                 do {
-                    let linkTarget = try FileManager.default.destinationOfSymbolicLink(atPath: swiftlyBinDir.appendingPathComponent(bin).path)
-                    return linkTarget == proxyTo
+                    let linkTarget = try FileManager.default.destinationOfSymbolicLink(atPath: (swiftlyBinDir / bin).string)
+                    return linkTarget == proxyTo.string
                 } catch { return false }
             }
 
             for p in existingProxies {
-                let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx).appendingPathComponent(p)
+                let proxy = Swiftly.currentPlatform.swiftlyBinDir(ctx) / p
 
-                if proxy.fileExists() {
-                    try FileManager.default.removeItem(at: proxy)
+                if try await fs.exists(atPath: proxy) {
+                    try await fs.remove(atPath: proxy)
                     pathChanged = true
                 }
             }
diff --git a/Sources/Swiftly/Update.swift b/Sources/Swiftly/Update.swift
diff --git a/Sources/Swiftly/Use.swift b/Sources/Swiftly/Use.swift
diff --git a/Tests/SwiftlyTests/LinkTests.swift b/Tests/SwiftlyTests/LinkTests.swift
diff --git a/Tests/SwiftlyTests/UnlinkTests.swift b/Tests/SwiftlyTests/UnlinkTests.swift

Original file line number	Diff line number	Diff line change
`@@ -23,12 +23,10 @@ struct Link: SwiftlyCommand {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`mutating func run(_ ctx: SwiftlyCoreContext) async throws {`
`26`		`- try validateSwiftly(ctx)`
`27`		`-`
`28`		`- var config = try Config.load(ctx)`
	`26`	`+ var config = try await validatedConfig(ctx)`
`29`	`27`	`let toolchainVersion = try await Install.determineToolchainVersion(`
`30`	`28`	`ctx,`
`31`		`- version: nil,`
	`29`	`+ version: config.inUse?.name,`
`32`	`30`	`config: &config`
`33`	`31`	`)`
`34`	`32`
`@@ -40,7 +38,11 @@ struct Link: SwiftlyCommand {`
`40`	`38`	`)`
`41`	`39`
`42`	`40`	`if pathChanged {`
`43`		`- await ctx.print(Messages.refreshShell)`
	`41`	`+ await ctx.print("""`
	`42`	`+ Linked swiftly to \(toolchainVersion.name).`
	`43`	`+`
	`44`	`+ \(Messages.refreshShell)`
	`45`	`+ """)`
`44`	`46`	`}`
`45`	`47`	`}`
`46`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,13 +38,11 @@ struct List: SwiftlyCommand {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`mutating func run(_ ctx: SwiftlyCoreContext) async throws {`
`41`		`- try await validateSwiftly(ctx)`
	`41`	`+ var config = try await validatedConfig(ctx)`
`42`	`42`	`let selector = try self.toolchainSelector.map { input in`
`43`	`43`	`try ToolchainSelector(parsing: input)`
`44`	`44`	`}`
`45`	`45`
`46`		`- var config = try await Config.load(ctx)`
`47`		`-`
`48`	`46`	`let toolchains = config.listInstalledToolchains(selector: selector).sorted { $0 > $1 }`
`49`	`47`	`let (inUse, _) = try await selectToolchain(ctx, config: &config)`
`50`	`48`
Original file line number	Diff line number	Diff line change
`@@ -44,13 +44,11 @@ struct ListAvailable: SwiftlyCommand {`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`mutating func run(_ ctx: SwiftlyCoreContext) async throws {`
`47`		`- try await validateSwiftly(ctx)`
	`47`	`+ var config = try await validatedConfig(ctx)`
`48`	`48`	`let selector = try self.toolchainSelector.map { input in`
`49`	`49`	`try ToolchainSelector(parsing: input)`
`50`	`50`	`}`
`51`	`51`
`52`		`- var config = try await Config.load(ctx)`
`53`		`-`
`54`	`52`	`let tc: [ToolchainVersion]`
`55`	`53`
`56`	`54`	`switch selector {`
Original file line number	Diff line number	Diff line change
`@@ -58,15 +58,13 @@ struct Run: SwiftlyCommand {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`mutating func run(_ ctx: SwiftlyCoreContext) async throws {`
`61`		`- try await validateSwiftly(ctx)`
	`61`	`+ var config = try await validatedConfig(ctx)`
`62`	`62`
`63`	`63`	`// Handle the specific case where help is requested of the run subcommand`
`64`	`64`	`if command == ["--help"] {`
`65`	`65`	`throw CleanExit.helpRequest(self)`
`66`	`66`	`}`
`67`	`67`
`68`		`- var config = try await Config.load(ctx)`
`69`		`-`
`70`	`68`	`let (command, selector) = try Self.extractProxyArguments(command: self.command)`
`71`	`69`
`72`	`70`	`let toolchain: ToolchainVersion?`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ struct SelfUpdate: SwiftlyCommand {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`mutating func run(_ ctx: SwiftlyCoreContext) async throws {`
`24`		`- try await validateSwiftly(ctx)`
	`24`	`+ try await validatedConfig(ctx)`
`25`	`25`
`26`	`26`	`let swiftlyBin = Swiftly.currentPlatform.swiftlyBinDir(ctx) / "swiftly"`
`27`	`27`	`guard try await fs.exists(atPath: swiftlyBin) else {`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ import SystemPackage`
`10`	`10`
`11`	`11`	`typealias fs = SwiftlyCore.FileSystem`
`12`	`12`
`13`		`-extension FilePath: ExpressibleByArgument {`
	`13`	`+extension FilePath: @retroactive ExpressibleByArgument {`
`14`	`14`	`public init?(argument: String) {`
`15`	`15`	`self.init(argument)`
`16`	`16`	`}`
`@@ -95,7 +95,8 @@ extension Data {`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`extension SwiftlyCommand {`
`98`		`- public mutating func validateSwiftly(_ ctx: SwiftlyCoreContext) async throws {`
	`98`	`+ @discardableResult`
	`99`	`+ public mutating func validatedConfig(_ ctx: SwiftlyCoreContext) async throws -> Config {`
`99`	`100`	`for requiredDir in Swiftly.requiredDirectories(ctx) {`
`100`	`101`	`guard try await fs.exists(atPath: requiredDir) else {`
`101`	`102`	`do {`
`@@ -107,7 +108,7 @@ extension SwiftlyCommand {`
`107`	`108`	`}`
`108`	`109`	`}`
`109`	`110`
`110`		`- // Verify that the configuration exists and can be loaded`
`111`		`- _ = try await Config.load(ctx)`
	`111`	`+ // Verifies that the configuration exists and can be loaded`
	`112`	`+ return try await Config.load(ctx)`
`112`	`113`	`}`
`113`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,7 @@ struct Uninstall: SwiftlyCommand {`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`mutating func run(_ ctx: SwiftlyCoreContext) async throws {`
`51`		`- try await validateSwiftly(ctx)`
`52`		`- let startingConfig = try await Config.load(ctx)`
	`51`	`+ let startingConfig = try await validatedConfig(ctx)`
`53`	`52`
`54`	`53`	`let toolchains: [ToolchainVersion]`
`55`	`54`	`if self.toolchain == "all" {`