SwiftFormat --ifdef no-indent (#494)

* SwiftFormat --ifdef no-indent

* update `generate_linux_tests.rb` to use new indention rule

Author: dnadoba

.swiftformat

@@ -9,7 +9,7 @@
 --patternlet inline
 --ranges nospace
 --stripunusedargs unnamed-only
---ifdef indent
+--ifdef no-indent
 --extensionacl on-declarations
 --disable typeSugar # https://github.com/nicklockwood/SwiftFormat/issues/636
 --disable andOperator

Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool+Factory.swift

@@ -21,7 +21,7 @@ import NIOSOCKS
 import NIOSSL
 import NIOTLS
 #if canImport(Network)
-    import NIOTransportServices
+import NIOTransportServices
 #endif
 
 extension HTTPConnectionPool {
@@ -341,18 +341,18 @@ extension HTTPConnectionPool.ConnectionFactory {
 
     private func makePlainBootstrap(deadline: NIODeadline, eventLoop: EventLoop) -> NIOClientTCPBootstrapProtocol {
         #if canImport(Network)
-            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), let tsBootstrap = NIOTSConnectionBootstrap(validatingGroup: eventLoop) {
-                return tsBootstrap
-                    .connectTimeout(deadline - NIODeadline.now())
-                    .channelInitializer { channel in
-                        do {
-                            try channel.pipeline.syncOperations.addHandler(HTTPClient.NWErrorHandler())
-                            return channel.eventLoop.makeSucceededVoidFuture()
-                        } catch {
-                            return channel.eventLoop.makeFailedFuture(error)
-                        }
+        if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), let tsBootstrap = NIOTSConnectionBootstrap(validatingGroup: eventLoop) {
+            return tsBootstrap
+                .connectTimeout(deadline - NIODeadline.now())
+                .channelInitializer { channel in
+                    do {
+                        try channel.pipeline.syncOperations.addHandler(HTTPClient.NWErrorHandler())
+                        return channel.eventLoop.makeSucceededVoidFuture()
+                    } catch {
+                        return channel.eventLoop.makeFailedFuture(error)
                     }
-            }
+                }
+        }
         #endif
 
         if let nioBootstrap = ClientBootstrap(validatingGroup: eventLoop) {
@@ -392,10 +392,10 @@ extension HTTPConnectionPool.ConnectionFactory {
         }
 
         #if canImport(Network)
-            // If NIOTransportSecurity is used, we want to map NWErrors into NWPOsixErrors or NWTLSError.
-            channelFuture = channelFuture.flatMapErrorThrowing { error in
-                throw HTTPClient.NWErrorHandler.translateError(error)
-            }
+        // If NIOTransportSecurity is used, we want to map NWErrors into NWPOsixErrors or NWTLSError.
+        channelFuture = channelFuture.flatMapErrorThrowing { error in
+            throw HTTPClient.NWErrorHandler.translateError(error)
+        }
         #endif
 
         return channelFuture
@@ -416,29 +416,29 @@ extension HTTPConnectionPool.ConnectionFactory {
         }
 
         #if canImport(Network)
-            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), let tsBootstrap = NIOTSConnectionBootstrap(validatingGroup: eventLoop) {
-                // create NIOClientTCPBootstrap with NIOTS TLS provider
-                let bootstrapFuture = tlsConfig.getNWProtocolTLSOptions(on: eventLoop).map {
-                    options -> NIOClientTCPBootstrapProtocol in
-
-                    tsBootstrap
-                        .connectTimeout(deadline - NIODeadline.now())
-                        .tlsOptions(options)
-                        .channelInitializer { channel in
-                            do {
-                                try channel.pipeline.syncOperations.addHandler(HTTPClient.NWErrorHandler())
-                                // we don't need to set a TLS deadline for NIOTS connections, since the
-                                // TLS handshake is part of the TS connection bootstrap. If the TLS
-                                // handshake times out the complete connection creation will be failed.
-                                try channel.pipeline.syncOperations.addHandler(TLSEventsHandler(deadline: nil))
-                                return channel.eventLoop.makeSucceededVoidFuture()
-                            } catch {
-                                return channel.eventLoop.makeFailedFuture(error)
-                            }
-                        } as NIOClientTCPBootstrapProtocol
-                }
-                return bootstrapFuture
+        if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), let tsBootstrap = NIOTSConnectionBootstrap(validatingGroup: eventLoop) {
+            // create NIOClientTCPBootstrap with NIOTS TLS provider
+            let bootstrapFuture = tlsConfig.getNWProtocolTLSOptions(on: eventLoop).map {
+                options -> NIOClientTCPBootstrapProtocol in
+
+                tsBootstrap
+                    .connectTimeout(deadline - NIODeadline.now())
+                    .tlsOptions(options)
+                    .channelInitializer { channel in
+                        do {
+                            try channel.pipeline.syncOperations.addHandler(HTTPClient.NWErrorHandler())
+                            // we don't need to set a TLS deadline for NIOTS connections, since the
+                            // TLS handshake is part of the TS connection bootstrap. If the TLS
+                            // handshake times out the complete connection creation will be failed.
+                            try channel.pipeline.syncOperations.addHandler(TLSEventsHandler(deadline: nil))
+                            return channel.eventLoop.makeSucceededVoidFuture()
+                        } catch {
+                            return channel.eventLoop.makeFailedFuture(error)
+                        }
+                    } as NIOClientTCPBootstrapProtocol
             }
+            return bootstrapFuture
+        }
         #endif
 
         let host = self.key.host

Sources/AsyncHTTPClient/ConnectionPool/State Machine/HTTPConnectionPool+Backoff.swift

@@ -14,9 +14,9 @@
 
 import NIOCore
 #if canImport(Darwin)
-    import func Darwin.pow
+import func Darwin.pow
 #else
-    import func Glibc.pow
+import func Glibc.pow
 #endif
 
 extension HTTPConnectionPool {

Sources/AsyncHTTPClient/HTTPClient.swift

@@ -99,13 +99,13 @@ public class HTTPClient {
             self.eventLoopGroup = group
         case .createNew:
             #if canImport(Network)
-                if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *) {
-                    self.eventLoopGroup = NIOTSEventLoopGroup()
-                } else {
-                    self.eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-                }
-            #else
+            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *) {
+                self.eventLoopGroup = NIOTSEventLoopGroup()
+            } else {
                 self.eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+            }
+            #else
+            self.eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
             #endif
         }
         self.configuration = configuration

Sources/AsyncHTTPClient/NIOTransportServices/NWErrorHandler.swift

@@ -13,51 +13,51 @@
 //===----------------------------------------------------------------------===//
 
 #if canImport(Network)
-    import Network
+import Network
 #endif
 import NIOCore
 import NIOHTTP1
 import NIOTransportServices
 
 extension HTTPClient {
     #if canImport(Network)
-        public struct NWPOSIXError: Error, CustomStringConvertible {
-            /// POSIX error code (enum)
-            public let errorCode: POSIXErrorCode
+    public struct NWPOSIXError: Error, CustomStringConvertible {
+        /// POSIX error code (enum)
+        public let errorCode: POSIXErrorCode
 
-            /// actual reason, in human readable form
-            private let reason: String
+        /// actual reason, in human readable form
+        private let reason: String
 
-            /// Initialise a NWPOSIXError
-            /// - Parameters:
-            ///   - errorType: posix error type
-            ///   - reason: String describing reason for error
-            public init(_ errorCode: POSIXErrorCode, reason: String) {
-                self.errorCode = errorCode
-                self.reason = reason
-            }
-
-            public var description: String { return self.reason }
+        /// Initialise a NWPOSIXError
+        /// - Parameters:
+        ///   - errorType: posix error type
+        ///   - reason: String describing reason for error
+        public init(_ errorCode: POSIXErrorCode, reason: String) {
+            self.errorCode = errorCode
+            self.reason = reason
         }
 
-        public struct NWTLSError: Error, CustomStringConvertible {
-            /// TLS error status. List of TLS errors can be found in <Security/SecureTransport.h>
-            public let status: OSStatus
+        public var description: String { return self.reason }
+    }
 
-            /// actual reason, in human readable form
-            private let reason: String
+    public struct NWTLSError: Error, CustomStringConvertible {
+        /// TLS error status. List of TLS errors can be found in <Security/SecureTransport.h>
+        public let status: OSStatus
 
-            /// initialise a NWTLSError
-            /// - Parameters:
-            ///   - status: TLS status
-            ///   - reason: String describing reason for error
-            public init(_ status: OSStatus, reason: String) {
-                self.status = status
-                self.reason = reason
-            }
+        /// actual reason, in human readable form
+        private let reason: String
 
-            public var description: String { return self.reason }
+        /// initialise a NWTLSError
+        /// - Parameters:
+        ///   - status: TLS status
+        ///   - reason: String describing reason for error
+        public init(_ status: OSStatus, reason: String) {
+            self.status = status
+            self.reason = reason
         }
+
+        public var description: String { return self.reason }
+    }
     #endif
 
     class NWErrorHandler: ChannelInboundHandler {
@@ -69,23 +69,23 @@ extension HTTPClient {
 
         static func translateError(_ error: Error) -> Error {
             #if canImport(Network)
-                if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *) {
-                    if let error = error as? NWError {
-                        switch error {
-                        case .tls(let status):
-                            return NWTLSError(status, reason: error.localizedDescription)
-                        case .posix(let errorCode):
-                            return NWPOSIXError(errorCode, reason: error.localizedDescription)
-                        default:
-                            return error
-                        }
+            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *) {
+                if let error = error as? NWError {
+                    switch error {
+                    case .tls(let status):
+                        return NWTLSError(status, reason: error.localizedDescription)
+                    case .posix(let errorCode):
+                        return NWPOSIXError(errorCode, reason: error.localizedDescription)
+                    default:
+                        return error
                     }
-                    return error
-                } else {
-                    preconditionFailure("\(self) used on a non-NIOTS Channel")
                 }
-            #else
+                return error
+            } else {
                 preconditionFailure("\(self) used on a non-NIOTS Channel")
+            }
+            #else
+            preconditionFailure("\(self) used on a non-NIOTS Channel")
             #endif
         }
     }