Sample Code for MacOS Core Data with external file management with Undo/Redo

Question

I'm trying to create an NSManagedObject subclass that manages a single file external to the Core Data database targeting back to MacOS 10.14. I don't think I can use the in built feature to store externally, as one of my use-cases is to have the managed file be accessible by QLPreviewItem, which only accepts a URL, not transformed data.

I'm storing the file name in the managed object, and constructing a file path URL on demand with the (known) directory and the file name. The basic behaviours of adding and deleting, even renaming the file (through the application) is all easy. I'm trying to add Undo/Redo support but keep coming into edge conditions where I get it mostly working, but then find some other case in testing where it breaks.

I've been basing my work on this excellent question.

@objc var filepath: URL? {
    get {
        willAccessValue(forKey: #keyPath(File.filepath))
        defer { didAccessValue(forKey: #keyPath(File.filepath)) }
        guard primitiveValue(forKey: #keyPath(File.filepath)) == nil else {
            return primitiveValue(forKey: #keyPath(File.filepath)) as? URL
        }
        setPrimitiveValue(file_directory.appendingPathComponent(primitiveValue(forKey: #keyPath(File.filename)) as! String), forKey: #keyPath(File.filepath))
        return primitiveValue(forKey: #keyPath(File.filepath)) as? URL
    }
}

And then in didSave() I'm checking for deletion and moving the file to the trash, and implementing restoring of the file in awake(fromSnapshotEvents:).

These managed files are typically in to-one relationships to other objects which can have many managed files, so I handle this by creating a child context and presenting a sheet to the user which contains a table with their managed files. This is a pattern that I've found works well to coalesce undo/redos of the entire sheet. However, this is where I encounter a lot of edge cases in trying to manage the files. The child context seems to need different undo/redo rules to the parent context after being saved back, but I then need a way to pass status information back to the parent context.

For example, if the user deletes a file, it will be moved to the trash when the child context saves itself to the parent context, but then the parent context needs to know the path to the file in the trash to restore the file should the user want to undo all operations in the sheet.

The behaviour and status information appears to be different depending on whether the child context is active, and again depending on whether the parent context is saved or not. Is there any good sample code that covers managing external data in this way? I feel like I'm playing whack-a-mole and have way to many checks for the state of the parent context. This must be a solved problem, but I haven't really found much other than this being the recommended approach a few years ago.

score 0 · Answer 1 · answered Jan 15 '22 at 23:02

What I ended up doing:

public class File: NSManagedObject {
    
    var file_directory: URL {
        get {
            return sharedDirectoryStucture.workFolder()
        }
    }
    
    @objc var filename: String {
        get {
            willAccessValue(forKey: #keyPath(File.filename))
            defer { didAccessValue(forKey: #keyPath(File.filename)) }
            return primitiveValue(forKey: #keyPath(File.filename)) as? String ?? ""
        }
        set {
            let new_filename = newValue as String
            willChangeValue(forKey: #keyPath(File.filename))
            defer { didChangeValue(forKey: #keyPath(File.filename)) }
            let lastname = primitiveValue(forKey: #keyPath(File.filename)) as? String
            setPrimitiveValue(new_filename, forKey: #keyPath(File.filename))
            setPrimitiveValue(nil, forKey: #keyPath(File.filepath))
            if let _ = lastname, sharedFileAccess.fileExists(file: file_directory.appendingPathComponent(lastname!)) {
                moveFile(from: file_directory.appendingPathComponent(lastname!), to: file_directory.appendingPathComponent(new_filename))
            }
        }
    }
    
    @objc var filepath: URL? {
        get {
            willAccessValue(forKey: #keyPath(File.filepath))
            defer { didAccessValue(forKey: #keyPath(File.filepath)) }
            guard primitiveValue(forKey: #keyPath(File.filepath)) == nil else {
                return primitiveValue(forKey: #keyPath(File.filepath)) as? URL
            }
            if let file_name = primitiveValue(forKey: #keyPath(File.filename)) as? String {
                setPrimitiveValue(file_directory.appendingPathComponent(file_name), forKey: #keyPath(File.filepath))
                return primitiveValue(forKey: #keyPath(File.filepath)) as? URL
            }
            return nil
        }
    }
    
    public class override func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String> {
        if key == #keyPath(File.filepath) {
            return Set(arrayLiteral: #keyPath(File.filename))
        }
        return super.keyPathsForValuesAffectingValue(forKey: key)
    }
    
    func createByCopyingExistingFile(remoteFilepath: URL, file_name: String) throws {
        do {
            let file_path = filepath!
            try sharedFileAccess.copyFile(from: remoteFilepath, to: file_path)
            if (managedObjectContext?.undoManager!.isUndoing)! == false || (managedObjectContext?.undoManager!.isRedoing)! == false {
                managedObjectContext?.undoManager?.registerUndo(withTarget: self) { _ in
                    self.moveFile(from: file_path, to: nil)
                }
            }
        } catch {
            NSApp.presentError(error, modalFor: NSApp.mainWindow!, delegate: nil, didPresent: nil, contextInfo: nil)
        }
    }
    
    override public func prepareForDeletion() {
        if managedObjectContext?.parent == nil {
            if let _ = filepath {
                moveFile(from: filepath!, to: nil)
            }
            else if let file_name = committedValues(forKeys: [#keyPath(File.filename)])[#keyPath(File.filename)] as? String {
                let file_path = file_directory.appendingPathComponent(file_name)
                if sharedFileAccess.fileExists(file: file_path) {
                    moveFile(from: file_path, to: nil)
                }
            }
        }
        super.prepareForDeletion()
    }
    
    func moveFile(from: URL, to: URL?) {
        do {
            var destination: URL
            if let _ = to {
                destination = to!
                try sharedFileAccess.moveFile(from: from, to: destination)
            }
            else {
                var trashedFile: NSURL?
                try sharedFileAccess.trashFile(at: from, trashedPath: &trashedFile)
                destination = trashedFile! as URL
            }
            managedObjectContext?.undoManager?.registerUndo(withTarget: self) { _ in
                self.moveFile(from: destination, to: from)
            }
        } catch {
            if (managedObjectContext?.undoManager!.isUndoing)! == false && (managedObjectContext?.undoManager!.isRedoing)! == false {
                NSApp.presentError(error, modalFor: NSApp.mainWindow!, delegate: nil, didPresent: nil, contextInfo: nil)
            }
        }
    }
    
}

I haven't found an edge case where this fails yet, but I'm unhappy with the catch in the moveFile() function. sharedFileAccess and sharedDirectoryStucture are my wrappers for the file moving/deleting functions and system locations (for injecting extra debug).

Sample Code for MacOS Core Data with external file management with Undo/Redo

1 Answers1