Sync form factor specific favorites

Sources/Bookmarks/BookmarkEditorViewModel.swift

@@ -31,11 +31,15 @@ public class BookmarkEditorViewModel: ObservableObject {
     }
 
     let context: NSManagedObjectContext
+    public let favoritesDisplayMode: FavoritesDisplayMode
 
     @Published public var bookmark: BookmarkEntity
     @Published public var locations = [Location]()
 
-    lazy var favoritesFolder: BookmarkEntity! = BookmarkUtils.fetchFavoritesFolder(context)
+    lazy var favoritesFolder: BookmarkEntity! = BookmarkUtils.fetchFavoritesFolder(
+        withUUID: favoritesDisplayMode.displayedFolder.rawValue,
+        in: context
+    )
 
     private var observer: NSObjectProtocol?
     private let subject = PassthroughSubject<Void, Never>()
@@ -59,11 +63,13 @@ public class BookmarkEditorViewModel: ObservableObject {
 
     public init(editingEntityID: NSManagedObjectID,
                 bookmarksDatabase: CoreDataDatabase,
+                favoritesDisplayMode: FavoritesDisplayMode,
                 errorEvents: EventMapping<BookmarksModelError>?) {
 
         externalUpdates = subject.eraseToAnyPublisher()
         self.errorEvents = errorEvents
         self.context = bookmarksDatabase.makeContext(concurrencyType: .mainQueueConcurrencyType)
+        self.favoritesDisplayMode = favoritesDisplayMode
 
         guard let entity = context.object(with: editingEntityID) as? BookmarkEntity else {
             // For sync, this is valid scenario in case of a timing issue
@@ -84,11 +90,13 @@ public class BookmarkEditorViewModel: ObservableObject {
 
     public init(creatingFolderWithParentID parentFolderID: NSManagedObjectID?,
                 bookmarksDatabase: CoreDataDatabase,
+                favoritesDisplayMode: FavoritesDisplayMode,
                 errorEvents: EventMapping<BookmarksModelError>?) {
 
         externalUpdates = subject.eraseToAnyPublisher()
         self.errorEvents = errorEvents
         self.context = bookmarksDatabase.makeContext(concurrencyType: .mainQueueConcurrencyType)
+        self.favoritesDisplayMode = favoritesDisplayMode
 
         let parent: BookmarkEntity?
         if let parentFolderID = parentFolderID {
@@ -173,13 +181,13 @@ public class BookmarkEditorViewModel: ObservableObject {
     }
 
     public func removeFromFavorites() {
-        assert(bookmark.isFavorite)
-        bookmark.removeFromFavorites()
+        assert(bookmark.isFavorite(on: favoritesDisplayMode.displayedFolder))
+        bookmark.removeFromFavorites(with: favoritesDisplayMode)
     }
 
     public func addToFavorites() {
-        assert(!bookmark.isFavorite)
-        bookmark.addToFavorites(favoritesRoot: favoritesFolder)
+        assert(!bookmark.isFavorite(on: favoritesDisplayMode.displayedFolder))
+        bookmark.addToFavorites(with: favoritesDisplayMode, in: context)
     }
 
     public func setParentWithID(_ parentID: NSManagedObjectID) {

Sources/Bookmarks/BookmarkEntity.swift

@@ -21,12 +21,28 @@
 import Foundation
 import CoreData
 
+/**
+ * This enum defines available favorites folders with their UUIDs as raw value.
+ */
+public enum FavoritesFolderID: String, CaseIterable {
+    /// Mobile form factor favorites folder
+    case mobile = "mobile_favorites_root"
+    /// Desktop form factor favorites folder
+    case desktop = "desktop_favorites_root"
+    /// Unified (mobile + desktop) favorites folder
+    case unified = "favorites_root"
+}
+
 @objc(BookmarkEntity)
 public class BookmarkEntity: NSManagedObject {
 
     public enum Constants {
         public static let rootFolderID = "bookmarks_root"
-        public static let favoritesFolderID = "favorites_root"
+        public static let favoriteFoldersIDs: Set<String> = Set(FavoritesFolderID.allCases.map(\.rawValue))
+    }
+
+    public static func isValidFavoritesFolderID(_ value: String) -> Bool {
+        FavoritesFolderID.allCases.contains { $0.rawValue == value }
     }
 
     public enum Error: Swift.Error {
@@ -49,7 +65,7 @@ public class BookmarkEntity: NSManagedObject {
     @NSManaged public var url: String?
     @NSManaged public var uuid: String?
     @NSManaged public var children: NSOrderedSet?
-    @NSManaged fileprivate(set) public var favoriteFolder: BookmarkEntity?
+    @NSManaged public fileprivate(set) var favoriteFolders: NSSet?
     @NSManaged public fileprivate(set) var favorites: NSOrderedSet?
     @NSManaged public var parent: BookmarkEntity?
 
@@ -58,8 +74,12 @@ public class BookmarkEntity: NSManagedObject {
     /// In-memory flag. When set to `false`, disables adjusting `modifiedAt` on `willSave()`. It's reset to `true` on `didSave()`.
     public var shouldManageModifiedAt: Bool = true
 
-    public var isFavorite: Bool {
-        favoriteFolder != nil
+    public func isFavorite(on platform: FavoritesFolderID) -> Bool {
+        favoriteFoldersSet.contains { $0.uuid == platform.rawValue }
+    }
+
+    public var favoritedOn: [FavoritesFolderID] {
+        favoriteFoldersSet.compactMap(\.uuid).compactMap(FavoritesFolderID.init)
     }
 
     public convenience init(context moc: NSManagedObjectContext) {
@@ -81,7 +101,7 @@ public class BookmarkEntity: NSManagedObject {
         guard !changedKeys.isEmpty, !changedKeys.contains(NSStringFromSelector(#selector(getter: modifiedAt))) else {
             return
         }
-        if isInserted && (uuid == Constants.rootFolderID || uuid == Constants.favoritesFolderID) {
+        if isInserted, let uuid, uuid == Constants.rootFolderID || Self.isValidFavoritesFolderID(uuid) {
             return
         }
         modifiedAt = Date()
@@ -123,6 +143,10 @@ public class BookmarkEntity: NSManagedObject {
         return children.filter { $0.isPendingDeletion == false }
     }
 
+    public var favoriteFoldersSet: Set<BookmarkEntity> {
+        return favoriteFolders.flatMap(Set<BookmarkEntity>.init) ?? []
+    }
+
     public static func makeFolder(title: String,
                                   parent: BookmarkEntity,
                                   insertAtBeginning: Bool = false,
@@ -168,9 +192,21 @@ public class BookmarkEntity: NSManagedObject {
             root.addToFavorites(self)
         }
     }
-
-    public func removeFromFavorites() {
-        favoriteFolder = nil
+
+    public func addToFavorites(folders: [BookmarkEntity]) {
+        for root in folders {
+            root.addToFavorites(self)
+        }
+    }
+
+    public func removeFromFavorites(folders: [BookmarkEntity]) {
+        for root in folders {
+            root.removeFromFavorites(self)
+        }
+    }
+
+    public func removeFromFavorites(favoritesRoot: BookmarkEntity) {
+        favoritesRoot.removeFromFavorites(self)
     }
 
     public func markPendingDeletion() {
@@ -200,20 +236,12 @@ extension BookmarkEntity {
     func validate() throws {
         try validateThatFoldersDoNotHaveURLs()
         try validateThatFolderHierarchyHasNoCycles()
-        try validateFavoritesStatus()
         try validateFavoritesFolder()
     }
 
-    func validateFavoritesStatus() throws {
-        let isInFavoriteCollection = favoriteFolder != nil
-        if isFavorite != isInFavoriteCollection {
-            throw Error.invalidFavoritesStatus
-        }
-    }
-
     func validateFavoritesFolder() throws {
-        if let favoritesFolderID = favoriteFolder?.uuid,
-            favoritesFolderID != Constants.favoritesFolderID {
+        let uuids = Set(favoriteFoldersSet.compactMap(\.uuid))
+        guard uuids.isSubset(of: Constants.favoriteFoldersIDs) else {
             throw Error.invalidFavoritesFolder
         }
     }
@@ -296,6 +324,23 @@ extension BookmarkEntity {
 
 }
 
+// MARK: Generated accessors for favoriteFolders
+extension BookmarkEntity {
+
+    @objc(addFavoriteFoldersObject:)
+    @NSManaged private func addToFavoriteFolders(_ value: BookmarkEntity)
+
+    @objc(removeFavoriteFoldersObject:)
+    @NSManaged private func removeFromFavoriteFolders(_ value: BookmarkEntity)
+
+    @objc(addFavoriteFolders:)
+    @NSManaged private func addToFavoriteFolders(_ values: NSSet)
+
+    @objc(removeFavoriteFolders:)
+    @NSManaged private func removeFromFavoriteFolders(_ values: NSSet)
+
+}
+
 extension BookmarkEntity: Identifiable {
 
 }

Sources/Bookmarks/BookmarkListViewModel.swift

@@ -27,6 +27,11 @@ public class BookmarkListViewModel: BookmarkListInteracting, ObservableObject {
     public let currentFolder: BookmarkEntity?
 
     let context: NSManagedObjectContext
+    public var favoritesDisplayMode: FavoritesDisplayMode {
+        didSet {
+            reloadData()
+        }
+    }
 
     public var bookmarks = [BookmarkEntity]()
 
@@ -40,11 +45,13 @@ public class BookmarkListViewModel: BookmarkListInteracting, ObservableObject {
 
     public init(bookmarksDatabase: CoreDataDatabase,
                 parentID: NSManagedObjectID?,
+                favoritesDisplayMode: FavoritesDisplayMode,
                 errorEvents: EventMapping<BookmarksModelError>?) {
         self.externalUpdates = self.subject.eraseToAnyPublisher()
         self.localUpdates = self.localSubject.eraseToAnyPublisher()
         self.errorEvents = errorEvents
         self.context = bookmarksDatabase.makeContext(concurrencyType: .mainQueueConcurrencyType)
+        self.favoritesDisplayMode = favoritesDisplayMode
 
         if let parentID = parentID {
             if let bookmark = (try? context.existingObject(with: parentID)) as? BookmarkEntity {
@@ -75,19 +82,19 @@ public class BookmarkListViewModel: BookmarkListInteracting, ObservableObject {
         }
     }
 
-    // swiftlint:disable:next function_parameter_count
-    public func createBookmark(title: String,
-                               url: String,
-                               folder: BookmarkEntity,
-                               folderIndex: Int,
-                               favoritesFolder: BookmarkEntity?,
-                               favoritesIndex: Int?) {
+    public func createBookmark(
+        title: String,
+        url: String,
+        folder: BookmarkEntity,
+        folderIndex: Int,
+        favoritesFoldersAndIndexes: [BookmarkEntity: Int]
+    ) {
         let bookmark = BookmarkEntity.makeBookmark(title: title, url: url, parent: folder, context: context)
         if let addedIndex = folder.childrenArray.firstIndex(of: bookmark) {
             moveBookmark(bookmark, fromIndex: addedIndex, toIndex: folderIndex)
         }
-        if let favoritesFolder, let favoritesIndex {
-            bookmark.addToFavorites(insertAt: favoritesIndex, favoritesRoot: favoritesFolder)
+        for (favoritesFolder, index) in favoritesFoldersAndIndexes {
+            bookmark.addToFavorites(insertAt: index, favoritesRoot: favoritesFolder)
         }
         save()
     }
@@ -115,10 +122,10 @@ public class BookmarkListViewModel: BookmarkListInteracting, ObservableObject {
     }
 
     public func toggleFavorite(_ bookmark: BookmarkEntity) {
-        if bookmark.isFavorite {
-            bookmark.removeFromFavorites()
-        } else if let folder = BookmarkUtils.fetchFavoritesFolder(context) {
-            bookmark.addToFavorites(favoritesRoot: folder)
+        if bookmark.isFavorite(on: favoritesDisplayMode.displayedFolder) {
+            bookmark.removeFromFavorites(with: favoritesDisplayMode)
+        } else {
+            bookmark.addToFavorites(with: favoritesDisplayMode, in: context)
         }
         save()
     }