Merge pull request #3 from thoven87/drop-actor

Author: thoven87

README.md

@@ -10,8 +10,7 @@ A comprehensive Swift 6 library for parsing and creating iCalendar (RFC 5545) ev
 
 - **RFC Compliant**: Full support for RFC 5545, RFC 5546, RFC 6868, RFC 7529, and RFC 7986
 - **Swift 6 Ready**: Complete Sendable conformance and structured concurrency support
-- **Type Safe**: Uses structs instead of classes with comprehensive type safety
-- **Actor-based**: Parser and serializer use actors for thread-safe operations
+- **Type Safe**: Uses structs instead of classes with comprehensive type  operations
 - **Comprehensive**: Support for events, todos, journals, alarms, time zones, and recurrence rules
 - **Builder Pattern**: Fluent API for easy calendar and event creation
 - **Extensible**: Support for custom properties and extensions
@@ -62,7 +61,7 @@ var calendar = client.createCalendar(productId: "-//My App//EN")
 calendar.addEvent(event)
 
 // Serialize to iCalendar format
-let icalString = try await client.serializeCalendar(calendar)
+let icalString = try client.serializeCalendar(calendar)
 print(icalString)
 ```
 
@@ -84,7 +83,7 @@ END:VEVENT
 END:VCALENDAR
 """
 
-let calendar = try await client.parseCalendar(from: icalContent)
+let calendar = try client.parseCalendar(from: icalContent)
 print("Found \(calendar.events.count) events")
 ```
 
@@ -266,7 +265,7 @@ let serializationOptions = ICalendarSerializer.SerializationOptions(
 )
 
 let serializer = ICalendarSerializer(options: serializationOptions)
-let serialized = try await serializer.serialize(calendar)
+let serialized = try serializer.serialize(calendar)
 ```
 
 ## Structured Concurrency Support
@@ -275,17 +274,17 @@ The library is built with Swift 6 structured concurrency in mind:
 
 ```swift
 // Concurrent parsing of multiple calendars
-async let calendar1 = client.parseCalendar(from: content1)
-async let calendar2 = client.parseCalendar(from: content2)
-async let calendar3 = client.parseCalendar(from: content3)
+let calendar1 = client.parseCalendar(from: content1)
+let calendar2 = client.parseCalendar(from: content2)
+let calendar3 = client.parseCalendar(from: content3)
 
-let calendars = try await [calendar1, calendar2, calendar3]
+let calendars = try [calendar1, calendar2, calendar3]
 
 // Process calendars concurrently
-await withTaskGroup { group in
+withTaskGroup { group in
     for calendar in calendars {
         group.addTask {
-            let serialized = try await client.serializeCalendar(calendar)
+            let serialized = try client.serializeCalendar(calendar)
             // Process serialized calendar...
         }
     }
@@ -343,8 +342,8 @@ let firstMonday = RecurrencePatterns.monthly(
 
 ```swift
 do {
-    let calendar = try await client.parseCalendar(from: icalContent)
-    let serialized = try await client.serializeCalendar(calendar)
+    let calendar = try client.parseCalendar(from: icalContent)
+    let serialized = try client.serializeCalendar(calendar)
 } catch ICalendarError.invalidFormat(let message) {
     print("Invalid format: \(message)")
 } catch ICalendarError.missingRequiredProperty(let property) {
@@ -360,7 +359,7 @@ do {
 
 ```swift
 // Validate a calendar
-try await client.validateCalendar(calendar)
+try client.validateCalendar(calendar)
 
 // Validate email addresses
 ValidationUtilities.isValidEmail("user@example.com") // true
@@ -374,19 +373,19 @@ ValidationUtilities.isValidPercentComplete(75) // true (0-100)
 
 ```swift
 // Outlook-compatible format
-let outlookFormat = await serializer.serializeForOutlook(calendar)
+let outlookFormat = serializer.serializeForOutlook(calendar)
 
 // Google Calendar format
-let googleFormat = await serializer.serializeForGoogle(calendar)
+let googleFormat = serializer.serializeForGoogle(calendar)
 
 // Pretty-printed format for debugging
-let prettyFormat = await serializer.serializePretty(calendar)
+let prettyFormat = serializer.serializePretty(calendar)
 ```
 
 ## Statistics and Analysis
 
 ```swift
-let stats = await client.getCalendarStatistics(calendar)
+let stats = client.getCalendarStatistics(calendar)
 print(stats.description)
 // Output:
 // Calendar Statistics:

Sources/ICalendar/ICalendar.swift

@@ -49,50 +49,50 @@ public struct ICalendarClient: Sendable {
     // MARK: - Parsing Operations
 
     /// Parse iCalendar content from string
-    public func parseCalendar(from content: String) async throws -> ICalendar {
+    public func parseCalendar(from content: String) throws -> ICalendar {
         let parser = ICalendarParser()
 
         if configuration.validateOnParse {
-            return try await parser.parseAndValidate(content)
+            return try parser.parseAndValidate(content)
         } else {
-            return try await parser.parse(content)
+            return try parser.parse(content)
         }
     }
 
     /// Parse iCalendar content from data
-    public func parseCalendar(from data: Data) async throws -> ICalendar {
+    public func parseCalendar(from data: Data) throws -> ICalendar {
         let parser = ICalendarParser()
 
         if configuration.validateOnParse {
-            let calendar = try await parser.parse(data)
-            try await parser.validate(calendar)
+            let calendar = try parser.parse(data)
+            try parser.validate(calendar)
             return calendar
         } else {
-            return try await parser.parse(data)
+            return try parser.parse(data)
         }
     }
 
     /// Parse iCalendar file from URL
-    public func parseCalendar(from url: URL) async throws -> ICalendar {
+    public func parseCalendar(from url: URL) throws -> ICalendar {
         let parser = ICalendarParser()
 
         if configuration.validateOnParse {
-            let calendar = try await parser.parseFile(at: url)
-            try await parser.validate(calendar)
+            let calendar = try parser.parseFile(at: url)
+            try parser.validate(calendar)
             return calendar
         } else {
-            return try await parser.parseFile(at: url)
+            return try parser.parseFile(at: url)
         }
     }
 
     /// Parse multiple calendars from content
-    public func parseCalendars(from content: String) async throws -> [ICalendar] {
+    public func parseCalendars(from content: String) throws -> [ICalendar] {
         let parser = ICalendarParser()
-        let calendars = try await parser.parseMultiple(content)
+        let calendars = try parser.parseMultiple(content)
 
         if configuration.validateOnParse {
             for calendar in calendars {
-                try await parser.validate(calendar)
+                try parser.validate(calendar)
             }
         }
 
@@ -102,43 +102,43 @@ public struct ICalendarClient: Sendable {
     // MARK: - Serialization Operations
 
     /// Serialize calendar to string
-    public func serializeCalendar(_ calendar: ICalendar) async throws -> String {
+    public func serializeCalendar(_ calendar: ICalendar) throws -> String {
         let serializer = ICalendarSerializer(
             options: ICalendarSerializer.SerializationOptions(
                 validateBeforeSerializing: configuration.validateOnSerialize
             )
         )
-        return try await serializer.serialize(calendar)
+        return try serializer.serialize(calendar)
     }
 
     /// Serialize calendar to data
-    public func serializeCalendar(_ calendar: ICalendar) async throws -> Data {
+    public func serializeCalendar(_ calendar: ICalendar) throws -> Data {
         let serializer = ICalendarSerializer(
             options: ICalendarSerializer.SerializationOptions(
                 validateBeforeSerializing: configuration.validateOnSerialize
             )
         )
-        return try await serializer.serializeToData(calendar)
+        return try serializer.serializeToData(calendar)
     }
 
     /// Serialize calendar to file
-    public func serializeCalendar(_ calendar: ICalendar, to url: URL) async throws {
+    public func serializeCalendar(_ calendar: ICalendar, to url: URL) throws {
         let serializer = ICalendarSerializer(
             options: ICalendarSerializer.SerializationOptions(
                 validateBeforeSerializing: configuration.validateOnSerialize
             )
         )
-        try await serializer.serializeToFile(calendar, url: url)
+        try serializer.serializeToFile(calendar, url: url)
     }
 
     /// Serialize multiple calendars
-    public func serializeCalendars(_ calendars: [ICalendar]) async throws -> String {
+    public func serializeCalendars(_ calendars: [ICalendar]) throws -> String {
         let serializer = ICalendarSerializer(
             options: ICalendarSerializer.SerializationOptions(
                 validateBeforeSerializing: configuration.validateOnSerialize
             )
         )
-        return try await serializer.serialize(calendars)
+        return try serializer.serialize(calendars)
     }
 
     // MARK: - Calendar Creation
@@ -455,15 +455,15 @@ public struct ICalendarClient: Sendable {
     // MARK: - Utility Operations
 
     /// Validate a calendar
-    public func validateCalendar(_ calendar: ICalendar) async throws {
+    public func validateCalendar(_ calendar: ICalendar) throws {
         let parser = ICalendarParser()
-        try await parser.validate(calendar)
+        try parser.validate(calendar)
     }
 
     /// Get calendar statistics
-    public func getCalendarStatistics(_ calendar: ICalendar) async -> CalendarStatistics {
+    public func getCalendarStatistics(_ calendar: ICalendar) -> CalendarStatistics {
         let serializer = ICalendarSerializer()
-        let serializationStats = await serializer.getStatistics(calendar)
+        let serializationStats = serializer.getStatistics(calendar)
 
         let totalAttendees = calendar.events.reduce(0) { $0 + $1.attendees.count }
         let eventsWithAlarms = calendar.events.filter { !$0.alarms.isEmpty }.count
@@ -486,7 +486,7 @@ public struct ICalendarClient: Sendable {
         in calendar: ICalendar,
         from startDate: Date,
         to endDate: Date
-    ) async -> [ICalEvent] {
+    ) -> [ICalEvent] {
         calendar.events.filter { event in
             guard let eventStart = event.dateTimeStart?.date else { return false }
 
@@ -854,15 +854,15 @@ public struct CalendarStatistics: Sendable {
 extension ICalendarClient {
 
     /// Quick parse from string
-    public static func parse(_ content: String) async throws -> ICalendar {
+    public static func parse(_ content: String) throws -> ICalendar {
         let client = ICalendarClient()
-        return try await client.parseCalendar(from: content)
+        return try client.parseCalendar(from: content)
     }
 
     /// Quick serialize to string
-    public static func serialize(_ calendar: ICalendar) async throws -> String {
+    public static func serialize(_ calendar: ICalendar) throws -> String {
         let client = ICalendarClient()
-        return try await client.serializeCalendar(calendar)
+        return try client.serializeCalendar(calendar)
     }
 
     /// Create a simple meeting invitation