Fix typos

Sources/ImageCache.swift

@@ -554,7 +554,7 @@ open class ImageCache {
     ///   - 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 {
+    open func imageCachedType(forKey key: String, processorIdentifier identifier: String = "") -> CacheType {
         let computedKey = key.computedKey(with: identifier)
         
         if memoryCache.object(forKey: computedKey as NSString) != nil {
@@ -654,7 +654,7 @@ 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.")
+    message: "CacheCheckResult is deprecated. Use imageCachedType(forKey:processorIdentifier:) API instead.")
     public struct CacheCheckResult {
         public let cached: Bool
         public let cacheType: CacheType?
@@ -668,10 +668,10 @@ extension ImageCache {
      - returns: The check result.
      */
     @available(*, deprecated,
-    message: "Use imageChachedType(forKey:processorIdentifier:) instead. CacheCheckResult.none indicates not being cached.",
-    renamed: "imageChachedType(forKey:processorIdentifier:)")
+    message: "Use imageCachedType(forKey:processorIdentifier:) instead. CacheCheckResult.none indicates not being cached.",
+    renamed: "imageCachedType(forKey:processorIdentifier:)")
     open func isImageCached(forKey key: String, processorIdentifier identifier: String = "") -> CacheCheckResult {
-        let result = imageChachedType(forKey: key, processorIdentifier: identifier)
+        let result = imageCachedType(forKey: key, processorIdentifier: identifier)
         switch result {
         case .memory, .disk:
             return CacheCheckResult(cached: true, cacheType: result)

Sources/ImagePrefetcher.swift

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

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.imageChachedType(forKey: key)
+            let cacheResult = self.cache.imageCachedType(forKey: key)
             XCTAssertTrue(cacheResult.cached, "Should be cached")
             XCTAssert(cacheResult == .disk, "Should be cached in disk")
         
             self.cache.clearDiskCache {
-                let cacheResult = self.cache.imageChachedType(forKey: key)
+                let cacheResult = self.cache.imageCachedType(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.imageChachedType(forKey: url.cacheKey).cached
+        let exists = cache.imageCachedType(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.imageChachedType(forKey: url.cacheKey).cached
+                    let exists = self.cache.imageCachedType(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.imageChachedType(forKey: url.cacheKey).cached
+                        let exists = self.cache.imageCachedType(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.imageChachedType(forKey: url.cacheKey).cached
+        let exists = cache.imageCachedType(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.imageChachedType(forKey: url.cacheKey).cached
+        let exists = cache.imageCachedType(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.imageChachedType(forKey: url.cacheKey).cached
+                    let exists = self.cache.imageCachedType(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.imageChachedType(forKey: url.cacheKey).cached
+                        let exists = self.cache.imageCachedType(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.imageChachedType(forKey: testKeys[0]).cached == false, "This image should not be cached yet.")
+        XCTAssert(self.cache.imageCachedType(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.imageChachedType(forKey: testKeys[0]).cached == true, "This image should be already cached.")
+            XCTAssert(self.cache.imageCachedType(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.imageChachedType(forKey: url.absoluteString).cached)
+                                    XCTAssertTrue(KingfisherManager.shared.cache.imageCachedType(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.imageChachedType(forKey: url.absoluteString, processorIdentifier: p.identifier).cached)
+                                                    XCTAssertTrue(KingfisherManager.shared.cache.imageCachedType(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.imageChachedType(forKey: url.absoluteString, processorIdentifier: p.identifier).cached)
+                                                XCTAssertTrue(KingfisherManager.shared.cache.imageCachedType(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.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.")
+            XCTAssertTrue(cache1.imageCachedType(forKey: URLString).cached, "This image should be cached in cache1.")
+            XCTAssertFalse(cache2.imageCachedType(forKey: URLString).cached, "This image should not be cached in cache2.")
+            XCTAssertFalse(KingfisherManager.shared.cache.imageCachedType(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.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.")
+                XCTAssertTrue(cache1.imageCachedType(forKey: URLString).cached, "This image should be cached in cache1.")
+                XCTAssertTrue(cache2.imageCachedType(forKey: URLString).cached, "This image should be cached in cache2.")
+                XCTAssertFalse(KingfisherManager.shared.cache.imageCachedType(forKey: URLString).cached, "This image should not be cached in default cache.")
                 
                 clearCaches([cache1, cache2])
                 

Tests/KingfisherTests/KingfisherManagerTests.swift

@@ -305,16 +305,16 @@ 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.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
-                    var originalCached = self.manager.cache.imageChachedType(forKey: URLString)
+                    var imageCached = self.manager.cache.imageCachedType(forKey: URLString, processorIdentifier: p.identifier)
+                    var originalCached = self.manager.cache.imageCachedType(forKey: URLString)
                     
                     XCTAssertEqual(imageCached, .memory)
                     XCTAssertEqual(originalCached, .memory)
                     
                     self.manager.cache.clearMemoryCache()
                     
-                    imageCached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
-                    originalCached = self.manager.cache.imageChachedType(forKey: URLString)
+                    imageCached = self.manager.cache.imageCachedType(forKey: URLString, processorIdentifier: p.identifier)
+                    originalCached = self.manager.cache.imageCachedType(forKey: URLString)
                     XCTAssertEqual(imageCached, .disk)
                     XCTAssertEqual(originalCached, .disk)
                     
@@ -338,16 +338,16 @@ 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.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
-                var originalCached = self.manager.cache.imageChachedType(forKey: URLString)
+                var imageCached = self.manager.cache.imageCachedType(forKey: URLString, processorIdentifier: p.identifier)
+                var originalCached = self.manager.cache.imageCachedType(forKey: URLString)
                 
                 XCTAssertEqual(imageCached, .memory)
                 XCTAssertEqual(originalCached, .none)
                 
                 self.manager.cache.clearMemoryCache()
                 
-                imageCached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
-                originalCached = self.manager.cache.imageChachedType(forKey: URLString)
+                imageCached = self.manager.cache.imageCachedType(forKey: URLString, processorIdentifier: p.identifier)
+                originalCached = self.manager.cache.imageCachedType(forKey: URLString)
                 XCTAssertEqual(imageCached, .disk)
                 XCTAssertEqual(originalCached, .none)
                 
@@ -367,7 +367,7 @@ class KingfisherManagerTests: XCTestCase {
         {
             let p = SimpleProcessor()
             
-            let cached = self.manager.cache.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
+            let cached = self.manager.cache.imageCachedType(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.imageChachedType(forKey: URLString, processorIdentifier: p.identifier)
+                    let cached = self.manager.cache.imageCachedType(forKey: URLString, processorIdentifier: p.identifier)
                     XCTAssertTrue(cached.cached)
                     expectation.fulfill()
                 }