Merge pull request #3 from crelies/dev

Custom cache + custom cache key, Unit Tests

Author: Chris

README.md

@@ -53,6 +53,24 @@ RemoteImage(type: .phAsset(localIdentifier: "541D4013-D51C-463C-AD85-0A1E4EA838F
 })
 ```
 
+## Custom cache
+
+The `RemoteImageService` uses a default cache. To use a custom one just conform to the protocol `RemoteImageCache` and set it on the type `RemoteImageService`.
+
+```swift
+RemoteImageService.cache = yourCache
+```
+
+## Custom cache key
+
+The default cache uses the associated value of the related `RemoteImageType` as the key. You can customize this by setting a cache key provider through
+
+```swift
+RemoteImageService.cacheKeyProvider = { remoteImageType -> AnyObject in
+    // return a key here
+}
+```
+
 ## Migration from 0.1.0 -> 1.0.0
 
 The `url parameter` was refactored to a `type parameter` which makes it easy to fetch images at a URL or from the iCloud. 

Sources/RemoteImage/private/Extensions/URLSession+RemoteImageURLDataPublisher.swift

@@ -0,0 +1,15 @@
+//
+//  URLSession+RemoteImageURLDataPublisher.swift
+//  RemoteImage
+//
+//  Created by Christian Elies on 15.12.19.
+//
+
+import Combine
+import Foundation
+
+extension URLSession: RemoteImageURLDataPublisher {
+    func dataPublisher(for request: URLRequest) -> AnyPublisher<(data: Data, response: URLResponse), URLError> {
+        dataTaskPublisher(for: request).eraseToAnyPublisher()
+    }
+}

Sources/RemoteImage/private/Models/RemoteImageState.swift

@@ -8,23 +8,8 @@
 
 import Foundation
 
-enum RemoteImageState {
-    case error(_ error: Error)
+enum RemoteImageState: Hashable {
+    case error(_ error: NSError)
     case image(_ image: PlatformSpecificImageType)
     case loading
 }
-
-extension RemoteImageState: Equatable {
-    static func == (lhs: RemoteImageState, rhs: RemoteImageState) -> Bool {
-        switch (lhs, rhs) {
-            case (.error(let lhsError), .error(let rhsError)):
-                return (lhsError as NSError) == (rhsError as NSError)
-            case (.image(let lhsImage), .image(let rhsImage)):
-                return lhsImage == rhsImage
-            case (.loading, .loading):
-                return true
-            default:
-                return false
-        }
-    }
-}

Sources/RemoteImage/private/Protocols/RemoteImageServiceProtocol.swift

@@ -0,0 +1,16 @@
+//
+//  RemoteImageServiceProtocol.swift
+//  RemoteImage
+//
+//  Created by Christian Elies on 15.12.19.
+//
+
+import Combine
+
+protocol RemoteImageServiceProtocol where Self: ObservableObject {
+    static var cache: RemoteImageCache { get set }
+    static var cacheKeyProvider: RemoteImageCacheKeyProvider { get set }
+
+    var state: RemoteImageState { get set }
+    func fetchImage(ofType type: RemoteImageType)
+}

Sources/RemoteImage/private/Protocols/RemoteImageURLDataPublisher.swift

@@ -0,0 +1,13 @@
+//
+//  RemoteImageURLDataPublisher.swift
+//  RemoteImage
+//
+//  Created by Christian Elies on 15.12.19.
+//
+
+import Combine
+import Foundation
+
+protocol RemoteImageURLDataPublisher {
+    func dataPublisher(for request: URLRequest) -> AnyPublisher<(data: Data, response: URLResponse), URLError>
+}

Sources/RemoteImage/private/Protocols/RemoteImageURLDataPublisherProvider.swift

@@ -0,0 +1,10 @@
+//
+//  RemoteImageURLDataPublisherProvider.swift
+//  RemoteImage
+//
+//  Created by Christian Elies on 15.12.19.
+//
+
+protocol RemoteImageURLDataPublisherProvider {
+    var remoteImageURLDataPublisher: RemoteImageURLDataPublisher { get }
+}

Sources/RemoteImage/private/Services/DefaultRemoteImageCache.swift

@@ -0,0 +1,22 @@
+//
+//  DefaultRemoteImageCache.swift
+//  
+//
+//  Created by Christian Elies on 14.12.19.
+//
+
+import Foundation
+
+struct DefaultRemoteImageCache {
+    let cache = NSCache<AnyObject, PlatformSpecificImageType>()
+}
+
+extension DefaultRemoteImageCache: RemoteImageCache {
+    func object(forKey key: AnyObject) -> PlatformSpecificImageType? { cache.object(forKey: key) }
+
+    func setObject(_ object: PlatformSpecificImageType, forKey key: AnyObject) { cache.setObject(object, forKey: key) }
+
+    func removeObject(forKey key: AnyObject) { cache.removeObject(forKey: key) }
+
+    func removeAllObjects() { cache.removeAllObjects() }
+}

Sources/RemoteImage/private/Services/PhotoKitService.swift

@@ -6,35 +6,34 @@ protocol PhotoKitServiceProvider {
 
 protocol PhotoKitServiceProtocol {
     func getPhotoData(localIdentifier: String,
-                      success: @escaping (Data) -> Void,
-                      failure: @escaping (Error) -> Void)
+                      _ completion: @escaping (Result<Data, Error>) -> Void)
 }
 
 final class PhotoKitService {
-	
+    static var asset: PHAsset.Type = PHAsset.self
+    static var imageManager: PHImageManager = PHImageManager.default()
 }
 
 extension PhotoKitService: PhotoKitServiceProtocol {
     func getPhotoData(localIdentifier: String,
-                      success: @escaping (Data) -> Void,
-                      failure: @escaping (Error) -> Void) {
-        let fetchAssetsResult = PHAsset.fetchAssets(withLocalIdentifiers: [localIdentifier], options: nil)
+                      _ completion: @escaping (Result<Data, Error>) -> Void) {
+        let fetchAssetsResult = Self.asset.fetchAssets(withLocalIdentifiers: [localIdentifier], options: nil)
         guard let phAsset = fetchAssetsResult.firstObject else {
-            failure(PhotoKitServiceError.phAssetNotFound(localIdentifier: localIdentifier))
+            completion(.failure(PhotoKitServiceError.phAssetNotFound(localIdentifier: localIdentifier)))
             return
         }
-        
+
         let options = PHImageRequestOptions()
         options.isNetworkAccessAllowed = true
-        PHImageManager.default().requestImageDataAndOrientation(for: phAsset,
-                                                                options: options,
-                                                                resultHandler: { data, _, _, info in
+        Self.imageManager.requestImageDataAndOrientation(for: phAsset,
+                                                         options: options,
+                                                         resultHandler: { data, _, _, info in
             if let error = info?[PHImageErrorKey] as? Error {
-                failure(error)
+                completion(.failure(error))
             } else if let data = data {
-                success(data)
+                completion(.success(data))
             } else {
-                failure(PhotoKitServiceError.missingData)
+                completion(.failure(PhotoKitServiceError.missingData))
             }
         })
     }

Sources/RemoteImage/private/Services/RemoteImageServiceDependencies.swift

@@ -7,14 +7,16 @@
 
 import Foundation
 
-protocol RemoteImageServiceDependenciesProtocol: PhotoKitServiceProvider {
+protocol RemoteImageServiceDependenciesProtocol: PhotoKitServiceProvider, RemoteImageURLDataPublisherProvider {
 
 }
 
 struct RemoteImageServiceDependencies: RemoteImageServiceDependenciesProtocol {
     let photoKitService: PhotoKitServiceProtocol
+    let remoteImageURLDataPublisher: RemoteImageURLDataPublisher
 
     init() {
         photoKitService = PhotoKitService()
+        remoteImageURLDataPublisher = URLSession.shared
     }
 }

Sources/RemoteImage/public/Models/PhotoKitServiceError.swift

@@ -5,6 +5,8 @@ public enum PhotoKitServiceError: Error {
     case phAssetNotFound(localIdentifier: String)
 }
 
+extension PhotoKitServiceError: Equatable {}
+
 extension PhotoKitServiceError: LocalizedError {
     public var errorDescription: String? {
         switch self {