appjam 0.1.8.8 → 0.1.8.9

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/components/UIGlossyButton/UIView+LayerEffects.h

@@ -0,0 +1,22 @@
+//
+//  UIView+ExtraAnimation.h
+//
+//  Created by Water Lou on 15/09/2010.
+//  Copyright 2010 First Water Tech Ltd. All rights reserved.
+// 
+//  many visual effects and animation effects create using CoreAnimation and CALayer
+//
+
+#import <Foundation/Foundation.h>
+
+@interface UIView(LayerEffects)
+
+// set round corner
+- (void) setCornerRadius : (CGFloat) radius;
+// set inner border
+- (void) setBorder : (UIColor *) color width : (CGFloat) width;
+// set the shadow
+// Example: [view setShadow:[UIColor blackColor] opacity:0.5 offset:CGSizeMake(1.0, 1.0) blueRadius:3.0];
+- (void) setShadow : (UIColor *)color opacity:(CGFloat)opacity offset:(CGSize) offset blurRadius:(CGFloat)blurRadius;
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/components/UIGlossyButton/UIView+LayerEffects.m

@@ -0,0 +1,32 @@
+//
+//  UIView+LayerEffects.m
+//
+//  Created by Water Lou on 15/09/2010.
+//  Copyright 2010 First Water Tech Ltd. All rights reserved.
+//
+
+#import <QuartzCore/QuartzCore.h>
+#import "UIView+LayerEffects.h"
+
+@implementation UIView(LayerEffects)
+
+/* simple setting using the layer */
+- (void) setCornerRadius : (CGFloat) radius {
+	self.layer.cornerRadius = radius;
+}
+
+- (void) setBorder : (UIColor *) color width : (CGFloat) width  {
+	self.layer.borderColor = [color CGColor];
+	self.layer.borderWidth = width;
+}
+
+- (void) setShadow : (UIColor *)color opacity:(CGFloat)opacity offset:(CGSize)offset blurRadius:(CGFloat)blurRadius {
+	CALayer *l = self.layer;
+	l.shadowColor = [color CGColor];
+	l.shadowOpacity = opacity;
+	l.shadowOffset = offset;
+	l.shadowRadius = blurRadius;
+}
+
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/AFIncrementalStore/AFIncrementalStore.h

@@ -0,0 +1,344 @@
+// AFIncrementalStore.h
+//
+// Copyright (c) 2012 Mattt Thompson (http://mattt.me)
+// 
+// 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 <CoreData/CoreData.h>
+#import "AFNetworking.h"
+
+@protocol AFIncrementalStoreHTTPClient;
+
+/**
+ `AFIncrementalStore` is an abstract subclass of `NSIncrementalStore`, designed to allow you to load and save data incrementally to and from a one or more web services.
+ 
+ ## Subclassing Notes
+ 
+ ### Methods to Override
+ 
+ In a subclass of `AFIncrementalStore`, you _must_ override the following methods to provide behavior appropriate for your store:
+    
+    - `+type`
+    - `+model`
+ 
+ Additionally, all `NSPersistentStore` subclasses, and thus all `AFIncrementalStore` subclasses must do `NSPersistentStoreCoordinator +registerStoreClass:forStoreType:` in order to be created by `NSPersistentStoreCoordinator -addPersistentStoreWithType:configuration:URL:options:error:`. It is recommended that subclasses register themselves in their own `+initialize` method.
+ 
+ Optionally, `AFIncrementalStore` subclasses can override the following methods:
+ 
+    - `-executeFetchRequest:withContext:error:`
+    - `-executeSaveChangesRequest:withContext:error:`
+
+ ### Methods Not To Be Overridden
+ 
+ Subclasses should not override `-executeRequest:withContext:error`. Instead, override `-executeFetchRequest:withContext:error:` or `-executeSaveChangesRequest:withContext:error:`, which are called by `-executeRequest:withContext:error` depending on the type of persistent store request.
+ */
+@interface AFIncrementalStore : NSIncrementalStore
+
+///---------------------------------------------
+/// @name Accessing Incremental Store Properties
+///---------------------------------------------
+
+/**
+ The HTTP client used to manage requests and responses with the associated web services.
+ */
+@property (nonatomic, strong) AFHTTPClient <AFIncrementalStoreHTTPClient> *HTTPClient;
+
+/**
+ The persistent store coordinator used to persist data from the associated web serivices locally.
+ 
+ @discussion Rather than persist values directly, `AFIncrementalStore` manages and proxies through a persistent store coordinator.
+ */
+@property (readonly) NSPersistentStoreCoordinator *backingPersistentStoreCoordinator;
+
+///-----------------------
+/// @name Required Methods
+///-----------------------
+
+/**
+ Returns the string used as the `NSStoreTypeKey` value by the application's persistent store coordinator.
+ 
+ @return The string used to describe the type of the store.
+ */
++ (NSString *)type;
+
+/**
+ Returns the managed object model used by the store.
+ 
+ @return The managed object model used by the store
+ */
++ (NSManagedObjectModel *)model;
+
+///-----------------------
+/// @name Optional Methods
+///-----------------------
+
+/**
+ 
+ */
+- (id)executeFetchRequest:(NSFetchRequest *)fetchRequest
+              withContext:(NSManagedObjectContext *)context
+                    error:(NSError *__autoreleasing *)error;
+
+/**
+ 
+ */
+- (id)executeSaveChangesRequest:(NSSaveChangesRequest *)saveChangesRequest
+                    withContext:(NSManagedObjectContext *)context
+                          error:(NSError *__autoreleasing *)error;
+
+@end
+
+#pragma mark -
+
+/**
+ The `AFIncrementalStoreHTTPClient` protocol defines the methods used by the HTTP client to interract with the associated web services of an `AFIncrementalStore`.
+ */
+@protocol AFIncrementalStoreHTTPClient <NSObject>
+
+///-----------------------
+/// @name Required Methods
+///-----------------------
+
+/**
+ Returns an `NSDictionary` or an `NSArray` of `NSDictionaries` containing the representations of the resources found in a response object.
+ 
+ @discussion For example, if `GET /users` returned an `NSDictionary` with an array of users keyed on `"users"`, this method would return the keyed array. Conversely, if `GET /users/123` returned a dictionary with all of the atributes of the requested user, this method would simply return that dictionary.
+
+ @param entity The entity represented
+ @param responseObject The response object returned from the server.
+ 
+ @return An `NSDictionary` with the representation or an `NSArray` of `NSDictionaries` containing the resource representations.
+ */
+- (id)representationOrArrayOfRepresentationsOfEntity:(NSEntityDescription *)entity
+                                  fromResponseObject:(id)responseObject;
+
+/**
+ Returns an `NSDictionary` containing the representations of associated objects found within the representation of a response object, keyed by their relationship name.
+ 
+ @discussion For example, if `GET /albums/123` returned the representation of an album, including the tracks as sub-entities, keyed under `"tracks"`, this method would return a dictionary with an array of representations for those objects, keyed under the name of the relationship used in the model (which is likely also to be `"tracks"`). Likewise, if an album also contained a representation of its artist, that dictionary would contain a dictionary representation of that artist, keyed under the name of the relationship used in the model (which is likely also to be `"artist"`).
+ 
+ @param representation The resource representation.
+ @param entity The entity for the representation.
+ @param response The HTTP response for the resource request.
+ 
+ @return An `NSDictionary` containing representations of relationships, keyed by relationship name.
+ */
+- (NSDictionary *)representationsForRelationshipsFromRepresentation:(NSDictionary *)representation
+                                                           ofEntity:(NSEntityDescription *)entity
+                                                       fromResponse:(NSHTTPURLResponse *)response;
+
+/**
+ Returns the resource identifier for the resource whose representation of an entity came from the specified HTTP response. A resource identifier is a string that uniquely identifies a particular resource among all resource types. If new attributes come back for an existing resource identifier, the managed object associated with that resource identifier will be updated, rather than a new object being created.
+ 
+ @discussion For example, if `GET /posts` returns a collection of posts, the resource identifier for any particular one might be its URL-safe "slug" or parameter string, or perhaps its numeric id.  For example: `/posts/123` might be a resource identifier for a particular post.
+ 
+ @param representation The resource representation.
+ @param entity The entity for the representation.
+ @param response The HTTP response for the resource request.
+ 
+ @return An `NSString` resource identifier for the resource.
+ */
+- (NSString *)resourceIdentifierForRepresentation:(NSDictionary *)representation
+                                         ofEntity:(NSEntityDescription *)entity
+                                     fromResponse:(NSHTTPURLResponse *)response;
+
+/**
+ Returns the attributes for the managed object corresponding to the representation of an entity from the specified response. This method is used to get the attributes of the managed object from its representation returned in `-representationOrArrayOfRepresentationsFromResponseObject` or `representationsForRelationshipsFromRepresentation:ofEntity:fromResponse:`.
+ 
+ @discussion For example, if the representation returned from `GET /products/123` had a `description` field that corresponded with the `productDescription` attribute in its Core Data model, this method would set the value of the `productDescription` key in the returned dictionary to the value of the `description` field in representation.
+ 
+ @param representation The resource representation.
+ @param entity The entity for the representation.
+ @param response The HTTP response for the resource request.
+ 
+ @return An `NSDictionary` containing the attributes for a managed object. 
+ */
+- (NSDictionary *)attributesForRepresentation:(NSDictionary *)representation
+                                     ofEntity:(NSEntityDescription *)entity
+                                 fromResponse:(NSHTTPURLResponse *)response;
+
+/**
+ Returns a URL request object for the specified fetch request within a particular managed object context.
+ 
+ @discussion For example, if the fetch request specified the `User` entity, this method might return an `NSURLRequest` with `GET /users` if the web service was RESTful, `POST /endpoint?method=users.getAll` for an RPC-style system, or a request with an XML envelope body for a SOAP webservice.
+ 
+ @param fetchRequest The fetch request to translate into a URL request.
+ @param context The managed object context executing the fetch request.
+ 
+ @return An `NSURLRequest` object corresponding to the specified fetch request.
+ */
+- (NSMutableURLRequest *)requestForFetchRequest:(NSFetchRequest *)fetchRequest
+                                    withContext:(NSManagedObjectContext *)context;
+
+/**
+ Returns a URL request object with a given HTTP method for a particular managed object. This method is used in `AFIncrementalStore -newValuesForObjectWithID:withContext:error`.
+ 
+ @discussion For example, if a `User` managed object were to be refreshed, this method might return a `GET /users/123` request.
+ 
+ @param method The HTTP method of the request.
+ @param objectID The object ID for the specified managed object.
+ @param context The managed object context for the managed object.
+ 
+ @return An `NSURLRequest` object with the provided HTTP method for the resource corresponding to the managed object.
+ */
+- (NSMutableURLRequest *)requestWithMethod:(NSString *)method
+                       pathForObjectWithID:(NSManagedObjectID *)objectID
+                               withContext:(NSManagedObjectContext *)context;
+
+/**
+ Returns a URL request object with a given HTTP method for a particular relationship of a given managed object. This method is used in `AFIncrementalStore -newValueForRelationship:forObjectWithID:withContext:error:`.
+ 
+ @discussion For example, if a `Department` managed object was attempting to fulfill a fault on the `employees` relationship, this method might return `GET /departments/sales/employees`.
+ 
+ @param method The HTTP method of the request.
+ @param relationship The relationship of the specifified managed object 
+ @param objectID The object ID for the specified managed object.
+ @param context The managed object context for the managed object.
+ 
+ @return An `NSURLRequest` object with the provided HTTP method for the resource or resoures corresponding to the relationship of the managed object.
+
+ */
+- (NSMutableURLRequest *)requestWithMethod:(NSString *)method
+                       pathForRelationship:(NSRelationshipDescription *)relationship
+                           forObjectWithID:(NSManagedObjectID *)objectID
+                               withContext:(NSManagedObjectContext *)context;
+
+@optional
+
+///-----------------------
+/// @name Optional Methods
+///-----------------------
+
+/**
+ Returns the attributes representation of an entity from the specified managed object. This method is used to get the attributes of the representation from its managed object.
+ 
+ @discussion For example, if the representation sent to `POST /products` or `PUT /products/123` had a `description` field that corresponded with the `productDescription` attribute in its Core Data model, this method would set the value of the `productDescription` field to the value of the `description` key in representation/dictionary.
+ 
+ @param attributes The resource representation.
+ @param managedObject The `NSManagedObject` for the representation.
+ 
+ @return An `NSDictionary` containing the attributes for a representation, based on the given managed object. 
+ */
+- (NSDictionary *)representationOfAttributes:(NSDictionary *)attributes
+                             ofManagedObject:(NSManagedObject *)managedObject;
+
+/**
+ 
+ */
+- (NSMutableURLRequest *)requestForInsertedObject:(NSManagedObject *)insertedObject;
+
+/**
+ 
+ */
+- (NSMutableURLRequest *)requestForUpdatedObject:(NSManagedObject *)updatedObject;
+
+/**
+ 
+ */
+- (NSMutableURLRequest *)requestForDeletedObject:(NSManagedObject *)deletedObject;
+
+/**
+ Returns whether the client should fetch remote attribute values for a particular managed object. This method is consulted when a managed object faults on an attribute, and will call `-requestWithMethod:pathForObjectWithID:withContext:` if `YES`.
+ 
+ @param objectID The object ID for the specified managed object.
+ @param context The managed object context for the managed object.
+ 
+ @return `YES` if an HTTP request should be made, otherwise `NO.
+ */
+- (BOOL)shouldFetchRemoteAttributeValuesForObjectWithID:(NSManagedObjectID *)objectID
+                                 inManagedObjectContext:(NSManagedObjectContext *)context;
+
+/**
+ Returns whether the client should fetch remote relationship values for a particular managed object. This method is consulted when a managed object faults on a particular relationship, and will call `-requestWithMethod:pathForRelationship:forObjectWithID:withContext:` if `YES`.
+ 
+ @param relationship The relationship of the specifified managed object
+ @param objectID The object ID for the specified managed object.
+ @param context The managed object context for the managed object.
+ 
+ @return `YES` if an HTTP request should be made, otherwise `NO.
+ */
+- (BOOL)shouldFetchRemoteValuesForRelationship:(NSRelationshipDescription *)relationship
+                               forObjectWithID:(NSManagedObjectID *)objectID
+                        inManagedObjectContext:(NSManagedObjectContext *)context;
+
+@end
+
+///----------------
+/// @name Functions
+///----------------
+
+/** 
+ There is a bug in Core Data wherein managed object IDs whose reference object is a string beginning with a digit will incorrectly strip any subsequent non-numeric characters from the reference object. This breaks any functionality related to URI representations of the managed object ID, and likely other methods as well. For example, an object ID with a reference object of @"123ABC" would generate one with a URI represenation `coredata://store-UUID/Entity/123`, rather than the expected `coredata://store-UUID/Entity/123ABC`. As a fix, rather than resource identifiers being used directly as reference objects, they are prepended with a non-numeric constant first.
+ 
+ Thus, in order to get the resource identifier of a managed object's reference object, you must use the function `AFResourceIdentifierFromReferenceObject()`.
+    
+ See https://github.com/AFNetworking/AFIncrementalStore/issues/82 for more details.
+ */
+extern NSString * AFReferenceObjectFromResourceIdentifier(NSString *resourceIdentifier);
+
+extern NSString * AFResourceIdentifierFromReferenceObject(id referenceObject);
+
+///----------------
+/// @name Constants
+///----------------
+
+/**
+ The name of the exception called when `AFIncrementalStore` or a subclass is attempted to be used, without implementing one of the required methods.
+ */
+extern NSString * const AFIncrementalStoreUnimplementedMethodException;
+
+///--------------------
+/// @name Notifications
+///--------------------
+
+/**
+ Posted before an HTTP request operation starts. 
+ The object is the managed object context of the request.
+ The notification `userInfo` contains the finished request operation, keyed at `AFIncrementalStoreRequestOperationKey`, as well as the associated persistent store request, if applicable, keyed at `AFIncrementalStorePersistentStoreRequestKey`.
+ */
+extern NSString * const AFIncrementalStoreContextWillFetchRemoteValues;
+
+/**
+ 
+ */
+extern NSString * const AFIncrementalStoreContextWillSaveRemoteValues;
+
+/**
+ Posted after an HTTP request operation finishes. 
+ The object is the managed object context of the request. 
+ The notification `userInfo` contains the finished request operation, keyed at `AFIncrementalStoreRequestOperationKey`, as well as the associated persistent store request, if applicable, keyed at `AFIncrementalStorePersistentStoreRequestKey`.
+ */
+extern NSString * const AFIncrementalStoreContextDidFetchRemoteValues;
+
+/**
+ 
+ */
+extern NSString * const AFIncrementalStoreContextDidSaveRemoteValues;
+
+/**
+ A key in the `userInfo` dictionary in a `AFIncrementalStoreContextWillFetchRemoteValues` or `AFIncrementalStoreContextDidFetchRemoteValues` notification.
+ The corresponding value is an `AFHTTPRequestOperation` object representing the associated request. */
+extern NSString * const AFIncrementalStoreRequestOperationKey;
+
+/**
+ A key in the `userInfo` dictionary in a `AFIncrementalStoreContextWillFetchRemoteValues` or `AFIncrementalStoreContextDidFetchRemoteValues` notification.
+ The corresponding value is an `NSPersistentStoreRequest` object representing the associated fetch or save request. */
+extern NSString * const AFIncrementalStorePersistentStoreRequestKey;
+
+extern NSString * const AFIncrementalStoreFetchedObjectsKey;

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/AFIncrementalStore/AFIncrementalStore.m

@@ -0,0 +1,848 @@
+// AFIncrementalStore.m
+//
+// Copyright (c) 2012 Mattt Thompson (http://mattt.me)
+//
+// 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 "AFIncrementalStore.h"
+#import "AFHTTPClient.h"
+#import <objc/runtime.h>
+
+NSString * const AFIncrementalStoreUnimplementedMethodException = @"com.alamofire.incremental-store.exceptions.unimplemented-method";
+
+NSString * const AFIncrementalStoreContextWillFetchRemoteValues = @"AFIncrementalStoreContextWillFetchRemoteValues";
+NSString * const AFIncrementalStoreContextWillSaveRemoteValues = @"AFIncrementalStoreContextWillSaveRemoteValues";
+NSString * const AFIncrementalStoreContextDidFetchRemoteValues = @"AFIncrementalStoreContextDidFetchRemoteValues";
+NSString * const AFIncrementalStoreContextDidSaveRemoteValues = @"AFIncrementalStoreContextDidSaveRemoteValues";
+NSString * const AFIncrementalStoreRequestOperationKey = @"AFIncrementalStoreRequestOperation";
+NSString * const AFIncrementalStorePersistentStoreRequestKey = @"AFIncrementalStorePersistentStoreRequest";
+NSString * const AFIncrementalStoreFetchedObjectsKey = @"AFIncrementalStoreFetchedObjectsKey";
+
+static char kAFResourceIdentifierObjectKey;
+
+static NSString * const kAFIncrementalStoreResourceIdentifierAttributeName = @"__af_resourceIdentifier";
+static NSString * const kAFIncrementalStoreLastModifiedAttributeName = @"__af_lastModified";
+
+static NSString * const kAFReferenceObjectPrefix = @"__af_";
+
+inline NSString * AFReferenceObjectFromResourceIdentifier(NSString *resourceIdentifier) {
+    if (!resourceIdentifier) {
+        return nil;
+    }
+    
+    return [kAFReferenceObjectPrefix stringByAppendingString:resourceIdentifier];    
+}
+
+inline NSString * AFResourceIdentifierFromReferenceObject(id referenceObject) {
+    if (!referenceObject) {
+        return nil;
+    }
+    
+    NSString *string = [referenceObject description];
+    return [string hasPrefix:kAFReferenceObjectPrefix] ? [string substringFromIndex:[kAFReferenceObjectPrefix length]] : string;
+}
+
+@interface NSManagedObject (_AFIncrementalStore)
+@property (readwrite, nonatomic, copy, setter = af_setResourceIdentifier:) NSString *af_resourceIdentifier;
+@end
+
+@implementation NSManagedObject (_AFIncrementalStore)
+@dynamic af_resourceIdentifier;
+
+- (NSString *)af_resourceIdentifier {
+    NSString *identifier = (NSString *)objc_getAssociatedObject(self, &kAFResourceIdentifierObjectKey);
+    
+    if (!identifier) {
+        if ([self.objectID.persistentStore isKindOfClass:[AFIncrementalStore class]]) {
+            id referenceObject = [(AFIncrementalStore *)self.objectID.persistentStore referenceObjectForObjectID:self.objectID];
+            if ([referenceObject isKindOfClass:[NSString class]]) {
+                return AFResourceIdentifierFromReferenceObject(referenceObject);
+            }
+        }
+    }
+    
+    return identifier;
+}
+
+- (void)af_setResourceIdentifier:(NSString *)resourceIdentifier {
+    objc_setAssociatedObject(self, &kAFResourceIdentifierObjectKey, resourceIdentifier, OBJC_ASSOCIATION_COPY_NONATOMIC);
+}
+
+@end
+
+#pragma mark -
+
+@implementation AFIncrementalStore {
+@private
+    NSCache *_backingObjectIDByObjectID;
+    NSMutableDictionary *_registeredObjectIDsByEntityNameAndNestedResourceIdentifier;
+    NSPersistentStoreCoordinator *_backingPersistentStoreCoordinator;
+    NSManagedObjectContext *_backingManagedObjectContext;
+}
+@synthesize HTTPClient = _HTTPClient;
+@synthesize backingPersistentStoreCoordinator = _backingPersistentStoreCoordinator;
+
++ (NSString *)type {
+    @throw([NSException exceptionWithName:AFIncrementalStoreUnimplementedMethodException reason:NSLocalizedString(@"Unimplemented method: +type. Must be overridden in a subclass", nil) userInfo:nil]);
+}
+
++ (NSManagedObjectModel *)model {
+    @throw([NSException exceptionWithName:AFIncrementalStoreUnimplementedMethodException reason:NSLocalizedString(@"Unimplemented method: +model. Must be overridden in a subclass", nil) userInfo:nil]);
+}
+
+#pragma mark -
+
+- (void)notifyManagedObjectContext:(NSManagedObjectContext *)context
+             aboutRequestOperation:(AFHTTPRequestOperation *)operation
+                   forFetchRequest:(NSFetchRequest *)fetchRequest
+                    fetchedObjects:(NSArray *)fetchedObjects
+{
+    NSString *notificationName = [operation isFinished] ? AFIncrementalStoreContextDidFetchRemoteValues : AFIncrementalStoreContextWillFetchRemoteValues;
+    
+    NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+    [userInfo setObject:operation forKey:AFIncrementalStoreRequestOperationKey];
+    [userInfo setObject:fetchRequest forKey:AFIncrementalStorePersistentStoreRequestKey];
+    if ([operation isFinished] && fetchedObjects) {
+        [userInfo setObject:fetchedObjects forKey:AFIncrementalStoreFetchedObjectsKey];
+    }
+    
+    [[NSNotificationCenter defaultCenter] postNotificationName:notificationName object:context userInfo:userInfo];
+}
+
+- (void)notifyManagedObjectContext:(NSManagedObjectContext *)context
+            aboutRequestOperations:(NSArray *)operations
+             forSaveChangesRequest:(NSSaveChangesRequest *)saveChangesRequest
+{
+    NSString *notificationName = [[operations lastObject] isFinished] ? AFIncrementalStoreContextDidSaveRemoteValues : AFIncrementalStoreContextWillSaveRemoteValues;
+    
+    NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+    [userInfo setObject:operations forKey:AFIncrementalStoreRequestOperationKey];
+    [userInfo setObject:saveChangesRequest forKey:AFIncrementalStorePersistentStoreRequestKey];
+
+    [[NSNotificationCenter defaultCenter] postNotificationName:notificationName object:context userInfo:userInfo];
+}
+
+#pragma mark -
+
+- (NSManagedObjectContext *)backingManagedObjectContext {
+    if (!_backingManagedObjectContext) {
+        _backingManagedObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
+        _backingManagedObjectContext.persistentStoreCoordinator = _backingPersistentStoreCoordinator;
+        _backingManagedObjectContext.retainsRegisteredObjects = YES;
+    }
+    
+    return _backingManagedObjectContext;
+}
+
+- (NSManagedObjectID *)objectIDForEntity:(NSEntityDescription *)entity
+                  withResourceIdentifier:(NSString *)resourceIdentifier
+{
+    if (!resourceIdentifier) {
+        return nil;
+    }
+    
+    NSManagedObjectID *objectID = nil;
+    NSMutableDictionary *objectIDsByResourceIdentifier = [_registeredObjectIDsByEntityNameAndNestedResourceIdentifier objectForKey:entity.name];
+    if (objectIDsByResourceIdentifier) {
+        objectID = [objectIDsByResourceIdentifier objectForKey:resourceIdentifier];
+    }
+        
+    if (!objectID) {
+        objectID = [self newObjectIDForEntity:entity referenceObject:AFReferenceObjectFromResourceIdentifier(resourceIdentifier)];
+    }
+    
+    NSParameterAssert([objectID.entity.name isEqualToString:entity.name]);
+    
+    return objectID;
+}
+
+- (NSManagedObjectID *)objectIDForBackingObjectForEntity:(NSEntityDescription *)entity
+                                  withResourceIdentifier:(NSString *)resourceIdentifier
+{
+    if (!resourceIdentifier) {
+        return nil;
+    }
+    
+    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:[entity name]];
+    fetchRequest.resultType = NSManagedObjectIDResultType;
+    fetchRequest.fetchLimit = 1;
+    fetchRequest.predicate = [NSPredicate predicateWithFormat:@"%K = %@", kAFIncrementalStoreResourceIdentifierAttributeName, resourceIdentifier];
+    
+    __block NSArray *results = nil;
+    __block NSError *error = nil;
+    
+    [self.backingPersistentStoreCoordinator lock];
+    NSManagedObjectContext *backingContext = [self backingManagedObjectContext];
+    [backingContext performBlockAndWait:^{
+        results = [backingContext executeFetchRequest:fetchRequest error:&error];
+    }];
+    [self.backingPersistentStoreCoordinator unlock];
+    
+    if (error) {
+        NSLog(@"Error: %@", error);
+        return nil;
+    }
+    
+    return [results lastObject];
+}
+
+- (void)updateBackingObject:(NSManagedObject *)backingObject
+withAttributeAndRelationshipValuesFromManagedObject:(NSManagedObject *)managedObject
+{
+    for (NSRelationshipDescription *relationship in [managedObject.entity.relationshipsByName allValues]) {
+        id relationshipValue = [managedObject valueForKey:relationship.name];
+        if (!relationshipValue) {
+            continue;
+        }
+        
+        if ([relationship isToMany]) {
+            id mutableBackingRelationshipValue = nil;
+            if ([relationship isOrdered]) {
+                mutableBackingRelationshipValue = [NSMutableOrderedSet orderedSetWithCapacity:[relationshipValue count]];
+            } else {
+                mutableBackingRelationshipValue = [NSMutableSet setWithCapacity:[relationshipValue count]];
+            }
+            
+            for (NSManagedObject *relationshipManagedObject in relationshipValue) {
+				if (![[relationshipManagedObject objectID] isTemporaryID]) {
+					NSManagedObjectID *backingRelationshipObjectID = [self objectIDForBackingObjectForEntity:relationship.destinationEntity withResourceIdentifier:AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:relationshipManagedObject.objectID])];
+					if (backingRelationshipObjectID) {
+						NSManagedObject *backingRelationshipObject = [backingObject.managedObjectContext existingObjectWithID:backingRelationshipObjectID error:nil];
+						if (backingRelationshipObject) {
+							[mutableBackingRelationshipValue addObject:backingRelationshipObject];
+						}
+					}
+				}
+            }
+            
+            [backingObject setValue:mutableBackingRelationshipValue forKey:relationship.name];
+        } else {
+			if (![[relationshipValue objectID] isTemporaryID]) {
+				NSManagedObjectID *backingRelationshipObjectID = [self objectIDForBackingObjectForEntity:relationship.destinationEntity withResourceIdentifier:AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:[relationshipValue objectID]])];
+				if (backingRelationshipObjectID) {
+					NSManagedObject *backingRelationshipObject = [backingObject.managedObjectContext existingObjectWithID:backingRelationshipObjectID error:nil];
+					[backingObject setValue:backingRelationshipObject forKey:relationship.name];
+				}
+			}
+        }
+    }
+    
+    [backingObject setValuesForKeysWithDictionary:[managedObject dictionaryWithValuesForKeys:[managedObject.entity.attributesByName allKeys]]];
+}
+
+#pragma mark -
+
+- (BOOL)insertOrUpdateObjectsFromRepresentations:(id)representationOrArrayOfRepresentations
+                                        ofEntity:(NSEntityDescription *)entity
+                                    fromResponse:(NSHTTPURLResponse *)response
+                                     withContext:(NSManagedObjectContext *)context
+                                           error:(NSError *__autoreleasing *)error
+                                 completionBlock:(void (^)(NSArray *managedObjects, NSArray *backingObjects))completionBlock
+{
+    NSParameterAssert([representationOrArrayOfRepresentations isKindOfClass:[NSArray class]] || [representationOrArrayOfRepresentations isKindOfClass:[NSDictionary class]]);
+    
+    if ([representationOrArrayOfRepresentations count] == 0) {
+        if (completionBlock) {
+            completionBlock([NSArray array], [NSArray array]);
+        }
+        
+        return NO;
+    }
+    
+    NSManagedObjectContext *backingContext = [self backingManagedObjectContext];
+    NSString *lastModified = [[response allHeaderFields] valueForKey:@"Last-Modified"];
+
+    NSArray *representations = nil;
+    if ([representationOrArrayOfRepresentations isKindOfClass:[NSArray class]]) {
+        representations = representationOrArrayOfRepresentations;
+    } else if ([representationOrArrayOfRepresentations isKindOfClass:[NSDictionary class]]) {
+        representations = [NSArray arrayWithObject:representationOrArrayOfRepresentations];
+    }
+
+    NSUInteger numberOfRepresentations = [representations count];
+    NSMutableArray *mutableManagedObjects = [NSMutableArray arrayWithCapacity:numberOfRepresentations];
+    NSMutableArray *mutableBackingObjects = [NSMutableArray arrayWithCapacity:numberOfRepresentations];
+    
+    for (NSDictionary *representation in representations) {
+        NSString *resourceIdentifier = [self.HTTPClient resourceIdentifierForRepresentation:representation ofEntity:entity fromResponse:response];
+        NSDictionary *attributes = [self.HTTPClient attributesForRepresentation:representation ofEntity:entity fromResponse:response];
+        
+        __block NSManagedObject *managedObject = nil;
+        [context performBlockAndWait:^{
+            managedObject = [context existingObjectWithID:[self objectIDForEntity:entity withResourceIdentifier:resourceIdentifier] error:nil];
+        }];
+        
+        [managedObject setValuesForKeysWithDictionary:attributes];
+        
+        NSManagedObjectID *backingObjectID = [self objectIDForBackingObjectForEntity:entity withResourceIdentifier:resourceIdentifier];
+        __block NSManagedObject *backingObject = nil;
+        [backingContext performBlockAndWait:^{
+            if (backingObjectID) {
+                backingObject = [backingContext existingObjectWithID:backingObjectID error:nil];
+            } else {
+                backingObject = [NSEntityDescription insertNewObjectForEntityForName:entity.name inManagedObjectContext:backingContext];
+                [backingObject.managedObjectContext obtainPermanentIDsForObjects:[NSArray arrayWithObject:backingObject] error:nil];
+            }
+        }];
+        [backingObject setValue:resourceIdentifier forKey:kAFIncrementalStoreResourceIdentifierAttributeName];
+        [backingObject setValue:lastModified forKey:kAFIncrementalStoreLastModifiedAttributeName];
+        [backingObject setValuesForKeysWithDictionary:attributes];
+        
+        if (!backingObjectID) {
+            [context insertObject:managedObject];
+        }
+        
+        NSDictionary *relationshipRepresentations = [self.HTTPClient representationsForRelationshipsFromRepresentation:representation ofEntity:entity fromResponse:response];
+        for (NSString *relationshipName in relationshipRepresentations) {
+            NSRelationshipDescription *relationship = [[entity relationshipsByName] valueForKey:relationshipName];
+            id relationshipRepresentation = [relationshipRepresentations objectForKey:relationshipName];
+            if (!relationship || (relationship.isOptional && (!relationshipRepresentation || [relationshipRepresentation isEqual:[NSNull null]]))) {
+                continue;
+            }
+                        
+            if (!relationshipRepresentation || [relationshipRepresentation isEqual:[NSNull null]] || [relationshipRepresentation count] == 0) {
+                [managedObject setValue:nil forKey:relationshipName];
+                [backingObject setValue:nil forKey:relationshipName];
+                continue;
+            }
+            
+            [self insertOrUpdateObjectsFromRepresentations:relationshipRepresentation ofEntity:relationship.destinationEntity fromResponse:response withContext:context error:error completionBlock:^(NSArray *managedObjects, NSArray *backingObjects) {
+                if ([relationship isToMany]) {
+                    if ([relationship isOrdered]) {
+                        [managedObject setValue:[NSOrderedSet orderedSetWithArray:managedObjects] forKey:relationship.name];
+                        [backingObject setValue:[NSOrderedSet orderedSetWithArray:backingObjects] forKey:relationship.name];
+                    } else {
+                        [managedObject setValue:[NSSet setWithArray:managedObjects] forKey:relationship.name];
+                        [backingObject setValue:[NSSet setWithArray:backingObjects] forKey:relationship.name];
+                    }
+                } else {
+                    [managedObject setValue:[managedObjects lastObject] forKey:relationship.name];
+                    [backingObject setValue:[backingObjects lastObject] forKey:relationship.name];
+                }
+            }];
+        }
+        
+        [mutableManagedObjects addObject:managedObject];
+        [mutableBackingObjects addObject:backingObject];
+    }
+    
+    if (completionBlock) {
+        completionBlock(mutableManagedObjects, mutableBackingObjects);
+    }
+
+    return YES;
+}
+
+- (id)executeFetchRequest:(NSFetchRequest *)fetchRequest
+              withContext:(NSManagedObjectContext *)context
+                    error:(NSError *__autoreleasing *)error
+{
+    NSURLRequest *request = [self.HTTPClient requestForFetchRequest:fetchRequest withContext:context];
+    if ([request URL]) {
+        AFHTTPRequestOperation *operation = [self.HTTPClient HTTPRequestOperationWithRequest:request success:^(AFHTTPRequestOperation *operation, id responseObject) {
+            id representationOrArrayOfRepresentations = [self.HTTPClient representationOrArrayOfRepresentationsOfEntity:fetchRequest.entity fromResponseObject:responseObject];
+    
+            NSManagedObjectContext *childContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
+            childContext.parentContext = context;
+            childContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy;
+                        
+            [childContext performBlockAndWait:^{
+                [self insertOrUpdateObjectsFromRepresentations:representationOrArrayOfRepresentations ofEntity:fetchRequest.entity fromResponse:operation.response withContext:childContext error:error completionBlock:^(NSArray *managedObjects, NSArray *backingObjects) {
+                
+                    NSSet *childObjects = [childContext registeredObjects];
+                    
+                    if (![[self backingManagedObjectContext] save:error] || ![childContext save:error]) {
+                        @throw [NSException exceptionWithName:NSInternalInconsistencyException reason:[*error localizedFailureReason] userInfo:[NSDictionary dictionaryWithObject:*error forKey:NSUnderlyingErrorKey]];
+                    }
+                    
+                    for (NSManagedObject *childObject in childObjects) {
+                        NSManagedObject *parentObject = [context objectWithID:childObject.objectID];
+                        [parentObject.managedObjectContext refreshObject:parentObject mergeChanges:NO];
+                    }
+
+                    [context performBlockAndWait:^{
+                        for (NSManagedObject *childObject in childObjects) {
+                            NSManagedObject *parentObject = [context objectWithID:childObject.objectID];
+                            [parentObject willChangeValueForKey:@"self"];
+                            [context refreshObject:parentObject mergeChanges:NO];
+                            [parentObject didChangeValueForKey:@"self"];
+                        }
+                    }];
+
+                    NSMutableArray *fetchedObjects = [[NSMutableArray alloc] initWithCapacity:[managedObjects count]];
+                    for (NSManagedObject *managedObject in managedObjects) {
+                        NSManagedObject *fetchedObject = [context existingObjectWithID:managedObject.objectID error:NULL];
+                        if (fetchedObject) {
+                            [fetchedObjects addObject:fetchedObject];
+                        }
+                    }
+                    [fetchedObjects sortUsingDescriptors:fetchRequest.sortDescriptors];
+                    
+                    [self notifyManagedObjectContext:context aboutRequestOperation:operation forFetchRequest:fetchRequest fetchedObjects:fetchedObjects];
+                }];
+            }];
+        } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
+            NSLog(@"Error: %@", error);
+            [self notifyManagedObjectContext:context aboutRequestOperation:operation forFetchRequest:fetchRequest fetchedObjects:nil];
+        }];
+
+        [self notifyManagedObjectContext:context aboutRequestOperation:operation forFetchRequest:fetchRequest fetchedObjects:nil];
+        [self.HTTPClient enqueueHTTPRequestOperation:operation];
+    }
+    
+    NSManagedObjectContext *backingContext = [self backingManagedObjectContext];
+	NSFetchRequest *backingFetchRequest = [fetchRequest copy];
+	backingFetchRequest.entity = [NSEntityDescription entityForName:fetchRequest.entityName inManagedObjectContext:backingContext];
+
+    switch (fetchRequest.resultType) {
+        case NSManagedObjectResultType: {
+            backingFetchRequest.resultType = NSDictionaryResultType;
+            backingFetchRequest.propertiesToFetch = [NSArray arrayWithObject:kAFIncrementalStoreResourceIdentifierAttributeName];
+            NSArray *results = [backingContext executeFetchRequest:backingFetchRequest error:error];
+
+            NSMutableArray *mutableObjects = [NSMutableArray arrayWithCapacity:[results count]];
+            for (NSString *resourceIdentifier in [results valueForKeyPath:kAFIncrementalStoreResourceIdentifierAttributeName]) {
+                NSManagedObjectID *objectID = [self objectIDForEntity:fetchRequest.entity withResourceIdentifier:resourceIdentifier];
+                NSManagedObject *object = [context objectWithID:objectID];
+                object.af_resourceIdentifier = resourceIdentifier;
+                [mutableObjects addObject:object];
+            }
+            
+            return mutableObjects;
+        }
+        case NSManagedObjectIDResultType: {
+            NSArray *backingObjectIDs = [backingContext executeFetchRequest:backingFetchRequest error:error];
+            NSMutableArray *managedObjectIDs = [NSMutableArray arrayWithCapacity:[backingObjectIDs count]];
+            
+            for (NSManagedObjectID *backingObjectID in backingObjectIDs) {
+                NSManagedObject *backingObject = [backingContext objectWithID:backingObjectID];
+                NSString *resourceID = [backingObject valueForKey:kAFIncrementalStoreResourceIdentifierAttributeName];
+                [managedObjectIDs addObject:[self objectIDForEntity:fetchRequest.entity withResourceIdentifier:resourceID]];
+            }
+            
+            return managedObjectIDs;
+        }
+        case NSDictionaryResultType:
+        case NSCountResultType:
+            return [backingContext executeFetchRequest:backingFetchRequest error:error];
+        default:
+            return nil;
+    }
+}
+
+- (id)executeSaveChangesRequest:(NSSaveChangesRequest *)saveChangesRequest
+                    withContext:(NSManagedObjectContext *)context
+                          error:(NSError *__autoreleasing *)error
+{
+    NSMutableArray *mutableOperations = [NSMutableArray array];
+    NSManagedObjectContext *backingContext = [self backingManagedObjectContext];
+
+    if ([self.HTTPClient respondsToSelector:@selector(requestForInsertedObject:)]) {
+        for (NSManagedObject *insertedObject in [saveChangesRequest insertedObjects]) {
+            NSURLRequest *request = [self.HTTPClient requestForInsertedObject:insertedObject];
+            if (!request) {
+                [backingContext performBlockAndWait:^{
+                    CFUUIDRef UUID = CFUUIDCreate(NULL);
+                    NSString *resourceIdentifier = (__bridge_transfer NSString *)CFUUIDCreateString(NULL, UUID);
+                    CFRelease(UUID);
+                    
+                    NSManagedObject *backingObject = [NSEntityDescription insertNewObjectForEntityForName:insertedObject.entity.name inManagedObjectContext:backingContext];
+                    [backingObject.managedObjectContext obtainPermanentIDsForObjects:[NSArray arrayWithObject:backingObject] error:nil];
+                    [backingObject setValue:resourceIdentifier forKey:kAFIncrementalStoreResourceIdentifierAttributeName];
+                    [self updateBackingObject:backingObject withAttributeAndRelationshipValuesFromManagedObject:insertedObject];
+                    [backingContext save:nil];
+                }];
+                
+                [insertedObject willChangeValueForKey:@"objectID"];
+                [context obtainPermanentIDsForObjects:[NSArray arrayWithObject:insertedObject] error:nil];
+                [insertedObject didChangeValueForKey:@"objectID"];
+                continue;
+            }
+            
+            AFHTTPRequestOperation *operation = [self.HTTPClient HTTPRequestOperationWithRequest:request success:^(AFHTTPRequestOperation *operation, id responseObject) {
+                NSString *resourceIdentifier = [self.HTTPClient resourceIdentifierForRepresentation:responseObject ofEntity:[insertedObject entity] fromResponse:operation.response];
+                NSManagedObjectID *objectID = [self objectIDForEntity:[insertedObject entity] withResourceIdentifier:resourceIdentifier];
+                insertedObject.af_resourceIdentifier = resourceIdentifier;
+                [insertedObject setValuesForKeysWithDictionary:[self.HTTPClient attributesForRepresentation:responseObject ofEntity:insertedObject.entity fromResponse:operation.response]];
+                
+                [backingContext performBlockAndWait:^{
+                    __block NSManagedObject *backingObject = nil;
+                    if (objectID) {
+                        [backingContext performBlockAndWait:^{
+                            backingObject = [backingContext existingObjectWithID:objectID error:nil];
+                        }];
+                    }
+                    
+                    if (!backingObject) {
+                        backingObject = [NSEntityDescription insertNewObjectForEntityForName:insertedObject.entity.name inManagedObjectContext:backingContext];
+                        [backingObject.managedObjectContext obtainPermanentIDsForObjects:[NSArray arrayWithObject:backingObject] error:nil];
+                    }
+                    
+                    [backingObject setValue:resourceIdentifier forKey:kAFIncrementalStoreResourceIdentifierAttributeName];
+                    [self updateBackingObject:backingObject withAttributeAndRelationshipValuesFromManagedObject:insertedObject];
+                    [backingContext save:nil];
+                }];
+                
+                [insertedObject willChangeValueForKey:@"objectID"];
+                [context obtainPermanentIDsForObjects:[NSArray arrayWithObject:insertedObject] error:nil];
+                [insertedObject didChangeValueForKey:@"objectID"];
+                
+                [context refreshObject:insertedObject mergeChanges:NO];
+            } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
+                NSLog(@"Insert Error: %@", error);
+            }];
+            
+            [mutableOperations addObject:operation];
+        }
+    }
+    
+    if ([self.HTTPClient respondsToSelector:@selector(requestForUpdatedObject:)]) {
+        for (NSManagedObject *updatedObject in [saveChangesRequest updatedObjects]) {
+            NSManagedObjectID *backingObjectID = [self objectIDForBackingObjectForEntity:[updatedObject entity] withResourceIdentifier:AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:updatedObject.objectID])];
+
+            NSURLRequest *request = [self.HTTPClient requestForUpdatedObject:updatedObject];
+            if (!request) {
+                [backingContext performBlockAndWait:^{
+                    NSManagedObject *backingObject = [backingContext existingObjectWithID:backingObjectID error:nil];
+                    [self updateBackingObject:backingObject withAttributeAndRelationshipValuesFromManagedObject:updatedObject];
+                    [backingContext save:nil];
+                }];
+                continue;
+            }
+            
+            AFHTTPRequestOperation *operation = [self.HTTPClient HTTPRequestOperationWithRequest:request success:^(AFHTTPRequestOperation *operation, id responseObject) {
+                [updatedObject setValuesForKeysWithDictionary:[self.HTTPClient attributesForRepresentation:responseObject ofEntity:updatedObject.entity fromResponse:operation.response]];
+                
+                [backingContext performBlockAndWait:^{
+                    NSManagedObject *backingObject = [backingContext existingObjectWithID:backingObjectID error:nil];
+                    [self updateBackingObject:backingObject withAttributeAndRelationshipValuesFromManagedObject:updatedObject];
+                    [backingContext save:nil];
+                }];
+                
+                [context refreshObject:updatedObject mergeChanges:NO];
+            } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
+                NSLog(@"Update Error: %@", error);
+                [context refreshObject:updatedObject mergeChanges:NO];
+            }];
+            
+            [mutableOperations addObject:operation];
+        }
+    }
+    
+    if ([self.HTTPClient respondsToSelector:@selector(requestForDeletedObject:)]) {
+        for (NSManagedObject *deletedObject in [saveChangesRequest deletedObjects]) {
+            NSManagedObjectID *backingObjectID = [self objectIDForBackingObjectForEntity:[deletedObject entity] withResourceIdentifier:AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:deletedObject.objectID])];
+
+            NSURLRequest *request = [self.HTTPClient requestForDeletedObject:deletedObject];
+            if (!request) {
+                [backingContext performBlockAndWait:^{
+                    NSManagedObject *backingObject = [backingContext existingObjectWithID:backingObjectID error:nil];
+                    [backingContext deleteObject:backingObject];
+                    [backingContext save:nil];
+                }];
+                continue;
+            }
+            
+            AFHTTPRequestOperation *operation = [self.HTTPClient HTTPRequestOperationWithRequest:request success:^(AFHTTPRequestOperation *operation, id responseObject) {
+                [backingContext performBlockAndWait:^{
+                    NSManagedObject *backingObject = [backingContext existingObjectWithID:backingObjectID error:nil];
+                    [backingContext deleteObject:backingObject];
+                    [backingContext save:nil];
+                }];
+            } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
+                NSLog(@"Delete Error: %@", error);
+            }];
+            
+            [mutableOperations addObject:operation];
+        }
+    }
+    
+    // NSManagedObjectContext removes object references from an NSSaveChangesRequest as each object is saved, so create a copy of the original in order to send useful information in AFIncrementalStoreContextDidSaveRemoteValues notification.
+    NSSaveChangesRequest *saveChangesRequestCopy = [[NSSaveChangesRequest alloc] initWithInsertedObjects:[saveChangesRequest.insertedObjects copy] updatedObjects:[saveChangesRequest.updatedObjects copy] deletedObjects:[saveChangesRequest.deletedObjects copy] lockedObjects:[saveChangesRequest.lockedObjects copy]];
+    
+    [self notifyManagedObjectContext:context aboutRequestOperations:mutableOperations forSaveChangesRequest:saveChangesRequestCopy];
+
+    [self.HTTPClient enqueueBatchOfHTTPRequestOperations:mutableOperations progressBlock:nil completionBlock:^(NSArray *operations) {
+        [self notifyManagedObjectContext:context aboutRequestOperations:operations forSaveChangesRequest:saveChangesRequestCopy];
+    }];
+    
+    return [NSArray array];
+}
+
+#pragma mark - NSIncrementalStore
+
+- (BOOL)loadMetadata:(NSError *__autoreleasing *)error {
+    if (!_backingObjectIDByObjectID) {
+        NSMutableDictionary *mutableMetadata = [NSMutableDictionary dictionary];
+        [mutableMetadata setValue:[[NSProcessInfo processInfo] globallyUniqueString] forKey:NSStoreUUIDKey];
+        [mutableMetadata setValue:NSStringFromClass([self class]) forKey:NSStoreTypeKey];
+        [self setMetadata:mutableMetadata];
+        
+        _backingObjectIDByObjectID = [[NSCache alloc] init];
+        _registeredObjectIDsByEntityNameAndNestedResourceIdentifier = [[NSMutableDictionary alloc] init];
+        
+        NSManagedObjectModel *model = [self.persistentStoreCoordinator.managedObjectModel copy];
+        for (NSEntityDescription *entity in model.entities) {
+            // Don't add properties for sub-entities, as they already exist in the super-entity
+            if ([entity superentity]) {
+                continue;
+            }
+            
+            NSAttributeDescription *resourceIdentifierProperty = [[NSAttributeDescription alloc] init];
+            [resourceIdentifierProperty setName:kAFIncrementalStoreResourceIdentifierAttributeName];
+            [resourceIdentifierProperty setAttributeType:NSStringAttributeType];
+            [resourceIdentifierProperty setIndexed:YES];
+            
+            NSAttributeDescription *lastModifiedProperty = [[NSAttributeDescription alloc] init];
+            [lastModifiedProperty setName:kAFIncrementalStoreLastModifiedAttributeName];
+            [lastModifiedProperty setAttributeType:NSStringAttributeType];
+            [lastModifiedProperty setIndexed:NO];
+            
+            [entity setProperties:[entity.properties arrayByAddingObjectsFromArray:[NSArray arrayWithObjects:resourceIdentifierProperty, lastModifiedProperty, nil]]];
+        }
+        
+        _backingPersistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:model];
+        
+        return YES;
+    } else {
+        return NO;
+    }
+}
+
+- (NSArray *)obtainPermanentIDsForObjects:(NSArray *)array error:(NSError **)error {
+    NSMutableArray *mutablePermanentIDs = [NSMutableArray arrayWithCapacity:[array count]];
+    for (NSManagedObject *managedObject in array) {
+        NSManagedObjectID *managedObjectID = managedObject.objectID;
+        if ([managedObjectID isTemporaryID] && managedObject.af_resourceIdentifier) {
+            NSManagedObjectID *objectID = [self objectIDForEntity:managedObject.entity withResourceIdentifier:managedObject.af_resourceIdentifier];
+            [mutablePermanentIDs addObject:objectID];
+        } else {
+            [mutablePermanentIDs addObject:managedObjectID];
+        }
+    }
+    
+    return mutablePermanentIDs;
+}
+
+- (id)executeRequest:(NSPersistentStoreRequest *)persistentStoreRequest
+         withContext:(NSManagedObjectContext *)context
+               error:(NSError *__autoreleasing *)error
+{
+    if (persistentStoreRequest.requestType == NSFetchRequestType) {
+        return [self executeFetchRequest:(NSFetchRequest *)persistentStoreRequest withContext:context error:error];
+    } else if (persistentStoreRequest.requestType == NSSaveRequestType) {
+        return [self executeSaveChangesRequest:(NSSaveChangesRequest *)persistentStoreRequest withContext:context error:error];
+    } else {
+        NSMutableDictionary *mutableUserInfo = [NSMutableDictionary dictionary];
+        [mutableUserInfo setValue:[NSString stringWithFormat:NSLocalizedString(@"Unsupported NSFetchRequestResultType, %d", nil), persistentStoreRequest.requestType] forKey:NSLocalizedDescriptionKey];
+        if (error) {
+            *error = [[NSError alloc] initWithDomain:AFNetworkingErrorDomain code:0 userInfo:mutableUserInfo];
+        }
+        
+        return nil;
+    }
+}
+
+- (NSIncrementalStoreNode *)newValuesForObjectWithID:(NSManagedObjectID *)objectID
+                                         withContext:(NSManagedObjectContext *)context
+                                               error:(NSError *__autoreleasing *)error
+{
+    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] initWithEntityName:[[objectID entity] name]];
+    fetchRequest.resultType = NSDictionaryResultType;
+    fetchRequest.fetchLimit = 1;
+    fetchRequest.includesSubentities = NO;
+    
+    NSArray *attributes = [[[NSEntityDescription entityForName:fetchRequest.entityName inManagedObjectContext:context] attributesByName] allValues];
+    NSArray *intransientAttributes = [attributes filteredArrayUsingPredicate:[NSPredicate predicateWithFormat:@"isTransient == NO"]];
+    fetchRequest.propertiesToFetch = [[intransientAttributes valueForKeyPath:@"name"] arrayByAddingObject:kAFIncrementalStoreLastModifiedAttributeName];
+    
+    fetchRequest.predicate = [NSPredicate predicateWithFormat:@"%K = %@", kAFIncrementalStoreResourceIdentifierAttributeName, AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:objectID])];
+    
+    __block NSArray *results;
+    NSManagedObjectContext *backingContext = [self backingManagedObjectContext];
+    [backingContext performBlockAndWait:^{
+        results = [backingContext executeFetchRequest:fetchRequest error:error];
+    }];
+    
+    NSDictionary *attributeValues = [results lastObject] ?: [NSDictionary dictionary];
+    NSIncrementalStoreNode *node = [[NSIncrementalStoreNode alloc] initWithObjectID:objectID withValues:attributeValues version:1];
+    
+    if ([self.HTTPClient respondsToSelector:@selector(shouldFetchRemoteAttributeValuesForObjectWithID:inManagedObjectContext:)] && [self.HTTPClient shouldFetchRemoteAttributeValuesForObjectWithID:objectID inManagedObjectContext:context]) {
+        if (attributeValues) {
+            NSManagedObjectContext *childContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
+            childContext.parentContext = context;
+            childContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy;
+            
+            NSMutableURLRequest *request = [self.HTTPClient requestWithMethod:@"GET" pathForObjectWithID:objectID withContext:context];
+            NSString *lastModified = [attributeValues objectForKey:kAFIncrementalStoreLastModifiedAttributeName];
+            if (lastModified) {
+                [request setValue:lastModified forHTTPHeaderField:@"Last-Modified"];
+            }
+            
+            if ([request URL]) {
+                if ([attributeValues valueForKey:kAFIncrementalStoreLastModifiedAttributeName]) {
+                    [request setValue:[[attributeValues valueForKey:kAFIncrementalStoreLastModifiedAttributeName] description] forHTTPHeaderField:@"If-Modified-Since"];
+                }
+                
+                AFHTTPRequestOperation *operation = [self.HTTPClient HTTPRequestOperationWithRequest:request success:^(AFHTTPRequestOperation *operation, NSDictionary *representation) {
+                    NSManagedObject *managedObject = [childContext existingObjectWithID:objectID error:error];
+                    
+                    NSMutableDictionary *mutableAttributeValues = [attributeValues mutableCopy];
+                    [mutableAttributeValues addEntriesFromDictionary:[self.HTTPClient attributesForRepresentation:representation ofEntity:managedObject.entity fromResponse:operation.response]];
+                    [mutableAttributeValues removeObjectForKey:kAFIncrementalStoreLastModifiedAttributeName];
+                    [managedObject setValuesForKeysWithDictionary:mutableAttributeValues];
+                    
+                    NSManagedObjectID *backingObjectID = [self objectIDForBackingObjectForEntity:[objectID entity] withResourceIdentifier:AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:objectID])];
+                    NSManagedObject *backingObject = [[self backingManagedObjectContext] existingObjectWithID:backingObjectID error:nil];
+                    [backingObject setValuesForKeysWithDictionary:mutableAttributeValues];
+                    
+                    NSString *lastModified = [[operation.response allHeaderFields] valueForKey:@"Last-Modified"];
+                    if (lastModified) {
+                        [backingObject setValue:lastModified forKey:kAFIncrementalStoreLastModifiedAttributeName];
+                    }
+
+                    id observer = [[NSNotificationCenter defaultCenter] addObserverForName:NSManagedObjectContextDidSaveNotification object:childContext queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification *note) {
+                        [context mergeChangesFromContextDidSaveNotification:note];
+                    }];
+                    
+                    [childContext performBlockAndWait:^{
+                        if (![[self backingManagedObjectContext] save:error] || ![childContext save:error]) {
+                            @throw [NSException exceptionWithName:NSInternalInconsistencyException reason:[*error localizedFailureReason] userInfo:[NSDictionary dictionaryWithObject:*error forKey:NSUnderlyingErrorKey]];
+                        }
+                    }];
+                    
+                    [[NSNotificationCenter defaultCenter] removeObserver:observer];
+                } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
+                    NSLog(@"Error: %@, %@", operation, error);
+                }];
+                
+                [self.HTTPClient enqueueHTTPRequestOperation:operation];
+            }
+        }
+    }
+    
+    return node;
+}
+
+- (id)newValueForRelationship:(NSRelationshipDescription *)relationship
+              forObjectWithID:(NSManagedObjectID *)objectID
+                  withContext:(NSManagedObjectContext *)context
+                        error:(NSError *__autoreleasing *)error
+{
+    if ([self.HTTPClient respondsToSelector:@selector(shouldFetchRemoteValuesForRelationship:forObjectWithID:inManagedObjectContext:)] && [self.HTTPClient shouldFetchRemoteValuesForRelationship:relationship forObjectWithID:objectID inManagedObjectContext:context]) {
+        NSURLRequest *request = [self.HTTPClient requestWithMethod:@"GET" pathForRelationship:relationship forObjectWithID:objectID withContext:context];
+        
+        if ([request URL] && ![[context existingObjectWithID:objectID error:nil] hasChanges]) {
+            NSManagedObjectContext *childContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
+            childContext.parentContext = context;
+            childContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy;
+                        
+            AFHTTPRequestOperation *operation = [self.HTTPClient HTTPRequestOperationWithRequest:request success:^(AFHTTPRequestOperation *operation, id responseObject) {
+                id representationOrArrayOfRepresentations = [self.HTTPClient representationOrArrayOfRepresentationsOfEntity:relationship.entity fromResponseObject:responseObject];
+                
+                [childContext performBlockAndWait:^{
+                    [self insertOrUpdateObjectsFromRepresentations:representationOrArrayOfRepresentations ofEntity:relationship.destinationEntity fromResponse:operation.response withContext:childContext error:error completionBlock:^(NSArray *managedObjects, NSArray *backingObjects) {
+                        NSManagedObject *managedObject = [childContext objectWithID:objectID];
+                        NSManagedObject *backingObject = [[self backingManagedObjectContext] existingObjectWithID:objectID error:nil];
+                        
+                        if ([relationship isToMany]) {
+                            if ([relationship isOrdered]) {
+                                [managedObject setValue:[NSOrderedSet orderedSetWithArray:managedObjects] forKey:relationship.name];
+                                [backingObject setValue:[NSOrderedSet orderedSetWithArray:backingObjects] forKey:relationship.name];
+                            } else {
+                                [managedObject setValue:[NSSet setWithArray:managedObjects] forKey:relationship.name];
+                                [backingObject setValue:[NSSet setWithArray:backingObjects] forKey:relationship.name];
+                            }
+                        } else {
+                            [managedObject setValue:[managedObjects lastObject] forKey:relationship.name];
+                            [backingObject setValue:[backingObjects lastObject] forKey:relationship.name];
+                        }
+                        
+                        id observer = [[NSNotificationCenter defaultCenter] addObserverForName:NSManagedObjectContextDidSaveNotification object:childContext queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification *note) {
+                            [context mergeChangesFromContextDidSaveNotification:note];
+                        }];
+                        
+                        if (![[self backingManagedObjectContext] save:error] || ![childContext save:error]) {
+                            @throw [NSException exceptionWithName:NSInternalInconsistencyException reason:[*error localizedFailureReason] userInfo:[NSDictionary dictionaryWithObject:*error forKey:NSUnderlyingErrorKey]];
+                        }
+                        
+                        [[NSNotificationCenter defaultCenter] removeObserver:observer];
+                    }];
+                }];
+            } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
+                NSLog(@"Error: %@, %@", operation, error);
+            }];
+
+            [self.HTTPClient enqueueHTTPRequestOperation:operation];
+        }
+    }
+    
+    NSManagedObjectID *backingObjectID = [self objectIDForBackingObjectForEntity:[objectID entity] withResourceIdentifier:AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:objectID])];
+    NSManagedObject *backingObject = (backingObjectID == nil) ? nil : [[self backingManagedObjectContext] existingObjectWithID:backingObjectID error:nil];
+    
+    if (backingObject && ![backingObject hasChanges]) {
+        id backingRelationshipObject = [backingObject valueForKeyPath:relationship.name];
+        if ([relationship isToMany]) {
+            NSMutableArray *mutableObjects = [NSMutableArray arrayWithCapacity:[backingRelationshipObject count]];
+            for (NSString *resourceIdentifier in [backingRelationshipObject valueForKeyPath:kAFIncrementalStoreResourceIdentifierAttributeName]) {
+                NSManagedObjectID *objectID = [self objectIDForEntity:relationship.destinationEntity withResourceIdentifier:resourceIdentifier];
+                [mutableObjects addObject:objectID];
+            }
+                        
+            return mutableObjects;            
+        } else {
+            NSString *resourceIdentifier = [backingRelationshipObject valueForKeyPath:kAFIncrementalStoreResourceIdentifierAttributeName];
+            NSManagedObjectID *objectID = [self objectIDForEntity:relationship.destinationEntity withResourceIdentifier:resourceIdentifier];
+            
+            return objectID ?: [NSNull null];
+        }
+    } else {
+        if ([relationship isToMany]) {
+            return [NSArray array];
+        } else {
+            return [NSNull null];
+        }
+    }
+}
+
+- (void)managedObjectContextDidRegisterObjectsWithIDs:(NSArray *)objectIDs {
+    [super managedObjectContextDidRegisterObjectsWithIDs:objectIDs];
+    
+    for (NSManagedObjectID *objectID in objectIDs) {
+        id referenceObject = [self referenceObjectForObjectID:objectID];
+        if (!referenceObject) {
+            continue;
+        }
+        
+        NSMutableDictionary *objectIDsByResourceIdentifier = [_registeredObjectIDsByEntityNameAndNestedResourceIdentifier objectForKey:objectID.entity.name] ?: [NSMutableDictionary dictionary];
+        [objectIDsByResourceIdentifier setObject:objectID forKey:AFResourceIdentifierFromReferenceObject(referenceObject)];
+        
+        [_registeredObjectIDsByEntityNameAndNestedResourceIdentifier setObject:objectIDsByResourceIdentifier forKey:objectID.entity.name];
+    }
+}
+
+- (void)managedObjectContextDidUnregisterObjectsWithIDs:(NSArray *)objectIDs {
+    [super managedObjectContextDidUnregisterObjectsWithIDs:objectIDs];
+    
+    for (NSManagedObjectID *objectID in objectIDs) {
+        [[_registeredObjectIDsByEntityNameAndNestedResourceIdentifier objectForKey:objectID.entity.name] removeObjectForKey:AFResourceIdentifierFromReferenceObject([self referenceObjectForObjectID:objectID])];
+    }
+}
+
+@end