update encoding

Author: bkhouri

Sources/Commands/SwiftTestCommand.swift

@@ -398,11 +398,40 @@ package struct CoverageFormatOutput: Encodable {
     package init() {
         self._underlying = [CoverageFormat : AbsolutePath]()
     }
-    
+
     package init(data: [CoverageFormat : AbsolutePath]) {
         self._underlying = data
     }
 
+    // Custom encoding to ensure the dictionary is encoded as a JSON object, not an array
+    public func encode(to encoder: Encoder) throws {
+        // Use keyed container to encode each format and its path
+        // This will create proper JSON objects and proper plain text "key: value" format
+        var container = encoder.container(keyedBy: DynamicCodingKey.self)
+
+        // Sort entries for consistent output
+        let sortedEntries = _underlying.sorted { $0.key.rawValue < $1.key.rawValue }
+
+        for (format, path) in sortedEntries {
+            let key = DynamicCodingKey(stringValue: format.rawValue)!
+            try container.encode(path.pathString, forKey: key)
+        }
+    }
+
+    // Dynamic coding keys for the formats
+    private struct DynamicCodingKey: CodingKey {
+        var stringValue: String
+        var intValue: Int? { nil }
+
+        init?(stringValue: String) {
+            self.stringValue = stringValue
+        }
+
+        init?(intValue: Int) {
+            return nil
+        }
+    }
+
     /// Adds a key/value pair to the underlying dictionary.
     /// - Parameters:
     ///   - format: The coverage format key
@@ -419,7 +448,7 @@ package struct CoverageFormatOutput: Encodable {
     package subscript(format: CoverageFormat) -> AbsolutePath? {
         return _underlying[format]
     }
-    
+
     /// Gets the path for a format, throwing an error if it doesn't exist.
     /// - Parameter format: The coverage format
     /// - Returns: The absolute path for the format
@@ -430,48 +459,17 @@ package struct CoverageFormatOutput: Encodable {
         }
         return path
     }
-    
+
     /// Returns all formats currently stored
     package var formats: [CoverageFormat] {
         return Array(_underlying.keys).sorted()
     }
-    
+
     /// Iterate over format/path pairs
     package func forEach(_ body: (CoverageFormat, AbsolutePath) throws -> Void) rethrows {
         try _underlying.forEach(body)
     }
-    
-    /// Encodes the coverage format output as JSON string
-    /// - Returns: JSON string representation of the format/path mapping
-    /// - Throws: `StringError` if JSON encoding fails
-    package func encodeAsJSON() throws -> String {
-        let sortedData = _underlying.sorted { $0.key.rawValue < $1.key.rawValue }
-        let jsonObject: [String: String] = Dictionary(uniqueKeysWithValues: sortedData.map { ($0.key.rawValue, $0.value.pathString) })
-        
-        do {
-            let jsonData = try JSONSerialization.data(withJSONObject: jsonObject, options: [.prettyPrinted, .sortedKeys])
-            guard let jsonString = String(data: jsonData, encoding: .utf8) else {
-                throw StringError("Failed to convert JSON data to string")
-            }
-            return jsonString
-        } catch {
-            throw StringError("Failed to encode coverage format output as JSON: \(error)")
-        }
-    }
-    
-    /// Encodes the coverage format output as plain text
-    /// - Returns: Text string with format/path pairs, one per line
-    package func encodeAsText() -> String {
-        let sortedFormats = _underlying.keys.sorted()
-        return sortedFormats.map { format in
-            let value = _underlying[format]!.pathString
-            if _underlying.count == 1 {
-                return value
-            } else {
-                return "\(format.rawValue.uppercased()): \(value)"
-            }
-        }.joined(separator: "\n")
-    }
+
 }
 
 struct CodeCoverageConfiguration {
@@ -1111,19 +1109,9 @@ extension SwiftTestCommand {
             let config = try await self.getCodeCoverageConfiguration(swiftCommandState, format: format)
             coverageData[format] = config.outputDir
         }
-        
+
         let coverageOutput = CoverageFormatOutput(data: coverageData)
-        
-        switch printMode {
-        case .json:
-            let jsonOutput = try coverageOutput.encodeAsJSON()
-            print(jsonOutput)
-        case .text:
-            let textOutput = coverageOutput.encodeAsText()
-            print(textOutput)
-        }
 
-        print("-----------------------")
         let data: Data
         switch printMode {
             case .json:

Sources/Commands/Utilities/PlainTextEncoder.swift

@@ -14,31 +14,34 @@ import struct Foundation.Data
 import class TSCBasic.BufferedOutputByteStream
 import protocol TSCBasic.OutputByteStream
 
-struct PlainTextEncoder {
+package struct PlainTextEncoder {
     /// The formatting of the output plain-text data.
-    struct FormattingOptions: OptionSet {
-        let rawValue: UInt
+    package struct FormattingOptions: OptionSet {
+        package let rawValue: UInt
 
-        init(rawValue: UInt) {
+        package init(rawValue: UInt) {
             self.rawValue = rawValue
         }
 
         /// Produce plain-text format with indented output.
-        static let prettyPrinted = FormattingOptions(rawValue: 1 << 0)
+        package static let prettyPrinted = FormattingOptions(rawValue: 1 << 0)
     }
 
     /// The output format to produce. Defaults to `[]`.
-    var formattingOptions: FormattingOptions = []
+    package var formattingOptions: FormattingOptions = []
 
     /// Contextual user-provided information for use during encoding.
-    var userInfo: [CodingUserInfoKey: Any] = [:]
+    package var userInfo: [CodingUserInfoKey: Any] = [:]
+
+    /// Initializes a new PlainTextEncoder.
+    package init() {}
 
     /// Encodes the given top-level value and returns its plain text representation.
     ///
     /// - parameter value: The value to encode.
     /// - returns: A new `Data` value containing the encoded plan-text data.
     /// - throws: An error if any value throws an error during encoding.
-    func encode<T: Encodable>(_ value: T) throws -> Data {
+    package func encode<T: Encodable>(_ value: T) throws -> Data {
         let outputStream = BufferedOutputByteStream()
         let encoder = _PlainTextEncoder(
             outputStream: outputStream,

Tests/CommandsTests/TestCommandTests+Helpers.swift

@@ -18,13 +18,14 @@ import func Commands.getOutputDir
 import enum Commands.CoverageFormat
 import struct Commands.CoverageFormatOutput
 import typealias Basics.StringError
+import struct Commands.PlainTextEncoder
 
 @Suite(
     .tags(
         .TestSize.small,
     )
 )
-struct TestCommmandHelperTests {
+struct TestCommmandHelpersTests {
 
     @Suite
     struct getOutputDirTests {
@@ -404,8 +405,10 @@ struct TestCommmandHelperTests {
             var output = CoverageFormatOutput()
             try output.addFormat(.json, path: path)
 
-            let jsonString = try output.encodeAsJSON()
-            let jsonData = jsonString.data(using: .utf8)!
+            let encoder = JSONEncoder()
+            encoder.keyEncodingStrategy = .convertToSnakeCase
+            let jsonData = try encoder.encode(output)
+            let jsonString = String(decoding: jsonData, as: UTF8.self)
             let decoded = try JSONSerialization.jsonObject(with: jsonData) as! [String: String]
 
             #expect(decoded["json"] == "/path/to/coverage.json")
@@ -430,8 +433,11 @@ struct TestCommmandHelperTests {
                     try output.addFormat(.json, path: jsonPath)
                     try output.addFormat(.html, path: htmlPath)
 
-                    let jsonString = try output.encodeAsJSON()
-                    let jsonData = jsonString.data(using: .utf8)!
+                    let encoder = JSONEncoder()
+                    encoder.keyEncodingStrategy = .convertToSnakeCase
+                    encoder.outputFormatting = [.prettyPrinted]
+                    let jsonData = try encoder.encode(output)
+                    let jsonString = String(decoding: jsonData, as: UTF8.self)
                     let decoded = try JSONSerialization.jsonObject(with: jsonData) as! [String: String]
 
                     #expect(decoded["json"] == "/path/to/coverage.json")
@@ -447,8 +453,11 @@ struct TestCommmandHelperTests {
                 func encodeAsJSONEmpty() throws {
                     let output = CoverageFormatOutput()
 
-                    let jsonString = try output.encodeAsJSON()
-                    let jsonData = jsonString.data(using: .utf8)!
+                    let encoder = JSONEncoder()
+                    encoder.keyEncodingStrategy = .convertToSnakeCase
+                    encoder.outputFormatting = [.prettyPrinted]
+                    let jsonData = try encoder.encode(output)
+                    let jsonString = String(decoding: jsonData, as: UTF8.self)
                     let decoded = try JSONSerialization.jsonObject(with: jsonData) as! [String: String]
 
                     #expect(decoded.isEmpty)
@@ -469,9 +478,14 @@ struct TestCommmandHelperTests {
                     var output = CoverageFormatOutput()
                     try output.addFormat(format, path: path)
 
-                    let textString = output.encodeAsText()
+                    var encoder = PlainTextEncoder()
+                    encoder.formattingOptions = [.prettyPrinted]
+                    let textData = try encoder.encode(output)
+                    let textString = String(decoding: textData, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines)
 
-                    #expect(textString == "/path/to/coverage.json")
+                    // PlainTextEncoder capitalizes first letter of keys
+                    let expectedFormat = format.rawValue.prefix(1).uppercased() + format.rawValue.dropFirst()
+                    #expect(textString == "\(expectedFormat): /path/to/coverage.json")
                 }
 
                 @Test("Encode as text with multiple formats")
@@ -483,17 +497,24 @@ struct TestCommmandHelperTests {
                     try output.addFormat(.json, path: jsonPath)
                     try output.addFormat(.html, path: htmlPath)
 
-                    let textString = output.encodeAsText()
+                    var encoder = PlainTextEncoder()
+                    encoder.formattingOptions = [.prettyPrinted]
+                    let textData = try encoder.encode(output)
+                    let textString = String(decoding: textData, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines)
 
                     // Should be sorted by format name (html comes before json alphabetically)
-                    #expect(textString == "HTML: /path/to/coverage-html\nJSON: /path/to/coverage.json")
+                    // PlainTextEncoder capitalizes first letter of keys
+                    #expect(textString == "Html: /path/to/coverage-html\nJson: /path/to/coverage.json")
                 }
 
                 @Test("Encode as text with empty data")
                 func encodeAsTextEmpty() throws {
                     let output = CoverageFormatOutput()
 
-                    let textString = output.encodeAsText()
+                    var encoder = PlainTextEncoder()
+                    encoder.formattingOptions = [.prettyPrinted]
+                    let textData = try encoder.encode(output)
+                    let textString = String(decoding: textData, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines)
 
                     #expect(textString.isEmpty)
                 }
@@ -510,13 +531,17 @@ struct TestCommmandHelperTests {
                 try output.addFormat(.html, path: htmlPath)  // Add html second
 
                 // Text encoding should show html first (alphabetically)
-                let textString = output.encodeAsText()
-                #expect(textString.hasPrefix("HTML:"))
-                #expect(textString.hasSuffix("JSON: /json/path"))
+                var textEncoder = PlainTextEncoder()
+                textEncoder.formattingOptions = [.prettyPrinted]
+                let textData = try textEncoder.encode(output)
+                let textString = String(decoding: textData, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines)
+                #expect(textString.hasPrefix("Html:"))
+                #expect(textString.hasSuffix("Json: /json/path"))
 
                 // JSON encoding should also maintain consistent ordering
-                let jsonString = try output.encodeAsJSON()
-                let jsonData = jsonString.data(using: .utf8)!
+                let jsonEncoder = JSONEncoder()
+                jsonEncoder.keyEncodingStrategy = .convertToSnakeCase
+                let jsonData = try jsonEncoder.encode(output)
                 let decoded = try JSONSerialization.jsonObject(with: jsonData) as! [String: String]
 
                 #expect(decoded["html"] == "/html/path")
@@ -529,9 +554,12 @@ struct TestCommmandHelperTests {
                 var output = CoverageFormatOutput()
                 try output.addFormat(.json, path: specialPath)
 
-                let textString = output.encodeAsText()
+                var encoder = PlainTextEncoder()
+                encoder.formattingOptions = [.prettyPrinted]
+                let textData = try encoder.encode(output)
+                let textString = String(decoding: textData, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines)
 
-                #expect(textString == "/path with/spaces & symbols/coverage.json")
+                #expect(textString == "Json: /path with/spaces & symbols/coverage.json")
             }
 
             @Test("JSON encoding handles special characters in paths")
@@ -540,8 +568,9 @@ struct TestCommmandHelperTests {
                 var output = CoverageFormatOutput()
                 try output.addFormat(.json, path: specialPath)
 
-                let jsonString = try output.encodeAsJSON()
-                let jsonData = jsonString.data(using: .utf8)!
+                let encoder = JSONEncoder()
+                encoder.keyEncodingStrategy = .convertToSnakeCase
+                let jsonData = try encoder.encode(output)
                 let decoded = try JSONSerialization.jsonObject(with: jsonData) as! [String: String]
 
                 #expect(decoded["json"] == "/path with/spaces & symbols/coverage.json")