diff --git a/ReactiveObjC.xcodeproj/project.pbxproj b/ReactiveObjC.xcodeproj/project.pbxproj index f8eee09cb..fafbdf9b4 100644 --- a/ReactiveObjC.xcodeproj/project.pbxproj +++ b/ReactiveObjC.xcodeproj/project.pbxproj @@ -198,6 +198,9 @@ 7DFBED6C1CDB8DE300EE435B /* RACTestUIButton.m in Sources */ = {isa = PBXBuildFile; fileRef = D0C3131D19EF2D9700984962 /* RACTestUIButton.m */; }; 7DFBED6E1CDB918900EE435B /* UIBarButtonItem+RACCommandSupport.m in Sources */ = {isa = PBXBuildFile; fileRef = D03764C719EDA41200A782A9 /* UIBarButtonItem+RACCommandSupport.m */; }; 7DFBED6F1CDB926400EE435B /* UIBarButtonItem+RACCommandSupport.h in Headers */ = {isa = PBXBuildFile; fileRef = D03764C619EDA41200A782A9 /* UIBarButtonItem+RACCommandSupport.h */; settings = {ATTRIBUTES = (Public, ); }; }; + 9AE2F1121DD8BF96008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 9AE2F10E1DD8B827008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m */; }; + 9AE2F1131DD8BF97008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 9AE2F10E1DD8B827008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m */; }; + 9AE2F1141DD8BF98008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 9AE2F10E1DD8B827008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m */; }; A1046B7A1BFF5661004D8045 /* EXTRuntimeExtensions.h in Headers */ = {isa = PBXBuildFile; fileRef = D037666719EDA57100A782A9 /* EXTRuntimeExtensions.h */; settings = {ATTRIBUTES = (Private, ); }; }; A1046B7B1BFF5662004D8045 /* EXTRuntimeExtensions.h in Headers */ = {isa = PBXBuildFile; fileRef = D037666719EDA57100A782A9 /* EXTRuntimeExtensions.h */; settings = {ATTRIBUTES = (Private, ); }; }; A1046B7C1BFF5662004D8045 /* EXTRuntimeExtensions.h in Headers */ = {isa = PBXBuildFile; fileRef = D037666719EDA57100A782A9 /* EXTRuntimeExtensions.h */; settings = {ATTRIBUTES = (Private, ); }; }; @@ -769,6 +772,7 @@ 7A70657E1A3F88B8001E8354 /* RACKVOProxy.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOProxy.m; sourceTree = ""; }; 7A7065831A3F8967001E8354 /* RACKVOProxySpec.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RACKVOProxySpec.m; sourceTree = ""; }; 7DFBED031CDB8C9500EE435B /* ReactiveObjCTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = ReactiveObjCTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 9AE2F10E1DD8B827008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = NSObjectRACSelectorSignalPerformanceTests.m; sourceTree = ""; }; A97451331B3A935E00F48E55 /* watchOS-Application.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = "watchOS-Application.xcconfig"; sourceTree = ""; }; A97451341B3A935E00F48E55 /* watchOS-Base.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = "watchOS-Base.xcconfig"; sourceTree = ""; }; A97451351B3A935E00F48E55 /* watchOS-Framework.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = "watchOS-Framework.xcconfig"; sourceTree = ""; }; @@ -1396,6 +1400,7 @@ D037667E19EDA60000A782A9 /* NSObjectRACPropertySubscribingExamples.m */, D037667F19EDA60000A782A9 /* NSObjectRACPropertySubscribingSpec.m */, D037668019EDA60000A782A9 /* NSObjectRACSelectorSignalSpec.m */, + 9AE2F10E1DD8B827008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m */, D037668119EDA60000A782A9 /* NSStringRACKeyPathUtilitiesSpec.m */, D037668319EDA60000A782A9 /* NSURLConnectionRACSupportSpec.m */, D037668419EDA60000A782A9 /* NSUserDefaultsRACSupportSpec.m */, @@ -2132,6 +2137,7 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( + 9AE2F1141DD8BF98008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m in Sources */, 7DFBED321CDB8DE300EE435B /* NSEnumeratorRACSequenceAdditionsSpec.m in Sources */, 7DFBED331CDB8DE300EE435B /* NSNotificationCenterRACSupportSpec.m in Sources */, 7DFBED351CDB8DE300EE435B /* NSObjectRACDeallocatingSpec.m in Sources */, @@ -2339,6 +2345,7 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( + 9AE2F1121DD8BF96008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m in Sources */, D03766C719EDA60000A782A9 /* NSObjectRACPropertySubscribingExamples.m in Sources */, D03766E319EDA60000A782A9 /* RACDelegateProxySpec.m in Sources */, D03766F919EDA60000A782A9 /* RACSerialDisposableSpec.m in Sources */, @@ -2510,6 +2517,7 @@ D03766C619EDA60000A782A9 /* NSObjectRACLiftingSpec.m in Sources */, D0C3131F19EF2D9700984962 /* RACTestExampleScheduler.m in Sources */, D03766D219EDA60000A782A9 /* NSURLConnectionRACSupportSpec.m in Sources */, + 9AE2F1131DD8BF97008A8FDD /* NSObjectRACSelectorSignalPerformanceTests.m in Sources */, D03766F419EDA60000A782A9 /* RACSequenceAdditionsSpec.m in Sources */, D03766EE19EDA60000A782A9 /* RACMulticastConnectionSpec.m in Sources */, D03766EA19EDA60000A782A9 /* RACKVOChannelSpec.m in Sources */, diff --git a/ReactiveObjC/NSObject+RACSelectorSignal.m b/ReactiveObjC/NSObject+RACSelectorSignal.m index 63e232003..45fda680f 100644 --- a/ReactiveObjC/NSObject+RACSelectorSignal.m +++ b/ReactiveObjC/NSObject+RACSelectorSignal.m @@ -15,15 +15,22 @@ #import "RACSubject.h" #import "RACTuple.h" #import "NSObject+RACDescription.h" +#import "EXTScope.h" #import #import +#import "pthread.h" NSString * const RACSelectorSignalErrorDomain = @"RACSelectorSignalErrorDomain"; const NSInteger RACSelectorSignalErrorMethodSwizzlingRace = 1; -static NSString * const RACSignalForSelectorAliasPrefix = @"rac_alias_"; static NSString * const RACSubclassSuffix = @"_RACSelectorSignal"; +static const char * RACSignalForSelectorAliasPrefix = "rac_alias_"; +static const int RACSignalForSelectorAliasPrefixLength = 10; +static const char * RACSignalForSelectorInteropAliasPrefix = "rac_interop_"; +static const int RACSignalForSelectorInteropAliasPrefixLength = 12; static void *RACSubclassAssociationKey = &RACSubclassAssociationKey; +static void *RACInteropImplsKey = &RACInteropImplsKey; +static void *RACInteropImplsLockKey = &RACInteropImplsLockKey; static NSMutableSet *swizzledClasses() { static NSMutableSet *set; @@ -38,32 +45,10 @@ @implementation NSObject (RACSelectorSignal) -static BOOL RACForwardInvocation(id self, NSInvocation *invocation) { - SEL aliasSelector = RACAliasForSelector(invocation.selector); - RACSubject *subject = objc_getAssociatedObject(self, aliasSelector); +static void RACSwizzleForwardInvocation(Class baseClass) { + Class statedClass = class_getSuperclass(baseClass); - Class class = object_getClass(invocation.target); - BOOL respondsToAlias = [class instancesRespondToSelector:aliasSelector]; - if (respondsToAlias) { - invocation.selector = aliasSelector; - [invocation invoke]; - } - - if (subject == nil) return respondsToAlias; - - [subject sendNext:invocation.rac_argumentsTuple]; - return YES; -} - -static void RACSwizzleForwardInvocation(Class class) { SEL forwardInvocationSEL = @selector(forwardInvocation:); - Method forwardInvocationMethod = class_getInstanceMethod(class, forwardInvocationSEL); - - // Preserve any existing implementation of -forwardInvocation:. - void (*originalForwardInvocation)(id, SEL, NSInvocation *) = NULL; - if (forwardInvocationMethod != NULL) { - originalForwardInvocation = (__typeof__(originalForwardInvocation))method_getImplementation(forwardInvocationMethod); - } // Set up a new version of -forwardInvocation:. // @@ -75,26 +60,83 @@ static void RACSwizzleForwardInvocation(Class class) { // was no existing implementation, throw an unrecognized selector // exception. id newForwardInvocation = ^(id self, NSInvocation *invocation) { - BOOL matched = RACForwardInvocation(self, invocation); - if (matched) return; + SEL originalSelector = invocation.selector; + SEL aliasSelector = RACAliasForSelector(originalSelector); + SEL interopAliasSelector = RACInteropAliasForSelector(originalSelector); - if (originalForwardInvocation == NULL) { - [self doesNotRecognizeSelector:invocation.selector]; - } else { - originalForwardInvocation(self, forwardInvocationSEL, invocation); + RACSubject* subject = objc_getAssociatedObject(self, aliasSelector); + + @onExit { + if (subject != nil) { + [subject sendNext:invocation.rac_argumentsTuple]; + } + }; + + // RAC exchanges implementations at runtime so as to invoke the desired + // version without using fragile dependencies like libffi. This means + // all instances that had been applied `signalForSelector:` are + // non-threadsafe as any mutable instances. + + Method method = class_getInstanceMethod(statedClass, originalSelector); + const char* typeEncoding = method_getTypeEncoding(method); + + if (class_respondsToSelector(baseClass, interopAliasSelector)) { + // `self` uses a runtime subclass generated by third-party APIs, and RAC + // found an existing implementation for the selector at the setup time. + // Call that implementation if it is not the ObjC message forwarder. + IMP interopImpl = class_getMethodImplementation(baseClass, interopAliasSelector); + IMP oldImpl = class_replaceMethod(baseClass, originalSelector, interopImpl, typeEncoding); + invocation.selector = originalSelector; + [invocation invoke]; + class_replaceMethod(baseClass, originalSelector, oldImpl, typeEncoding); + return; + } + + BOOL forwardRegardless = NO; + + if (method != nil) { + IMP statedClassImpl = method_getImplementation(method); + + if (statedClassImpl != _objc_msgForward) { + // The stated class has an implementation of the selector. Call that + // implementation if it is not the ObjC message forwarder. + Method aliasMethod = rac_getImmediateInstanceMethod(baseClass, aliasSelector); + + if (statedClassImpl != method_getImplementation(aliasMethod)) { + class_replaceMethod(baseClass, aliasSelector, statedClassImpl, typeEncoding); + } + + invocation.selector = aliasSelector; + [invocation invoke]; + + return; + } + + forwardRegardless = YES; + } + + // No appropriate implementation was found. Forward the invocation to the + // stated class' `forwardInvocation:` only if the selector had not been + // intercepted via `signalForSelector:`. + // + // `subject` is usually null except for optional protocol requirements + // that are implemented at runtime through RAC. + if (subject == nil || forwardRegardless) { + // Forward the invocation to the closest `forwardInvocation:` in the + // inheritance hierarchy. + Method forwardInvocationMethod = class_getInstanceMethod(statedClass, forwardInvocationSEL); + void*(*superForwardInvocation)(id, SEL, NSInvocation*) = (__typeof__(superForwardInvocation)) method_getImplementation(forwardInvocationMethod); + superForwardInvocation(self, forwardInvocationSEL, invocation); } }; - class_replaceMethod(class, forwardInvocationSEL, imp_implementationWithBlock(newForwardInvocation), "v@:@"); + class_replaceMethod(baseClass, forwardInvocationSEL, imp_implementationWithBlock(newForwardInvocation), "v@:@"); } -static void RACSwizzleRespondsToSelector(Class class) { +static void RACSwizzleRespondsToSelector(Class baseClass) { + Class statedClass = class_getSuperclass(baseClass); SEL respondsToSelectorSEL = @selector(respondsToSelector:); - // Preserve existing implementation of -respondsToSelector:. - Method respondsToSelectorMethod = class_getInstanceMethod(class, respondsToSelectorSEL); - BOOL (*originalRespondsToSelector)(id, SEL, SEL) = (__typeof__(originalRespondsToSelector))method_getImplementation(respondsToSelectorMethod); - // Set up a new version of -respondsToSelector: that returns YES for methods // added by -rac_signalForSelector:. // @@ -103,17 +145,19 @@ static void RACSwizzleRespondsToSelector(Class class) { // the instance has a signal for the selector. // Otherwise, call the original -respondsToSelector:. id newRespondsToSelector = ^ BOOL (id self, SEL selector) { - Method method = rac_getImmediateInstanceMethod(class, selector); + Method method = rac_getImmediateInstanceMethod(baseClass, selector); if (method != NULL && method_getImplementation(method) == _objc_msgForward) { SEL aliasSelector = RACAliasForSelector(selector); if (objc_getAssociatedObject(self, aliasSelector) != nil) return YES; } - return originalRespondsToSelector(self, respondsToSelectorSEL, selector); + Method superMethod = class_getInstanceMethod(statedClass, respondsToSelectorSEL); + BOOL(*superRespondsToSelector)(id, SEL, SEL) = (__typeof__(superRespondsToSelector)) method_getImplementation(superMethod); + return superRespondsToSelector(self, respondsToSelectorSEL, selector); }; - class_replaceMethod(class, respondsToSelectorSEL, imp_implementationWithBlock(newRespondsToSelector), method_getTypeEncoding(respondsToSelectorMethod)); + class_replaceMethod(baseClass, respondsToSelectorSEL, imp_implementationWithBlock(newRespondsToSelector), "v@::"); } static void RACSwizzleGetClass(Class class, Class statedClass) { @@ -125,32 +169,30 @@ static void RACSwizzleGetClass(Class class, Class statedClass) { class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(method)); } -static void RACSwizzleMethodSignatureForSelector(Class class) { +static void RACSwizzleMethodSignatureForSelector(Class baseClass) { + Class statedClass = class_getSuperclass(baseClass); + SEL methodSignatureForSelectorSEL = @selector(methodSignatureForSelector:); + IMP newIMP = imp_implementationWithBlock(^(id self, SEL selector) { // Don't send the -class message to the receiver because we've changed // that to return the original class. - Class actualClass = object_getClass(self); - Method method = class_getInstanceMethod(actualClass, selector); + Method method = class_getInstanceMethod(baseClass, selector); + if (method == NULL) { // Messages that the original class dynamically implements fall // here. // // Call the original class' -methodSignatureForSelector:. - struct objc_super target = { - .super_class = class_getSuperclass(class), - .receiver = self, - }; - NSMethodSignature * (*messageSend)(struct objc_super *, SEL, SEL) = (__typeof__(messageSend))objc_msgSendSuper; - return messageSend(&target, @selector(methodSignatureForSelector:), selector); + Method superMethod = class_getInstanceMethod(statedClass, methodSignatureForSelectorSEL); + NSMethodSignature * (*messageSend)(id, SEL, SEL) = (__typeof__(messageSend)) method_getImplementation(superMethod); + return messageSend(self, methodSignatureForSelectorSEL, selector); } char const *encoding = method_getTypeEncoding(method); return [NSMethodSignature signatureWithObjCTypes:encoding]; }); - SEL selector = @selector(methodSignatureForSelector:); - Method methodSignatureForSelectorMethod = class_getInstanceMethod(class, selector); - class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(methodSignatureForSelectorMethod)); + class_replaceMethod(baseClass, methodSignatureForSelectorSEL, newIMP, "@@::"); } // It's hard to tell which struct return types use _objc_msgForward, and @@ -173,6 +215,7 @@ static void RACCheckTypeEncoding(const char *typeEncoding) { static RACSignal *NSObjectRACSignalForSelector(NSObject *self, SEL selector, Protocol *protocol) { SEL aliasSelector = RACAliasForSelector(selector); + SEL interopAliasSelector = RACInteropAliasForSelector(selector); @synchronized (self) { RACSubject *subject = objc_getAssociatedObject(self, aliasSelector); @@ -224,8 +267,18 @@ static void RACCheckTypeEncoding(const char *typeEncoding) { RACCheckTypeEncoding(typeEncoding); - BOOL addedAlias __attribute__((unused)) = class_addMethod(class, aliasSelector, method_getImplementation(targetMethod), typeEncoding); - NSCAssert(addedAlias, @"Original implementation for %@ is already copied to %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(aliasSelector), class); + @synchronized (class) { + if (!class_respondsToSelector(class, interopAliasSelector)) { + Method dynamicImmediateMethod = rac_getImmediateInstanceMethod(class, selector); + if (dynamicImmediateMethod) { + IMP dynamicImmediateImpl = method_getImplementation(dynamicImmediateMethod); + if (dynamicImmediateImpl != _objc_msgForward) { + BOOL success __attribute__((unused)) = class_addMethod(class, interopAliasSelector, dynamicImmediateImpl, typeEncoding); + NSCAssert(success, @"Unexpected race condition: `%@` has already been added, and subsequent attempts should have been ignored.", NSStringFromSelector(interopAliasSelector)); + } + } + } + } // Redefine the selector to call -forwardInvocation:. class_replaceMethod(class, selector, _objc_msgForward, method_getTypeEncoding(targetMethod)); @@ -236,8 +289,28 @@ static void RACCheckTypeEncoding(const char *typeEncoding) { } static SEL RACAliasForSelector(SEL originalSelector) { - NSString *selectorName = NSStringFromSelector(originalSelector); - return NSSelectorFromString([RACSignalForSelectorAliasPrefix stringByAppendingString:selectorName]); + return _RACAliasForSelector(originalSelector, RACSignalForSelectorAliasPrefix, RACSignalForSelectorAliasPrefixLength); +} + +static SEL RACInteropAliasForSelector(SEL originalSelector) { + return _RACAliasForSelector(originalSelector, RACSignalForSelectorInteropAliasPrefix, RACSignalForSelectorInteropAliasPrefixLength); +} + +static SEL _RACAliasForSelector(SEL originalSelector, const char* prefix, int prefixLength) { + const char* selectorString = sel_getName(originalSelector); + unsigned long length = strlen(selectorString); + unsigned long finalLength = length + prefixLength; + + char* buffer = malloc(finalLength + 1); + @onExit { + free(buffer); + }; + + memcpy(buffer, prefix, prefixLength); + memcpy(buffer + prefixLength, selectorString, length); + *(buffer + finalLength) = '\0'; + + return sel_registerName(buffer); } static const char *RACSignatureForUndefinedSelector(SEL selector) { diff --git a/ReactiveObjCTests/NSObjectRACSelectorSignalPerformanceTests.m b/ReactiveObjCTests/NSObjectRACSelectorSignalPerformanceTests.m new file mode 100644 index 000000000..6bf639684 --- /dev/null +++ b/ReactiveObjCTests/NSObjectRACSelectorSignalPerformanceTests.m @@ -0,0 +1,75 @@ +// +// NSObjectRACSelectorSignalPerformanceTests.m +// ReactiveObjC +// +// Created by Anders Ha on 13/11/2016. +// Copyright © 2016 GitHub. All rights reserved. +// + +@import Nimble; + +#import +#import "RACTestObject.h" +#import "NSObject+RACSelectorSignal.h" +#import "RACSignal.h" +#import "NSObject+RACPropertySubscribing.h" + +@interface NSObjectRACSelectorSignalPerformanceTests : XCTestCase + +@end + +@implementation NSObjectRACSelectorSignalPerformanceTests + +- (void)testKVORACStressTest { + RACTestObject* object = [[RACTestObject alloc] init]; + + [self measureBlock:^{ + __block unsigned int racCount = 0, kvoCount = 0; + + [RACObserve(object, objectValue) subscribeNext:^(id value) { + kvoCount += 1; + }]; + + [[object rac_signalForSelector:@selector(setObjectValue:)] subscribeNext:^(id value) { + racCount += 1; + }]; + + unsigned int iterations = 2500; + + for (unsigned int i = 0; i < iterations; i++) { + [object setObjectValue:@(i)]; + } + + expect(object.objectValue).to(equal(@(iterations - 1))); + expect(@(racCount)).to(equal(@(iterations))); + expect(@(kvoCount)).to(equal(@(iterations + 1))); + }]; +} + +- (void)testRACKVOStressTest { + RACTestObject* object = [[RACTestObject alloc] init]; + + [self measureBlock:^{ + __block unsigned int racCount = 0, kvoCount = 0; + + [[object rac_signalForSelector:@selector(setObjectValue:)] subscribeNext:^(id value) { + racCount += 1; + }]; + + [RACObserve(object, objectValue) subscribeNext:^(id value) { + kvoCount += 1; + }]; + + unsigned int iterations = 2500; + + for (unsigned int i = 0; i < iterations; i++) { + [object setObjectValue:@(i)]; + } + + expect(object.objectValue).to(equal(@(iterations - 1))); + expect(@(racCount)).to(equal(@(iterations))); + expect(@(kvoCount)).to(equal(@(iterations + 1))); + }]; +} + +@end diff --git a/ReactiveObjCTests/NSObjectRACSelectorSignalSpec.m b/ReactiveObjCTests/NSObjectRACSelectorSignalSpec.m index 7c4afbaa0..f5072fe36 100644 --- a/ReactiveObjCTests/NSObjectRACSelectorSignalSpec.m +++ b/ReactiveObjCTests/NSObjectRACSelectorSignalSpec.m @@ -9,9 +9,13 @@ @import Quick; @import Nimble; +#import + #import "RACTestObject.h" #import "RACSubclassObject.h" +#import + #import "NSObject+RACDeallocating.h" #import "NSObject+RACPropertySubscribing.h" #import "NSObject+RACSelectorSignal.h" @@ -137,7 +141,11 @@ - (id)objectValue; qck_it(@"should send arguments for invocation and invoke the original method on previously KVO'd receiver", ^{ RACTestObject *object = [[RACTestObject alloc] init]; - [[RACObserve(object, objectValue) publish] connect]; + __block id latestValue; + [[[RACObserve(object, objectValue) publish] autoconnect] subscribeNext:^(id objectValue) { + latestValue = objectValue; + }]; + expect(latestValue).to(beNil()); __block id key; __block id value; @@ -152,10 +160,54 @@ - (id)objectValue; expect(object.objectValue).to(equal(@YES)); expect(object.secondObjectValue).to(equal(@"Winner")); + expect(latestValue).to(equal(@YES)); + expect(value).to(equal(@YES)); expect(key).to(equal(@"Winner")); }); + qck_it(@"should send arguments for invocation and invoke the a KVO-swizzled then RAC-swizzled setter", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id latestValue; + [[[RACObserve(object, objectValue) publish] autoconnect] subscribeNext:^(id objectValue) { + latestValue = objectValue; + }]; + expect(latestValue).to(beNil()); + + __block id value; + [[object rac_signalForSelector:@selector(setObjectValue:)] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + [object setObjectValue:@YES]; + + expect(object.objectValue).to(equal(@YES)); + expect(latestValue).to(equal(@YES)); + expect(value).to(equal(@YES)); + }); + + qck_it(@"should send arguments for invocation and invoke the a RAC-swizzled then KVO-swizzled setter", ^{ + RACTestObject *object = [[RACTestObject alloc] init]; + + __block id value; + [[object rac_signalForSelector:@selector(setObjectValue:)] subscribeNext:^(RACTuple *x) { + value = x.first; + }]; + + __block id latestValue; + [[[RACObserve(object, objectValue) publish] autoconnect] subscribeNext:^(id objectValue) { + latestValue = objectValue; + }]; + expect(latestValue).to(beNil()); + + [object setObjectValue:@YES]; + + expect(object.objectValue).to(equal(@YES)); + expect(latestValue).to(equal(@YES)); + expect(value).to(equal(@YES)); + }); + qck_it(@"should send arguments for invocation and invoke the original method when receiver is subsequently KVO'd", ^{ RACTestObject *object = [[RACTestObject alloc] init]; @@ -166,7 +218,11 @@ - (id)objectValue; key = x.second; }]; - [[RACObserve(object, objectValue) publish] connect]; + __block id latestValue; + [[[RACObserve(object, objectValue) publish] autoconnect] subscribeNext:^(id objectValue) { + latestValue = objectValue; + }]; + expect(latestValue).to(beNil()); [object setObjectValue:@YES andSecondObjectValue:@"Winner"]; @@ -174,6 +230,8 @@ - (id)objectValue; expect(object.objectValue).to(equal(@YES)); expect(object.secondObjectValue).to(equal(@"Winner")); + expect(latestValue).to(equal(@YES)); + expect(value).to(equal(@YES)); expect(key).to(equal(@"Winner")); }); @@ -193,7 +251,7 @@ - (id)objectValue; expect(@([object respondsToSelector:selector])).to(beTruthy()); }); - + qck_it(@"should properly implement -respondsToSelector: when called on signalForSelector'd receiver that has subsequently been KVO'd", ^{ RACTestObject *object = [[RACTestObject alloc] init]; @@ -306,6 +364,133 @@ - (id)objectValue; }); }); +qck_describe(@"interoperability", ^{ + __block BOOL invoked; + __block RACTestObject * object; + __block Class originalClass; + + qck_beforeEach(^{ + invoked = NO; + object = [[RACTestObject alloc] init]; + originalClass = RACTestObject.class; + }); + + qck_it(@"should invoke the swizzled `forwardInvocation:` on an instance isa-swizzled by both RAC and KVO.", ^{ + [[RACObserve(object, objectValue) publish] connect]; + [object rac_signalForSelector:@selector(lifeIsGood:)]; + + SEL swizzledSelector = @selector(lifeIsGood:); + + // Redirect `swizzledSelector` to the forwarding machinery. + Method method = class_getInstanceMethod(originalClass, swizzledSelector); + const char *typeDescription = (char *)method_getTypeEncoding(method); + IMP originalImp = class_replaceMethod(originalClass, swizzledSelector, _objc_msgForward, typeDescription); + + @onExit { + class_replaceMethod(originalClass, swizzledSelector, originalImp, typeDescription); + }; + + // Swizzle `forwardInvocation:` to intercept `swizzledSelector`. + id patchForwardInvocationBlock = ^(id self, NSInvocation *invocation) { + if (invocation.selector == swizzledSelector) { + expect(@(invoked)).to(beFalsy()); + invoked = YES; + } + }; + + IMP newForwardInvocation = imp_implementationWithBlock(patchForwardInvocationBlock); + IMP oldForwardInvocation = class_replaceMethod(originalClass, @selector(forwardInvocation:), newForwardInvocation, "v@:@"); + + @onExit { + class_replaceMethod(originalClass, @selector(forwardInvocation:), oldForwardInvocation, "v@:@"); + }; + + [object lifeIsGood:nil]; + expect(@(invoked)).to(beTruthy()); + }); + + qck_it(@"should invoke the swizzled `forwardInvocation:` on an instance isa-swizzled by RAC.", ^{ + [object rac_signalForSelector:@selector(lifeIsGood:)]; + + SEL swizzledSelector = @selector(lifeIsGood:); + + // Redirect `swizzledSelector` to the forwarding machinery. + Method method = class_getInstanceMethod(originalClass, swizzledSelector); + const char *typeEncoding = (char *)method_getTypeEncoding(method); + IMP originalImp = class_replaceMethod(originalClass, swizzledSelector, _objc_msgForward, typeEncoding); + + @onExit { + class_replaceMethod(originalClass, swizzledSelector, originalImp, typeEncoding); + }; + + // Swizzle `forwardInvocation:` to intercept `swizzledSelector`. + id patchForwardInvocationBlock = ^(id self, NSInvocation *invocation) { + if (invocation.selector == swizzledSelector) { + expect(@(invoked)).to(beFalsy()); + invoked = YES; + } + }; + + IMP newForwardInvocation = imp_implementationWithBlock(patchForwardInvocationBlock); + IMP oldForwardInvocation = class_replaceMethod(originalClass, @selector(forwardInvocation:), newForwardInvocation, "v@:@"); + + @onExit { + class_replaceMethod(originalClass, @selector(forwardInvocation:), oldForwardInvocation, "v@:@"); + }; + + [object lifeIsGood:nil]; + expect(@(invoked)).to(beTruthy()); + }); + + qck_it(@"should invoke the swizzled selector on an instance isa-swizzled by RAC.", ^{ + [object rac_signalForSelector:@selector(lifeIsGood:)]; + + SEL swizzledSelector = @selector(lifeIsGood:); + + Method method = class_getInstanceMethod(originalClass, swizzledSelector); + const char *typeEncoding = (char *)method_getTypeEncoding(method); + + id methodSwizzlingBlock = ^(id self) { + expect(@(invoked)).to(beFalsy()); + invoked = YES; + }; + + IMP newImplementation = imp_implementationWithBlock(methodSwizzlingBlock); + IMP oldImplementation = class_replaceMethod(originalClass, swizzledSelector, newImplementation, typeEncoding); + + @onExit { + class_replaceMethod(originalClass, swizzledSelector, oldImplementation, typeEncoding); + }; + + [object lifeIsGood:nil]; + expect(@(invoked)).to(beTruthy()); + }); + + qck_it(@"should invoke the swizzled setter on an instance isa-swizzled by RAC.", ^{ + [object rac_signalForSelector:@selector(setObjectValue:)]; + + SEL swizzledSelector = @selector(lifeIsGood:); + + Method method = class_getInstanceMethod(originalClass, swizzledSelector); + const char *typeEncoding = (char *)method_getTypeEncoding(method); + + id methodSwizzlingBlock = ^(id self) { + expect(@(invoked)).to(beFalsy()); + invoked = YES; + }; + + IMP newImplementation = imp_implementationWithBlock(methodSwizzlingBlock); + IMP oldImplementation = class_replaceMethod(originalClass, swizzledSelector, newImplementation, typeEncoding); + + @onExit { + class_replaceMethod(originalClass, swizzledSelector, oldImplementation, typeEncoding); + }; + + [object lifeIsGood:nil]; + expect(@(invoked)).to(beTruthy()); + }); +}); + qck_it(@"should swizzle an NSObject method", ^{ NSObject *object = [[NSObject alloc] init]; diff --git a/ReactiveObjCTests/RACTestObject.m b/ReactiveObjCTests/RACTestObject.m index 66aac010a..32298abec 100644 --- a/ReactiveObjCTests/RACTestObject.m +++ b/ReactiveObjCTests/RACTestObject.m @@ -15,6 +15,10 @@ - (void)dealloc { free((void *)_constCharPointerValue); } +- (void)setObjectValue:(id)objectValue { + _objectValue = objectValue; +} + - (void)setNilValueForKey:(NSString *)key { if (!self.catchSetNilValueForKey) [super setNilValueForKey:key]; }