Rev docs referencing primaryKey as opposed to identificationAttributes

Code/CoreData/RKManagedObjectMappingOperationDataSource.h

@@ -24,7 +24,7 @@
 @protocol RKManagedObjectCaching;
 
 /**
- The `RKManagedObjectMappingOperationDataSource` class provides support for performing object mapping operations where the mapped objects exist within a Core Data managed object context. The class is responsible for finding exist managed object instances by primary key, instantiating new managed objects, and connecting relationships for mapped objects.
+ The `RKManagedObjectMappingOperationDataSource` class provides support for performing object mapping operations where the mapped objects exist within a Core Data managed object context. The class is responsible for finding exist managed object instances by the identification attributes, instantiating new managed objects, and connecting relationships for mapped objects.
 
  @see `RKMappingOperationDataSource`
  @see `RKConnectionMapping`
@@ -39,7 +39,7 @@
  Initializes the receiver with a given managed object context and managed object cache.
  
  @param managedObjectContext The managed object context with which to associate the receiver. Cannot be nil.
- @param managedObjectCache The managed object cache used by the receiver to find existing object instances by primary key.
+ @param managedObjectCache The managed object cache used by the receiver to find existing object instances by their identification attributes.
  @return The receiver, initialized with the given managed object context and managed objet cache.
  */
 - (id)initWithManagedObjectContext:(NSManagedObjectContext *)managedObjectContext cache:(id<RKManagedObjectCaching>)managedObjectCache;
@@ -54,7 +54,7 @@
 @property (nonatomic, strong, readonly) NSManagedObjectContext *managedObjectContext;
 
 /**
- The managed object cache utilized by the receiver to find existing managed object instances by primary key. A nil managed object cache will result in the insertion of new managed objects for all mapped content.
+ The managed object cache utilized by the receiver to find existing managed object instances by the identification attributes. A nil managed object cache will result in the insertion of new managed objects for all mapped content.
 
  @see `RKFetchRequestManagedObjectCache`
  @see `RKInMemoryManagedObjectCache`

Code/CoreData/RKManagedObjectMappingOperationDataSource.m

@@ -154,7 +154,7 @@ extern NSString * const RKObjectMappingNestingAttributeKeyName;
     NSDictionary *entityIdentifierAttributes = RKEntityIdentificationAttributesForEntityMappingWithRepresentation(entityMapping, representation);
     if (! self.managedObjectCache) {
         RKLogWarning(@"Performing managed object mapping with a nil managed object cache:\n"
-                      "Unable to update existing object instances by primary key. Duplicate objects may be created.");
+                      "Unable to update existing object instances by identification attributes. Duplicate objects may be created.");
     }
 
     // If we have found the entity identifier attributes, try to find an existing instance to update

Code/CoreData/RKManagedObjectStore.h

@@ -175,12 +175,12 @@
 /**
  The managed object cache associated with the receiver.
 
- The managed object cache is used to accelerate intensive Core Data operations by caching managed objects by their primary key value.
+ The managed object cache is used to accelerate intensive Core Data operations by caching managed objects by one or more attributes.
  
  **Default**: An instance of `RKFetchRequestManagedObjectCache`.
 
  @see `RKManagedObjectCaching`
- @warning A nil managed object cache will result in a store that is unable to uniquely identify existing objects by primary key attribute value and may result in the creation of duplicate objects within the store.
+ @warning A nil managed object cache will result in a store that is unable to uniquely identify existing objects by identification attributes and may result in the creation of duplicate objects within the store.
  */
 @property (nonatomic, strong) id<RKManagedObjectCaching> managedObjectCache;
 

Code/CoreData/RKRelationshipConnectionOperation.h

@@ -26,7 +26,7 @@
 /**
  The `RKRelationshipConnectionOperation` class is a subclass of `NSOperation` that manages the connection of `NSManagedObject` relationships as described by an `RKConnectionDescription` object. When executed, the operation will find related objects by searching the associated managed object cache for objects matching the connection description and setting them as the value for the relationship being connected.
 
- For example, given a managed object for the `Employee` entity with a one-to-one relationship to a `Company` named `company` (with an inverse relationship one-to-many relationship named `employees`) and a connection mapping specifying that the relationship can be connected by finding the `Company` managed object whose `companyID` attribute matches the `companyID` of the `Employee`, the operation would find the Company that employs the Employee by primary key and set the Core Data relationship to reflect the relationship appropriately.
+ For example, given a managed object for the `Employee` entity with a one-to-one relationship to a `Company` named `company` (with an inverse relationship one-to-many relationship named `employees`) and a connection specifying that the relationship can be connected by finding the `Company` managed object whose `companyID` attribute matches the `companyID` of the `Employee`, the operation would find the Company that employs the Employee by primary key and set the Core Data relationship to reflect the relationship appropriately.
 
  @see `RKConnectionDescription`
  */

Code/Network/RKManagedObjectRequestOperation.h

@@ -40,11 +40,11 @@
 
  One of the confounding factors when working with asycnhronous processes interacting with Core Data is the addressability of managed objects that have not been saved to the persistent store across contexts. Unpersisted `NSManagedObject` instances have an `objectID` that is temporary and unsuitable for use in uniquely addressing a given object across two managed object contexts, even if they have common ancestry and share a persistent store coordinator. To mitigate this addressability issue without requiring objects to be saved to the persistent store, managed object request operations invoke `obtainPermanentIDsForObjects:` on the operation's target object (if any) and all managed objects that were inserted into the context during the mapping process. By the time the operation finishes, all managed objects in the mapping result can be referenced by `objectID` across contexts with no further action.
 
- ## Primary Keys & Managed Object Caching
+ ## Identification Attributes & Managed Object Caching
 
- When object mapping managed objects it is necessary to differentiate between objects that already exist in the local store and those that are being created as part of the mapping process. This ensures that the local store does not become populated with duplicate records. To make this differentiation, RestKit requires that each `NSEntityDescription` be configured with a primary key attribute. The primary key must correspond to a static attribute assigned by the remote backend system. During mapping, this key is used to search the managed object context for an existing managed object. If one is found, the object is updated else a new object is created. Primary keys are configured at the entity level and additional discussion accompanies the `NSEntityDescription (RKAdditions)` category.
+ When object mapping managed objects it is necessary to differentiate between objects that already exist in the local store and those that are being created as part of the mapping process. This ensures that the local store does not become populated with duplicate records. To make this differentiation, RestKit requires that each `RKEntityMapping` be configured with one or more identification attributes. Each identification attribute must correspond to a static attribute assigned by the remote backend system. During mapping, these attributes are used to search the managed object context for an existing managed object. If one is found, the object is updated else a new object is created. Identification attributes are configured on the `[RKEntityMapping identificationAttributes]` property.
 
- Primary key attributes are used in conjunction with the `RKManagedObjectCaching` protocol. Each managed object request operation is associated with an object conforming to the `RKManagedObjectCaching` protocol via the `managedObjectCache` proeprty. This cache is consulted during mapping to find existing objects and when establishing relationships between entities by primary key. Please see the documentation accompanying `RKManagedObjectCaching` and `RKConnectionMapping` for more information.
+ Identification attributes are used in conjunction with the `RKManagedObjectCaching` protocol. Each managed object request operation is associated with an object conforming to the `RKManagedObjectCaching` protocol via the `managedObjectCache` proeprty. This cache is consulted during mapping to find existing objects and when establishing relationships between entities by one or more attributes. Please see the documentation accompanying `RKManagedObjectCaching` and `RKConnectionDescription` classes for more information.
 
  ## Deleting Managed Objects for `DELETE` requests
 

Code/Network/RKResponseMapperOperation.h

@@ -175,7 +175,7 @@
 @property (nonatomic, strong) NSManagedObjectContext *managedObjectContext;
 
 /**
- An object implementing the `RKManagedObjectCaching` protocol to be used for retrieving existing `NSManagedObject` instances by primary key. If `nil`, existing object cannot be retrieved and new objects will be created for all mappable content within the response data, likely resulting in the creation of duplicate objects.
+ An object implementing the `RKManagedObjectCaching` protocol to be used for retrieving existing `NSManagedObject` instances by identification attributes. If `nil`, existing object cannot be retrieved and new objects will be created for all mappable content within the response data, likely resulting in the creation of duplicate objects.
  
  @see `RKManagedObjectCaching`
  */