Core Data stack in Swift

gistfile1.swift

//
//  PersistenceStack.swift

import CoreData

public class PersistenceStack: NSObject {
    let mainContext: NSManagedObjectContext = {
        let context = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
            context.undoManager = nil
            context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
            return context
    }()
    var isSetup: Bool { return mainContext.persistentStoreCoordinator != nil }
    override init() {
        super.init()
        setupStack()
    }
    
    class func sharedStack() -> PersistenceStack {
        struct Singleton {
            static let _sharedStack = PersistenceStack()
        }
        return Singleton._sharedStack
    }
    
    public func deleteAndResetStack() {
        var error: NSError?
        
        let coordinator = mainContext.persistentStoreCoordinator
        if let store = coordinator.persistentStoreForURL(storeURL) {
            mainContext.reset()
            let removedStore = coordinator.removePersistentStore(store, error: &error)
            if !removedStore {
                println("Unable to remove store: \(error)")
                return
            }
            
            let fm = NSFileManager.defaultManager()
            let deleted = fm.removeItemAtURL(storeURL, error: &error)
            if !deleted {
                println("Unable to remove Core Data DB at \(storeURL): \(error)")
            }
            addStoreToCoordinator(coordinator)
        }
        
    }
    
    private func setupStack() {
        let model = NSManagedObjectModel(contentsOfURL: modelURL)
        let coordinator = NSPersistentStoreCoordinator(managedObjectModel: model)
        addStoreToCoordinator(coordinator)
        
        mainContext.persistentStoreCoordinator = coordinator
    }
    
    private func addStoreToCoordinator(coordinator: NSPersistentStoreCoordinator) {
        var error: NSError?
        let store = coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: storeURL, options: nil, error: &error)
        if store == nil {
            println("Could not open store at \(storeURL): \(error)")
        }
    }
    
    public func printStoreInfo() {
        let model = mainContext.persistentStoreCoordinator.managedObjectModel
        let entities = model.entities as [NSEntityDescription]
        for entity in entities {
            println(entity)
        }
    }
    
    public func save() {
        let moc = mainContext
        moc.performBlock {
            var error: NSError?
            if !moc.save(&error) {
                println("Error saving context: \(error)")
            }
        }
    }
}

extension PersistenceStack { // MARK: URLs
    var modelURL: NSURL! {
        return NSBundle.mainBundle().URLForResource("Posessions", withExtension: "momd")
    }
    
    var storeURL: NSURL! {
        let urls = NSFileManager.defaultManager().URLsForDirectory(NSSearchPathDirectory.DocumentDirectory, inDomains: NSSearchPathDomainMask.UserDomainMask)
        let documentURL = urls.last as NSURL
        let storeURL = documentURL.URLByAppendingPathComponent("Posessions.sqlite")
        return storeURL
    }
}


//
//  ManagedObject.swift

import CoreData

class ManagedObject: NSManagedObject {
    class var managedEntityName: String { return "" }
	class var sortDescriptors: [NSSortDescriptor] { return [] }
    
    class func all() -> [AnyObject]? {
        let request = NSFetchRequest(entityName: managedEntityName)
        let moc = PersistenceStack.sharedStack().mainContext
        var error: NSError?
        let result = moc.executeFetchRequest(request, error: &error)
        if result == nil {
            println("Error fetching \(NSStringFromClass(self)): \(error)")
            return nil
        } else {
            return result
        }
    }
    
    class func insert() -> AnyObject? {
        let moc = PersistenceStack.sharedStack().mainContext
        let object = NSEntityDescription.insertNewObjectForEntityForName(managedEntityName, inManagedObjectContext: moc) as? ManagedObject
        return object
    }
	
	class func controller() -> NSFetchedResultsController {
		let moc = PersistenceStack.sharedStack().mainContext
        let request = NSFetchRequest(entityName: managedEntityName)
		request.sortDescriptors = sortDescriptors
        let controller = NSFetchedResultsController(fetchRequest: request, managedObjectContext: moc, sectionNameKeyPath: nil, cacheName: nil)
		
		return controller
	}
}