Fix SwiftLint violations

- Remove trailing whitespace from test and source files
- Add trailing newline to test file
- Break long lines in logger statements to comply with line length rules
- Improve code formatting for better readability

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ikesyo

Sources/ScipioKit/Producer/FrameworkProducer.swift

@@ -105,11 +105,11 @@ struct FrameworkProducer {
                     to: storagesWithConsumer,
                     cacheSystem: cacheSystem
                 )
-                
+
                 if !restored.isEmpty {
                     await shareRestoredCachesToProducers(restored, cacheSystem: cacheSystem)
                 }
-                
+
                 let skipTargets = valid.union(restored)
                 targetGraph.remove(skipTargets)
             }
@@ -374,21 +374,31 @@ struct FrameworkProducer {
             logger.warning("⚠️ Could not create VersionFile. This framework will not be cached.", metadata: .color(.yellow))
         }
     }
-    
-    internal func shareRestoredCachesToProducers(_ restoredTargets: Set<CacheSystem.CacheTarget>, cacheSystem: CacheSystem) async {
+
+    internal func shareRestoredCachesToProducers(
+        _ restoredTargets: Set<CacheSystem.CacheTarget>,
+        cacheSystem: CacheSystem
+    ) async {
         let storagesWithProducer = cachePolicies.storages(for: .producer)
         guard !storagesWithProducer.isEmpty else { return }
-        
-        logger.info("🔄 Sharing \(restoredTargets.count) restored framework(s) to other cache storages", metadata: .color(.blue))
-        
+
+        logger.info(
+            "🔄 Sharing \(restoredTargets.count) restored framework(s) to other cache storages",
+            metadata: .color(.blue)
+        )
+
         for storage in storagesWithProducer {
             await shareCachesToStorage(restoredTargets, to: storage, cacheSystem: cacheSystem)
         }
     }
-    
-    private func shareCachesToStorage(_ targets: Set<CacheSystem.CacheTarget>, to storage: any CacheStorage, cacheSystem: CacheSystem) async {
+
+    private func shareCachesToStorage(
+        _ targets: Set<CacheSystem.CacheTarget>,
+        to storage: any CacheStorage,
+        cacheSystem: CacheSystem
+    ) async {
         let chunked = targets.chunks(ofCount: storage.parallelNumber ?? CacheSystem.defaultParalellNumber)
-        
+
         for chunk in chunked {
             await withTaskGroup(of: Void.self) { group in
                 for target in chunk {
@@ -397,14 +407,20 @@ struct FrameworkProducer {
                             let cacheKey = try await cacheSystem.calculateCacheKey(of: target)
                             let hasCache = try await storage.existsValidCache(for: cacheKey)
                             guard !hasCache else { return }
-                            
+
                             let frameworkName = target.buildProduct.frameworkName
                             let frameworkPath = outputDir.appendingPathComponent(frameworkName)
-                            
-                            logger.info("🔄 Share \(frameworkName) to cache storage: \(storage.displayName)", metadata: .color(.blue))
+
+                            logger.info(
+                                "🔄 Share \(frameworkName) to cache storage: \(storage.displayName)",
+                                metadata: .color(.blue)
+                            )
                             try await storage.cacheFramework(frameworkPath, for: cacheKey)
                         } catch {
-                            logger.warning("⚠️ Failed to share cache to \(storage.displayName): \(error.localizedDescription)", metadata: .color(.yellow))
+                            logger.warning(
+                                "⚠️ Failed to share cache to \(storage.displayName): \(error.localizedDescription)",
+                                metadata: .color(.yellow)
+                            )
                         }
                     }
                 }

Tests/ScipioKitTests/FrameworkProducerTests.swift

@@ -5,26 +5,26 @@ import ScipioStorage
 import Logging
 
 struct FrameworkProducerTests {
-    
+
     init() {
         LoggingSystem.bootstrap { _ in SwiftLogNoOpLogHandler() }
     }
-    
+
     @Test func cacheSharing() async throws {
         let tempDir = FileManager.default.temporaryDirectory
         let outputDir = tempDir.appendingPathComponent("test-output-\(UUID().uuidString)")
-        
+
         try FileManager.default.createDirectory(at: outputDir, withIntermediateDirectories: true)
-        
+
         defer {
             try? FileManager.default.removeItem(at: outputDir)
         }
-        
+
         // Create mock cache storages
         let consumerStorage = MockCacheStorage(name: "consumer")
         let producer1Storage = MockCacheStorage(name: "producer1")
         let producer2Storage = MockCacheStorage(name: "producer2")
-        
+
         // Create cache policies
         let consumerPolicy = Runner.Options.CachePolicy(
             storage: consumerStorage,
@@ -38,23 +38,23 @@ struct FrameworkProducerTests {
             storage: producer2Storage,
             actors: [.producer]
         )
-        
+
         let cachePolicies = [consumerPolicy, producerPolicy1, producerPolicy2]
-        
+
         // Use CacheKeyTests/AsRemotePackage fixture to avoid revision detection issues
         let testPackagePath = URL(fileURLWithPath: #filePath)
             .deletingLastPathComponent()
             .appendingPathComponent("Resources")
             .appendingPathComponent("Fixtures")
             .appendingPathComponent("CacheKeyTests")
             .appendingPathComponent("AsRemotePackage")
-        
+
         let descriptionPackage = try await DescriptionPackage(
             packageDirectory: testPackagePath,
             mode: .prepareDependencies,
             onlyUseVersionsFromResolvedFile: false
         )
-        
+
         let frameworkProducer = FrameworkProducer(
             descriptionPackage: descriptionPackage,
             buildOptions: BuildOptions(
@@ -74,9 +74,9 @@ struct FrameworkProducerTests {
             overwrite: false,
             outputDir: outputDir
         )
-        
+
         let cacheSystem = CacheSystem(outputDirectory: outputDir)
-        
+
         // Create a mock cache target using the real package info
         let package = try #require(
             descriptionPackage
@@ -102,29 +102,29 @@ struct FrameworkProducerTests {
                 stripStaticDWARFSymbols: false
             )
         )
-        
+
         let restoredTargets: Set<CacheSystem.CacheTarget> = [mockTarget]
         let mockCacheKey = try await cacheSystem.calculateCacheKey(of: mockTarget)
-        
+
         // Setup initial state: producer1 has cache, producer2 doesn't
         try await producer1Storage.setHasCache(for: mockCacheKey, value: true)
         try await producer2Storage.setHasCache(for: mockCacheKey, value: false)
-        
+
         // Test FrameworkProducer's cache sharing functionality
         await frameworkProducer.shareRestoredCachesToProducers(restoredTargets, cacheSystem: cacheSystem)
-        
+
         let producer1CacheCalls = await producer1Storage.getCacheFrameworkCalls()
         let producer2CacheCalls = await producer2Storage.getCacheFrameworkCalls()
-        
+
         // Verify behavior: producer1 already has cache so no call, producer2 doesn't have cache so gets a call
         #expect(producer1CacheCalls.count == 0, "Producer1 already has cache, so cacheFramework should not be called")
         try #require(producer2CacheCalls.count == 1, "Producer2 doesn't have cache, so cacheFramework should be called once")
-        
+
         // Verify the cache call was made with correct parameters
         let actualFrameworkPath = producer2CacheCalls[0].frameworkPath
         let expectedFrameworkPath = outputDir.appendingPathComponent(buildProduct.frameworkName)
         #expect(actualFrameworkPath == expectedFrameworkPath, "Framework path should match")
-        
+
         // Verify the cache call was made with the correct cache key
         let expectedCacheKey = try mockCacheKey.calculateChecksum()
         #expect(producer2CacheCalls[0].cacheKey == expectedCacheKey, "Cache key should match the actual cache key used")
@@ -135,7 +135,7 @@ struct FrameworkProducerTests {
 
 private struct MockCacheKey: CacheKey {
     let targetName: String
-    
+
     func calculateChecksum() throws -> String {
         return "mock-checksum-\(targetName)"
     }
@@ -146,36 +146,36 @@ private struct MockCacheKey: CacheKey {
 private actor MockCacheStorage: CacheStorage {
     let displayName: String
     let parallelNumber: Int? = 1
-    
+
     private var hasCacheMap: [String: Bool] = [:]
     private var cacheFrameworkCalls: [(frameworkPath: URL, cacheKey: String)] = []
-    
+
     init(name: String) {
         self.displayName = name
     }
-    
+
     func existsValidCache(for cacheKey: some CacheKey) async throws -> Bool {
         let keyString = try cacheKey.calculateChecksum()
         return hasCacheMap[keyString] ?? false
     }
-    
+
     func fetchArtifacts(for cacheKey: some CacheKey, to destinationDir: URL) async throws {
         // Mock implementation - no-op
     }
-    
+
     func cacheFramework(_ frameworkPath: URL, for cacheKey: some CacheKey) async throws {
         let keyString = try cacheKey.calculateChecksum()
         let call = (frameworkPath: frameworkPath, cacheKey: keyString)
         cacheFrameworkCalls.append(call)
     }
-    
+
     // Test helper methods
     func setHasCache(for cacheKey: some CacheKey, value: Bool) async throws {
         let keyString = try cacheKey.calculateChecksum()
         hasCacheMap[keyString] = value
     }
-    
+
     func getCacheFrameworkCalls() -> [(frameworkPath: URL, cacheKey: String)] {
         return cacheFrameworkCalls
     }
-}
+}