Merge branch 'develop' into corestore4_develop

# Conflicts:
#	CoreStore.podspec
#	Sources/CoreStoreImportableAttributeType.swift
#	Sources/CoreStoreQueryableAttributeType.swift
#	Sources/Info.plist
#	Sources/NSManagedObjectModel+Setup.swift

Sources/SchemaHistory.swift

@@ -0,0 +1,266 @@
+//
+//  SchemaHistory.swift
+//  CoreStore
+//
+//  Copyright © 2017 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 CoreData
+import Foundation
+
+
+// MARK: - SchemaHistory
+
+/**
+ The `SchemaHistory` encapsulates multiple `DynamicSchema` across multiple model versions. It contains all model history and is used by the `DataStack` to 
+ */
+public final class SchemaHistory: ExpressibleByArrayLiteral {
+    
+    /**
+     The version string for the current model version. The `DataStack` will try to migrate all `StorageInterface`s added to itself to this version, following the version steps provided by the `migrationChain`.
+     */
+    public let currentModelVersion: ModelVersion
+    
+    /**
+     The version string for the current model version. The `DataStack` will try to migrate all `StorageInterface`s added to itself to this version, following the version steps provided by the `migrationChain`.
+     */
+    public let migrationChain: MigrationChain
+    
+    /**
+     Initializes a `SchemaHistory` with all models declared in the specified (.xcdatamodeld) model file.
+     - Important: Use this initializer only if all model versions are either `XcodeDataModelSchema`s or `LegacyXcodeDataModelSchema`s. Do not use this initializer if even one of the model versions is a `CoreStoreSchema`; use the `SchemaHistory.init(allSchema:migrationChain:exactCurrentModelVersion:)` initializer instead.
+     - parameter modelName: the name of the (.xcdatamodeld) model file. If not specified, the application name (CFBundleName) will be used if it exists, or "CoreData" if it the bundle name was not set.
+     - parameter bundle: an optional bundle to load models from. If not specified, the main bundle will be used.
+     - parameter migrationChain: the `MigrationChain` that indicates the sequence of model versions to be used as the order for progressive migrations. If not specified, will default to a non-migrating data stack.
+     */
+    public convenience init(modelName: XcodeDataModelFileName, bundle: Bundle = Bundle.main, migrationChain: MigrationChain = nil) {
+        
+        guard let modelFilePath = bundle.path(forResource: modelName, ofType: "momd") else {
+            
+            // For users migrating from very old Xcode versions: Old xcdatamodel files are not contained inside xcdatamodeld (with a "d"), and will thus fail this check. If that was the case, create a new xcdatamodeld file and copy all contents into the new model.
+            let foundModels = bundle
+                .paths(forResourcesOfType: "momd", inDirectory: nil)
+                .map({ ($0 as NSString).lastPathComponent })
+            CoreStore.abort("Could not find \"\(modelName).momd\" from the bundle \"\(bundle.bundleIdentifier ?? "<nil>")\". Other model files in bundle: \(foundModels.coreStoreDumpString)")
+        }
+        
+        let modelFileURL = URL(fileURLWithPath: modelFilePath)
+        let versionInfoPlistURL = modelFileURL.appendingPathComponent("VersionInfo.plist", isDirectory: false)
+        
+        guard let versionInfo = NSDictionary(contentsOf: versionInfoPlistURL),
+            let versionHashes = versionInfo["NSManagedObjectModel_VersionHashes"] as? [String: AnyObject] else {
+                
+                CoreStore.abort("Could not load \(cs_typeName(NSManagedObjectModel.self)) metadata from path \"\(versionInfoPlistURL)\".")
+        }
+        
+        let modelVersions = Set(versionHashes.keys)
+        let modelVersionHints = migrationChain.leafVersions
+        let currentModelVersion: String
+        if let plistModelVersion = versionInfo["NSManagedObjectModel_CurrentVersionName"] as? String,
+            modelVersionHints.isEmpty || modelVersionHints.contains(plistModelVersion) {
+            
+            currentModelVersion = plistModelVersion
+        }
+        else if let resolvedVersion = modelVersions.intersection(modelVersionHints).first {
+            
+            CoreStore.log(
+                .warning,
+                message: "The \(cs_typeName(MigrationChain.self)) 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 \(cs_typeName(MigrationChain.self)) leaf versions do not include any of the model file's embedded versions. Resolving to version \"\(resolvedVersion)\"."
+                )
+            }
+            currentModelVersion = resolvedVersion
+        }
+        else {
+            
+            CoreStore.abort("No model files were found in URL \"\(modelFileURL)\".")
+        }
+        var allSchema: [DynamicSchema] = []
+        for modelVersion in modelVersions {
+            
+            let fileURL = modelFileURL.appendingPathComponent("\(modelVersion).mom", isDirectory: false)
+            allSchema.append(XcodeDataModelSchema(modelName: modelVersion, modelVersionFileURL: fileURL))
+        }
+        self.init(
+            allSchema: allSchema,
+            migrationChain: migrationChain,
+            exactCurrentModelVersion: currentModelVersion
+        )
+    }
+    
+    /**
+     Initializes a `SchemaHistory` with a list of `DynamicSchema` and a `MigrationChain` to describe the order of progressive migrations.
+     - parameter schema: a `DynamicSchema` that represents a model version
+     - parameter otherSchema: a list of `DynamicSchema` that represent other model versions
+     - parameter migrationChain: the `MigrationChain` that indicates the sequence of model versions to be used as the order for progressive migrations. If not specified, will default to a non-migrating data stack.
+     - parameter exactCurrentModelVersion: an optional string to explicitly select the current model version string. This is useful if the `DataStack` should load a non-latest model version (usually to prepare data before migration). If not provided, the current model version will be computed from the `MigrationChain`.
+     */
+    public convenience init(_ schema: DynamicSchema, _ otherSchema: DynamicSchema..., migrationChain: MigrationChain = nil, exactCurrentModelVersion: String? = nil) {
+        
+        self.init(
+            allSchema: [schema] + otherSchema,
+            migrationChain: migrationChain,
+            exactCurrentModelVersion: exactCurrentModelVersion
+        )
+    }
+    
+    /**
+     Initializes a `SchemaHistory` with a list of `DynamicSchema` and a `MigrationChain` to describe the order of progressive migrations.
+     - parameter allSchema: a list of `DynamicSchema` that represent model versions
+     - parameter migrationChain: the `MigrationChain` that indicates the sequence of model versions to be used as the order for progressive migrations. If not specified, will default to a non-migrating data stack.
+     - parameter exactCurrentModelVersion: an optional string to explicitly select the current model version string. This is useful if the `DataStack` should load a non-latest model version (usually to prepare data before migration). If not provided, the current model version will be computed from the `MigrationChain`.
+     */
+    public required init(allSchema: [DynamicSchema], migrationChain: MigrationChain = nil, exactCurrentModelVersion: String? = nil) {
+        
+        if allSchema.isEmpty {
+            
+            CoreStore.abort("The \"allSchema\" argument of the \(cs_typeName(SchemaHistory.self)) initializer cannot be empty.")
+        }
+        CoreStore.assert(
+            migrationChain.isValid,
+            "Invalid migration chain passed to the \(cs_typeName(SchemaHistory.self)). Check that the model versions' order are correct and that no repetitions or ambiguities exist."
+        )
+        var schemaByVersion: [ModelVersion: DynamicSchema] = [:]
+        for schema in allSchema {
+            
+            let modelVersion = schema.modelVersion
+            CoreStore.assert(
+                schemaByVersion[modelVersion] == nil,
+                "Multiple model schema found for model version \"\(modelVersion)\"."
+            )
+            schemaByVersion[modelVersion] = schema
+        }
+        let modelVersions = Set(schemaByVersion.keys)
+        let currentModelVersion: ModelVersion
+        if let exactCurrentModelVersion = exactCurrentModelVersion {
+            
+            if !migrationChain.isEmpty && !migrationChain.contains(exactCurrentModelVersion) {
+                
+                CoreStore.abort("An \"exactCurrentModelVersion\" argument was provided to \(cs_typeName(SchemaHistory.self)) initializer but a matching schema could not be found from the provided \(cs_typeName(MigrationChain.self)).")
+            }
+            if schemaByVersion[exactCurrentModelVersion] == nil {
+                
+                CoreStore.abort("An \"exactCurrentModelVersion\" argument was provided to \(cs_typeName(SchemaHistory.self)) initializer but a matching schema could not be found from the \(cs_typeName(DynamicSchema.self)) list.")
+            }
+            currentModelVersion = exactCurrentModelVersion
+        }
+        else if migrationChain.isEmpty && schemaByVersion.count == 1 {
+            
+            currentModelVersion = schemaByVersion.keys.first!
+        }
+        else {
+            
+            let candidateVersions = modelVersions.intersection(migrationChain.leafVersions)
+            switch candidateVersions.count {
+                
+            case 0:
+                CoreStore.abort("None of the \(cs_typeName(MigrationChain.self)) leaf versions provided to the \(cs_typeName(SchemaHistory.self)) initializer matches any scheme from the \(cs_typeName(DynamicSchema.self)) list.")
+                
+            case 1:
+                currentModelVersion = candidateVersions.first!
+                
+            default:
+                CoreStore.abort("Could not resolve the \(cs_typeName(SchemaHistory.self)) current model version because the \(cs_typeName(MigrationChain.self)) have ambiguous leaf versions: \(candidateVersions)")
+            }
+        }
+        
+        self.schemaByVersion = schemaByVersion
+        self.migrationChain = migrationChain
+        self.currentModelVersion = currentModelVersion
+        self.rawModel = schemaByVersion[currentModelVersion]!.rawModel()
+    }
+    
+    
+    // MARK: ExpressibleByArrayLiteral
+    
+    public typealias Element = DynamicSchema
+    
+    public convenience init(arrayLiteral elements: DynamicSchema...) {
+
+        self.init(
+            allSchema: elements,
+            migrationChain: MigrationChain(elements.map({ $0.modelVersion })),
+            exactCurrentModelVersion: nil
+        )
+    }
+    
+    
+    // MARK: Internal
+    
+    internal let schemaByVersion: [ModelVersion: DynamicSchema]
+    internal let rawModel: NSManagedObjectModel
+    
+    internal private(set) lazy var entityDescriptionsByEntityIdentifier: [EntityIdentifier: NSEntityDescription] = cs_lazy { [unowned self] in
+        
+        var mapping: [EntityIdentifier: NSEntityDescription] = [:]
+        self.rawModel.entities.forEach { (entityDescription) in
+            
+            let entityIdentifier = EntityIdentifier(entityDescription)
+            mapping[entityIdentifier] = entityDescription
+        }
+        return mapping
+    }
+    
+    internal func rawModel(for modelVersion: ModelVersion) -> NSManagedObjectModel? {
+        
+        if modelVersion == self.currentModelVersion {
+            
+            return self.rawModel
+        }
+        return self.schemaByVersion[modelVersion]?.rawModel()
+    }
+    
+    internal func schema(for modelVersion: ModelVersion) -> DynamicSchema? {
+        
+        return self.schemaByVersion[modelVersion]
+    }
+    
+    internal func schema(for storeMetadata: [String: Any]) -> DynamicSchema? {
+        
+        guard let modelHashes = storeMetadata[NSStoreModelVersionHashesKey] as! [String: Data]? else {
+            
+            return nil
+        }
+        for (_, schema) in self.schemaByVersion {
+            
+            let rawModel = schema.rawModel()
+            if modelHashes == rawModel.entityVersionHashesByName {
+                
+                return schema
+            }
+        }
+        return nil
+    }
+    
+    internal func mergedModels() -> [NSManagedObjectModel] {
+        
+        return self.schemaByVersion.values.map({ $0.rawModel() })
+    }
+}