Swift Package Manager support

Sources/Observing/CoreStore+Observing.swift

@@ -0,0 +1,150 @@
+//
+//  CoreStore+Observing.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: - CoreStore
+
+@available(OSX, unavailable)
+public extension CoreStore {
+    
+    /**
+     Using the `defaultStack`, creates a `ObjectMonitor` for the specified `NSManagedObject`. Multiple `ObjectObserver`s may then register themselves to be notified when changes are made to the `NSManagedObject`.
+     
+     - parameter object: the `NSManagedObject` to observe changes from
+     - returns: a `ObjectMonitor` that monitors changes to `object`
+     */
+    @warn_unused_result
+    public static func monitorObject<T: NSManagedObject>(object: T) -> ObjectMonitor<T> {
+        
+        return self.defaultStack.monitorObject(object)
+    }
+    
+    /**
+     Using the `defaultStack`, creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public static func monitorList<T: NSManagedObject>(from: From<T>, _ queryClauses: FetchClause...) -> ListMonitor<T> {
+        
+        return self.defaultStack.monitorList(from, queryClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public static func monitorList<T: NSManagedObject>(from: From<T>, _ queryClauses: [FetchClause]) -> ListMonitor<T> {
+        
+        return self.defaultStack.monitorList(from, queryClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, asynchronously creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public static func monitorList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ fetchClauses: FetchClause...) {
+        
+        self.defaultStack.monitorList(createAsynchronously: createAsynchronously, from, fetchClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, asynchronously creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public static func monitorList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ fetchClauses: [FetchClause])  {
+        
+        self.defaultStack.monitorList(createAsynchronously: createAsynchronously, from, fetchClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public static func monitorSectionedList<T: NSManagedObject>(from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: FetchClause...) -> ListMonitor<T> {
+        
+        return self.defaultStack.monitorSectionedList(from, sectionBy, fetchClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public static func monitorSectionedList<T: NSManagedObject>(from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: [FetchClause]) -> ListMonitor<T> {
+        
+        return self.defaultStack.monitorSectionedList(from, sectionBy, fetchClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, asynchronously creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public static func monitorSectionedList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: FetchClause...) {
+        
+        self.defaultStack.monitorSectionedList(createAsynchronously: createAsynchronously, from, sectionBy, fetchClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, asynchronously creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public static func monitorSectionedList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: [FetchClause]) {
+        
+        self.defaultStack.monitorSectionedList(createAsynchronously: createAsynchronously, from, sectionBy, fetchClauses)
+    }
+}

Sources/Observing/DataStack+Observing.swift

@@ -0,0 +1,219 @@
+//
+//  DataStack+Observing.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
+#if USE_FRAMEWORKS
+    import GCDKit
+#endif
+
+
+// MARK: - DataStack
+
+@available(OSX, unavailable)
+public extension DataStack {
+    
+    /**
+     Creates a `ObjectMonitor` for the specified `NSManagedObject`. Multiple `ObjectObserver`s may then register themselves to be notified when changes are made to the `NSManagedObject`.
+     
+     - parameter object: the `NSManagedObject` to observe changes from
+     - returns: a `ObjectMonitor` that monitors changes to `object`
+     */
+    @warn_unused_result
+    public func monitorObject<T: NSManagedObject>(object: T) -> ObjectMonitor<T> {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        
+        return ObjectMonitor(
+            dataStack: self,
+            object: object
+        )
+    }
+    
+    /**
+     Creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorList<T: NSManagedObject>(from: From<T>, _ fetchClauses: FetchClause...) -> ListMonitor<T> {
+        
+        return self.monitorList(from, fetchClauses)
+    }
+    
+    /**
+     Creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorList<T: NSManagedObject>(from: From<T>, _ fetchClauses: [FetchClause]) -> ListMonitor<T> {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        return ListMonitor(
+            dataStack: self,
+            from: from,
+            sectionBy: nil,
+            fetchClauses: fetchClauses
+        )
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ fetchClauses: FetchClause...) {
+        
+        self.monitorList(createAsynchronously: createAsynchronously, from, fetchClauses)
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ fetchClauses: [FetchClause])  {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        _ = ListMonitor(
+            dataStack: self,
+            from: from,
+            sectionBy: nil,
+            fetchClauses: fetchClauses,
+            createAsynchronously: createAsynchronously
+        )
+    }
+    
+    /**
+     Creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorSectionedList<T: NSManagedObject>(from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: FetchClause...) -> ListMonitor<T> {
+        
+        return self.monitorSectionedList(from, sectionBy, fetchClauses)
+    }
+    
+    /**
+     Creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorSectionedList<T: NSManagedObject>(from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: [FetchClause]) -> ListMonitor<T> {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        return ListMonitor(
+            dataStack: self,
+            from: from,
+            sectionBy: sectionBy,
+            fetchClauses: fetchClauses
+        )
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorSectionedList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: FetchClause...) {
+        
+        self.monitorSectionedList(createAsynchronously: createAsynchronously, from, sectionBy, fetchClauses)
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorSectionedList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: [FetchClause]) {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        _ = ListMonitor(
+            dataStack: self,
+            from: from,
+            sectionBy: sectionBy,
+            fetchClauses: fetchClauses,
+            createAsynchronously: createAsynchronously
+        )
+    }
+}

Sources/Observing/ListObserver.swift

@@ -0,0 +1,238 @@
+//
+//  ListObserver.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: - ListObserver
+
+/**
+ Implement the `ListObserver` protocol to observe changes to a list of `NSManagedObject`s. `ListObserver`s may register themselves to a `ListMonitor`'s `addObserver(_:)` method:
+ ```
+ let monitor = CoreStore.monitorList(
+     From(MyPersonEntity),
+     OrderBy(.Ascending("lastName"))
+ )
+ monitor.addObserver(self)
+ ```
+ */
+@available(OSX, unavailable)
+public protocol ListObserver: class {
+    
+    /**
+     The `NSManagedObject` type for the observed list
+     */
+    associatedtype ListEntityType: NSManagedObject
+    
+    /**
+     Handles processing just before a change to the observed list occurs
+     
+     - parameter monitor: the `ListMonitor` monitoring the list being observed
+     */
+    func listMonitorWillChange(monitor: ListMonitor<ListEntityType>)
+    
+    /**
+     Handles processing right after a change to the observed list occurs
+     
+     - parameter monitor: the `ListMonitor` monitoring the object being observed
+     */
+    func listMonitorDidChange(monitor: ListMonitor<ListEntityType>)
+    
+    /**
+     This method is broadcast from within the `ListMonitor`'s `refetch(...)` method to let observers prepare for the internal `NSFetchedResultsController`'s pending change to its predicate, sort descriptors, etc. Note that the actual refetch will happen after the `NSFetchedResultsController`'s last `controllerDidChangeContent(_:)` notification completes.
+     
+     - parameter monitor: the `ListMonitor` monitoring the object being observed
+     */
+    func listMonitorWillRefetch(monitor: ListMonitor<ListEntityType>)
+    
+    /**
+     After the `ListMonitor`'s `refetch(...)` method is called, this method is broadcast after the `NSFetchedResultsController`'s last `controllerDidChangeContent(_:)` notification completes.
+     
+     - parameter monitor: the `ListMonitor` monitoring the object being observed
+     */
+    func listMonitorDidRefetch(monitor: ListMonitor<ListEntityType>)
+}
+
+
+// MARK: - ListObserver (Default Implementations)
+
+@available(OSX, unavailable)
+public extension ListObserver {
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitorWillChange(monitor: ListMonitor<ListEntityType>) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitorDidChange(monitor: ListMonitor<ListEntityType>) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitorWillRefetch(monitor: ListMonitor<ListEntityType>) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitorDidRefetch(monitor: ListMonitor<ListEntityType>) { }
+}
+
+
+// MARK: - ListObjectObserver
+
+/**
+ Implement the `ListObjectObserver` protocol to observe detailed changes to a list's object. `ListObjectObserver`s may register themselves to a `ListMonitor`'s `addObserver(_:)` method:
+ ```
+ let monitor = CoreStore.monitorList(
+     From(MyPersonEntity),
+     OrderBy(.Ascending("lastName"))
+ )
+ monitor.addObserver(self)
+ ```
+ */
+@available(OSX, unavailable)
+public protocol ListObjectObserver: ListObserver {
+    
+    /**
+     Notifies that an object was inserted to the specified `NSIndexPath` in the list
+     
+     - parameter monitor: the `ListMonitor` monitoring the list being observed
+     - parameter object: the entity type for the inserted object
+     - parameter indexPath: the new `NSIndexPath` for the inserted object
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didInsertObject object: ListEntityType, toIndexPath indexPath: NSIndexPath)
+    
+    /**
+     Notifies that an object was deleted from the specified `NSIndexPath` in the list
+     
+     - parameter monitor: the `ListMonitor` monitoring the list being observed
+     - parameter object: the entity type for the deleted object
+     - parameter indexPath: the `NSIndexPath` for the deleted object
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didDeleteObject object: ListEntityType, fromIndexPath indexPath: NSIndexPath)
+    
+    /**
+     Notifies that an object at the specified `NSIndexPath` was updated
+     
+     - parameter monitor: the `ListMonitor` monitoring the list being observed
+     - parameter object: the entity type for the updated object
+     - parameter indexPath: the `NSIndexPath` for the updated object
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didUpdateObject object: ListEntityType, atIndexPath indexPath: NSIndexPath)
+    
+    /**
+     Notifies that an object's index changed
+     
+     - parameter monitor: the `ListMonitor` monitoring the list being observed
+     - parameter object: the entity type for the moved object
+     - parameter fromIndexPath: the previous `NSIndexPath` for the moved object
+     - parameter toIndexPath: the new `NSIndexPath` for the moved object
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didMoveObject object: ListEntityType, fromIndexPath: NSIndexPath, toIndexPath: NSIndexPath)
+}
+
+
+// MARK: - ListObjectObserver (Default Implementations)
+
+@available(OSX, unavailable)
+public extension ListObjectObserver {
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didInsertObject object: ListEntityType, toIndexPath indexPath: NSIndexPath) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didDeleteObject object: ListEntityType, fromIndexPath indexPath: NSIndexPath) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didUpdateObject object: ListEntityType, atIndexPath indexPath: NSIndexPath) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didMoveObject object: ListEntityType, fromIndexPath: NSIndexPath, toIndexPath: NSIndexPath) { }
+}
+
+
+// MARK: - ListSectionObserver
+
+/**
+ Implement the `ListSectionObserver` protocol to observe changes to a list's section info. `ListSectionObserver`s may register themselves to a `ListMonitor`'s `addObserver(_:)` method:
+ ```
+ let monitor = CoreStore.monitorSectionedList(
+     From(MyPersonEntity),
+     SectionBy("age") { "Age \($0)" },
+     OrderBy(.Ascending("lastName"))
+ )
+ monitor.addObserver(self)
+ ```
+ */
+@available(OSX, unavailable)
+public protocol ListSectionObserver: ListObjectObserver {
+    
+    /**
+     Notifies that a section was inserted at the specified index
+     
+     - parameter monitor: the `ListMonitor` monitoring the list being observed
+     - parameter sectionInfo: the `NSFetchedResultsSectionInfo` for the inserted section
+     - parameter sectionIndex: the new section index for the new section
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didInsertSection sectionInfo: NSFetchedResultsSectionInfo, toSectionIndex sectionIndex: Int)
+    
+    /**
+     Notifies that a section was inserted at the specified index
+     
+     - parameter monitor: the `ListMonitor` monitoring the list being observed
+     - parameter sectionInfo: the `NSFetchedResultsSectionInfo` for the deleted section
+     - parameter sectionIndex: the previous section index for the deleted section
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didDeleteSection sectionInfo: NSFetchedResultsSectionInfo, fromSectionIndex sectionIndex: Int)
+}
+
+
+// MARK: - ListSectionObserver (Default Implementations)
+
+@available(OSX, unavailable)
+public extension ListSectionObserver {
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didInsertSection sectionInfo: NSFetchedResultsSectionInfo, toSectionIndex sectionIndex: Int) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func listMonitor(monitor: ListMonitor<ListEntityType>, didDeleteSection sectionInfo: NSFetchedResultsSectionInfo, fromSectionIndex sectionIndex: Int) { }
+}

Sources/Observing/ObjectMonitor.swift

@@ -0,0 +1,330 @@
+//
+//  ObjectMonitor.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
+#if USE_FRAMEWORKS
+    import GCDKit
+#endif
+
+
+// MARK: - ObjectMonitor
+
+/**
+ The `ObjectMonitor` monitors changes to a single `NSManagedObject` instance. Observers that implement the `ObjectObserver` protocol may then register themselves to the `ObjectMonitor`'s `addObserver(_:)` method:
+ ```
+ let monitor = CoreStore.monitorObject(object)
+ monitor.addObserver(self)
+ ```
+ The created `ObjectMonitor` instance needs to be held on (retained) for as long as the object needs to be observed.
+ 
+ Observers registered via `addObserver(_:)` are not retained. `ObjectMonitor` only keeps a `weak` reference to all observers, thus keeping itself free from retain-cycles.
+ */
+@available(OSX, unavailable)
+public final class ObjectMonitor<T: NSManagedObject> {
+    
+    /**
+     Returns the `NSManagedObject` instance being observed, or `nil` if the object was already deleted.
+     */
+    public var object: T? {
+        
+        return self.fetchedResultsController.fetchedObjects?.first as? T
+    }
+    
+    /**
+     Returns `true` if the `NSManagedObject` instance being observed still exists, or `false` if the object was already deleted.
+     */
+    public var isObjectDeleted: Bool {
+        
+        return self.object?.managedObjectContext == nil
+    }
+    
+    /**
+     Registers an `ObjectObserver` to be notified when changes to the receiver's `object` are made.
+     
+     To prevent retain-cycles, `ObjectMonitor` only keeps `weak` references to its observers.
+     
+     For thread safety, this method needs to be called from the main thread. An assertion failure will occur (on debug builds only) if called from any thread other than the main thread.
+     
+     Calling `addObserver(_:)` multiple times on the same observer is safe, as `ObjectMonitor` unregisters previous notifications to the observer before re-registering them.
+     
+     - parameter observer: an `ObjectObserver` to send change notifications to
+     */
+    public func addObserver<U: ObjectObserver where U.ObjectEntityType == T>(observer: U) {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to add an observer of type \(typeName(observer)) outside the main thread."
+        )
+        
+        self.removeObserver(observer)
+        
+        self.registerChangeNotification(
+            &self.willChangeObjectKey,
+            name: ObjectMonitorWillChangeObjectNotification,
+            toObserver: observer,
+            callback: { [weak observer] (monitor) -> Void in
+                
+                guard let object = monitor.object, let observer = observer else {
+                    
+                    return
+                }
+                observer.objectMonitor(monitor, willUpdateObject: object)
+            }
+        )
+        self.registerObjectNotification(
+            &self.didDeleteObjectKey,
+            name: ObjectMonitorDidDeleteObjectNotification,
+            toObserver: observer,
+            callback: { [weak observer] (monitor, object) -> Void in
+                
+                guard let observer = observer else {
+                    
+                    return
+                }
+                observer.objectMonitor(monitor, didDeleteObject: object)
+            }
+        )
+        self.registerObjectNotification(
+            &self.didUpdateObjectKey,
+            name: ObjectMonitorDidUpdateObjectNotification,
+            toObserver: observer,
+            callback: { [weak self, weak observer] (monitor, object) -> Void in
+                
+                guard let `self` = self, let observer = observer else {
+                    
+                    return
+                }
+                
+                let previousCommitedAttributes = self.lastCommittedAttributes
+                let currentCommitedAttributes = object.committedValuesForKeys(nil) as! [String: NSObject]
+                
+                var changedKeys = Set<String>()
+                for key in currentCommitedAttributes.keys {
+                    
+                    if previousCommitedAttributes[key] != currentCommitedAttributes[key] {
+                        
+                        changedKeys.insert(key)
+                    }
+                }
+                
+                self.lastCommittedAttributes = currentCommitedAttributes
+                observer.objectMonitor(
+                    monitor,
+                    didUpdateObject: object,
+                    changedPersistentKeys: changedKeys
+                )
+            }
+        )
+    }
+    
+    /**
+     Unregisters an `ObjectObserver` from receiving notifications for changes to the receiver's `object`.
+     
+     For thread safety, this method needs to be called from the main thread. An assertion failure will occur (on debug builds only) if called from any thread other than the main thread.
+     
+     - parameter observer: an `ObjectObserver` to unregister notifications to
+     */
+    public func removeObserver<U: ObjectObserver where U.ObjectEntityType == T>(observer: U) {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to remove an observer of type \(typeName(observer)) outside the main thread."
+        )
+        
+        let nilValue: AnyObject? = nil
+        setAssociatedRetainedObject(nilValue, forKey: &self.willChangeObjectKey, inObject: observer)
+        setAssociatedRetainedObject(nilValue, forKey: &self.didDeleteObjectKey, inObject: observer)
+        setAssociatedRetainedObject(nilValue, forKey: &self.didUpdateObjectKey, inObject: observer)
+    }
+    
+    
+    // MARK: Internal
+    
+    internal convenience init(dataStack: DataStack, object: T) {
+        
+        self.init(context: dataStack.mainContext, object: object)
+    }
+    
+    internal convenience init(unsafeTransaction: UnsafeDataTransaction, object: T) {
+        
+        self.init(context: unsafeTransaction.context, object: object)
+    }
+    
+    private init(context: NSManagedObjectContext, object: T) {
+        
+        let fetchRequest = NSFetchRequest()
+        fetchRequest.entity = object.entity
+        fetchRequest.fetchLimit = 0
+        fetchRequest.resultType = .ManagedObjectResultType
+        fetchRequest.sortDescriptors = []
+        fetchRequest.includesPendingChanges = false
+        fetchRequest.shouldRefreshRefetchedObjects = true
+        
+        let fetchedResultsController = CoreStoreFetchedResultsController<T>(
+            context: context,
+            fetchRequest: fetchRequest,
+            fetchClauses: [Where("SELF", isEqualTo: object.objectID)]
+        )
+        
+        let fetchedResultsControllerDelegate = FetchedResultsControllerDelegate()
+        
+        self.fetchedResultsController = fetchedResultsController
+        self.fetchedResultsControllerDelegate = fetchedResultsControllerDelegate
+        
+        fetchedResultsControllerDelegate.handler = self
+        fetchedResultsControllerDelegate.fetchedResultsController = fetchedResultsController
+        try! fetchedResultsController.performFetchFromSpecifiedStores()
+        
+        self.lastCommittedAttributes = (self.object?.committedValuesForKeys(nil) as? [String: NSObject]) ?? [:]
+    }
+    
+    deinit {
+        
+        self.fetchedResultsControllerDelegate.fetchedResultsController = nil
+    }
+    
+    
+    // MARK: Private
+    
+    private let fetchedResultsController: CoreStoreFetchedResultsController<T>
+    private let fetchedResultsControllerDelegate: FetchedResultsControllerDelegate
+    private var lastCommittedAttributes = [String: NSObject]()
+    
+    private var willChangeObjectKey: Void?
+    private var didDeleteObjectKey: Void?
+    private var didUpdateObjectKey: Void?
+    
+    private func registerChangeNotification(notificationKey: UnsafePointer<Void>, name: String, toObserver observer: AnyObject, callback: (monitor: ObjectMonitor<T>) -> Void) {
+        
+        setAssociatedRetainedObject(
+            NotificationObserver(
+                notificationName: name,
+                object: self,
+                closure: { [weak self] (note) -> Void in
+                    
+                    guard let `self` = self else {
+                        
+                        return
+                    }
+                    callback(monitor: self)
+                }
+            ),
+            forKey: notificationKey,
+            inObject: observer
+        )
+    }
+    
+    private func registerObjectNotification(notificationKey: UnsafePointer<Void>, name: String, toObserver observer: AnyObject, callback: (monitor: ObjectMonitor<T>, object: T) -> Void) {
+        
+        setAssociatedRetainedObject(
+            NotificationObserver(
+                notificationName: name,
+                object: self,
+                closure: { [weak self] (note) -> Void in
+                    
+                    guard let `self` = self,
+                        let userInfo = note.userInfo,
+                        let object = userInfo[UserInfoKeyObject] as? T else {
+                            
+                            return
+                    }
+                    callback(monitor: self, object: object)
+                }
+            ),
+            forKey: notificationKey,
+            inObject: observer
+        )
+    }
+}
+
+
+// MARK: - ObjectMonitor: Equatable
+
+@available(OSX, unavailable)
+public func ==<T: NSManagedObject>(lhs: ObjectMonitor<T>, rhs: ObjectMonitor<T>) -> Bool {
+    
+    return lhs === rhs
+}
+
+@available(OSX, unavailable)
+extension ObjectMonitor: Equatable { }
+
+
+// MARK: - ObjectMonitor: FetchedResultsControllerHandler
+
+@available(OSX, unavailable)
+extension ObjectMonitor: FetchedResultsControllerHandler {
+    
+    // MARK: FetchedResultsControllerHandler
+    
+    internal func controllerWillChangeContent(controller: NSFetchedResultsController) {
+        
+        NSNotificationCenter.defaultCenter().postNotificationName(
+            ObjectMonitorWillChangeObjectNotification,
+            object: self
+        )
+    }
+    
+    internal func controllerDidChangeContent(controller: NSFetchedResultsController) { }
+    
+    internal func controller(controller: NSFetchedResultsController, didChangeObject anObject: AnyObject, atIndexPath indexPath: NSIndexPath?, forChangeType type: NSFetchedResultsChangeType, newIndexPath: NSIndexPath?) {
+        
+        switch type {
+            
+        case .Delete:
+            NSNotificationCenter.defaultCenter().postNotificationName(
+                ObjectMonitorDidDeleteObjectNotification,
+                object: self,
+                userInfo: [UserInfoKeyObject: anObject]
+            )
+            
+        case .Update:
+            NSNotificationCenter.defaultCenter().postNotificationName(
+                ObjectMonitorDidUpdateObjectNotification,
+                object: self,
+                userInfo: [UserInfoKeyObject: anObject]
+            )
+            
+        default:
+            break
+        }
+    }
+    
+    internal func controller(controller: NSFetchedResultsController, didChangeSection sectionInfo: NSFetchedResultsSectionInfo, atIndex sectionIndex: Int, forChangeType type: NSFetchedResultsChangeType) { }
+    
+    internal func controller(controller: NSFetchedResultsController, sectionIndexTitleForSectionName sectionName: String?) -> String? {
+        
+        return sectionName
+    }
+}
+
+
+private let ObjectMonitorWillChangeObjectNotification = "ObjectMonitorWillChangeObjectNotification"
+private let ObjectMonitorDidDeleteObjectNotification = "ObjectMonitorDidDeleteObjectNotification"
+private let ObjectMonitorDidUpdateObjectNotification = "ObjectMonitorDidUpdateObjectNotification"
+
+private let UserInfoKeyObject = "UserInfoKeyObject"
+

Sources/Observing/ObjectObserver.swift

@@ -0,0 +1,93 @@
+//
+//  ObjectObserver.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: - ObjectObserver
+
+/**
+ Implement the `ObjectObserver` protocol to observe changes to a single `NSManagedObject` instance. `ObjectObserver`s may register themselves to a `ObjectMonitor`'s `addObserver(_:)` method:
+ ```
+ let monitor = CoreStore.monitorObject(object)
+ monitor.addObserver(self)
+ ```
+ */
+@available(OSX, unavailable)
+public protocol ObjectObserver: class {
+    
+    /**
+     The `NSManagedObject` type for the observed object
+     */
+    associatedtype ObjectEntityType: NSManagedObject
+    
+    /**
+     Handles processing just before a change to the observed `object` occurs
+     
+     - parameter monitor: the `ObjectMonitor` monitoring the object being observed
+     - parameter object: the `NSManagedObject` instance being observed
+     */
+    func objectMonitor(monitor: ObjectMonitor<ObjectEntityType>, willUpdateObject object: ObjectEntityType)
+    
+    /**
+     Handles processing right after a change to the observed `object` occurs
+     
+     - parameter monitor: the `ObjectMonitor` monitoring the object being observed
+     - parameter object: the `NSManagedObject` instance being observed
+     - parameter changedPersistentKeys: a `Set` of key paths for the attributes that were changed. Note that `changedPersistentKeys` only contains keys for attributes/relationships present in the persistent store, thus transient properties will not be reported.
+     */
+    func objectMonitor(monitor: ObjectMonitor<ObjectEntityType>, didUpdateObject object: ObjectEntityType, changedPersistentKeys: Set<KeyPath>)
+    
+    /**
+     Handles processing right after `object` is deleted
+     
+     - parameter monitor: the `ObjectMonitor` monitoring the object being observed
+     - parameter object: the `NSManagedObject` instance being observed
+     */
+    func objectMonitor(monitor: ObjectMonitor<ObjectEntityType>, didDeleteObject object: ObjectEntityType)
+}
+
+
+// MARK: - ObjectObserver (Default Implementations)
+
+@available(OSX, unavailable)
+public extension ObjectObserver {
+    
+    /**
+     The default implementation does nothing.
+     */
+    func objectMonitor(monitor: ObjectMonitor<ObjectEntityType>, willUpdateObject object: ObjectEntityType) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func objectMonitor(monitor: ObjectMonitor<ObjectEntityType>, didUpdateObject object: ObjectEntityType, changedPersistentKeys: Set<KeyPath>) { }
+    
+    /**
+     The default implementation does nothing.
+     */
+    func objectMonitor(monitor: ObjectMonitor<ObjectEntityType>, didDeleteObject object: ObjectEntityType) { }
+}

Sources/Observing/SectionBy.swift

@@ -0,0 +1,72 @@
+//
+//  SectionBy.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: - SectionBy
+
+/**
+ The `SectionBy` clause indicates the key path to use to group the `ListMonitor` objects into sections. An optional closure can also be provided to transform the value into an appropriate section name:
+ ```
+ let monitor = CoreStore.monitorSectionedList(
+     From(MyPersonEntity),
+     SectionBy("age") { "Age \($0)" },
+     OrderBy(.Ascending("lastName"))
+ )
+ ```
+ */
+@available(OSX, unavailable)
+public struct SectionBy {
+    
+    /**
+     Initializes a `SectionBy` clause with the key path to use to group `ListMonitor` objects into sections
+     
+     - parameter sectionKeyPath: the key path to use to group the objects into sections
+     */
+    public init(_ sectionKeyPath: KeyPath) {
+        
+        self.init(sectionKeyPath, { $0 })
+    }
+    
+    /**
+     Initializes a `SectionBy` clause with the key path to use to group `ListMonitor` objects into sections, and a closure to transform the value for the key path to an appropriate section name
+     
+     - parameter sectionKeyPath: the key path to use to group the objects into sections
+     - parameter sectionIndexTransformer: a closure to transform the value for the key path to an appropriate section name
+     */
+    public init(_ sectionKeyPath: KeyPath, _ sectionIndexTransformer: (sectionName: String?) -> String?) {
+        
+        self.sectionKeyPath = sectionKeyPath
+        self.sectionIndexTransformer = sectionIndexTransformer
+    }
+    
+    
+    // MARK: Internal
+    
+    internal let sectionKeyPath: KeyPath
+    internal let sectionIndexTransformer: (sectionName: KeyPath?) -> String?
+}

Sources/Observing/UnsafeDataTransaction+Observing.swift

@@ -0,0 +1,198 @@
+//
+//  UnsafeDataTransaction+Observing.swift
+//  CoreStore
+//
+//  Copyright © 2016 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
+#if USE_FRAMEWORKS
+    import GCDKit
+#endif
+
+
+// MARK: - UnsafeDataTransaction
+
+@available(OSX, unavailable)
+public extension UnsafeDataTransaction {
+    
+    /**
+     Creates a `ObjectMonitor` for the specified `NSManagedObject`. Multiple `ObjectObserver`s may then register themselves to be notified when changes are made to the `NSManagedObject`.
+     
+     - parameter object: the `NSManagedObject` to observe changes from
+     - returns: a `ObjectMonitor` that monitors changes to `object`
+     */
+    @warn_unused_result
+    public func monitorObject<T: NSManagedObject>(object: T) -> ObjectMonitor<T> {
+        
+        return ObjectMonitor(
+            unsafeTransaction: self,
+            object: object
+        )
+    }
+    
+    /**
+     Creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorList<T: NSManagedObject>(from: From<T>, _ fetchClauses: FetchClause...) -> ListMonitor<T> {
+        
+        return self.monitorList(from, fetchClauses)
+    }
+    
+    /**
+     Creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorList<T: NSManagedObject>(from: From<T>, _ fetchClauses: [FetchClause]) -> ListMonitor<T> {
+        
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        return ListMonitor(
+            unsafeTransaction: self,
+            from: from,
+            sectionBy: nil,
+            fetchClauses: fetchClauses
+        )
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ fetchClauses: FetchClause...) {
+        
+        self.monitorList(createAsynchronously: createAsynchronously, from, fetchClauses)
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ fetchClauses: [FetchClause])  {
+        
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        _ = ListMonitor(
+            unsafeTransaction: self,
+            from: from,
+            sectionBy: nil,
+            fetchClauses: fetchClauses,
+            createAsynchronously: createAsynchronously
+        )
+    }
+    
+    /**
+     Creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorSectionedList<T: NSManagedObject>(from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: FetchClause...) -> ListMonitor<T> {
+        
+        return self.monitorSectionedList(from, sectionBy, fetchClauses)
+    }
+    
+    /**
+     Creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     - returns: a `ListMonitor` instance that monitors changes to the list
+     */
+    @warn_unused_result
+    public func monitorSectionedList<T: NSManagedObject>(from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: [FetchClause]) -> ListMonitor<T> {
+        
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        return ListMonitor(
+            unsafeTransaction: self,
+            from: from,
+            sectionBy: sectionBy,
+            fetchClauses: fetchClauses
+        )
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorSectionedList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: FetchClause...) {
+        
+        self.monitorSectionedList(createAsynchronously: createAsynchronously, from, sectionBy, fetchClauses)
+    }
+    
+    /**
+     Asynchronously creates a `ListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `ListMonitor` instance
+     - parameter from: a `From` clause indicating the entity type
+     - parameter sectionBy: a `SectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses.
+     */
+    public func monitorSectionedList<T: NSManagedObject>(createAsynchronously createAsynchronously: (ListMonitor<T>) -> Void, _ from: From<T>, _ sectionBy: SectionBy, _ fetchClauses: [FetchClause]) {
+        
+        CoreStore.assert(
+            fetchClauses.filter { $0 is OrderBy }.count > 0,
+            "A ListMonitor requires an OrderBy clause."
+        )
+        
+        _ = ListMonitor(
+            unsafeTransaction: self,
+            from: from,
+            sectionBy: sectionBy,
+            fetchClauses: fetchClauses,
+            createAsynchronously: createAsynchronously
+        )
+    }
+}