Swift Package Manager support

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?
+    }
+}