Merge pull request #135 from Aldo10012/cleanup_adaptors_p2

Cleanup adaptors p2

Author: Aldo10012

Documentation/03_howToPerformARequest.md

@@ -22,72 +22,6 @@ do {
 }
 ```
 
-## Completion Handlers
-
-Traditional callback-based approach:
-
-```swift
-// With response decoding
-RequestPerformer().performTask(request: request, decodeTo: UserData.self) { result in
-    switch result {
-    case .success(let userData):
-        // Handle decoded response
-    case .failure(let error):
-        // Handle error
-    }
-}
-
-// Without decoding
-RequestPerformer().performTask(request: request, decodeTo: EmptyResponse.self) { result in
-    switch result {
-    case .success:
-        // Handle success
-    case .failure(let error):
-        // Handle error
-    }
-}
-```
-
-## Task Control
-
-Control over URLSessionTask:
-
-```swift
-// Store task reference
-let task = RequestPerformer().performTask(request: request) { _ in
-    // Handle completion
-}
-
-// Cancel task if needed
-task.cancel()
-
-// Resume suspended task
-task.resume()
-
-// Suspend task
-task.suspend()
-
-// Get task state
-print(task.state) // running, suspended, canceling, completed
-```
-
-## Publishers
-
-If you prefer using the Combine framework
-
-```swift
-let cancellables = Set<AnyCancellable>()
-
-RequestPerformer()
-    .performPublisher(request: CustomRequest(), decodeTo: CustomeType.swift)
-    .sink(receiveCompletion: { completion in
-        // handle completion
-    }, receiveValue: { customType in
-        // handle response
-    })
-    .store(in: &cancellables)
-```
-
 ## Error Handling
 
 EZNetworking provides comprehensive error handling:

Sources/EZNetworking/Core/Common/CancellableRequest.swift

@@ -6,15 +6,4 @@ public protocol RequestPerformable {
         request: Request,
         decodeTo decodableObject: T.Type
     ) async throws -> T
-
-    func performTask<T: Decodable & Sendable>(
-        request: Request,
-        decodeTo decodableObject: T.Type,
-        completion: @escaping ((Result<T, NetworkingError>) -> Void)
-    ) -> CancellableRequest
-
-    func performPublisher<T: Decodable & Sendable>(
-        request: Request,
-        decodeTo decodableObject: T.Type
-    ) -> AnyPublisher<T, NetworkingError>
 }

Sources/EZNetworking/Core/Common/TaskBox.swift

@@ -16,8 +16,6 @@ public struct RequestPerformer: RequestPerformable {
         self.decoder = decoder
     }
 
-    // MARK: - CORE - async/await
-
     public func perform<T: Decodable & Sendable>(
         request: Request,
         decodeTo decodableObject: T.Type
@@ -36,63 +34,8 @@ public struct RequestPerformer: RequestPerformable {
         }
     }
 
-    // MARK: - Adapter - callbacks
-
-    @discardableResult
-    public func performTask<T: Decodable & Sendable>(
-        request: Request,
-        decodeTo decodableObject: T.Type,
-        completion: @escaping (Result<T, NetworkingError>) -> Void
-    ) -> CancellableRequest {
-        let taskBox = TaskBox()
-        let cancellableRequest = CancellableRequest {
-            taskBox.task = createTaskAndPerform(request: request, decodeTo: decodableObject, completion: completion)
-        } onCancel: {
-            taskBox.task?.cancel()
-        }
-        cancellableRequest.resume()
-        return cancellableRequest
-    }
-
-    // MARK: - Adapter - Publisher
-
-    public func performPublisher<T: Decodable & Sendable>(
-        request: Request,
-        decodeTo decodableObject: T.Type
-    ) -> AnyPublisher<T, NetworkingError> {
-        Deferred {
-            let taskBox = TaskBox()
-            return Future<T, NetworkingError> { promise in
-                taskBox.task = createTaskAndPerform(request: request, decodeTo: decodableObject, completion: { promise($0) })
-            }
-            .handleEvents(receiveCancel: {
-                taskBox.task?.cancel()
-            })
-        }
-        .eraseToAnyPublisher()
-    }
-
     // MARK: - Helpers
 
-    private func createTaskAndPerform<T: Decodable & Sendable>(
-        request: Request,
-        decodeTo decodableObject: T.Type,
-        completion: @escaping ((Result<T, NetworkingError>) -> Void)
-    ) -> Task<Void, Never> {
-        Task {
-            do {
-                let result = try await perform(request: request, decodeTo: decodableObject)
-                guard !Task.isCancelled else { return }
-                completion(.success(result))
-            } catch is CancellationError {
-                // Task has been cancelled, do not return
-            } catch {
-                guard !Task.isCancelled else { return }
-                completion(.failure(mapError(error)))
-            }
-        }
-    }
-
     private func mapError(_ error: Error) -> NetworkingError {
         if let networkError = error as? NetworkingError { return networkError }
         if let urlError = error as? URLError { return .requestFailed(reason: .urlError(underlying: urlError)) }

Sources/EZNetworking/Services/Performers/Protocols/RequestPerformable.swift

@@ -2,8 +2,8 @@
 import Foundation
 import Testing
 
-@Suite("Test RequestPerformable async/await methods")
-final class RequestPerformableAsyncAwaitTests {
+@Suite("Test RequestPerformable")
+final class RequestPerformableTests {
     // MARK: - SUCCESS RESPONSE
 
     @Test("test perform(request:_, decodeTo:_) with all valid inputs does not throw error")