Adopt ISO8601FormatStyle on newer platforms

Author: arthurcro

Benchmarks/Benchmarks/OpenAPIRuntimeBenchmarks/Benchmarks.swift

@@ -27,35 +27,8 @@ let benchmarks = {
             maxIterations: 5
         )
     ) { benchmark in
-        let transcoder = ISO8601DateTranscoder()
+        let transcoder = ISO8601DateTranscoder(formatStyle: .iso8601)
         benchmark.startMeasurement()
         for _ in benchmark.scaledIterations { blackHole(try transcoder.encode(.distantFuture)) }
     }
-
-    Benchmark(
-        "ISO8601DateFormatter.string(from:)",
-        configuration: Benchmark.Configuration(
-            metrics: defaultMetrics,
-            scalingFactor: .kilo,
-            maxDuration: .seconds(10_000_000),
-            maxIterations: 5
-        )
-    ) { benchmark in
-        let formatter = ISO8601DateFormatter()
-        benchmark.startMeasurement()
-        for _ in benchmark.scaledIterations { blackHole(formatter.string(from: .distantFuture)) }
-    }
-
-    Benchmark(
-        "Date.ISO8601Format(_:)",
-        configuration: Benchmark.Configuration(
-            metrics: defaultMetrics,
-            scalingFactor: .kilo,
-            maxDuration: .seconds(10_000_000),
-            maxIterations: 5
-        )
-    ) { benchmark in
-        benchmark.startMeasurement()
-        for _ in benchmark.scaledIterations { blackHole(Date.distantFuture.ISO8601Format()) }
-    }
 }

Sources/OpenAPIRuntime/Conversion/Configuration.swift

@@ -25,42 +25,85 @@ public protocol DateTranscoder: Sendable {
 }
 
 /// A transcoder for dates encoded as an ISO-8601 string (in RFC 3339 format).
-public struct ISO8601DateTranscoder: DateTranscoder, @unchecked Sendable {
+public struct ISO8601DateTranscoder: DateTranscoder {
+    /// A transcoder using `ISO8601DateFormatter` for encoding and decoding.
+    private struct DateFormatterTranscoder: DateTranscoder, @unchecked Sendable {
+        /// The lock protecting the formatter.
+        private let lock: NSLock
+
+        /// The underlying date formatter.
+        private let locked_formatter: ISO8601DateFormatter
+
+        init(options: ISO8601DateFormatter.Options? = nil) {
+            let formatter = ISO8601DateFormatter()
+            if let options { formatter.formatOptions = options }
+            lock = NSLock()
+            lock.name = "com.apple.swift-openapi-generator.runtime.ISO8601DateTranscoder"
+            locked_formatter = formatter
+        }
+
+        func encode(_ date: Date) throws -> String {
+            lock.lock()
+            defer { lock.unlock() }
+            return locked_formatter.string(from: date)
+        }
+
+        func decode(_ dateString: String) throws -> Date {
+            lock.lock()
+            defer { lock.unlock() }
+            guard let date = locked_formatter.date(from: dateString) else {
+                throw DecodingError.dataCorrupted(
+                    .init(codingPath: [], debugDescription: "Expected date string to be ISO8601-formatted.")
+                )
+            }
+            return date
+        }
+    }
 
-    /// The lock protecting the formatter.
-    private let lock: NSLock
+    @available(macOS 12, *)
+    /// A transcoder using `Date.ISO8601FormatStyle` for encoding and decoding which
+    /// is significantly faster than `DateFormatterTranscoder`.
+    private struct DateFormatStyleTranscoder: DateTranscoder {
+        private let formatStyle: Date.ISO8601FormatStyle
 
-    /// The underlying date formatter.
-    private let locked_formatter: ISO8601DateFormatter
+        init(formatStyle: Date.ISO8601FormatStyle) {
+            self.formatStyle = formatStyle
+        }
+
+        func encode(_ date: Date) throws -> String {
+            date.formatted(formatStyle)
+        }
+
+        func decode(_ dateString: String) throws -> Date {
+            try formatStyle.parse(dateString)
+        }
+    }
+
+    private let dateTranscoder: any DateTranscoder
 
     /// Creates a new transcoder with the provided options.
     /// - Parameter options: Options to override the default ones. If you provide nil here, the default options
     ///   are used.
+    @available(macOS, deprecated: 12, message: "Use .init(formatStyle:) instead.")
     public init(options: ISO8601DateFormatter.Options? = nil) {
-        let formatter = ISO8601DateFormatter()
-        if let options { formatter.formatOptions = options }
-        lock = NSLock()
-        lock.name = "com.apple.swift-openapi-generator.runtime.ISO8601DateTranscoder"
-        locked_formatter = formatter
+        self.dateTranscoder = DateFormatterTranscoder(options: options)
+    }
+
+    /// Creates a new transcoder with the given ISO8601 format style.
+    /// - Parameter formatStyle: The format style for encoding/decoding dates. Defaults to `Date.ISO8601FormatStyle()`.
+    @available(macOS 12.0, *)
+    public init(formatStyle: Date.ISO8601FormatStyle) {
+        self.dateTranscoder = DateFormatStyleTranscoder(formatStyle: formatStyle)
     }
 
     /// Creates and returns an ISO 8601 formatted string representation of the specified date.
     public func encode(_ date: Date) throws -> String {
-        lock.lock()
-        defer { lock.unlock() }
-        return locked_formatter.string(from: date)
+        try self.dateTranscoder.encode(date)
     }
 
     /// Creates and returns a date object from the specified ISO 8601 formatted string representation.
     public func decode(_ dateString: String) throws -> Date {
-        lock.lock()
-        defer { lock.unlock() }
-        guard let date = locked_formatter.date(from: dateString) else {
-            throw DecodingError.dataCorrupted(
-                .init(codingPath: [], debugDescription: "Expected date string to be ISO8601-formatted.")
-            )
-        }
-        return date
+        try self.dateTranscoder.decode(dateString)
     }
 }
 
@@ -70,7 +113,17 @@ extension DateTranscoder where Self == ISO8601DateTranscoder {
 
     /// A transcoder that transcodes dates as ISO-8601–formatted string (in RFC 3339 format) with fractional seconds.
     public static var iso8601WithFractionalSeconds: Self {
-        ISO8601DateTranscoder(options: [.withInternetDateTime, .withFractionalSeconds])
+        if #available(macOS 12, *) {
+            let formatStyle = Date.ISO8601FormatStyle(
+                dateSeparator: .dash,
+                timeSeparator: .colon,
+                timeZoneSeparator: .colon,
+                includingFractionalSeconds: true
+            )
+            return ISO8601DateTranscoder(formatStyle: formatStyle)
+        } else {
+            return ISO8601DateTranscoder(options: [.withInternetDateTime, .withFractionalSeconds])
+        }
     }
 }