Add version check and prompt for self update

Sources/Swiftly/Install.swift

@@ -82,7 +82,10 @@ struct Install: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
 
         var config = try await Config.load(ctx)
 

Sources/Swiftly/List.swift

@@ -38,7 +38,11 @@ struct List: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
+
         let selector = try self.toolchainSelector.map { input in
             try ToolchainSelector(parsing: input)
         }

Sources/Swiftly/ListAvailable.swift

@@ -44,7 +44,11 @@ struct ListAvailable: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
+
         let selector = try self.toolchainSelector.map { input in
             try ToolchainSelector(parsing: input)
         }

Sources/Swiftly/Run.swift

@@ -58,7 +58,10 @@ struct Run: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
 
         // Handle the specific case where help is requested of the run subcommand
         if command == ["--help"] {

Sources/Swiftly/SelfUpdate.swift

@@ -21,7 +21,7 @@ struct SelfUpdate: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let _ = try await validateSwiftly(ctx)
 
         let swiftlyBin = Swiftly.currentPlatform.swiftlyBinDir(ctx) / "swiftly"
         guard try await fs.exists(atPath: swiftlyBin) else {

Sources/Swiftly/Swiftly.swift

@@ -93,7 +93,7 @@ extension Data {
 }
 
 extension SwiftlyCommand {
-    public mutating func validateSwiftly(_ ctx: SwiftlyCoreContext) async throws {
+    public mutating func validateSwiftly(_ ctx: SwiftlyCoreContext) async throws -> () -> Void {
         for requiredDir in Swiftly.requiredDirectories(ctx) {
             guard try await fs.exists(atPath: requiredDir) else {
                 do {
@@ -107,5 +107,27 @@ extension SwiftlyCommand {
 
         // Verify that the configuration exists and can be loaded
         _ = try await Config.load(ctx)
+
+        let shouldUpdateSwiftly: Bool
+        if let swiftlyRelease = try? await ctx.httpClient.getCurrentSwiftlyRelease() {
+            shouldUpdateSwiftly = try swiftlyRelease.swiftlyVersion > SwiftlyCore.version
+        } else {
+            shouldUpdateSwiftly = false
+        }
+
+        return {
+            if shouldUpdateSwiftly {
+                let updateMessage = """
+                -----------------------------
+                A new release of swiftly is available.
+                Please run `swiftly self-update` to update.
+                -----------------------------\n
+                """
+
+                if let data = updateMessage.data(using: .utf8) {
+                    FileHandle.standardError.write(data)
+                }
+            }
+        }
     }
 }

Sources/Swiftly/Uninstall.swift

@@ -48,7 +48,11 @@ struct Uninstall: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
+
         let startingConfig = try await Config.load(ctx)
 
         let toolchains: [ToolchainVersion]

Sources/Swiftly/Update.swift

@@ -83,7 +83,11 @@ struct Update: SwiftlyCommand {
     }
 
     public mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
+
         var config = try await Config.load(ctx)
 
         guard let parameters = try await self.resolveUpdateParameters(ctx, &config) else {

Sources/Swiftly/Use.swift

@@ -60,7 +60,11 @@ struct Use: SwiftlyCommand {
     }
 
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
-        try await validateSwiftly(ctx)
+        let versionUpdateReminder = try await validateSwiftly(ctx)
+        defer {
+            versionUpdateReminder()
+        }
+
         var config = try await Config.load(ctx)
 
         // This is the bare use command where we print the selected toolchain version (or the path to it)

Tests/SwiftlyTests/ListTests.swift

@@ -19,17 +19,21 @@ import Testing
         .oldReleaseSnapshot,
     ]
 
+    private static let swiftlyVersion = SwiftlyVersion(major: SwiftlyCore.version.major, minor: 0, patch: 0)
+
     /// Constructs a mock home directory with the toolchains listed above installed and runs the provided closure within
     /// the context of that home.
     func runListTest(f: () async throws -> Void) async throws {
         try await SwiftlyTests.withTestHome(name: Self.homeName) {
-            for toolchain in Set<ToolchainVersion>.allToolchains() {
-                try await SwiftlyTests.installMockedToolchain(toolchain: toolchain)
-            }
+            try await SwiftlyTests.withMockedSwiftlyVersion(latestSwiftlyVersion: Self.swiftlyVersion) {
+                for toolchain in Set<ToolchainVersion>.allToolchains() {
+                    try await SwiftlyTests.installMockedToolchain(toolchain: toolchain)
+                }
 
-            try await SwiftlyTests.runCommand(Use.self, ["use", "latest"])
+                try await SwiftlyTests.runCommand(Use.self, ["use", "latest"])
 
-            try await f()
+                try await f()
+            }
         }
     }
 
@@ -155,16 +159,18 @@ import Testing
 
     /// Tests that `list` properly handles the case where no toolchains have been installed yet.
     @Test(.testHome(Self.homeName)) func listEmpty() async throws {
-        var toolchains = try await self.runList(selector: nil)
-        #expect(toolchains == [])
+        try await SwiftlyTests.withMockedSwiftlyVersion(latestSwiftlyVersion: Self.swiftlyVersion) {
+            var toolchains = try await self.runList(selector: nil)
+            #expect(toolchains == [])
 
-        toolchains = try await self.runList(selector: "5")
-        #expect(toolchains == [])
+            toolchains = try await self.runList(selector: "5")
+            #expect(toolchains == [])
 
-        toolchains = try await self.runList(selector: "main-snapshot")
-        #expect(toolchains == [])
+            toolchains = try await self.runList(selector: "main-snapshot")
+            #expect(toolchains == [])
 
-        toolchains = try await self.runList(selector: "5.7-snapshot")
-        #expect(toolchains == [])
+            toolchains = try await self.runList(selector: "5.7-snapshot")
+            #expect(toolchains == [])
+        }
     }
 }

Tests/SwiftlyTests/PlatformTests.swift

@@ -18,7 +18,7 @@ import Testing
         return (mockedToolchainFile, version, tmpDir)
     }
 
-    @Test(.testHome()) func install() async throws {
+    @Test(.testHome(), .mockedSwiftlyVersion()) func install() async throws {
         // GIVEN: a toolchain has been downloaded
         var (mockedToolchainFile, version, tmpDir) = try await self.mockToolchainDownload(version: "5.7.1")
         var cleanup = [tmpDir]
@@ -53,7 +53,7 @@ import Testing
         #expect(2 == toolchains.count)
     }
 
-    @Test(.testHome()) func uninstall() async throws {
+    @Test(.testHome(), .mockedSwiftlyVersion()) func uninstall() async throws {
         // GIVEN: toolchains have been downloaded, and installed
         var (mockedToolchainFile, version, tmpDir) = try await self.mockToolchainDownload(version: "5.8.0")
         var cleanup = [tmpDir]
@@ -89,6 +89,7 @@ import Testing
 
 #if os(macOS) || os(Linux)
     @Test(
+        .mockedSwiftlyVersion(),
         .mockHomeToolchains(),
         arguments: [
             "/a/b/c:SWIFTLY_BIN_DIR:/d/e/f",

Tests/SwiftlyTests/RunTests.swift

@@ -8,7 +8,7 @@ import Testing
     static let homeName = "runTests"
 
     /// Tests that the `run` command can switch between installed toolchains.
-    @Test(.mockHomeToolchains()) func runSelection() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains()) func runSelection() async throws {
         // GIVEN: a set of installed toolchains
         // WHEN: invoking the run command with a selector argument for that toolchain
         var output = try await SwiftlyTests.runWithMockedIO(Run.self, ["run", "swift", "--version", "+\(ToolchainVersion.newStable.name)"])
@@ -35,7 +35,7 @@ import Testing
     }
 
     /// Tests the `run` command verifying that the environment is as expected
-    @Test(.mockHomeToolchains()) func runEnvironment() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains()) func runEnvironment() async throws {
         // The toolchains directory should be the fist entry on the path
         let output = try await SwiftlyTests.runWithMockedIO(Run.self, ["run", try await Swiftly.currentPlatform.getShell(), "-c", "echo $PATH"])
         #expect(output.count == 1)

Tests/SwiftlyTests/SwiftlyTests.swift

@@ -142,6 +142,23 @@ extension Trait where Self == TestHomeTrait {
     static func testHome(_ name: String = "testHome") -> Self { Self(name) }
 }
 
+// extension Trait for mockedSwiftlyVersion
+struct MockedSwiftlyVersionTrait: TestTrait, TestScoping {
+    var name: String = "testHome"
+
+    init(_ name: String) { self.name = name }
+
+    func provideScope(for _: Test, testCase _: Test.Case?, performing function: @Sendable () async throws -> Void) async throws {
+        try await SwiftlyTests.withMockedSwiftlyVersion(latestSwiftlyVersion: SwiftlyVersion(major: SwiftlyCore.version.major, minor: 0, patch: 0)) {
+            try await function()
+        }
+    }
+}
+
+extension Trait where Self == MockedSwiftlyVersionTrait {
+    static func mockedSwiftlyVersion(_ name: String = "testHome") -> Self { Self(name) }
+}
+
 struct MockHomeToolchainsTrait: TestTrait, TestScoping {
     var name: String = "testHome"
     var toolchains: Set<ToolchainVersion> = .allToolchains()

Tests/SwiftlyTests/UninstallTests.swift

@@ -7,7 +7,7 @@ import Testing
     static let homeName = "uninstallTests"
 
     /// Tests that `swiftly uninstall` successfully handles being invoked when no toolchains have been installed yet.
-    @Test(.mockHomeToolchains(Self.homeName, toolchains: [])) func uninstallNoInstalledToolchains() async throws {
+    @Test(.mockHomeToolchains(Self.homeName, toolchains: []), .mockedSwiftlyVersion()) func uninstallNoInstalledToolchains() async throws {
         _ = try await SwiftlyTests.runWithMockedIO(Uninstall.self, ["uninstall", "1.2.3"], input: ["y"])
 
         try await SwiftlyTests.validateInstalledToolchains(
@@ -17,7 +17,7 @@ import Testing
     }
 
     /// Tests that `swiftly uninstall latest` successfully uninstalls the latest stable release of Swift.
-    @Test func uninstallLatest() async throws {
+    @Test(.mockedSwiftlyVersion()) func uninstallLatest() async throws {
         let toolchains = Set<ToolchainVersion>.allToolchains().filter { $0.asStableRelease != nil }
         try await SwiftlyTests.withMockedHome(homeName: Self.homeName, toolchains: toolchains) {
             var installed = toolchains
@@ -38,7 +38,7 @@ import Testing
     }
 
     /// Tests that a fully-qualified stable release version can be supplied to `swiftly uninstall`.
-    @Test(.mockHomeToolchains(Self.homeName)) func uninstallStableRelease() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName)) func uninstallStableRelease() async throws {
         var installed: Set<ToolchainVersion> = .allToolchains()
 
         for toolchain in Set<ToolchainVersion>.allToolchains().filter({ $0.isStableRelease() }) {
@@ -60,7 +60,7 @@ import Testing
     }
 
     /// Tests that a fully-qualified snapshot version can be supplied to `swiftly uninstall`.
-    @Test(.mockHomeToolchains(Self.homeName)) func uninstallSnapshot() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName)) func uninstallSnapshot() async throws {
         var installed: Set<ToolchainVersion> = .allToolchains()
 
         for toolchain in Set<ToolchainVersion>.allToolchains().filter({ $0.isSnapshot() }) {
@@ -82,7 +82,7 @@ import Testing
     }
 
     /// Tests that multiple toolchains can be installed at once.
-    @Test func bulkUninstall() async throws {
+    @Test(.mockedSwiftlyVersion()) func bulkUninstall() async throws {
         let toolchains = Set(
             [
                 "main-snapshot-2022-01-03",
@@ -158,7 +158,7 @@ import Testing
     }
 
     /// Tests that uninstalling the toolchain that is currently "in use" has the expected behavior.
-    @Test func uninstallInUse() async throws {
+    @Test(.mockedSwiftlyVersion()) func uninstallInUse() async throws {
         let toolchains: Set<ToolchainVersion> = [
             .oldStable,
             .oldStableNewPatch,
@@ -224,7 +224,7 @@ import Testing
     }
 
     /// Tests that uninstalling the last toolchain is handled properly and cleans up any symlinks.
-    @Test(.mockHomeToolchains(Self.homeName, toolchains: [.oldStable])) func uninstallLastToolchain() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName, toolchains: [.oldStable])) func uninstallLastToolchain() async throws {
         _ = try await SwiftlyTests.runWithMockedIO(Uninstall.self, ["uninstall", ToolchainVersion.oldStable.name], input: ["y"])
         let config = try await Config.load()
         #expect(config.inUse == nil)
@@ -237,7 +237,7 @@ import Testing
     }
 
     /// Tests that aborting an uninstall works correctly.
-    @Test(.mockHomeToolchains(Self.homeName, toolchains: .allToolchains(), inUse: .oldStable)) func uninstallAbort() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName, toolchains: .allToolchains(), inUse: .oldStable)) func uninstallAbort() async throws {
         let preConfig = try await Config.load()
         _ = try await SwiftlyTests.runWithMockedIO(Uninstall.self, ["uninstall", ToolchainVersion.oldStable.name], input: ["n"])
         try await SwiftlyTests.validateInstalledToolchains(
@@ -250,7 +250,7 @@ import Testing
     }
 
     /// Tests that providing the `-y` argument skips the confirmation prompt.
-    @Test(.mockHomeToolchains(Self.homeName, toolchains: [.oldStable, .newStable])) func uninstallAssumeYes() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName, toolchains: [.oldStable, .newStable])) func uninstallAssumeYes() async throws {
         try await SwiftlyTests.runCommand(Uninstall.self, ["uninstall", "-y", ToolchainVersion.oldStable.name])
         try await SwiftlyTests.validateInstalledToolchains(
             [.newStable],
@@ -259,7 +259,7 @@ import Testing
     }
 
     /// Tests that providing "all" as an argument to uninstall will uninstall all toolchains.
-    @Test(.mockHomeToolchains(Self.homeName, toolchains: [.oldStable, .newStable, .newMainSnapshot, .oldReleaseSnapshot])) func uninstallAll() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName, toolchains: [.oldStable, .newStable, .newMainSnapshot, .oldReleaseSnapshot])) func uninstallAll() async throws {
         try await SwiftlyTests.runCommand(Uninstall.self, ["uninstall", "-y", "all"])
         try await SwiftlyTests.validateInstalledToolchains(
             [],
@@ -268,7 +268,7 @@ import Testing
     }
 
     /// Tests that uninstalling a toolchain that is the global default, but is not in the list of installed toolchains.
-    @Test(.mockHomeToolchains(Self.homeName, toolchains: [.oldStable, .newStable, .newMainSnapshot, .oldReleaseSnapshot])) func uninstallNotInstalled() async throws {
+    @Test(.mockedSwiftlyVersion(), .mockHomeToolchains(Self.homeName, toolchains: [.oldStable, .newStable, .newMainSnapshot, .oldReleaseSnapshot])) func uninstallNotInstalled() async throws {
         var config = try await Config.load()
         config.inUse = .newMainSnapshot
         config.installedToolchains.remove(.newMainSnapshot)