Added automatic PFObject subclass registration.

This will scan all loaded code bundles for classes which inherit from `PFObject`, and register them upon Parse initialization. Still have opt-in support for manual-only registration, though it shouldn't be necessary for most cases.

Author: richardjrossiii

Parse/Internal/Object/Subclassing/PFObjectSubclassingController.h

@@ -14,18 +14,12 @@
 
 @interface PFObjectSubclassingController : NSObject
 
-///--------------------------------------
-#pragma mark - Init
-///--------------------------------------
-
-//TODO: (nlutsenko, richardross) Make it not terrible aka don't have singletons.
-+ (instancetype)defaultController;
-+ (void)clearDefaultController;
-
 ///--------------------------------------
 #pragma mark - Registration
 ///--------------------------------------
 
+- (void)scanForUnregisteredSubclasses:(BOOL)shouldSubscribe;
+
 - (Class<PFSubclassing>)subclassForParseClassName:(NSString *)parseClassName;
 - (void)registerSubclass:(Class<PFSubclassing>)kls;
 - (void)unregisterSubclass:(Class<PFSubclassing>)kls;

Parse/Internal/Object/Subclassing/PFObjectSubclassingController.m

@@ -16,6 +16,8 @@
 
 #import "PFAssert.h"
 #import "PFMacros.h"
+#import "PFObject.h"
+#import "PFObject+Subclass.h"
 #import "PFObjectSubclassInfo.h"
 #import "PFPropertyInfo_Private.h"
 #import "PFPropertyInfo_Runtime.h"
@@ -80,10 +82,9 @@ @implementation PFObjectSubclassingController {
     dispatch_queue_t _registeredSubclassesAccessQueue;
     NSMutableDictionary *_registeredSubclasses;
     NSMutableDictionary *_unregisteredSubclasses;
+    id<NSObject> _bundleLoadedSubscriptionToken;
 }
 
-static PFObjectSubclassingController *defaultController_;
-
 ///--------------------------------------
 #pragma mark - Init
 ///--------------------------------------
@@ -99,15 +100,10 @@ - (instancetype)init {
     return self;
 }
 
-+ (instancetype)defaultController {
-    if (!defaultController_) {
-        defaultController_ = [[PFObjectSubclassingController alloc] init];
-    }
-    return defaultController_;
-}
-
-+ (void)clearDefaultController {
-    defaultController_ = nil;
+- (void)dealloc {
+    [[NSNotificationCenter defaultCenter] removeObserver:_bundleLoadedSubscriptionToken
+                                                    name:NSBundleDidLoadNotification
+                                                  object:nil];
 }
 
 ///--------------------------------------
@@ -122,6 +118,33 @@ + (void)clearDefaultController {
     return result;
 }
 
+- (void)scanForUnregisteredSubclasses:(BOOL)shouldSubscribe {
+    // NOTE: Potential race-condition here - if another thread dynamically loads a bundle, we may end up accidentally
+    // Skipping a bundle. Not entirely sure of the best solution to that here.
+    if (shouldSubscribe && _bundleLoadedSubscriptionToken == nil) {
+        @weakify(self);
+        _bundleLoadedSubscriptionToken = [[NSNotificationCenter defaultCenter] addObserverForName:NSBundleDidLoadNotification
+                                                                                           object:nil
+                                                                                            queue:nil
+                                                                                       usingBlock:^(NSNotification *note) {
+                                                                                           @strongify(self);
+                                                                                           [self _registerSubclassesInBundle:note.object];
+                                                                                       }];
+    }
+    NSArray *bundles = [[NSBundle allFrameworks] arrayByAddingObjectsFromArray:[NSBundle allBundles]];
+    for (NSBundle *bundle in bundles) {
+        // Skip bundles that aren't loaded yet.
+        if (!bundle.loaded || !bundle.executablePath) {
+            continue;
+        }
+        // Filter out any system bundles
+        if ([bundle.bundlePath hasPrefix:@"/System/"] || [bundle.bundlePath hasPrefix:@"/Library/"]) {
+            continue;
+        }
+        [self _registerSubclassesInBundle:bundle];
+    }
+}
+
 - (void)registerSubclass:(Class<PFSubclassing>)kls {
     pf_sync_with_throw(_registeredSubclassesAccessQueue, ^{
         [self _rawRegisterSubclass:kls];
@@ -315,4 +338,47 @@ - (void)_rawRegisterSubclass:(Class)kls {
     _registeredSubclasses[[kls parseClassName]] = subclassInfo;
 }
 
+- (void)_registerSubclassesInBundle:(NSBundle *)bundle {
+    PFConsistencyAssert(bundle.loaded, @"Cannot register subclasses in a bundle that hasn't been loaded!");
+    dispatch_sync(_registeredSubclassesAccessQueue, ^{
+        Class pfObjectClass = [PFObject class];
+        unsigned bundleClassCount = 0;
+
+        // NSBundle's executablePath does not resolve symlinks (sadface). Unfortunately, objc_copyClassNamesForImage()
+        // Only takes absolute paths, as it does a direct string compare. This causes issues when using a framework
+        // which uses the `Versions/XXX` format, vs. just having the binary be at the root of the `.framework` bundle.
+        // However, we cannot use stringByResolvingSymlinksInPath for some reason here. On iOS, it never resolves the first,
+        // symlink in the path, e.g. /var to /private/var.
+        // Luckily, the POSIX function `realpath` will expand that symlink, and give us the path we need.
+        char pathBuf[PATH_MAX + 1] = { 0 };
+        if (!realpath(bundle.executablePath.UTF8String, pathBuf)) {
+            return;
+        }
+        
+        const char **classNames = objc_copyClassNamesForImage(pathBuf, &bundleClassCount);
+        for (unsigned i = 0; i < bundleClassCount; i++) {
+            Class bundleClass = objc_getClass(classNames[i]);
+            // For obvious reasons, don't register the PFObject class.
+            if (bundleClass == pfObjectClass) {
+                continue;
+            }
+            // NOTE: (richardross) Cannot use isSubclassOfClass here. Some classes may be part of a system bundle (even
+            // though we attempt to filter those out) that may be an internal class which doesn't inherit from NSObject.
+            // Scary, I know!
+            for (Class kls = bundleClass; kls != nil; kls = class_getSuperclass(kls)) {
+                if (kls == pfObjectClass) {
+                    // Do class_conformsToProtocol as late in the checking as possible, as its SUUUPER slow.
+                    // Behind the scenes this is a strcmp (lolwut?)
+                    if (class_conformsToProtocol(bundleClass, @protocol(PFSubclassing)) &&
+                        !class_conformsToProtocol(bundleClass, @protocol(PFSubclassingSkipAutomaticRegistration))) {
+                        [self _rawRegisterSubclass:bundleClass];
+                    }
+                    break;
+                }
+            }
+        }
+        free(classNames);
+    });
+}
+
 @end

Parse/Internal/PFCoreDataProvider.h

@@ -36,6 +36,14 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
+@class PFObjectSubclassingController;
+
+@protocol PFObjectSubclassingControllerProvider <NSObject>
+
+@property (null_resettable, nonatomic, strong) PFObjectSubclassingController *objectSubclassingController;
+
+@end
+
 @class PFObjectBatchController;
 
 @protocol PFObjectBatchController <NSObject>

Parse/Internal/PFCoreManager.h

@@ -42,6 +42,7 @@ PFPersistenceControllerProvider>
 <PFLocationManagerProvider,
 PFDefaultACLControllerProvider,
 PFObjectControllerProvider,
+PFObjectSubclassingControllerProvider,
 PFObjectBatchController,
 PFObjectFilePersistenceControllerProvider,
 PFPinningObjectStoreProvider,

Parse/Internal/PFCoreManager.m

@@ -53,6 +53,7 @@ @implementation PFCoreManager
 @synthesize cloudCodeController = _cloudCodeController;
 @synthesize configController = _configController;
 @synthesize objectController = _objectController;
+@synthesize objectSubclassingController = _objectSubclassingController;
 @synthesize objectBatchController = _objectBatchController;
 @synthesize objectFilePersistenceController = _objectFilePersistenceController;
 @synthesize objectLocalIdStore = _objectLocalIdStore;
@@ -235,6 +236,28 @@ - (void)setObjectController:(PFObjectController *)controller {
     });
 }
 
+///--------------------------------------
+#pragma mark - ObjectSubclassingController
+///--------------------------------------
+
+- (PFObjectSubclassingController *)objectSubclassingController {
+    __block PFObjectSubclassingController *controller = nil;
+    dispatch_sync(_controllerAccessQueue, ^{
+        if (!_objectSubclassingController) {
+            _objectSubclassingController = [[PFObjectSubclassingController alloc] init];
+            [_objectSubclassingController scanForUnregisteredSubclasses:YES];
+        }
+        controller = _objectSubclassingController;
+    });
+    return controller;
+}
+
+- (void)setObjectSubclassingController:(PFObjectSubclassingController *)objectSubclassingController {
+    dispatch_sync(_controllerAccessQueue, ^{
+        _objectSubclassingController = objectSubclassingController;
+    });
+}
+
 ///--------------------------------------
 #pragma mark - ObjectBatchController
 ///--------------------------------------

Parse/PFObject+Subclass.h

@@ -132,4 +132,15 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
+/*!
+ This protocol exists ONLY so that, if you absolutely need it, you can perform manual subclass registration
+ via `[Subclass registerSubclass]`. Note that any calls to `registerSubclass` must happen after parse has been
+ initialized already. This should only ever be needed in the scenario where you may be dynamically creation new 
+ Objective-C classes for parse objects, or you are doing conditional subclass registration (e.g. only register class A 
+ if config setting 'foo' is defined, otherwise register B).
+ */
+@protocol PFSubclassingSkipAutomaticRegistration <PFSubclassing>
+
+@end
+
 NS_ASSUME_NONNULL_END

Parse/PFObject.m

@@ -2454,7 +2454,7 @@ + (PFCurrentUserController *)currentUserController {
 }
 
 + (PFObjectSubclassingController *)subclassingController {
-    return [PFObjectSubclassingController defaultController];
+    return [Parse _currentManager].coreManager.objectSubclassingController;
 }
 
 @end

Parse/Parse.m

@@ -80,22 +80,6 @@ + (void)initializeWithConfiguration:(ParseClientConfiguration *)configuration {
 
     currentParseManager_ = manager;
 
-    PFObjectSubclassingController *subclassingController = [PFObjectSubclassingController defaultController];
-    // Register built-in subclasses of PFObject so they get used.
-    // We're forced to register subclasses directly this way, in order to prevent a deadlock.
-    // If we ever switch to bundle scanning, this code can go away.
-    [subclassingController registerSubclass:[PFUser class]];
-    [subclassingController registerSubclass:[PFSession class]];
-    [subclassingController registerSubclass:[PFRole class]];
-    [subclassingController registerSubclass:[PFPin class]];
-    [subclassingController registerSubclass:[PFEventuallyPin class]];
-#if !TARGET_OS_WATCH && !TARGET_OS_TV
-    [subclassingController registerSubclass:[PFInstallation class]];
-#endif
-#if TARGET_OS_IOS || TARGET_OS_TV
-    [subclassingController registerSubclass:[PFProduct class]];
-#endif
-
 #if TARGET_OS_IOS
     [PFNetworkActivityIndicatorManager sharedManager].enabled = YES;
 #endif

Tests/Other/TestCases/UnitTestCase/PFUnitTestCase.m

@@ -42,7 +42,6 @@ - (void)setUp {
 - (void)tearDown {
     [[Parse _currentManager] clearEventuallyQueue];
     [Parse _clearCurrentManager];
-    [PFObjectSubclassingController clearDefaultController];
 
     [super tearDown];
 }

Tests/Unit/ACLTests.m

@@ -13,10 +13,10 @@
 #import "PFMacros.h"
 #import "PFObjectPrivate.h"
 #import "PFRole.h"
-#import "PFTestCase.h"
+#import "PFUnitTestCase.h"
 #import "PFUserPrivate.h"
 
-@interface ACLTests : PFTestCase
+@interface ACLTests : PFUnitTestCase
 
 @end
 
@@ -210,8 +210,6 @@ - (void)testUnsharedCopy {
 
 
 - (void)testACLRequiresObjectId {
-    [PFUser registerSubclass];
-
     PFACL *acl = [PFACL ACL];
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wnonnull"

Tests/Unit/ObjectSubclassPropertiesTests.m

@@ -105,22 +105,6 @@ @interface ObjectSubclassPropertiesTests : PFUnitTestCase
 
 @implementation ObjectSubclassPropertiesTests
 
-///--------------------------------------
-#pragma mark - XCTestCase
-///--------------------------------------
-
-- (void)setUp {
-    [super setUp];
-
-    [PFTestObject registerSubclass];
-}
-
-- (void)tearDown {
-    [PFObject unregisterSubclass:[PFTestObject class]];
-
-    [super tearDown];
-}
-
 ///--------------------------------------
 #pragma mark - Tests
 ///--------------------------------------

Tests/Unit/ObjectSubclassTests.m

@@ -17,7 +17,7 @@
 #pragma mark - Helpers
 ///--------------------------------------
 
-@interface TheFlash : PFObject<PFSubclassing> {
+@interface TheFlash : PFObject<PFSubclassingSkipAutomaticRegistration> {
     NSString *flashName;
 }
 
@@ -59,7 +59,7 @@ + (NSString *)parseClassName {
 
 @end
 
-@interface ClassWithDirtyingConstructor : PFObject<PFSubclassing>
+@interface ClassWithDirtyingConstructor : PFObject<PFSubclassingSkipAutomaticRegistration>
 @end
 
 @implementation ClassWithDirtyingConstructor
@@ -85,7 +85,7 @@ @interface UtilityClass : PFObject
 @implementation UtilityClass
 @end
 
-@interface DescendantOfUtility : UtilityClass<PFSubclassing>
+@interface DescendantOfUtility : UtilityClass<PFSubclassingSkipAutomaticRegistration>
 @end
 
 @implementation DescendantOfUtility
@@ -94,7 +94,7 @@ + (NSString *)parseClassName {
 }
 @end
 
-@interface StateClass : PFObject<PFSubclassing>
+@interface StateClass : PFObject<PFSubclassing, PFSubclassingSkipAutomaticRegistration>
 
 @property (nonatomic, copy) NSString *state;
 
@@ -120,17 +120,6 @@ @interface ObjectSubclassTests : PFUnitTestCase
 
 @implementation ObjectSubclassTests
 
-///--------------------------------------
-#pragma mark - XCTestCase
-///--------------------------------------
-
-- (void)tearDown {
-    [PFObject unregisterSubclass:[TheFlash class]];
-    [PFObject unregisterSubclass:[BarryAllen class]];
-
-    [super tearDown];
-}
-
 ///--------------------------------------
 #pragma mark - Tests
 ///--------------------------------------
@@ -173,18 +162,6 @@ - (void)testSubclassesCanInheritUtilityClassesWithoutParseClassName {
     [DescendantOfUtility registerSubclass];
 }
 
-- (void)testSubclassRegistrationBeforeInitializingParse {
-    [[Parse _currentManager] clearEventuallyQueue];
-    [Parse _clearCurrentManager];
-
-    [TheFlash registerSubclass];
-
-    [Parse setApplicationId:@"a" clientKey:@"b"];
-
-    PFObject *theFlash = [PFObject objectWithClassName:@"Person"];
-    PFAssertIsKindOfClass(theFlash, [TheFlash class]);
-}
-
 - (void)testStateIsSubclassable {
     [StateClass registerSubclass];
     StateClass *stateClass = [StateClass object];

Tests/Unit/ObjectSubclassingControllerTests.m

@@ -16,13 +16,13 @@
 #import "PFUnitTestCase.h"
 #import "ParseUnitTests-Swift.h"
 
-@interface TestSubclass : PFObject<PFSubclassing>
+@interface TestSubclass : PFObject<PFSubclassingSkipAutomaticRegistration>
 @end
 
-@interface NotSubclass : PFObject<PFSubclassing>
+@interface NotSubclass : PFObject<PFSubclassingSkipAutomaticRegistration>
 @end
 
-@interface PropertySubclass : PFObject<PFSubclassing> {
+@interface PropertySubclass : PFObject<PFSubclassingSkipAutomaticRegistration> {
 @public
     id _ivarProperty;
 }