From a27556f294994fedaa85019b07e299c2b561b41d Mon Sep 17 00:00:00 2001 From: John Estropia Date: Thu, 8 Dec 2016 18:59:41 +0900 Subject: [PATCH] minor Swift 3 cleanup --- CoreStoreTests/WhereTests.swift | 205 ++++++++++++++++++ ...FetchedResultsController+Convenience.swift | 2 +- .../NSManagedObject+Convenience.swift | 19 +- Sources/CoreStoreError.swift | 54 ++--- .../Concrete Clauses/GroupBy.swift | 16 +- .../Concrete Clauses/OrderBy.swift | 16 +- .../Concrete Clauses/Select.swift | 66 +++--- .../Concrete Clauses/Where.swift | 16 +- .../BaseDataTransaction+Importing.swift | 12 +- Sources/Internal/MigrationManager.swift | 2 +- Sources/Logging/CoreStore+Logging.swift | 1 - Sources/Migrating/MigrationChain.swift | 22 +- Sources/Migrating/MigrationResult.swift | 36 +-- Sources/Migrating/MigrationType.swift | 42 ++-- Sources/Migrating/SetupResult.swift | 36 +-- Sources/Observing/ListMonitor.swift | 48 ++-- Sources/Observing/ObjectMonitor.swift | 30 ++- Sources/Observing/SectionBy.swift | 2 +- Sources/Setup/DataStack.swift | 20 +- Sources/Transactions/Into.swift | 27 +-- Sources/Transactions/SaveResult.swift | 36 +-- 21 files changed, 453 insertions(+), 255 deletions(-) diff --git a/CoreStoreTests/WhereTests.swift b/CoreStoreTests/WhereTests.swift index 46ed81c..8dec55a 100644 --- a/CoreStoreTests/WhereTests.swift +++ b/CoreStoreTests/WhereTests.swift @@ -87,6 +87,211 @@ final class WhereTests: XCTestCase { } } + @objc + dynamic func test_ThatWhereClauses_BridgeArgumentsCorrectly() { + + do { + + let value: Int = 100 + let whereClause1 = Where("%K == %d", "key", value) + let whereClause2 = Where("%K == %d", "key", value as AnyObject) + let whereClause3 = Where("%K == %d", "key", NSNumber(value: value)) + let whereClause4 = Where("%K == %@", "key", value) + let whereClause5 = Where("%K == %@", "key", value as AnyObject) + let whereClause6 = Where("%K == %@", "key", NSNumber(value: value)) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + do { + + let value = NSNumber(value: 100) + let whereClause1 = Where("%K == %d", "key", value) + let whereClause2 = Where("%K == %d", "key", value as AnyObject) + let whereClause3 = Where("%K == %d", "key", value.intValue) + let whereClause4 = Where("%K == %@", "key", value) + let whereClause5 = Where("%K == %@", "key", value as AnyObject) + let whereClause6 = Where("%K == %@", "key", value.intValue) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + do { + + let value: Int64 = Int64.max + let whereClause1 = Where("%K == %d", "key", value) + let whereClause2 = Where("%K == %d", "key", value as AnyObject) + let whereClause3 = Where("%K == %d", "key", NSNumber(value: value)) + let whereClause4 = Where("%K == %@", "key", value) + let whereClause5 = Where("%K == %@", "key", value as AnyObject) + let whereClause6 = Where("%K == %@", "key", NSNumber(value: value)) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + do { + + let value = NSNumber(value: Int64.max) + let whereClause1 = Where("%K == %d", "key", value) + let whereClause2 = Where("%K == %d", "key", value as AnyObject) + let whereClause3 = Where("%K == %d", "key", value.intValue) + let whereClause4 = Where("%K == %@", "key", value) + let whereClause5 = Where("%K == %@", "key", value as AnyObject) + let whereClause6 = Where("%K == %@", "key", value.intValue) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + do { + + let value: String = "value" + let whereClause1 = Where("%K == %s", "key", value) + let whereClause2 = Where("%K == %s", "key", value as AnyObject) + let whereClause3 = Where("%K == %s", "key", NSString(string: value)) + let whereClause4 = Where("%K == %@", "key", value) + let whereClause5 = Where("%K == %@", "key", value as AnyObject) + let whereClause6 = Where("%K == %@", "key", NSString(string: value)) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + do { + + let value = NSString(string: "value") + let whereClause1 = Where("%K == %s", "key", value) + let whereClause2 = Where("%K == %s", "key", value as String) + let whereClause3 = Where("%K == %s", "key", value as String as AnyObject) + let whereClause4 = Where("%K == %@", "key", value) + let whereClause5 = Where("%K == %@", "key", value as String) + let whereClause6 = Where("%K == %@", "key", value as String as AnyObject) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + do { + + let value: [Int] = [100, 200] + let whereClause1 = Where("%K == %@", "key", value) + let whereClause2 = Where("%K == %@", "key", value as AnyObject) + let whereClause3 = Where("%K == %@", "key", value as [AnyObject]) + let whereClause4 = Where("%K == %@", "key", value as NSArray) + let whereClause5 = Where("%K == %@", "key", NSArray(array: value)) + let whereClause6 = Where("%K == %@", "key", value as AnyObject as! NSArray) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + do { + + let value: [Int64] = [Int64.min, 100, Int64.max] + let whereClause1 = Where("%K == %@", "key", value) + let whereClause2 = Where("%K == %@", "key", value as AnyObject) + let whereClause3 = Where("%K == %@", "key", value as [AnyObject]) + let whereClause4 = Where("%K == %@", "key", value as NSArray) + let whereClause5 = Where("%K == %@", "key", NSArray(array: value)) + let whereClause6 = Where("%K == %@", "key", value as AnyObject as! NSArray) + XCTAssertEqual(whereClause1, whereClause2) + XCTAssertEqual(whereClause1, whereClause3) + XCTAssertEqual(whereClause1, whereClause4) + XCTAssertEqual(whereClause1, whereClause5) + XCTAssertEqual(whereClause1, whereClause6) + XCTAssertEqual(whereClause2, whereClause3) + XCTAssertEqual(whereClause2, whereClause4) + XCTAssertEqual(whereClause2, whereClause5) + XCTAssertEqual(whereClause2, whereClause6) + XCTAssertEqual(whereClause3, whereClause4) + XCTAssertEqual(whereClause3, whereClause5) + XCTAssertEqual(whereClause3, whereClause6) + XCTAssertEqual(whereClause4, whereClause5) + XCTAssertEqual(whereClause4, whereClause6) + XCTAssertEqual(whereClause5, whereClause6) + } + } + @objc dynamic func test_ThatWhereClauseOperations_ComputeCorrectly() { diff --git a/Sources/Convenience/NSFetchedResultsController+Convenience.swift b/Sources/Convenience/NSFetchedResultsController+Convenience.swift index b6aca1a..56d0e37 100644 --- a/Sources/Convenience/NSFetchedResultsController+Convenience.swift +++ b/Sources/Convenience/NSFetchedResultsController+Convenience.swift @@ -214,7 +214,7 @@ fileprivate func createFRC(fromContext context: NSManagedObj fetchRequest.sortDescriptors?.isEmpty == false, "An \(cs_typeName(NSFetchedResultsController.self)) requires a sort information. Specify from a \(cs_typeName(OrderBy.self)) clause or any custom \(cs_typeName(FetchClause.self)) that provides a sort descriptor." ) - } + } ) return controller.dynamicCast() } diff --git a/Sources/Convenience/NSManagedObject+Convenience.swift b/Sources/Convenience/NSManagedObject+Convenience.swift index 59e22f3..6fbe2a9 100644 --- a/Sources/Convenience/NSManagedObject+Convenience.swift +++ b/Sources/Convenience/NSManagedObject+Convenience.swift @@ -93,17 +93,34 @@ public extension NSManagedObject { return primitiveValue } + /** + Provides a convenience wrapper for accessing `primitiveValueForKey(...)` with proper calls to `willAccessValueForKey(...)` and `didAccessValueForKey(...)`. This is useful when implementing accessor methods for transient attributes. + + - parameter KVCKey: the KVC key + - parameter closure: a closure that receives the accessed value. This closure is executed between `willAccessValueForKey(...)` and `didAccessValueForKey(...)` + - returns: the primitive value for the KVC key + */ + @nonobjc + public func accessValueForKVCKey(_ KVCKey: KeyPath, _ closure: (Any?) -> Void) { + + self.willAccessValue(forKey: KVCKey) + closure(self.primitiveValue(forKey: KVCKey)) + self.didAccessValue(forKey: KVCKey) + } + /** Provides a convenience wrapper for setting `setPrimitiveValue(...)` with proper calls to `willChangeValueForKey(...)` and `didChangeValueForKey(...)`. This is useful when implementing mutator methods for transient attributes. - parameter value: the value to set the KVC key with + - parameter closure: a closure that receives the accessed value. This closure is executed between `willChangeValue(...)` and `didChangeValue(...)` - parameter KVCKey: the KVC key */ @nonobjc - public func setValue(_ value: Any?, forKVCKey KVCKey: KeyPath) { + public func setValue(_ value: Any?, forKVCKey KVCKey: KeyPath, _ closure: () -> Void = {}) { self.willChangeValue(forKey: KVCKey) self.setPrimitiveValue(value, forKey: KVCKey) + closure() self.didChangeValue(forKey: KVCKey) } diff --git a/Sources/CoreStoreError.swift b/Sources/CoreStoreError.swift index 945df3b..8a87ab8 100644 --- a/Sources/CoreStoreError.swift +++ b/Sources/CoreStoreError.swift @@ -120,6 +120,33 @@ public enum CoreStoreError: Error, CustomNSError, Hashable { } + // MARK: Equatable + + public static func == (lhs: CoreStoreError, rhs: CoreStoreError) -> Bool { + + switch (lhs, rhs) { + + case (.unknown, .unknown): + return true + + case (.differentStorageExistsAtURL(let url1), .differentStorageExistsAtURL(let url2)): + return url1 == url2 + + case (.mappingModelNotFound(let url1, let model1, let version1), .mappingModelNotFound(let url2, let model2, let version2)): + return url1 == url2 && model1 == model2 && version1 == version2 + + case (.progressiveMigrationRequired(let url1), .progressiveMigrationRequired(let url2)): + return url1 == url2 + + case (.internalError(let NSError1), .internalError(let NSError2)): + return NSError1 == NSError2 + + default: + return false + } + } + + // MARK: Hashable public var hashValue: Int { @@ -154,33 +181,6 @@ public enum CoreStoreError: Error, CustomNSError, Hashable { } -// MARK: - CoreStoreError: Equatable - -public func == (lhs: CoreStoreError, rhs: CoreStoreError) -> Bool { - - switch (lhs, rhs) { - - case (.unknown, .unknown): - return true - - case (.differentStorageExistsAtURL(let url1), .differentStorageExistsAtURL(let url2)): - return url1 == url2 - - case (.mappingModelNotFound(let url1, let model1, let version1), .mappingModelNotFound(let url2, let model2, let version2)): - return url1 == url2 && model1 == model2 && version1 == version2 - - case (.progressiveMigrationRequired(let url1), .progressiveMigrationRequired(let url2)): - return url1 == url2 - - case (.internalError(let NSError1), .internalError(let NSError2)): - return NSError1 == NSError2 - - default: - return false - } -} - - // MARK: - CoreStoreErrorDomain /** diff --git a/Sources/Fetching and Querying/Concrete Clauses/GroupBy.swift b/Sources/Fetching and Querying/Concrete Clauses/GroupBy.swift index 3723b0b..842b713 100644 --- a/Sources/Fetching and Querying/Concrete Clauses/GroupBy.swift +++ b/Sources/Fetching and Querying/Concrete Clauses/GroupBy.swift @@ -85,6 +85,14 @@ public struct GroupBy: QueryClause, Hashable { } + // MARK: Equatable + + public static func == (lhs: GroupBy, rhs: GroupBy) -> Bool { + + return lhs.keyPaths == rhs.keyPaths + } + + // MARK: Hashable public var hashValue: Int { @@ -92,11 +100,3 @@ public struct GroupBy: QueryClause, Hashable { return (self.keyPaths as NSArray).hashValue } } - - -// MARK: - GroupBy: Equatable - -public func == (lhs: GroupBy, rhs: GroupBy) -> Bool { - - return lhs.keyPaths == rhs.keyPaths -} diff --git a/Sources/Fetching and Querying/Concrete Clauses/OrderBy.swift b/Sources/Fetching and Querying/Concrete Clauses/OrderBy.swift index 9868fca..76bb49d 100644 --- a/Sources/Fetching and Querying/Concrete Clauses/OrderBy.swift +++ b/Sources/Fetching and Querying/Concrete Clauses/OrderBy.swift @@ -152,6 +152,14 @@ public struct OrderBy: FetchClause, QueryClause, DeleteClause, Hashable { } + // MARK: Equatable + + public static func == (lhs: OrderBy, rhs: OrderBy) -> Bool { + + return lhs.sortDescriptors == rhs.sortDescriptors + } + + // MARK: Hashable public var hashValue: Int { @@ -159,11 +167,3 @@ public struct OrderBy: FetchClause, QueryClause, DeleteClause, Hashable { return (self.sortDescriptors as NSArray).hashValue } } - - -// MARK: - OrderBy: Equatable - -public func == (lhs: OrderBy, rhs: OrderBy) -> Bool { - - return lhs.sortDescriptors == rhs.sortDescriptors -} diff --git a/Sources/Fetching and Querying/Concrete Clauses/Select.swift b/Sources/Fetching and Querying/Concrete Clauses/Select.swift index 960c5ca..89f7a9b 100644 --- a/Sources/Fetching and Querying/Concrete Clauses/Select.swift +++ b/Sources/Fetching and Querying/Concrete Clauses/Select.swift @@ -241,6 +241,31 @@ public enum SelectTerm: ExpressibleByStringLiteral, Hashable { } + // MARK: Equatable + + public static func == (lhs: SelectTerm, rhs: SelectTerm) -> Bool { + + switch (lhs, rhs) { + + case (._attribute(let keyPath1), ._attribute(let keyPath2)): + return keyPath1 == keyPath2 + + case (._aggregate(let function1, let keyPath1, let alias1, let nativeType1), + ._aggregate(let function2, let keyPath2, let alias2, let nativeType2)): + return function1 == function2 + && keyPath1 == keyPath2 + && alias1 == alias2 + && nativeType1 == nativeType2 + + case (._identity(let alias1, let nativeType1), ._identity(let alias2, let nativeType2)): + return alias1 == alias2 && nativeType1 == nativeType2 + + default: + return false + } + } + + // MARK: Hashable public var hashValue: Int { @@ -267,31 +292,6 @@ public enum SelectTerm: ExpressibleByStringLiteral, Hashable { } -// MARK: - SelectTerm: Equatable - -public func == (lhs: SelectTerm, rhs: SelectTerm) -> Bool { - - switch (lhs, rhs) { - - case (._attribute(let keyPath1), ._attribute(let keyPath2)): - return keyPath1 == keyPath2 - - case (._aggregate(let function1, let keyPath1, let alias1, let nativeType1), - ._aggregate(let function2, let keyPath2, let alias2, let nativeType2)): - return function1 == function2 - && keyPath1 == keyPath2 - && alias1 == alias2 - && nativeType1 == nativeType2 - - case (._identity(let alias1, let nativeType1), ._identity(let alias2, let nativeType2)): - return alias1 == alias2 && nativeType1 == nativeType2 - - default: - return false - } -} - - // MARK: - Select /** @@ -364,6 +364,14 @@ public struct Select: Hashable { } + // MARK: Equatable + + public static func == (lhs: Select, rhs: Select) -> Bool { + + return lhs.selectTerms == rhs.selectTerms + } + + // MARK: Hashable public var hashValue: Int { @@ -386,14 +394,6 @@ public extension Select where T: NSManagedObjectID { } -// MARK: - Select: Equatable - -public func == (lhs: Select, rhs: Select) -> Bool { - - return lhs.selectTerms == rhs.selectTerms -} - - // MARK: - Bool: SelectValueResultType extension Bool: SelectValueResultType { diff --git a/Sources/Fetching and Querying/Concrete Clauses/Where.swift b/Sources/Fetching and Querying/Concrete Clauses/Where.swift index e85aa27..75fc7f6 100644 --- a/Sources/Fetching and Querying/Concrete Clauses/Where.swift +++ b/Sources/Fetching and Querying/Concrete Clauses/Where.swift @@ -157,6 +157,14 @@ public struct Where: FetchClause, QueryClause, DeleteClause, Hashable { } + // MARK: Equatable + + public static func == (lhs: Where, rhs: Where) -> Bool { + + return lhs.predicate == rhs.predicate + } + + // MARK: Hashable public var hashValue: Int { @@ -164,11 +172,3 @@ public struct Where: FetchClause, QueryClause, DeleteClause, Hashable { return self.predicate.hashValue } } - - -// MARK: - Where: Equatable - -public func == (lhs: Where, rhs: Where) -> Bool { - - return lhs.predicate == rhs.predicate -} diff --git a/Sources/Importing/BaseDataTransaction+Importing.swift b/Sources/Importing/BaseDataTransaction+Importing.swift index df41f2f..2a7085c 100644 --- a/Sources/Importing/BaseDataTransaction+Importing.swift +++ b/Sources/Importing/BaseDataTransaction+Importing.swift @@ -82,12 +82,10 @@ public extension BaseDataTransaction { try autoreleasepool { let entityType = type(of: object) - guard entityType.shouldInsert(from: source, in: self) else { return } - try object.didInsert(from: source, in: self) } } @@ -114,12 +112,10 @@ public extension BaseDataTransaction { 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) @@ -150,7 +146,6 @@ public extension BaseDataTransaction { 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 { @@ -163,7 +158,6 @@ public extension BaseDataTransaction { return nil } - try object.update(from: source, in: self) return object } @@ -173,7 +167,6 @@ public extension BaseDataTransaction { return nil } - let object = self.create(into) object.uniqueIDValue = uniqueIDValue try object.didInsert(from: source, in: self) @@ -206,7 +199,6 @@ public extension BaseDataTransaction { return try autoreleasepool { let entityType = into.entityClass as! T.Type - var importSourceByID = Dictionary() let sortedIDs = try autoreleasepool { @@ -242,17 +234,15 @@ public extension BaseDataTransaction { 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) } } diff --git a/Sources/Internal/MigrationManager.swift b/Sources/Internal/MigrationManager.swift index de4ed7f..eda35c8 100644 --- a/Sources/Internal/MigrationManager.swift +++ b/Sources/Internal/MigrationManager.swift @@ -37,7 +37,7 @@ internal final class MigrationManager: NSMigrationManager, ProgressReporting { super.didChangeValue(forKey: key) - guard key == "migrationProgress" else { + guard key == #keyPath(NSMigrationManager.migrationProgress) else { return } diff --git a/Sources/Logging/CoreStore+Logging.swift b/Sources/Logging/CoreStore+Logging.swift index dfb5ed2..6102cf8 100644 --- a/Sources/Logging/CoreStore+Logging.swift +++ b/Sources/Logging/CoreStore+Logging.swift @@ -71,7 +71,6 @@ public extension CoreStore { ) } - internal static func abort(_ message: String, fileName: StaticString = #file, lineNumber: Int = #line, functionName: StaticString = #function) -> Never { self.logger.abort( diff --git a/Sources/Migrating/MigrationChain.swift b/Sources/Migrating/MigrationChain.swift index 3082e41..9507303 100644 --- a/Sources/Migrating/MigrationChain.swift +++ b/Sources/Migrating/MigrationChain.swift @@ -216,6 +216,17 @@ public struct MigrationChain: ExpressibleByNilLiteral, ExpressibleByStringLitera } + // MARK: Equatable + + public static func == (lhs: MigrationChain, rhs: MigrationChain) -> Bool { + + return lhs.versionTree == rhs.versionTree + && lhs.rootVersions == rhs.rootVersions + && lhs.leafVersions == rhs.leafVersions + && lhs.valid == rhs.valid + } + + // MARK: Internal internal let rootVersions: Set @@ -249,14 +260,3 @@ public struct MigrationChain: ExpressibleByNilLiteral, ExpressibleByStringLitera fileprivate let versionTree: [String: String] } - -// MARK: - MigrationChain: Equatable - -public func == (lhs: MigrationChain, rhs: MigrationChain) -> Bool { - - return lhs.versionTree == rhs.versionTree - && lhs.rootVersions == rhs.rootVersions - && lhs.leafVersions == rhs.leafVersions - && lhs.valid == rhs.valid -} - diff --git a/Sources/Migrating/MigrationResult.swift b/Sources/Migrating/MigrationResult.swift index 8be44aa..a27f58d 100644 --- a/Sources/Migrating/MigrationResult.swift +++ b/Sources/Migrating/MigrationResult.swift @@ -83,6 +83,24 @@ public enum MigrationResult: Hashable { } + // MARK: Equatable + + public static func == (lhs: MigrationResult, rhs: MigrationResult) -> Bool { + + switch (lhs, rhs) { + + case (.success(let migrationTypes1), .success(let migrationTypes2)): + return migrationTypes1 == migrationTypes2 + + case (.failure(let error1), .failure(let error2)): + return error1 == error2 + + default: + return false + } + } + + // MARK: Hashable public var hashValue: Int { @@ -116,21 +134,3 @@ public enum MigrationResult: Hashable { self = .failure(CoreStoreError(error)) } } - - -// MARK: - SetupResult: Equatable - -public func == (lhs: MigrationResult, rhs: MigrationResult) -> Bool { - - switch (lhs, rhs) { - - case (.success(let migrationTypes1), .success(let migrationTypes2)): - return migrationTypes1 == migrationTypes2 - - case (.failure(let error1), .failure(let error2)): - return error1 == error2 - - default: - return false - } -} diff --git a/Sources/Migrating/MigrationType.swift b/Sources/Migrating/MigrationType.swift index 5dc5a35..f40c918 100644 --- a/Sources/Migrating/MigrationType.swift +++ b/Sources/Migrating/MigrationType.swift @@ -122,6 +122,27 @@ public enum MigrationType: Hashable { } + // MARK: Equatable + + public static func == (lhs: MigrationType, rhs: MigrationType) -> Bool { + + switch (lhs, rhs) { + + case (.none(let version1), .none(let version2)): + return version1 == version2 + + case (.lightweight(let source1, let destination1), .lightweight(let source2, let destination2)): + return source1 == source2 && destination1 == destination2 + + case (.heavyweight(let source1, let destination1), .heavyweight(let source2, let destination2)): + return source1 == source2 && destination1 == destination2 + + default: + return false + } + } + + // MARK: Hashable public var hashValue: Int { @@ -140,24 +161,3 @@ public enum MigrationType: Hashable { } } } - - -// MARK: - MigrationType: Equatable - -public func == (lhs: MigrationType, rhs: MigrationType) -> Bool { - - switch (lhs, rhs) { - - case (.none(let version1), .none(let version2)): - return version1 == version2 - - case (.lightweight(let source1, let destination1), .lightweight(let source2, let destination2)): - return source1 == source2 && destination1 == destination2 - - case (.heavyweight(let source1, let destination1), .heavyweight(let source2, let destination2)): - return source1 == source2 && destination1 == destination2 - - default: - return false - } -} diff --git a/Sources/Migrating/SetupResult.swift b/Sources/Migrating/SetupResult.swift index 2d3dc92..545412a 100644 --- a/Sources/Migrating/SetupResult.swift +++ b/Sources/Migrating/SetupResult.swift @@ -86,6 +86,24 @@ public enum SetupResult: Hashable { } + // MARK: Equatable + + public static func == (lhs: SetupResult, rhs: SetupResult) -> Bool { + + switch (lhs, rhs) { + + case (.success(let storage1), .success(let storage2)): + return storage1 === storage2 + + case (.failure(let error1), .failure(let error2)): + return error1 == error2 + + default: + return false + } + } + + // MARK: Hashable public var hashValue: Int { @@ -118,21 +136,3 @@ public enum SetupResult: Hashable { self = .failure(CoreStoreError(error)) } } - - -// MARK: - SetupResult: Equatable - -public func == (lhs: SetupResult, rhs: SetupResult) -> Bool { - - switch (lhs, rhs) { - - case (.success(let storage1), .success(let storage2)): - return storage1 === storage2 - - case (.failure(let error1), .failure(let error2)): - return error1 == error2 - - default: - return false - } -} diff --git a/Sources/Observing/ListMonitor.swift b/Sources/Observing/ListMonitor.swift index 9a17dce..38a4ec8 100644 --- a/Sources/Observing/ListMonitor.swift +++ b/Sources/Observing/ListMonitor.swift @@ -594,6 +594,29 @@ public final class ListMonitor: Hashable { } + // MARK: Equatable + + public static func == (lhs: ListMonitor, rhs: ListMonitor) -> Bool { + + return lhs === rhs + } + + public static func == (lhs: ListMonitor, rhs: ListMonitor) -> Bool { + + return lhs.fetchedResultsController === rhs.fetchedResultsController + } + + public static func ~= (lhs: ListMonitor, rhs: ListMonitor) -> Bool { + + return lhs === rhs + } + + public static func ~= (lhs: ListMonitor, rhs: ListMonitor) -> Bool { + + return lhs.fetchedResultsController === rhs.fetchedResultsController + } + + // MARK: Hashable public var hashValue: Int { @@ -1123,31 +1146,6 @@ public final class ListMonitor: Hashable { } -// MARK: - ListMonitor: Equatable - -public func == (lhs: ListMonitor, rhs: ListMonitor) -> Bool { - - return lhs === rhs -} - -public func == (lhs: ListMonitor, rhs: ListMonitor) -> Bool { - - return lhs.fetchedResultsController === rhs.fetchedResultsController -} - -public func ~= (lhs: ListMonitor, rhs: ListMonitor) -> Bool { - - return lhs === rhs -} - -public func ~= (lhs: ListMonitor, rhs: ListMonitor) -> Bool { - - return lhs.fetchedResultsController === rhs.fetchedResultsController -} - -extension ListMonitor: Equatable { } - - // MARK: - ListMonitor: FetchedResultsControllerHandler extension ListMonitor: FetchedResultsControllerHandler { diff --git a/Sources/Observing/ObjectMonitor.swift b/Sources/Observing/ObjectMonitor.swift index 0feb59a..5db3b32 100644 --- a/Sources/Observing/ObjectMonitor.swift +++ b/Sources/Observing/ObjectMonitor.swift @@ -41,7 +41,7 @@ import CoreData Observers registered via `addObserver(_:)` are not retained. `ObjectMonitor` only keeps a `weak` reference to all observers, thus keeping itself free from retain-cycles. */ -public final class ObjectMonitor { +public final class ObjectMonitor: Equatable { /** Returns the `NSManagedObject` instance being observed, or `nil` if the object was already deleted. @@ -103,6 +103,19 @@ public final class ObjectMonitor { } + // MARK: Equatable + + public static func == (lhs: ObjectMonitor, rhs: ObjectMonitor) -> Bool { + + return lhs === rhs + } + + public static func ~= (lhs: ObjectMonitor, rhs: ObjectMonitor) -> Bool { + + return lhs === rhs + } + + // MARK: Hashable public var hashValue: Int { @@ -291,21 +304,6 @@ public final class ObjectMonitor { } -// MARK: - ObjectMonitor: Equatable - -public func == (lhs: ObjectMonitor, rhs: ObjectMonitor) -> Bool { - - return lhs === rhs -} - -public func ~= (lhs: ObjectMonitor, rhs: ObjectMonitor) -> Bool { - - return lhs === rhs -} - -extension ObjectMonitor: Equatable { } - - // MARK: - ObjectMonitor: FetchedResultsControllerHandler extension ObjectMonitor: FetchedResultsControllerHandler { diff --git a/Sources/Observing/SectionBy.swift b/Sources/Observing/SectionBy.swift index abc4c8b..63cfc9d 100644 --- a/Sources/Observing/SectionBy.swift +++ b/Sources/Observing/SectionBy.swift @@ -70,7 +70,7 @@ public struct SectionBy { // MARK: Internal internal let sectionKeyPath: KeyPath - internal let sectionIndexTransformer: (_ sectionName: KeyPath?) -> String? + internal let sectionIndexTransformer: (_ sectionName: String?) -> String? } #endif diff --git a/Sources/Setup/DataStack.swift b/Sources/Setup/DataStack.swift index abdcd6a..557cb4b 100644 --- a/Sources/Setup/DataStack.swift +++ b/Sources/Setup/DataStack.swift @@ -32,7 +32,7 @@ import CoreData /** The `DataStack` encapsulates the data model for the Core Data stack. Each `DataStack` can have multiple data stores, usually specified as a "Configuration" in the model editor. Behind the scenes, the DataStack manages its own `NSPersistentStoreCoordinator`, a root `NSManagedObjectContext` for disk saves, and a shared `NSManagedObjectContext` designed as a read-only model interface for `NSManagedObjects`. */ -public final class DataStack { +public final class DataStack: Equatable { /** Initializes a `DataStack` from the model with the specified `modelName` in the specified `bundle`. @@ -381,6 +381,14 @@ public final class DataStack { } + // MARK: Equatable + + public static func == (lhs: DataStack, rhs: DataStack) -> Bool { + + return lhs === rhs + } + + // MARK: Internal internal static let applicationName = (Bundle.main.object(forInfoDictionaryKey: "CFBundleName") as? String) ?? "CoreData" @@ -527,13 +535,3 @@ public final class DataStack { return self.objectID(forURIRepresentation: url) } } - - -// MARK: - DataStack: Equatable - -public func == (lhs: DataStack, rhs: DataStack) -> Bool { - - return lhs === rhs -} - -extension DataStack: Equatable {} diff --git a/Sources/Transactions/Into.swift b/Sources/Transactions/Into.swift index cb19731..cc9666f 100644 --- a/Sources/Transactions/Into.swift +++ b/Sources/Transactions/Into.swift @@ -134,6 +134,16 @@ public struct Into: Hashable { } + // MARK: Equatable + + public static func == (lhs: Into, rhs: Into) -> Bool { + + return lhs.entityClass == rhs.entityClass + && lhs.configuration == rhs.configuration + && lhs.inferStoreIfPossible == rhs.inferStoreIfPossible + } + + // MARK: Hashable public var hashValue: Int { @@ -172,20 +182,3 @@ public struct Into: Hashable { self.inferStoreIfPossible = inferStoreIfPossible } } - - -// MARK: - Into: Equatable - -public func == (lhs: Into, rhs: Into) -> Bool { - - return lhs.entityClass == rhs.entityClass - && lhs.configuration == rhs.configuration - && lhs.inferStoreIfPossible == rhs.inferStoreIfPossible -} - -public func != (lhs: Into, rhs: Into) -> Bool { - - return lhs.entityClass == rhs.entityClass - && lhs.configuration == rhs.configuration - && lhs.inferStoreIfPossible == rhs.inferStoreIfPossible -} diff --git a/Sources/Transactions/SaveResult.swift b/Sources/Transactions/SaveResult.swift index c0a9856..15632a5 100644 --- a/Sources/Transactions/SaveResult.swift +++ b/Sources/Transactions/SaveResult.swift @@ -83,6 +83,24 @@ public enum SaveResult: Hashable { } + // MARK: Equatable + + public static func == (lhs: SaveResult, rhs: SaveResult) -> Bool { + + switch (lhs, rhs) { + + case (.success(let hasChanges1), .success(let hasChanges2)): + return hasChanges1 == hasChanges2 + + case (.failure(let error1), .failure(let error2)): + return error1 == error2 + + default: + return false + } + } + + // MARK: Hashable public var hashValue: Int { @@ -110,21 +128,3 @@ public enum SaveResult: Hashable { self = .failure(error) } } - - -// MARK: - SaveResult: Equatable - -public func == (lhs: SaveResult, rhs: SaveResult) -> Bool { - - switch (lhs, rhs) { - - case (.success(let hasChanges1), .success(let hasChanges2)): - return hasChanges1 == hasChanges2 - - case (.failure(let error1), .failure(let error2)): - return error1 == error2 - - default: - return false - } -}