version bump

Add DEBUG flag to the Debug config

CoreStore.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
     s.name = "CoreStore"
-    s.version = "2.0.1"
+    s.version = "2.0.6"
     s.license = "MIT"
     s.summary = "Unleashing the real power of Core Data with the elegance and safety of Swift"
     s.homepage = "https://github.com/JohnEstropia/CoreStore"
@@ -16,8 +16,9 @@ Pod::Spec.new do |s|
     s.public_header_files = "Sources/**/*.h"
     s.frameworks = "Foundation", "CoreData"
     s.requires_arc = true
-    s.pod_target_xcconfig = { 'OTHER_SWIFT_FLAGS' => '-D USE_FRAMEWORKS',
+    s.pod_target_xcconfig = { 'OTHER_SWIFT_FLAGS[config=Debug]' => '-D USE_FRAMEWORKS -D DEBUG',
+                              'OTHER_SWIFT_FLAGS[config=Release]' => '-D USE_FRAMEWORKS',
                               'GCC_PREPROCESSOR_DEFINITIONS' => 'USE_FRAMEWORKS=1' }
-    
+
     s.dependency "GCDKit", "1.2.6"
-end
+end

CoreStoreTests/BridgingTests.m

@@ -197,4 +197,41 @@
     XCTAssertNil(sqliteError);
 }
 
+- (void)test_ThatTransactions_BridgeCorrectly {
+    
+    [CSCoreStore
+     setDefaultStack:[[CSDataStack alloc]
+                      initWithModelName:@"Model"
+                      bundle:[NSBundle bundleForClass:[self class]]
+                      versionChain:nil]];
+    [CSCoreStore
+     addInMemoryStorageAndWait:[CSInMemoryStore new]
+     error:nil];
+    
+    {
+        CSUnsafeDataTransaction *transaction = [CSCoreStore beginUnsafe];
+        XCTAssertNotNil(transaction);
+        XCTAssert([transaction isKindOfClass:[CSUnsafeDataTransaction class]]);
+    }
+    {
+        XCTestExpectation *expectation = [self expectationWithDescription:@"sync"];
+        [CSCoreStore beginSynchronous:^(CSSynchronousDataTransaction * _Nonnull transaction) {
+            
+            XCTAssertNotNil(transaction);
+            XCTAssert([transaction isKindOfClass:[CSSynchronousDataTransaction class]]);
+            [expectation fulfill];
+        }];
+    }
+    {
+        XCTestExpectation *expectation = [self expectationWithDescription:@"async"];
+        [CSCoreStore beginAsynchronous:^(CSAsynchronousDataTransaction * _Nonnull transaction) {
+            
+            XCTAssertNotNil(transaction);
+            XCTAssert([transaction isKindOfClass:[CSAsynchronousDataTransaction class]]);
+            [expectation fulfill];
+        }];
+    }
+    [self waitForExpectationsWithTimeout:10 handler:nil];
+}
+
 @end

CoreStoreTests/ErrorTests.swift

@@ -147,7 +147,7 @@ final class ErrorTests: XCTestCase {
                 "key3": NSDate()
             ]
         )
-        let error = CoreStoreError.InternalError(NSError: internalError)
+        let error = CoreStoreError(internalError)
         XCTAssertEqual((error as NSError).domain, CoreStoreErrorDomain)
         XCTAssertEqual((error as NSError).code, CoreStoreErrorCode.InternalError.rawValue)
         

README.md

@@ -308,7 +308,7 @@ public protocol LocalStorage: StorageInterface {
     var mappingModelBundles: [NSBundle] { get }
     var localStorageOptions: LocalStorageOptions { get }
     func storeOptionsForOptions(options: LocalStorageOptions) -> [String: AnyObject]?
-    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel) throws
+    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?) throws
 }
 ```
 If you have custom `NSIncrementalStore` or `NSAtomicStore` subclasses, you can implement this protocol and use it similarly to `SQLiteStore`.

Sources/Fetching and Querying/Concrete Clauses/Select.swift

@@ -715,9 +715,28 @@ internal extension CollectionType where Generator.Element == SelectTerm {
         fetchRequest.includesPendingChanges = false
         fetchRequest.resultType = .DictionaryResultType
         
-        let entityDescription = fetchRequest.entity!
-        let propertiesByName = entityDescription.propertiesByName
-        let attributesByName = entityDescription.attributesByName
+        func attributeDescriptionForKeyPath(keyPath: String, inEntity entity: NSEntityDescription) -> NSAttributeDescription? {
+            
+            let components = keyPath.componentsSeparatedByString(".")
+            switch components.count {
+                
+            case 0:
+                return nil
+                
+            case 1:
+                return entity.attributesByName[components[0]]
+                
+            default:
+                guard let relationship = entity.relationshipsByName[components[0]] else {
+                    
+                    return nil
+                }
+                return attributeDescriptionForKeyPath(
+                    components.dropFirst().joinWithSeparator("."),
+                    inEntity: relationship.entity
+                )
+            }
+        }
         
         var propertiesToFetch = [AnyObject]()
         for term in self {
@@ -725,20 +744,22 @@ internal extension CollectionType where Generator.Element == SelectTerm {
             switch term {
                 
             case ._Attribute(let keyPath):
-                if let propertyDescription = propertiesByName[keyPath] {
+                let entityDescription = fetchRequest.entity!
+                if let attributeDescription = attributeDescriptionForKeyPath(keyPath, inEntity: entityDescription) {
                     
-                    propertiesToFetch.append(propertyDescription)
+                    propertiesToFetch.append(attributeDescription)
                 }
                 else {
                     
                     CoreStore.log(
                         .Warning,
-                        message: "The property \"\(keyPath)\" does not exist in entity \(cs_typeName(entityDescription.managedObjectClassName)) and will be ignored by \(cs_typeName(owner)) query clause."
+                        message: "The key path \"\(keyPath)\" could not be resolved in entity \(cs_typeName(entityDescription.managedObjectClassName)) as an attribute and will be ignored by \(cs_typeName(owner)) query clause."
                     )
                 }
                 
             case ._Aggregate(let function, let keyPath, let alias, let nativeType):
-                if let attributeDescription = attributesByName[keyPath] {
+                let entityDescription = fetchRequest.entity!
+                if let attributeDescription = attributeDescriptionForKeyPath(keyPath, inEntity: entityDescription) {
                     
                     let expressionDescription = NSExpressionDescription()
                     expressionDescription.name = alias
@@ -754,14 +775,13 @@ internal extension CollectionType where Generator.Element == SelectTerm {
                         forFunction: function,
                         arguments: [NSExpression(forKeyPath: keyPath)]
                     )
-                    
                     propertiesToFetch.append(expressionDescription)
                 }
                 else {
                     
                     CoreStore.log(
                         .Warning,
-                        message: "The attribute \"\(keyPath)\" does not exist in entity \(cs_typeName(entityDescription.managedObjectClassName)) and will be ignored by \(cs_typeName(owner)) query clause."
+                        message: "The key path \"\(keyPath)\" could not be resolved in entity \(cs_typeName(entityDescription.managedObjectClassName)) as an attribute and will be ignored by \(cs_typeName(owner)) query clause."
                     )
                 }
                 

Sources/Info.plist

@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>2.0.1</string>
+	<string>2.0.6</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>

Sources/Internal/NotificationObserver.swift

@@ -32,14 +32,10 @@ internal final class NotificationObserver {
     
     // MARK: Public
     
-    let notificationName: String
-    let object: AnyObject?
     let observer: NSObjectProtocol
     
     init(notificationName: String, object: AnyObject?, queue: NSOperationQueue? = nil, closure: (note: NSNotification) -> Void) {
         
-        self.notificationName = notificationName
-        self.object = object
         self.observer = NSNotificationCenter.defaultCenter().addObserverForName(
             notificationName,
             object: object,
@@ -50,10 +46,6 @@ internal final class NotificationObserver {
     
     deinit {
         
-        NSNotificationCenter.defaultCenter().removeObserver(
-            self.observer,
-            name: self.notificationName,
-            object: self.object
-        )
+        NSNotificationCenter.defaultCenter().removeObserver(self.observer)
     }
 }

Sources/Migrating/DataStack+Migration.swift

@@ -223,7 +223,7 @@ public extension DataStack {
                                 
                                 do {
                                     
-                                    try _ = self.model[metadata].flatMap(storage.eraseStorageAndWait)
+                                    _ = try storage.eraseStorageAndWait(soureModel: self.model[metadata])
                                     try self.addStorageAndWait(storage)
                                     
                                     GCDQueue.Main.async {
@@ -388,7 +388,7 @@ public extension DataStack {
                         URL: cacheFileURL,
                         options: storeOptions
                     )
-                    try _ = self.model[metadata].flatMap(storage.eraseStorageAndWait)
+                    _ = try storage.eraseStorageAndWait(soureModel: self.model[metadata])
                     
                     try self.createPersistentStoreFromStorage(
                         storage,

Sources/ObjectiveC/CSAsynchronousDataTransaction.swift

@@ -144,7 +144,7 @@ public final class CSAsynchronousDataTransaction: CSBaseDataTransaction {
     
     // MARK: CoreStoreObjectiveCType
     
-    internal typealias SwiftType = AsynchronousDataTransaction
+    public typealias SwiftType = AsynchronousDataTransaction
     
     public override var bridgeToSwift: AsynchronousDataTransaction {
         
@@ -153,21 +153,21 @@ public final class CSAsynchronousDataTransaction: CSBaseDataTransaction {
     
     public required init(_ swiftValue: AsynchronousDataTransaction) {
         
-        super.init(swiftValue)
+        super.init(swiftValue as BaseDataTransaction)
     }
     
     public required init(_ swiftValue: BaseDataTransaction) {
         
-        fatalError("init(_:) requires an AsynchronousDataTransaction instance")
+        super.init(swiftValue as! AsynchronousDataTransaction)
     }
 }
 
 
 // MARK: - AsynchronousDataTransaction
 
-extension AsynchronousDataTransaction {
+extension AsynchronousDataTransaction: CoreStoreSwiftType {
     
     // MARK: CoreStoreSwiftType
     
-    internal typealias ObjectiveCType = CSAsynchronousDataTransaction
+    public typealias ObjectiveCType = CSAsynchronousDataTransaction
 }

Sources/ObjectiveC/CSBaseDataTransaction.swift

@@ -292,8 +292,6 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
     
     // MARK: CoreStoreObjectiveCType
     
-    public typealias SwiftType = BaseDataTransaction
-    
     public required init(_ swiftValue: BaseDataTransaction) {
         
         self.swiftTransaction = swiftValue
@@ -312,11 +310,11 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
 }
 
 
-// MARK: - BaseDataTransaction
-
-extension BaseDataTransaction: CoreStoreSwiftType {
-    
-    // MARK: CoreStoreSwiftType
-    
-    public typealias ObjectiveCType = CSBaseDataTransaction
-}
+//// MARK: - BaseDataTransaction
+//
+//extension BaseDataTransaction: CoreStoreSwiftType {
+//    
+//    // MARK: CoreStoreSwiftType
+//    
+//    public typealias ObjectiveCType = CSBaseDataTransaction
+//}

Sources/ObjectiveC/CSError.swift

@@ -248,9 +248,17 @@ internal extension ErrorType {
         
         switch self {
             
-        case let error as CoreStoreError:   return error
-        case let error as CSError:          return error.bridgeToSwift
-        default:                            return .Unknown
+        case let error as CoreStoreError:
+            return error
+            
+        case let error as CSError:
+            return error.bridgeToSwift
+            
+        case let error as NSError where self.dynamicType is NSError.Type:
+            return .InternalError(NSError: error)
+            
+        default:
+            return .Unknown
         }
     }
     
@@ -258,9 +266,14 @@ internal extension ErrorType {
         
         switch self {
             
-        case let error as CoreStoreError:   return error.bridgeToObjectiveC
-        case let error as CSError:          return error
-        default:                            return self as NSError
+        case let error as CoreStoreError:
+            return error.bridgeToObjectiveC
+            
+        case let error as CSError:
+            return error
+            
+        default:
+            return self as NSError
         }
     }
 }

Sources/ObjectiveC/CSSQliteStore.swift

@@ -154,7 +154,7 @@ public final class CSSQLiteStore: NSObject, CSLocalStorage, CoreStoreObjectiveCT
      Called by the `CSDataStack` to perform actual deletion of the store file from disk. Do not call directly! The `sourceModel` argument is a hint for the existing store's model version. For `CSSQLiteStore`, this converts the database's WAL journaling mode to DELETE before deleting the file.
      */
     @objc
-    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel, error: NSErrorPointer) -> Bool {
+    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?, error: NSErrorPointer) -> Bool {
         
         return bridge(error) {
             

Sources/ObjectiveC/CSStorageInterface.swift

@@ -121,5 +121,5 @@ public protocol CSLocalStorage: CSStorageInterface {
      Called by the `CSDataStack` to perform actual deletion of the store file from disk. Do not call directly! The `sourceModel` argument is a hint for the existing store's model version. Implementers can use the `sourceModel` to perform necessary store operations. (SQLite stores for example, can convert WAL journaling mode to DELETE before deleting)
      */
     @objc
-    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel, error: NSErrorPointer) -> Bool
+    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?, error: NSErrorPointer) -> Bool
 }

Sources/ObjectiveC/CSSynchronousDataTransaction.swift

@@ -143,7 +143,7 @@ public final class CSSynchronousDataTransaction: CSBaseDataTransaction {
     
     // MARK: CoreStoreObjectiveCType
     
-    internal typealias SwiftType = SynchronousDataTransaction
+    public typealias SwiftType = SynchronousDataTransaction
     
     public override var bridgeToSwift: SynchronousDataTransaction {
         
@@ -152,21 +152,21 @@ public final class CSSynchronousDataTransaction: CSBaseDataTransaction {
     
     public required init(_ swiftValue: SynchronousDataTransaction) {
         
-        super.init(swiftValue)
+        super.init(swiftValue as BaseDataTransaction)
     }
     
     public required init(_ swiftValue: BaseDataTransaction) {
         
-        fatalError("init(_:) requires a BaseDataTransaction instance")
+        super.init(swiftValue as! SynchronousDataTransaction)
     }
 }
 
 
 // MARK: - SynchronousDataTransaction
 
-extension SynchronousDataTransaction {
+extension SynchronousDataTransaction: CoreStoreSwiftType {
     
     // MARK: CoreStoreSwiftType
     
-    internal typealias ObjectiveCType = CSSynchronousDataTransaction
+    public typealias ObjectiveCType = CSSynchronousDataTransaction
 }

Sources/ObjectiveC/CSUnsafeDataTransaction.swift

@@ -174,7 +174,7 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction {
     
     // MARK: CoreStoreObjectiveCType
     
-    internal typealias SwiftType = UnsafeDataTransaction
+    public typealias SwiftType = UnsafeDataTransaction
     
     public override var bridgeToSwift: UnsafeDataTransaction {
         
@@ -183,21 +183,21 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction {
     
     public required init(_ swiftValue: UnsafeDataTransaction) {
         
-        super.init(swiftValue)
+        super.init(swiftValue as BaseDataTransaction)
     }
     
     public required init(_ swiftValue: BaseDataTransaction) {
         
-        fatalError("init(_:) requires an UnsafeDataTransaction instance")
+        super.init(swiftValue as! UnsafeDataTransaction)
     }
 }
 
 
 // MARK: - UnsafeDataTransaction
 
-extension UnsafeDataTransaction {
+extension UnsafeDataTransaction: CoreStoreSwiftType {
     
     // MARK: CoreStoreSwiftType
     
-    internal typealias ObjectiveCType = CSUnsafeDataTransaction
+    public typealias ObjectiveCType = CSUnsafeDataTransaction
 }

Sources/ObjectiveC/CoreStoreBridge.swift

@@ -118,12 +118,18 @@ internal func bridge<T: CoreStoreSwiftType>(error: NSErrorPointer, @noescape _ c
     do {
         
         let result = try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return result.bridgeToObjectiveC
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return nil
     }
 }
@@ -133,12 +139,18 @@ internal func bridge(error: NSErrorPointer, @noescape _ closure: () throws -> Vo
     do {
         
         try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return true
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return false
     }
 }
@@ -148,12 +160,18 @@ internal func bridge<T>(error: NSErrorPointer, @noescape _ closure: () throws ->
     do {
         
         let result = try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return result
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return nil
     }
 }
@@ -163,12 +181,18 @@ internal func bridge<T: CoreStoreSwiftType>(error: NSErrorPointer, @noescape _ c
     do {
         
         let result = try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return result.map { $0.bridgeToObjectiveC }
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return nil
     }
 }

Sources/Setup/DataStack.swift

@@ -263,7 +263,7 @@ public final class DataStack {
                         URL: fileURL,
                         options: storeOptions
                     )
-                    try _ = self.model[metadata].flatMap(storage.eraseStorageAndWait)
+                    _ = try storage.eraseStorageAndWait(soureModel: self.model[metadata])
                     
                     try self.createPersistentStoreFromStorage(
                         storage,
@@ -359,7 +359,7 @@ public final class DataStack {
                         URL: cacheFileURL,
                         options: storeOptions
                     )
-                    try _ = self.model[metadata].flatMap(storage.eraseStorageAndWait)
+                    _ = try storage.eraseStorageAndWait(soureModel: self.model[metadata])
                     
                     try self.createPersistentStoreFromStorage(
                         storage,

Sources/Setup/StorageInterfaces/ICloudStore.swift

@@ -424,11 +424,19 @@ public class ICloudStore: CloudStorage {
     /**
      Called by the `DataStack` to perform actual deletion of the store file from disk. Do not call directly! The `sourceModel` argument is a hint for the existing store's model version. For `SQLiteStore`, this converts the database's WAL journaling mode to DELETE before deleting the file.
      */
-    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel) throws {
+    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?) throws {
         
         // TODO: check if attached to persistent store
         
         let cacheFileURL = self.cacheFileURL
+        guard let soureModel = soureModel else {
+            
+            let fileManager = NSFileManager.defaultManager()
+            try fileManager.removeItemAtURL(cacheFileURL)
+            _ = try? fileManager.removeItemAtPath("\(cacheFileURL.absoluteString)-wal")
+            _ = try? fileManager.removeItemAtPath("\(cacheFileURL.absoluteString)-shm")
+            return
+        }
         try cs_autoreleasepool {
             
             let journalUpdatingCoordinator = NSPersistentStoreCoordinator(managedObjectModel: soureModel)

Sources/Setup/StorageInterfaces/LegacySQLiteStore.swift

@@ -165,11 +165,19 @@ public final class LegacySQLiteStore: LocalStorage, DefaultInitializableStore {
     /**
      Called by the `DataStack` to perform actual deletion of the store file from disk. Do not call directly! The `sourceModel` argument is a hint for the existing store's model version. For `SQLiteStore`, this converts the database's WAL journaling mode to DELETE before deleting the file.
      */
-    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel) throws {
+    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?) throws {
         
         // TODO: check if attached to persistent store
         
         let fileURL = self.fileURL
+        guard let soureModel = soureModel else {
+            
+            let fileManager = NSFileManager.defaultManager()
+            try fileManager.removeItemAtURL(fileURL)
+            _ = try? fileManager.removeItemAtPath("\(fileURL.absoluteString)-wal")
+            _ = try? fileManager.removeItemAtPath("\(fileURL.absoluteString)-shm")
+            return
+        }
         try cs_autoreleasepool {
             
             let journalUpdatingCoordinator = NSPersistentStoreCoordinator(managedObjectModel: soureModel)

Sources/Setup/StorageInterfaces/SQLiteStore.swift

@@ -162,11 +162,19 @@ public final class SQLiteStore: LocalStorage, DefaultInitializableStore {
     /**
      Called by the `DataStack` to perform actual deletion of the store file from disk. Do not call directly! The `sourceModel` argument is a hint for the existing store's model version. For `SQLiteStore`, this converts the database's WAL journaling mode to DELETE before deleting the file.
      */
-    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel) throws {
+    public func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?) throws {
         
         // TODO: check if attached to persistent store
         
         let fileURL = self.fileURL
+        guard let soureModel = soureModel else {
+            
+            let fileManager = NSFileManager.defaultManager()
+            try fileManager.removeItemAtURL(fileURL)
+            _ = try? fileManager.removeItemAtPath("\(fileURL.absoluteString)-wal")
+            _ = try? fileManager.removeItemAtPath("\(fileURL.absoluteString)-shm")
+            return
+        }
         try cs_autoreleasepool {
             
             let journalUpdatingCoordinator = NSPersistentStoreCoordinator(managedObjectModel: soureModel)

Sources/Setup/StorageInterfaces/StorageInterface.swift

@@ -158,7 +158,7 @@ public protocol LocalStorage: StorageInterface {
     /**
      Called by the `DataStack` to perform actual deletion of the store file from disk. **Do not call directly!** The `sourceModel` argument is a hint for the existing store's model version. Implementers can use the `sourceModel` to perform necessary store operations. (SQLite stores for example, can convert WAL journaling mode to DELETE before deleting)
      */
-    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel) throws
+    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?) throws
 }
 
 internal extension LocalStorage {
@@ -242,7 +242,7 @@ public protocol CloudStorage: StorageInterface {
     /**
      Called by the `DataStack` to perform actual deletion of the store file from disk. **Do not call directly!** The `sourceModel` argument is a hint for the existing store's model version. Implementers can use the `sourceModel` to perform necessary store operations. (Cloud stores for example, can set the NSPersistentStoreRemoveUbiquitousMetadataOption option before deleting)
      */
-    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel) throws
+    func eraseStorageAndWait(soureModel soureModel: NSManagedObjectModel?) throws
 }
 
 internal extension CloudStorage {