Swift Package Manager support

Sources/Internal/AssociatedObjects.swift

@@ -0,0 +1,68 @@
+//
+//  NSObject+CoreStore.swift
+//  CoreStore
+//
+//  Copyright © 2014 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+internal func getAssociatedObjectForKey<T: AnyObject>(key: UnsafePointer<Void>, inObject object: AnyObject) -> T? {
+    
+    switch objc_getAssociatedObject(object, key) {
+        
+    case let associatedObject as T:
+        return associatedObject
+        
+    case let associatedObject as WeakObject:
+        return associatedObject.object as? T
+        
+    default:
+        return nil
+    }
+}
+
+internal func setAssociatedRetainedObject<T: AnyObject>(associatedObject: T?, forKey key: UnsafePointer<Void>, inObject object: AnyObject) {
+    
+    objc_setAssociatedObject(object, key, associatedObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+}
+
+internal func setAssociatedCopiedObject<T: AnyObject>(associatedObject: T?, forKey key: UnsafePointer<Void>, inObject object: AnyObject) {
+    
+    objc_setAssociatedObject(object, key, associatedObject, .OBJC_ASSOCIATION_COPY_NONATOMIC)
+}
+
+internal func setAssociatedAssignedObject<T: AnyObject>(associatedObject: T?, forKey key: UnsafePointer<Void>, inObject object: AnyObject) {
+    
+    objc_setAssociatedObject(object, key, associatedObject, .OBJC_ASSOCIATION_ASSIGN)
+}
+
+internal func setAssociatedWeakObject<T: AnyObject>(associatedObject: T?, forKey key: UnsafePointer<Void>, inObject object: AnyObject) {
+    
+    if let associatedObject = associatedObject {
+        
+        objc_setAssociatedObject(object, key, WeakObject(associatedObject), .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+    else {
+        
+        objc_setAssociatedObject(object, key, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}

Sources/Internal/CoreStoreFetchedResultsController.swift

@@ -0,0 +1,100 @@
+//
+//  CoreStoreFetchedResultsController.swift
+//  CoreStore
+//
+//  Copyright © 2016 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - CoreStoreFetchedResultsController
+
+@available(OSX, unavailable)
+internal final class CoreStoreFetchedResultsController<T: NSManagedObject>: NSFetchedResultsController {
+    
+    // MARK: Internal
+    
+    internal convenience init<T>(dataStack: DataStack, fetchRequest: NSFetchRequest, from: From<T>? = nil, sectionBy: SectionBy? = nil, fetchClauses: [FetchClause]) {
+        
+        self.init(
+            context: dataStack.mainContext,
+            fetchRequest: fetchRequest,
+            from: from,
+            sectionBy: sectionBy,
+            fetchClauses: fetchClauses
+        )
+    }
+    
+    internal init<T>(context: NSManagedObjectContext, fetchRequest: NSFetchRequest, from: From<T>? = nil, sectionBy: SectionBy? = nil, fetchClauses: [FetchClause]) {
+        
+        from?.applyToFetchRequest(fetchRequest, context: context, applyAffectedStores: false)
+        for clause in fetchClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        if let from = from {
+            
+            self.reapplyAffectedStores = {
+                
+                return from.applyAffectedStoresForFetchedRequest(fetchRequest, context: context)
+            }
+        }
+        else {
+            
+            guard let from = (fetchRequest.entity.flatMap { $0.managedObjectClassName }).flatMap(NSClassFromString).flatMap(From.init) else {
+                
+                fatalError("Attempted to create an \(typeName(NSFetchedResultsController)) without a  From clause or an NSEntityDescription.")
+            }
+            
+            self.reapplyAffectedStores = {
+                
+                return from.applyAffectedStoresForFetchedRequest(fetchRequest, context: context)
+            }
+        }
+        
+        super.init(
+            fetchRequest: fetchRequest,
+            managedObjectContext: context,
+            sectionNameKeyPath: sectionBy?.sectionKeyPath,
+            cacheName: nil
+        )
+    }
+    
+    internal func performFetchFromSpecifiedStores() throws {
+        
+        if !self.reapplyAffectedStores() {
+            
+            CoreStore.log(
+                .Warning,
+                message: "Attempted to perform a fetch on an \(typeName(NSFetchedResultsController)) but could not find any persistent store for the entity \(typeName(self.fetchRequest.entityName))"
+            )
+        }
+        try self.performFetch()
+    }
+    
+    
+    // MARK: Private
+    
+    private let reapplyAffectedStores: () -> Bool
+}

Sources/Internal/FetchedResultsControllerDelegate.swift

@@ -0,0 +1,219 @@
+//
+//  FetchedResultsControllerDelegate.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - FetchedResultsControllerHandler
+
+@available(OSX, unavailable)
+internal protocol FetchedResultsControllerHandler: class {
+    
+    func controller(controller: NSFetchedResultsController, didChangeObject anObject: AnyObject, atIndexPath indexPath: NSIndexPath?, forChangeType type: NSFetchedResultsChangeType, newIndexPath: NSIndexPath?)
+    
+    func controller(controller: NSFetchedResultsController, didChangeSection sectionInfo: NSFetchedResultsSectionInfo, atIndex sectionIndex: Int, forChangeType type: NSFetchedResultsChangeType)
+    
+    func controllerWillChangeContent(controller: NSFetchedResultsController)
+    
+    func controllerDidChangeContent(controller: NSFetchedResultsController)
+    
+    func controller(controller: NSFetchedResultsController, sectionIndexTitleForSectionName sectionName: String?) -> String?
+}
+
+
+// MARK: - FetchedResultsControllerDelegate
+
+@available(OSX, unavailable)
+internal final class FetchedResultsControllerDelegate: NSObject, NSFetchedResultsControllerDelegate {
+    
+    // MARK: Internal
+    
+    internal var enabled = true
+    
+    internal weak var handler: FetchedResultsControllerHandler?
+    internal weak var fetchedResultsController: NSFetchedResultsController? {
+        
+        didSet {
+            
+            oldValue?.delegate = nil
+            self.fetchedResultsController?.delegate = self
+        }
+    }
+    
+    deinit {
+        
+        self.fetchedResultsController?.delegate = nil
+    }
+    
+    
+    // MARK: NSFetchedResultsControllerDelegate
+    
+    @objc dynamic func controllerWillChangeContent(controller: NSFetchedResultsController) {
+        
+        guard self.enabled else {
+            
+            return
+        }
+        
+        self.deletedSections = []
+        self.insertedSections = []
+        
+        self.handler?.controllerWillChangeContent(controller)
+    }
+    
+    @objc dynamic func controllerDidChangeContent(controller: NSFetchedResultsController) {
+        
+        guard self.enabled else {
+            
+            return
+        }
+        
+        self.handler?.controllerDidChangeContent(controller)
+    }
+    
+    @objc dynamic func controller(controller: NSFetchedResultsController, didChangeObject anObject: AnyObject, atIndexPath indexPath: NSIndexPath?, forChangeType type: NSFetchedResultsChangeType, newIndexPath: NSIndexPath?) {
+        
+        guard self.enabled else {
+            
+            return
+        }
+        
+        guard let actualType = NSFetchedResultsChangeType(rawValue: type.rawValue) else {
+            
+            // This fix is for a bug where iOS passes 0 for NSFetchedResultsChangeType, but this is not a valid enum case.
+            // Swift will then always execute the first case of the switch causing strange behaviour.
+            // https://forums.developer.apple.com/thread/12184#31850
+            return
+        }
+        
+        // This whole dance is a workaround for a nasty bug introduced in XCode 7 targeted at iOS 8 devices
+        // http://stackoverflow.com/questions/31383760/ios-9-attempt-to-delete-and-reload-the-same-index-path/31384014#31384014
+        // https://forums.developer.apple.com/message/9998#9998
+        // https://forums.developer.apple.com/message/31849#31849
+        
+        switch actualType {
+            
+        case .Update:
+            guard let section = indexPath?.indexAtPosition(0) else {
+                
+                return
+            }
+            if self.deletedSections.contains(section)
+                || self.insertedSections.contains(section) {
+                    
+                    return
+            }
+            
+        case .Move:
+            guard let indexPath = indexPath, let newIndexPath = newIndexPath else {
+                
+                return
+            }
+            guard indexPath == newIndexPath else {
+                
+                break
+            }
+            if self.insertedSections.contains(indexPath.indexAtPosition(0)) {
+                
+                // Observers that handle the .Move change are advised to delete then reinsert the object instead of just moving. This is especially true when indexPath and newIndexPath are equal. For example, calling tableView.moveRowAtIndexPath(_:toIndexPath) when both indexPaths are the same will crash the tableView.
+                self.handler?.controller(
+                    controller,
+                    didChangeObject: anObject,
+                    atIndexPath: indexPath,
+                    forChangeType: .Move,
+                    newIndexPath: newIndexPath
+                )
+                return
+            }
+            if self.deletedSections.contains(indexPath.indexAtPosition(0)) {
+                
+                self.handler?.controller(
+                    controller,
+                    didChangeObject: anObject,
+                    atIndexPath: nil,
+                    forChangeType: .Insert,
+                    newIndexPath: indexPath
+                )
+                return
+            }
+            self.handler?.controller(
+                controller,
+                didChangeObject: anObject,
+                atIndexPath: indexPath,
+                forChangeType: .Update,
+                newIndexPath: nil
+            )
+            return
+            
+        default:
+            break
+        }
+        
+        self.handler?.controller(
+            controller,
+            didChangeObject: anObject,
+            atIndexPath: indexPath,
+            forChangeType: actualType,
+            newIndexPath: newIndexPath
+        )
+    }
+    
+    @objc dynamic func controller(controller: NSFetchedResultsController, didChangeSection sectionInfo: NSFetchedResultsSectionInfo, atIndex sectionIndex: Int, forChangeType type: NSFetchedResultsChangeType) {
+        
+        guard self.enabled else {
+            
+            return
+        }
+        
+        switch type {
+            
+        case .Delete:   self.deletedSections.insert(sectionIndex)
+        case .Insert:   self.insertedSections.insert(sectionIndex)
+        default: break
+        }
+        
+        self.handler?.controller(
+            controller,
+            didChangeSection: sectionInfo,
+            atIndex: sectionIndex,
+            forChangeType: type
+        )
+    }
+    
+    @objc dynamic func controller(controller: NSFetchedResultsController, sectionIndexTitleForSectionName sectionName: String) -> String? {
+        
+        return self.handler?.controller(
+            controller,
+            sectionIndexTitleForSectionName: sectionName
+        )
+    }
+    
+    
+    // MARK: Private
+    
+    private var deletedSections = Set<Int>()
+    private var insertedSections = Set<Int>()
+}

Sources/Internal/Functions.swift

@@ -0,0 +1,81 @@
+//
+//  Functions.swift
+//  CoreStore
+//
+//  Copyright © 2014 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+internal func autoreleasepool<T>(@noescape closure: () -> T) -> T {
+    
+    var closureValue: T!
+    ObjectiveC.autoreleasepool {
+        
+        closureValue = closure()
+    }
+    
+    return closureValue
+}
+
+internal func autoreleasepool<T>(@noescape closure: () throws -> T) throws -> T {
+    
+    var closureValue: T!
+    var closureError: ErrorType?
+    ObjectiveC.autoreleasepool {
+        
+        do {
+            
+            closureValue = try closure()
+        }
+        catch {
+            
+            closureError = error
+        }
+    }
+    
+    if let closureError = closureError {
+        
+        throw closureError
+    }
+    return closureValue
+}
+
+internal func autoreleasepool(@noescape closure: () throws -> Void) throws {
+    
+    var closureError: ErrorType?
+    ObjectiveC.autoreleasepool {
+        
+        do {
+            
+            try closure()
+        }
+        catch {
+            
+            closureError = error
+        }
+    }
+    
+    if let closureError = closureError {
+        
+        throw closureError
+    }
+}

Sources/Internal/MigrationManager.swift

@@ -0,0 +1,62 @@
+//
+//  MigrationManager.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - MigrationManager
+
+internal final class MigrationManager: NSMigrationManager, NSProgressReporting {
+    
+    // MARK: NSObject
+    
+    override func didChangeValueForKey(key: String) {
+        
+        super.didChangeValueForKey(key)
+        
+        guard key == "migrationProgress" else {
+            
+            return
+        }
+        let progress = self.progress
+        progress.completedUnitCount = Int64(Float(progress.totalUnitCount) * self.migrationProgress)
+    }
+    
+    
+    // MARK: NSMigrationManager
+
+    init(sourceModel: NSManagedObjectModel, destinationModel: NSManagedObjectModel, progress: NSProgress) {
+        
+        self.progress = progress
+        
+        super.init(sourceModel: sourceModel, destinationModel: destinationModel)
+    }
+    
+
+    // MARK: NSProgressReporting
+    
+    let progress: NSProgress
+}

Sources/Internal/NSFileManager+Setup.swift

@@ -0,0 +1,26 @@
+//
+//  NSFileManager+Setup.swift
+//  CoreStore
+//
+//  Created by John Rommel Estropia on 2015/07/19.
+//  Copyright © 2015 John Rommel Estropia. All rights reserved.
+//
+
+import Foundation
+
+
+// MARK: - NSFileManager
+
+internal extension NSFileManager {
+    
+    // MARK: Internal
+    
+    internal func removeSQLiteStoreAtURL(fileURL: NSURL) {
+        
+        _ = try? self.removeItemAtURL(fileURL)
+        
+        let filePath = fileURL.path!
+        _ = try? self.removeItemAtPath(filePath.stringByAppendingString("-shm"))
+        _ = try? self.removeItemAtPath(filePath.stringByAppendingString("-wal"))
+    }
+}

Sources/Internal/NSManagedObjectContext+CoreStore.swift

@@ -0,0 +1,136 @@
+//
+//  NSManagedObjectContext+CoreStore.swift
+//  CoreStore
+//
+//  Copyright © 2014 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+#if USE_FRAMEWORKS
+    import GCDKit
+#endif
+
+
+// MARK: - NSManagedObjectContext
+
+internal extension NSManagedObjectContext {
+    
+    // MARK: Internal
+    
+    internal var shouldCascadeSavesToParent: Bool {
+        
+        get {
+            
+            let number: NSNumber? = getAssociatedObjectForKey(
+                &PropertyKeys.shouldCascadeSavesToParent,
+                inObject: self
+            )
+            return number?.boolValue ?? false
+        }
+        set {
+            
+            setAssociatedCopiedObject(
+                NSNumber(bool: newValue),
+                forKey: &PropertyKeys.shouldCascadeSavesToParent,
+                inObject: self
+            )
+        }
+    }
+    
+    internal func entityDescriptionForEntityType(entity: NSManagedObject.Type) -> NSEntityDescription? {
+        
+        return self.entityDescriptionForEntityClass(entity)
+    }
+    
+    internal func entityDescriptionForEntityClass(entity: AnyClass) -> NSEntityDescription? {
+        
+        guard let entityName = self.parentStack?.entityNameForEntityClass(entity) else {
+            
+            return nil
+        }
+        return NSEntityDescription.entityForName(
+            entityName,
+            inManagedObjectContext: self
+        )
+    }
+    
+    internal func setupForCoreStoreWithContextName(contextName: String) {
+        
+        self.name = contextName
+        
+        self.observerForWillSaveNotification = NotificationObserver(
+            notificationName: NSManagedObjectContextWillSaveNotification,
+            object: self,
+            closure: { (note) -> Void in
+                
+                let context = note.object as! NSManagedObjectContext
+                let insertedObjects = context.insertedObjects
+                let numberOfInsertedObjects = insertedObjects.count
+                guard numberOfInsertedObjects > 0 else {
+                    
+                    return
+                }
+                
+                do {
+                    
+                    try context.obtainPermanentIDsForObjects(Array(insertedObjects))
+                }
+                catch {
+                    
+                    CoreStore.handleError(
+                        error as NSError,
+                        "Failed to obtain permanent ID(s) for \(numberOfInsertedObjects) inserted object(s)."
+                    )
+                }
+            }
+        )
+    }
+    
+    
+    // MARK: Private
+    
+    private struct PropertyKeys {
+        
+        static var observerForWillSaveNotification: Void?
+        static var shouldCascadeSavesToParent: Void?
+    }
+    
+    private var observerForWillSaveNotification: NotificationObserver? {
+        
+        get {
+            
+            return getAssociatedObjectForKey(
+                &PropertyKeys.observerForWillSaveNotification,
+                inObject: self
+            )
+        }
+        set {
+            
+            setAssociatedRetainedObject(
+                newValue,
+                forKey: &PropertyKeys.observerForWillSaveNotification,
+                inObject: self
+            )
+        }
+    }
+}
+

Sources/Internal/NSManagedObjectContext+Querying.swift

@@ -0,0 +1,422 @@
+//
+//  NSManagedObjectContext+Querying.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - NSManagedObjectContext
+
+internal extension NSManagedObjectContext {
+    
+    // MARK: Internal
+    
+    internal func fetchExisting<T: NSManagedObject>(object: T) -> T? {
+        
+        if object.objectID.temporaryID {
+            
+            do {
+                
+                try withExtendedLifetime(self) { (context: NSManagedObjectContext) -> Void in
+                    
+                    try context.obtainPermanentIDsForObjects([object])
+                }
+            }
+            catch {
+                
+                CoreStore.handleError(
+                    error as NSError,
+                    "Failed to obtain permanent ID for object."
+                )
+                return nil
+            }
+        }
+        
+        do {
+            
+            let existingObject = try self.existingObjectWithID(object.objectID)
+            return (existingObject as! T)
+        }
+        catch {
+            
+            CoreStore.handleError(
+                error as NSError,
+                "Failed to load existing \(typeName(object)) in context."
+            )
+            return nil
+        }
+    }
+    
+    internal func fetchOne<T: NSManagedObject>(from: From<T>, _ fetchClauses: FetchClause...) -> T? {
+        
+        return self.fetchOne(from, fetchClauses)
+    }
+    
+    internal func fetchOne<T: NSManagedObject>(from: From<T>, _ fetchClauses: [FetchClause]) -> T? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        fetchRequest.fetchLimit = 1
+        fetchRequest.resultType = .ManagedObjectResultType
+        
+        for clause in fetchClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var fetchResults: [T]?
+        var fetchError: NSError?
+        self.performBlockAndWait {
+            
+            do {
+                
+                fetchResults = try self.executeFetchRequest(fetchRequest) as? [T]
+            }
+            catch {
+                
+                fetchError = error as NSError
+            }
+        }
+        if fetchResults == nil {
+            
+            CoreStore.handleError(
+                fetchError ?? NSError(coreStoreErrorCode: .UnknownError),
+                "Failed executing fetch request."
+            )
+            return nil
+        }
+        
+        return fetchResults?.first
+    }
+    
+    internal func fetchAll<T: NSManagedObject>(from: From<T>, _ fetchClauses: FetchClause...) -> [T]? {
+        
+        return self.fetchAll(from, fetchClauses)
+    }
+    
+    internal func fetchAll<T: NSManagedObject>(from: From<T>, _ fetchClauses: [FetchClause]) -> [T]? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        fetchRequest.fetchLimit = 0
+        fetchRequest.resultType = .ManagedObjectResultType
+        
+        for clause in fetchClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var fetchResults: [T]?
+        var fetchError: NSError?
+        self.performBlockAndWait {
+            
+            do {
+                
+                fetchResults = try self.executeFetchRequest(fetchRequest) as? [T]
+            }
+            catch {
+                
+                fetchError = error as NSError
+            }
+        }
+        if fetchResults == nil {
+            
+            CoreStore.handleError(
+                fetchError ?? NSError(coreStoreErrorCode: .UnknownError),
+                "Failed executing fetch request."
+            )
+            return nil
+        }
+        
+        return fetchResults
+    }
+    
+    internal func fetchCount<T: NSManagedObject>(from: From<T>, _ fetchClauses: FetchClause...) -> Int? {
+    
+        return self.fetchCount(from, fetchClauses)
+    }
+    
+    internal func fetchCount<T: NSManagedObject>(from: From<T>, _ fetchClauses: [FetchClause]) -> Int? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        for clause in fetchClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var count = 0
+        var error: NSError?
+        self.performBlockAndWait {
+            
+            count = self.countForFetchRequest(fetchRequest, error: &error)
+        }
+        if count == NSNotFound {
+            
+            CoreStore.handleError(
+                error ?? NSError(coreStoreErrorCode: .UnknownError),
+                "Failed executing fetch request."
+            )
+            return nil
+        }
+        
+        return count
+    }
+    
+    internal func fetchObjectID<T: NSManagedObject>(from: From<T>, _ fetchClauses: FetchClause...) -> NSManagedObjectID? {
+        
+        return self.fetchObjectID(from, fetchClauses)
+    }
+    
+    internal func fetchObjectID<T: NSManagedObject>(from: From<T>, _ fetchClauses: [FetchClause]) -> NSManagedObjectID? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        fetchRequest.fetchLimit = 1
+        fetchRequest.resultType = .ManagedObjectIDResultType
+        
+        for clause in fetchClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var fetchResults: [NSManagedObjectID]?
+        var fetchError: NSError?
+        self.performBlockAndWait {
+            
+            do {
+                
+                fetchResults = try self.executeFetchRequest(fetchRequest) as? [NSManagedObjectID]
+            }
+            catch {
+                
+                fetchError = error as NSError
+            }
+        }
+        if fetchResults == nil {
+            
+            CoreStore.handleError(
+                fetchError ?? NSError(coreStoreErrorCode: .UnknownError),
+                "Failed executing fetch request."
+            )
+            return nil
+        }
+        
+        return fetchResults?.first
+    }
+    
+    internal func fetchObjectIDs<T: NSManagedObject>(from: From<T>, _ fetchClauses: FetchClause...) -> [NSManagedObjectID]? {
+        
+        return self.fetchObjectIDs(from, fetchClauses)
+    }
+    
+    internal func fetchObjectIDs<T: NSManagedObject>(from: From<T>, _ fetchClauses: [FetchClause]) -> [NSManagedObjectID]? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        fetchRequest.fetchLimit = 0
+        fetchRequest.resultType = .ManagedObjectIDResultType
+        
+        for clause in fetchClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var fetchResults: [NSManagedObjectID]?
+        var fetchError: NSError?
+        self.performBlockAndWait {
+            
+            do {
+                
+                fetchResults = try self.executeFetchRequest(fetchRequest) as? [NSManagedObjectID]
+            }
+            catch {
+                
+                fetchError = error as NSError
+            }
+        }
+        if fetchResults == nil {
+            
+            CoreStore.handleError(
+                fetchError ?? NSError(coreStoreErrorCode: .UnknownError),
+                "Failed executing fetch request."
+            )
+            return nil
+        }
+        
+        return fetchResults
+    }
+    
+    internal func deleteAll<T: NSManagedObject>(from: From<T>, _ deleteClauses: DeleteClause...) -> Int? {
+        
+        return self.deleteAll(from, deleteClauses)
+    }
+    
+    internal func deleteAll<T: NSManagedObject>(from: From<T>, _ deleteClauses: [DeleteClause]) -> Int? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        fetchRequest.fetchLimit = 0
+        fetchRequest.resultType = .ManagedObjectResultType
+        fetchRequest.returnsObjectsAsFaults = true
+        fetchRequest.includesPropertyValues = false
+        
+        for clause in deleteClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var numberOfDeletedObjects: Int?
+        var fetchError: NSError?
+        self.performBlockAndWait {
+            
+            autoreleasepool {
+                
+                do {
+                    
+                    let fetchResults = try self.executeFetchRequest(fetchRequest) as? [T] ?? []
+                    for object in fetchResults {
+                        
+                        self.deleteObject(object)
+                    }
+                    numberOfDeletedObjects = fetchResults.count
+                }
+                catch {
+                    
+                    fetchError = error as NSError
+                }
+            }
+        }
+        if numberOfDeletedObjects == nil {
+            
+            CoreStore.handleError(
+                fetchError ?? NSError(coreStoreErrorCode: .UnknownError),
+                "Failed executing fetch request."
+            )
+            return nil
+        }
+        
+        return numberOfDeletedObjects
+    }
+    
+    internal func queryValue<T: NSManagedObject, U: SelectValueResultType>(from: From<T>, _ selectClause: Select<U>, _ queryClauses: QueryClause...) -> U? {
+        
+        return self.queryValue(from, selectClause, queryClauses)
+    }
+    
+    internal func queryValue<T: NSManagedObject, U: SelectValueResultType>(from: From<T>, _ selectClause: Select<U>, _ queryClauses: [QueryClause]) -> U? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        fetchRequest.fetchLimit = 0
+        
+        selectClause.applyToFetchRequest(fetchRequest)
+        
+        for clause in queryClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var fetchResults: [AnyObject]?
+        var fetchError: NSError?
+        self.performBlockAndWait {
+            
+            do {
+                
+                fetchResults = try self.executeFetchRequest(fetchRequest)
+            }
+            catch {
+                
+                fetchError = error as NSError
+            }
+        }
+        if let fetchResults = fetchResults {
+            
+            if let rawResult = fetchResults.first as? NSDictionary,
+                let rawObject: AnyObject = rawResult[selectClause.keyPathForFirstSelectTerm()] {
+                    
+                    return Select<U>.ReturnType.fromResultObject(rawObject)
+            }
+            return nil
+        }
+        
+        CoreStore.handleError(
+            fetchError ?? NSError(coreStoreErrorCode: .UnknownError),
+            "Failed executing fetch request."
+        )
+        return nil
+    }
+    
+    internal func queryAttributes<T: NSManagedObject>(from: From<T>, _ selectClause: Select<NSDictionary>, _ queryClauses: QueryClause...) -> [[NSString: AnyObject]]? {
+        
+        return self.queryAttributes(from, selectClause, queryClauses)
+    }
+    
+    internal func queryAttributes<T: NSManagedObject>(from: From<T>, _ selectClause: Select<NSDictionary>, _ queryClauses: [QueryClause]) -> [[NSString: AnyObject]]? {
+        
+        let fetchRequest = NSFetchRequest()
+        from.applyToFetchRequest(fetchRequest, context: self)
+        
+        fetchRequest.fetchLimit = 0
+        
+        selectClause.applyToFetchRequest(fetchRequest)
+        
+        for clause in queryClauses {
+            
+            clause.applyToFetchRequest(fetchRequest)
+        }
+        
+        var fetchResults: [AnyObject]?
+        var fetchError: NSError?
+        self.performBlockAndWait {
+            
+            do {
+                
+                fetchResults = try self.executeFetchRequest(fetchRequest)
+            }
+            catch {
+                
+                fetchError = error as NSError
+            }
+        }
+        if let fetchResults = fetchResults {
+            
+            return Select<NSDictionary>.ReturnType.fromResultObjects(fetchResults)
+        }
+        
+        CoreStore.handleError(
+            fetchError ?? NSError(coreStoreErrorCode: .UnknownError),
+            "Failed executing fetch request."
+        )
+        return nil
+    }
+}

Sources/Internal/NSManagedObjectContext+Setup.swift

@@ -0,0 +1,127 @@
+//
+//  NSManagedObjectContext+Setup.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - NSManagedObjectContext
+
+internal extension NSManagedObjectContext {
+    
+    // MARK: Internal
+    
+    internal weak var parentStack: DataStack? {
+        
+        get {
+            
+            if let parentContext = self.parentContext {
+                
+                return parentContext.parentStack
+            }
+            
+            return getAssociatedObjectForKey(&PropertyKeys.parentStack, inObject: self)
+        }
+        set {
+            
+            guard self.parentContext == nil else {
+                
+                return
+            }
+            
+            setAssociatedWeakObject(
+                newValue,
+                forKey: &PropertyKeys.parentStack,
+                inObject: self
+            )
+        }
+    }
+    
+    internal class func rootSavingContextForCoordinator(coordinator: NSPersistentStoreCoordinator) -> NSManagedObjectContext {
+        
+        let context = NSManagedObjectContext(concurrencyType: .PrivateQueueConcurrencyType)
+        context.persistentStoreCoordinator = coordinator
+        context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
+        context.undoManager = nil
+        context.setupForCoreStoreWithContextName("com.corestore.rootcontext")
+        
+        return context
+    }
+    
+    internal class func mainContextForRootContext(rootContext: NSManagedObjectContext) -> NSManagedObjectContext {
+        
+        let context = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
+        context.parentContext = rootContext
+        context.mergePolicy = NSRollbackMergePolicy
+        context.undoManager = nil
+        context.setupForCoreStoreWithContextName("com.corestore.maincontext")
+        context.observerForDidSaveNotification = NotificationObserver(
+            notificationName: NSManagedObjectContextDidSaveNotification,
+            object: rootContext,
+            closure: { [weak context] (note) -> Void in
+                
+                context?.performBlock { () -> Void in
+                    
+                    let updatedObjects = (note.userInfo?[NSUpdatedObjectsKey] as? Set<NSManagedObject>) ?? []
+                    for object in updatedObjects {
+                        
+                        context?.objectWithID(object.objectID).willAccessValueForKey(nil)
+                    }
+                    context?.mergeChangesFromContextDidSaveNotification(note)
+                }
+            }
+        )
+        
+        return context
+    }
+    
+    
+    // MARK: Private
+    
+    private struct PropertyKeys {
+        
+        static var parentStack: Void?
+        static var observerForDidSaveNotification: Void?
+    }
+    
+    private var observerForDidSaveNotification: NotificationObserver? {
+        
+        get {
+            
+            return getAssociatedObjectForKey(
+                &PropertyKeys.observerForDidSaveNotification,
+                inObject: self
+            )
+        }
+        set {
+            
+            setAssociatedRetainedObject(
+                newValue,
+                forKey: &PropertyKeys.observerForDidSaveNotification,
+                inObject: self
+            )
+        }
+    }
+}

Sources/Internal/NSManagedObjectContext+Transaction.swift

@@ -0,0 +1,189 @@
+//
+//  NSManagedObjectContext+Transaction.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+#if USE_FRAMEWORKS
+    import GCDKit
+#endif
+
+
+// MARK: - NSManagedObjectContext
+
+internal extension NSManagedObjectContext {
+    
+    // MARK: Internal
+    
+    internal weak var parentTransaction: BaseDataTransaction? {
+        
+        get {
+            
+            return getAssociatedObjectForKey(
+                &PropertyKeys.parentTransaction,
+                inObject: self
+            )
+        }
+        set {
+            
+            setAssociatedWeakObject(
+                newValue,
+                forKey: &PropertyKeys.parentTransaction,
+                inObject: self
+            )
+        }
+    }
+    
+    internal func isRunningInAllowedQueue() -> Bool {
+        
+        guard let parentTransaction = self.parentTransaction else {
+            
+            return false
+        }
+        return parentTransaction.isRunningInAllowedQueue()
+    }
+    
+    internal func temporaryContextInTransactionWithConcurrencyType(concurrencyType: NSManagedObjectContextConcurrencyType) -> NSManagedObjectContext {
+        
+        let context = NSManagedObjectContext(concurrencyType: concurrencyType)
+        context.parentContext = self
+        context.parentStack = self.parentStack
+        context.setupForCoreStoreWithContextName("com.corestore.temporarycontext")
+        context.shouldCascadeSavesToParent = (self.parentStack?.rootSavingContext == self)
+        context.retainsRegisteredObjects = true
+        
+        return context
+    }
+    
+    internal func saveSynchronously() -> SaveResult {
+        
+        var result = SaveResult(hasChanges: false)
+        
+        self.performBlockAndWait { [unowned self] () -> Void in
+            
+            guard self.hasChanges else {
+                
+                return
+            }
+            
+            do {
+                
+                try self.save()
+            }
+            catch {
+                
+                let saveError = error as NSError
+                CoreStore.handleError(
+                    saveError,
+                    "Failed to save \(typeName(NSManagedObjectContext))."
+                )
+                result = SaveResult(saveError)
+                return
+            }
+            
+            if let parentContext = self.parentContext where self.shouldCascadeSavesToParent {
+                
+                switch parentContext.saveSynchronously() {
+                    
+                case .Success:
+                    result = SaveResult(hasChanges: true)
+                    
+                case .Failure(let error):
+                    result = SaveResult(error)
+                }
+            }
+            else {
+                
+                result = SaveResult(hasChanges: true)
+            }
+        }
+        
+        return result
+    }
+    
+    internal func saveAsynchronouslyWithCompletion(completion: ((result: SaveResult) -> Void) = { _ in }) {
+        
+        self.performBlock { () -> Void in
+            
+            guard self.hasChanges else {
+                
+                GCDQueue.Main.async {
+                    
+                    completion(result: SaveResult(hasChanges: false))
+                }
+                return
+            }
+            
+            do {
+                
+                try self.save()
+            }
+            catch {
+                
+                let saveError = error as NSError
+                CoreStore.handleError(
+                    saveError,
+                    "Failed to save \(typeName(NSManagedObjectContext))."
+                )
+                GCDQueue.Main.async {
+                    
+                    completion(result: SaveResult(saveError))
+                }
+                return
+            }
+            
+            if let parentContext = self.parentContext where self.shouldCascadeSavesToParent {
+                
+                parentContext.saveAsynchronouslyWithCompletion(completion)
+            }
+            else {
+                
+                GCDQueue.Main.async {
+                    
+                    completion(result: SaveResult(hasChanges: true))
+                }
+            }
+        }
+    }
+    
+    internal func refreshAllObjectsAsFaults() {
+        
+        if #available(iOS 8.3, OSX 10.11, *) {
+            
+            self.refreshAllObjects()
+        }
+        else {
+            
+            self.registeredObjects.forEach { self.refreshObject($0, mergeChanges: false) }
+        }
+    }
+    
+    
+    // MARK: Private
+    
+    private struct PropertyKeys {
+        
+        static var parentTransaction: Void?
+    }
+}

Sources/Internal/NSManagedObjectModel+Setup.swift

@@ -0,0 +1,281 @@
+//
+//  NSManagedObjectModel+Setup.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - NSManagedObjectModel
+
+internal extension NSManagedObjectModel {
+    
+    // MARK: Internal
+    
+    @nonobjc internal class func fromBundle(bundle: NSBundle, modelName: String, modelVersionHints: Set<String> = []) -> NSManagedObjectModel {
+        
+        guard let modelFilePath = bundle.pathForResource(modelName, ofType: "momd") else {
+            
+            fatalError("Could not find \"\(modelName).momd\" from the bundle. \(bundle)")
+        }
+        
+        let modelFileURL = NSURL(fileURLWithPath: modelFilePath)
+        let versionInfoPlistURL = modelFileURL.URLByAppendingPathComponent("VersionInfo.plist", isDirectory: false)
+        
+        guard let versionInfo = NSDictionary(contentsOfURL: versionInfoPlistURL),
+            let versionHashes = versionInfo["NSManagedObjectModel_VersionHashes"] as? [String: AnyObject] else {
+                
+                fatalError("Could not load \(typeName(NSManagedObjectModel)) metadata from path \"\(versionInfoPlistURL)\".")
+        }
+        
+        let modelVersions = Set(versionHashes.keys)
+        let currentModelVersion: String
+        if let plistModelVersion = versionInfo["NSManagedObjectModel_CurrentVersionName"] as? String where modelVersionHints.isEmpty || modelVersionHints.contains(plistModelVersion) {
+            
+            currentModelVersion = plistModelVersion
+        }
+        else if let resolvedVersion = modelVersions.intersect(modelVersionHints).first {
+            
+            CoreStore.log(
+                .Warning,
+                message: "The MigrationChain leaf versions do not include the model file's current version. Resolving to version \"\(resolvedVersion)\"."
+            )
+            currentModelVersion = resolvedVersion
+        }
+        else if let resolvedVersion = modelVersions.first ?? modelVersionHints.first {
+            
+            if !modelVersionHints.isEmpty {
+                
+                CoreStore.log(
+                    .Warning,
+                    message: "The MigrationChain leaf versions do not include any of the model file's embedded versions. Resolving to version \"\(resolvedVersion)\"."
+                )
+            }
+            currentModelVersion = resolvedVersion
+        }
+        else {
+            
+            fatalError("No model files were found in URL \"\(modelFileURL)\".")
+        }
+        
+        var modelVersionFileURL: NSURL?
+        for modelVersion in modelVersions {
+            
+            let fileURL = modelFileURL.URLByAppendingPathComponent("\(modelVersion).mom", isDirectory: false)
+            
+            if modelVersion == currentModelVersion {
+                
+                modelVersionFileURL = fileURL
+                continue
+            }
+            
+            precondition(
+                NSManagedObjectModel(contentsOfURL: fileURL) != nil,
+                "Could not find the \"\(modelVersion).mom\" version file for the model at URL \"\(modelFileURL)\"."
+            )
+        }
+        
+        if let modelVersionFileURL = modelVersionFileURL,
+            let rootModel = NSManagedObjectModel(contentsOfURL: modelVersionFileURL) {
+                
+                rootModel.modelVersionFileURL = modelVersionFileURL
+                rootModel.modelVersions = modelVersions
+                rootModel.currentModelVersion = currentModelVersion
+                return rootModel
+        }
+        
+        fatalError("Could not create an \(typeName(NSManagedObjectModel)) from the model at URL \"\(modelFileURL)\".")
+    }
+    
+    @nonobjc internal private(set) var currentModelVersion: String? {
+        
+        get {
+            
+            let value: NSString? = getAssociatedObjectForKey(
+                &PropertyKeys.currentModelVersion,
+                inObject: self
+            )
+            return value as? String
+        }
+        set {
+            
+            setAssociatedCopiedObject(
+                newValue == nil ? nil : (newValue! as NSString),
+                forKey: &PropertyKeys.currentModelVersion,
+                inObject: self
+            )
+        }
+    }
+    
+    @nonobjc internal private(set) var modelVersions: Set<String>? {
+        
+        get {
+            
+            let value: NSSet? = getAssociatedObjectForKey(
+                &PropertyKeys.modelVersions,
+                inObject: self
+            )
+            return value as? Set<String>
+        }
+        set {
+            
+            setAssociatedCopiedObject(
+                newValue == nil ? nil : (newValue! as NSSet),
+                forKey: &PropertyKeys.modelVersions,
+                inObject: self
+            )
+        }
+    }
+    
+    @nonobjc internal func entityNameForClass(entityClass: AnyClass) -> String {
+        
+        return self.entityNameMapping[NSStringFromClass(entityClass)]!
+    }
+    
+    @nonobjc internal func entityTypesMapping() -> [String: NSManagedObject.Type] {
+    
+        var mapping = [String: NSManagedObject.Type]()
+        self.entityNameMapping.forEach { (className, entityName) in
+            
+            mapping[entityName] = (NSClassFromString(className)! as! NSManagedObject.Type)
+        }
+        return mapping
+    }
+    
+    @nonobjc internal func mergedModels() -> [NSManagedObjectModel] {
+        
+        return self.modelVersions?.map { self[$0] }.flatMap { $0 == nil ? [] : [$0!] } ?? [self]
+    }
+    
+    @nonobjc internal subscript(modelVersion: String) -> NSManagedObjectModel? {
+        
+        if modelVersion == self.currentModelVersion {
+            
+            return self
+        }
+        
+        guard let modelFileURL = self.modelFileURL,
+            let modelVersions = self.modelVersions
+            where modelVersions.contains(modelVersion) else {
+                
+                return nil
+        }
+        
+        let versionModelFileURL = modelFileURL.URLByAppendingPathComponent("\(modelVersion).mom", isDirectory: false)
+        guard let model = NSManagedObjectModel(contentsOfURL: versionModelFileURL) else {
+            
+            return nil
+        }
+        
+        model.currentModelVersion = modelVersion
+        model.modelVersionFileURL = versionModelFileURL
+        model.modelVersions = modelVersions
+        return model
+    }
+    
+    @nonobjc internal subscript(metadata: [String: AnyObject]) -> NSManagedObjectModel? {
+        
+        guard let modelHashes = metadata[NSStoreModelVersionHashesKey] as? [String : NSData] else {
+            
+            return nil
+        }
+        for modelVersion in self.modelVersions ?? [] {
+            
+            if let versionModel = self[modelVersion] where modelHashes == versionModel.entityVersionHashesByName {
+                
+                return versionModel
+            }
+        }
+        return nil
+    }
+    
+    
+    // MARK: Private
+    
+    private var modelFileURL: NSURL? {
+        
+        get {
+            
+            return self.modelVersionFileURL?.URLByDeletingLastPathComponent
+        }
+    }
+    
+    private var modelVersionFileURL: NSURL? {
+        
+        get {
+            
+            let value: NSURL? = getAssociatedObjectForKey(
+                &PropertyKeys.modelVersionFileURL,
+                inObject: self
+            )
+            return value
+        }
+        set {
+            
+            setAssociatedCopiedObject(
+                newValue,
+                forKey: &PropertyKeys.modelVersionFileURL,
+                inObject: self
+            )
+        }
+    }
+    
+    private var entityNameMapping: [String: String] {
+        
+        get {
+            
+            if let mapping: NSDictionary = getAssociatedObjectForKey(&PropertyKeys.entityNameMapping, inObject: self) {
+                
+                return mapping as! [String: String]
+            }
+            
+            var mapping = [String: String]()
+            self.entities.forEach {
+                
+                guard let entityName = $0.name else {
+                    
+                    return
+                }
+                
+                let className = $0.managedObjectClassName
+                mapping[className] = entityName
+            }
+            setAssociatedCopiedObject(
+                mapping as NSDictionary,
+                forKey: &PropertyKeys.entityNameMapping,
+                inObject: self
+            )
+            return mapping
+        }
+    }
+    
+    private struct PropertyKeys {
+        
+        static var entityNameMapping: Void?
+        
+        static var modelVersionFileURL: Void?
+        static var modelVersions: Void?
+        static var currentModelVersion: Void?
+    }
+}

Sources/Internal/NSPersistentStoreCoordinator+Setup.swift

@@ -0,0 +1,89 @@
+//
+//  NSPersistentStoreCoordinator+Setup.swift
+//  CoreStore
+//
+//  Copyright © 2016 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - NSPersistentStoreCoordinator
+
+internal extension NSPersistentStoreCoordinator {
+    
+    // MARK: Internal
+    
+    @nonobjc internal func performBlockAndWait<T>(block: () throws -> T) throws -> T {
+        
+        var result: T?
+        var closureError: ErrorType?
+        
+        self.performBlockAndWait {
+            
+            do {
+                
+                result = try block()
+            }
+            catch {
+                
+                closureError = error
+            }
+        }
+        
+        if let result = result {
+            
+            return result
+        }
+        
+        throw closureError!
+    }
+    
+    @nonobjc internal func addPersistentStoreSynchronously(storeType: String, configuration: String?, URL storeURL: NSURL?, options: [NSObject : AnyObject]?) throws -> NSPersistentStore {
+        
+        var store: NSPersistentStore?
+        var storeError: NSError?
+        self.performBlockAndWait {
+            
+            do {
+                
+                store = try self.addPersistentStoreWithType(
+                    storeType,
+                    configuration: configuration,
+                    URL: storeURL,
+                    options: options
+                )
+            }
+            catch {
+                
+                storeError = error as NSError
+            }
+        }
+        
+        if let store = store {
+            
+            return store
+        }
+        
+        throw storeError ?? NSError(coreStoreErrorCode: .UnknownError)
+    }
+}

Sources/Internal/NotificationObserver.swift

@@ -0,0 +1,59 @@
+//
+//  NotificationObserver.swift
+//  CoreStore
+//
+//  Copyright © 2014 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+
+// MARK: - NotificationObserver
+
+internal final class NotificationObserver {
+    
+    // MARK: Public
+    
+    let notificationName: String
+    let object: AnyObject?
+    let observer: NSObjectProtocol
+    
+    init(notificationName: String, object: AnyObject?, closure: (note: NSNotification) -> Void) {
+        
+        self.notificationName = notificationName
+        self.object = object
+        self.observer = NSNotificationCenter.defaultCenter().addObserverForName(
+            notificationName,
+            object: object,
+            queue: nil,
+            usingBlock: closure
+        )
+    }
+    
+    deinit {
+        
+        NSNotificationCenter.defaultCenter().removeObserver(
+            self.observer,
+            name: self.notificationName,
+            object: self.object
+        )
+    }
+}

Sources/Internal/WeakObject.swift

@@ -0,0 +1,41 @@
+//
+//  WeakObject.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+
+// MARK: - WeakObject
+
+internal final class WeakObject {
+    
+    // MARK: Internal
+    
+    internal init(_ object: AnyObject) {
+        
+        self.object = object
+    }
+    
+    internal private(set) weak var object: AnyObject?
+}