Merge branch 'main' of github.com:jpsim/Yams

Author: Adora Lynch

.github/workflows/swiftpm.yml

@@ -69,7 +69,7 @@ jobs:
     name: macOS 15 with Xcode ${{ matrix.xcode_version }}
     strategy:
       matrix:
-        xcode_version: ['15.4', '16.0', '16.2', '16.3']
+        xcode_version: ['16.0', '16.2', '16.3']
     runs-on: macos-15
     env:
       DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode_version }}.app
@@ -79,7 +79,7 @@ jobs:
       - run: YAMS_DEFAULT_ENCODING=UTF16 swift test --parallel
       - run: YAMS_DEFAULT_ENCODING=UTF8 swift test --parallel
       - name: Code Coverage
-        if: matrix.xcode_version == '15.4'
+        if: matrix.xcode_version == '16.0'
         run: |
           swift test --enable-code-coverage
           xcrun llvm-cov export -format="lcov" .build/debug/YamsPackageTests.xctest/Contents/MacOS/YamsPackageTests -instr-profile .build/debug/codecov/default.profdata > coverage.lcov

.github/workflows/xcodebuild.yml

@@ -99,7 +99,7 @@ jobs:
     name: macOS 15 with Xcode ${{ matrix.xcode_version }}
     strategy:
       matrix:
-        xcode_version: ['15.4', '16.0', '16.2', '16.3']
+        xcode_version: ['16.0', '16.2', '16.3']
         xcode_flags: ['-scheme Yams -project Yams.xcodeproj']
     runs-on: macos-15
     env:

Sources/Yams/Decoder.swift

@@ -340,7 +340,14 @@ extension _Decoder: SingleValueDecodingContainer {
             return dereferenced
         }
 
-        let constructed = try _construct(type)
+        var constructed = try _construct(type)
+
+        if var anchorCoding = constructed as? YamlAnchorCoding,
+           anchorCoding.yamlAnchor == nil,
+           let anchor = self.node.anchor {
+            anchorCoding.yamlAnchor = anchor
+            constructed = anchorCoding as! T // swiftlint:disable:this force_cast
+        }
 
         recordAnchor(constructed)
 

Sources/Yams/Encoder.swift

@@ -243,6 +243,17 @@ extension _Encoder: SingleValueEncodingContainer {
         try encode(yamlEncodable: value)
     }
 
+    func encode<T>(_ value: T) throws where T: Encodable {
+        assertCanEncodeNewValue()
+        if let encodable = value as? YAMLEncodable {
+            try encode(yamlEncodable: encodable)
+        } else {
+            try resolveAlias(for: value) {
+                try value.encode(to: self)
+            }
+        }
+    }
+
     private func encode(yamlEncodable encodable: YAMLEncodable) throws {
         func encodeNode() {
             node = encodable.box()
@@ -264,7 +275,7 @@ extension _Encoder: SingleValueEncodingContainer {
                     return // nothing left to do
                 }
 
-                if let orphanedAnchor = self.node.anchor {
+                if let orphanedAnchor = self.node.anchor, self.node.isScalar {
                     // our sub-tree was a single value container which declared an anchor
                     // that anchor will not be represented in the final tree
                     // because `anchor` is the prevailing value in this context
@@ -293,17 +304,6 @@ extension _Encoder: SingleValueEncodingContainer {
         }
     }
 
-    func encode<T>(_ value: T) throws where T: Encodable {
-        assertCanEncodeNewValue()
-        if let encodable = value as? YAMLEncodable {
-            try encode(yamlEncodable: encodable)
-        } else {
-            try resolveAlias(for: value) {
-                try value.encode(to: self)
-            }
-        }
-    }
-
     // MARK: -
 
     /// Asserts that a single value can be encoded at the current coding path

Sources/Yams/Node.swift

@@ -300,6 +300,13 @@ extension Node: ExpressibleByStringLiteral {
 extension Node {
     // MARK: Internal convenience accessors
 
+    var isScalar: Bool {
+        if case .scalar = self {
+            return true
+        }
+        return false
+    }
+
     var isMapping: Bool {
         if case .mapping = self {
             return true

Tests/LinuxMain.swift

@@ -7,6 +7,7 @@ XCTMain([
     testCase(EmitterTests.allTests),
     testCase(EncoderTests.allTests),
     testCase(MarkTests.allTests),
+    testCase(NodeInternalHelpersTests.allTests),
     testCase(NodeTests.allTests),
     testCase(PerformanceTests.allTests),
     testCase(RepresenterTests.allTests),

Tests/YamsTests/AnchorCodingTests.swift

@@ -96,6 +96,7 @@ class AnchorCodingTests: XCTestCase {
     }
 }
 
+// swiftlint:disable:next type_body_length
 class AnchorAliasingTests: XCTestCase {
 
     /// CYaml library does not detect identical values and automatically alias them.
@@ -225,7 +226,8 @@ class AnchorAliasingTests: XCTestCase {
     /// If types conform to YamlAnchorProviding and are NOT Hashable-Equal then
     /// HashableAliasingStrategy does not alias them even though their members may still be
     /// Hashable-Equal and therefor maybe aliased.
-    /// Note particularly that the to Simple* values here have exactly the same encoded representation,
+    /// Note particularly that the to SimpleSimpleWithoutAnchor* and the int-valued types here
+    /// have exactly the same encoded representation,
     /// they're just different types and thus not Hashable-Equal
     func testEncoderAutoAlias_Hashable_NoAnchor() throws {
         let differentTypesNoAnchors = SimplePair(first:
@@ -359,6 +361,53 @@ class AnchorAliasingTests: XCTestCase {
         try _testMetaPropertyKeyExposure(source: string)
     }
 
+    /// Test that RawRepresentable types which conform toYamlAnchorCoding preserve their Anchors round-trip
+    func testDecoder_anchorPreserving_RawRepresentable_mapping() throws {
+        var intWithAnchor: SimpleIntRepresesnting = 52
+        intWithAnchor.yamlAnchor = "fifty_two"
+        let subject = ["key": intWithAnchor]
+
+        var options = YAMLEncoder.Options()
+        options.redundancyAliasingStrategy = StrictEncodableAliasingStrategy()
+        _testRoundTrip(of: subject,
+                       with: options,
+                       expectedYAML: """
+                                     key: &fifty_two 52
+
+                                     """ )
+    }
+
+    /// Test that RawRepresentable types which conform toYamlAnchorCoding preserve their Anchors round-trip
+    func testDecoder_anchorPreserving_RawRepresentable_sequence() throws {
+        var intWithAnchor: SimpleIntRepresesnting = 52
+        intWithAnchor.yamlAnchor = "fifty_two"
+        let subject = [intWithAnchor]
+
+        var options = YAMLEncoder.Options()
+        options.redundancyAliasingStrategy = StrictEncodableAliasingStrategy()
+        _testRoundTrip(of: subject,
+                       with: options,
+                       expectedYAML: """
+                                     - &fifty_two 52
+
+                                     """ )
+    }
+
+    /// Test that RawRepresentable types which conform toYamlAnchorCoding preserve their Anchors round-trip
+    func testDecoder_anchorPreserving_RawRepresentable_scalar() throws {
+        var intWithAnchor: SimpleIntRepresesnting = 52
+        intWithAnchor.yamlAnchor = "fifty_two"
+
+        var options = YAMLEncoder.Options()
+        options.redundancyAliasingStrategy = StrictEncodableAliasingStrategy()
+        _testRoundTrip(of: intWithAnchor,
+                       with: options,
+                       expectedYAML: """
+                                     &fifty_two 52
+
+                                     """ )
+    }
+
     private func _testMetaPropertyKeyExposure(source: String) throws {
         struct KeyCountAssertingStruct: Codable {
             var someInt: Int
@@ -445,7 +494,11 @@ extension Int {
     }
 }
 
-private struct SimpleIntRepresesnting: RawRepresentable, Codable, Hashable, ExpressibleByIntegerLiteral {
+private struct SimpleIntRepresesnting: RawRepresentable,
+                                        Codable,
+                                        Hashable,
+                                        ExpressibleByIntegerLiteral,
+                                        YamlAnchorCoding {
     init(integerLiteral value: Int) {
         self.rawValue = value
     }
@@ -455,6 +508,11 @@ private struct SimpleIntRepresesnting: RawRepresentable, Codable, Hashable, Expr
     }
 
     let rawValue: Int
+    var yamlAnchor: Anchor?
+
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        lhs.rawValue == rhs.rawValue && lhs.yamlAnchor == rhs.yamlAnchor
+    }
 }
 
 // swiftlint:disable:this file_length

Tests/YamsTests/CMakeLists.txt

@@ -7,6 +7,7 @@ add_library(YamsTests
   EmitterTests.swift
   EncoderTests.swift
   MarkTests.swift
+  NodeInternalHelpersTests.swift
   NodeTests.swift
   PerformanceTests.swift
   RepresenterTests.swift

Tests/YamsTests/EncoderTests.swift

@@ -454,7 +454,7 @@ where T: Codable, T: Equatable {
         let producedYAML = try encoder.encode(value)
 
         if let expectedYAML = yamlString {
-            XCTAssertEqual(producedYAML, expectedYAML, "Produced YAML not identical to expected YAML.",
+            XCTAssertEqual("\n"+producedYAML, "\n"+expectedYAML, "Produced YAML not identical to expected YAML.",
                            file: (file), line: line)
         }
 

Tests/YamsTests/NodeInternalHelpersTests.swift

@@ -0,0 +1,32 @@
+//
+//  NodeTests.swift
+//  Yams
+//
+//  Created by Adora Lynch on 6/23/25.
+//  Copyright (c) 2024 Yams. All rights reserved.
+//
+
+import Foundation
+import XCTest
+@testable import Yams
+
+final class NodeInternalHelpersTests: XCTestCase, @unchecked Sendable {
+    // swiftlint:disable force_try
+    func testIsScalar() {
+        var node = Node("1") // a scalar
+        XCTAssertEqual(node.isScalar, true)
+        node = try! Node(["key": "1"]) // a mapping
+        XCTAssertEqual(node.isScalar, false)
+        node = try! Node(["one", "1"]) // a sequnce
+        XCTAssertEqual(node.isScalar, false)
+    }
+    // swiftlint:enable force_try
+}
+
+extension NodeInternalHelpersTests {
+    static var allTests: [(String, (NodeInternalHelpersTests) -> () throws -> Void)] {
+        return [
+            ("testIsScalar", testIsScalar)
+        ]
+    }
+}