Add bindable property to wrap a control's value (#119)

* Provide a `setUp` to properly configure the associated property

The introduced `setUp` is extremely helpful to setup any signals that may
affect the property once.

* Add bindable property to wrap a control's value

This property is common to every `UIControl` and can be used by
providing a getter and a setter for the value wrapped. This property
uses `UIControlEvents.ValueChanged` and `UIControlEvents.EditingChanged`
events to detect changes and keep the value up-to-date. This kind of
logic can be reused instead of being defined and used for each control.

* Use `setUp` to install the dependent signal of `rex_dismissAnimated`

This prevents repetition of events in cases where the property is
accessed more than once (each access adds a new `rac_signalForSelector`
for the dismiss of the view controller).

* Fixes #129 - UITextField's text bindable property should be of optional type

Author: dmcrodrigues

Rex.xcodeproj/project.pbxproj

@@ -50,10 +50,12 @@ public func associatedProperty<T: AnyObject>(host: AnyObject, keyPath: StaticStr
 /// This can be used as an alternative to `DynamicProperty` for creating strongly typed
 /// bindings on Cocoa objects.
 @warn_unused_result(message="Did you forget to use the property?")
-public func associatedProperty<Host: AnyObject, T>(host: Host, key: UnsafePointer<()>, @noescape initial: Host -> T, setter: (Host, T) -> ()) -> MutableProperty<T> {
+public func associatedProperty<Host: AnyObject, T>(host: Host, key: UnsafePointer<()>, @noescape initial: Host -> T, setter: (Host, T) -> (), @noescape setUp: MutableProperty<T> -> () = { _ in }) -> MutableProperty<T> {
     return associatedObject(host, key: key) { host in
         let property = MutableProperty(initial(host))
 
+        setUp(property)
+
         property.producer.startWithNext { [weak host] next in
             if let host = host {
                 setter(host, next)

Source/Foundation/Association.swift

@@ -11,6 +11,7 @@ import UIKit
 import enum Result.NoError
 
 extension UIControl {
+
 #if os(iOS)
     /// Creates a producer for the sender whenever a specified control event is triggered.
     @warn_unused_result(message="Did you forget to use the property?")
@@ -20,6 +21,21 @@ extension UIControl {
             .map { $0 as? UIControl }
             .flatMapError { _ in SignalProducer(value: nil) }
     }
+
+    /// Creates a bindable property to wrap a control's value.
+    /// 
+    /// This property uses `UIControlEvents.ValueChanged` and `UIControlEvents.EditingChanged` 
+    /// events to detect changes and keep the value up-to-date.
+    //
+    @warn_unused_result(message="Did you forget to use the property?")
+    class func rex_value<Host: UIControl, T>(host: Host, getter: Host -> T, setter: (Host, T) -> ()) -> MutableProperty<T> {
+        return associatedProperty(host, key: &valueChangedKey, initial: getter, setter: setter) { property in
+            property <~
+                host.rex_controlEvents([.ValueChanged, .EditingChanged])
+                    .filterMap { $0 as? Host }
+                    .filterMap(getter)
+        }
+    }
 #endif
 
     /// Wraps a control's `enabled` state in a bindable property.
@@ -41,3 +57,4 @@ extension UIControl {
 private var enabledKey: UInt8 = 0
 private var selectedKey: UInt8 = 0
 private var highlightedKey: UInt8 = 0
+private var valueChangedKey: UInt8 = 0

Source/UIKit/UIControl.swift

@@ -5,24 +5,14 @@
 //  Created by Guido Marucci Blas on 3/25/16.
 //  Copyright © 2016 Neil Pankey. All rights reserved.
 //
-import UIKit
+
 import ReactiveCocoa
+import UIKit
 
 extension UIDatePicker {
-    
+
+    // Wraps a datePicker's `date` value in a bindable property.
     public var rex_date: MutableProperty<NSDate> {
-        let initial = { (picker: UIDatePicker) -> NSDate in
-            picker.addTarget(self, action: #selector(UIDatePicker.rex_changedDate), forControlEvents: .ValueChanged)
-            return picker.date
-        }
-        return associatedProperty(self, key: &dateKey, initial: initial) { $0.date = $1 }
-    }
-    
-    @objc
-    private func rex_changedDate() {
-        rex_date.value = date
+        return UIControl.rex_value(self, getter: { $0.date }, setter: { $0.date = $1 })
     }
-    
 }
-
-private var dateKey: UInt8 = 0

Source/UIKit/UIDatePicker.swift

@@ -11,17 +11,8 @@ import UIKit
 
 extension UISwitch {
 
-    /// Wraps a switch's `on` state in a bindable property.
+    /// Wraps a switch's `on` value in a bindable property.
     public var rex_on: MutableProperty<Bool> {
-
-        let property = associatedProperty(self, key: &onKey, initial: { $0.on }, setter: { $0.on = $1 })
-
-        property <~ rex_controlEvents(.ValueChanged)
-            .filterMap { ($0 as? UISwitch)?.on }
-
-        return property
+        return UIControl.rex_value(self, getter: { $0.on }, setter: { $0.on = $1 })
     }
-    
 }
-
-private var onKey: UInt8 = 0

Source/UIKit/UISwitch.swift

@@ -8,14 +8,25 @@
 
 import ReactiveCocoa
 import UIKit
-import enum Result.NoError
 
 extension UITextField {
 
-    /// Sends the field's string value whenever it changes.
-    public var rex_text: SignalProducer<String, NoError> {
-        return NSNotificationCenter.defaultCenter()
-            .rac_notifications(UITextFieldTextDidChangeNotification, object: self)
-            .filterMap  { ($0.object as? UITextField)?.text }
+    /// Wraps a textField's `text` value in a bindable property.
+    public var rex_text: MutableProperty<String?> {
+        let getter: UITextField -> String? = { $0.text }
+        let setter: (UITextField, String?) -> () = { $0.text = $1 }
+#if os(iOS)
+        return UIControl.rex_value(self, getter: getter, setter: setter)
+#else
+        return associatedProperty(self, key: &textKey, initial: getter, setter: setter) { property in
+            property <~
+                NSNotificationCenter.defaultCenter()
+                    .rac_notifications(UITextFieldTextDidChangeNotification, object: self)
+                    .filterMap  { ($0.object as? UITextField)?.text }
+            }
+#endif
     }
+
 }
+
+private var textKey: UInt8 = 0

Source/UIKit/UITextField.swift

@@ -63,13 +63,12 @@ extension UIViewController {
             host.dismissViewControllerAnimated(unwrapped.animated, completion: unwrapped.completion)
         }
 
-        let property = associatedProperty(self, key: &dismissModally, initial: initial, setter: setter)
-        
-        property <~ rac_signalForSelector(#selector(UIViewController.dismissViewControllerAnimated(_:completion:)))
-            .takeUntilBlock { _ in property.value != nil }
-            .rex_toTriggerSignal()
-            .map { _ in return nil }
-
+        let property = associatedProperty(self, key: &dismissModally, initial: initial, setter: setter) { property in
+            property <~ self.rac_signalForSelector(#selector(UIViewController.dismissViewControllerAnimated(_:completion:)))
+                .takeUntilBlock { _ in property.value != nil }
+                .rex_toTriggerSignal()
+                .map { _ in return nil }
+        }
 
         return property
     }

Source/UIKit/UIViewController.swift

@@ -0,0 +1,57 @@
+//
+//  UIControl+EnableSendActionsForControlEvents.swift
+//  Rex
+//
+//  Created by David Rodrigues on 24/04/16.
+//  Copyright © 2016 Neil Pankey. All rights reserved.
+//
+
+import UIKit
+
+/// Unfortunately, there's an apparent limitation in using `sendActionsForControlEvents`
+/// on unit-tests for any control besides `UIButton` which is very unfortunate since we
+/// want test our bindings for `UIDatePicker`, `UISwitch`, `UITextField` and others
+/// in the future. To be able to test them, we're now using swizzling to manually invoke
+/// the pair target+action.
+extension UIControl {
+
+    public override class func initialize() {
+
+        struct Static {
+            static var token: dispatch_once_t = 0
+        }
+
+        if self !== UIControl.self {
+            return
+        }
+
+        dispatch_once(&Static.token) {
+
+            let originalSelector = #selector(UIControl.sendAction(_:to:forEvent:))
+            let swizzledSelector = #selector(UIControl.rex_sendAction(_:to:forEvent:))
+
+            let originalMethod = class_getInstanceMethod(self, originalSelector)
+            let swizzledMethod = class_getInstanceMethod(self, swizzledSelector)
+
+            let didAddMethod = class_addMethod(self,
+                                               originalSelector,
+                                               method_getImplementation(swizzledMethod),
+                                               method_getTypeEncoding(swizzledMethod))
+
+            if didAddMethod {
+                class_replaceMethod(self,
+                                    swizzledSelector,
+                                    method_getImplementation(originalMethod),
+                                    method_getTypeEncoding(originalMethod))
+            } else {
+                method_exchangeImplementations(originalMethod, swizzledMethod)
+            }
+        }
+    }
+
+    // MARK: - Method Swizzling
+
+    func rex_sendAction(action: Selector, to target: AnyObject?, forEvent event: UIEvent?) {
+        target?.performSelector(action, withObject: self)
+    }
+}

Tests/Helpers/UIControl+EnableSendActionsForControlEvents.swift

@@ -30,8 +30,7 @@ class UIDatePickerTests: XCTestCase {
         XCTAssertEqual(picker.date, date)
     }
 
-    // FIXME Can this actually be made to work inside XCTest?
-    func _testUpdatePropertyFromPicker() {
+    func testUpdatePropertyFromPicker() {
         let expectation = self.expectationWithDescription("Expected rex_date to send an event when picker's date value is changed by a UI event")
         defer { self.waitForExpectationsWithTimeout(2, handler: nil) }
 

Tests/UIKit/UIDatePickerTests.swift

@@ -13,15 +13,19 @@ import Result
 class UISwitchTests: XCTestCase {
 
     func testOnProperty() {
-        let s = UISwitch(frame: CGRectZero)
-        s.on = false
+        let `switch` = UISwitch(frame: CGRectZero)
+        `switch`.on = false
 
         let (pipeSignal, observer) = Signal<Bool, NoError>.pipe()
-        s.rex_on <~ SignalProducer(signal: pipeSignal)
+        `switch`.rex_on <~ SignalProducer(signal: pipeSignal)
 
         observer.sendNext(true)
-        XCTAssertTrue(s.on)
+        XCTAssertTrue(`switch`.on)
         observer.sendNext(false)
-        XCTAssertFalse(s.on)
+        XCTAssertFalse(`switch`.on)
+
+        `switch`.on = true
+        `switch`.sendActionsForControlEvents(.ValueChanged)
+        XCTAssertTrue(`switch`.rex_on.value)
     }
 }