Update cache result API

Sources/ImageCache.swift

@@ -60,6 +60,13 @@ Cache type of a cached image.
 */
 public enum CacheType {
     case none, memory, disk
+    
+    public var cached: Bool {
+        switch self {
+        case .memory, .disk: return true
+        case .none: return false
+        }
+    }
 }
 
 /// `ImageCache` represents both the memory and disk cache system of Kingfisher. 
@@ -541,27 +548,17 @@ open class ImageCache {
 
     // MARK: - Check cache status
     
-    /**
-    *  Cache result for checking whether an image is cached for a key.
-    */
-    public struct CacheCheckResult {
-        public let cached: Bool
-        public let cacheType: CacheType?
-    }
-    
-    /**
-    Check whether an image is cached for a key.
-    
-    - parameter key: Key for the image.
-    
-    - returns: The check result.
-    */
-    open func isImageCached(forKey key: String, processorIdentifier identifier: String = "") -> CacheCheckResult {
-        
+    /// Cache type for checking whether an image is cached for a key in current cache.
+    ///
+    /// - Parameters:
+    ///   - key: Key for the image.
+    ///   - identifier: Processor identifier which used for this image. Default is empty string.
+    /// - Returns: A `CacheType` instance which indicates the cache status. `.none` means the image is not in cache yet.
+    open func imageChachedType(forKey key: String, processorIdentifier identifier: String = "") -> CacheType {
         let computedKey = key.computedKey(with: identifier)
         
         if memoryCache.object(forKey: computedKey as NSString) != nil {
-            return CacheCheckResult(cached: true, cacheType: .memory)
+            return .memory
         }
         
         let filePath = cachePath(forComputedKey: computedKey)
@@ -570,12 +567,12 @@ open class ImageCache {
         ioQueue.sync {
             diskCached = fileManager.fileExists(atPath: filePath)
         }
-
+        
         if diskCached {
-            return CacheCheckResult(cached: true, cacheType: .disk)
+            return .disk
         }
         
-        return CacheCheckResult(cached: false, cacheType: nil)
+        return .none
     }
     
     /**
@@ -651,6 +648,39 @@ extension ImageCache {
     }
 }
 
+// MARK: - Deprecated
+extension ImageCache {
+    /**
+     *  Cache result for checking whether an image is cached for a key.
+     */
+    @available(*, deprecated,
+    message: "CacheCheckResult is deprecated. Use imageChachedType(forKey:processorIdentifier:) API instead.")
+    public struct CacheCheckResult {
+        public let cached: Bool
+        public let cacheType: CacheType?
+    }
+    
+    /**
+     Check whether an image is cached for a key.
+     
+     - parameter key: Key for the image.
+     
+     - returns: The check result.
+     */
+    @available(*, deprecated,
+    message: "Use imageChachedType(forKey:processorIdentifier:) instead. CacheCheckResult.none indicates not being cached.",
+    renamed: "imageChachedType(forKey:processorIdentifier:)")
+    open func isImageCached(forKey key: String, processorIdentifier identifier: String = "") -> CacheCheckResult {
+        let result = imageChachedType(forKey: key, processorIdentifier: identifier)
+        switch result {
+        case .memory, .disk:
+            return CacheCheckResult(cached: true, cacheType: result)
+        case .none:
+            return CacheCheckResult(cached: false, cacheType: nil)
+        }
+    }
+}
+
 extension Kingfisher where Base: Image {
     var imageCost: Int {
         return images == nil ?

Sources/ImagePrefetcher.swift

@@ -233,9 +233,8 @@ public class ImagePrefetcher {
         if optionsInfo.forceRefresh {
             downloadAndCache(resource)
         } else {
-            let alreadyInCache = manager.cache.isImageCached(forKey: resource.cacheKey,
+            let alreadyInCache = manager.cache.imageChachedType(forKey: resource.cacheKey,
                                                              processorIdentifier: optionsInfo.processor.identifier).cached
-
             if alreadyInCache {
                 append(cached: resource)
             } else {

Tests/KingfisherTests/ImageCacheTests.swift

@@ -78,12 +78,12 @@ class ImageCacheTests: XCTestCase {
         
         cache.store(testImage, original: testImageData as Data?, forKey: key, toDisk: true) { () -> () in
             self.cache.clearMemoryCache()
-            let cacheResult = self.cache.isImageCached(forKey: key)
+            let cacheResult = self.cache.imageChachedType(forKey: key)
             XCTAssertTrue(cacheResult.cached, "Should be cached")
-            XCTAssert(cacheResult.cacheType == .disk, "Should be cached in disk")
+            XCTAssert(cacheResult == .disk, "Should be cached in disk")
         
             self.cache.clearDiskCache {
-                let cacheResult = self.cache.isImageCached(forKey: key)
+                let cacheResult = self.cache.imageChachedType(forKey: key)
                 XCTAssertFalse(cacheResult.cached, "Should be not cached")
                 expectation.fulfill()
             }
@@ -159,7 +159,7 @@ class ImageCacheTests: XCTestCase {
         let URLString = testKeys[0]
         let url = URL(string: URLString)!
         
-        let exists = cache.isImageCached(forKey: url.cacheKey).cached
+        let exists = cache.imageChachedType(forKey: url.cacheKey).cached
         XCTAssertFalse(exists)
         
         cache.retrieveImage(forKey: URLString, options: nil, completionHandler: { (image, type) -> () in
@@ -172,7 +172,7 @@ class ImageCacheTests: XCTestCase {
                     XCTAssertNotNil(image, "Should be cached (memory or disk)")
                     XCTAssertEqual(type, .memory)
 
-                    let exists = self.cache.isImageCached(forKey: url.cacheKey).cached
+                    let exists = self.cache.imageChachedType(forKey: url.cacheKey).cached
                     XCTAssertTrue(exists, "Image should exist in the cache (memory or disk)")
 
                     self.cache.clearMemoryCache()
@@ -180,7 +180,7 @@ class ImageCacheTests: XCTestCase {
                         XCTAssertNotNil(image, "Should be cached (disk)")
                         XCTAssertEqual(type, CacheType.disk)
                         
-                        let exists = self.cache.isImageCached(forKey: url.cacheKey).cached
+                        let exists = self.cache.imageChachedType(forKey: url.cacheKey).cached
                         XCTAssertTrue(exists, "Image should exist in the cache (disk)")
                         
                         expectation.fulfill()
@@ -196,7 +196,7 @@ class ImageCacheTests: XCTestCase {
         let URLString = testKeys[0]
         let url = URL(string: URLString)!
         
-        let exists = cache.isImageCached(forKey: url.cacheKey).cached
+        let exists = cache.imageChachedType(forKey: url.cacheKey).cached
         XCTAssertFalse(exists)
     }
 
@@ -207,7 +207,7 @@ class ImageCacheTests: XCTestCase {
         let URLString = testKeys[0]
         let url = URL(string: URLString)!
         
-        let exists = cache.isImageCached(forKey: url.cacheKey).cached
+        let exists = cache.imageChachedType(forKey: url.cacheKey).cached
         XCTAssertFalse(exists)
         
         cache.retrieveImage(forKey: URLString, options: nil, completionHandler: { (image, type) -> () in
@@ -220,7 +220,7 @@ class ImageCacheTests: XCTestCase {
                     XCTAssertNotNil(image, "Should be cached (memory or disk)")
                     XCTAssertEqual(type, .memory)
                     
-                    let exists = self.cache.isImageCached(forKey: url.cacheKey).cached
+                    let exists = self.cache.imageChachedType(forKey: url.cacheKey).cached
                     XCTAssertTrue(exists, "Image should exist in the cache (memory or disk)")
                     
                     self.cache.clearMemoryCache()
@@ -228,7 +228,7 @@ class ImageCacheTests: XCTestCase {
                         XCTAssertNotNil(image, "Should be cached (disk)")
                         XCTAssertEqual(type, CacheType.disk)
                         
-                        let exists = self.cache.isImageCached(forKey: url.cacheKey).cached
+                        let exists = self.cache.imageChachedType(forKey: url.cacheKey).cached
                         XCTAssertTrue(exists, "Image should exist in the cache (disk)")
                         
                         let cachePath = self.cache.cachePath(forKey: url.cacheKey)
@@ -262,9 +262,9 @@ class ImageCacheTests: XCTestCase {
     func testIsImageCachedForKey() {
         let expectation = self.expectation(description: "wait for caching image")
         
-        XCTAssert(self.cache.isImageCached(forKey: testKeys[0]).cached == false, "This image should not be cached yet.")
+        XCTAssert(self.cache.imageChachedType(forKey: testKeys[0]).cached == false, "This image should not be cached yet.")
         self.cache.store(testImage, original: testImageData as Data?, forKey: testKeys[0], toDisk: true) { () -> () in
-            XCTAssert(self.cache.isImageCached(forKey: testKeys[0]).cached == true, "This image should be already cached.")
+            XCTAssert(self.cache.imageChachedType(forKey: testKeys[0]).cached == true, "This image should be already cached.")
             expectation.fulfill()
         }
 

Tests/KingfisherTests/ImagePrefetcherTests.swift

@@ -78,7 +78,7 @@ class ImagePrefetcherTests: XCTestCase {
                                 XCTAssertEqual(completedResources.count, urls.count, "All resources prefetching should be completed.")
                                 XCTAssertEqual(progressCalledCount, urls.count, "Progress should be called the same time of download count.")
                                 for url in urls {
-                                    XCTAssertTrue(KingfisherManager.shared.cache.isImageCached(forKey: url.absoluteString).cached)
+                                    XCTAssertTrue(KingfisherManager.shared.cache.imageChachedType(forKey: url.absoluteString).cached)
                                 }
                             })
         prefetcher.start()
@@ -210,7 +210,7 @@ class ImagePrefetcherTests: XCTestCase {
                                                 XCTAssertEqual(completedResources.count, 0, "No need to prefetch anymore")
                                                 XCTAssertEqual(progressCalledCount, urls.count, "Progress should be called the same time of download count.")
                                                 for url in urls {
-                                                    XCTAssertTrue(KingfisherManager.shared.cache.isImageCached(forKey: url.absoluteString, processorIdentifier: p.identifier).cached)
+                                                    XCTAssertTrue(KingfisherManager.shared.cache.imageChachedType(forKey: url.absoluteString, processorIdentifier: p.identifier).cached)
                                                 }
                                                 expectation.fulfill()
 
@@ -231,7 +231,7 @@ class ImagePrefetcherTests: XCTestCase {
                                             XCTAssertEqual(completedResources.count, urls.count, "All resources prefetching should be completed.")
                                             XCTAssertEqual(progressCalledCount, urls.count, "Progress should be called the same time of download count.")
                                             for url in urls {
-                                                XCTAssertTrue(KingfisherManager.shared.cache.isImageCached(forKey: url.absoluteString, processorIdentifier: p.identifier).cached)
+                                                XCTAssertTrue(KingfisherManager.shared.cache.imageChachedType(forKey: url.absoluteString, processorIdentifier: p.identifier).cached)
                                             }
                                             
                                             prefetchAgain()

Tests/KingfisherTests/ImageViewExtensionTests.swift

@@ -332,17 +332,17 @@ class ImageViewExtensionTests: XCTestCase {
             
         }) { (image, error, cacheType, imageURL) -> () in
             
-            XCTAssertTrue(cache1.isImageCached(forKey: URLString).cached, "This image should be cached in cache1.")
-            XCTAssertFalse(cache2.isImageCached(forKey: URLString).cached, "This image should not be cached in cache2.")
-            XCTAssertFalse(KingfisherManager.shared.cache.isImageCached(forKey: URLString).cached, "This image should not be cached in default cache.")
+            XCTAssertTrue(cache1.imageChachedType(forKey: URLString).cached, "This image should be cached in cache1.")
+            XCTAssertFalse(cache2.imageChachedType(forKey: URLString).cached, "This image should not be cached in cache2.")
+            XCTAssertFalse(KingfisherManager.shared.cache.imageChachedType(forKey: URLString).cached, "This image should not be cached in default cache.")
             
             self.imageView.kf.setImage(with: url, placeholder: nil, options: [.targetCache(cache2)], progressBlock: { (receivedSize, totalSize) -> () in
                 
             }, completionHandler: { (image, error, cacheType, imageURL) -> () in
                 
-                XCTAssertTrue(cache1.isImageCached(forKey: URLString).cached, "This image should be cached in cache1.")
-                XCTAssertTrue(cache2.isImageCached(forKey: URLString).cached, "This image should be cached in cache2.")
-                XCTAssertFalse(KingfisherManager.shared.cache.isImageCached(forKey: URLString).cached, "This image should not be cached in default cache.")
+                XCTAssertTrue(cache1.imageChachedType(forKey: URLString).cached, "This image should be cached in cache1.")
+                XCTAssertTrue(cache2.imageChachedType(forKey: URLString).cached, "This image should be cached in cache2.")
+                XCTAssertFalse(KingfisherManager.shared.cache.imageChachedType(forKey: URLString).cached, "This image should not be cached in default cache.")
                 
                 clearCaches([cache1, cache2])
                 

Tests/KingfisherTests/KingfisherManagerTests.swift

@@ -305,18 +305,18 @@ class KingfisherManagerTests: XCTestCase {
             self.manager.downloadAndCacheImage(with: url, forKey: URLString, retrieveImageTask: RetrieveImageTask(), progressBlock: nil, completionHandler: {
                 (image, error, cacheType, url) in
                 delay(0.1) {
-                    var imageCached = self.manager.cache.isImageCached(forKey: URLString, processorIdentifier: p.identifier)
-                    var originalCached = self.manager.cache.isImageCached(forKey: URLString)
+                    var imageCached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
+                    var originalCached = self.manager.cache.imageChachedType(forKey: URLString)
                     
-                    XCTAssertEqual(imageCached.cacheType, .memory)
-                    XCTAssertEqual(originalCached.cacheType, .memory)
+                    XCTAssertEqual(imageCached, .memory)
+                    XCTAssertEqual(originalCached, .memory)
                     
                     self.manager.cache.clearMemoryCache()
                     
-                    imageCached = self.manager.cache.isImageCached(forKey: URLString, processorIdentifier: p.identifier)
-                    originalCached = self.manager.cache.isImageCached(forKey: URLString)
-                    XCTAssertEqual(imageCached.cacheType, .disk)
-                    XCTAssertEqual(originalCached.cacheType, .disk)
+                    imageCached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
+                    originalCached = self.manager.cache.imageChachedType(forKey: URLString)
+                    XCTAssertEqual(imageCached, .disk)
+                    XCTAssertEqual(originalCached, .disk)
                     
                     expectation.fulfill()
                 }
@@ -338,18 +338,18 @@ class KingfisherManagerTests: XCTestCase {
         manager.downloadAndCacheImage(with: url, forKey: URLString, retrieveImageTask: RetrieveImageTask(), progressBlock: nil, completionHandler: {
             (image, error, cacheType, url) in
             delay(0.1) {
-                var imageCached = self.manager.cache.isImageCached(forKey: URLString, processorIdentifier: p.identifier)
-                var originalCached = self.manager.cache.isImageCached(forKey: URLString)
+                var imageCached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
+                var originalCached = self.manager.cache.imageChachedType(forKey: URLString)
                 
-                XCTAssertEqual(imageCached.cacheType, .memory)
-                XCTAssertEqual(originalCached.cacheType, .none)
+                XCTAssertEqual(imageCached, .memory)
+                XCTAssertEqual(originalCached, .none)
                 
                 self.manager.cache.clearMemoryCache()
                 
-                imageCached = self.manager.cache.isImageCached(forKey: URLString, processorIdentifier: p.identifier)
-                originalCached = self.manager.cache.isImageCached(forKey: URLString)
-                XCTAssertEqual(imageCached.cacheType, .disk)
-                XCTAssertEqual(originalCached.cacheType, .none)
+                imageCached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
+                originalCached = self.manager.cache.imageChachedType(forKey: URLString)
+                XCTAssertEqual(imageCached, .disk)
+                XCTAssertEqual(originalCached, .none)
                 
                 expectation.fulfill()
             }
@@ -367,7 +367,7 @@ class KingfisherManagerTests: XCTestCase {
         {
             let p = SimpleProcessor()
             
-            let cached = self.manager.cache.isImageCached(forKey: URLString, processorIdentifier: p.identifier)
+            let cached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
             XCTAssertFalse(cached.cached)
             
             // No downloading will happen
@@ -379,7 +379,7 @@ class KingfisherManagerTests: XCTestCase {
                 
                 // The processed image should be cached
                 delay(0.1) {
-                    let cached = self.manager.cache.isImageCached(forKey: URLString, processorIdentifier: p.identifier)
+                    let cached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
                     XCTAssertTrue(cached.cached)
                     expectation.fulfill()
                 }