Refactor config loading, use in use toolchain when linking

Author: plemarquand

Sources/Swiftly/Install.swift

@@ -88,6 +88,7 @@ struct Install: SwiftlyCommand {
         }
 
         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,
@@ -109,12 +110,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(
@@ -132,21 +150,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(
@@ -155,7 +175,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 {
@@ -171,16 +191,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
             }
@@ -330,120 +347,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

Sources/Swiftly/Link.swift

@@ -23,12 +23,15 @@ struct Link: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
 
-        var config = try Config.load(ctx)
+        var config = try await Config.load(ctx)
         let toolchainVersion = try await Install.determineToolchainVersion(
             ctx,
-            version: nil,
+            version: config.inUse?.name,
             config: &config
         )
 
@@ -40,7 +43,11 @@ struct Link: SwiftlyCommand {
         )
 
         if pathChanged {
-            await ctx.print(Messages.refreshShell)
+            await ctx.print("""
+            Linked swiftly to \(toolchainVersion.name).
+
+            \(Messages.refreshShell)
+            """)
         }
     }
 }

Sources/Swiftly/List.swift

@@ -43,12 +43,11 @@ struct List: SwiftlyCommand {
             versionUpdateReminder()
         }
 
+        var config = try await Config.load(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)
 

Sources/Swiftly/ListAvailable.swift

@@ -49,12 +49,11 @@ struct ListAvailable: SwiftlyCommand {
             versionUpdateReminder()
         }
 
+        var config = try await Config.load(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 {

Sources/Swiftly/Run.swift

@@ -62,14 +62,13 @@ struct Run: SwiftlyCommand {
         defer {
             versionUpdateReminder()
         }
+        var config = try await Config.load(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?

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)
     }

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,28 @@ struct Unlink: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
 
         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
                 }
             }

Tests/SwiftlyTests/LinkTests.swift

@@ -7,10 +7,9 @@ import Testing
     /// Tests that enabling swiftly results in swiftlyBinDir being populated with symlinks.
     @Test func testLink() async throws {
         try await SwiftlyTests.withTestHome {
-            let fm = FileManager.default
             let swiftlyBinDir = Swiftly.currentPlatform.swiftlyBinDir(SwiftlyTests.ctx)
-            let swiftlyBinaryPath = swiftlyBinDir.appendingPathComponent("swiftly")
-            let swiftVersionFilename = SwiftlyTests.ctx.currentDirectory.appendingPathComponent(".swift-version")
+            let swiftlyBinaryPath = swiftlyBinDir / "swiftly"
+            let swiftVersionFilename = SwiftlyTests.ctx.currentDirectory / ".swift-version"
 
             // Configure a mock toolchain
             let versionString = "6.0.3"
@@ -20,20 +19,18 @@ import Testing
             // And start creating a mock folder structure for that toolchain.
             try "swiftly binary".write(to: swiftlyBinaryPath, atomically: true, encoding: .utf8)
 
-            let toolchainDir = Swiftly.currentPlatform.findToolchainLocation(SwiftlyTests.ctx, toolchainVersion)
-                .appendingPathComponent("usr")
-                .appendingPathComponent("bin")
-            try fm.createDirectory(at: toolchainDir, withIntermediateDirectories: true)
+            let toolchainDir = Swiftly.currentPlatform.findToolchainLocation(SwiftlyTests.ctx, toolchainVersion) / "usr" / "bin"
+            try await fs.mkdir([.parents], atPath: toolchainDir)
 
             let proxies = ["swift-build", "swift-test", "swift-run"]
             for proxy in proxies {
-                let proxyPath = toolchainDir.appendingPathComponent(proxy)
-                try fm.createSymbolicLink(at: proxyPath, withDestinationURL: swiftlyBinaryPath)
+                let proxyPath = toolchainDir / proxy
+                try await fs.symlink(atPath: proxyPath, linkPath: swiftlyBinaryPath)
             }
 
             _ = try await SwiftlyTests.runWithMockedIO(Link.self, ["link"])
 
-            let enabledSwiftlyBinDirContents = try fm.contentsOfDirectory(atPath: swiftlyBinDir.path).sorted()
+            let enabledSwiftlyBinDirContents = try await fs.ls(atPath: swiftlyBinDir).sorted()
             let expectedProxies = (["swiftly"] + proxies).sorted()
             #expect(enabledSwiftlyBinDirContents == expectedProxies)
         }