Merge pull request #166 from onevcat/sheepy1-master

Sheepy1 master

Kingfisher/ImageDownloader.swift

@@ -259,17 +259,6 @@ extension ImageDownloader: NSURLSessionDataDelegate {
         }
     }
     
-    private func callbackWithImage(image: UIImage?, error: NSError?, imageURL: NSURL, originalData: NSData?) {
-        if let callbackPairs = fetchLoadForKey(imageURL)?.callbacks {
-            
-            self.cleanForURL(imageURL)
-            
-            for callbackPair in callbackPairs {
-                callbackPair.completionHander?(image: image, error: error, imageURL: imageURL, originalData: originalData)
-            }
-        }
-    }
-    
     /**
     This method is exposed since the compiler requests. Do not call it.
     */
@@ -279,36 +268,7 @@ extension ImageDownloader: NSURLSessionDataDelegate {
             if let error = error { // Error happened
                 callbackWithImage(nil, error: error, imageURL: URL, originalData: nil)
             } else { //Download finished without error
-                
-                // We are on main queue when receiving this.
-                dispatch_async(processQueue, { () -> Void in
-                    
-                    if let fetchLoad = self.fetchLoadForKey(URL) {
-                        
-                        if let image = UIImage.kf_imageWithData(fetchLoad.responseData, scale: fetchLoad.scale) {
-                            
-                            self.delegate?.imageDownloader?(self, didDownloadImage: image, forURL: URL, withResponse: task.response!)
-                            
-                            if fetchLoad.shouldDecode {
-                                self.callbackWithImage(image.kf_decodedImage(scale: fetchLoad.scale), error: nil, imageURL: URL, originalData: fetchLoad.responseData)
-                            } else {
-                                self.callbackWithImage(image, error: nil, imageURL: URL, originalData: fetchLoad.responseData)
-                            }
-                            
-                        } else {
-                            // If server response is 304 (Not Modified), inform the callback handler with NotModified error.
-                            // It should be handled to get an image from cache, which is response of a manager object.
-                            if let res = task.response as? NSHTTPURLResponse where res.statusCode == 304 {
-                                self.callbackWithImage(nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.NotModified.rawValue, userInfo: nil), imageURL: URL, originalData: nil)
-                                return
-                            }
-                            
-                            self.callbackWithImage(nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.BadData.rawValue, userInfo: nil), imageURL: URL, originalData: nil)
-                        }
-                    } else {
-                        self.callbackWithImage(nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.BadData.rawValue, userInfo: nil), imageURL: URL, originalData: nil)
-                    }
-                })
+                processImageForTask(task, URL: URL)
             }
         }
     }
@@ -329,4 +289,46 @@ extension ImageDownloader: NSURLSessionDataDelegate {
         completionHandler(.PerformDefaultHandling, nil)
     }
     
+    private func callbackWithImage(image: UIImage?, error: NSError?, imageURL: NSURL, originalData: NSData?) {
+        if let callbackPairs = fetchLoadForKey(imageURL)?.callbacks {
+            
+            self.cleanForURL(imageURL)
+            
+            for callbackPair in callbackPairs {
+                callbackPair.completionHander?(image: image, error: error, imageURL: imageURL, originalData: originalData)
+            }
+        }
+    }
+    
+    private func processImageForTask(task: NSURLSessionTask, URL: NSURL) {
+        // We are on main queue when receiving this.
+        dispatch_async(processQueue, { () -> Void in
+            
+            if let fetchLoad = self.fetchLoadForKey(URL) {
+                
+                if let image = UIImage.kf_imageWithData(fetchLoad.responseData, scale: fetchLoad.scale) {
+                    
+                    self.delegate?.imageDownloader?(self, didDownloadImage: image, forURL: URL, withResponse: task.response!)
+                    
+                    if fetchLoad.shouldDecode {
+                        self.callbackWithImage(image.kf_decodedImage(scale: fetchLoad.scale), error: nil, imageURL: URL, originalData: fetchLoad.responseData)
+                    } else {
+                        self.callbackWithImage(image, error: nil, imageURL: URL, originalData: fetchLoad.responseData)
+                    }
+                    
+                } else {
+                    // If server response is 304 (Not Modified), inform the callback handler with NotModified error.
+                    // It should be handled to get an image from cache, which is response of a manager object.
+                    if let res = task.response as? NSHTTPURLResponse where res.statusCode == 304 {
+                        self.callbackWithImage(nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.NotModified.rawValue, userInfo: nil), imageURL: URL, originalData: nil)
+                        return
+                    }
+                    
+                    self.callbackWithImage(nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.BadData.rawValue, userInfo: nil), imageURL: URL, originalData: nil)
+                }
+            } else {
+                self.callbackWithImage(nil, error: NSError(domain: KingfisherErrorDomain, code: KingfisherError.BadData.rawValue, userInfo: nil), imageURL: URL, originalData: nil)
+            }
+        })
+    }
 }

Kingfisher/KingfisherManager.swift

@@ -135,28 +135,14 @@ public class KingfisherManager {
                 targetCache: targetCache,
                 downloader: downloader)
         } else {
-            let diskTaskCompletionHandler: CompletionHandler = { (image, error, cacheType, imageURL) -> () in
-                // Break retain cycle created inside diskTask closure below
-                task.diskRetrieveTask = nil
-                completionHandler?(image: image, error: error, cacheType: cacheType, imageURL: imageURL)
-            }
-            let diskTask = targetCache.retrieveImageForKey(resource.cacheKey, options: options,
-                completionHandler: { image, cacheType in
-                    if image != nil {
-                        diskTaskCompletionHandler(image: image, error: nil, cacheType:cacheType, imageURL: resource.downloadURL)
-                    } else {
-                        self.downloadAndCacheImageWithURL(resource.downloadURL,
-                            forKey: resource.cacheKey,
-                            retrieveImageTask: task,
-                            progressBlock: progressBlock,
-                            completionHandler: diskTaskCompletionHandler,
-                            options: options,
-                            targetCache: targetCache,
-                            downloader: downloader)
-                    }
-                }
-            )
-            task.diskRetrieveTask = diskTask
+            tryToRetrieveImageFromCacheForKey(resource.cacheKey,
+                withURL: resource.downloadURL,
+                retrieveImageTask: task,
+                progressBlock: progressBlock,
+                completionHandler: completionHandler,
+                options: options,
+                targetCache: targetCache,
+                downloader: downloader)
         }
         
         return task
@@ -220,6 +206,39 @@ public class KingfisherManager {
         )
     }
     
+    func tryToRetrieveImageFromCacheForKey(key: String,
+                                   withURL URL: NSURL,
+                             retrieveImageTask: RetrieveImageTask,
+                                 progressBlock: DownloadProgressBlock?,
+                             completionHandler: CompletionHandler?,
+                                       options: Options,
+                                   targetCache: ImageCache,
+                                    downloader: ImageDownloader)
+    {
+        let diskTaskCompletionHandler: CompletionHandler = { (image, error, cacheType, imageURL) -> () in
+            // Break retain cycle created inside diskTask closure below
+            retrieveImageTask.diskRetrieveTask = nil
+            completionHandler?(image: image, error: error, cacheType: cacheType, imageURL: imageURL)
+        }
+        let diskTask = targetCache.retrieveImageForKey(key, options: options,
+            completionHandler: { image, cacheType in
+                if image != nil {
+                    diskTaskCompletionHandler(image: image, error: nil, cacheType:cacheType, imageURL: URL)
+                } else {
+                    self.downloadAndCacheImageWithURL(URL,
+                        forKey: key,
+                        retrieveImageTask: retrieveImageTask,
+                        progressBlock: progressBlock,
+                        completionHandler: diskTaskCompletionHandler,
+                        options: options,
+                        targetCache: targetCache,
+                        downloader: downloader)
+                }
+            }
+        )
+        retrieveImageTask.diskRetrieveTask = diskTask
+    }
+    
     func parseOptionsInfo(optionsInfo: KingfisherOptionsInfo?) -> (Options, ImageCache, ImageDownloader) {
         var options = KingfisherManager.DefaultOptions
         var targetCache = self.cache

Kingfisher/KingfisherOptionsInfo.swift

@@ -46,7 +46,12 @@ public enum KingfisherOptionsInfoItem {
     case Transition(ImageTransition)
 }
 
-func == (a: KingfisherOptionsInfoItem, b: KingfisherOptionsInfoItem) -> Bool {
+infix operator <== {
+    associativity none
+    precedence 160
+}
+
+func <== (a: KingfisherOptionsInfoItem, b: KingfisherOptionsInfoItem) -> Bool {
     switch (a, b) {
     case (.Options(_), .Options(_)): return true
     case (.TargetCache(_), .TargetCache(_)): return true
@@ -61,7 +66,7 @@ extension CollectionType where Generator.Element == KingfisherOptionsInfoItem {
         
         let index = indexOf {
             e in
-            return e == target
+            return e <== target
         }
         
         return (index != nil) ? self[index!] : nil