Implementing Target.Resource.Rule

Author: goergisn

Sources/PublicModules/PADPackageFileAnalyzer/SwiftPackageFileAnalyzer.swift

@@ -336,6 +336,8 @@ private extension SwiftPackageFileAnalyzer {
         let addedTargetDependencies = newTargetDependencies.subtracting(oldTargetDependencies)
         let removedTargetDependencies = oldTargetDependencies.subtracting(newTargetDependencies)
 
+        // TODO: Add analyzing of SwiftPackageDescription.Target.Resource
+        
         // MARK: Product Dependencies
 
         let oldProductDependencies = Set(oldTarget.productDependencies ?? [])

Sources/Shared/Package/SwiftPackageFileHelperModule/SwiftPackageDescription.swift

@@ -74,7 +74,7 @@ package extension SwiftPackageDescription {
 
     struct Product: Codable, Equatable, Hashable {
 
-        // TODO: Add `rule` property
+        // TODO: Add `type` property
 
         package let name: String
         package let targets: [String]
@@ -179,28 +179,31 @@ package extension SwiftPackageDescription {
         package let productDependencies: [String]?
         /// `.target(name: ...) dependency
         package let targetDependencies: [String]?
-
+        // TODO: check this in the SwiftPackageFileAnalyzer
+        package let resources: [Resource]?
+        
         // Ignoring following properties for now as they are not handled in the `PackageAnalyzer`
         // and thus would produce changes that are not visible
         //
         // let productMemberships: [String]?
         // let sources: [String]
-        // let resources: [Resource]?
 
         init(
             name: String,
             type: TargetType,
             path: String,
             moduleType: ModuleType,
             productDependencies: [String]? = nil,
-            targetDependencies: [String]? = nil
+            targetDependencies: [String]? = nil,
+            resources: [Resource]? = nil
         ) {
             self.name = name
             self.type = type
             self.path = path
             self.moduleType = moduleType
             self.productDependencies = productDependencies
             self.targetDependencies = targetDependencies
+            self.resources = resources
         }
 
         enum CodingKeys: String, CodingKey {
@@ -210,6 +213,7 @@ package extension SwiftPackageDescription {
             case targetDependencies = "target_dependencies"
             case type
             case path
+            case resources
         }
     }
 }
@@ -257,9 +261,77 @@ extension SwiftPackageDescription.Target: CustomStringConvertible {
 package extension SwiftPackageDescription.Target {
 
     struct Resource: Codable, Equatable {
+        package let path: String
+        package let rule: Rule
+    }
+}
+
+package extension SwiftPackageDescription.Target.Resource {
+    
+    enum Rule: Codable, Equatable {
+        case copy
+        case embeddInCode
+        case process([String: String])
+        
+        package init(from decoder: any Decoder) throws {
+   
+            enum RuleError: Error {
+                case unsupportedRule
+            }
+            
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            
+            if (try? container.decode([String: String].self, forKey: .copy)) != nil {
+                self = .copy
+                return
+            }
+            
+            if (try? container.decode([String: String].self, forKey: .embeddInCode)) != nil {
+                self = .embeddInCode
+                return
+            }
+            
+            if let metadata = try? container.decode([String: String].self, forKey: .process) {
+                self = .process(metadata)
+                return
+            }
+            
+            throw RuleError.unsupportedRule
+        }
+        
+        package func encode(to encoder: any Encoder) throws {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            
+            switch self {
+            case .copy:
+                try container.encode([:] as [String: String], forKey: .copy)
+            case .embeddInCode:
+                try container.encode([:] as [String: String], forKey: .embeddInCode)
+            case let .process(metadata):
+                try container.encode(metadata, forKey: .process)
+            }
+        }
+        
+        enum CodingKeys: String, CodingKey {
+            case copy
+            case embeddInCode = "embed_in_code"
+            case process
+        }
+    }
+}
 
-        // TODO: Add `rule` property
+extension SwiftPackageDescription.Target.Resource.Rule: CustomStringConvertible {
 
-        package let path: String
+    package var description: String {
+        return switch self {
+        case .copy: "copy"
+        case .embeddInCode: "embeddInCode"
+        case let .process(metadata):
+            if let localization = metadata["localization"] {
+                "process (localization: \(localization))"
+            } else {
+                "process"
+            }
+        }
     }
 }