kylefang/RestKit
1
0
Fork 0
mirror of https://github.com/zhigang1992/RestKit.git synced 2026-04-21 19:42:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Standardized around a single protocol callback instead of an ad-hoc callback for model loader requests. Simplified the API greatly in RKRequest. Major streamlining

Browse Source
This commit is contained in:
Blake Watters
2010-03-25 13:44:41 -04:00
parent cb4b7c2ba8
commit e970087f57
9 changed files with 212 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
Code/RKClient.m
View File

@@ -83,7 +83,6 @@ static RKClient* sharedClient = nil;
CFRelease(reachability);
return isNetworkAvailable;
}
- (NSURL*)URLForResourcePath:(NSString*)resourcePath {
@@ -105,75 +104,78 @@ static RKClient* sharedClient = nil;
// Asynchronous Requests
///////////////////////////////////////////////////////////////////////////////////////////////////////////
- (RKRequest*)get:(NSString*)resourcePath delegate:(id)delegate callback:(SEL)callback {
- (RKRequest*)load:(NSString*)resourcePath method:(RKRequestMethod)method delegate:(id)delegate callback:(SEL)callback {
RKRequest* request = [[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath] delegate:delegate callback:callback];
[self setupRequest:request];
[request get];
[request sendWithMethod:method];
return request;
}
- (RKRequest*)load:(NSString*)resourcePath method:(RKRequestMethod)method params:(NSObject<RKRequestSerializable>*)params delegate:(id)delegate callback:(SEL)callback {
RKRequest* request = [[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath] delegate:delegate callback:callback];
[self setupRequest:request];
request.params = params;
[request sendWithMethod:method];
return request;
}
- (RKRequest*)get:(NSString*)resourcePath delegate:(id)delegate callback:(SEL)callback {
return [self load:resourcePath method:RKRequestMethodGET delegate:delegate callback:callback];
}
- (RKRequest*)get:(NSString*)resourcePath params:(NSDictionary*)params delegate:(id)delegate callback:(SEL)callback {
NSString* resourcePathWithQueryString = [NSString stringWithFormat:@"%@?%@", resourcePath, [params URLEncodedString]];
RKRequest* request = [[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePathWithQueryString] delegate:delegate callback:callback];
[self setupRequest:request];
[request get];
return request;
return [self load:resourcePathWithQueryString method:RKRequestMethodGET delegate:delegate callback:callback];
}
- (RKRequest*)post:(NSString*)resourcePath params:(NSObject<RKRequestSerializable>*)params delegate:(id)delegate callback:(SEL)callback {
RKRequest* request = [[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath] delegate:delegate callback:callback];
[self setupRequest:request];
[request postParams:params];
return request;
return [self load:resourcePath method:RKRequestMethodPOST params:params delegate:delegate callback:callback];
}
- (RKRequest*)put:(NSString*)resourcePath params:(NSObject<RKRequestSerializable>*)params delegate:(id)delegate callback:(SEL)callback {
RKRequest* request = [[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath] delegate:delegate callback:callback];
[self setupRequest:request];
[request putParams:params];
return request;
return [self load:resourcePath method:RKRequestMethodPUT params:params delegate:delegate callback:callback];
}
- (RKRequest*)delete:(NSString*)resourcePath delegate:(id)delegate callback:(SEL)callback {
RKRequest* request = [[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath] delegate:delegate callback:callback];
[self setupRequest:request];
[request delete];
return request;
return [self load:resourcePath method:RKRequestMethodDELETE delegate:delegate callback:callback];
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Synchronous Requests
///////////////////////////////////////////////////////////////////////////////////////////////////////////
- (RKResponse*)getSynchronously:(NSString*)resourcePath {
RKRequest* request = [[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath]];
- (RKResponse*)loadSynchronously:(NSString*)resourcePath method:(RKRequestMethod)method {
RKRequest* request = [[[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath]] autorelease];
[self setupRequest:request];
return [request sendSynchronouslyWithMethod:method];;
}
- (RKResponse*)loadSynchronously:(NSString*)resourcePath method:(RKRequestMethod)method params:(NSObject<RKRequestSerializable>*)params {
RKRequest* request = [[[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath]] autorelease];
[self setupRequest:request];
return [request getSynchronously];
request.params = params;
return [request sendSynchronouslyWithMethod:method];;
}
- (RKResponse*)getSynchronously:(NSString*)resourcePath {
return [self loadSynchronously:resourcePath method:RKRequestMethodGET];
}
- (RKResponse*)getSynchronously:(NSString*)resourcePath params:(NSDictionary*)params {
NSString* resourcePathWithQueryString = [NSString stringWithFormat:@"%@?%@", resourcePath, [params URLEncodedString]];
RKRequest* request = [[[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePathWithQueryString]] autorelease];
[self setupRequest:request];
return [request getSynchronously];
return [self loadSynchronously:resourcePathWithQueryString method:RKRequestMethodGET];
}
- (RKResponse*)postSynchronously:(NSString*)resourcePath params:(NSObject<RKRequestSerializable>*)params {
RKRequest* request = [[[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath]] autorelease];
[self setupRequest:request];
return [request postParamsSynchronously:params];
return [self loadSynchronously:resourcePath method:RKRequestMethodPOST params:params];
}
- (RKResponse*)putSynchronously:(NSString*)resourcePath params:(NSObject<RKRequestSerializable>*)params {
RKRequest* request = [[[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath]] autorelease];
[self setupRequest:request];
return [request putParamsSynchronously:params];
return [self loadSynchronously:resourcePath method:RKRequestMethodPUT params:params];
}
- (RKResponse*)deleteSynchronously:(NSString*)resourcePath {
RKRequest* request = [[[RKRequest alloc] initWithURL:[self URLForResourcePath:resourcePath]] autorelease];
[self setupRequest:request];
return [request deleteSynchronously];
return [self loadSynchronously:resourcePath method:RKRequestMethodDELETE];
}
@end

65
Code/RKModelLoader.m
View File

@@ -6,8 +6,10 @@
// Copyright 2009 Two Toasters. All rights reserved.
//
#import <CoreData/CoreData.h>
#import "RKModelLoader.h"
#import "RKResponse.h"
#import "RKModelManager.h"
@implementation RKModelLoader
@@ -30,11 +32,7 @@
[super dealloc];
}
- (SEL)memberCallback {
return @selector(loadModelFromResponse:);
}
- (SEL)collectionCallback {
- (SEL)callback {
return @selector(loadModelsFromResponse:);
}
@@ -54,6 +52,7 @@
if (nil == errorMessage) {
errorMessage = [response payloadString];
}
// TODO: Eliminate this method in favor of a single error dispatch
[_delegate modelLoaderRequest:response.request didReturnErrorMessage:errorMessage response:response model:(id<RKModelMappable>)request.userData];
return YES;
} else if ([response isServerError]) {
@@ -65,35 +64,52 @@
return NO;
}
- (void)processLoadModelInBackground:(RKResponse*)response {
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
id model = response.request.userData;
if (model) {
[_mapper mapModel:model fromString:[response payloadString]];
} else {
model = [_mapper mapFromString:[response payloadString]];
}
[_delegate performSelectorOnMainThread:self.callback withObject:model waitUntilDone:NO];
[pool release];
// TODO: This locking implementation needs to be further cleaned up...
- (void)lockManagedObjectContext {
NSManagedObjectContext* managedObjectContext = [[[RKModelManager manager] objectStore] managedObjectContext];
[managedObjectContext retain];
[managedObjectContext lock];
}
- (void)loadModelFromResponse:(RKResponse*)response {
if (NO == [self encounteredErrorWhileProcessingRequest:response] && [response isSuccessful]) {
[self performSelectorInBackground:@selector(processLoadModelInBackground:) withObject:response];
}
- (void)unlockManagedObjectContext {
NSManagedObjectContext* managedObjectContext = [[[RKModelManager manager] objectStore] managedObjectContext];
[managedObjectContext unlock];
[managedObjectContext release];
}
- (void)informDelegateOfModelLoadWithInfoDictionary:(NSDictionary*)dictionary {
RKResponse* response = [dictionary objectForKey:@"response"];
NSArray* models = [dictionary objectForKey:@"models"];
[dictionary release];
RKRequest* request = response.request;
[_delegate modelLoaderRequest:request didLoadModels:models response:response model:(id<RKModelMappable>)request.userData];
// Release the response now that we have finished all our processing
[response release];
}
- (void)processLoadModelsInBackground:(RKResponse *)response {
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
// NSLog(@"RKModelLoader -> processLoadModelsInBackground: Processing response %@", [response payloadString]);
NSArray* models = [_mapper mapFromString:[response payloadString]];
// NSLog(@"RKModelLoader -> processLoadModelsInBackground: Loaded models %@", models);
[_delegate performSelectorOnMainThread:self.callback withObject:models waitUntilDone:NO];
[self lockManagedObjectContext];
id mapperResult = [_mapper mapFromString:[response payloadString]];
NSArray* models = nil;
if ([mapperResult isKindOfClass:[NSArray class]]) {
models = mapperResult;
} else if ([mapperResult conformsToProtocol:@protocol(RKModelMappable)]) {
models = [NSArray arrayWithObject:mapperResult];
}
[self unlockManagedObjectContext];
NSDictionary* infoDictionary = [[NSDictionary dictionaryWithObjectsAndKeys:response, @"response", models, @"models", nil] retain];
[self performSelectorOnMainThread:@selector(informDelegateOfModelLoadWithInfoDictionary:) withObject:infoDictionary waitUntilDone:NO];
[pool release];
}
- (void)loadModelsFromResponse:(RKResponse*)response {
if (NO == [self encounteredErrorWhileProcessingRequest:response] && [response isSuccessful]) {
if (NO == [self encounteredErrorWhileProcessingRequest:response] && [response isSuccessful]) {
// Retain the response to prevent this thread from dealloc'ing before we have finished processing
[response retain];
[self performSelectorInBackground:@selector(processLoadModelsInBackground:) withObject:response];
}
}
@@ -121,7 +137,6 @@
}
}
// TODO: Implement
- (void)requestDidCancelLoad:(RKRequest*)request {
if ([_delegate respondsToSelector:@selector(requestDidCancelLoad:)]) {
[(NSObject<RKRequestDelegate>*)_delegate requestDidCancelLoad:request];

71
Code/RKModelManager.m
View File

@@ -91,95 +91,102 @@ static RKModelManager* sharedManager = nil;
- (void)registerModel:(Class<RKModelMappable>)class forElementNamed:(NSString*)elementName {
[_mapper registerModel:class forElementNamed:elementName];
}
/**
* Load a model from a restful resource and invoke the callback
*/
- (RKRequest*)loadModel:(NSString*)resourcePath delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback {
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
loader.callback = callback;
return [_client get:resourcePath delegate:loader callback:loader.memberCallback];
}
/**
* Load a collection of models from a restful resource and invoke the callback
* Load a collection of models from a restful resource
*/
- (RKRequest*)loadModels:(NSString*)resourcePath delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback {
- (RKRequest*)loadModels:(NSString *)resourcePath method:(RKRequestMethod)method params:(NSDictionary*)params delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
loader.callback = callback;
return [_client get:resourcePath delegate:loader callback:loader.collectionCallback];
return [_client load:resourcePath method:method params:params delegate:loader callback:loader.callback];
}
- (RKRequest*)loadModels:(NSString*)resourcePath params:(NSDictionary*)params delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback {
- (RKRequest*)loadModels:(NSString*)resourcePath delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
// return [self loadModels:resourcePath method:RKRequestMethodGET params:nil delegate:delegate];
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
loader.callback = callback;
return [_client get:resourcePath params:params delegate:loader callback:loader.collectionCallback];
return [_client get:resourcePath delegate:loader callback:loader.callback];
}
- (RKRequest*)getModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback {
- (RKRequest*)loadModels:(NSString*)resourcePath method:(RKRequestMethod)method delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
loader.callback = callback;
RKRequest* request = [_client get:[model memberPath] delegate:loader callback:loader.memberCallback];
return [_client load:resourcePath method:method delegate:loader callback:loader.callback];
}
- (RKRequest*)loadModels:(NSString*)resourcePath params:(NSDictionary*)params delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
return [_client get:resourcePath params:params delegate:loader callback:loader.callback];
}
/////
- (RKRequest*)getModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
RKRequest* request = [_client get:[model memberPath] delegate:loader callback:loader.callback];
request.userData = model;
return request;
}
- (RKRequest*)postModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback {
- (RKRequest*)postModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
loader.callback = callback;
RKParams* params = [RKParams paramsWithDictionary:[model resourceParams]];
RKRequest* request = [_client post:[model collectionPath] params:params delegate:loader callback:loader.memberCallback];
RKRequest* request = [_client post:[model collectionPath] params:params delegate:loader callback:loader.callback];
request.userData = model;
return request;
}
- (RKRequest*)putModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback {
- (RKRequest*)putModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
if ([self isOffline]) {
return nil;
}
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
loader.callback = callback;
RKParams* params = [RKParams paramsWithDictionary:[model resourceParams]];
RKRequest* request = [_client put:[model memberPath] params:params delegate:loader callback:loader.memberCallback];
RKRequest* request = [_client put:[model memberPath] params:params delegate:loader callback:loader.callback];
request.userData = model;
return request;
}
- (RKRequest*)deleteModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback {
- (RKRequest*)deleteModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate {
if ([self isOffline]) {
return nil;
}
// TODO: are we responsible for deleting the object too,
// or are we to assume that the caller has/will delete it?
// TODO: Right now we are sending back the response object for deletes. Wrong thing to do???
RKRequest* request = [_client delete:[model memberPath] delegate:delegate callback:callback];
RKModelLoader* loader = [RKModelLoader loaderWithMapper:self.mapper];
loader.delegate = delegate;
RKRequest* request = [_client delete:[model memberPath] delegate:delegate callback:loader.callback];
request.userData = model;
return request;
}

96
Code/RKRequest.m
View File

@@ -14,7 +14,7 @@
@implementation RKRequest
@synthesize URL = _URL, URLRequest = _URLRequest, delegate = _delegate, callback = _callback, additionalHTTPHeaders = _additionalHTTPHeaders,
params = _params, userData = _userData, username = _username, password = _password;
params = _params, userData = _userData, username = _username, password = _password, method = _method;
+ (RKRequest*)requestWithURL:(NSURL*)URL delegate:(id)delegate callback:(SEL)callback {
RKRequest* request = [[RKRequest alloc] initWithURL:URL delegate:delegate callback:callback];
@@ -54,10 +54,6 @@
[super dealloc];
}
- (NSString*)HTTPMethod {
return [_URLRequest HTTPMethod];
}
- (void)addHeadersToRequest {
NSString* header;
for (header in _additionalHTTPHeaders) {
@@ -69,7 +65,38 @@
NSLog(@"Headers: %@", [_URLRequest allHTTPHeaderFields]);
}
- (void)setMethod:(RKRequestMethod)method {
_method = method;
[_URLRequest setHTTPMethod:[self HTTPMethod]];
}
- (void)setParams:(NSObject<RKRequestSerializable>*)params {
_params = [params retain];
[_URLRequest setHTTPBody:[_params HTTPBody]];
}
- (NSString*)HTTPMethod {
switch (_method) {
case RKRequestMethodGET:
return @"GET";
break;
case RKRequestMethodPOST:
return @"POST";
break;
case RKRequestMethodPUT:
return @"PUT";
break;
case RKRequestMethodDELETE:
return @"DELETE";
break;
default:
return nil;
break;
}
}
- (void)send {
[self addHeadersToRequest];
NSString* body = [[NSString alloc] initWithData:[_URLRequest HTTPBody] encoding:NSUTF8StringEncoding];
NSLog(@"Sending %@ request to URL %@. HTTP Body: %@", [self HTTPMethod], [[self URL] absoluteString], body);
[body release];
@@ -80,7 +107,8 @@
_connection = [[NSURLConnection connectionWithRequest:_URLRequest delegate:response] retain];
}
- (RKResponse*)sendSynchronous {
- (RKResponse*)sendSynchronously {
[self addHeadersToRequest];
NSString* body = [[NSString alloc] initWithData:[_URLRequest HTTPBody] encoding:NSUTF8StringEncoding];
NSLog(@"Sending synchronous %@ request to URL %@. HTTP Body: %@", [self HTTPMethod], [[self URL] absoluteString], body);
[body release];
@@ -93,60 +121,14 @@
return [[[RKResponse alloc] initWithSynchronousRequest:self URLResponse:URLResponse payload:payload error:error] autorelease];
}
- (void)get {
[_URLRequest setHTTPMethod:@"GET"];
[self addHeadersToRequest];
- (void)sendWithMethod:(RKRequestMethod)method {
self.method = method;
[self send];
}
- (void)postParams:(NSObject<RKRequestSerializable>*)params {
[_URLRequest setHTTPMethod:@"POST"];
_params = [params retain];
[_URLRequest setHTTPBody:[_params HTTPBody]];
[self addHeadersToRequest];
[self send];
}
- (void)putParams:(NSObject<RKRequestSerializable>*)params {
[_URLRequest setHTTPMethod:@"PUT"];
_params = [params retain];
[_URLRequest setHTTPBody:[_params HTTPBody]];
[self addHeadersToRequest];
[self send];
}
- (void)delete {
[_URLRequest setHTTPMethod:@"DELETE"];
[self addHeadersToRequest];
[self send];
}
- (RKResponse*)putParamsSynchronously:(NSObject<RKRequestSerializable>*)params {
[_URLRequest setHTTPMethod:@"PUT"];
_params = [params retain];
[_URLRequest setHTTPBody:[_params HTTPBody]];
[self addHeadersToRequest];
return [self sendSynchronous];
}
- (RKResponse*)getSynchronously {
[_URLRequest setHTTPMethod:@"GET"];
[self addHeadersToRequest];
return [self sendSynchronous];
}
- (RKResponse*)postParamsSynchronously:(NSObject<RKRequestSerializable>*)params {
[_URLRequest setHTTPMethod:@"POST"];
_params = [params retain];
[_URLRequest setHTTPBody:[_params HTTPBody]];
[self addHeadersToRequest];
return [self sendSynchronous];
}
- (RKResponse*)deleteSynchronously {
[_URLRequest setHTTPMethod:@"DELETE"];
[self addHeadersToRequest];
return [self sendSynchronous];
- (RKResponse*)sendSynchronouslyWithMethod:(RKRequestMethod)method {
self.method = method;
return [self sendSynchronously];
}
- (void)cancel {

10
Code/RestKit/RKClient.h
View File

@@ -78,6 +78,16 @@
// Asynchronous Requests
///////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Load a resource via the specified HTTP method and invoke a callback with the resulting payload
*/
- (RKRequest*)load:(NSString*)resourcePath method:(RKRequestMethod)method delegate:(id)delegate callback:(SEL)callback;
/**
* Load a resource via the specified HTTP method and invoke a callback with the resulting payload
*/
- (RKRequest*)load:(NSString*)resourcePath method:(RKRequestMethod)method params:(NSObject<RKRequestSerializable>*)params delegate:(id)delegate callback:(SEL)callback;
/**
* Fetch a resource via an HTTP GET and invoke a callback with the result
*/

6
Code/RestKit/RKManagedObjectStore.h
View File

@@ -23,9 +23,9 @@ extern NSString* const RKManagedObjectStoreDidFailSaveNotification;
}
@property (nonatomic, readonly) NSString* storeFilename;
@property (nonatomic, readonly) NSManagedObjectModel *managedObjectModel;
@property (nonatomic, readonly) NSManagedObjectContext *managedObjectContext;
@property (nonatomic, readonly) NSPersistentStoreCoordinator *persistentStoreCoordinator;
@property (nonatomic, readonly) NSManagedObjectModel* managedObjectModel;
@property (nonatomic, readonly) NSManagedObjectContext* managedObjectContext;
@property (nonatomic, readonly) NSPersistentStoreCoordinator* persistentStoreCoordinator;
/**
* Initialize a new managed object store with a SQLite database with the filename specified

19
Code/RestKit/RKModelLoader.h
View File

@@ -12,7 +12,11 @@
@protocol RKModelLoaderDelegate <RKRequestDelegate>
// TODO: didLoadModel: modelDidLoad: modelLoaderDidLoad:
/**
* Invoked when a request sent through the model manager loads a collection of models. The model will be nil if the request was
* not dispatched with a model object instance
*/
- (void)modelLoaderRequest:(RKRequest*)request didLoadModels:(NSArray*)models response:(RKResponse*)response model:(id<RKModelMappable>)model;
/**
* Invoked when a request sent through the model manager encounters an error. The model will be nil if the request was
@@ -23,6 +27,7 @@
/**
* Invoked when a request sent through the model manager returns an error message from the server.
*/
// TODO: Gets eliminated
- (void)modelLoaderRequest:(RKRequest*)request didReturnErrorMessage:(NSString*)errorMessage response:(RKResponse*)response model:(id<RKModelMappable>)model;
@end
@@ -46,20 +51,10 @@
*/
@property (nonatomic, retain) NSObject<RKModelLoaderDelegate>* delegate;
/**
* The method to invoke after loading the models
*/
@property (nonatomic, assign) SEL callback;
/**
* The method to invoke to trigger model mappings. Used as the callback for a restful model mapping request
*/
@property (nonatomic, readonly) SEL memberCallback;
/**
* The method to invoke to trigger model mappings. Used as the callback for a restful model mapping request
*/
@property (nonatomic, readonly) SEL collectionCallback;
@property (nonatomic, readonly) SEL callback;
+ (id)loaderWithMapper:(RKModelMapper*)mapper;

27
Code/RestKit/RKModelManager.h
View File

@@ -11,6 +11,7 @@
#import "RKManagedObjectStore.h"
#import "RKModelLoader.h"
// Notifications
extern NSString* const RKDidEnterOfflineModeNotification;
extern NSString* const RKDidEnterOnlineModeNotification;
@@ -88,40 +89,42 @@ extern NSString* const RKDidEnterOnlineModeNotification;
/**
* Fetch a resource via an HTTP GET and invoke a callback with the model for the resulting payload
*/
- (RKRequest*)loadModel:(NSString*)resourcePath delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback;
- (RKRequest*)loadModels:(NSString*)resourcePath delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
// Load via a method...
- (RKRequest*)loadModels:(NSString*)resourcePath method:(RKRequestMethod)method delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
/**
* Fetch a resource via an HTTP GET and invoke a callback with the model for the resulting payload
* Fetch a resource via a specified HTTP method
*/
- (RKRequest*)loadModels:(NSString*)resourcePath delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback;
- (RKRequest*)loadModels:(NSString *)resourcePath method:(RKRequestMethod)method params:(NSDictionary*)params delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
/**
* Fetch a resource via an HTTP POST with a dictionary of parameters and invoke a callback with the models mapped from the payload
*
* TODO: This may not be right... may want to allow specification of the HTTP verb. The use case is to support
* loading a remote resource where the amount of data exceeds what is encodeable in URL parameters. This comes up
* in GateGuru when loading HighFlyer's from Facebook friends, as the payload gets big fast.
*/
- (RKRequest*)loadModels:(NSString*)resourcePath params:(NSDictionary*)params delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback;
- (RKRequest*)loadModels:(NSString*)resourcePath params:(NSDictionary*)params delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
////////////////////////////////////////////////////////
// Model Mappable object helpers
/**
* Update a mappable model by loading its attributes from the web
*/
- (RKRequest*)getModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback;
- (RKRequest*)getModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
/**
* Create a remote mappable model by POSTing the attributes to the remote resource and loading the resulting model from the payload
*/
- (RKRequest*)postModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback;
- (RKRequest*)postModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
/**
* Update a remote mappable model by PUTing the attributes to the remote resource and loading the resulting model from the payload
*/
- (RKRequest*)putModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback;
- (RKRequest*)putModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
/**
* Delete the remote instance of a mappable model by performing an HTTP DELETE on the remote resource
*/
- (RKRequest*)deleteModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate callback:(SEL)callback;
- (RKRequest*)deleteModel:(id<RKModelMappable>)model delegate:(NSObject<RKModelLoaderDelegate>*)delegate;
@end

56
Code/RestKit/RKRequest.h
View File

@@ -10,6 +10,13 @@
#import "DocumentRoot.h"
#import "RKRequestSerializable.h"
typedef enum RKRequestMethod {
RKRequestMethodGET = 0,
RKRequestMethodPOST,
RKRequestMethodPUT,
RKRequestMethodDELETE
} RKRequestMethod;
@class RKResponse;
@interface RKRequest : NSObject {
@@ -23,6 +30,7 @@
id _userData;
NSString* _username;
NSString* _password;
RKRequestMethod _method;
}
/**
@@ -66,7 +74,13 @@
/**
* A serializable collection of parameters sent as the HTTP Body of the request
*/
@property(nonatomic, readonly) NSObject<RKRequestSerializable>* params;
// TODO: Should I be copy?
@property(nonatomic, retain) NSObject<RKRequestSerializable>* params;
/**
* The HTTP verb the request is sent via
*/
@property(nonatomic, assign) RKRequestMethod method;
////////////////////////////////////////////////////////////////////////////////
@@ -88,48 +102,24 @@
- (id)initWithURL:(NSURL*)URL delegate:(id)delegate callback:(SEL)callback;
/**
* GET the resource and invoke the callback with the response payload
* Send the request asynchronously
*/
- (void)get;
- (void)send;
/**
* POST a collection of params to the resource and invoke the callback with the response payload
* Send the request synchronously and return a hydrated response object
*/
- (void)postParams:(NSObject<RKRequestSerializable>*)params;
- (RKResponse*)sendSynchronously;
/**
* PUT a collection of params to the resource and invoke the callback with the response payload
* Utility method for setting the request HTTP method and then sending the method asynchronously
*/
- (void)putParams:(NSObject<RKRequestSerializable>*)params;
- (void)sendWithMethod:(RKRequestMethod)method;
/**
* DELETE the resource and invoke the callback with the response payload
* Utility method for setting the request HTTP method and then sending the method synchronously
*/
- (void)delete;
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Synchronous Requests
///////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* GET the resource and invoke the callback with the response payload
*/
- (RKResponse*)getSynchronously;
/**
* POST a collection of params to the resource and invoke the callback with the response payload
*/
- (RKResponse*)postParamsSynchronously:(NSObject<RKRequestSerializable>*)params;
/**
* PUT a collection of params to the resource and invoke the callback with the response payload
*/
- (RKResponse*)putParamsSynchronously:(NSObject<RKRequestSerializable>*)params;
/**
* DELETE the resource and invoke the callback with the response payload
*/
- (RKResponse*)deleteSynchronously;
- (RKResponse*)sendSynchronouslyWithMethod:(RKRequestMethod)method;
/**
* Cancels the underlying URL connection