Remove DelegateProxy.Delegate type condition.

tarunon · kzaher · commit 68484a6c73a7 · 2017-10-29T18:59:58.000+01:00
diff --git a/RxCocoa/Common/DelegateProxy.swift b/RxCocoa/Common/DelegateProxy.swift
@@ -18,7 +18,7 @@
     /// Base class for `DelegateProxyType` protocol.
     ///
     /// This implementation is not thread safe and can be used only from one thread (Main thread).
-    open class DelegateProxy<P: AnyObject, D: AnyObject>: _RXDelegateProxy {
+    open class DelegateProxy<P: AnyObject, D>: _RXDelegateProxy {
         public typealias ParentObject = P
         public typealias Delegate = D
 
@@ -28,17 +28,17 @@
         /// Parent object associated with delegate proxy.
         private weak private(set) var _parentObject: ParentObject?
 
-        fileprivate let _currentDelegateFor: (ParentObject) -> Delegate?
-        fileprivate let _setCurrentDelegateTo: (Delegate?, ParentObject) -> ()
+        fileprivate let _currentDelegateFor: (ParentObject) -> AnyObject?
+        fileprivate let _setCurrentDelegateTo: (AnyObject?, ParentObject) -> ()
 
         /// Initializes new instance.
         ///
         /// - parameter parentObject: Optional parent object that owns `DelegateProxy` as associated object.
         public init<Proxy: DelegateProxyType>(parentObject: ParentObject, delegateProxy: Proxy.Type)
             where Proxy: DelegateProxy<ParentObject, Delegate>, Proxy.ParentObject == ParentObject, Proxy.Delegate == Delegate {
             self._parentObject = parentObject
-            self._currentDelegateFor = delegateProxy.currentDelegate(for:)
-            self._setCurrentDelegateTo = delegateProxy.setCurrentDelegate(_:to:)
+            self._currentDelegateFor = delegateProxy._currentDelegate
+            self._setCurrentDelegateTo = delegateProxy._setCurrentDelegate
 
             MainScheduler.ensureExecutingOnScheduler()
             #if TRACE_RESOURCES
diff --git a/RxCocoa/Common/DelegateProxyType.swift b/RxCocoa/Common/DelegateProxyType.swift
@@ -74,7 +74,7 @@ Since RxCocoa needs to automagically create those Proxys and because views that
 */
 public protocol DelegateProxyType: class {
     associatedtype ParentObject: AnyObject
-    associatedtype Delegate: AnyObject
+    associatedtype Delegate
     
     /// It is require that enumerate call `register` of the extended DelegateProxy subclasses here.
     static func registerKnownImplementations()
@@ -130,6 +130,25 @@ extension DelegateProxyType {
     }
 }
 
+// workaround of Delegate: class
+extension DelegateProxyType {
+    static func _currentDelegate(for object: ParentObject) -> AnyObject? {
+        return currentDelegate(for: object).map { $0 as AnyObject }
+    }
+    
+    static func _setCurrentDelegate(_ delegate: AnyObject?, to object: ParentObject) {
+        return setCurrentDelegate(castOptionalOrFatalError(delegate), to: object)
+    }
+    
+    func _forwardToDelegate() -> AnyObject? {
+        return forwardToDelegate().map { $0 as AnyObject }
+    }
+    
+    func _setForwardToDelegate(_ forwardToDelegate: AnyObject?, retainDelegate: Bool) {
+        return setForwardToDelegate(castOptionalOrFatalError(forwardToDelegate), retainDelegate: retainDelegate)
+    }
+}
+
 extension DelegateProxyType {
 
     /// Store DelegateProxy subclass to factory.
@@ -168,8 +187,7 @@ extension DelegateProxyType {
 
         let maybeProxy = self.assignedProxy(for: object)
 
-        // Type is ideally be `(Self & Delegate)`, but Swift 3.0 doesn't support it.
-        let proxy: Delegate
+        let proxy: AnyObject
         if let existingProxy = maybeProxy {
             proxy = existingProxy
         }
@@ -178,15 +196,15 @@ extension DelegateProxyType {
             self.assignProxy(proxy, toObject: object)
             assert(self.assignedProxy(for: object) === proxy)
         }
-        let currentDelegate = self.currentDelegate(for: object)
+        let currentDelegate = self._currentDelegate(for: object)
         let delegateProxy: Self = castOrFatalError(proxy)
 
         if currentDelegate !== delegateProxy {
-            delegateProxy.setForwardToDelegate(currentDelegate, retainDelegate: false)
-            assert(delegateProxy.forwardToDelegate() === currentDelegate)
-            self.setCurrentDelegate(proxy, to: object)
-            assert(self.currentDelegate(for: object) === proxy)
-            assert(delegateProxy.forwardToDelegate() === currentDelegate)
+            delegateProxy._setForwardToDelegate(currentDelegate, retainDelegate: false)
+            assert(delegateProxy._forwardToDelegate() === currentDelegate)
+            self._setCurrentDelegate(proxy, to: object)
+            assert(self._currentDelegate(for: object) === proxy)
+            assert(delegateProxy._forwardToDelegate() === currentDelegate)
         }
 
         return delegateProxy
@@ -200,10 +218,10 @@ extension DelegateProxyType {
     /// - parameter onProxyForObject: Object that has `delegate` property.
     /// - returns: Disposable object that can be used to clear forward delegate.
     public static func installForwardDelegate(_ forwardDelegate: Delegate, retainDelegate: Bool, onProxyForObject object: ParentObject) -> Disposable {
-        weak var weakForwardDelegate: AnyObject? = forwardDelegate
+        weak var weakForwardDelegate: AnyObject? = forwardDelegate as AnyObject
         let proxy = self.proxy(for: object)
 
-        assert(proxy.forwardToDelegate() === nil, "This is a feature to warn you that there is already a delegate (or data source) set somewhere previously. The action you are trying to perform will clear that delegate (data source) and that means that some of your features that depend on that delegate (data source) being set will likely stop working.\n" +
+        assert(proxy._forwardToDelegate() === nil, "This is a feature to warn you that there is already a delegate (or data source) set somewhere previously. The action you are trying to perform will clear that delegate (data source) and that means that some of your features that depend on that delegate (data source) being set will likely stop working.\n" +
             "If you are ok with this, try to set delegate (data source) to `nil` in front of this operation.\n" +
             " This is the source object value: \(object)\n" +
             " This this the original delegate (data source) value: \(proxy.forwardToDelegate()!)\n" +
@@ -216,7 +234,7 @@ extension DelegateProxyType {
 
             let delegate: AnyObject? = weakForwardDelegate
 
-            assert(delegate == nil || proxy.forwardToDelegate() === delegate, "Delegate was changed from time it was first set. Current \(String(describing: proxy.forwardToDelegate())), and it should have been \(proxy)")
+            assert(delegate == nil || proxy._forwardToDelegate() === delegate, "Delegate was changed from time it was first set. Current \(String(describing: proxy.forwardToDelegate())), and it should have been \(proxy)")
 
             proxy.setForwardToDelegate(nil, retainDelegate: retainDelegate)
         }
@@ -225,27 +243,25 @@ extension DelegateProxyType {
 
 
 // fileprivate extensions
-extension DelegateProxyType
-{
+extension DelegateProxyType {
     fileprivate static var factory: DelegateProxyFactory {
         return DelegateProxyFactory.sharedFactory(for: self)
     }
 
-
-    fileprivate static func assignedProxy(for object: ParentObject) -> Delegate? {
+    fileprivate static func assignedProxy(for object: ParentObject) -> AnyObject? {
         let maybeDelegate = objc_getAssociatedObject(object, self.identifier)
-        return castOptionalOrFatalError(maybeDelegate.map { $0 as AnyObject })
+        return castOptionalOrFatalError(maybeDelegate)
     }
 
-    fileprivate static func assignProxy(_ proxy: Delegate, toObject object: ParentObject) {
+    fileprivate static func assignProxy(_ proxy: AnyObject, toObject object: ParentObject) {
         objc_setAssociatedObject(object, self.identifier, proxy, .OBJC_ASSOCIATION_RETAIN)
     }
 }
 
 /// Describes an object that has a delegate.
 public protocol HasDelegate: AnyObject {
     /// Delegate type
-    associatedtype Delegate: AnyObject
+    associatedtype Delegate
 
     /// Delegate
     var delegate: Delegate? { get set }
@@ -264,7 +280,7 @@ extension DelegateProxyType where ParentObject: HasDelegate, Self.Delegate == Pa
 /// Describes an object that has a data source.
 public protocol HasDataSource: AnyObject {
     /// Data source type
-    associatedtype DataSource: AnyObject
+    associatedtype DataSource
 
     /// Data source
     var dataSource: DataSource? { get set }
@@ -286,7 +302,8 @@ extension DelegateProxyType where ParentObject: HasDataSource, Self.Delegate ==
         extension ObservableType {
             func subscribeProxyDataSource<DelegateProxy: DelegateProxyType>(ofObject object: DelegateProxy.ParentObject, dataSource: DelegateProxy.Delegate, retainDataSource: Bool, binding: @escaping (DelegateProxy, Event<E>) -> Void)
                 -> Disposable
-                where DelegateProxy.ParentObject: UIView {
+                where DelegateProxy.ParentObject: UIView
+                , DelegateProxy.Delegate: AnyObject {
                 let proxy = DelegateProxy.proxy(for: object)
                 let unregisterDelegate = DelegateProxy.installForwardDelegate(dataSource, retainDelegate: retainDataSource, onProxyForObject: object)
                 // this is needed to flush any delayed old state (https://github.com/RxSwiftCommunity/RxDataSources/pull/75)
@@ -368,8 +385,7 @@ extension DelegateProxyType where ParentObject: HasDataSource, Self.Delegate ==
             _identifier = proxyType.identifier
         }
 
-        fileprivate func extend<DelegateProxy: DelegateProxyType, ParentObject>(make: @escaping (ParentObject) -> DelegateProxy)
-           {
+        fileprivate func extend<DelegateProxy: DelegateProxyType, ParentObject>(make: @escaping (ParentObject) -> DelegateProxy) {
                 MainScheduler.ensureExecutingOnScheduler()
                 precondition(_identifier == DelegateProxy.identifier, "Delegate proxy has inconsistent identifier")
                 precondition((DelegateProxy.self as? DelegateProxy.Delegate) != nil, "DelegateProxy subclass should be as a Delegate")
diff --git a/Tests/RxCocoaTests/DelegateProxyTest.swift b/Tests/RxCocoaTests/DelegateProxyTest.swift
@@ -32,7 +32,7 @@ import UIKit
 
 protocol TestDelegateControl: NSObjectProtocol {
     associatedtype TestParentObject: AnyObject
-    associatedtype TestDelegate: NSObjectProtocol
+    associatedtype TestDelegate
     func doThatTest(_ value: Int)
 
     var delegateProxy: DelegateProxy<TestParentObject, TestDelegate> { get }
@@ -348,6 +348,19 @@ extension DelegateProxyTest {
     }
 }
 
+extension DelegateProxyTest {
+    func test_InstallPureSwiftDelegateProxy() {
+        let view = PureSwiftView()
+        let mock = MockPureSwiftDelegate()
+        
+        view.delegate = mock
+        
+        let proxy = view.rx.proxy
+        XCTAssertTrue(view.delegate === proxy)
+        XCTAssertTrue(view.rx.proxy.forwardToDelegate() === mock)
+    }
+}
+
 #if os(iOS)
 extension DelegateProxyTest {
     func test_DelegateProxyHierarchyWorks() {
@@ -614,6 +627,43 @@ class ExtendClassViewDelegateProxy_b: InitialClassViewDelegateProxy {
     }
 }
 
+
+protocol PureSwiftDelegate: class {}
+
+class PureSwiftView: ReactiveCompatible {
+    weak var delegate: PureSwiftDelegate?
+}
+
+extension Reactive where Base: PureSwiftView {
+    var proxy: DelegateProxy<PureSwiftView, PureSwiftDelegate> {
+        return PureSwiftDelegateProxy.proxy(for: base)
+    }
+}
+
+class PureSwiftDelegateProxy
+    : DelegateProxy<PureSwiftView, PureSwiftDelegate>
+    , DelegateProxyType
+    , PureSwiftDelegate {
+    
+    init(parentObject: PureSwiftView) {
+        super.init(parentObject: parentObject, delegateProxy: PureSwiftDelegateProxy.self)
+    }
+    
+    static func registerKnownImplementations() {
+        self.register { PureSwiftDelegateProxy.init(parentObject: $0) }
+    }
+    
+    static func currentDelegate(for object: ParentObject) -> PureSwiftDelegate? {
+        return object.delegate
+    }
+    
+    static func setCurrentDelegate(_ delegate: PureSwiftDelegate?, to object: ParentObject) {
+        return object.delegate = delegate
+    }
+}
+
+final class MockPureSwiftDelegate: PureSwiftDelegate {}
+
 // }
 
 #if os(macOS)
