based off of Marcus Zarra's work here http://martiancraft.com/blog/2015/03/core-data-stack/

PersistenceController.swift

//                 .-'
//            '--./ /     _.---.
//            '-,  (__..-`       \
//               \          .     |
//                `,.__.   ,__.--/
//                  '._/_.'___.-`

import Foundation
import CoreData

public class PersistenceController {
    private let privateContext: NSManagedObjectContext
    public let mainContext: NSManagedObjectContext
    
    public init(_ callback: (()->Void)? = nil) {
        let modelURL = NSBundle.mainBundle().URLForResource("Model", withExtension: "momd")!
        let mom = NSManagedObjectModel(contentsOfURL: modelURL)!
        let coordinator = NSPersistentStoreCoordinator(managedObjectModel: mom)
        
        mainContext = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
        privateContext = NSManagedObjectContext(concurrencyType: .PrivateQueueConcurrencyType)
        
        privateContext.persistentStoreCoordinator = coordinator
        mainContext.parentContext = privateContext
        
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0)) {
            let psc = self.privateContext.persistentStoreCoordinator
            let options = [
                NSMigratePersistentStoresAutomaticallyOption: true,
                NSInferMappingModelAutomaticallyOption: true,
                NSSQLitePragmasOption: ["journal_mode":"DELETE"]
            ]
            
            let fileManager = NSFileManager.defaultManager()
            let documentsURL = fileManager.URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask).last!
            let storeURL = documentsURL.URLByAppendingPathComponent("Model.sqlite")
            
            do {
                try psc!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: storeURL, options: options)
            }
            catch {
                print("Error adding persisten store: \(error)")
            }
            
            if let callback = callback {
                dispatch_async(dispatch_get_main_queue()) {
                    callback()
                }
            }
        }
    }
    
    public func save() {
        guard privateContext.hasChanges || self.mainContext.hasChanges else {
            return
        }
        
        self.mainContext.performBlockAndWait {
            do {
                try self.mainContext.save()
                self.privateContext.performBlock {
                    do {
                        try self.privateContext.save()
                    }
                    catch {
                        print("Error trying to save privateContext: \(error)")
                    }
                }
            }
            catch {
                print("Error trying to save mainContext: \(error)")
            }
        }
    }
    
    public func makeWorkerContext() -> NSManagedObjectContext {
        let workerContext = NSManagedObjectContext(concurrencyType: .PrivateQueueConcurrencyType)
        workerContext.parentContext = mainContext
        return workerContext
    }
}