Introduce CachePolicy and replace CacheMode with an array of CachePolicy

Sources/ScipioKit/Producer/FrameworkProducer.swift

@@ -10,15 +10,15 @@ struct FrameworkProducer {
     private let descriptionPackage: DescriptionPackage
     private let baseBuildOptions: BuildOptions
     private let buildOptionsMatrix: [String: BuildOptions]
-    private let cacheMode: Runner.Options.CacheMode
+    private let cachePolicies: [Runner.Options.CachePolicy]
     private let overwrite: Bool
     private let outputDir: URL
     private let fileSystem: any FileSystem
     private let toolchainEnvironment: [String: String]?
 
     private var shouldGenerateVersionFile: Bool {
-        // cacheMode is not disabled
-        if case .storages(let configs) = cacheMode, configs.isEmpty {
+        // cache is not disabled
+        guard !cachePolicies.isEmpty else {
             return false
         }
 
@@ -33,7 +33,7 @@ struct FrameworkProducer {
         descriptionPackage: DescriptionPackage,
         buildOptions: BuildOptions,
         buildOptionsMatrix: [String: BuildOptions],
-        cacheMode: Runner.Options.CacheMode,
+        cachePolicies: [Runner.Options.CachePolicy],
         overwrite: Bool,
         outputDir: URL,
         toolchainEnvironment: [String: String]? = nil,
@@ -42,7 +42,7 @@ struct FrameworkProducer {
         self.descriptionPackage = descriptionPackage
         self.baseBuildOptions = buildOptions
         self.buildOptionsMatrix = buildOptionsMatrix
-        self.cacheMode = cacheMode
+        self.cachePolicies = cachePolicies
         self.overwrite = overwrite
         self.outputDir = outputDir
         self.toolchainEnvironment = toolchainEnvironment
@@ -96,14 +96,10 @@ struct FrameworkProducer {
         )
 
         let targetsToBuild: OrderedSet<CacheSystem.CacheTarget>
-        switch cacheMode {
-        case .storages(let configs):
-            if configs.isEmpty {
-                // no-op because cache is disabled
-                targetsToBuild = allTargets
-                break
-            }
-
+        if cachePolicies.isEmpty {
+            // no-op because cache is disabled
+            targetsToBuild = allTargets
+        } else {
             let targets = Set(allTargets)
 
             // Validate the existing frameworks in `outputDir` before restoration
@@ -112,15 +108,14 @@ struct FrameworkProducer {
                 cacheSystem: cacheSystem
             )
 
-            let storagesWithConsumer = configs.compactMap { config in
-                config.actors.contains(.consumer) ? config.storage : nil
-            }
+            let storagesWithConsumer = cachePolicies.storages(for: .consumer)
             if storagesWithConsumer.isEmpty {
                 // no-op
                 targetsToBuild = allTargets.subtracting(valid)
             } else {
                 let restored = await restoreAllAvailableCachesIfNeeded(
                     availableTargets: targets.subtracting(valid),
+                    to: storagesWithConsumer,
                     cacheSystem: cacheSystem
                 )
                 targetsToBuild = allTargets
@@ -196,29 +191,17 @@ struct FrameworkProducer {
 
     private func restoreAllAvailableCachesIfNeeded(
         availableTargets: Set<CacheSystem.CacheTarget>,
+        to storages: [any CacheStorage],
         cacheSystem: CacheSystem
     ) async -> Set<CacheSystem.CacheTarget> {
-        let cacheStorages: [any CacheStorage]
-
-        switch cacheMode {
-        case .storages(let configs):
-            guard !configs.isEmpty else { return [] }
-
-            let storagesWithConsumer = configs.compactMap { config in
-                config.actors.contains(.consumer) ? config.storage : nil
-            }
-            guard !storagesWithConsumer.isEmpty else { return [] }
-            cacheStorages = storagesWithConsumer
-        }
-
         var remainingTargets = availableTargets
         var restored: Set<CacheSystem.CacheTarget> = []
 
-        for index in cacheStorages.indices {
-            let storage = cacheStorages[index]
+        for index in storages.indices {
+            let storage = storages[index]
 
             let logSuffix = "[\(index)] \(type(of: storage))"
-            if index == cacheStorages.startIndex {
+            if index == storages.startIndex {
                 logger.info(
                     "▶️ Starting restoration with cache storage: \(logSuffix)",
                     metadata: .color(.green)
@@ -357,16 +340,9 @@ struct FrameworkProducer {
     }
 
     private func cacheFrameworksIfNeeded(_ targets: Set<CacheSystem.CacheTarget>, cacheSystem: CacheSystem) async {
-        switch cacheMode {
-        case .storages(let configs):
-            guard !configs.isEmpty else { return }
-
-            let storagesWithProducer = configs.compactMap { config in
-                config.actors.contains(.producer) ? config.storage : nil
-            }
-            if !storagesWithProducer.isEmpty {
-                await cacheSystem.cacheFrameworks(targets, to: storagesWithProducer)
-            }
+        let storagesWithProducer = cachePolicies.storages(for: .producer)
+        if !storagesWithProducer.isEmpty {
+            await cacheSystem.cacheFrameworks(targets, to: storagesWithProducer)
         }
     }
 
@@ -378,3 +354,13 @@ struct FrameworkProducer {
         }
     }
 }
+
+extension [Runner.Options.CachePolicy] {
+    fileprivate func storages(for actor: Runner.Options.CachePolicy.CacheActorKind) -> [any CacheStorage] {
+        reduce(into: []) { result, cachePolicy in
+            if cachePolicy.actors.contains(actor) {
+                result.append(cachePolicy.storage)
+            }
+        }
+    }
+}

Sources/ScipioKit/Runner.swift

@@ -97,7 +97,7 @@ public struct Runner {
             descriptionPackage: descriptionPackage,
             buildOptions: buildOptions,
             buildOptionsMatrix: buildOptionsMatrix,
-            cacheMode: options.cacheMode,
+            cachePolicies: options.cachePolicies,
             overwrite: options.overwrite,
             outputDir: outputDir
         )
@@ -208,35 +208,31 @@ extension Runner {
             public var buildOptionsMatrix: [String: TargetBuildOptions]
         }
 
-        public enum CacheMode: Sendable {
-            public struct StorageConfig: Sendable {
-                public let storage: any CacheStorage
-                public let actors: Set<CacheActorKind>
-
-                public init(storage: any CacheStorage, actors: Set<CacheActorKind>) {
-                    self.storage = storage
-                    self.actors = actors
-                }
-            }
-
+        public struct CachePolicy: Sendable {
             public enum CacheActorKind: Sendable {
                 // Save built product to cacheStorage
                 case producer
                 // Consume stored caches
                 case consumer
             }
 
-            case storages([StorageConfig])
+            public let storage: any CacheStorage
+            public let actors: Set<CacheActorKind>
 
-            public static let disabled: Self = .storages([])
+            public init(storage: any CacheStorage, actors: Set<CacheActorKind>) {
+                self.storage = storage
+                self.actors = actors
+            }
 
-            public static let project: Self = .storages([
-                .init(storage: ProjectCacheStorage(), actors: [.producer]),
-            ])
+            public static let project = Self(
+                storage: ProjectCacheStorage(),
+                actors: [.producer]
+            )
 
-            public static func storage(_ config: StorageConfig) -> Self {
-                .storages([config])
-            }
+            public static let localDisk = Self(
+                storage: LocalDiskCacheStorage(),
+                actors: [.producer, .consumer]
+            )
         }
 
         public enum PlatformSpecifier: Equatable {
@@ -255,7 +251,7 @@ extension Runner {
 
         public var buildOptionsContainer: BuildOptionsContainer
         public var shouldOnlyUseVersionsFromResolvedFile: Bool
-        public var cacheMode: CacheMode
+        public var cachePolicies: [CachePolicy]
         public var overwrite: Bool
         public var verbose: Bool
         public var toolchainEnvironment: [String: String]?
@@ -264,7 +260,7 @@ extension Runner {
             baseBuildOptions: BuildOptions = .init(),
             buildOptionsMatrix: [String: TargetBuildOptions] = [:],
             shouldOnlyUseVersionsFromResolvedFile: Bool = false,
-            cacheMode: CacheMode = .project,
+            cachePolicies: [CachePolicy] = [.project],
             overwrite: Bool = false,
             verbose: Bool = false,
             toolchainEnvironment: [String: String]? = nil
@@ -274,7 +270,7 @@ extension Runner {
                 buildOptionsMatrix: buildOptionsMatrix
             )
             self.shouldOnlyUseVersionsFromResolvedFile = shouldOnlyUseVersionsFromResolvedFile
-            self.cacheMode = cacheMode
+            self.cachePolicies = cachePolicies
             self.overwrite = overwrite
             self.verbose = verbose
             self.toolchainEnvironment = toolchainEnvironment

Sources/scipio/CommandType.swift

@@ -3,7 +3,7 @@ import ScipioKit
 
 enum CommandType {
     case create(platformSpecifier: Runner.Options.PlatformSpecifier)
-    case prepare(cacheMode: Runner.Options.CacheMode)
+    case prepare(cachePolicies: [Runner.Options.CachePolicy])
 
     var mode: Runner.Mode {
         switch self {
@@ -23,12 +23,12 @@ enum CommandType {
         }
     }
 
-    var cacheMode: Runner.Options.CacheMode {
+    var cachePolicies: [Runner.Options.CachePolicy] {
         switch self {
         case .create:
-            return .disabled
-        case .prepare(let cacheMode):
-            return cacheMode
+            return []
+        case .prepare(let cachePolicies):
+            return cachePolicies
         }
     }
 }
@@ -51,19 +51,19 @@ extension Runner {
         let runnerOptions = Runner.Options(
             baseBuildOptions: baseBuildOptions,
             shouldOnlyUseVersionsFromResolvedFile: buildOptions.shouldOnlyUseVersionsFromResolvedFile,
-            cacheMode: Self.cacheMode(from: commandType),
+            cachePolicies: Self.cachePolicies(from: commandType),
             overwrite: buildOptions.overwrite,
             verbose: globalOptions.verbose
         )
         self.init(mode: commandType.mode, options: runnerOptions)
     }
 
-    private static func cacheMode(from commandType: CommandType) -> Runner.Options.CacheMode {
+    private static func cachePolicies(from commandType: CommandType) -> [Runner.Options.CachePolicy] {
         switch commandType {
         case .create:
-            return .disabled
-        case .prepare(let cacheMode):
-            return cacheMode
+            return []
+        case .prepare(let cachePolicies):
+            return cachePolicies
         }
     }
 

Sources/scipio/PrepareCommands.swift

@@ -31,21 +31,18 @@ extension Scipio {
             let logLevel: Logger.Level = globalOptions.verbose ? .trace : .info
             LoggingSystem.bootstrap(logLevel: logLevel)
 
-            let runnerCacheMode: Runner.Options.CacheMode
+            let runnerCachePolicies: [Runner.Options.CachePolicy]
             switch cachePolicy {
             case .disabled:
-                runnerCacheMode = .disabled
+                runnerCachePolicies = []
             case .project:
-                runnerCacheMode = .project
+                runnerCachePolicies = [.project]
             case .local:
-                runnerCacheMode = .storage(.init(
-                    storage: LocalDiskCacheStorage(),
-                    actors: [.consumer, .producer]
-                ))
+                runnerCachePolicies = [.localDisk]
             }
 
             let runner = Runner(
-                commandType: .prepare(cacheMode: runnerCacheMode),
+                commandType: .prepare(cachePolicies: runnerCachePolicies),
                 buildOptions: buildOptions,
                 globalOptions: globalOptions
             )

Tests/ScipioKitTests/IntegrationTests.swift

@@ -108,7 +108,7 @@ final class IntegrationTests: XCTestCase {
                 ),
                 buildOptionsMatrix: buildOptionsMatrix,
                 shouldOnlyUseVersionsFromResolvedFile: true,
-                cacheMode: .disabled,
+                cachePolicies: [],
                 overwrite: true,
                 verbose: false
             )