WIP: changes

Author: TamarMilchtaich

Sources/XcodeGraph/DependenciesGraph/DependenciesGraph.swift

@@ -33,12 +33,12 @@ public struct DependenciesGraph: Equatable, Codable, Sendable {
             name: String = "Test",
             // swiftlint:disable:next force_try
             path: AbsolutePath = AbsolutePath.root.appending(try! RelativePath(validating: "Test.xcframework")),
-            originalSignature: XCFrameworkOriginalSignatureType = .notSigned,
+            expectedSignature: XCFrameworkSignature = .notSigned,
             status: LinkingStatus = .required
         ) -> DependenciesGraph {
           let externalDependencies = [name: [TargetDependency.xcframework(
             path: path,
-            originalSignature: originalSignature,
+            expectedSignature: expectedSignature,
             status: status
           )]]
 

Sources/XcodeGraph/Models/TargetDependency.swift

@@ -7,7 +7,7 @@ public enum LinkingStatus: String, Hashable, Codable, Sendable {
     case none
 }
 
-public enum XCFrameworkOriginalSignatureType: Equatable, Hashable, Codable, Sendable {
+public enum XCFrameworkSignature: Equatable, Hashable, Codable, Sendable {
     case notSigned
     case signedByApple(teamIdentifier: String, teamName: String)
     case selfSigned(fingerprint: String)
@@ -24,6 +24,7 @@ public enum XCFrameworkOriginalSignatureType: Equatable, Hashable, Codable, Send
     }
 }
 
+
 public enum TargetDependency: Equatable, Hashable, Codable, Sendable {
     public enum PackageType: String, Equatable, Hashable, Codable, Sendable {
         case runtime
@@ -35,7 +36,7 @@ public enum TargetDependency: Equatable, Hashable, Codable, Sendable {
     case target(name: String, status: LinkingStatus = .required, condition: PlatformCondition? = nil)
     case project(target: String, path: AbsolutePath, status: LinkingStatus = .required, condition: PlatformCondition? = nil)
     case framework(path: AbsolutePath, status: LinkingStatus, condition: PlatformCondition? = nil)
-    case xcframework(path: AbsolutePath, originalSignature: XCFrameworkOriginalSignatureType, status: LinkingStatus, condition: PlatformCondition? = nil)
+    case xcframework(path: AbsolutePath, expectedSignature: XCFrameworkSignature?, status: LinkingStatus, condition: PlatformCondition? = nil)
     case library(
         path: AbsolutePath,
         publicHeaders: AbsolutePath,
@@ -54,7 +55,7 @@ public enum TargetDependency: Equatable, Hashable, Codable, Sendable {
             condition
         case .framework(path: _, status: _, condition: let condition):
             condition
-        case .xcframework(path: _, originalSignature: _, status: _, condition: let condition):
+        case .xcframework(path: _, expectedSignature: _, status: _, condition: let condition):
             condition
         case .library(path: _, publicHeaders: _, swiftModuleMap: _, condition: let condition):
             condition
@@ -74,8 +75,8 @@ public enum TargetDependency: Equatable, Hashable, Codable, Sendable {
             return .project(target: target, path: path, status: status, condition: condition)
         case .framework(path: let path, status: let status, condition: _):
             return .framework(path: path, status: status, condition: condition)
-        case .xcframework(path: let path, originalSignature: let originalSignature, status: let status, condition: _):
-          return .xcframework(path: path, originalSignature:originalSignature, status: status, condition: condition)
+        case .xcframework(path: let path, expectedSignature: let expectedSignature, status: let status, condition: _):
+          return .xcframework(path: path, expectedSignature:expectedSignature, status: status, condition: condition)
         case .library(path: let path, publicHeaders: let headers, swiftModuleMap: let moduleMap, condition: _):
             return .library(path: path, publicHeaders: headers, swiftModuleMap: moduleMap, condition: condition)
         case .package(product: let product, type: let type, condition: _):

Sources/XcodeGraphMapper/Mappers/Phases/PBXFrameworksBuildPhaseMapper.swift

@@ -97,7 +97,7 @@ struct PBXFrameworksBuildPhaseMapper: PBXFrameworksBuildPhaseMapping {
             .throwing(PBXFrameworksBuildPhaseMappingError.missingFilePath(name: fileRef.name))
 
         let absolutePath = try AbsolutePath(validating: filePathString)
-      return try pathMapper.map(path: absolutePath, originalSignature: nil, condition: nil)
+      return try pathMapper.map(path: absolutePath, expectedSignature: nil, condition: nil)
     }
 }
 

Sources/XcodeGraphMapper/Mappers/Targets/PBXTargetDependencyMapper.swift

@@ -108,14 +108,14 @@ struct PBXTargetDependencyMapper: PBXTargetDependencyMapping {
             if let fileRef = object as? PBXFileReference {
                 return try mapFileDependency(
                   pathString: fileRef.path,
-                  originalSignature: nil,
+                  expectedSignature: nil,
                   condition: condition,
                   xcodeProj: xcodeProj
                 )
             } else if let refProxy = object as? PBXReferenceProxy {
                 return try mapFileDependency(
                     pathString: refProxy.path,
-                    originalSignature: nil,
+                    expectedSignature: nil,
                     condition: condition,
                     xcodeProj: xcodeProj
                 )
@@ -132,22 +132,22 @@ struct PBXTargetDependencyMapper: PBXTargetDependencyMapping {
     /// Maps file-based dependencies (e.g., frameworks, libraries) into `TargetDependency` models.
     /// - Parameters:
     ///   - pathString: The path string for the file-based dependency (relative or absolute).
-    ///   - originalSignature: The expected signature if `path` is of a signed XCFramework, `nil` otherwise.
+    ///   - expectedSignature: The expected signature if `path` is of a signed XCFramework, `nil` otherwise.
     ///   - condition: An optional platform condition.
     ///   - xcodeProj: The Xcode project reference for resolving the directory structure.
     /// - Returns: A `TargetDependency` reflecting the file’s extension (framework, library, etc.).
     /// - Throws: If the path is missing or invalid.
     private func mapFileDependency(
         pathString: String?,
-        originalSignature:XCFrameworkOriginalSignatureType?,
+        expectedSignature:XCFrameworkSignature?,
         condition: PlatformCondition?,
         xcodeProj: XcodeProj
     ) throws -> TargetDependency {
         let pathString = try pathString.throwing(
             TargetDependencyMappingError.missingFileReference("Path string is nil in file dependency.")
         )
         let path = xcodeProj.srcPath.appending(try RelativePath(validating: pathString))
-      return try pathMapper.map(path: path, originalSignature:originalSignature, condition: condition)
+      return try pathMapper.map(path: path, expectedSignature:expectedSignature, condition: condition)
     }
 }
 

Sources/XcodeGraphMapper/Mappers/Targets/TargetDependency+GraphMapping.swift

@@ -51,8 +51,12 @@ extension TargetDependency {
                 status: status
             )
 
-        case let .xcframework(path, originalSignature, status, _):
-          let metadata = try await xcframeworkMetadataProvider.loadMetadata(at: path, expectedSignature: originalSignature.expectedSignature(), status: status)
+        case let .xcframework(path, expectedSignature, status, _):
+          let metadata = try await xcframeworkMetadataProvider.loadMetadata(
+            at: path,
+            expectedSignature: expectedSignature?.expectedSignature(),
+            status: status
+          )
             return .xcframework(
                 .init(
                     path: path,

Sources/XcodeGraphMapper/Utilities/PathDependencyMapper.swift

@@ -8,24 +8,24 @@ protocol PathDependencyMapping {
     ///
     /// - Parameters:
     ///   - path: The file path to map.
-    ///   - originalSignature: The expected signature if `path` is of a signed XCFramework, `nil` otherwise.
+    ///   - expectedSignature: The expected signature if `path` is of a signed XCFramework, `nil` otherwise.
     ///   - condition: An optional platform condition (e.g., iOS only).
     /// - Returns: The corresponding `TargetDependency`, if the path extension is recognized.
     /// - Throws: `PathDependencyError.invalidExtension` if the file extension is not supported.
-  func map(path: AbsolutePath, originalSignature:XCFrameworkOriginalSignatureType?, condition: PlatformCondition?) throws -> TargetDependency
+  func map(path: AbsolutePath, expectedSignature:XCFrameworkSignature?, condition: PlatformCondition?) throws -> TargetDependency
 }
 
 /// A mapper that converts file paths (like `.framework`, `.xcframework`, or libraries) to `TargetDependency` models.
 struct PathDependencyMapper: PathDependencyMapping {
-  func map(path: AbsolutePath, originalSignature: XCFrameworkOriginalSignatureType? = nil, condition: PlatformCondition?) throws -> TargetDependency {
+  func map(path: AbsolutePath, expectedSignature: XCFrameworkSignature? = nil, condition: PlatformCondition?) throws -> TargetDependency {
         let status: LinkingStatus = .required
 
         switch path.fileExtension {
         case .framework:
             return .framework(path: path, status: status, condition: condition)
         case .xcframework:
           // TODO: throw some error? log warning? this is very general, but from what I can tell it's only called from a non-xcframework contexts
-          return .xcframework(path: path, originalSignature: originalSignature ?? .notSigned, status: status, condition: condition)
+          return .xcframework(path: path, expectedSignature: expectedSignature ?? .notSigned, status: status, condition: condition)
         case .dynamicLibrary, .textBasedDynamicLibrary, .staticLibrary:
             return .library(
                 path: path,