Add ability to temporarily unlink swiftly (#315)

Adds two new commands, `swiftly unlink` and `swiftly link`, which
will disable and reenable swiftly's management of the active toolchain.

The `unlink` command removes the symlinks to toolchain binaries in the
swiftly bin directory that is in the user's path. This allows the rest
of the `$PATH` to be searched for available toolchain installations,
falling back to the system default. On macOS with Xcode installed this
has the effect of falling back to the toolchain in the user's installed
Xcode.

The `link` command reinstates the symlinks to the `inUse` toolchain,
which allows swiftly to resume management of the active toolchain.

* Print message to reload shell

* Return swiftly bin path, even in tests

* Refactor config loading, use in use toolchain when linking

* Notify swiftly is unlinked when performing use, install and update

* Mock out toolchain in link/unlink tests

Author: plemarquand

Documentation/SwiftlyDocs.docc/swiftly-cli-reference.md

@@ -545,3 +545,81 @@ The script will receive the argument '+abcde' followed by '+xyz'.
 
 
 
+## link
+
+Link swiftly so it resumes management of the active toolchain.
+
+```
+swiftly link [<toolchain-selector>] [--assume-yes] [--verbose] [--version] [--help]
+```
+
+**toolchain-selector:**
+
+*Links swiftly if it has been disabled.*
+
+
+Links swiftly if it has been disabled.
+
+
+**--assume-yes:**
+
+*Disable confirmation prompts by assuming 'yes'*
+
+
+**--verbose:**
+
+*Enable verbose reporting from swiftly*
+
+
+**--version:**
+
+*Show the version.*
+
+
+**--help:**
+
+*Show help information.*
+
+
+
+
+## unlink
+
+Unlinks swiftly so it no longer manages the active toolchain.
+
+```
+swiftly unlink [<toolchain-selector>] [--assume-yes] [--verbose] [--version] [--help]
+```
+
+**toolchain-selector:**
+
+*Unlinks swiftly, allowing the system default toolchain to be used.*
+
+
+Unlinks swiftly until swiftly is linked again with:
+
+    $ swiftly link
+
+
+**--assume-yes:**
+
+*Disable confirmation prompts by assuming 'yes'*
+
+
+**--verbose:**
+
+*Enable verbose reporting from swiftly*
+
+
+**--version:**
+
+*Show the version.*
+
+
+**--help:**
+
+*Show help information.*
+
+
+
+

Sources/Swiftly/Init.swift

@@ -297,14 +297,7 @@ struct Init: SwiftlyCommand {
         }
 
         if let postInstall {
-            await ctx.print("""
-            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:
-
-                \(postInstall)
-
-            """)
+            await ctx.print(Messages.postInstall(postInstall))
         }
     }
 }

Sources/Swiftly/Install.swift

@@ -86,33 +86,11 @@ struct Install: SwiftlyCommand {
         defer {
             versionUpdateReminder()
         }
+        try await validateLinked(ctx)
 
         var config = try await Config.load(ctx)
+        let toolchainVersion = try await Self.determineToolchainVersion(ctx, version: self.version, config: &config)
 
-        var selector: ToolchainSelector
-
-        if let version = self.version {
-            selector = try ToolchainSelector(parsing: version)
-        } else {
-            if case let (_, result) = try await selectToolchain(ctx, config: &config),
-               case let .swiftVersionFile(_, sel, error) = result
-            {
-                if let sel = sel {
-                    selector = sel
-                } else if let error = error {
-                    throw error
-                } else {
-                    throw SwiftlyError(message: "Internal error selecting toolchain to install.")
-                }
-            } else {
-                throw SwiftlyError(
-                    message:
-                    "Swiftly couldn't determine the toolchain version to install. Please set a version like this and try again: `swiftly install latest`"
-                )
-            }
-        }
-
-        let toolchainVersion = try await Self.resolve(ctx, config: config, selector: selector)
         let (postInstallScript, pathChanged) = try await Self.execute(
             ctx,
             version: toolchainVersion,
@@ -164,6 +142,101 @@ struct Install: SwiftlyCommand {
         }
     }
 
+    public static func setupProxies(
+        _ ctx: SwiftlyCoreContext,
+        version: ToolchainVersion,
+        verbose: Bool,
+        assumeYes: Bool
+    ) async throws -> Bool {
+        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)")
+                }
+
+                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
+            }
+        }
+        return pathChanged
+    }
+
+    static func determineToolchainVersion(
+        _ ctx: SwiftlyCoreContext,
+        version: String?,
+        config: inout Config
+    ) async throws -> ToolchainVersion {
+        let selector: ToolchainSelector
+
+        if let version = version {
+            selector = try ToolchainSelector(parsing: version)
+        } else {
+            if case let (_, result) = try await selectToolchain(ctx, config: &config),
+               case let .swiftVersionFile(_, sel, error) = result
+            {
+                if let sel = sel {
+                    selector = sel
+                } else if let error = error {
+                    throw error
+                } else {
+                    throw SwiftlyError(message: "Internal error selecting toolchain to install.")
+                }
+            } else {
+                throw SwiftlyError(
+                    message:
+                    "Swiftly couldn't determine the toolchain version to install. Please set a version like this and try again: `swiftly install latest`"
+                )
+            }
+        }
+
+        return try await Self.resolve(ctx, config: config, selector: selector)
+    }
+
     public static func execute(
         _ ctx: SwiftlyCoreContext,
         version: ToolchainVersion,
@@ -275,61 +348,12 @@ 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)")
-                    }
-
-                    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
-                }
-            }
+            let pathChanged = try await Self.setupProxies(
+                ctx,
+                version: version,
+                verbose: verbose,
+                assumeYes: assumeYes
+            )
 
             config.installedToolchains.insert(version)
 

Sources/Swiftly/Link.swift

@@ -0,0 +1,57 @@
+import ArgumentParser
+import Foundation
+import SwiftlyCore
+
+struct Link: SwiftlyCommand {
+    public static let configuration = CommandConfiguration(
+        abstract: "Link swiftly so it resumes management of the active toolchain."
+    )
+
+    @Argument(help: ArgumentHelp(
+        "Links swiftly if it has been disabled.",
+        discussion: """
+
+        Links swiftly if it has been disabled.
+        """
+    ))
+    var toolchainSelector: String?
+
+    @OptionGroup var root: GlobalOptions
+
+    mutating func run() async throws {
+        try await self.run(Swiftly.createDefaultContext())
+    }
+
+    mutating func run(_ ctx: SwiftlyCoreContext) async throws {
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
+
+        var config = try await Config.load(ctx)
+        let toolchainVersion = try await Install.determineToolchainVersion(
+            ctx,
+            version: config.inUse?.name,
+            config: &config
+        )
+
+        let pathChanged = try await Install.setupProxies(
+            ctx,
+            version: toolchainVersion,
+            verbose: self.root.verbose,
+            assumeYes: self.root.assumeYes
+        )
+
+        if pathChanged {
+            await ctx.print("""
+            Linked swiftly to Swift \(toolchainVersion.name).
+
+            \(Messages.refreshShell)
+            """)
+        } else {
+            await ctx.print("""
+            Swiftly is already linked to Swift \(toolchainVersion.name).
+            """)
+        }
+    }
+}

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 {