style: Format code

Author: rakuyoMo

Demo.playground/Pages/Advanced.xcplaygroundpage/Contents.swift

@@ -6,16 +6,17 @@ import Foundation
 
 import APIWrapper
 
-/*:
- The `RaAPIWrapper` is extremely extensible.
- You can work with the `userInfo` property to customize the api parameters you need.
- 
- The `RaAPIWrapper/AF` module then takes advantage of this feature and supports the `ParameterEncoding` field of `Alamofire`.
- 
- The following code demonstrates how to add a custom parameter to `API`:
- */
-
-// will be used later as a custom parameter of the api.
+// MARK: - VerificationType
+
+/// :
+/// The `RaAPIWrapper` is extremely extensible.
+/// You can work with the `userInfo` property to customize the api parameters you need.
+///
+/// The `RaAPIWrapper/AF` module then takes advantage of this feature and supports the `ParameterEncoding` field of `Alamofire`.
+///
+/// The following code demonstrates how to add a custom parameter to `API`:
+
+/// will be used later as a custom parameter of the api.
 enum VerificationType: Hashable {
     case normal
     case special
@@ -35,12 +36,13 @@ extension API {
     }
 }
 
+// MARK: - AdvancedAPI
+
 enum AdvancedAPI {
     /// Finally, the new initialization method declared above is called on
     /// the property wrapper to complete the interface definition.
     @GET("/api", verification: .normal)
     static var testAPI: APIParameterBuilder<()>? = nil
 }
 
-
 //: [Next](@next)

Demo.playground/Pages/Basic.xcplaygroundpage/Contents.swift

@@ -4,11 +4,12 @@ import Foundation
 
 import APIWrapper
 
-/*:
- This example uses [Postman Echo](https://www.postman.com/postman/workspace/published-postman-templates/documentation/631643-f695cab7-6878-eb55-7943-ad88e1ccfd65?ctx=documentation) as the sample api.
- 
- The return value of this api depends on the parameters and will return the parameters, headers and other data as is.
- */
+// MARK: - BasicAPI
+
+/// :
+/// This example uses [Postman Echo](https://www.postman.com/postman/workspace/published-postman-templates/documentation/631643-f695cab7-6878-eb55-7943-ad88e1ccfd65?ctx=documentation) as the sample api.
+///
+/// The return value of this api depends on the parameters and will return the parameters, headers and other data as is.
 
 //: To begin by showing some of the most basic uses, look at how the api is defined.
 
@@ -26,12 +27,12 @@ enum BasicAPI {
 do {
     // Requests the api and parses the return value of the interface. Note the use of the `$` character.
     let response = try await BasicAPI.$get.request(to: PostManResponse<Arg>.self)
-    
+
     // You can also ignore the return value and focus only on the act of requesting the api itself.
     try await BasicAPI.$get.request()
-    
+
 } catch {
-    print("❌ get request failure: \(error)")
+    Log.log("❌ get request failure: \(error)")
 }
 
 //: The api with parameters is a little more complicated to define:
@@ -45,10 +46,10 @@ extension BasicAPI {
     static var postWithTuple: APIParameterBuilder<(foo1: String, foo2: Int?)>? = .init {
         [
             "foo1": $0.foo1,
-            "foo2": $0.foo2
+            "foo2": $0.foo2,
         ]
     }
-    
+
     /// This is an api for requests using the **POST** method.
     ///
     /// The full api address is: [](https://postman-echo.com/post) .
@@ -59,18 +60,19 @@ extension BasicAPI {
 
 do {
     // Request the api and parse the return value.
-    let tupleAPIResponse = try await BasicAPI.$postWithTuple.request(with: (foo1: "foo1", foo2: nil), to: PostManResponse<Arg>.self)
-    
-    /**
-     *  If you look at the return value, you will see that `foo2` is not passed to the server.
-     *  This is because `RaAPIWrapper` filters out all parameters with the value `nil`.
-     */
-    
+    let tupleAPIResponse = try await BasicAPI.$postWithTuple.request(
+        with: (foo1: "foo1", foo2: nil),
+        to: PostManResponse<Arg>.self
+    )
+
+    ///  If you look at the return value, you will see that `foo2` is not passed to the server.
+    ///  This is because `RaAPIWrapper` filters out all parameters with the value `nil`.
+
     // Try using model as a parameter and you will get the same result.
     let modelAPIResponse = try await BasicAPI.$postWithModel.request(with: .init(foo2: "foo2"), to: PostManResponse<Arg>.self)
-    
+
 } catch {
-    print("❌ post request failure: \(error)")
+    Log.log("❌ post request failure: \(error)")
 }
 
 //: [Next](@next)

Demo.playground/Pages/Combine.xcplaygroundpage/Contents.swift

@@ -8,15 +8,17 @@ import ObjectiveC
 
 import APIWrapper
 
-/*:
- The design goal of `RaAPIWrapper` is to better encapsulate requests and simplify the request process rather than execute them.
-  
-  So we don't provide any methods for request api. You can define your own request methods by referring to the code in the `Demo/Sources/API+Request.swift` file.
-  
-  Here are 2 request wrappers for `Combine`, which are roughly written for reference only:
- */
-
-// For subsequent examples
+// MARK: - CombineAPI
+
+/// :
+/// The design goal of `RaAPIWrapper` is to better encapsulate requests and simplify the request process rather than execute them.
+///
+/// So we don't provide any methods for request api.
+/// You can define your own request methods by referring to the code in the `Demo/Sources/API+Request.swift` file.
+///
+/// Here are 2 request wrappers for `Combine`, which are roughly written for reference only:
+
+/// For subsequent examples
 enum CombineAPI {
     @POST("/post")
     static var post: APIParameterBuilder<String>? = { $0 }
@@ -29,54 +31,54 @@ enum CombineAPI {
 extension API {
     func requestPublisher(with params: Parameter) -> AnyPublisher<Data, URLError> {
         let info = createRequestInfo(params)
-        
+
         // To simplify the demo process, here is a forced unpacking
-        let url = URL(string: "https://postman-echo.com" + info.path)!
-        
+        guard let url = URL(string: "https://postman-echo.com" + info.path) else {
+            fatalError("url(\(info.path) nil!")
+        }
+
         var request = URLRequest(url: url)
         request.httpMethod = info.httpMethod.rawValue
-        
+
         if let parameters = info.parameters {
             do {
                 request.httpBody = try JSONEncoder().encode(parameters)
             } catch {
-                fatalError("")
+                fatalError("Encoder failure: \(error)")
             }
-            
+
             request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         }
-        
+
         return URLSession.shared
             .dataTaskPublisher(for: request)
-            .map { (data, _) in return data }
+            .map { data, _ in data }
             .mapError { $0 }
             .eraseToAnyPublisher()
     }
 }
 
 var cancellable = Set<AnyCancellable>()
 let publisher = CombineAPI.$post.requestPublisher(with: "123")
-publisher.sink(receiveCompletion: {
-    print($0)
-    
-}, receiveValue: {
-    print(String(data: $0, encoding: .utf8) as Any)
-    
-}).store(in: &cancellable)
+publisher
+    .sink(
+        receiveCompletion: { Log.log($0) },
+        receiveValue: { Log.log(String(data: $0, encoding: .utf8) as Any) }
+    )
+    .store(in: &cancellable)
 
 // MARK: - PassthroughSubject
 
-/*:
- The second one is to provide a `PassthroughSubject` object to the outside world,
- send parameters when requesting the api, subscribe to the object at other places,
- accept the parameters and send the request.
- */
+/// :
+/// The second one is to provide a `PassthroughSubject` object to the outside world,
+/// send parameters when requesting the api, subscribe to the object at other places,
+/// accept the parameters and send the request.
 
-private var kParamSubjectKey: String = "kParamSubjectKey"
+private var kParamSubjectKey = "kParamSubjectKey"
 
-public extension API {
+extension API {
     @available(iOS 13.0, *)
-    var paramSubject: PassthroughSubject<Parameter, URLError>? {
+    public var paramSubject: PassthroughSubject<Parameter, URLError>? {
         get {
             if let value = objc_getAssociatedObject(self, &kParamSubjectKey) as? PassthroughSubject<Parameter, URLError> {
                 return value
@@ -87,22 +89,21 @@ public extension API {
         }
         set { objc_setAssociatedObject(self, &kParamSubjectKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC) }
     }
-    
+
     @available(iOS 13.0, *)
-    func requestPublisher() -> AnyPublisher<Data, URLError>? {
-        return paramSubject?.flatMap { self.requestPublisher(with: $0) }.eraseToAnyPublisher()
+    public func requestPublisher() -> AnyPublisher<Data, URLError>? {
+        paramSubject?.flatMap { self.requestPublisher(with: $0) }.eraseToAnyPublisher()
     }
 }
 
 let api = CombineAPI.$post
 
-api.requestPublisher()?.sink(receiveCompletion: {
-    print($0)
-    
-}, receiveValue: {
-    print(String(data: $0, encoding: .utf8) as Any)
-    
-}).store(in: &cancellable)
+api.requestPublisher()?
+    .sink(
+        receiveCompletion: { Log.log($0) },
+        receiveValue: { Log.log(String(data: $0, encoding: .utf8) as Any) }
+    )
+    .store(in: &cancellable)
 
 api.paramSubject?.send("233")
 api.paramSubject?.send("433")

Demo.playground/Sources/API+Request.swift

@@ -10,73 +10,76 @@ import APIWrapper
 /// This part of the logic needs to be implemented by you in your own project,
 /// for now we provide a simple implementation:
 
-public extension API {
+extension API {
     /// Request an api **with parameters** and resolve the api return value to a `T` type.
     ///
     /// - Parameters:
     ///     - params: api parameters.
     ///     - type: the type of the api return value.
     /// - Returns: The result of the parsing.
-    func request<T: Decodable>(with params: Parameter, to type: T.Type) async throws -> T {
+    public func request<T: Decodable>(with params: Parameter, to type: T.Type) async throws -> T {
         let data = try await _request(with: params)
         return try JSONDecoder().decode(type, from: data)
     }
-    
+
     /// Request an api **without** parameters.
     ///
     /// This method means: the requesting party does not need the parameters returned by the api,
     /// so no return value is provided.
     ///
     /// - Parameter params: api parameters.
-    func request(with params: Parameter) async throws {
+    public func request(with params: Parameter) async throws {
         _ = try await _request(with: params)
     }
 }
 
 /// For some api that do not require parameters,
 /// we can also provide the following methods to make the request process even simpler.
 
-public extension API where Parameter == Void {
+extension API where Parameter == Void {
     /// Request an api **without** parameters and resolve the api return value to a `T` type.
     ///
     /// - Parameter type: The type of the api's return value.
     /// - Returns: The result of the parsing.
-    func request<T: Decodable>(to type: T.Type) async throws -> T {
-        return try await request(with: (), to: type)
+    public func request<T: Decodable>(to type: T.Type) async throws -> T {
+        try await request(with: (), to: type)
     }
-    
+
     /// Request an api **without** parameters.
     ///
     /// This method means: the requesting party does not need the parameters returned by the api,
     /// so no return value is provided.
-    func request() async throws {
+    public func request() async throws {
         try await request(with: ())
     }
 }
 
 // MARK: - Tools
 
-private extension API {
-    func _request(with params: Parameter) async throws -> Data {
+extension API {
+    private func _request(with params: Parameter) async throws -> Data {
         let info = createRequestInfo(params)
-        
+
         // To simplify the demo process, here is a forced unpacking
-        let url = URL(string: "https://postman-echo.com" + info.path)!
-        print("▶️ Requests will begin soon: \(url.absoluteString)")
-        
+        guard let url = URL(string: "https://postman-echo.com" + info.path) else {
+            fatalError("url(\(info.path) nil!")
+        }
+
+        Log.log("▶️ Requests will begin soon: \(url.absoluteString)")
+
         var request = URLRequest(url: url)
         request.httpMethod = info.httpMethod.rawValue
-        
+
         if let parameters = info.parameters {
-            print("🚧 parameters: \(parameters)")
+            Log.log("🚧 parameters: \(parameters)")
             request.httpBody = try JSONEncoder().encode(parameters)
-            
+
             request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         }
-        
+
         let (data, response) = try await URLSession.shared.data(for: request)
-        print("✅ \(response.url?.absoluteString ?? "nil") End of request")
-        
+        Log.log("✅ \(response.url?.absoluteString ?? "nil") End of request")
+
         return data
     }
 }

Demo.playground/Sources/Log.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+enum Log {
+    static func log(_ content: Any) {
+        // swiftlint:disable:next no_direct_standard_out_logs
+        print(content)
+    }
+}