Merge/release 21.8 finalized into trunk

RELEASE-NOTES.txt

@@ -15,6 +15,7 @@
 * [*] Reader: Add ability to block a followed site. [#20053]
 * [*] Reader: Add ability to report a post's author. [#20064]
 * [*] [internal] Refactored the topic related features in the Reader tab (i.e. following, unfollowing, and search). [#20150]
+* [*] Fix inaccessible block settings within the unsupported block editor [https://github.com/WordPress/gutenberg/pull/48435]
 
 21.7
 -----

WordPress/Classes/Extensions/UIApplication+AppAvailability.swift

@@ -3,6 +3,7 @@ import Foundation
 enum AppScheme: String {
     case wordpress = "wordpress://"
     case wordpressMigrationV1 = "wordpressmigration+v1://"
+    case jetpack = "jetpack://"
 }
 
 extension UIApplication {

WordPress/Classes/System/WordPressAppDelegate.swift

@@ -516,6 +516,22 @@ extension WordPressAppDelegate {
             return
         }
 
+        // When a counterpart WordPress/Jetpack app is detected, ensure that the router can handle the URL.
+        // Passing a URL that the router can't handle results in opening the URL in Safari, which will
+        // cause the other app to "catch" the intent — and leads to a navigation loop between the two apps.
+        //
+        // TODO: Remove this after the Universal Link routes for the WordPress app are removed.
+        //
+        // Read more: https://github.com/wordpress-mobile/WordPress-iOS/issues/19755
+        if MigrationAppDetection.isCounterpartAppInstalled {
+            // If we can handle the URL, then let the UniversalLinkRouter do it.
+            guard UniversalLinkRouter.shared.canHandle(url: url) else {
+                // Otherwise, try to convert the URL to a WP Admin link and open it in Safari.
+                WPAdminConvertibleRouter.shared.handle(url: url)
+                return
+            }
+        }
+
         trackDeepLink(for: url) { url in
             UniversalLinkRouter.shared.handle(url: url)
         }

WordPress/Classes/Utility/ContextManager.swift

@@ -135,6 +135,41 @@ public class ContextManager: NSObject, CoreDataStack, CoreDataStackSwift {
             save(context, .asynchronously)
         }
     }
+
+    static func migrateDataModelsIfNecessary(storeURL: URL, objectModel: NSManagedObjectModel) throws {
+        guard FileManager.default.fileExists(atPath: storeURL.path) else {
+            DDLogInfo("No store exists at \(storeURL).  Skipping migration.")
+            return
+        }
+
+        guard let metadata = try? NSPersistentStoreCoordinator.metadataForPersistentStore(ofType: NSSQLiteStoreType, at: storeURL),
+            !objectModel.isConfiguration(withName: nil, compatibleWithStoreMetadata: metadata)
+        else {
+            return
+        }
+
+        DDLogWarn("Migration required for persistent store.")
+
+        guard let modelFileURL = Bundle.main.url(forResource: "WordPress", withExtension: "momd") else {
+            fatalError("Can't find WordPress.momd")
+        }
+
+        guard let versionInfo = NSDictionary(contentsOf: modelFileURL.appendingPathComponent("VersionInfo.plist")) else {
+            fatalError("Can't get the object model's version info")
+        }
+
+        guard let modelNames = (versionInfo["NSManagedObjectModel_VersionHashes"] as? [String: AnyObject])?.keys else {
+            fatalError("Can't parse the model versions")
+        }
+
+        let sortedModelNames = modelNames.sorted { $0.compare($1, options: .numeric) == .orderedAscending }
+        try CoreDataIterativeMigrator.iterativeMigrate(
+            sourceStore: storeURL,
+            storeType: NSSQLiteStoreType,
+            to: objectModel,
+            using: sortedModelNames
+        )
+    }
 }
 
 // MARK: - Private methods
@@ -236,40 +271,6 @@ private extension ContextManager {
         return persistentContainer
     }
 
-    static func migrateDataModelsIfNecessary(storeURL: URL, objectModel: NSManagedObjectModel) throws {
-        guard FileManager.default.fileExists(atPath: storeURL.path) else {
-            DDLogInfo("No store exists at \(storeURL).  Skipping migration.")
-            return
-        }
-
-        guard let metadata = try? NSPersistentStoreCoordinator.metadataForPersistentStore(ofType: NSSQLiteStoreType, at: storeURL),
-            objectModel.isConfiguration(withName: nil, compatibleWithStoreMetadata: metadata)
-        else {
-            return
-        }
-
-        DDLogWarn("Migration required for persistent store.")
-
-        guard let modelFileURL = Bundle.main.url(forResource: "WordPress", withExtension: "momd") else {
-            fatalError("Can't find WordPress.momd")
-        }
-
-        guard let versionInfo = NSDictionary(contentsOf: modelFileURL.appendingPathComponent("VersionInfo.plist")) else {
-            fatalError("Can't get the object model's version info")
-        }
-
-        guard let modelNames = (versionInfo["NSManagedObjectModel_VersionHashes"] as? [String: AnyObject])?.keys else {
-            fatalError("Can't parse the model versions")
-        }
-
-        let sortedModelNames = modelNames.sorted { $0.compare($1, options: .numeric) == .orderedAscending }
-        try CoreDataIterativeMigrator.iterativeMigrate(
-            sourceStore: storeURL,
-            storeType: NSSQLiteStoreType,
-            to: objectModel,
-            using: sortedModelNames
-        )
-    }
 }
 
 extension ContextManager {

WordPress/Classes/Utility/CoreDataHelper.swift

@@ -250,14 +250,19 @@ extension CoreDataStack {
             throw ContextManager.ContextManagerError.missingDatabase
         }
 
+        try? migrateDatabaseIfNecessary(at: databaseLocation)
+
         mainContext.reset()
         try storeCoordinator.remove(store)
         let databaseReplaced = replaceDatabase(from: databaseLocation, to: currentDatabaseLocation)
 
         do {
+            let options = [NSMigratePersistentStoresAutomaticallyOption: true,
+                                 NSInferMappingModelAutomaticallyOption: true]
             try storeCoordinator.addPersistentStore(ofType: NSSQLiteStoreType,
                                                     configurationName: nil,
-                                                    at: currentDatabaseLocation)
+                                                    at: currentDatabaseLocation,
+                                                    options: options)
 
             if databaseReplaced {
                 // The database was replaced successfully and the store added with no errors so we
@@ -327,4 +332,12 @@ extension CoreDataStack {
         _ = try? FileManager.default.replaceItemAt(locationShm, withItemAt: shmBackup)
         _ = try? FileManager.default.replaceItemAt(locationWal, withItemAt: walBackup)
     }
+
+    private func migrateDatabaseIfNecessary(at databaseLocation: URL) throws {
+        guard let modelFileURL = Bundle.main.url(forResource: "WordPress", withExtension: "momd"),
+              let objectModel = NSManagedObjectModel(contentsOf: modelFileURL) else {
+            return
+        }
+        try ContextManager.migrateDataModelsIfNecessary(storeURL: databaseLocation, objectModel: objectModel)
+    }
 }

WordPress/Classes/Utility/Universal Links/Migration/WPAdminConvertibleRouter.swift

@@ -0,0 +1,95 @@
+/// A router that handles routes that can be converted to /wp-admin links.
+///
+/// Note that this is a workaround for an infinite redirect issue between WordPress and Jetpack
+/// when both apps are installed.
+///
+/// This can be removed once we remove the Universal Link routes for the WordPress app.
+struct WPAdminConvertibleRouter: LinkRouter {
+    static let shared = WPAdminConvertibleRouter(routes: [
+        EditPostRoute()
+    ])
+
+    let routes: [Route]
+    let matcher: RouteMatcher
+
+    init(routes: [Route]) {
+        self.routes = routes
+        matcher = RouteMatcher(routes: routes)
+    }
+
+    func canHandle(url: URL) -> Bool {
+        return matcher.routesMatching(url).count > 0
+    }
+
+    func handle(url: URL, shouldTrack track: Bool = false, source: DeepLinkSource? = nil) {
+        matcher.routesMatching(url).forEach { route in
+            route.action.perform(route.values, source: nil, router: self)
+        }
+    }
+}
+
+// MARK: - Routes
+
+struct EditPostRoute: Route {
+    let path = "/post/:domain/:postID"
+    let section: DeepLinkSection? = nil
+    let action: NavigationAction = WPAdminConvertibleNavigationAction.editPost
+    let jetpackPowered: Bool = false
+}
+
+// MARK: - Navigation Action
+
+enum WPAdminConvertibleNavigationAction: NavigationAction {
+    case editPost
+
+    func perform(_ values: [String: String], source: UIViewController?, router: LinkRouter) {
+        let wpAdminURL: URL? = {
+            switch self {
+            case .editPost:
+                guard let url = blogURLString(from: values),
+                      let postID = postID(from: values) else {
+                    return nil
+                }
+
+                var components = URLComponents(string: "https://\(url)/wp-admin/post.php")
+                components?.queryItems = [
+                    .init(name: "post", value: postID),
+                    .init(name: "action", value: "edit"),
+                    .init(name: "calypsoify", value: "1")
+                ]
+                return components?.url
+            }
+        }()
+
+        guard let wpAdminURL else {
+            return
+        }
+
+        UIApplication.shared.open(wpAdminURL)
+    }
+}
+
+private extension WPAdminConvertibleNavigationAction {
+    func blogURLString(from values: [String: String]?) -> String? {
+        guard let domain = values?["domain"] else {
+            return nil
+        }
+
+        // First, check if the provided domain is a siteID.
+        // If it is, then try to look up existing blogs and return the URL instead.
+        if let siteID = Int(domain) {
+            let blog = try? Blog.lookup(withID: siteID, in: ContextManager.shared.mainContext)
+            return blog?.hostURL as? String
+        }
+
+        if let _ = URL(string: domain) {
+            return domain
+        }
+
+        return nil
+    }
+
+    func postID(from values: [String: String]?) -> String? {
+        return values?["postID"]
+    }
+}

WordPress/Classes/Utility/Universal Links/Route.swift

@@ -44,6 +44,14 @@ extension NavigationAction {
                 return false
         }
 
+        // TODO: This is a workaround. Remove after the Universal Link routes for the WordPress app are removed.
+        //
+        // Don't fallback to Safari if the counterpart WordPress/Jetpack app is installed.
+        // Read more: https://github.com/wordpress-mobile/WordPress-iOS/issues/19755
+        if MigrationAppDetection.isCounterpartAppInstalled {
+            return false
+        }
+
         let noOptions: [UIApplication.OpenExternalURLOptionsKey: Any] = [:]
         UIApplication.shared.open(url, options: noOptions, completionHandler: nil)
         return true

WordPress/Classes/Utility/Universal Links/UniversalLinkRouter.swift

@@ -150,6 +150,14 @@ struct UniversalLinkRouter: LinkRouter {
         }
 
         if matches.isEmpty {
+            // TODO: This is a workaround. Remove after the Universal Link routes for the WordPress app are removed.
+            //
+            // Don't fallback to Safari if the counterpart WordPress/Jetpack app is installed.
+            // Read more: https://github.com/wordpress-mobile/WordPress-iOS/issues/19755
+            if MigrationAppDetection.isCounterpartAppInstalled {
+                return
+            }
+
             UIApplication.shared.open(url,
                                       options: [:],
                                       completionHandler: nil)

WordPress/Jetpack/Classes/ViewRelated/WordPress-to-Jetpack Migration/Common/MigrationAppDetection.swift

@@ -23,4 +23,9 @@ struct MigrationAppDetection {
 
         return .wordPressNotInstalled
     }
+
+    static var isCounterpartAppInstalled: Bool {
+        let scheme: AppScheme = AppConfiguration.isJetpack ? .wordpress : .jetpack
+        return UIApplication.shared.canOpen(app: scheme)
+    }
 }