Docs

Author: tevelee

.github/workflows/docs.yml

@@ -0,0 +1,45 @@
+name: Documentation
+
+on:
+  push:
+    branches:
+      - main
+
+env:
+  SWIFT_VERSION: 5.6
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Package
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Download Swift
+        run: wget -q https://download.swift.org/swift-$SWIFT_VERSION-release/ubuntu2004/swift-$SWIFT_VERSION-RELEASE/swift-$SWIFT_VERSION-RELEASE-ubuntu20.04.tar.gz
+      - name: Extract Swift
+        run: tar xzf swift-$SWIFT_VERSION-RELEASE-ubuntu20.04.tar.gz
+      - name: Add Swift toolchain to PATH
+        run: |
+          echo "$GITHUB_WORKSPACE/swift-$SWIFT_VERSION-RELEASE-ubuntu20.04/usr/bin" >> $GITHUB_PATH
+
+      - name: Build documentation
+        run: >
+          swift package --allow-writing-to-directory docs \
+            generate-documentation \
+            --target AsyncHTTP \
+            --disable-indexing \
+            --transform-for-static-hosting \
+            --hosting-base-path /AsyncHTTP \
+            --output-path docs
+      
+      - name: Publish documentation to GitHub Pages
+        uses: JamesIves/github-pages-deploy-action@4.1.7
+        with:
+          branch: gh-pages
+          folder: docs
+          git-config-name: László Teveli
+          git-config-email: tevelee@gmail.com
+

.gitignore

@@ -4,4 +4,5 @@
 /Packages
 *.xcodeproj
 xcuserdata/
-.swiftpm
+.swiftpm
+/docs

Package.resolved

@@ -0,0 +1,14 @@
+{
+  "pins" : [
+    {
+      "identity" : "swift-docc-plugin",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-docc-plugin",
+      "state" : {
+        "revision" : "3303b164430d9a7055ba484c8ead67a52f7b74f6",
+        "version" : "1.0.0"
+      }
+    }
+  ],
+  "version" : 2
+}

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.5
+// swift-tools-version:5.6
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -12,7 +12,9 @@ let package = Package(
     products: [
         .library(name: "AsyncHTTP", targets: ["AsyncHTTP"]),
     ],
-    dependencies: [],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
+    ],
     targets: [
         .target(name: "AsyncHTTP", dependencies: []),
         .testTarget(name: "AsyncHTTPTests", dependencies: ["AsyncHTTP"]),

README.md

@@ -15,15 +15,15 @@ let request = try HTTPRequest().configured { request in
     request.retryStrategy = .immediately(maximumNumberOfAttempts: 3)
 }
 
-let loader: some HTTPLoader = URLSession.shared.http
+let loader: some HTTPLoader = URLSession.shared.httpLoader()
     .applyServerEnvironment()
     .applyTimeout(default: 30)
     .applyRetryStrategy()
     .deduplicate()
     .throttle(maximumNumberOfRequests: 2)
 
 let response: HTTPResponse = try await loader.load(request)
-let body: MyResponseStruct = response.jsonBody()
+let body: MyResponseStruct = try response.jsonBody()
 
 print(request.formatted())
 print(response.formatted())

Sources/AsyncHTTP/Documentation.docc/Documentation.md

@@ -0,0 +1,74 @@
+# ``AsyncHTTP``
+
+Generic Swift networking library with async/await
+
+## Overview
+
+AsyncHTTP
+
+## Topics
+
+### Requests
+
+- ``HTTPRequest``
+- ``HTTPRequestOption``
+- ``HTTPRequestBody``
+
+### Loading Requests
+
+- ``Loader``
+- ``Loaders``
+- ``AnyLoader``
+- ``HTTPLoader``
+- ``CompositeLoader``
+- ``HTTPResponse``
+
+### HTTP
+
+- ``HTTPMethod``
+- ``HTTPHeader``
+- ``AuthorizationHeader``
+- ``HTTPStatus``
+- ``HTTPVersion``
+- ``MIMEType``
+- ``URIScheme``
+
+### Timeout
+
+- ``Timeout``
+- ``TimeoutOption``
+
+### Retry Strategy
+
+- ``RetryStrategy``
+- ``RetryStrategyWrapper``
+- ``RetryStrategyOption``
+- ``Backoff``
+
+### Server Environment
+
+- ``ServerEnvironment``
+- ``ServerEnvironmentOption``
+
+### Identifying Requests
+
+- ``HTTPRequestIdentifier``
+- ``HTTPRequestIdentifierOption``
+
+### Formatting
+
+- ``Formatter``
+- ``CURLHTTPRequestFormatter``
+- ``StandardHTTPRequestFormatter``
+- ``StandardHTTPResponseFormatter``
+- ``Formattible``
+- ``DefaultFormattible``
+
+### Utils
+
+- ``Converted``
+- ``ConversionStrategy``
+- ``TwoWayConversionStrategy``
+- ``DecoderStrategy``
+- ``EncoderStrategy``
+- ``HTTPFormattible``

Sources/AsyncHTTP/Loader.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
 
 public protocol Loader {
     associatedtype Input

Sources/AsyncHTTP/Loaders/Decode.swift

@@ -1,4 +1,6 @@
+#if canImport(Combine)
 import Combine
+#endif
 import Foundation
 
 extension Loader where Output: Decodable {

Sources/AsyncHTTP/Loaders/HTTP.swift

@@ -1,7 +1,10 @@
 import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
 
 extension Loader where Input == URLRequest, Output == (Data, URLResponse) {
-    public func http(modify: ((HTTPRequest, inout URLRequest) -> Void)? = nil) -> Loaders.HTTP<Self> { .init(loader: self, modify: modify) }
+    public func httpLoader(modify: ((HTTPRequest, inout URLRequest) -> Void)? = nil) -> Loaders.HTTP<Self> { .init(loader: self, modify: modify) }
 }
 
 public protocol HTTPLoader: Loader where Input == HTTPRequest, Output == HTTPResponse {}

Sources/AsyncHTTP/Loaders/URLSession.swift

@@ -1,12 +1,30 @@
 import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
 
 extension URLSession {
-    public var data: Loaders.URLSessionData {
+    func data(for urlRequest: URLRequest) async throws -> (Data, URLResponse) {
+        try await withCheckedThrowingContinuation { continuation in
+            let task = dataTask(with: urlRequest) { data, response, error in
+                guard let data = data, let response = response else {
+                    let error = error ?? URLError(.badServerResponse)
+                    return continuation.resume(throwing: error)
+                }
+                continuation.resume(returning: (data, response))
+            }
+            task.resume()
+        }
+    }
+}
+#endif
+
+extension URLSession {
+    public var dataLoader: Loaders.URLSessionData {
         .init(urlSession: self)
     }
 
-    public var http: Loaders.HTTP<Loaders.URLSessionData> {
-        data.http()
+    public var httpLoader: Loaders.HTTP<Loaders.URLSessionData> {
+        dataLoader.httpLoader()
     }
 }
 

Sources/AsyncHTTP/Model/HTTPRequest.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
 
 public struct HTTPRequest: Equatable, Hashable, Sendable {
     public var method: HTTPMethod

Sources/AsyncHTTP/Model/HTTPRequestBody.swift

@@ -1,4 +1,6 @@
+#if canImport(Combine)
 import Combine
+#endif
 import Foundation
 
 public struct HTTPRequestBody: Equatable, Hashable, Sendable {

Sources/AsyncHTTP/Model/HTTPResponse.swift

@@ -1,5 +1,10 @@
+#if canImport(Combine)
 import Combine
+#endif
 import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
 
 public struct HTTPResponse {
     public let request: HTTPRequest

Sources/AsyncHTTP/Model/HTTPStatus.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
 
 public struct HTTPStatus: Equatable, Hashable, Codable {
     public let code: Int

Sources/AsyncHTTP/Plugins/IdentifyRequests.swift

@@ -20,21 +20,19 @@ extension HTTPRequest: Identifiable {
 }
 
 extension Loader {
-    public func identifyRequests(generateIdentifier: @escaping (HTTPRequest) -> String = generateUUID) -> Loaders.ApplyRequestIdentity<Self> where Input == HTTPRequest {
+    public func identifyRequests(generateIdentifier: @escaping (HTTPRequest) -> String = { _ in UUID().uuidString }) -> Loaders.ApplyRequestIdentity<Self> where Input == HTTPRequest {
         .init(loader: self, generateIdentifier: generateIdentifier)
     }
 }
 
-public let generateUUID: (HTTPRequest) -> String = { _ in UUID().uuidString }
 
 extension Loaders {
     public struct ApplyRequestIdentity<Wrapped: Loader>: CompositeLoader where Wrapped.Input == HTTPRequest {
-
         private let loader: Wrapped
         private let generateIdentifier: (HTTPRequest) -> String
 
         init(loader: Wrapped,
-             generateIdentifier: @escaping (HTTPRequest) -> String = generateUUID) {
+             generateIdentifier: @escaping (HTTPRequest) -> String = { _ in UUID().uuidString }) {
             self.loader = loader
             self.generateIdentifier = generateIdentifier
         }

Sources/AsyncHTTP/Plugins/Retry.swift

@@ -10,13 +10,16 @@ public enum RetryStrategyOption: HTTPRequestOption {
 
 public struct RetryStrategyWrapper: Hashable {
     let wrapped: RetryStrategy
+    private var objectID: ObjectIdentifier {
+        ObjectIdentifier(type(of: wrapped))
+    }
 
     public func hash(into hasher: inout Hasher) {
-        hasher.combine(ObjectIdentifier(type(of: wrapped)))
+        hasher.combine(objectID)
     }
 
     public static func == (lhs: RetryStrategyWrapper, rhs: RetryStrategyWrapper) -> Bool {
-        ObjectIdentifier(lhs.wrapped) == ObjectIdentifier(lhs.wrapped)
+        lhs.objectID == rhs.objectID
     }
 }
 

Sources/AsyncHTTP/Utils/Combine.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+#if !canImport(Combine)
+public protocol TopLevelDecoder {
+    associatedtype Input
+
+    func decode<T: Decodable>(_ type: T.Type, from: Input) throws -> T
+}
+
+extension JSONDecoder: TopLevelDecoder {
+    public typealias Input = Data
+}
+
+public protocol TopLevelEncoder {
+    associatedtype Output
+
+    func encode<T: Encodable>(_ value: T) throws -> Output
+}
+
+extension JSONEncoder: TopLevelEncoder {
+    public typealias Output = Data
+}
+#endif