Implement the use command on Linux platforms (#20)

patrickfreed · web-flow · commit 08118e40390e · 2022-11-11T11:39:44.000-05:00
diff --git a/Sources/LinuxPlatform/Linux.swift b/Sources/LinuxPlatform/Linux.swift
@@ -36,7 +36,7 @@ public struct Linux: Platform {
             throw Error(message: "\(tmpFile) doesn't exist")
         }
 
-        let toolchainsDir = swiftlyHomeDir.appendingPathComponent("toolchains")
+        let toolchainsDir = SwiftlyCore.homeDir.appendingPathComponent("toolchains")
         if !toolchainsDir.fileExists() {
             try FileManager.default.createDirectory(at: toolchainsDir, withIntermediateDirectories: false)
         }
@@ -55,13 +55,36 @@ public struct Linux: Platform {
             // prepend ~/.swiftly/toolchains/<toolchain> to each file name
             return toolchainDir.appendingPathComponent(String(relativePath))
         }
-
-        // TODO: if config doesn't have an active toolchain, set it to that
     }
 
     public func uninstall(version _: ToolchainVersion) throws {}
 
-    public func use(_: ToolchainVersion) throws {}
+    public func use(_ toolchain: ToolchainVersion) throws {
+        let toolchainBinURL = SwiftlyCore.toolchainsDir
+            .appendingPathComponent(toolchain.name, isDirectory: true)
+            .appendingPathComponent("usr", isDirectory: true)
+            .appendingPathComponent("bin", isDirectory: true)
+
+        // Delete existing symlinks from previously in-use toolchain.
+        for existingExecutable in try FileManager.default.contentsOfDirectory(atPath: SwiftlyCore.binDir.path) {
+            guard existingExecutable != "swiftly" else {
+                continue
+            }
+            try SwiftlyCore.binDir.appendingPathComponent(existingExecutable).deleteIfExists()
+        }
+
+        for executable in try FileManager.default.contentsOfDirectory(atPath: toolchainBinURL.path) {
+            let linkURL = SwiftlyCore.binDir.appendingPathComponent(executable)
+            let executableURL = toolchainBinURL.appendingPathComponent(executable)
+
+            try linkURL.deleteIfExists()
+
+            try FileManager.default.createSymbolicLink(
+                atPath: linkURL.path,
+                withDestinationPath: executableURL.path
+            )
+        }
+    }
 
     public func listToolchains(selector _: ToolchainSelector?) -> [ToolchainVersion] {
         []
diff --git a/Sources/Swiftly/Install.swift b/Sources/Swiftly/Install.swift
@@ -144,8 +144,13 @@ struct Install: SwiftlyCommand {
 
         try Swiftly.currentPlatform.install(from: tmpFile, version: version)
 
-        try Config.update { config in
-            config.installedToolchains.insert(version)
+        var config = try Config.load()
+        config.installedToolchains.insert(version)
+        try config.save()
+
+        // If this is the first installed toolchain, mark it as in-use.
+        if config.inUse == nil {
+            try await Use.execute(version)
         }
 
         print("\(version) installed successfully!")
diff --git a/Sources/Swiftly/List.swift b/Sources/Swiftly/List.swift
@@ -38,8 +38,10 @@ struct List: SwiftlyCommand {
             try ToolchainSelector(parsing: input)
         }
 
-        let toolchains = Swiftly.currentPlatform.listToolchains(selector: selector)
-        let activeToolchain = try Swiftly.currentPlatform.currentToolchain()
+        let config = try Config.load()
+
+        let toolchains = config.listInstalledToolchains(selector: selector)
+        let activeToolchain = config.inUse
 
         let printToolchain = { (toolchain: ToolchainVersion) in
             var message = "\(toolchain)"
diff --git a/Sources/Swiftly/ListAvailable.swift b/Sources/Swiftly/ListAvailable.swift
@@ -42,8 +42,10 @@ struct ListAvailable: SwiftlyCommand {
             .map(ToolchainVersion.stable)
             .filter { selector?.matches(toolchain: $0) ?? true }
 
-        let installedToolchains = Set(Swiftly.currentPlatform.listToolchains(selector: selector))
-        let activeToolchain = try Swiftly.currentPlatform.currentToolchain()
+        let config = try Config.load()
+
+        let installedToolchains = Set(config.listInstalledToolchains(selector: selector))
+        let activeToolchain = config.inUse
 
         let printToolchain = { (toolchain: ToolchainVersion) in
             var message = "\(toolchain)"
diff --git a/Sources/Swiftly/Swiftly.swift b/Sources/Swiftly/Swiftly.swift
@@ -37,14 +37,14 @@ public protocol SwiftlyCommand: AsyncParsableCommand {}
 
 extension SwiftlyCommand {
     public mutating func validate() throws {
-        do {
-            _ = try Config.load()
-        } catch {
-            let msg = """
-            Could not load swiftly's configuration file due to error: \"\(error)\".
-            To use swiftly, modify the configuration file to fix the issue or perform a clean installation.
-            """
-            throw Error(message: msg)
+        for requiredDir in SwiftlyCore.requiredDirectories {
+            guard requiredDir.fileExists() else {
+                try FileManager.default.createDirectory(at: requiredDir, withIntermediateDirectories: true)
+                continue
+            }
         }
+
+        // Verify that the configuration exists and can be loaded
+        _ = try Config.load()
     }
 }
diff --git a/Sources/Swiftly/Uninstall.swift b/Sources/Swiftly/Uninstall.swift
@@ -35,7 +35,8 @@ struct Uninstall: SwiftlyCommand {
 
     mutating func run() async throws {
         let selector = try ToolchainSelector(parsing: self.toolchain)
-        let toolchains = Swiftly.currentPlatform.listToolchains(selector: selector)
+        let config = try Config.load()
+        let toolchains = config.listInstalledToolchains(selector: selector)
 
         guard !toolchains.isEmpty else {
             print("no toolchains matched \"\(self.toolchain)\"")
diff --git a/Sources/Swiftly/Update.swift b/Sources/Swiftly/Update.swift
@@ -63,11 +63,11 @@ struct Update: SwiftlyCommand {
 
     private func oldToolchain() throws -> ToolchainVersion? {
         guard let input = self.toolchain else {
-            return try Swiftly.currentPlatform.currentToolchain()
+            return try Config.load().inUse
         }
 
         let selector = try ToolchainSelector(parsing: input)
-        let toolchains = Swiftly.currentPlatform.listToolchains(selector: selector)
+        let toolchains = try Config.load().listInstalledToolchains(selector: selector)
 
         // When multiple toolchains are matched, update the latest one.
         // This is for situations such as `swiftly update 5.5` when both
diff --git a/Sources/Swiftly/Use.swift b/Sources/Swiftly/Use.swift
@@ -1,7 +1,7 @@
 import ArgumentParser
 import SwiftlyCore
 
-struct Use: SwiftlyCommand {
+internal struct Use: SwiftlyCommand {
     public static var configuration = CommandConfiguration(
         abstract: "Set the active toolchain."
     )
@@ -40,21 +40,32 @@ struct Use: SwiftlyCommand {
 
     internal mutating func run() async throws {
         let selector = try ToolchainSelector(parsing: self.toolchain)
-        guard let toolchain = Swiftly.currentPlatform.listToolchains(selector: selector).max() else {
-            print("no installed toolchains match \"\(self.toolchain)\"")
+        let config = try Config.load()
+
+        guard let toolchain = config.listInstalledToolchains(selector: selector).max() else {
+            print("No installed toolchains match \"\(self.toolchain)\"")
             return
         }
 
-        let old = try Swiftly.currentPlatform.currentToolchain()
+        try await Self.execute(toolchain)
+    }
+
+    internal static func execute(_ toolchain: ToolchainVersion) async throws {
+        var config = try Config.load()
+        let previousToolchain = config.inUse
 
-        try Swiftly.currentPlatform.use(toolchain)
-        try Config.update { config in
-            config.inUse = toolchain
+        guard toolchain != previousToolchain else {
+            print("\(toolchain) is already in use")
+            return
         }
 
-        var message = "The current toolchain is now \(toolchain)"
-        if let old {
-            message += " (was \(old))"
+        try Swiftly.currentPlatform.use(toolchain)
+        config.inUse = toolchain
+        try config.save()
+
+        var message = "Set the active toolchain to \(toolchain)"
+        if let previousToolchain {
+            message += " (was \(previousToolchain))"
         }
 
         print(message)
diff --git a/Sources/SwiftlyCore/Config.swift b/Sources/SwiftlyCore/Config.swift
@@ -1,8 +1,5 @@
 import Foundation
 
-public var swiftlyHomeDir =
-    FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".swiftly", isDirectory: true)
-
 /// Struct modelling the config.json file used to track installed toolchains,
 /// the current in-use tooolchain, and information about the platform.
 ///
@@ -18,10 +15,6 @@ public struct Config: Codable, Equatable {
     public var installedToolchains: Set<ToolchainVersion>
     public var platform: PlatformDefinition
 
-    // TODO: support other locations
-    public static let fileName = "config.json"
-    private static let url = swiftlyHomeDir.appendingPathComponent(Self.fileName)
-
     internal init(inUse: ToolchainVersion?, installedToolchains: Set<ToolchainVersion>, platform: PlatformDefinition) {
         self.inUse = inUse
         self.installedToolchains = installedToolchains
@@ -36,14 +29,40 @@ public struct Config: Codable, Equatable {
 
     /// Read the config file from disk.
     public static func load() throws -> Config {
-        let data = try Data(contentsOf: Config.url)
-        return try JSONDecoder().decode(Config.self, from: data)
+        do {
+            let data = try Data(contentsOf: SwiftlyCore.configFile)
+            return try JSONDecoder().decode(Config.self, from: data)
+        } catch {
+            let msg = """
+            Could not load swiftly's configuration file at \(SwiftlyCore.configFile.path) due to error: \"\(error)\".
+            To use swiftly, modify the configuration file to fix the issue or perform a clean installation.
+            """
+            throw Error(message: msg)
+        }
     }
 
     /// Write the contents of this `Config` struct to disk.
     public func save() throws {
         let outData = try Self.makeEncoder().encode(self)
-        try outData.write(to: Config.url, options: .atomic)
+        try outData.write(to: SwiftlyCore.configFile, options: .atomic)
+    }
+
+    public func listInstalledToolchains(selector: ToolchainSelector?) -> [ToolchainVersion] {
+        guard let selector else {
+            return Array(self.installedToolchains)
+        }
+
+        if case .latest = selector {
+            var ts: [ToolchainVersion] = []
+            if let t = self.installedToolchains.filter({ $0.isStableRelease() }).max() {
+                ts.append(t)
+            }
+            return ts
+        }
+
+        return self.installedToolchains.filter { toolchain in
+            selector.matches(toolchain: toolchain)
+        }
     }
 
     /// Load the config, pass it to the provided closure, and then
diff --git a/Sources/SwiftlyCore/Platform.swift b/Sources/SwiftlyCore/Platform.swift
@@ -34,9 +34,6 @@ public protocol Platform {
     /// Select the toolchain associated with the given version.
     func use(_ version: ToolchainVersion) throws
 
-    /// List the installed toolchains.
-    func listToolchains(selector: ToolchainSelector?) -> [ToolchainVersion]
-
     /// Get a list of snapshot builds for the platform. If a version is specified, only
     /// return snapshots associated with the version.
     /// This will likely have a default implementation.
@@ -46,9 +43,6 @@ public protocol Platform {
     /// This will likely have a default implementation.
     func selfUpdate() async throws
 
-    /// Get the toolchain that is currently "in use", if any.
-    func currentToolchain() throws -> ToolchainVersion?
-
     /// Get a path pointing to a unique, temporary file.
     /// This does not need to actually create the file.
     func getTempFilePath() -> URL
diff --git a/Sources/SwiftlyCore/SwiftlyCore.swift b/Sources/SwiftlyCore/SwiftlyCore.swift
@@ -0,0 +1,46 @@
+import Foundation
+
+/// The location on disk where swiftly will store its configuration, installed toolchains, and symlinks to
+/// the active location.
+///
+/// The structure of this directory looks like the following:
+///
+/// ```
+/// homeDir/
+///   |
+///   -- bin/
+///   |
+///   -- toolchains/
+///   |
+///   -- config.json
+/// ```
+///
+/// TODO: support other locations besides ~/.swiftly
+public var homeDir =
+    FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".swiftly", isDirectory: true)
+
+/// The "bin" subdirectory of swiftly's home directory. Contains the swiftly executable as well as symlinks
+/// to executables in the "bin" directory of the active toolchain.
+public var binDir: URL {
+    SwiftlyCore.homeDir.appendingPathComponent("bin", isDirectory: true)
+}
+
+/// The "toolchains" subdirectory of swiftly's home directory. Contains the Swift toolchains managed by swiftly.
+public var toolchainsDir: URL {
+    SwiftlyCore.homeDir.appendingPathComponent("toolchains", isDirectory: true)
+}
+
+/// The URL of the configuration file in swiftly's home directory.
+public var configFile: URL {
+    SwiftlyCore.homeDir.appendingPathComponent("config.json")
+}
+
+/// The list of directories that swiftly needs to exist in order to execute.
+/// If they do not exist when a swiftly command is invoked, they will be created.
+public var requiredDirectories: [URL] {
+    [
+        SwiftlyCore.homeDir,
+        SwiftlyCore.binDir,
+        SwiftlyCore.toolchainsDir,
+    ]
+}
diff --git a/Sources/SwiftlyCore/ToolchainVerison.swift b/Sources/SwiftlyCore/ToolchainVerison.swift
@@ -114,6 +114,20 @@ public enum ToolchainVersion {
         return true
     }
 
+    public var asStableRelease: StableRelease? {
+        guard case let .stable(s) = self else {
+            return nil
+        }
+        return s
+    }
+
+    public var asSnapshot: Snapshot? {
+        guard case let .snapshot(s) = self else {
+            return nil
+        }
+        return s
+    }
+
     public func isSnapshot() -> Bool {
         guard case .snapshot = self else {
             return false
diff --git a/Sources/SwiftlyCore/Utils.swift b/Sources/SwiftlyCore/Utils.swift
@@ -4,4 +4,14 @@ extension URL {
     public func fileExists() -> Bool {
         FileManager.default.fileExists(atPath: self.path, isDirectory: nil)
     }
+
+    public func deleteIfExists() throws {
+        do {
+            try FileManager.default.removeItem(at: self)
+        } catch let error as NSError {
+            guard error.domain == NSCocoaErrorDomain && error.code == CocoaError.fileNoSuchFile.rawValue else {
+                throw error
+            }
+        }
+    }
 }
diff --git a/Tests/SwiftlyTests/InstallTests.swift b/Tests/SwiftlyTests/InstallTests.swift
@@ -219,4 +219,24 @@ final class InstallTests: SwiftlyTests {
         try await self.duplicateTest("5.7-snapshot-2022-08-30")
         try await self.duplicateTest("5.7-snapshot")
     }
+
+    /// Verify that the installed toolchain will be used if no toolchains currently are installed.
+    func testInstallUsesFirstToolchain() async throws {
+        try await self.withTestHome {
+            let config = try Config.load()
+            XCTAssertTrue(config.inUse == nil)
+            try await validateInUse(expected: nil)
+
+            var cmd = try self.parseCommand(Install.self, ["install", "5.7.0"])
+            try await cmd.run()
+
+            try await validateInUse(expected: ToolchainVersion(major: 5, minor: 7, patch: 0))
+
+            var install56 = try self.parseCommand(Install.self, ["install", "5.6.0"])
+            try await install56.run()
+
+            // Verify that 5.7.0 is still in use.
+            try await self.validateInUse(expected: ToolchainVersion(major: 5, minor: 7, patch: 0))
+        }
+    }
 }
diff --git a/Tests/SwiftlyTests/SwiftlyTests.swift b/Tests/SwiftlyTests/SwiftlyTests.swift
diff --git a/Tests/SwiftlyTests/UseTests.swift b/Tests/SwiftlyTests/UseTests.swift
