style: Apply SwiftFormat before push

Author: fatbobman

Tests/Objects2XLSXTests/Book/BookAsyncTests.swift

@@ -7,8 +7,8 @@
 // Copyright © 2025 Fatbobman. All rights reserved.
 
 import Foundation
-import Testing
 @testable import Objects2XLSX
+import Testing
 
 /// Test data structure for async book testing
 struct AsyncTestPerson: Sendable {
@@ -19,177 +19,173 @@ struct AsyncTestPerson: Sendable {
 
 @Suite("Book Async Write Tests")
 struct BookAsyncTests {
-    
     @Test("Book with async data provider writes successfully")
-    func testBookAsyncWrite() async throws {
+    func bookAsyncWrite() async throws {
         let tempDir = FileManager.default.temporaryDirectory
         let testURL = tempDir.appendingPathComponent("async_test.xlsx")
-        
+
         // Clean up any existing file
         try? FileManager.default.removeItem(at: testURL)
-        
+
         // Create test data
         let people = [
             AsyncTestPerson(name: "Alice", age: 25, isActive: true),
             AsyncTestPerson(name: "Bob", age: 30, isActive: false),
             AsyncTestPerson(name: "Charlie", age: 35, isActive: true)
         ]
-        
+
         // Create book with async data provider
         let sheet = Sheet<AsyncTestPerson>(
             name: "Async People",
             asyncDataProvider: {
                 // Simulate async data loading
                 try? await Task.sleep(nanoseconds: 10_000_000) // 0.01 second
                 return people
+            }) {
+                Column(name: "Name", keyPath: \.name)
+                Column(name: "Age", keyPath: \.age)
+                Column(name: "Active", keyPath: \.isActive, booleanExpressions: .yesAndNo)
             }
-        ) {
-            Column(name: "Name", keyPath: \.name)
-            Column(name: "Age", keyPath: \.age)
-            Column(name: "Active", keyPath: \.isActive, booleanExpressions: .yesAndNo)
-        }
-        
+
         let book = Book(style: BookStyle(), sheets: [sheet.eraseToAnySheet()])
-        
+
         // Write asynchronously
         let outputURL = try await book.writeAsync(to: testURL)
-        
+
         // Verify file was created
         #expect(FileManager.default.fileExists(atPath: outputURL.path))
         #expect(outputURL.pathExtension == "xlsx")
-        
+
         // Clean up
         try? FileManager.default.removeItem(at: outputURL)
     }
-    
+
     @Test("Book with mixed sync and async sheets")
-    func testBookMixedDataProviders() async throws {
+    func bookMixedDataProviders() async throws {
         let tempDir = FileManager.default.temporaryDirectory
         let testURL = tempDir.appendingPathComponent("mixed_test.xlsx")
-        
+
         // Clean up any existing file
         try? FileManager.default.removeItem(at: testURL)
-        
+
         // Create test data
         let syncPeople = [
             AsyncTestPerson(name: "Sync1", age: 20, isActive: true),
             AsyncTestPerson(name: "Sync2", age: 25, isActive: false)
         ]
-        
+
         let asyncPeople = [
             AsyncTestPerson(name: "Async1", age: 30, isActive: true),
             AsyncTestPerson(name: "Async2", age: 35, isActive: false)
         ]
-        
+
         // Create book with mixed data providers
         let syncSheet = Sheet<AsyncTestPerson>(
             name: "Sync People",
-            dataProvider: { syncPeople }
-        ) {
+            dataProvider: { syncPeople })
+        {
             Column(name: "Name", keyPath: \.name)
             Column(name: "Age", keyPath: \.age)
         }
-        
+
         let asyncSheet = Sheet<AsyncTestPerson>(
             name: "Async People",
             asyncDataProvider: {
                 try? await Task.sleep(nanoseconds: 5_000_000) // 0.005 second
                 return asyncPeople
+            }) {
+                Column(name: "Name", keyPath: \.name)
+                Column(name: "Age", keyPath: \.age)
+                Column(name: "Active", keyPath: \.isActive, booleanExpressions: .yesAndNo)
             }
-        ) {
-            Column(name: "Name", keyPath: \.name)
-            Column(name: "Age", keyPath: \.age)
-            Column(name: "Active", keyPath: \.isActive, booleanExpressions: .yesAndNo)
-        }
-        
+
         let book = Book(style: BookStyle(), sheets: [
             syncSheet.eraseToAnySheet(),
             asyncSheet.eraseToAnySheet()
         ])
-        
+
         // Write asynchronously
         let outputURL = try await book.writeAsync(to: testURL)
-        
+
         // Verify file was created
         #expect(FileManager.default.fileExists(atPath: outputURL.path))
         #expect(outputURL.pathExtension == "xlsx")
-        
+
         // Clean up
         try? FileManager.default.removeItem(at: outputURL)
     }
-    
+
     @Test("Book writeAsync falls back to sync for sheets without async providers")
-    func testBookAsyncFallbackToSync() async throws {
+    func bookAsyncFallbackToSync() async throws {
         let tempDir = FileManager.default.temporaryDirectory
         let testURL = tempDir.appendingPathComponent("fallback_test.xlsx")
-        
+
         // Clean up any existing file
         try? FileManager.default.removeItem(at: testURL)
-        
+
         // Create test data
         let people = [
             AsyncTestPerson(name: "Test1", age: 25, isActive: true),
             AsyncTestPerson(name: "Test2", age: 30, isActive: false)
         ]
-        
+
         // Create book with only sync data provider
         let sheet = Sheet<AsyncTestPerson>(
             name: "Sync Only",
-            dataProvider: { people }
-        ) {
+            dataProvider: { people })
+        {
             Column(name: "Name", keyPath: \.name)
             Column(name: "Age", keyPath: \.age)
         }
-        
+
         let book = Book(style: BookStyle(), sheets: [sheet.eraseToAnySheet()])
-        
+
         // Write asynchronously (should fall back to sync)
         let outputURL = try await book.writeAsync(to: testURL)
-        
+
         // Verify file was created
         #expect(FileManager.default.fileExists(atPath: outputURL.path))
         #expect(outputURL.pathExtension == "xlsx")
-        
+
         // Clean up
         try? FileManager.default.removeItem(at: outputURL)
     }
-    
+
     @Test("Progress reporting works with async write")
-    func testAsyncProgressReporting() async throws {
+    func asyncProgressReporting() async throws {
         let tempDir = FileManager.default.temporaryDirectory
         let testURL = tempDir.appendingPathComponent("progress_test.xlsx")
-        
+
         // Clean up any existing file
         try? FileManager.default.removeItem(at: testURL)
-        
+
         // Create test data
         let people = [
             AsyncTestPerson(name: "Progress1", age: 25, isActive: true),
             AsyncTestPerson(name: "Progress2", age: 30, isActive: false)
         ]
-        
+
         // Create book with async data provider
         let sheet = Sheet<AsyncTestPerson>(
             name: "Progress Test",
             asyncDataProvider: {
                 try? await Task.sleep(nanoseconds: 20_000_000) // 0.02 second
                 return people
+            }) {
+                Column(name: "Name", keyPath: \.name)
+                Column(name: "Age", keyPath: \.age)
             }
-        ) {
-            Column(name: "Name", keyPath: \.name)
-            Column(name: "Age", keyPath: \.age)
-        }
-        
+
         let book = Book(style: BookStyle(), sheets: [sheet.eraseToAnySheet()])
-        
+
         // Write asynchronously
         let outputURL = try await book.writeAsync(to: testURL)
-        
+
         // Verify file was created
         #expect(FileManager.default.fileExists(atPath: outputURL.path))
         #expect(outputURL.pathExtension == "xlsx")
-        
+
         // Clean up
         try? FileManager.default.removeItem(at: outputURL)
     }
-}
+}

Tests/Objects2XLSXTests/Sheet/SheetAsyncTests.swift

@@ -17,7 +17,7 @@ struct SheetAsyncTests {
     }
 
     @Test("Create sheet with async data provider")
-    func testAsyncDataProviderInitialization() async {
+    func asyncDataProviderInitialization() async {
         // Create sheet with async data provider
         let sheet = Sheet<AsyncPerson>(
             name: "Async People",
@@ -26,7 +26,7 @@ struct SheetAsyncTests {
                 try? await Task.sleep(nanoseconds: 100_000) // 0.1ms
                 return [
                     AsyncPerson(id: 1, name: "Alice", age: 30),
-                    AsyncPerson(id: 2, name: "Bob", age: 25),
+                    AsyncPerson(id: 2, name: "Bob", age: 25)
                 ]
             }) {
                 Column(name: "ID", keyPath: \.id)
@@ -46,7 +46,7 @@ struct SheetAsyncTests {
     }
 
     @Test("Set async data provider via method")
-    func testAsyncDataProviderMethod() async {
+    func asyncDataProviderMethod() async {
         // Create sheet without data provider
         let sheet = Sheet<AsyncPerson>(name: "People") {
             Column(name: "ID", keyPath: \.id)
@@ -59,7 +59,7 @@ struct SheetAsyncTests {
         sheet.asyncDataProvider {
             [
                 AsyncPerson(id: 1, name: "Charlie", age: 35),
-                AsyncPerson(id: 2, name: "Diana", age: 28),
+                AsyncPerson(id: 2, name: "Diana", age: 28)
             ]
         }
 
@@ -73,7 +73,7 @@ struct SheetAsyncTests {
     }
 
     @Test("Async data provider clears sync provider")
-    func testAsyncClearsSyncProvider() async {
+    func asyncClearsSyncProvider() async {
         let sheet = Sheet<AsyncPerson>(name: "People") {
             Column(name: "Name", keyPath: \.name)
         }
@@ -95,7 +95,7 @@ struct SheetAsyncTests {
     }
 
     @Test("Sync data provider clears async provider")
-    func testSyncClearsAsyncProvider() {
+    func syncClearsAsyncProvider() {
         let sheet = Sheet<AsyncPerson>(name: "People") {
             Column(name: "Name", keyPath: \.name)
         }
@@ -119,7 +119,7 @@ struct SheetAsyncTests {
     }
 
     @Test("LoadDataAsync falls back to sync provider")
-    func testLoadDataAsyncFallback() async {
+    func loadDataAsyncFallback() async {
         let sheet = Sheet<AsyncPerson>(name: "People") {
             Column(name: "Name", keyPath: \.name)
         }