Move Codable conformance out of PackageModel+Codable.swift

Author: mattt

Sources/PackageModel/CMakeLists.txt

@@ -10,7 +10,6 @@ add_library(PackageModel
   BuildSettings.swift
   Manifest.swift
   Package.swift
-  PackageModel+Codable.swift
   Platform.swift
   Product.swift
   ResolvedModels.swift

Sources/PackageModel/Manifest.swift

@@ -380,7 +380,7 @@ public struct TargetDescription: Equatable, Codable {
     }
 
     /// Represents a target's dependency on another entity.
-    public enum Dependency: Equatable, ExpressibleByStringLiteral {
+    public enum Dependency: Equatable, ExpressibleByStringLiteral, Codable {
         case target(name: String, condition: PackageConditionDescription?)
         case product(name: String, package: String?, condition: PackageConditionDescription?)
         case byName(name: String, condition: PackageConditionDescription?)
@@ -396,6 +396,54 @@ public struct TargetDescription: Equatable, Codable {
         public static func product(name: String, package: String? = nil) -> Dependency {
             return .product(name: name, package: package, condition: nil)
         }
+
+        private enum CodingKeys: String, CodingKey {
+            case target, product, byName
+        }
+
+        public func encode(to encoder: Encoder) throws {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            switch self {
+            case let .target(a1, a2):
+                var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .target)
+                try unkeyedContainer.encode(a1)
+                try unkeyedContainer.encode(a2)
+            case let .product(a1, a2, a3):
+                var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .product)
+                try unkeyedContainer.encode(a1)
+                try unkeyedContainer.encode(a2)
+                try unkeyedContainer.encode(a3)
+            case let .byName(a1, a2):
+                var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .byName)
+                try unkeyedContainer.encode(a1)
+                try unkeyedContainer.encode(a2)
+            }
+        }
+
+        public init(from decoder: Decoder) throws {
+            let values = try decoder.container(keyedBy: CodingKeys.self)
+            guard let key = values.allKeys.first(where: values.contains) else {
+                throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath, debugDescription: "Did not find a matching key"))
+            }
+            switch key {
+            case .target:
+                var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+                let a1 = try unkeyedValues.decode(String.self)
+                let a2 = try unkeyedValues.decodeIfPresent(PackageConditionDescription.self)
+                self = .target(name: a1, condition: a2)
+            case .product:
+                var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+                let a1 = try unkeyedValues.decode(String.self)
+                let a2 = try unkeyedValues.decodeIfPresent(String.self)
+                let a3 = try unkeyedValues.decodeIfPresent(PackageConditionDescription.self)
+                self = .product(name: a1, package: a2, condition: a3)
+            case .byName:
+                var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+                let a1 = try unkeyedValues.decode(String.self)
+                let a2 = try unkeyedValues.decodeIfPresent(PackageConditionDescription.self)
+                self = .byName(name: a1, condition: a2)
+            }
+        }
     }
 
     public struct Resource: Codable, Equatable {
@@ -560,17 +608,57 @@ public struct ProductDescription: Equatable, Codable {
 }
 
 /// Represents system package providers.
-public enum SystemPackageProviderDescription: Equatable {
+public enum SystemPackageProviderDescription: Equatable, Codable {
     case brew([String])
     case apt([String])
     case yum([String])
+
+    private enum CodingKeys: String, CodingKey {
+        case brew, apt, yum
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case let .brew(a1):
+            var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .brew)
+            try unkeyedContainer.encode(a1)
+        case let .apt(a1):
+            var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .apt)
+            try unkeyedContainer.encode(a1)
+        case let .yum(a1):
+            var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .yum)
+            try unkeyedContainer.encode(a1)
+        }
+    }
+
+    public init(from decoder: Decoder) throws {
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        guard let key = values.allKeys.first(where: values.contains) else {
+            throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath, debugDescription: "Did not find a matching key"))
+        }
+        switch key {
+        case .brew:
+            var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+            let a1 = try unkeyedValues.decode([String].self)
+            self = .brew(a1)
+        case .apt:
+            var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+            let a1 = try unkeyedValues.decode([String].self)
+            self = .apt(a1)
+        case .yum:
+            var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+            let a1 = try unkeyedValues.decode([String].self)
+            self = .yum(a1)
+        }
+    }
 }
 
 /// Represents a package dependency.
 public struct PackageDependencyDescription: Equatable, Codable {
 
     /// The dependency requirement.
-    public enum Requirement: Equatable, Hashable, CustomStringConvertible {
+    public enum Requirement: Equatable, Hashable, CustomStringConvertible, Codable {
         case exact(Version)
         case range(Range<Version>)
         case revision(String)
@@ -599,6 +687,57 @@ public struct PackageDependencyDescription: Equatable, Codable {
                 return "local"
             }
         }
+
+        private enum CodingKeys: String, CodingKey {
+            case exact, range, revision, branch, localPackage
+        }
+
+        public func encode(to encoder: Encoder) throws {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            switch self {
+            case let .exact(a1):
+                var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .exact)
+                try unkeyedContainer.encode(a1)
+            case let .range(a1):
+                var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .range)
+                try unkeyedContainer.encode(CodableRange(a1))
+            case let .revision(a1):
+                var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .revision)
+                try unkeyedContainer.encode(a1)
+            case let .branch(a1):
+                var unkeyedContainer = container.nestedUnkeyedContainer(forKey: .branch)
+                try unkeyedContainer.encode(a1)
+            case .localPackage:
+                try container.encodeNil(forKey: .localPackage)
+            }
+        }
+
+        public init(from decoder: Decoder) throws {
+            let values = try decoder.container(keyedBy: CodingKeys.self)
+            guard let key = values.allKeys.first(where: values.contains) else {
+                throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath, debugDescription: "Did not find a matching key"))
+            }
+            switch key {
+            case .exact:
+                var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+                let a1 = try unkeyedValues.decode(Version.self)
+                self = .exact(a1)
+            case .range:
+                var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+                let a1 = try unkeyedValues.decode(CodableRange<Version>.self)
+                self = .range(a1.range)
+            case .revision:
+                var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+                let a1 = try unkeyedValues.decode(String.self)
+                self = .revision(a1)
+            case .branch:
+                var unkeyedValues = try values.nestedUnkeyedContainer(forKey: key)
+                let a1 = try unkeyedValues.decode(String.self)
+                self = .branch(a1)
+            case .localPackage:
+                self = .localPackage
+            }
+        }
     }
 
     /// The name of the dependency explicitly defined in the manifest.