Fix formatting

yim-lee · yim-lee · commit d728e49b9059 · 2021-10-04T10:22:07.000-07:00
diff --git a/Sources/Basics/AuthorizationProvider.swift b/Sources/Basics/AuthorizationProvider.swift
@@ -28,8 +28,8 @@ public enum AuthorizationProviderError: Error {
     case other(String)
 }
 
-extension AuthorizationProvider {
-    public func httpAuthorizationHeader(for url: Foundation.URL) -> String? {
+public extension AuthorizationProvider {
+    func httpAuthorizationHeader(for url: Foundation.URL) -> String? {
         guard let (user, password) = self.authentication(for: url) else {
             return nil
         }
@@ -55,9 +55,9 @@ extension Foundation.URL {
 public struct NetrcAuthorizationProvider: AuthorizationProvider {
     let path: AbsolutePath
     private let fileSystem: FileSystem
-    
+
     private var underlying: TSCUtility.Netrc?
-    
+
     var machines: [TSCUtility.Netrc.Machine] {
         self.underlying?.machines ?? []
     }
@@ -67,17 +67,17 @@ public struct NetrcAuthorizationProvider: AuthorizationProvider {
         self.fileSystem = fileSystem
         self.underlying = try Self.load(from: path)
     }
-    
+
     public mutating func addOrUpdate(for url: Foundation.URL, user: String, password: String, callback: @escaping (Result<Void, Error>) -> Void) {
         guard let machine = url.authenticationID else {
             return callback(.failure(AuthorizationProviderError.invalidURLHost))
         }
-        
+
         // Same entry already exists, no need to add or update
         guard self.machines.first(where: { $0.name.lowercased() == machine && $0.login == user && $0.password == password }) == nil else {
             return
         }
-        
+
         do {
             // Append to end of file
             try self.fileSystem.withLock(on: self.path, type: .exclusive) {
@@ -92,13 +92,13 @@ public struct NetrcAuthorizationProvider: AuthorizationProvider {
                     stream.write("\n")
                 }
             }
-            
+
             // At this point the netrc file should exist and non-empty
             guard let netrc = try Self.load(from: self.path) else {
                 throw AuthorizationProviderError.other("Failed to update netrc file at \(self.path)")
             }
             self.underlying = netrc
-            
+
             callback(.success(()))
         } catch {
             callback(.failure(AuthorizationProviderError.other("Failed to update netrc file at \(self.path): \(error)")))
@@ -139,16 +139,16 @@ public struct NetrcAuthorizationProvider: AuthorizationProvider {
 #if canImport(Security)
 public struct KeychainAuthorizationProvider: AuthorizationProvider {
     public init() {}
-    
+
     public func addOrUpdate(for url: Foundation.URL, user: String, password: String, callback: @escaping (Result<Void, Error>) -> Void) {
         guard let server = url.authenticationID else {
             return callback(.failure(AuthorizationProviderError.invalidURLHost))
         }
         guard let passwordData = password.data(using: .utf8) else {
             return callback(.failure(AuthorizationProviderError.cannotEncodePassword))
         }
-        let `protocol` = self.`protocol`(for: url)
-        
+        let `protocol` = self.protocol(for: url)
+
         do {
             if !(try self.update(server: server, protocol: `protocol`, account: user, password: passwordData)) {
                 try self.create(server: server, protocol: `protocol`, account: user, password: passwordData)
@@ -158,17 +158,18 @@ public struct KeychainAuthorizationProvider: AuthorizationProvider {
             callback(.failure(error))
         }
     }
-    
+
     public func authentication(for url: Foundation.URL) -> (user: String, password: String)? {
         guard let server = url.authenticationID else {
             return nil
         }
-        
+
         do {
-            guard let existingItem = try self.search(server: server, protocol: self.`protocol`(for: url)) as? [String : Any],
+            guard let existingItem = try self.search(server: server, protocol: self.protocol(for: url)) as? [String: Any],
                   let passwordData = existingItem[kSecValueData as String] as? Data,
                   let password = String(data: passwordData, encoding: String.Encoding.utf8),
-                  let account = existingItem[kSecAttrAccount as String] as? String else {
+                  let account = existingItem[kSecAttrAccount as String] as? String
+            else {
                 throw AuthorizationProviderError.other("Failed to extract credentials for server \(server) from keychain")
             }
             return (user: account, password: password)
@@ -184,27 +185,27 @@ public struct KeychainAuthorizationProvider: AuthorizationProvider {
             return nil
         }
     }
-    
-    private func create(server: String, `protocol`: CFString, account: String, password: Data) throws {
+
+    private func create(server: String, protocol: CFString, account: String, password: Data) throws {
         let query: [String: Any] = [kSecClass as String: kSecClassInternetPassword,
                                     kSecAttrServer as String: server,
                                     kSecAttrProtocol as String: `protocol`,
                                     kSecAttrAccount as String: account,
                                     kSecValueData as String: password]
-        
+
         let status = SecItemAdd(query as CFDictionary, nil)
         guard status == errSecSuccess else {
             throw AuthorizationProviderError.other("Failed to save credentials for server \(server) to keychain: status \(status)")
         }
     }
-    
-    private func update(server: String, `protocol`: CFString, account: String, password: Data) throws -> Bool {
+
+    private func update(server: String, protocol: CFString, account: String, password: Data) throws -> Bool {
         let query: [String: Any] = [kSecClass as String: kSecClassInternetPassword,
                                     kSecAttrServer as String: server,
                                     kSecAttrProtocol as String: `protocol`]
         let attributes: [String: Any] = [kSecAttrAccount as String: account,
                                          kSecValueData as String: password]
-        
+
         let status = SecItemUpdate(query as CFDictionary, attributes as CFDictionary)
         guard status != errSecItemNotFound else {
             return false
@@ -214,15 +215,15 @@ public struct KeychainAuthorizationProvider: AuthorizationProvider {
         }
         return true
     }
-    
-    private func search(server: String, `protocol`: CFString) throws -> CFTypeRef? {
+
+    private func search(server: String, protocol: CFString) throws -> CFTypeRef? {
         let query: [String: Any] = [kSecClass as String: kSecClassInternetPassword,
                                     kSecAttrServer as String: server,
                                     kSecAttrProtocol as String: `protocol`,
                                     kSecMatchLimit as String: kSecMatchLimitOne,
                                     kSecReturnAttributes as String: true,
                                     kSecReturnData as String: true]
-        
+
         var item: CFTypeRef?
         // Search keychain for server's username and password, if any.
         let status = SecItemCopyMatching(query as CFDictionary, &item)
@@ -232,10 +233,10 @@ public struct KeychainAuthorizationProvider: AuthorizationProvider {
         guard status == errSecSuccess else {
             throw AuthorizationProviderError.other("Failed to find credentials for server \(server) in keychain: status \(status)")
         }
-        
+
         return item
     }
-    
+
     private func `protocol`(for url: Foundation.URL) -> CFString {
         // See https://developer.apple.com/documentation/security/keychain_services/keychain_items/item_attribute_keys_and_values?language=swift
         // for a list of possible values for the `kSecAttrProtocol` attribute.
@@ -253,15 +254,15 @@ public struct KeychainAuthorizationProvider: AuthorizationProvider {
 
 public struct CompositeAuthorizationProvider: AuthorizationProvider {
     private let providers: [AuthorizationProvider]
-    
+
     public init(_ providers: AuthorizationProvider...) {
         self.init(providers)
     }
-    
+
     public init(_ providers: [AuthorizationProvider]) {
         self.providers = providers
     }
-    
+
     public func authentication(for url: Foundation.URL) -> (user: String, password: String)? {
         for provider in self.providers {
             if let authentication = provider.authentication(for: url) {
diff --git a/Tests/BasicsTests/AuthorizationProviderTests.swift b/Tests/BasicsTests/AuthorizationProviderTests.swift
@@ -19,106 +19,106 @@ final class AuthorizationProviderTests: XCTestCase {
         let url = URL(string: "http://\(UUID().uuidString)")!
         let user = UUID().uuidString
         let password = UUID().uuidString
-        
+
         let provider = TestProvider(map: [url: (user: user, password: password)])
         self.assertAuthentication(provider, for: url, expected: (user, password))
     }
-    
+
     func testNetrc() throws {
         try testWithTemporaryDirectory { tmpPath in
             let netrcPath = tmpPath.appending(component: ".netrc")
-            
+
             var provider = try NetrcAuthorizationProvider(path: netrcPath, fileSystem: localFileSystem)
 
             let user = UUID().uuidString
-            
+
             let url = URL(string: "http://\(UUID().uuidString)")!
             let password = UUID().uuidString
-            
+
             let otherURL = URL(string: "https://\(UUID().uuidString)")!
             let otherPassword = UUID().uuidString
-            
+
             // Add
             XCTAssertNoThrow(try tsc_await { callback in provider.addOrUpdate(for: url, user: user, password: password, callback: callback) })
             XCTAssertNoThrow(try tsc_await { callback in provider.addOrUpdate(for: otherURL, user: user, password: otherPassword, callback: callback) })
-            
+
             self.assertAuthentication(provider, for: url, expected: (user, password))
-            
+
             // Update - the new password is appended to the end of file
             let newPassword = UUID().uuidString
             XCTAssertNoThrow(try tsc_await { callback in provider.addOrUpdate(for: url, user: user, password: newPassword, callback: callback) })
-            
+
             // .netrc file now contains two entries for `url`: one with `password` and the other with `newPassword`.
             // `NetrcAuthorizationProvider` returns the first entry it finds.
             self.assertAuthentication(provider, for: url, expected: (user, password))
-            
+
             // Make sure the new entry is saved
             XCTAssertNotNil(provider.machines.first(where: { $0.name == url.host!.lowercased() && $0.login == user && $0.password == newPassword }))
-            
+
             self.assertAuthentication(provider, for: otherURL, expected: (user, otherPassword))
         }
     }
-    
+
     func testKeychain() throws {
         #if !canImport(Security) || !ENABLE_KEYCHAIN_TEST
         try XCTSkipIf(true)
         #else
         let provider = KeychainAuthorizationProvider()
 
         let user = UUID().uuidString
-        
+
         let url = URL(string: "http://\(UUID().uuidString)")!
         let password = UUID().uuidString
-        
+
         let otherURL = URL(string: "https://\(UUID().uuidString)")!
         let otherPassword = UUID().uuidString
-        
+
         // Add
         XCTAssertNoThrow(try tsc_await { callback in provider.addOrUpdate(for: url, user: user, password: password, callback: callback) })
         XCTAssertNoThrow(try tsc_await { callback in provider.addOrUpdate(for: otherURL, user: user, password: otherPassword, callback: callback) })
-        
+
         self.assertAuthentication(provider, for: url, expected: (user, password))
-        
+
         // Update
         let newPassword = UUID().uuidString
         XCTAssertNoThrow(try tsc_await { callback in provider.addOrUpdate(for: url, user: user, password: newPassword, callback: callback) })
-        
+
         // Existing password is updated
         self.assertAuthentication(provider, for: url, expected: (user, newPassword))
-        
+
         self.assertAuthentication(provider, for: otherURL, expected: (user, otherPassword))
         #endif
     }
-    
+
     func testComposite() throws {
         let url = URL(string: "http://\(UUID().uuidString)")!
         let user = UUID().uuidString
         let passwordOne = UUID().uuidString
         let passwordTwo = UUID().uuidString
-        
+
         let providerOne = TestProvider(map: [url: (user: user, password: passwordOne)])
         let providerTwo = TestProvider(map: [url: (user: user, password: passwordTwo)])
-        
+
         do {
             // providerOne's password is returned first
             let provider = CompositeAuthorizationProvider(providerOne, providerTwo)
             self.assertAuthentication(provider, for: url, expected: (user, passwordOne))
         }
-        
+
         do {
             // providerTwo's password is returned first
             let provider = CompositeAuthorizationProvider(providerTwo, providerOne)
             self.assertAuthentication(provider, for: url, expected: (user, passwordTwo))
         }
-        
+
         do {
             // Neither has password
             let unknownURL = URL(string: "http://\(UUID().uuidString)")!
             let provider = CompositeAuthorizationProvider(providerOne, providerTwo)
             XCTAssertNil(provider.authentication(for: unknownURL))
         }
     }
-    
+
     private func assertAuthentication(_ provider: AuthorizationProvider, for url: Foundation.URL, expected: (user: String, password: String)) {
         let authentication = provider.authentication(for: url)
         XCTAssertEqual(authentication?.user, expected.user)
