Flatten file directories (fixes #159)

Sources/BaseDataTransaction+Importing.swift

@@ -0,0 +1,255 @@
+//
+//  BaseDataTransaction+Importing.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: - BaseDataTransaction
+
+public extension BaseDataTransaction {
+    
+    /**
+     Creates an `ImportableObject` by importing from the specified import source.
+     
+     - parameter into: an `Into` clause specifying the entity type
+     - parameter source: the object to import values from
+     - throws: an `Error` thrown from any of the `ImportableObject` methods
+     - returns: the created `ImportableObject` instance, or `nil` if the import was ignored
+     */
+    public func importObject<T>(
+        _ into: Into<T>,
+        source: T.ImportSource) throws -> T? where T: NSManagedObject, T: ImportableObject {
+            
+            CoreStore.assert(
+                self.isRunningInAllowedQueue(),
+                "Attempted to import an object of type \(cs_typeName(into.entityClass)) outside the transaction's designated queue."
+            )
+        
+            return try autoreleasepool {
+                
+                let entityType = into.entityClass as! T.Type
+                
+                guard entityType.shouldInsert(from: source, in: self) else {
+                    
+                    return nil
+                }
+                
+                let object = self.create(into)
+                try object.didInsert(from: source, in: self)
+                return object
+            }
+    }
+    
+    /**
+     Updates an existing `ImportableObject` by importing values from the specified import source.
+     
+     - parameter object: the `NSManagedObject` to update
+     - parameter source: the object to import values from
+     - throws: an `Error` thrown from any of the `ImportableObject` methods
+     */
+    public func importObject<T>(
+        _ object: T,
+        source: T.ImportSource) throws where T: NSManagedObject, T: ImportableObject {
+            
+            CoreStore.assert(
+                self.isRunningInAllowedQueue(),
+                "Attempted to import an object of type \(cs_typeName(object)) outside the transaction's designated queue."
+            )
+            
+            try autoreleasepool {
+              
+                let entityType = type(of: object)
+                guard entityType.shouldInsert(from: source, in: self) else {
+                    
+                    return
+                }
+                try object.didInsert(from: source, in: self)
+            }
+    }
+    
+    /**
+     Creates multiple `ImportableObject`s by importing from the specified array of import sources.
+     
+     - parameter into: an `Into` clause specifying the entity type
+     - parameter sourceArray: the array of objects to import values from
+     - throws: an `Error` thrown from any of the `ImportableObject` methods
+     - returns: the array of created `ImportableObject` instances
+     */
+    public func importObjects<T, S: Sequence>(
+        _ into: Into<T>,
+        sourceArray: S) throws -> [T] where T: NSManagedObject, T: ImportableObject, S.Iterator.Element == T.ImportSource {
+            
+            CoreStore.assert(
+                self.isRunningInAllowedQueue(),
+                "Attempted to import an object of type \(cs_typeName(into.entityClass)) outside the transaction's designated queue."
+            )
+            
+            return try autoreleasepool {
+                
+                return try sourceArray.flatMap { (source) -> T? in
+                  
+                    let entityType = into.entityClass as! T.Type
+                    guard entityType.shouldInsert(from: source, in: self) else {
+                        
+                        return nil
+                    }
+                    return try autoreleasepool {
+                        
+                        let object = self.create(into)
+                        try object.didInsert(from: source, in: self)
+                        return object
+                    }
+                }
+            }
+    }
+    
+    /**
+     Updates an existing `ImportableUniqueObject` or creates a new instance by importing from the specified import source.
+     
+     - parameter into: an `Into` clause specifying the entity type
+     - parameter source: the object to import values from
+     - throws: an `Error` thrown from any of the `ImportableUniqueObject` methods
+     - returns: the created/updated `ImportableUniqueObject` instance, or `nil` if the import was ignored
+     */
+    public func importUniqueObject<T>(
+        _ into: Into<T>,
+        source: T.ImportSource) throws -> T? where T: NSManagedObject, T: ImportableUniqueObject  {
+            
+            CoreStore.assert(
+                self.isRunningInAllowedQueue(),
+                "Attempted to import an object of type \(cs_typeName(into.entityClass)) outside the transaction's designated queue."
+            )
+            
+            return try autoreleasepool {
+              
+                let entityType = into.entityClass as! T.Type
+                let uniqueIDKeyPath = entityType.uniqueIDKeyPath
+                guard let uniqueIDValue = try entityType.uniqueID(from: source, in: self) else {
+                    
+                    return nil
+                }
+                
+                if let object = self.fetchOne(From(entityType), Where(uniqueIDKeyPath, isEqualTo: uniqueIDValue)) {
+                    
+                    guard entityType.shouldUpdate(from: source, in: self) else {
+                        
+                        return nil
+                    }
+                    try object.update(from: source, in: self)
+                    return object
+                }
+                else {
+                    
+                    guard entityType.shouldInsert(from: source, in: self) else {
+                        
+                        return nil
+                    }
+                    let object = self.create(into)
+                    object.uniqueIDValue = uniqueIDValue
+                    try object.didInsert(from: source, in: self)
+                    return object
+                }
+            }
+    }
+    
+    /**
+     Updates existing `ImportableUniqueObject`s or creates them by importing from the specified array of import sources.
+     `ImportableUniqueObject` methods are called on the objects in the same order as they are in the `sourceArray`, and are returned in an array with that same order.
+     - Warning: If `sourceArray` contains multiple import sources with same ID, no merging will occur and ONLY THE LAST duplicate will be imported.
+     
+     - parameter into: an `Into` clause specifying the entity type
+     - parameter sourceArray: the array of objects to import values from
+     - parameter preProcess: a closure that lets the caller tweak the internal `UniqueIDType`-to-`ImportSource` mapping to be used for importing. Callers can remove from/add to/update `mapping` and return the updated array from the closure.
+     - throws: an `Error` thrown from any of the `ImportableUniqueObject` methods
+     - returns: the array of created/updated `ImportableUniqueObject` instances
+     */
+    public func importUniqueObjects<T, S: Sequence>(
+        _ into: Into<T>,
+        sourceArray: S,
+        preProcess: @escaping (_ mapping: [T.UniqueIDType: T.ImportSource]) throws -> [T.UniqueIDType: T.ImportSource] = { $0 }) throws -> [T] where T: NSManagedObject, T: ImportableUniqueObject, S.Iterator.Element == T.ImportSource {
+            
+            CoreStore.assert(
+                self.isRunningInAllowedQueue(),
+                "Attempted to import an object of type \(cs_typeName(into.entityClass)) outside the transaction's designated queue."
+            )
+            
+            return try autoreleasepool {
+              
+                let entityType = into.entityClass as! T.Type
+                var importSourceByID = Dictionary<T.UniqueIDType, T.ImportSource>()
+                let sortedIDs = try autoreleasepool {
+                  
+                    return try sourceArray.flatMap { (source) -> T.UniqueIDType? in
+                        
+                        guard let uniqueIDValue = try entityType.uniqueID(from: source, in: self) else {
+                            
+                            return nil
+                        }
+                        importSourceByID[uniqueIDValue] = source // effectively replaces duplicate with the latest
+                        return uniqueIDValue
+                    }
+                }
+                
+                importSourceByID = try autoreleasepool { try preProcess(importSourceByID) }
+
+                var existingObjectsByID = Dictionary<T.UniqueIDType, T>()
+                self.fetchAll(From(entityType), Where(entityType.uniqueIDKeyPath, isMemberOf: sortedIDs))?
+                    .forEach { existingObjectsByID[$0.uniqueIDValue] = $0 }
+              
+                var processedObjectIDs = Set<T.UniqueIDType>()
+                var result = [T]()
+              
+                for objectID in sortedIDs where !processedObjectIDs.contains(objectID) {
+                    
+                    guard let source = importSourceByID[objectID] else {
+                        
+                        continue
+                    }
+                    try autoreleasepool {
+
+                        if let object = existingObjectsByID[objectID] {
+                            
+                            guard entityType.shouldUpdate(from: source, in: self) else {
+                                
+                                return
+                            }
+                            try object.update(from: source, in: self)
+                            result.append(object)
+                        }
+                        else if entityType.shouldInsert(from: source, in: self) {
+                            
+                            let object = self.create(into)
+                            object.uniqueIDValue = objectID
+                            try object.didInsert(from: source, in: self)
+                            result.append(object)
+                        }
+                        processedObjectIDs.insert(objectID)
+                    }
+                }
+                return result
+            }
+    }
+}