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
 
-///--------------------------------------
-/// @name Init
-///--------------------------------------
-
-//TODO: (nlutsenko, richardross) Make it not terrible aka don't have singletons.
-+ (instancetype)defaultController;
-+ (void)clearDefaultController;
-
 ///--------------------------------------
 /// @name 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

@@ -14,6 +14,7 @@
 #import "PFAssert.h"
 #import "PFMacros.h"
 #import "PFObject.h"
+#import "PFObject+Subclass.h"
 #import "PFObjectSubclassInfo.h"
 #import "PFPropertyInfo_Private.h"
 #import "PFPropertyInfo_Runtime.h"
@@ -108,17 +109,6 @@ - (instancetype)init {
     return self;
 }
 
-+ (instancetype)defaultController {
-    if (!defaultController_) {
-        defaultController_ = [[PFObjectSubclassingController alloc] init];
-    }
-    return defaultController_;
-}
-
-+ (void)clearDefaultController {
-    defaultController_ = nil;
-}
-
 ///--------------------------------------
 #pragma mark - Public
 ///--------------------------------------
@@ -131,6 +121,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) {
+        @weakify(self);
+        [[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];
@@ -324,4 +341,40 @@ - (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.
+        NSString *realPath = [[bundle executablePath] stringByResolvingSymlinksInPath];
+        const char **classNames = objc_copyClassNamesForImage([realPath UTF8String], &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

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

Parse/Internal/PFCoreManager.h

@@ -40,6 +40,7 @@ PFInstallationIdentifierStoreProvider>
 @interface PFCoreManager : NSObject
 <PFLocationManagerProvider,
 PFObjectControllerProvider,
+PFObjectSubclassingControllerProvider,
 PFObjectBatchController,
 PFObjectFilePersistenceControllerProvider,
 PFPinningObjectStoreProvider,

Parse/Internal/PFCoreManager.m

@@ -48,6 +48,7 @@ @implementation PFCoreManager
 @synthesize cloudCodeController = _cloudCodeController;
 @synthesize configController = _configController;
 @synthesize objectController = _objectController;
+@synthesize objectSubclassingController = _objectSubclassingController;
 @synthesize objectBatchController = _objectBatchController;
 @synthesize objectFilePersistenceController = _objectFilePersistenceController;
 @synthesize objectLocalIdStore = _objectLocalIdStore;
@@ -217,6 +218,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

@@ -122,4 +122,17 @@ PF_ASSUME_NONNULL_BEGIN
 
 @end
 
+/*!
+ As of Parse 1.8.1, subclasses are automatically registered when parse is initialized.
+
+ This protocol exists ONLY so that, if you absolutely need it, you can perform manual subclass registration
+ via `[PFObject 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
+
 PF_ASSUME_NONNULL_END

Parse/PFObject.m

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

Parse/Parse.m

@@ -67,20 +67,6 @@ + (void)setApplicationId:(NSString *)applicationId clientKey:(NSString *)clientK
 
     shouldEnableLocalDatastore_ = NO;
 
-    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:[PFInstallation class]];
-    [subclassingController registerSubclass:[PFSession class]];
-    [subclassingController registerSubclass:[PFRole class]];
-    [subclassingController registerSubclass:[PFPin class]];
-    [subclassingController registerSubclass:[PFEventuallyPin class]];
-#if TARGET_OS_IPHONE
-    [subclassingController registerSubclass:[PFProduct class]];
-#endif
-
     [currentParseManager_ preloadDiskObjectsToMemoryAsync];
 
     [[self parseModulesCollection] parseDidInitializeWithApplicationId:applicationId clientKey:clientKey];

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/ACLUnitTests.m

@@ -218,8 +218,6 @@ - (void)testDefaultACL {
 }
 
 - (void)testACLRequiresObjectId {
-    [PFUser registerSubclass];
-
     PFACL *acl = [PFACL ACL];
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wnonnull"