Refactor config loading, use in use toolchain when linking

Author: plemarquand

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,20 +107,37 @@ 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(
                 to: postInstallFile, options: .atomic
             )
         }
-    }
-
+    }    
+    
     public static func setupProxies(
         _ ctx: SwiftlyCoreContext,
         version: ToolchainVersion,
@@ -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)
+
+            var existingProxies: [String] = []
 
-            let existingProxies = swiftlyBinDirContents.filter { bin in
+            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
             }
@@ -196,8 +213,7 @@ struct Install: SwiftlyCommand {
             selector = try ToolchainSelector(parsing: version)
         } else {
             if case let (_, result) = try await selectToolchain(ctx, config: &config),
-               case let .swiftVersionFile(_, sel, error) = result
-            {
+               case let .swiftVersionFile(_, sel, error) = result {
                 if let sel = sel {
                     selector = sel
                 } else if let error = error {
@@ -327,120 +343,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,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)
+            """)
         }
     }
 }

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)
 

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 {

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?

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 {

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

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" {