apply swiftformat

Examples/Foundation/Lambda.swift

@@ -122,8 +122,7 @@ struct ExchangeRatesCalculator {
                           monthIndex: Array<Date>.Index,
                           currencies: [String],
                           state: [Date: ExchangeRates],
-                          callback: @escaping ((Result<[Date: ExchangeRates], Swift.Error>) -> Void))
-    {
+                          callback: @escaping ((Result<[Date: ExchangeRates], Swift.Error>) -> Void)) {
         if monthIndex == months.count {
             return callback(.success(state))
         }
@@ -182,7 +181,7 @@ struct ExchangeRatesCalculator {
             interval = nil
         }
 
-        let ratesByCurrencyCode: [String: Decimal?] = Dictionary(uniqueKeysWithValues: try currencyCodes.map {
+        let ratesByCurrencyCode: [String: Decimal?] = try Dictionary(uniqueKeysWithValues: currencyCodes.map {
             let xpathCurrency = $0.replacingOccurrences(of: "'", with: "&apos;")
             if let rateString = try document.nodes(forXPath: "/exchangeRateMonthList/exchangeRate/currencyCode[text()='\(xpathCurrency)']/../rateNew/text()").first?.stringValue,
                // We must parse the decimal data using the UK locale, not the system one.

Examples/LocalDebugging/MyApp/MyApp/ContentView.swift

@@ -23,35 +23,35 @@ struct ContentView: View {
 
     var body: some View {
         VStack(alignment: .leading, spacing: 20) {
-            TextField("Username", text: $name)
-            SecureField("Password", text: $password)
-            let inputIncomplete = name.isEmpty || password.isEmpty
+            TextField("Username", text: self.$name)
+            SecureField("Password", text: self.$password)
+            let inputIncomplete = self.name.isEmpty || self.password.isEmpty
             Button {
                 Task {
-                    isLoading = true
+                    self.isLoading = true
                     do {
-                        response = try await self.register()
+                        self.response = try await self.register()
                     } catch {
-                        response = error.localizedDescription
+                        self.response = error.localizedDescription
                     }
-                    isLoading = false
+                    self.isLoading = false
                 }
             } label: {
                 Text("Register")
                     .padding()
                     .foregroundColor(.white)
                     .background(.black)
                     .border(.black, width: 2)
-                    .opacity(isLoading ? 0 : 1)
+                    .opacity(self.isLoading ? 0 : 1)
                     .overlay {
-                        if isLoading {
+                        if self.isLoading {
                             ProgressView()
                         }
                     }
             }
-            .disabled(inputIncomplete || isLoading)
+            .disabled(inputIncomplete || self.isLoading)
             .opacity(inputIncomplete ? 0.5 : 1)
-            Text(response)
+            Text(self.response)
         }.padding(100)
     }
 

Package.swift

@@ -23,7 +23,7 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.67.0")),
         .package(url: "https://github.com/apple/swift-log.git", .upToNextMajor(from: "1.5.4")),
-        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-docc-plugin", exact: "1.3.0"),
     ],
     targets: [
         .target(name: "AWSLambdaRuntime", dependencies: [

Package@swift-5.7.swift

@@ -24,7 +24,7 @@ let package = Package(
         .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.43.1")),
         .package(url: "https://github.com/apple/swift-log.git", .upToNextMajor(from: "1.4.2")),
         .package(url: "https://github.com/swift-server/swift-backtrace.git", .upToNextMajor(from: "1.2.3")),
-        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-docc-plugin", exact: "1.3.0"),
     ],
     targets: [
         .target(name: "AWSLambdaRuntime", dependencies: [

Package@swift-5.8.swift

@@ -24,7 +24,7 @@ let package = Package(
         .package(url: "https://github.com/apple/swift-nio.git", .upToNextMajor(from: "2.43.1")),
         .package(url: "https://github.com/apple/swift-log.git", .upToNextMajor(from: "1.4.2")),
         .package(url: "https://github.com/swift-server/swift-backtrace.git", .upToNextMajor(from: "1.2.3")),
-        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-docc-plugin", exact: "1.3.0"),
     ],
     targets: [
         .target(name: "AWSLambdaRuntime", dependencies: [

Sources/AWSLambdaRuntimeCore/ControlPlaneRequest.swift

@@ -66,7 +66,7 @@ struct ErrorResponse: Hashable, Codable {
 }
 
 extension ErrorResponse {
-    internal func toJSONBytes() -> [UInt8] {
+    func toJSONBytes() -> [UInt8] {
         var bytes = [UInt8]()
         bytes.append(UInt8(ascii: "{"))
         bytes.append(contentsOf: #""errorType":"#.utf8)

Sources/AWSLambdaRuntimeCore/DetachedTasks.swift

@@ -12,19 +12,18 @@
 //
 //===----------------------------------------------------------------------===//
 import Foundation
+import Logging
 import NIOConcurrencyHelpers
 import NIOCore
-import Logging
 
 /// A container that allows tasks to finish after a synchronous invocation
 /// has produced its response.
 actor DetachedTasksContainer: Sendable {
-
     struct Context: Sendable {
         let eventLoop: EventLoop
         let logger: Logger
     }
-    
+
     private var context: Context
     private var storage: [RegistrationKey: EventLoopFuture<Void>] = [:]
 
@@ -40,17 +39,17 @@ actor DetachedTasksContainer: Sendable {
     /// - Returns: A `RegistrationKey` for the registered task.
     func detached(task: @Sendable @escaping () async -> Void) {
         let key = RegistrationKey()
-        let promise = context.eventLoop.makePromise(of: Void.self)
+        let promise = self.context.eventLoop.makePromise(of: Void.self)
         promise.completeWithTask(task)
-        let task = promise.futureResult.always { [weak self] result in
+        let task = promise.futureResult.always { [weak self] _ in
             guard let self else { return }
             Task {
                 await self.removeTask(forKey: key)
             }
         }
         self.storage[key] = task
     }
-    
+
     func removeTask(forKey key: RegistrationKey) {
         self.storage.removeValue(forKey: key)
     }
@@ -59,9 +58,9 @@ actor DetachedTasksContainer: Sendable {
     ///
     /// - Returns: An `EventLoopFuture<Void>` that completes when all tasks have finished.
     func awaitAll() -> EventLoopFuture<Void> {
-        let tasks = storage.values
+        let tasks = self.storage.values
         if tasks.isEmpty {
-            return context.eventLoop.makeSucceededVoidFuture()
+            return self.context.eventLoop.makeSucceededVoidFuture()
         } else {
             let context = context
             return EventLoopFuture.andAllComplete(Array(tasks), on: context.eventLoop).flatMap { [weak self] in

Sources/AWSLambdaRuntimeCore/HTTPClient.swift

@@ -20,7 +20,7 @@ import NIOPosix
 /// A barebone HTTP client to interact with AWS Runtime Engine which is an HTTP server.
 /// Note that Lambda Runtime API dictate that only one requests runs at a time.
 /// This means we can avoid locks and other concurrency concern we would otherwise need to build into the client
-internal final class HTTPClient {
+final class HTTPClient {
     private let eventLoop: EventLoop
     private let configuration: LambdaConfiguration.RuntimeEngine
     private let targetHost: String
@@ -120,7 +120,7 @@ internal final class HTTPClient {
         }
     }
 
-    internal struct Request: Equatable {
+    struct Request: Equatable {
         let url: String
         let method: HTTPMethod
         let targetHost: String
@@ -138,14 +138,14 @@ internal final class HTTPClient {
         }
     }
 
-    internal struct Response: Equatable {
+    struct Response: Equatable {
         var version: HTTPVersion
         var status: HTTPResponseStatus
         var headers: HTTPHeaders
         var body: ByteBuffer?
     }
 
-    internal enum Errors: Error {
+    enum Errors: Error {
         case connectionResetByPeer
         case timeout
         case cancelled
@@ -277,6 +277,7 @@ private final class LambdaChannelHandler: ChannelDuplexHandler {
         switch self.state {
         case .idle:
             break
+
         case .running(let promise, let timeout):
             self.state = .idle
             timeout?.cancel()

Sources/AWSLambdaRuntimeCore/Lambda+LocalServer.swift

@@ -36,7 +36,7 @@ extension Lambda {
     ///     - body: Code to run within the context of the mock server. Typically this would be a Lambda.run function call.
     ///
     /// - note: This API is designed strictly for local testing and is behind a DEBUG flag
-    internal static func withLocalServer<Value>(invocationEndpoint: String? = nil, _ body: @escaping () -> Value) throws -> Value {
+    static func withLocalServer<Value>(invocationEndpoint: String? = nil, _ body: @escaping () -> Value) throws -> Value {
         let server = LocalLambda.Server(invocationEndpoint: invocationEndpoint)
         try server.start().wait()
         defer { try! server.stop() }

Sources/AWSLambdaRuntimeCore/Lambda.swift

@@ -40,11 +40,11 @@ public enum Lambda {
     ///     - handlerType: The Handler to create and invoke.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    internal static func run<Handler: SimpleLambdaHandler>(
+    static func run<Handler: SimpleLambdaHandler>(
         configuration: LambdaConfiguration = .init(),
         handlerType: Handler.Type
     ) -> Result<Int, Error> {
-        Self.run(configuration: configuration, handlerProvider: CodableSimpleLambdaHandler<Handler>.makeHandler(context:))
+        self.run(configuration: configuration, handlerProvider: CodableSimpleLambdaHandler<Handler>.makeHandler(context:))
     }
 
     /// Run a Lambda defined by implementing the ``LambdaHandler`` protocol.
@@ -56,11 +56,11 @@ public enum Lambda {
     ///     - handlerType: The Handler to create and invoke.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    internal static func run<Handler: LambdaHandler>(
+    static func run<Handler: LambdaHandler>(
         configuration: LambdaConfiguration = .init(),
         handlerType: Handler.Type
     ) -> Result<Int, Error> {
-        Self.run(configuration: configuration, handlerProvider: CodableLambdaHandler<Handler>.makeHandler(context:))
+        self.run(configuration: configuration, handlerProvider: CodableLambdaHandler<Handler>.makeHandler(context:))
     }
 
     /// Run a Lambda defined by implementing the ``EventLoopLambdaHandler`` protocol.
@@ -72,11 +72,11 @@ public enum Lambda {
     ///     - handlerType: The Handler to create and invoke.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    internal static func run<Handler: EventLoopLambdaHandler>(
+    static func run<Handler: EventLoopLambdaHandler>(
         configuration: LambdaConfiguration = .init(),
         handlerType: Handler.Type
     ) -> Result<Int, Error> {
-        Self.run(configuration: configuration, handlerProvider: CodableEventLoopLambdaHandler<Handler>.makeHandler(context:))
+        self.run(configuration: configuration, handlerProvider: CodableEventLoopLambdaHandler<Handler>.makeHandler(context:))
     }
 
     /// Run a Lambda defined by implementing the ``ByteBufferLambdaHandler`` protocol.
@@ -88,11 +88,11 @@ public enum Lambda {
     ///     - handlerType: The Handler to create and invoke.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    internal static func run(
+    static func run(
         configuration: LambdaConfiguration = .init(),
         handlerType: (some ByteBufferLambdaHandler).Type
     ) -> Result<Int, Error> {
-        Self.run(configuration: configuration, handlerProvider: handlerType.makeHandler(context:))
+        self.run(configuration: configuration, handlerProvider: handlerType.makeHandler(context:))
     }
 
     /// Run a Lambda defined by implementing the ``LambdaRuntimeHandler`` protocol.
@@ -101,7 +101,7 @@ public enum Lambda {
     ///     - handlerProvider: A provider of the ``LambdaRuntimeHandler`` to invoke.
     ///
     /// - note: This is a blocking operation that will run forever, as its lifecycle is managed by the AWS Lambda Runtime Engine.
-    internal static func run(
+    static func run(
         configuration: LambdaConfiguration = .init(),
         handlerProvider: @escaping (LambdaInitializationContext) -> EventLoopFuture<some LambdaRuntimeHandler>
     ) -> Result<Int, Error> {

Sources/AWSLambdaRuntimeCore/LambdaConfiguration.swift

@@ -16,7 +16,7 @@ import Dispatch
 import Logging
 import NIOCore
 
-internal struct LambdaConfiguration: CustomStringConvertible {
+struct LambdaConfiguration: CustomStringConvertible {
     let general: General
     let lifecycle: Lifecycle
     let runtimeEngine: RuntimeEngine

Sources/AWSLambdaRuntimeCore/LambdaContext.swift

@@ -197,19 +197,18 @@ public struct LambdaContext: CustomDebugStringConvertible, Sendable {
         let remaining = deadline - now
         return .milliseconds(remaining)
     }
-    
+
     var tasks: DetachedTasksContainer {
         self.storage.tasks
     }
-
-
+
     /// Registers a background task that continues running after the synchronous invocation has completed.
     /// This is useful for tasks like flushing metrics or performing clean-up operations without delaying the response.
     ///
     /// - Parameter body: An asynchronous closure that performs the background task.
     /// - Warning: You will be billed for the milliseconds of Lambda execution time until the very last
     ///   background task is finished.
-    public func detachedBackgroundTask(_ body: @escaping @Sendable () async -> ()) {
+    public func detachedBackgroundTask(_ body: @escaping @Sendable () async -> Void) {
         Task {
             await self.tasks.detached(task: body)
         }

Sources/AWSLambdaRuntimeCore/LambdaHandler.swift

@@ -255,7 +255,7 @@ extension LambdaHandler {
 /// unchecked sendable wrapper for the handler
 /// this is safe since lambda runtime is designed to calls the handler serially
 @usableFromInline
-internal struct UncheckedSendableHandler<Underlying: LambdaHandler, Event, Output>: @unchecked Sendable where Event == Underlying.Event, Output == Underlying.Output {
+struct UncheckedSendableHandler<Underlying: LambdaHandler, Event, Output>: @unchecked Sendable where Event == Underlying.Event, Output == Underlying.Output {
     @usableFromInline
     let underlying: Underlying
 

Sources/AWSLambdaRuntimeCore/LambdaRequestID.swift

@@ -217,38 +217,38 @@ extension LambdaRequestID {
         // are safe and we don't need Swifts safety guards.
 
         characters.withUnsafeBufferPointer { lookup in
-            string.0 = lookup[Int(uuid.0 >> 4)]
-            string.1 = lookup[Int(uuid.0 & 0x0F)]
-            string.2 = lookup[Int(uuid.1 >> 4)]
-            string.3 = lookup[Int(uuid.1 & 0x0F)]
-            string.4 = lookup[Int(uuid.2 >> 4)]
-            string.5 = lookup[Int(uuid.2 & 0x0F)]
-            string.6 = lookup[Int(uuid.3 >> 4)]
-            string.7 = lookup[Int(uuid.3 & 0x0F)]
-            string.9 = lookup[Int(uuid.4 >> 4)]
-            string.10 = lookup[Int(uuid.4 & 0x0F)]
-            string.11 = lookup[Int(uuid.5 >> 4)]
-            string.12 = lookup[Int(uuid.5 & 0x0F)]
-            string.14 = lookup[Int(uuid.6 >> 4)]
-            string.15 = lookup[Int(uuid.6 & 0x0F)]
-            string.16 = lookup[Int(uuid.7 >> 4)]
-            string.17 = lookup[Int(uuid.7 & 0x0F)]
-            string.19 = lookup[Int(uuid.8 >> 4)]
-            string.20 = lookup[Int(uuid.8 & 0x0F)]
-            string.21 = lookup[Int(uuid.9 >> 4)]
-            string.22 = lookup[Int(uuid.9 & 0x0F)]
-            string.24 = lookup[Int(uuid.10 >> 4)]
-            string.25 = lookup[Int(uuid.10 & 0x0F)]
-            string.26 = lookup[Int(uuid.11 >> 4)]
-            string.27 = lookup[Int(uuid.11 & 0x0F)]
-            string.28 = lookup[Int(uuid.12 >> 4)]
-            string.29 = lookup[Int(uuid.12 & 0x0F)]
-            string.30 = lookup[Int(uuid.13 >> 4)]
-            string.31 = lookup[Int(uuid.13 & 0x0F)]
-            string.32 = lookup[Int(uuid.14 >> 4)]
-            string.33 = lookup[Int(uuid.14 & 0x0F)]
-            string.34 = lookup[Int(uuid.15 >> 4)]
-            string.35 = lookup[Int(uuid.15 & 0x0F)]
+            string.0 = lookup[Int(self.uuid.0 >> 4)]
+            string.1 = lookup[Int(self.uuid.0 & 0x0F)]
+            string.2 = lookup[Int(self.uuid.1 >> 4)]
+            string.3 = lookup[Int(self.uuid.1 & 0x0F)]
+            string.4 = lookup[Int(self.uuid.2 >> 4)]
+            string.5 = lookup[Int(self.uuid.2 & 0x0F)]
+            string.6 = lookup[Int(self.uuid.3 >> 4)]
+            string.7 = lookup[Int(self.uuid.3 & 0x0F)]
+            string.9 = lookup[Int(self.uuid.4 >> 4)]
+            string.10 = lookup[Int(self.uuid.4 & 0x0F)]
+            string.11 = lookup[Int(self.uuid.5 >> 4)]
+            string.12 = lookup[Int(self.uuid.5 & 0x0F)]
+            string.14 = lookup[Int(self.uuid.6 >> 4)]
+            string.15 = lookup[Int(self.uuid.6 & 0x0F)]
+            string.16 = lookup[Int(self.uuid.7 >> 4)]
+            string.17 = lookup[Int(self.uuid.7 & 0x0F)]
+            string.19 = lookup[Int(self.uuid.8 >> 4)]
+            string.20 = lookup[Int(self.uuid.8 & 0x0F)]
+            string.21 = lookup[Int(self.uuid.9 >> 4)]
+            string.22 = lookup[Int(self.uuid.9 & 0x0F)]
+            string.24 = lookup[Int(self.uuid.10 >> 4)]
+            string.25 = lookup[Int(self.uuid.10 & 0x0F)]
+            string.26 = lookup[Int(self.uuid.11 >> 4)]
+            string.27 = lookup[Int(self.uuid.11 & 0x0F)]
+            string.28 = lookup[Int(self.uuid.12 >> 4)]
+            string.29 = lookup[Int(self.uuid.12 & 0x0F)]
+            string.30 = lookup[Int(self.uuid.13 >> 4)]
+            string.31 = lookup[Int(self.uuid.13 & 0x0F)]
+            string.32 = lookup[Int(self.uuid.14 >> 4)]
+            string.33 = lookup[Int(self.uuid.14 & 0x0F)]
+            string.34 = lookup[Int(self.uuid.15 >> 4)]
+            string.35 = lookup[Int(self.uuid.15 & 0x0F)]
         }
 
         return string