Refactor URL component extraction

Author: karwa

Sources/AsyncHTTPClient/HTTPHandler.swift

@@ -108,63 +108,43 @@ extension HTTPClient {
             private static var hostRestrictedSchemes: Set = ["http", "https"]
             private static var allSupportedSchemes: Set = ["http", "https", "unix", "http+unix", "https+unix"]
 
-            init(forScheme scheme: String) throws {
-                switch scheme {
-                case "http", "https": self = .host
-                case "unix": self = .unixSocket(.baseURL)
-                case "http+unix": self = .unixSocket(.http_unix)
-                case "https+unix": self = .unixSocket(.https_unix)
-                default:
-                    throw HTTPClientError.unsupportedScheme(scheme)
-                }
-            }
+            func supportsRedirects(to scheme: String?) -> Bool {
+                guard let scheme = scheme?.lowercased() else { return false }
 
-            func hostFromURL(_ url: URL) throws -> String {
                 switch self {
                 case .host:
-                    guard let host = url.host else {
-                        throw HTTPClientError.emptyHost
-                    }
-                    return host
+                    return Kind.hostRestrictedSchemes.contains(scheme)
                 case .unixSocket:
-                    return ""
+                    return Kind.allSupportedSchemes.contains(scheme)
                 }
             }
+        }
 
-            func socketPathFromURL(_ url: URL) throws -> String {
-                switch self {
-                case .unixSocket(.baseURL):
-                    return url.baseURL?.path ?? url.path
-                case .unixSocket:
-                    guard let socketPath = url.host else {
-                        throw HTTPClientError.missingSocketPath
-                    }
-                    return socketPath
-                case .host:
-                    return ""
+        static func deconstructURL(
+          _ url: URL
+        ) throws -> (kind: Kind, hostname: String, socketPath: String, uri: String) {
+            let scheme = url.scheme?.lowercased()
+            switch scheme {
+            case "http", "https":
+                guard let host = url.host, !host.isEmpty else {
+                    throw HTTPClientError.emptyHost
                 }
-            }
-
-            func uriFromURL(_ url: URL) -> String {
-                switch self {
-                case .host:
-                    return url.uri
-                case .unixSocket(.baseURL):
-                    return url.baseURL != nil ? url.uri : "/"
-                case .unixSocket:
-                    return url.uri
+                return (.host, host, "", url.uri)
+            case "http+unix", "https+unix":
+                guard let socketPath = url.host, !socketPath.isEmpty else {
+                    throw HTTPClientError.missingSocketPath
                 }
-            }
-
-            func supportsRedirects(to scheme: String?) -> Bool {
-                guard let scheme = scheme?.lowercased() else { return false }
-
-                switch self {
-                case .host:
-                    return Kind.hostRestrictedSchemes.contains(scheme)
-                case .unixSocket:
-                    return Kind.allSupportedSchemes.contains(scheme)
+                let unixKind: Kind.UnixScheme = (scheme == "http+unix") ? .http_unix : .https_unix
+                return (.unixSocket(unixKind), "", socketPath, url.uri)
+            case "unix":
+                let socketPath = url.baseURL?.path ?? url.path
+                let uri = url.baseURL != nil ? url.uri : "/"
+                guard !socketPath.isEmpty else {
+                    throw HTTPClientError.missingSocketPath
                 }
+                return (.unixSocket(.baseURL), "", socketPath, uri)
+            default:
+                throw HTTPClientError.unsupportedScheme(url.scheme ?? "")
             }
         }
 
@@ -267,12 +247,7 @@ extension HTTPClient {
             guard let scheme = url.scheme?.lowercased() else {
                 throw HTTPClientError.emptyScheme
             }
-
-            self.kind = try Kind(forScheme: scheme)
-            self.host = try self.kind.hostFromURL(url)
-            self.socketPath = try self.kind.socketPathFromURL(url)
-            self.uri = self.kind.uriFromURL(url)
-
+            (self.kind, self.host, self.socketPath, self.uri) = try Self.deconstructURL(url)
             self.redirectState = nil
             self.url = url
             self.method = method