apply swiftformat (#342)

* apply swiftformat

* update dep on Swift Docc to v1.3.0

* force usage of swift docc plugin 1.3.0

Author: sebsto

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> {