Add map APIs to variant collection types

Adds map APIs to variant collection types to facilitate transforming the
value contained in variant collections.

Author: franklinsch

Sources/SwiftDocC/Model/Rendering/Variants/VariantCollection+Variant.swift

@@ -0,0 +1,42 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2022 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See https://swift.org/LICENSE.txt for license information
+ See https://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import Foundation
+
+public extension VariantCollection {
+    /// A variant for a render node value.
+    struct Variant<Value: Codable> {
+        /// The traits associated with the override.
+        public var traits: [RenderNode.Variant.Trait]
+        
+        /// The patch to apply as part of the override.
+        public var patch: [VariantPatchOperation<Value>]
+        
+        /// Creates an override value for the given traits.
+        ///
+        /// - Parameters:
+        ///   - traits: The traits associated with this override value.
+        ///   - patch: The patch to apply as part of the override.
+        public init(traits: [RenderNode.Variant.Trait], patch: [VariantPatchOperation<Value>]) {
+            self.traits = traits
+            self.patch = patch
+        }
+        
+        /// Returns a new variant collection containing the traits of this variant collection with the values transformed by the given closure.
+        public func mapPatch<TransformedValue>(
+            _ transform: (Value) -> TransformedValue
+        ) -> VariantCollection<TransformedValue>.Variant<TransformedValue> {
+            VariantCollection<TransformedValue>.Variant<TransformedValue>(
+                traits: traits,
+                patch: patch.map { patchOperation in patchOperation.map(transform) }
+            )
+        }
+    }
+}

Sources/SwiftDocC/Model/Rendering/Variants/VariantCollection.swift

@@ -91,25 +91,16 @@ public struct VariantCollection<Value: Codable>: Codable {
 
         encoder.userInfoVariantOverrides?.add(contentsOf: overrides)
     }
-}
-
-public extension VariantCollection {
-    /// A variant for a render node value.
-    struct Variant<Value: Codable> {
-        /// The traits associated with the override.
-        public var traits: [RenderNode.Variant.Trait]
-        
-        /// The patch to apply as part of the override.
-        public var patch: [VariantPatchOperation<Value>]
-        
-        /// Creates an override value for the given traits.
-        ///
-        /// - Parameters:
-        ///   - traits: The traits associated with this override value.
-        ///   - patch: The patch to apply as part of the override.
-        public init(traits: [RenderNode.Variant.Trait], patch: [VariantPatchOperation<Value>]) {
-            self.traits = traits
-            self.patch = patch
-        }
+    
+    /// Returns a variant collection containing the results of calling the given transformation with each value of this variant collection.
+    public func mapValues<TransformedValue>(
+        _ transform: (Value) -> TransformedValue
+    ) -> VariantCollection<TransformedValue> {
+        VariantCollection<TransformedValue>(
+            defaultValue: transform(defaultValue),
+            variants: variants.map { variant in
+                variant.mapPatch(transform)
+            }
+        )
     }
 }

Sources/SwiftDocC/Model/Rendering/Variants/VariantPatchOperation.swift

@@ -17,6 +17,9 @@ public enum VariantPatchOperation<Value: Codable> {
     /// - Parameter value: The value to use in the replacement.
     case replace(value: Value)
 
+    /// An addition operation.
+    ///
+    /// - Parameter value: The value to use in the addition.
     case add(value: Value)
 
     /// A removal operation.
@@ -33,6 +36,24 @@ public enum VariantPatchOperation<Value: Codable> {
             return .remove
         }
     }
+    
+    /// Returns a new patch operation with its value transformed using the given closure.
+    ///
+    /// If the patch operation doesn't have a value—for example, if it's a removal operation—the operation is returned unmodified.
+    func map<TransformedValue>(
+        _ transform: (Value) -> TransformedValue
+    ) -> VariantPatchOperation<TransformedValue> {
+        switch self {
+        case .replace(let value):
+            return VariantPatchOperation<TransformedValue>.replace(value: transform(value))
+            
+        case .add(let value):
+            return VariantPatchOperation<TransformedValue>.add(value: transform(value))
+            
+        case .remove:
+            return .remove
+        }
+    }
 }
 
 extension VariantCollection.Variant where Value: RangeReplaceableCollection {

Tests/SwiftDocCTests/Rendering/Variants/VariantCollection+VariantTests.swift

@@ -0,0 +1,44 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2022 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See https://swift.org/LICENSE.txt for license information
+ See https://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import Foundation
+import XCTest
+@testable import SwiftDocC
+
+class VariantCollection_VariantTests: XCTestCase {
+    let testVariant = VariantCollection<String>.Variant<String>(
+        traits: [.interfaceLanguage("a")],
+        patch: [
+            .replace(value: "replace"),
+            .add(value: "add"),
+            .remove,
+        ]
+    )
+    
+    func testMapPatch() throws {
+        XCTAssertEqual(
+            testVariant.mapPatch { "\($0) transformed" }.patch.map(\.value),
+            ["replace transformed", "add transformed", nil]
+        )
+    }
+}
+
+private extension VariantPatchOperation {
+    var value: Value? {
+        switch self {
+        case let .replace(value):
+            return value
+        case let .add(value):
+            return value
+        case .remove:
+            return nil
+        }
+    }
+}

Tests/SwiftDocCTests/Rendering/Variants/VariantCollectionTests.swift

@@ -74,4 +74,23 @@ class VariantCollectionTests: XCTestCase {
             XCTAssertEqual(value.value as! String, expectedValue)
         }
     }
+    
+    func testMapValues() {
+        let testCollection = testCollection.mapValues { value -> String? in
+            if value == "default value" {
+               return "default value transformed"
+            }
+            
+            return nil
+        }
+        
+        XCTAssertEqual(testCollection.defaultValue, "default value transformed")
+        
+        guard case .replace(let value)? = testCollection.variants.first?.patch.first else {
+            XCTFail()
+            return
+        }
+        
+        XCTAssertNil(value)
+    }
 }

Tests/SwiftDocCTests/Rendering/Variants/VariantPatchOperationTests.swift

@@ -66,4 +66,29 @@ class VariantPatchOperationTests: XCTestCase {
             XCTAssertEqual(stringVariant.applyingPatchTo("A"), expectedValue)
         }
     }
+    
+    func testMap() throws {
+        let transform: (String) -> String = { "\($0) transformed" }
+        let replace = VariantPatchOperation<String>.replace(value: "replace")
+        guard case .replace(let value) = replace.map(transform) else {
+            XCTFail("Expected replace operation")
+            return
+        }
+        
+        XCTAssertEqual(value, "replace transformed")
+        
+        let add = VariantPatchOperation<String>.add(value: "add")
+        guard case .add(let value) = add.map(transform) else {
+            XCTFail("Expected add operation")
+            return
+        }
+        
+        XCTAssertEqual(value, "add transformed")
+        
+        let remove = VariantPatchOperation<String>.remove.map(transform)
+        guard case .remove = remove else {
+            XCTFail("Expected remove operation")
+            return
+        }
+    }
 }