     }
     public var sectionNameKeyPath: String?
     public var cacheName: String?
-    public let managedObjectContext:NSManagedObjectContext
-    public private(set) var presenter:TableViewCellPresenter<CellType, EntityType>
-    public let logger:Logger
-    
+    public let managedObjectContext: NSManagedObjectContext
+    public private(set) var presenter: TableViewCellPresenter<CellType, EntityType>
+    public let logger: Logger
+
+
     // MARK: - Initialization
-    
-    public init(targetingTableView tableView:UITableView,
-         presenter:TableViewCellPresenter<CellType, EntityType>,
+
+    public init(targetingTableView tableView: UITableView,
+        presenter: TableViewCellPresenter<CellType, EntityType>,
          entityName: String,
          sortDescriptors: [NSSortDescriptor],
-         managedObjectContext context:NSManagedObjectContext,
-         logger:Logger) {
-    
+         managedObjectContext context: NSManagedObjectContext,
+         logger: Logger) {
+
         self.tableView = tableView
         self.presenter = presenter
         self.entityName = entityName


    public func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        let value = self.objectAtIndexPath(indexPath)
        
        let reuseIdentifier = self.presenter.cellReuseIdentifier
        let cell = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier, forIndexPath: indexPath) as! CellType

        self.presenter.configureCellBlock(cell, value)
        
        return cell
    }
    
    public func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
        
        if let editRowBlock = self.presenter.canEditRowAtIndexPathBlock {
            return editRowBlock(indexPath: indexPath)
        }
        
        return false
    }

    public func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
     
        if let commitEditingBlock = self.presenter.commitEditingStyleBlock {
            commitEditingBlock(editingStyle: editingStyle, forRowAtIndexPath: indexPath)
        }
        
    }
    
    // MARK: - Fetched results controller
    
    public var fetchedResultsController: NSFetchedResultsController {
        
        if _fetchedResultsController != nil {
            return _fetchedResultsController!
        }
        
        let fetchRequest = NSFetchRequest()
        let entity = NSEntityDescription.entityForName(self.entityName, inManagedObjectContext: self.managedObjectContext)
        fetchRequest.entity = entity
        
        fetchRequest.predicate = self.predicate
        
        if let fetchLimit = self.fetchLimit where fetchLimit > 0 {
            fetchRequest.fetchLimit = fetchLimit
        }
        
        fetchRequest.fetchBatchSize = 100
        fetchRequest.sortDescriptors = self.sortDescriptors

        let aFetchedResultsController = NSFetchedResultsController(fetchRequest: fetchRequest, managedObjectContext: self.managedObjectContext, sectionNameKeyPath: self.sectionNameKeyPath, cacheName: self.cacheName)
        aFetchedResultsController.delegate = self
        _fetchedResultsController = aFetchedResultsController
        
        return _fetchedResultsController!
    }
    public var _fetchedResultsController: NSFetchedResultsController? = nil
    
    public func controllerWillChangeContent(controller: NSFetchedResultsController) {
        self.tableView.beginUpdates()
    }

import York_Swift_Try_Catch

public class FetcherDataSource<CellType: UITableViewCell, EntityType: NSManagedObject>: NSObject, NSFetchedResultsControllerDelegate, UITableViewDataSource {

    // MARK: - Properties

    public let tableView: UITableView
    public private(set) var entityName: String
    public var predicate: NSPredicate? {
        didSet {
