Implement the argument bridging logic.

Author: andersio

ReactiveCocoa/NSObject+Intercepting.swift

@@ -43,8 +43,134 @@ extension Reactive where Base: NSObject {
 			return signal
 		}
 	}
+
+	/// Create a signal which sends a `next` event, containing an array of bridged
+	/// arguments, at the end of every invocation of `selector` on the object.
+	///
+	/// `trigger(for:from:)` can be used to intercept optional protocol
+	/// requirements by supplying the protocol as `protocol`. The instance need
+	/// not have a concrete implementation of the requirement.
+	///
+	/// However, as Cocoa classes usually cache information about delegate
+	/// conformances, trigger signals for optional, unbacked protocol requirements
+	/// should be set up before the instance is assigned as the corresponding
+	/// delegate.
+	///
+	/// - parameters:
+	///   - selector: The selector to observe.
+	///   - protocol: The protocol of the selector, or `nil` if the selector does
+	///               not belong to any protocol.
+	///
+	/// - returns:
+	///   A signal that sends an array of bridged arguments.
+	public func signal(for selector: Selector, from protocol: Protocol? = nil) -> Signal<[Any?], NoError> {
+		return base.synchronized {
+			let map = associatedValue { _ in NSMutableDictionary() }
+
+			let selectorName = String(describing: selector) as NSString
+			if let signal = map.object(forKey: selectorName) as! Signal<[Any?], NoError>? {
+				return signal
+			}
+
+			let (signal, observer) = Signal<[Any?], NoError>.pipe()
+			let isSuccessful = base._rac_setupInvocationObservation(for: selector,
+			                                                        protocol: `protocol`,
+			                                                        receiver: bridge(observer))
+			precondition(isSuccessful)
+
+			lifetime.ended.observeCompleted(observer.sendCompleted)
+			map.setObject(signal, forKey: selectorName)
+
+			return signal
+		}
+	}
+}
+
+private func bridge(_ observer: Observer<[Any?], NoError>) -> (RACSwiftInvocationArguments) -> Void {
+	return { arguments in
+		let count = arguments.count
+
+		var bridged = [Any?]()
+		bridged.reserveCapacity(count - 2)
+
+		// Ignore `self` and `_cmd`.
+		for position in 2 ..< count {
+			let encoding = TypeEncoding(rawValue: arguments.argumentType(at: position).pointee) ?? .undefined
+
+			func extract<U>(_ type: U.Type) -> U {
+				let pointer = UnsafeMutableRawPointer.allocate(bytes: MemoryLayout<U>.size,
+				                                               alignedTo: MemoryLayout<U>.alignment)
+				defer {
+					pointer.deallocate(bytes: MemoryLayout<U>.size,
+					                   alignedTo: MemoryLayout<U>.alignment)
+				}
+
+				arguments.copyArgument(at: position, to: pointer)
+				return pointer.assumingMemoryBound(to: type).pointee
+			}
+
+			switch encoding {
+			case .char:
+				bridged.append(extract(CChar.self))
+			case .int:
+				bridged.append(extract(CInt.self))
+			case .short:
+				bridged.append(extract(CShort.self))
+			case .long:
+				bridged.append(extract(CLong.self))
+			case .longLong:
+				bridged.append(extract(CLongLong.self))
+
+			case .unsignedChar:
+				bridged.append(extract(CUnsignedChar.self))
+			case .unsignedInt:
+				bridged.append(extract(CUnsignedInt.self))
+			case .unsignedShort:
+				bridged.append(extract(CUnsignedShort.self))
+			case .unsignedLong:
+				bridged.append(extract(CUnsignedLong.self))
+
+			case .bitfield:
+				fallthrough
+			case .unsignedLongLong:
+				bridged.append(extract(CUnsignedLongLong.self))
+
+			case .float:
+				bridged.append(extract(CFloat.self))
+			case .double:
+				bridged.append(extract(CDouble.self))
+
+			case .bool:
+				bridged.append(extract(CBool.self))
+			case .void:
+				bridged.append(())
+
+			case .cString:
+				var pointer: UnsafePointer<Int8>?
+				arguments.copyArgument(at: position, to: &pointer)
+				bridged.append(pointer.map(String.init(cString:)))
+
+			case .object:
+				bridged.append(extract((AnyObject?).self))
+			case .type:
+				bridged.append(extract((AnyClass?).self))
+
+			case .selector:
+				bridged.append(arguments.selectorString(at: position))
+
+			case .array:
+				bridged.append(extract(OpaquePointer.self))
+
+			case .undefined:
+				bridged.append(nil)
+			}
+		}
+
+		observer.send(value: bridged)
+	}
 }
 
+
 private enum TypeEncoding: Int8 {
 	// Integer
 	case char = 99
@@ -72,6 +198,7 @@ private enum TypeEncoding: Int8 {
 	case selector = 58
 	case array = 91
 	case bitfield = 98
-	case pointer = 94
 	// Note: Structure `{` and union `(` are not supported.
+
+	case undefined = -1
 }

ReactiveCocoa/RACObjCRuntimeUtilities.h

@@ -7,6 +7,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 -(const char *)argumentTypeAt:(NSInteger)position;
 -(void)copyArgumentAt:(NSInteger)position to:(void *)buffer;
+-(NSString*)selectorStringAt:(NSInteger)position;
 
 @end
 

ReactiveCocoa/RACObjCRuntimeUtilities.m

@@ -321,7 +321,7 @@ -(instancetype) initWithInvocation:(NSInvocation *)inv {
 	return self;
 }
 
--(NSInteger)getCount {
+-(NSInteger)count {
 	return [[invocation methodSignature] numberOfArguments];
 }
 
@@ -333,4 +333,10 @@ -(void)copyArgumentAt:(NSInteger)position to:(void *)buffer {
 	[invocation getArgument:buffer atIndex:position];
 }
 
+-(NSString*)selectorStringAt:(NSInteger)position {
+	SEL selector;
+	[invocation getArgument:&selector atIndex:position];
+	return NSStringFromSelector(selector);
+}
+
 @end

ReactiveCocoaTests/InterceptingSpec.swift

@@ -56,7 +56,6 @@ class InterceptingSpec: QuickSpec {
 
 				(object as TestProtocol).optionalMethod!()
 				expect(counter) == 2
-
 			}
 
 			it("should complete when the object deinitializes") {
@@ -110,6 +109,118 @@ class InterceptingSpec: QuickSpec {
 				}
 			}
 		}
+
+		describe("signal(for:)") {
+			var object: InterceptedObject!
+			weak var _object: InterceptedObject?
+
+			beforeEach {
+				object = InterceptedObject()
+				_object = object
+			}
+
+			afterEach {
+				object = nil
+				expect(_object).to(beNil())
+			}
+
+			it("should send a value with bridged arguments") {
+				let signal = object.reactive.signal(for: #selector(object.test))
+
+				var arguments = [[Any?]]()
+				signal.observeValues { arguments.append($0) }
+
+				expect(arguments.count) == 0
+
+				let firstObject = NSObject()
+				object.test(a: 1, b: 10.0, c: firstObject, d: nil)
+				expect(arguments.count) == 1
+
+				expect(arguments[0][0] as? Int64) == 1
+				expect(arguments[0][1] as? Double) == 10.0
+				expect(arguments[0][2] as? NSObject) == firstObject
+				expect(arguments[0][3] as! NSObject?).to(beNil())
+
+				let secondObject = NSObject()
+				object.test(a: 2, b: 20.0, c: secondObject, d: nil)
+				expect(arguments.count) == 2
+
+				expect(arguments[1][0] as? Int64) == 2
+				expect(arguments[1][1] as? Double) == 20.0
+				expect(arguments[1][2] as? NSObject) == secondObject
+				expect(arguments[1][3] as! NSObject?).to(beNil())
+			}
+
+			it("should send a value when the selector is invoked without implementation") {
+				let selector = #selector(TestProtocol.optionalMethod)
+
+				let signal = object.reactive.signal(for: selector,
+				                                     from: TestProtocol.self)
+				expect(object.responds(to: selector)) == true
+
+				var counter = 0
+				signal.observeValues { _ in counter += 1 }
+
+				expect(counter) == 0
+
+				(object as TestProtocol).optionalMethod!()
+				expect(counter) == 1
+
+				(object as TestProtocol).optionalMethod!()
+				expect(counter) == 2
+			}
+
+			it("should complete when the object deinitializes") {
+				let signal = object.reactive.signal(for: #selector(object.increment))
+
+				var isCompleted = false
+				signal.observeCompleted { isCompleted = true }
+				expect(isCompleted) == false
+
+				object = nil
+				expect(_object).to(beNil())
+				expect(isCompleted) == true
+			}
+
+			it("should multicast") {
+				let signal1 = object.reactive.signal(for: #selector(object.increment))
+				let signal2 = object.reactive.signal(for: #selector(object.increment))
+
+				var counter1 = 0
+				var counter2 = 0
+				signal1.observeValues { _ in counter1 += 1 }
+				signal2.observeValues { _ in counter2 += 1 }
+
+				expect(counter1) == 0
+				expect(counter2) == 0
+
+				object.increment()
+				expect(counter1) == 1
+				expect(counter2) == 1
+
+				object.increment()
+				expect(counter1) == 2
+				expect(counter2) == 2
+			}
+
+			it("should not deadlock") {
+				for _ in 1 ... 10 {
+					var isDeadlocked = true
+
+					DispatchQueue.global(priority: .high).async {
+						_ = object.reactive.signal(for: #selector(object.increment))
+
+						DispatchQueue.global(priority: .high).async {
+							_ = object.reactive.signal(for: #selector(object.increment))
+
+							isDeadlocked = false
+						}
+					}
+					
+					expect(isDeadlocked).toEventually(beFalsy())
+				}
+			}
+		}
 	}
 }
 
@@ -119,9 +230,10 @@ class InterceptingSpec: QuickSpec {
 
 class InterceptedObject: NSObject, TestProtocol {
 	var counter = 0
-	var testProtocolCounter = 0
 
 	dynamic func increment() {
 		counter += 1
 	}
+
+	dynamic func test(a: Int, b: Double, c: NSObject, d: NSObject?) {}
 }