UIButton namespacing compatible

Kingfisher.swift

@@ -8,6 +8,20 @@
 
 import Foundation
 
+#if os(macOS)
+    import AppKit
+    public typealias Image = NSImage
+    public typealias Color = NSColor
+    public typealias ImageView = NSImageView
+    typealias Button = NSButton
+#else
+    import UIKit
+    public typealias Image = UIImage
+    public typealias Color = UIColor
+    public typealias ImageView = UIImageView
+    typealias Button = UIButton
+#endif
+
 public struct Kingfisher<Base> {
     public let base: Base
     public init(_ base: Base) {
@@ -32,3 +46,4 @@ public extension KingfisherCompatible {
 
 extension ImageView: KingfisherCompatible { }
 extension Image: KingfisherCompatible { }
+extension Button: KingfisherCompatible { }

Sources/Image.swift

@@ -27,17 +27,11 @@
 
 #if os(macOS)
 import AppKit
-public typealias Image = NSImage
-public typealias Color = NSColor
-
 private var imagesKey: Void?
 private var durationKey: Void?
 #else
 import UIKit
 import MobileCoreServices
-public typealias Image = UIImage
-public typealias Color = UIColor
-    
 private var imageSourceKey: Void?
 private var animatedImageDataKey: Void?
 #endif

Sources/ImageView+Kingfisher.swift

@@ -27,12 +27,14 @@
 
 #if os(macOS)
 import AppKit
-public typealias ImageView = NSImageView
 #else
 import UIKit
-public typealias ImageView = UIImageView
 #endif
 
+// MARK: - Extension methods.
+/**
+ *	Set image to use from web.
+ */
 extension Kingfisher where Base: ImageView {
     /**
      Set an image with a resource, a placeholder image, options, progress handler and completion handler.
@@ -50,10 +52,10 @@ extension Kingfisher where Base: ImageView {
      */
     @discardableResult
     public func setImage(with resource: Resource?,
-                            placeholder: Image? = nil,
-                            options: KingfisherOptionsInfo? = nil,
-                            progressBlock: DownloadProgressBlock? = nil,
-                            completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
+                         placeholder: Image? = nil,
+                         options: KingfisherOptionsInfo? = nil,
+                         progressBlock: DownloadProgressBlock? = nil,
+                         completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
     {
         base.image = placeholder
         
@@ -215,9 +217,9 @@ extension Kingfisher where Base: ImageView {
 }
 
 
-// MARK: - Back compatible
+// MARK: - Deprecated. Only for back compatibility.
 /**
-*	Set image to use from web.
+*	Set image to use from web. Deprecated. Use `kf` namespacing instead.
 */
 extension ImageView {
     /**

Sources/UIButton+Kingfisher.swift

@@ -27,228 +27,376 @@
 import UIKit
 
 /**
-*	Set image to use from web for a specified state.
-*/
-extension UIButton {
+ *	Set image to use in button from web for a specified state.
+ */
+extension Kingfisher where Base: UIButton {
     /**
-    Set an image to use for a specified state with a resource, a placeholder image, options, progress handler and completion handler.
-    
-    - parameter resource:          Resource object contains information such as `cacheKey` and `downloadURL`.
-    - parameter state:             The state that uses the specified image.
-    - parameter placeholder:       A placeholder image when retrieving the image at URL.
-    - parameter options:           A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
-    - parameter progressBlock:     Called when the image downloading progress gets updated.
-    - parameter completionHandler: Called when the image retrieved and set.
-    
-    - returns: A task represents the retrieving process.
+     Set an image to use for a specified state with a resource, a placeholder image, options, progress handler and
+     completion handler.
      
-    - note: Both the `progressBlock` and `completionHandler` will be invoked in main thread.
+     - parameter resource:          Resource object contains information such as `cacheKey` and `downloadURL`.
+     - parameter state:             The state that uses the specified image.
+     - parameter placeholder:       A placeholder image when retrieving the image at URL.
+     - parameter options:           A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
+     - parameter progressBlock:     Called when the image downloading progress gets updated.
+     - parameter completionHandler: Called when the image retrieved and set.
+     
+     - returns: A task represents the retrieving process.
+     
+     - note: Both the `progressBlock` and `completionHandler` will be invoked in main thread.
      The `CallbackDispatchQueue` specified in `optionsInfo` will not be used in callbacks of this method.
-    */
+     */
     @discardableResult
-    public func kf_setImage(with resource: Resource?,
-                                for state: UIControlState,
-                              placeholder: UIImage? = nil,
-                                  options: KingfisherOptionsInfo? = nil,
-                            progressBlock: DownloadProgressBlock? = nil,
-                        completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
+    public func setImage(with resource: Resource?,
+                         for state: UIControlState,
+                         placeholder: UIImage? = nil,
+                         options: KingfisherOptionsInfo? = nil,
+                         progressBlock: DownloadProgressBlock? = nil,
+                         completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
     {
-        setImage(placeholder, for: state)
+        base.setImage(placeholder, for: state)
         
         guard let resource = resource else {
             completionHandler?(nil, nil, .none, nil)
             return .empty
         }
         
-        kf_setWebURL(resource.downloadURL, for: state)
-        let task = KingfisherManager.shared.retrieveImage(with: resource, options: options,
+        setWebURL(resource.downloadURL, for: state)
+        let task = KingfisherManager.shared.retrieveImage(
+            with: resource,
+            options: options,
             progressBlock: { receivedSize, totalSize in
                 if let progressBlock = progressBlock {
                     progressBlock(receivedSize, totalSize)
                 }
             },
-            completionHandler: {[weak self] image, error, cacheType, imageURL in
+            completionHandler: {[weak base] image, error, cacheType, imageURL in
                 DispatchQueue.main.safeAsync {
-                    guard let sSelf = self, imageURL == sSelf.kf_webURL(for: state) else {
+                    guard let strongBase = base, imageURL == self.webURL(for: state) else {
                         return
                     }
-                    
-                    sSelf.kf_setImageTask(nil)
+                    self.setImageTask(nil)
                     
                     if image != nil {
-                        sSelf.setImage(image, for: state)
+                        strongBase.setImage(image, for: state)
                     }
-                    
+
                     completionHandler?(image, error, cacheType, imageURL)
                 }
             })
         
-        kf_setImageTask(task)
+        setImageTask(task)
         return task
     }
+    
+    /**
+     Cancel the image download task bounded to the image view if it is running.
+     Nothing will happen if the downloading has already finished.
+     */
+    public func cancelImageDownloadTask() {
+        imageTask?.downloadTask?.cancel()
+    }
 }
 
+// MARK: - Associated Object
 private var lastURLKey: Void?
 private var imageTaskKey: Void?
 
-// MARK: - Runtime for UIButton image
-extension UIButton {
+extension Kingfisher where Base: UIButton {
     /**
-    Get the image URL binded to this button for a specified state. 
-    
-    - parameter state: The state that uses the specified image.
-    
-    - returns: Current URL for image.
-    */
-    public func kf_webURL(for state: UIControlState) -> URL? {
-        return kf_webURLs[NSNumber(value:state.rawValue)] as? URL
+     Get the image URL binded to this button for a specified state.
+     
+     - parameter state: The state that uses the specified image.
+     
+     - returns: Current URL for image.
+     */
+    public func webURL(for state: UIControlState) -> URL? {
+        return webURLs[NSNumber(value:state.rawValue)] as? URL
     }
     
-    fileprivate func kf_setWebURL(_ url: URL, for state: UIControlState) {
-        kf_webURLs[NSNumber(value:state.rawValue)] = url
+    fileprivate func setWebURL(_ url: URL, for state: UIControlState) {
+        webURLs[NSNumber(value:state.rawValue)] = url
     }
     
-    fileprivate var kf_webURLs: NSMutableDictionary {
-        var dictionary = objc_getAssociatedObject(self, &lastURLKey) as? NSMutableDictionary
+    fileprivate var webURLs: NSMutableDictionary {
+        var dictionary = objc_getAssociatedObject(base, &lastURLKey) as? NSMutableDictionary
         if dictionary == nil {
             dictionary = NSMutableDictionary()
-            kf_setWebURLs(dictionary!)
+            setWebURLs(dictionary!)
         }
         return dictionary!
     }
     
-    fileprivate func kf_setWebURLs(_ URLs: NSMutableDictionary) {
-        objc_setAssociatedObject(self, &lastURLKey, URLs, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    fileprivate func setWebURLs(_ URLs: NSMutableDictionary) {
+        objc_setAssociatedObject(base, &lastURLKey, URLs, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
     }
     
-    fileprivate var kf_imageTask: RetrieveImageTask? {
-        return objc_getAssociatedObject(self, &imageTaskKey) as? RetrieveImageTask
+    fileprivate var imageTask: RetrieveImageTask? {
+        return objc_getAssociatedObject(base, &imageTaskKey) as? RetrieveImageTask
     }
     
-    fileprivate func kf_setImageTask(_ task: RetrieveImageTask?) {
-        objc_setAssociatedObject(self, &imageTaskKey, task, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    fileprivate func setImageTask(_ task: RetrieveImageTask?) {
+        objc_setAssociatedObject(base, &imageTaskKey, task, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
     }
 }
 
+
 /**
-*	Set background image to use from web for a specified state.
-*/
-extension UIButton {
+ *	Set background image to use from web for a specified state.
+ */
+extension Kingfisher where Base: UIButton {
     /**
-    Set the background image to use for a specified state with a resource,
-    a placeholder image, options progress handler and completion handler.
-    
-    - parameter resource:          Resource object contains information such as `cacheKey` and `downloadURL`.
-    - parameter state:             The state that uses the specified image.
-    - parameter placeholder:       A placeholder image when retrieving the image at URL.
-    - parameter options:           A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
-    - parameter progressBlock:     Called when the image downloading progress gets updated.
-    - parameter completionHandler: Called when the image retrieved and set.
-    
-    - returns: A task represents the retrieving process.
+     Set the background image to use for a specified state with a resource,
+     a placeholder image, options progress handler and completion handler.
      
-    - note: Both the `progressBlock` and `completionHandler` will be invoked in main thread.
+     - parameter resource:          Resource object contains information such as `cacheKey` and `downloadURL`.
+     - parameter state:             The state that uses the specified image.
+     - parameter placeholder:       A placeholder image when retrieving the image at URL.
+     - parameter options:           A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
+     - parameter progressBlock:     Called when the image downloading progress gets updated.
+     - parameter completionHandler: Called when the image retrieved and set.
+     
+     - returns: A task represents the retrieving process.
+     
+     - note: Both the `progressBlock` and `completionHandler` will be invoked in main thread.
      The `CallbackDispatchQueue` specified in `optionsInfo` will not be used in callbacks of this method.
-    */
+     */
     @discardableResult
-    public func kf_setBackgroundImage(with resource: Resource?,
-                                          for state: UIControlState,
-                                        placeholder: UIImage? = nil,
-                                            options: KingfisherOptionsInfo? = nil,
-                                      progressBlock: DownloadProgressBlock? = nil,
-                                  completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
+    public func setBackgroundImage(with resource: Resource?,
+                                   for state: UIControlState,
+                                   placeholder: UIImage? = nil,
+                                   options: KingfisherOptionsInfo? = nil,
+                                   progressBlock: DownloadProgressBlock? = nil,
+                                   completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
     {
-        setBackgroundImage(placeholder, for: state)
+        base.setBackgroundImage(placeholder, for: state)
         
         guard let resource = resource else {
             completionHandler?(nil, nil, .none, nil)
             return .empty
         }
         
-        kf_setBackgroundWebURL(resource.downloadURL, for: state)
-        let task = KingfisherManager.shared.retrieveImage(with: resource, options: options,
+        setBackgroundWebURL(resource.downloadURL, for: state)
+        let task = KingfisherManager.shared.retrieveImage(
+            with: resource,
+            options: options,
             progressBlock: { receivedSize, totalSize in
                 if let progressBlock = progressBlock {
                     progressBlock(receivedSize, totalSize)
                 }
             },
-            completionHandler: { [weak self] image, error, cacheType, imageURL in
+            completionHandler: { [weak base] image, error, cacheType, imageURL in
                 DispatchQueue.main.safeAsync {
-                    guard let sSelf = self, imageURL == sSelf.kf_backgroundWebURL(for: state) else {
+                    guard let strongBase = base, imageURL == self.backgroundWebURL(for: state) else {
                         return
                     }
-                    
-                    sSelf.kf_setBackgroundImageTask(nil)
-                        
+                    self.setBackgroundImageTask(nil)
                     if image != nil {
-                        sSelf.setBackgroundImage(image, for: state)
+                        strongBase.setBackgroundImage(image, for: state)
                     }
                     completionHandler?(image, error, cacheType, imageURL)
                 }
             })
         
-        kf_setBackgroundImageTask(task)
+        setBackgroundImageTask(task)
         return task
     }
+    
+    /**
+     Cancel the background image download task bounded to the image view if it is running.
+     Nothing will happen if the downloading has already finished.
+     */
+    public func cancelBackgroundImageDownloadTask() {
+        backgroundImageTask?.downloadTask?.cancel()
+    }
 }
 
 private var lastBackgroundURLKey: Void?
 private var backgroundImageTaskKey: Void?
-    
+
 // MARK: - Runtime for UIButton background image
-extension UIButton {
+extension Kingfisher where Base: UIButton {
     /**
-    Get the background image URL binded to this button for a specified state.
-    
-    - parameter state: The state that uses the specified background image.
-    
-    - returns: Current URL for background image.
-    */
-    public func kf_backgroundWebURL(for state: UIControlState) -> URL? {
-        return kf_backgroundWebURLs[NSNumber(value:state.rawValue)] as? URL
+     Get the background image URL binded to this button for a specified state.
+     
+     - parameter state: The state that uses the specified background image.
+     
+     - returns: Current URL for background image.
+     */
+    public func backgroundWebURL(for state: UIControlState) -> URL? {
+        return backgroundWebURLs[NSNumber(value:state.rawValue)] as? URL
     }
     
-    fileprivate func kf_setBackgroundWebURL(_ url: URL, for state: UIControlState) {
-        kf_backgroundWebURLs[NSNumber(value:state.rawValue)] = url
+    fileprivate func setBackgroundWebURL(_ url: URL, for state: UIControlState) {
+        backgroundWebURLs[NSNumber(value:state.rawValue)] = url
     }
     
-    fileprivate var kf_backgroundWebURLs: NSMutableDictionary {
-        var dictionary = objc_getAssociatedObject(self, &lastBackgroundURLKey) as? NSMutableDictionary
+    fileprivate var backgroundWebURLs: NSMutableDictionary {
+        var dictionary = objc_getAssociatedObject(base, &lastBackgroundURLKey) as? NSMutableDictionary
         if dictionary == nil {
             dictionary = NSMutableDictionary()
-            kf_setBackgroundWebURLs(dictionary!)
+            setBackgroundWebURLs(dictionary!)
         }
         return dictionary!
     }
     
-    fileprivate func kf_setBackgroundWebURLs(_ URLs: NSMutableDictionary) {
-        objc_setAssociatedObject(self, &lastBackgroundURLKey, URLs, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    fileprivate func setBackgroundWebURLs(_ URLs: NSMutableDictionary) {
+        objc_setAssociatedObject(base, &lastBackgroundURLKey, URLs, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
     }
     
-    fileprivate var kf_backgroundImageTask: RetrieveImageTask? {
-        return objc_getAssociatedObject(self, &backgroundImageTaskKey) as? RetrieveImageTask
+    fileprivate var backgroundImageTask: RetrieveImageTask? {
+        return objc_getAssociatedObject(base, &backgroundImageTaskKey) as? RetrieveImageTask
     }
     
-    fileprivate func kf_setBackgroundImageTask(_ task: RetrieveImageTask?) {
-        objc_setAssociatedObject(self, &backgroundImageTaskKey, task, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    fileprivate func setBackgroundImageTask(_ task: RetrieveImageTask?) {
+        objc_setAssociatedObject(base, &backgroundImageTaskKey, task, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
     }
 }
 
-// MARK: - Cancel image download tasks.
+// MARK: - Deprecated. Only for back compatibility.
+/**
+*	Set image to use from web for a specified state. Deprecated. Use `kf` namespacing instead.
+*/
 extension UIButton {
+    /**
+    Set an image to use for a specified state with a resource, a placeholder image, options, progress handler and 
+     completion handler.
+    
+    - parameter resource:          Resource object contains information such as `cacheKey` and `downloadURL`.
+    - parameter state:             The state that uses the specified image.
+    - parameter placeholder:       A placeholder image when retrieving the image at URL.
+    - parameter options:           A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
+    - parameter progressBlock:     Called when the image downloading progress gets updated.
+    - parameter completionHandler: Called when the image retrieved and set.
+    
+    - returns: A task represents the retrieving process.
+     
+    - note: Both the `progressBlock` and `completionHandler` will be invoked in main thread.
+     The `CallbackDispatchQueue` specified in `optionsInfo` will not be used in callbacks of this method.
+    */
+    @discardableResult
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated. Use `button.kf.setImage` instead.",
+    renamed: "kf.setImage")
+    public func kf_setImage(with resource: Resource?,
+                                for state: UIControlState,
+                              placeholder: UIImage? = nil,
+                                  options: KingfisherOptionsInfo? = nil,
+                            progressBlock: DownloadProgressBlock? = nil,
+                        completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
+    {
+        return kf.setImage(with: resource, for: state, placeholder: placeholder, options: options,
+                              progressBlock: progressBlock, completionHandler: completionHandler)
+    }
+    
     /**
      Cancel the image download task bounded to the image view if it is running.
      Nothing will happen if the downloading has already finished.
      */
-    public func kf_cancelImageDownloadTask() {
-        kf_imageTask?.downloadTask?.cancel()
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated. Use `button.kf.cancelImageDownloadTask` instead.",
+    renamed: "kf.cancelImageDownloadTask")
+    public func kf_cancelImageDownloadTask() { kf.cancelImageDownloadTask() }
+    
+    /**
+     Set the background image to use for a specified state with a resource,
+     a placeholder image, options progress handler and completion handler.
+     
+     - parameter resource:          Resource object contains information such as `cacheKey` and `downloadURL`.
+     - parameter state:             The state that uses the specified image.
+     - parameter placeholder:       A placeholder image when retrieving the image at URL.
+     - parameter options:           A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
+     - parameter progressBlock:     Called when the image downloading progress gets updated.
+     - parameter completionHandler: Called when the image retrieved and set.
+     
+     - returns: A task represents the retrieving process.
+     
+     - note: Both the `progressBlock` and `completionHandler` will be invoked in main thread.
+     The `CallbackDispatchQueue` specified in `optionsInfo` will not be used in callbacks of this method.
+     */
+    @discardableResult
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated. Use `button.kf.setBackgroundImage` instead.",
+    renamed: "kf.setBackgroundImage")
+    public func kf_setBackgroundImage(with resource: Resource?,
+                                      for state: UIControlState,
+                                      placeholder: UIImage? = nil,
+                                      options: KingfisherOptionsInfo? = nil,
+                                      progressBlock: DownloadProgressBlock? = nil,
+                                      completionHandler: CompletionHandler? = nil) -> RetrieveImageTask
+    {
+        return kf.setBackgroundImage(with: resource, for: state, placeholder: placeholder, options: options,
+                                     progressBlock: progressBlock, completionHandler: completionHandler)
     }
     
     /**
      Cancel the background image download task bounded to the image view if it is running.
      Nothing will happen if the downloading has already finished.
      */
-    public func kf_cancelBackgroundImageDownloadTask() {
-        kf_backgroundImageTask?.downloadTask?.cancel()
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated. Use `button.kf.cancelBackgroundImageDownloadTask` instead.",
+    renamed: "kf.cancelBackgroundImageDownloadTask")
+    public func kf_cancelBackgroundImageDownloadTask() { kf.cancelBackgroundImageDownloadTask() }
+    
+    /**
+     Get the image URL binded to this button for a specified state.
+     
+     - parameter state: The state that uses the specified image.
+     
+     - returns: Current URL for image.
+     */
+    @available(*, deprecated,
+        message: "Extensions directly on UIButton are deprecated. Use `button.kf.webURL` instead.",
+        renamed: "kf.webURL")
+    public func kf_webURL(for state: UIControlState) -> URL? { return kf.webURL(for: state) }
+    
+    @available(*, deprecated, message: "Extensions directly on UIButton are deprecated.",renamed: "kf.setWebURL")
+    fileprivate func kf_setWebURL(_ url: URL, for state: UIControlState) { kf.setWebURL(url, for: state) }
+    
+    @available(*, deprecated, message: "Extensions directly on UIButton are deprecated.",renamed: "kf.webURLs")
+    fileprivate var kf_webURLs: NSMutableDictionary { return kf.webURLs }
+    
+    @available(*, deprecated, message: "Extensions directly on UIButton are deprecated.",renamed: "kf.setWebURLs")
+    fileprivate func kf_setWebURLs(_ URLs: NSMutableDictionary) { kf.setWebURLs(URLs) }
+    
+    @available(*, deprecated, message: "Extensions directly on UIButton are deprecated.",renamed: "kf.imageTask")
+    fileprivate var kf_imageTask: RetrieveImageTask? { return kf.imageTask }
+    
+    @available(*, deprecated, message: "Extensions directly on UIButton are deprecated.",renamed: "kf.setImageTask")
+    fileprivate func kf_setImageTask(_ task: RetrieveImageTask?) { kf.setImageTask(task) }
+    
+    /**
+     Get the background image URL binded to this button for a specified state.
+     
+     - parameter state: The state that uses the specified background image.
+     
+     - returns: Current URL for background image.
+     */
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated. Use `button.kf.backgroundWebURL` instead.",
+    renamed: "kf.backgroundWebURL")
+    public func kf_backgroundWebURL(for state: UIControlState) -> URL? { return kf.backgroundWebURL(for: state) }
+    
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated.",renamed: "kf.setBackgroundWebURL")
+    fileprivate func kf_setBackgroundWebURL(_ url: URL, for state: UIControlState) {
+        kf.setBackgroundWebURL(url, for: state)
     }
+    
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated.",renamed: "kf.backgroundWebURLs")
+    fileprivate var kf_backgroundWebURLs: NSMutableDictionary { return kf.backgroundWebURLs }
+    
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated.",renamed: "kf.setBackgroundWebURLs")
+    fileprivate func kf_setBackgroundWebURLs(_ URLs: NSMutableDictionary) { kf.setBackgroundWebURLs(URLs) }
+    
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated.",renamed: "kf.backgroundImageTask")
+    fileprivate var kf_backgroundImageTask: RetrieveImageTask? { return kf.backgroundImageTask }
+    
+    @available(*, deprecated,
+    message: "Extensions directly on UIButton are deprecated.",renamed: "kf.setBackgroundImageTask")
+    fileprivate func kf_setBackgroundImageTask(_ task: RetrieveImageTask?) { return kf.setBackgroundImageTask(task) }
+    
 }

Tests/KingfisherTests/UIButtonExtensionTests.swift

@@ -71,7 +71,7 @@ class UIButtonExtensionTests: XCTestCase {
         
         cleanDefaultCache()
         
-        button.kf_setImage(with: url, for: .highlighted, placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
+        button.kf.setImage(with: url, for: .highlighted, placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
             progressBlockIsCalled = true
         }) { (image, error, cacheType, imageURL) -> () in
             expectation.fulfill()
@@ -80,7 +80,7 @@ class UIButtonExtensionTests: XCTestCase {
             XCTAssert(image != nil, "Downloaded image should exist.")
             XCTAssert(image! == testImage, "Downloaded image should be the same as test image.")
             XCTAssert(self.button.image(for: UIControlState.highlighted)! == testImage, "Downloaded image should be already set to the image for state")
-            XCTAssert(self.button.kf_webURL(for: .highlighted) == imageURL, "Web URL should equal to the downloaded url.")
+            XCTAssert(self.button.kf.webURL(for: .highlighted) == imageURL, "Web URL should equal to the downloaded url.")
             XCTAssert(cacheType == .none, "The cache type should be none here. This image was just downloaded. But now is: \(cacheType)")
         }
         waitForExpectations(timeout: 5, handler: nil)
@@ -94,7 +94,7 @@ class UIButtonExtensionTests: XCTestCase {
         let url = Foundation.URL(string: URLString)!
         
         var progressBlockIsCalled = false
-        button.kf_setBackgroundImage(with: url, for: .normal, placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
+        button.kf.setBackgroundImage(with: url, for: .normal, placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
             progressBlockIsCalled = true
             }) { (image, error, cacheType, imageURL) -> () in
                 expectation.fulfill()
@@ -103,7 +103,7 @@ class UIButtonExtensionTests: XCTestCase {
                 XCTAssert(image != nil, "Downloaded image should exist.")
                 XCTAssert(image! == testImage, "Downloaded image should be the same as test image.")
                 XCTAssert(self.button.backgroundImage(for: .normal)! == testImage, "Downloaded image should be already set to the image for state")
-                XCTAssert(self.button.kf_backgroundWebURL(for: .normal) == imageURL, "Web URL should equal to the downloaded url.")
+                XCTAssert(self.button.kf.backgroundWebURL(for: .normal) == imageURL, "Web URL should equal to the downloaded url.")
                 XCTAssert(cacheType == .none, "cacheType should be .None since the image was just downloaded.")
 
         }
@@ -117,7 +117,7 @@ class UIButtonExtensionTests: XCTestCase {
         let stub = stubRequest("GET", URLString).andReturn(200)?.withBody(testImageData)?.delay()
         let url = URL(string: URLString)!
 
-        button.kf_setImage(with: url, for: UIControlState.highlighted, placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
+        button.kf.setImage(with: url, for: UIControlState.highlighted, placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
                 XCTFail("Progress block should not be called.")
             }) { (image, error, cacheType, imageURL) -> () in
                 XCTAssertNotNil(error)
@@ -126,7 +126,7 @@ class UIButtonExtensionTests: XCTestCase {
                 expectation.fulfill()
         }
         DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + Double(Int64(Double(NSEC_PER_SEC) * 0.1)) / Double(NSEC_PER_SEC)) { () -> Void in
-            self.button.kf_cancelImageDownloadTask()
+            self.button.kf.cancelImageDownloadTask()
             _ = stub!.go()
         }
 
@@ -140,7 +140,7 @@ class UIButtonExtensionTests: XCTestCase {
         let stub = stubRequest("GET", URLString).andReturn(200)?.withBody(testImageData)?.delay()
         let url = URL(string: URLString)!
         
-        button.kf_setBackgroundImage(with: url, for: UIControlState(), placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
+        button.kf.setBackgroundImage(with: url, for: UIControlState(), placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
             XCTFail("Progress block should not be called.")
             }) { (image, error, cacheType, imageURL) -> () in
                 XCTAssertNotNil(error)
@@ -149,7 +149,7 @@ class UIButtonExtensionTests: XCTestCase {
                 expectation.fulfill()
         }
         DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + Double(Int64(Double(NSEC_PER_SEC) * 0.1)) / Double(NSEC_PER_SEC)) { () -> Void in
-            self.button.kf_cancelBackgroundImageDownloadTask()
+            self.button.kf.cancelBackgroundImageDownloadTask()
             _ = stub!.go()
         }
         
@@ -160,7 +160,7 @@ class UIButtonExtensionTests: XCTestCase {
         let expectation = self.expectation(description: "wait for downloading image")
         
         let url: URL? = nil
-        button.kf_setBackgroundImage(with: url, for: UIControlState(), placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
+        button.kf.setBackgroundImage(with: url, for: UIControlState(), placeholder: nil, options: nil, progressBlock: { (receivedSize, totalSize) -> () in
             XCTFail("Progress block should not be called.")
         }) { (image, error, cacheType, imageURL) -> () in
             XCTAssertNil(image)