update encoding

Author: bkhouri

Sources/Commands/SwiftTestCommand.swift

@@ -265,7 +265,7 @@ public struct CoverageOptions: ParsableArguments {
             .customLong("show-code-coverage-path"),
             .customLong("show-coverage-path"),
         ],
-        help: "Print the path of the exported code coverage JSON file.",
+        help: "Print the path of the exported code coverage files.",
     )
     var shouldPrintPath: Bool = false
 
@@ -399,11 +399,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
@@ -420,7 +449,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
@@ -431,48 +460,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 {
@@ -1122,29 +1120,29 @@ 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:
+                let coverageOutput = CoverageFormatOutput(data: coverageData)
                 let encoder = JSONEncoder.makeWithDefaults()
                 encoder.keyEncodingStrategy = .convertToSnakeCase
                 data = try encoder.encode(coverageOutput)
             case .text:
-                var encoder = PlainTextEncoder()
-                encoder.formattingOptions = [.prettyPrinted]
-                data = try encoder.encode(coverageOutput)
+                // When there's only one format, don't show the key prefix
+                if formats.count == 1, let singlePath = coverageData.values.first {
+                    swiftCommandState.observabilityScope.emit(
+                        warning: """
+                        The contents of this output are subject to change in the future. Use `--print-coverage-path-mode json` if the output is required in a script.
+                        """,
+                    )
+                    data = Data("\(singlePath.pathString)".utf8)
+                } else {
+                    let coverageOutput = CoverageFormatOutput(data: coverageData)
+                    var encoder = PlainTextEncoder()
+                    encoder.formattingOptions = [.prettyPrinted]
+                    data = try encoder.encode(coverageOutput)
+                }
         }
         print(String(decoding: data, as: UTF8.self))
     }

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/CoverageTests.swift

@@ -128,7 +128,7 @@ struct CoverageTests {
     }
 
     struct GenerateCoverageReportTestData {
-        let buildData: BuildData
+        // let buildData: BuildData
         let fixtureName: String
         let coverageFormat: CoverageFormat
     }
@@ -138,23 +138,24 @@ struct CoverageTests {
             "Coverage/Simple",
             "Miscellaneous/TestDiscovery/Simple",
         ].flatMap { fixturePath in
-            getBuildData(for: SupportedBuildSystemOnAllPlatforms).flatMap { buildData in
+            // getBuildData(for: SupportedBuildSystemOnAllPlatforms).flatMap { buildData in
                 CoverageFormat.allCases.map { format in
                     GenerateCoverageReportTestData(
-                        buildData: buildData,
+                        // buildData: buildData,
                         fixtureName: fixturePath,
                         coverageFormat: format,
                     )
                 }
-            }
+            // }
         },
     )
     func generateSingleCoverageReport(
+        buildData: BuildData,
         testData: GenerateCoverageReportTestData,
     ) async throws {
         let fixtureName = testData.fixtureName
         let coverageFormat = testData.coverageFormat
-        let buildData = testData.buildData
+        // let buildData = testData.buildData
         try await fixture(name: fixtureName) { path in
             let commonCoverageArgs = [
                 "--coverage-format",
@@ -199,13 +200,20 @@ struct CoverageTests {
     @Test
     func htmlReportOutputDirectory() async throws {
         // Verify the output directory argument specified in the response file override the default location.
-        Issue.record("Test needs to be implemented.")
+        Issue.record("""
+        Test needs to be implemented.
+          - Provide output directory that is a relative path
+          - provide output directory that is an absolute path
+        """)
     }
 
     @Test
     func htmlReportResponseFile() async throws {
         // Verify the arguments specified in the response file are used.
-        Issue.record("Test needs to be implemented.")
+        Issue.record("""
+        Test needs to be implemented.
+          - verify command line argument
+        """)
     }
 
     @Suite