Refactor to JSON Output Format

Author: roulpriya

Sources/Swiftly/OutputSchema.swift

@@ -0,0 +1,76 @@
+import Foundation
+import SwiftlyCore
+
+struct LocationInfo: OutputData {
+    let path: String
+
+    init(path: String) {
+        self.path = path
+    }
+
+    var description: String {
+        return self.path
+    }
+}
+
+struct ToolchainInfo: OutputData {
+    let version: String
+    let source: ToolchainSource?
+
+    init(version: String, source: ToolchainSource? = nil) {
+        self.version = version
+        self.source = source
+    }
+
+    var description: String {
+        var message = self.version
+        if let source = source {
+            message += " (\(source.description))"
+        }
+        return message
+    }
+}
+
+struct ToolchainSetInfo: OutputData {
+    let version: String
+    let previousVersion: String?
+    let isGlobal: Bool
+    let configFile: String?
+
+    init(
+        version: String, previousVersion: String? = nil, isGlobal: Bool, configFile: String? = nil
+    ) {
+        self.version = version
+        self.previousVersion = previousVersion
+        self.isGlobal = isGlobal
+        self.configFile = configFile
+    }
+
+    var description: String {
+        var message = self.version
+        if let previousVersion = previousVersion {
+            message += " (previous: \(previousVersion))"
+        }
+        if isGlobal {
+            message += " (global)"
+        }
+        if let configFile = configFile {
+            message += " (config: \(configFile))"
+        }
+        return message
+    }
+}
+
+enum ToolchainSource: Encodable, CustomStringConvertible {
+    case swiftVersionFile(String)
+    case globalDefault
+
+    var description: String {
+        switch self {
+        case let .swiftVersionFile(path):
+            return path
+        case .globalDefault:
+            return "default"
+        }
+    }
+}

Sources/Swiftly/Swiftly.swift

@@ -27,6 +27,9 @@ public struct GlobalOptions: ParsableArguments {
     @Flag(help: "Enable verbose reporting from swiftly")
     var verbose: Bool = false
 
+    @Option(name: .long, help: "Output format (text, json)")
+    var format: SwiftlyCore.OutputFormat = .text
+
     public init() {}
 }
 

Sources/Swiftly/Use.swift

@@ -69,6 +69,8 @@ struct Use: SwiftlyCommand {
 
         try await validateLinked(ctx)
 
+        let formatter: OutputFormatter = self.root.format == .json ? JSONOutputFormatter() : TextOutputFormatter()
+
         // This is the bare use command where we print the selected toolchain version (or the path to it)
         guard let toolchain = self.toolchain else {
             let (selectedVersion, result) = try await selectToolchain(ctx, config: &config, globalDefault: self.globalDefault)
@@ -84,21 +86,22 @@ struct Use: SwiftlyCommand {
             }
 
             if self.printLocation {
-                // Print the toolchain location and exit
-                await ctx.message("\(Swiftly.currentPlatform.findToolchainLocation(ctx, selectedVersion))")
+                let location = "\(Swiftly.currentPlatform.findToolchainLocation(ctx, selectedVersion))"
+                let output = formatter.format(LocationInfo(path: location))
+                await ctx.print(output)
                 return
             }
 
-            var message = "\(selectedVersion)"
-
-            switch result {
+            let source: ToolchainSource? = switch result {
             case let .swiftVersionFile(versionFile, _, _):
-                message += " (\(versionFile))"
+                .swiftVersionFile("\(versionFile)")
             case .globalDefault:
-                message += " (default)"
+                .globalDefault
             }
 
-            await ctx.message(message)
+            let toolchainInfo = ToolchainInfo(version: "\(selectedVersion)", source: source)
+            let output = formatter.format(toolchainInfo)
+            await ctx.print(output)
 
             return
         }
@@ -110,24 +113,25 @@ struct Use: SwiftlyCommand {
         let selector = try ToolchainSelector(parsing: toolchain)
 
         guard let toolchain = config.listInstalledToolchains(selector: selector).max() else {
-            await ctx.message("No installed toolchains match \"\(toolchain)\"")
-            return
+            throw SwiftlyError(message: "No installed toolchains match \"\(toolchain)\"")
         }
 
-        try await Self.execute(ctx, toolchain, globalDefault: self.globalDefault, assumeYes: self.root.assumeYes, &config)
+        try await Self.execute(ctx, toolchain, globalDefault: self.globalDefault, assumeYes: self.root.assumeYes, formatter: formatter, &config)
     }
 
     /// Use a toolchain. This method can modify and save the input config and also create/modify a `.swift-version` file.
-    static func execute(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, globalDefault: Bool, assumeYes: Bool = true, _ config: inout Config) async throws {
+    static func execute(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, globalDefault: Bool, assumeYes: Bool = true, formatter: OutputFormatter? = nil, _ config: inout Config) async throws {
         let (selectedVersion, result) = try await selectToolchain(ctx, config: &config, globalDefault: globalDefault)
 
-        var message: String
+        let outputFormatter = formatter ?? TextOutputFormatter()
+        let isGlobal: Bool
+        let configFile: String?
 
         if case let .swiftVersionFile(versionFile, _, _) = result {
             // We don't care in this case if there were any problems with the swift version files, just overwrite it with the new value
             try toolchain.name.write(to: versionFile, atomically: true)
-
-            message = "The file `\(versionFile)` has been set to `\(toolchain)`"
+            isGlobal = false
+            configFile = "\(versionFile)"
         } else if let newVersionFile = try await findNewVersionFile(ctx), !globalDefault {
             if !assumeYes {
                 await ctx.message("A new file `\(newVersionFile)` will be created to set the new in-use toolchain for this project. Alternatively, you can set your default globally with the `--global-default` flag. Proceed with creating this file?")
@@ -139,19 +143,24 @@ struct Use: SwiftlyCommand {
             }
 
             try toolchain.name.write(to: newVersionFile, atomically: true)
-
-            message = "The file `\(newVersionFile)` has been set to `\(toolchain)`"
+            isGlobal = false
+            configFile = "\(newVersionFile)"
         } else {
             config.inUse = toolchain
             try config.save(ctx)
-            message = "The global default toolchain has been set to `\(toolchain)`"
+            isGlobal = true
+            configFile = nil
         }
 
-        if let selectedVersion {
-            message += " (was \(selectedVersion.name))"
-        }
+        let setInfo = ToolchainSetInfo(
+            version: "\(toolchain)",
+            previousVersion: selectedVersion?.name,
+            isGlobal: isGlobal,
+            configFile: configFile
+        )
 
-        await ctx.message(message)
+        let output = outputFormatter.format(setInfo)
+        await ctx.print(output)
     }
 
     static func findNewVersionFile(_ ctx: SwiftlyCoreContext) async throws -> FilePath? {

Sources/SwiftlyCore/OutputFormatter.swift

@@ -0,0 +1,44 @@
+import ArgumentParser
+import Foundation
+
+public enum OutputFormat: String, CaseIterable, ExpressibleByArgument {
+    case text
+    case json
+
+    public var description: String {
+        self.rawValue
+    }
+}
+
+public protocol OutputFormatter {
+    func format(_ data: OutputData) -> String
+}
+
+public protocol OutputData: Encodable, CustomStringConvertible {
+    var description: String { get }
+}
+
+public struct TextOutputFormatter: OutputFormatter {
+    public init() {}
+
+    public func format(_ data: OutputData) -> String {
+        data.description
+    }
+}
+
+public struct JSONOutputFormatter: OutputFormatter {
+    public init() {}
+
+    public func format(_ data: OutputData) -> String {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+
+        let jsonData = try? encoder.encode(data)
+
+        guard let jsonData = jsonData, let result = String(data: jsonData, encoding: .utf8) else {
+            return "{}"
+        }
+
+        return result
+    }
+}