Merge branch release/0.9.0

Author: rakuyoMo

Package.swift

@@ -14,7 +14,7 @@ let package = Package(
     dependencies: [
         .package(
             url: "https://github.com/Alamofire/Alamofire.git",
-            from: "5.6.2"
+            .upToNextMajor(from: "5.0.0")
         ),
     ],
     targets: [

RaAPIWrapper.podspec

@@ -5,7 +5,7 @@ Pod::Spec.new do |s|
 
   s.name             = 'RaAPIWrapper'
 
-  s.version          = '0.8.3'
+  s.version          = '0.9.0'
 
   s.summary          = 'Wrappers for requesting api.'
 
@@ -27,7 +27,7 @@ Pod::Spec.new do |s|
 
   s.module_name      = 'APIWrapper'
 
-  s.source_files     = 'Sources/*/*'
+  s.source_files     = 'Sources/*/**/*'
 
   s.dependency 'Alamofire'
 

Sources/RequestInfo/APIHTTPMethod.swift

@@ -0,0 +1,35 @@
+//
+//  APIHTTPMethod.swift
+//  RaAPIWrapper
+//
+//  Created by Rakuyo on 2022/12/15.
+//  Copyright © 2022 Rakuyo. All rights reserved.
+//
+
+import Foundation
+
+/// The HTTP method to use when requesting the api.
+///
+/// With the `ExpressibleByStringLiteral` protocol,
+/// you can initialize the object directly with string literals
+public struct APIHTTPMethod: RawRepresentable {
+    public typealias RawValue = String
+    
+    public var rawValue: RawValue
+    
+    public init(rawValue: RawValue) {
+        self.rawValue = rawValue
+    }
+}
+
+// MARK: - ExpressibleByStringLiteral
+
+extension APIHTTPMethod: ExpressibleByStringLiteral {
+    public init(stringLiteral value: RawValue) {
+        self.init(rawValue: value)
+    }
+}
+
+// MARK: - Hashable
+
+extension APIHTTPMethod: Hashable { }

Sources/RequestInfo/APIHeaders.swift

@@ -0,0 +1,12 @@
+//
+//  APIHeaders.swift
+//  RaAPIWrapper
+//
+//  Created by Rakuyo on 2022/12/15.
+//  Copyright © 2022 Rakuyo. All rights reserved.
+//
+
+import Foundation
+
+/// Defines the type of header you can pass into the `API` property wrapper.
+public typealias APIHeaders = [String: String]

Sources/RequestInfo/APIInfoProtocol.swift

@@ -10,55 +10,56 @@ import Foundation
 
 public protocol APIParameter {
     /// Converts the target to an Encodable-compliant type.
-    var toParameters: Encodable { get }
+    var toParameters: AnyAPIHashableParameter { get }
 }
 
 // MARK: - Default
 
-extension APIParameter where Self: Encodable {
-    public var toParameters: Encodable { self }
+extension APIParameter where Self: APIHashableParameter {
+    public var toParameters: AnyAPIHashableParameter { .init(self) }
 }
 
 // MARK: - Array
 
 extension Array: APIParameter {
-    public var toParameters: Encodable {
-        (self as [Any?])
-            .lazy
+    public var toParameters: AnyAPIHashableParameter {
+        let result: [AnyAPIHashableParameter] = (self as [Any?])
             .compactMap {
-                if let value = $0 as? Encodable { return value }
+                if let value = $0 as? (any APIHashableParameter) { return .init(value) }
                 if let value = $0 as? APIParameter { return value.toParameters }
                 return mapAnyObjectToEncodable($0 as? AnyObject)
             }
-            .map { AnyEncodable($0) }
+        
+        return .init(result)
     }
 }
 
 // MARK: - Dictionary
 
 extension Dictionary: APIParameter where Key == String {
-    public var toParameters: Encodable {
-        (self as [String: Any?])
+    public var toParameters: AnyAPIHashableParameter {
+        let result: [String: AnyAPIHashableParameter] = (self as [String: Any?])
             .compactMapValues {
-                if let value = $0 as? Encodable { return value }
+                if let value = $0 as? (any APIHashableParameter) { return .init(value) }
                 if let value = $0 as? APIParameter { return value.toParameters }
                 return mapAnyObjectToEncodable($0 as? AnyObject)
             }
-            .mapValues { AnyEncodable($0) }
+        
+        return .init(result)
     }
 }
 
 // MARK: - Tools
 
 fileprivate extension APIParameter {
-    func mapAnyObjectToEncodable(_ value: AnyObject?) -> Encodable? {
+    func mapAnyObjectToEncodable(_ value: AnyObject?) -> AnyAPIHashableParameter? {
         guard let _value = value else { return nil }
 
-        if let result = _value as? String { return result }
-        if let result = _value as? Int { return result }
-        if let result = _value as? Double { return result }
-        if let result = _value as? Bool { return result }
-        if let result = _value as? Data { return result }
+        if let result = _value as? String { return .init(result) }
+        if let result = _value as? Int { return .init(result) }
+        if let result = _value as? Double { return .init(result) }
+        if let result = _value as? Bool { return .init(result) }
+        if let result = _value as? Data { return .init(result) }
         if let result = _value as? [String: Any] { return result.toParameters }
         if let result = _value as? [Any] { return result.toParameters }
 

Sources/RequestInfo/APIParameter.swift

@@ -9,7 +9,7 @@
 import Foundation
 
 /// Information needed to request the api
-open class APIRequestInfo: APIInfoProtocol {
+public struct APIRequestInfo {
     /// The path to the requested api
     public let path: String
 
@@ -19,50 +19,39 @@ open class APIRequestInfo: APIInfoProtocol {
     public let specialBaseURL: URL?
 
     /// Type representing HTTP methods
-    public let method: APIHTTPMethod
+    public let httpMethod: APIHTTPMethod
 
     /// API header
     public let header: APIHeaders?
 
     /// Parameters of the requested api
-    public let parameters: APIParameters?
+    public let parameters: AnyAPIHashableParameter?
 
     /// Encoding of `parameters`
-    public let parameterEncoding: APIParameterEncoding?
+    public let parameterEncoding: AnyAPIHashableParameterEncoding?
+    
+    ///
+    public let userInfo: APIRequestUserInfo
 
     public init(
         path: String,
-        specialBaseURL: URL?,
-        method: APIHTTPMethod,
-        header: APIHeaders?,
-        parameters: APIParameters?,
-        parameterEncoding: APIParameterEncoding?
+        specialBaseURL: URL? = nil,
+        httpMethod: APIHTTPMethod,
+        header: APIHeaders? = nil,
+        parameters: AnyAPIHashableParameter? = nil,
+        parameterEncoding: AnyAPIHashableParameterEncoding? = nil,
+        userInfo: APIRequestUserInfo = [:]
     ) {
         self.path = path
         self.specialBaseURL = specialBaseURL
-        self.method = method
+        self.httpMethod = httpMethod
         self.header = header
         self.parameters = parameters
         self.parameterEncoding = parameterEncoding
+        self.userInfo = userInfo
     }
 }
 
 // MARK: - Hashable
 
-extension APIRequestInfo: Hashable {
-    public static func == (lhs: APIRequestInfo, rhs: APIRequestInfo) -> Bool {
-        return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
-    }
-    
-    public func hash(into hasher: inout Hasher) {
-        hasher.combine(ObjectIdentifier(self))
-    }
-}
-
-// MARK: - CustomStringConvertible
-
-extension APIRequestInfo: CustomStringConvertible {
-    public var description: String {
-        "specialBaseURL: \(specialBaseURL?.absoluteString ?? "nil"); path: \(path); method: \(method.rawValue); header: \(header?.description ?? "nil"); parameters: \(String(describing: parameters)); parameterEncoding: \(String(describing: parameterEncoding))"
-    }
-}
+extension APIRequestInfo: Hashable { }

Sources/RequestInfo/APIRequestInfo.swift

@@ -0,0 +1,12 @@
+//
+//  APIRequestUserInfo.swift
+//  RaAPIWrapper
+//
+//  Created by Rakuyo on 2022/8/25.
+//  Copyright © 2022 Rakuyo. All rights reserved.
+//
+
+import Foundation
+
+/// Defines the type of custom data you can pass into the `API` property wrapper.
+public typealias APIRequestUserInfo = [AnyHashable: AnyHashable]

Sources/RequestInfo/APIRequestUserInfo.swift

@@ -0,0 +1,67 @@
+//
+//  AnyAPIHashable.swift
+//  RaAPIWrapper
+//
+//  Created by Rakuyo on 2022/12/15.
+//  Copyright © 2022 Rakuyo. All rights reserved.
+//
+
+import Foundation
+
+/// You can make any property or protocol follow the `Hashable` protocol through this protocol.
+///
+/// Define a type, then make it follow the `AnyAPIHashable` protocol,
+/// then specify the type of Value as the type you want to make it follow the Hashable.
+/// That's all you need to do to get the job done.
+///
+/// See `AnyAPIHashableParameter` or `AnyAPIHashableParameterEncoding` for details on how to use it.
+/// the former makes the `Encodable` protocol follow `Hashable`,
+/// the latter makes `Alamofire.ParameterEncoding` do the same thing.
+public protocol AnyAPIHashable: Hashable, CustomStringConvertible, CustomDebugStringConvertible {
+    /// The type itself that you want to make follow the Hashable protocol.
+    /// For example: `typealias Value = Encodable`
+    associatedtype Value
+    
+    /// Storing the original object.
+    var value: Value { get }
+    
+    /// Used to implement `Equatable`.
+    ///
+    /// When using this type, you do not need to care about the specifics of the value.
+    var equals: (Value) -> Bool { get }
+    
+    /// Used to implement `Hashable`.
+    ///
+    /// When using this type, you do not need to care about the specifics of the value.
+    var hash: (_ hasher: inout Hasher) -> Void { get }
+}
+
+// MARK: - Hashable
+
+extension AnyAPIHashable {
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        return lhs.equals(rhs.value)
+    }
+    
+    public func hash(into hasher: inout Hasher) {
+        self.hash(&hasher)
+    }
+}
+
+// MARK: - CustomStringConvertible
+
+extension AnyAPIHashable {
+    public var description: String {
+        // When printing the logs, only the objects that need attention are kept by themselves.
+        .init(describing: value)
+    }
+}
+
+// MARK: - CustomDebugStringConvertible
+
+extension AnyAPIHashable {
+    public var debugDescription: String {
+        // In debug mode, focus on the full content
+        .init(describing: self)
+    }
+}

Sources/RequestInfo/AnyAPIHashableWrapper /AnyAPIHashable.swift

@@ -0,0 +1,39 @@
+//
+//  AnyAPIHashableParameter.swift
+//  RaAPIWrapper
+//
+//  Created by Rakuyo on 2022/12/15.
+//  Copyright © 2022 Rakuyo. All rights reserved.
+//
+
+import Foundation
+
+/// API parameters.
+public typealias APIHashableParameter = AnyAPIHashableParameter.Input
+
+/// Make `Encodable` follow `Hashable` protocol.
+public struct AnyAPIHashableParameter: AnyAPIHashable {
+    public typealias Value = Encodable
+    
+    public typealias Input = Value & Hashable
+    
+    public let value: Value
+    
+    public let equals: (Value) -> Bool
+    
+    public let hash: (_ hasher: inout Hasher) -> Void
+    
+    public init<T: Input>(_ value: T) {
+        self.value = value
+        self.equals = { ($0 as? T == value) }
+        self.hash = { $0.combine(value) }
+    }
+}
+
+// MARK: - Encodable
+
+extension AnyAPIHashableParameter: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        try value.encode(to: encoder)
+    }
+}