Implement support for delta updates (#33)

Author: jozefizso

Sources/Appcast/SUAppcastItem.swift

@@ -625,10 +625,77 @@ public struct SUAppcastItem: Sendable, Equatable {
             self.date = nil
         }
 
-        self.installationType = ""
-        self.deltaUpdates = [String: SUAppcastItem]()
-        self.deltaFromSparkleLocales = ["en"]
-        self.deltaFromSparkleExecutableSize = 0
+        self.installationType = enclosure?[SUAppcastAttribute.InstallationType] ?? ""
+
+        var deltaUpdates: [String: SUAppcastItem] = [:]
+        if let deltaEnclosures = dict[SUAppcastElement.Deltas] as? [SUAppcast.AttributesDictionary] {
+            for deltaEnclosure in deltaEnclosures {
+                guard let deltaFromVersion = deltaEnclosure[SUAppcastAttribute.DeltaFrom], !deltaFromVersion.isEmpty else {
+                    continue
+                }
+
+                var deltaItemDictionary = SUAppcastItemProperties()
+                deltaItemDictionary[SUAppcastElement.Version] = newVersion
+
+                var mergedEnclosure = deltaEnclosure
+                if let osType = enclosure?[SUAppcastAttribute.OsType], mergedEnclosure[SUAppcastAttribute.OsType] == nil {
+                    mergedEnclosure[SUAppcastAttribute.OsType] = osType
+                }
+                deltaItemDictionary[SURSSElement.Enclosure] = mergedEnclosure
+
+                // Inherit state-affecting properties from parent item
+                if let link = dict[SURSSElement.Link] {
+                    deltaItemDictionary[SURSSElement.Link] = link
+                }
+                if let informationalUpdate = dict[SUAppcastElement.InformationalUpdate] {
+                    deltaItemDictionary[SUAppcastElement.InformationalUpdate] = informationalUpdate
+                }
+                if let minimumSystemVersion = dict[SUAppcastElement.MinimumSystemVersion] {
+                    deltaItemDictionary[SUAppcastElement.MinimumSystemVersion] = minimumSystemVersion
+                }
+                if let maximumSystemVersion = dict[SUAppcastElement.MaximumSystemVersion] {
+                    deltaItemDictionary[SUAppcastElement.MaximumSystemVersion] = maximumSystemVersion
+                }
+                if let minimumAutoupdateVersion = dict[SUAppcastElement.MinimumAutoupdateVersion] {
+                    deltaItemDictionary[SUAppcastElement.MinimumAutoupdateVersion] = minimumAutoupdateVersion
+                }
+                if let ignoreSkippedUpgradesBelowVersion = dict[SUAppcastElement.IgnoreSkippedUpgradesBelowVersion] {
+                    deltaItemDictionary[SUAppcastElement.IgnoreSkippedUpgradesBelowVersion] = ignoreSkippedUpgradesBelowVersion
+                }
+                if let channel = dict[SUAppcastElement.Channel] {
+                    deltaItemDictionary[SUAppcastElement.Channel] = channel
+                }
+                if let tags = dict[SUAppcastElement.Tags] {
+                    deltaItemDictionary[SUAppcastElement.Tags] = tags
+                }
+                if let criticalUpdate = dict[SUAppcastElement.CriticalUpdate] {
+                    deltaItemDictionary[SUAppcastElement.CriticalUpdate] = criticalUpdate
+                }
+                if let shortVersionString = dict[SUAppcastElement.ShortVersionString] {
+                    deltaItemDictionary[SUAppcastElement.ShortVersionString] = shortVersionString
+                }
+
+                do {
+                    let deltaItem = try SUAppcastItem(dictionary: deltaItemDictionary, relativeTo: appcastURL, stateResolver: stateResolver, resolvedState: nil)
+                    deltaUpdates[deltaFromVersion] = deltaItem
+                } catch {
+                    continue
+                }
+            }
+        }
+        self.deltaUpdates = deltaUpdates
+
+        self.deltaFromSparkleExecutableSize = enclosure?[SUAppcastAttribute.DeltaFromSparkleExecutableSize].flatMap(Int.init)
+        if let deltaLocalesString = enclosure?[SUAppcastAttribute.DeltaFromSparkleLocales] {
+            let locales = deltaLocalesString
+                .split(separator: ",")
+                .map { String($0).trimmingCharacters(in: .whitespacesAndNewlines) }
+                .filter { !$0.isEmpty }
+
+            self.deltaFromSparkleLocales = Set(locales.prefix(Self.DELTA_EXPECTED_LOCALES_LIMIT))
+        } else {
+            self.deltaFromSparkleLocales = nil
+        }
     }
 
     private static func parseChannel(_ dict: SUAppcastItemProperties) -> String? {

Tests/IntegrationTests/SUAppcastDriverTests.swift

@@ -115,7 +115,7 @@ class SUAppcastDriverTests: XCTestCase {
 extension SUAppcastDriver {
     public static func bestItem(fromAppcastItems: [SUAppcastItem], getDeltaItem: inout SUAppcastItem?, withHostVersion: String, comparator: SUVersionComparison) -> SUAppcastItem? {
         let item = SUAppcastDriver.bestItem(fromAppcastItems: fromAppcastItems, getDeltaItem: getDeltaItem, withHostVersion: withHostVersion, comparator: comparator)
-        if let item, getDeltaItem != nil {
+        if let item {
             getDeltaItem = deltaUpdate(from: item, hostVersion: withHostVersion)
         }
         return item