candle 0.0.1

data/lib/candle/generators/lua/wax/lib/extensions/HTTP/wax_http.h

@@ -0,0 +1,14 @@
+//
+//    wax_http.h
+//    Rentals
+//
+//    Created by ProbablyInteractive on 7/13/09.
+//    Copyright 2009 Probably Interactive. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+#import "lua.h"
+
+#define WAX_HTTP_METATABLE_NAME "wax.http"
+
+int luaopen_wax_http(lua_State *L);

data/lib/candle/generators/lua/wax/lib/extensions/HTTP/wax_http.m

@@ -0,0 +1,240 @@
+//
+//    wax_http.m
+//    Rentals
+//
+//    Created by ProbablyInteractive on 7/13/09.
+//    Copyright 2009 Probably Interactive. All rights reserved.
+//
+
+#import "wax_http.h"
+#import "wax_http_connection.h"
+#import "wax_instance.h"
+#import "wax_helpers.h"
+
+#import "lua.h"
+#import "lauxlib.h"
+
+const NSTimeInterval WAX_HTTP_TIMEOUT = 30;
+
+static int request(lua_State *L);
+
+static BOOL pushCallback(lua_State *L, char *callbackName, int table_index);
+
+static int getFormat(lua_State *L, int tableIndex);
+static NSURLRequestCachePolicy getCachePolicy(lua_State *L, int tableIndex);
+static NSDictionary *getHeaders(lua_State *L, int tableIndex);
+static NSString *getMethod(lua_State *L, int tableIndex);
+static NSTimeInterval getTimeout(lua_State *L, int tableIndex);
+static NSString *getBody(lua_State *L, int tableIndex);
+
+static const struct luaL_Reg metaFunctions[] = {
+    {NULL, NULL}
+};
+
+static const struct luaL_Reg functions[] = {
+    {"request", request},
+    {NULL, NULL}
+};
+
+int luaopen_wax_http(lua_State *L) {
+    BEGIN_STACK_MODIFY(L);
+    
+    luaL_newmetatable(L, WAX_HTTP_METATABLE_NAME);        
+    luaL_register(L, NULL, metaFunctions);
+    luaL_register(L, WAX_HTTP_METATABLE_NAME, functions);    
+    
+    lua_pushvalue(L, -2);
+    lua_setmetatable(L, -2); // Set the metatable for the module
+    
+    END_STACK_MODIFY(L, 0)
+    
+    return 0;
+}
+
+// wax.request({url, options}) => returns connection object or (body, response) if syncronous
+// wax.request{url, options}   => same as above, but with syntax sugar
+// options:
+//   method = "get" | "post" | "put" | "delete"
+//   format = "text" | "binary" | "json" | "xml" # if none given, uses value from response Content-Type Header
+//   headers = table # Table of header values
+//   timout = number
+//   body = string
+//   cache = NSURLRequestCachePolicy # one of those enums, defaults to NSURLRequestUseProtocolCachePolicy
+//   callback = function(body, response) # No callback? Then treat request is treated as syncronous
+//   progressCallback = function(percentComplete, data) # Shows how much is left to download
+//   authCallback = function(NSURLAuthenticationChallenge) # Handle just like you would with NSURLConnection
+//   redirectCallback = function(response) # If there is a redirect, this callback will be called
+static int request(lua_State *L) {
+    lua_rawgeti(L, 1, 1);
+    
+    NSString *urlString = [NSString stringWithUTF8String:luaL_checkstring(L, -1)];
+    if (![urlString hasPrefix:@"http://"] && ![urlString hasPrefix:@"https://"]) urlString = [NSString stringWithFormat:@"http://%@", urlString];
+    NSURL *url = [NSURL URLWithString:urlString];
+    
+    lua_pop(L, 1); // Pop the url off the stack
+    
+    if (!url) luaL_error(L, "wax_http: Could not create URL from string '%s'", [urlString UTF8String]);
+          
+    
+    NSURLRequestCachePolicy cachePolicy = getCachePolicy(L, 1);
+    NSDictionary *headerFields = getHeaders(L, 1);
+    NSData *body = [getBody(L, 1) dataUsingEncoding:NSUTF8StringEncoding];
+    
+    // Get the format
+    int format = getFormat(L, 1);    
+    NSTimeInterval timeout = getTimeout(L, 1);
+    NSString *method = getMethod(L, 1);
+    
+    NSMutableURLRequest *urlRequest = [[NSMutableURLRequest alloc] initWithURL:url];
+
+	[urlRequest setHTTPMethod:method];
+    [urlRequest setCachePolicy:cachePolicy];
+    [urlRequest setAllHTTPHeaderFields:headerFields];
+    [urlRequest setHTTPBody:body];
+    
+    wax_http_connection *connection;
+    connection = [[[wax_http_connection alloc] initWithRequest:urlRequest timeout:timeout luaState:L] autorelease]; 
+    connection.format = format;
+    [urlRequest release];
+    
+    wax_instance_create(L, connection, NO);
+
+	if (pushCallback(L, WAX_HTTP_AUTH_CALLBACK_FUNCTION_NAME, 1)) {
+		lua_setfield(L, -2, WAX_HTTP_AUTH_CALLBACK_FUNCTION_NAME); // Set the authCallback function for the userdata         
+	}
+
+	if (pushCallback(L, WAX_HTTP_PROGRESS_CALLBACK_FUNCTION_NAME, 1)) {
+		lua_setfield(L, -2, WAX_HTTP_PROGRESS_CALLBACK_FUNCTION_NAME); // Set the progressCallback function for the userdata         
+	}	
+
+	if (pushCallback(L, WAX_HTTP_REDIRECT_CALLBACK_FUNCTION_NAME, 1)) {
+		lua_setfield(L, -2, WAX_HTTP_REDIRECT_CALLBACK_FUNCTION_NAME); // Set the redirectCallback function for the userdata         
+	}		
+	
+    // Asyncronous or Syncronous
+    if (pushCallback(L, WAX_HTTP_CALLBACK_FUNCTION_NAME, 1)) { 
+        lua_setfield(L, -2, WAX_HTTP_CALLBACK_FUNCTION_NAME); // Set the callback function for the userdata         
+
+        [connection start];
+        
+        return 1; // Return the connectionDelegate as userdata
+    }
+    else {    
+        [connection start];
+
+        NSRunLoop* runLoop = [NSRunLoop currentRunLoop];        
+        while (!connection.finished) {
+            [runLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+        }
+        
+        return 3;
+    }
+}
+
+static NSTimeInterval getTimeout(lua_State *L, int tableIndex) {
+    NSTimeInterval timeout = WAX_HTTP_TIMEOUT; // Default
+    if (lua_isnoneornil(L, tableIndex)) return timeout;
+    
+    lua_getfield(L, tableIndex, "timeout");
+    if (!lua_isnil(L, -1)) {
+        timeout = luaL_checknumber(L, -1);
+    }
+    lua_pop(L, 1);
+    
+    return timeout;
+}
+
+static NSDictionary *getHeaders(lua_State *L, int tableIndex) {
+    NSDictionary *headers = [NSDictionary dictionary];
+    
+    if (lua_isnoneornil(L, tableIndex)) return headers;
+
+    lua_getfield(L, tableIndex, "headers");
+    if (!lua_isnil(L, -1)) {
+        id *result = wax_copyToObjc(L, "@", -1, nil);
+        headers = *result;
+        free(result);
+    }
+    lua_pop(L, 1);
+    
+    return headers;
+}
+
+static NSString *getMethod(lua_State *L, int tableIndex) {
+    NSString *method = @"GET"; // Default
+    if (lua_isnoneornil(L, tableIndex)) return method;
+
+    lua_getfield(L, tableIndex, "method");
+    if (!lua_isnil(L, -1)) {
+        const char *string = luaL_checkstring(L, -1);
+        method = [[NSString stringWithUTF8String:string] uppercaseString];
+    }
+    lua_pop(L, 1);
+    
+    return method;
+}
+
+static NSURLRequestCachePolicy getCachePolicy(lua_State *L, int tableIndex) {
+    NSURLRequestCachePolicy cachePolicy = NSURLRequestUseProtocolCachePolicy;
+    if (lua_isnoneornil(L, tableIndex)) return cachePolicy;
+    
+    lua_getfield(L, tableIndex, "cache");
+    if (!lua_isnil(L, -1)) {
+        cachePolicy = luaL_checknumber(L, -1);
+    }
+    lua_pop(L, 1);
+    
+    return cachePolicy;
+}
+
+static int getFormat(lua_State *L, int tableIndex) {
+    int format = WAX_HTTP_UNKNOWN; // Default
+    if (lua_isnoneornil(L, tableIndex)) return format;
+
+    lua_getfield(L, tableIndex, "format");
+    if (!lua_isnil(L, -1)) {
+        const char *formatString = luaL_checkstring(L, -1);
+        if (strcasecmp(formatString, "text") == 0) {
+            format = WAX_HTTP_TEXT;
+        }
+        else if (strcasecmp(formatString, "binary") == 0) {
+            format = WAX_HTTP_BINARY;
+        }
+        else if (strcasecmp(formatString, "json") == 0) {
+            format = WAX_HTTP_JSON;
+        }
+        else {
+            luaL_error(L, "wax_http: Unknown format name '%s'", formatString);
+        }
+    }
+    lua_pop(L, 1);  
+    
+    return format;
+}
+
+static NSString *getBody(lua_State *L, int tableIndex) {
+    NSString *body = @""; // Default
+    if (lua_isnoneornil(L, tableIndex)) return body;
+    
+    lua_getfield(L, tableIndex, "body");
+    if (!lua_isnil(L, -1)) {
+        const char *string = luaL_checkstring(L, -1);
+        body = [NSString stringWithUTF8String:string];
+    }
+    lua_pop(L, 1);
+    
+    return body;
+}
+
+// Assumes table is on top of the stack
+static BOOL pushCallback(lua_State *L, char *callbackName, int tableIndex) {
+    lua_getfield(L, tableIndex, callbackName);
+
+    if (lua_isnil(L, -1)) {
+        lua_pop(L, 1);
+        return NO;
+    }
+    else {
+        return YES;
+    }
+}

data/lib/candle/generators/lua/wax/lib/extensions/HTTP/wax_http_connection.h

@@ -0,0 +1,54 @@
+//
+//    wax_http_connection.h
+//    RentList
+//
+//    Created by Corey Johnson on 8/9/09.
+//    Copyright 2009 ProbablyInteractive. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+#import "lua.h"
+
+enum {
+    WAX_HTTP_UNKNOWN,
+    WAX_HTTP_TEXT,
+    WAX_HTTP_BINARY, // Like an image or something
+    WAX_HTTP_JSON,
+    WAX_HTTP_XML
+};
+
+#define WAX_HTTP_CALLBACK_FUNCTION_NAME "callback"
+#define WAX_HTTP_PROGRESS_CALLBACK_FUNCTION_NAME "progressCallback"
+#define WAX_HTTP_AUTH_CALLBACK_FUNCTION_NAME "authCallback"
+#define WAX_HTTP_REDIRECT_CALLBACK_FUNCTION_NAME "redirectCallback"
+
+@interface wax_http_connection : NSURLConnection {
+    lua_State *L;
+    NSMutableData *_data;
+    NSHTTPURLResponse *_response;
+    NSURLRequest *_request;
+    NSTimer *_timeoutTimer;
+    NSError *_error;
+    
+    NSTimeInterval _timeout;
+    int _format;
+    bool _finished;
+    bool _canceled;
+}
+
+@property (nonatomic, assign) NSHTTPURLResponse *response;
+
+@property (nonatomic, assign) int format;
+@property (nonatomic, readonly, getter=isFinished) bool finished;
+
+- (id)initWithRequest:(NSURLRequest *)urlRequest timeout:(NSTimeInterval)timeout luaState:(lua_State *)luaState;
+- (void)callRedirectCallback:(NSURLResponse *)redirectResponse;
+- (BOOL)callLuaAuthCallback:(NSURLAuthenticationChallenge *)challenge;
+- (void)callLuaProgressCallback;
+- (void)callLuaCallback;
+
+// HSHTTPURLResponse Delegate Methods
+- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error;
+
+@end
+

data/lib/candle/generators/lua/wax/lib/extensions/HTTP/wax_http_connection.m

@@ -0,0 +1,304 @@
+//
+//    wax_http_connection.m
+//    RentList
+//
+//    Created by Corey Johnson on 8/9/09.
+//    Copyright 2009 ProbablyInteractive. All rights reserved.
+//
+
+#include <CommonCrypto/CommonDigest.h>
+
+#import "lauxlib.h"
+
+#import "wax_http_connection.h"
+#import "wax_instance.h"
+#import "wax_helpers.h"
+#import "wax_json.h"
+
+#ifdef WAX_XML_INCLUDED
+#import "wax_xml.h"
+#endif
+
+@implementation wax_http_connection
+
+@synthesize response=_response;
+@synthesize format=_format;
+@synthesize finished=_finished;
+
+- (void)dealloc {
+    [_data release];
+    [_error release];
+    [_response release];
+    [_request release];
+    [_timeoutTimer release];
+    [super dealloc];
+}
+
+- (id)initWithRequest:(NSURLRequest *)urlRequest timeout:(NSTimeInterval)timeout luaState:(lua_State *)luaState {
+    self = [super initWithRequest:urlRequest delegate:self startImmediately:NO];
+    [self scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
+    L = luaState;
+
+    _data = [[NSMutableData alloc] init];
+    _request = [urlRequest retain];
+
+    _timeout = timeout;
+    _format = WAX_HTTP_UNKNOWN;
+    _canceled = NO;
+    return self;
+}
+
+- (void)timeoutHack {
+    NSError *error = [NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorTimedOut userInfo:nil];
+    [self connection:self didFailWithError:error];
+    [self cancel];
+}
+
+- (void)start {
+    // Apple makes has a mandatory 240 second minimum timeout WTF? https://devforums.apple.com/thread/25282
+    // Because of this stupidity by Apple, we are forced to setup our own timeout
+    // using a timer.
+    _timeoutTimer = [[NSTimer scheduledTimerWithTimeInterval:_timeout target:self selector:@selector(timeoutHack) userInfo:nil repeats:NO] retain]; 
+    wax_log(LOG_NETWORK, @"HTTP(%@) %@", [_request HTTPMethod], [_request URL]);
+    [super start];
+}
+
+- (void)cancel {
+	wax_log(LOG_NETWORK, @"CANCELING (%@) %@", [_request HTTPMethod], [_request URL]);
+    [_timeoutTimer invalidate];
+    _canceled = YES;
+    [super cancel];
+}
+
+- (bool)isFinished {
+	return _canceled || _finished;
+}
+
+- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response {
+    if (response != _response) [_response release];
+    _response = [response retain];
+}
+
+- (NSURLRequest *)connection:(NSURLConnection *)connection willSendRequest:(NSURLRequest *)request redirectResponse:(NSURLResponse *)redirectResponse {
+	if (redirectResponse) [self callRedirectCallback:redirectResponse];
+	return request;
+}
+
+- (void)connection:(NSURLConnection *)connection didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {
+    if (![self callLuaAuthCallback:challenge]) {
+        [[challenge sender] continueWithoutCredentialForAuthenticationChallenge:challenge];
+    }
+}
+
+- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
+    [_data appendData:data];
+	[self callLuaProgressCallback];
+}
+
+- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error {
+    if (!_canceled) {
+        _error = [error retain];
+        [_data release];
+        _data = nil;
+        [self callLuaCallback];
+    }
+}
+
+- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
+    if (!_canceled) {
+        [self callLuaCallback];
+    }
+}
+
+- (void)callRedirectCallback:(NSURLResponse *)redirectResponse {
+	BEGIN_STACK_MODIFY(L)
+    
+    if (_canceled) {
+        assert("OH NO, URL CONNECTION WAS CANCELED BUT NOT CAUGHT");
+    }
+    
+    wax_instance_pushUserdata(L, self);
+    lua_getfield(L, -1, WAX_HTTP_REDIRECT_CALLBACK_FUNCTION_NAME);
+    
+    bool hasCallback = YES;
+    if (lua_isnil(L, -1)) { 
+        hasCallback = NO;
+        lua_pop(L, 1);
+    }
+    
+    wax_fromObjc(L, "@", &redirectResponse);
+    
+    if (hasCallback && wax_pcall(L, 1, 0)) {
+        const char* error_string = lua_tostring(L, -1);
+        luaL_error(L, "Problem calling Lua function '%s' from wax_http.\n%s", WAX_HTTP_REDIRECT_CALLBACK_FUNCTION_NAME, error_string);
+    }
+    
+    END_STACK_MODIFY(L, 0)
+}
+
+- (BOOL)callLuaAuthCallback:(NSURLAuthenticationChallenge *)challenge { 
+    BEGIN_STACK_MODIFY(L)
+    
+    if (_canceled) {
+        assert("OH NO, URL CONNECTION WAS CANCELED BUT NOT CAUGHT");
+    }
+    
+    wax_instance_pushUserdata(L, self);
+    lua_getfield(L, -1, WAX_HTTP_AUTH_CALLBACK_FUNCTION_NAME);
+    
+    bool hasCallback = YES;
+    if (lua_isnil(L, -1)) { 
+        hasCallback = NO;
+        lua_pop(L, 1);
+    }
+    
+    wax_fromObjc(L, "@", &challenge);
+    
+    if (hasCallback && wax_pcall(L, 1, 0)) {
+        const char* error_string = lua_tostring(L, -1);
+        luaL_error(L, "Problem calling Lua function '%s' from wax_http.\n%s", WAX_HTTP_AUTH_CALLBACK_FUNCTION_NAME, error_string);
+    }
+    
+    END_STACK_MODIFY(L, 0)
+    
+    return hasCallback;
+}
+
+- (void)callLuaProgressCallback { 
+    BEGIN_STACK_MODIFY(L)
+    
+    if (_canceled) {
+        assert("OH NO, URL CONNECTION WAS CANCELED BUT NOT CAUGHT");
+    }
+    
+    wax_instance_pushUserdata(L, self);
+    lua_getfield(L, -1, WAX_HTTP_PROGRESS_CALLBACK_FUNCTION_NAME);
+    
+    if (lua_isnil(L, -1)) { 
+        lua_pop(L, 1);
+    }
+	else {
+		float percentComplete = 0;
+		
+		@try {
+			percentComplete = _data.length / [[[_response allHeaderFields] objectForKey:@"Content-Length"] floatValue];
+		}
+		@catch (NSException * e) {
+			NSLog(@"Error: Couldn't calculate percent Complete");
+		}
+		
+		
+		wax_fromObjc(L, "f", &percentComplete);
+		wax_fromObjc(L, "@", &_data);
+    
+		if (wax_pcall(L, 2, 0)) {
+			const char* error_string = lua_tostring(L, -1);
+			luaL_error(L, "Problem calling Lua function '%s' from wax_http.\n%s", WAX_HTTP_PROGRESS_CALLBACK_FUNCTION_NAME, error_string);
+		}
+	}
+    
+    END_STACK_MODIFY(L, 0)
+}
+
+
+- (void)callLuaCallback { 
+    [_timeoutTimer invalidate];
+    
+    BEGIN_STACK_MODIFY(L)
+    
+    if (_canceled) {
+        assert("OH NO, URL CONNECTION WAS CANCELED BUT NOT CAUGHT");
+    }
+    
+    wax_instance_pushUserdata(L, self);
+    lua_getfield(L, -1, WAX_HTTP_CALLBACK_FUNCTION_NAME);
+    
+    bool hasCallback = YES;
+    if (lua_isnil(L, -1)) { 
+        hasCallback = NO;
+        lua_pop(L, 1);
+    }
+    
+    // Try and guess the format type
+    if (_format == WAX_HTTP_UNKNOWN) {
+        NSString *contentType = [[_response allHeaderFields] objectForKey:@"Content-Type"];
+
+        if ([contentType hasPrefix:@"application/xml"] ||
+            [contentType hasPrefix:@"text/xml"]) {
+#ifdef WAX_XML_INCLUDED
+            _format = WAX_HTTP_XML;
+#else
+			_format = WAX_HTTP_TEXT;
+#endif
+        }
+        else if ([contentType hasPrefix:@"application/json"] ||
+                 [contentType hasPrefix:@"text/json"] ||
+                 [contentType hasPrefix:@"application/javascript"] ||
+                 [contentType hasPrefix:@"text/javascript"]) {
+            _format = WAX_HTTP_JSON;
+        }
+        else if ([contentType hasPrefix:@"image/"] ||
+                 [contentType hasPrefix:@"audio/"] ||
+                 [contentType hasPrefix:@"application/octet-stream"]) {
+            _format = WAX_HTTP_BINARY;
+        }
+        else {
+            _format = WAX_HTTP_TEXT;
+        }
+    }
+    
+    if (_error) {
+        lua_pushnil(L);
+    }
+    else if (_format == WAX_HTTP_TEXT || _format == WAX_HTTP_JSON || _format == WAX_HTTP_XML) {
+        NSString *string = [[NSString alloc] initWithData:_data encoding:NSUTF8StringEncoding];
+        if (!string) string = [[NSString alloc] initWithData:_data encoding:NSISOLatin1StringEncoding];
+        if (!string) string = [[NSString alloc] initWithData:_data encoding:NSNonLossyASCIIStringEncoding];
+        if (!string) string = [[NSString alloc] initWithData:_data encoding:NSNonLossyASCIIStringEncoding];        
+        
+        
+        if (_format == WAX_HTTP_JSON) {
+            json_parseString(L, [string UTF8String]);            
+        }
+        else if (_format == WAX_HTTP_XML){
+#ifdef WAX_XML_INCLUDED
+            wax_xml_parseString(L, [string UTF8String]);
+#else
+			luaL_error(L, "Trying to parse xml, but xml library not included.");
+#endif
+        }
+        else {
+            wax_fromObjc(L, "@", &string);
+        }
+
+        
+        [string release];
+    }
+    else if (_format == WAX_HTTP_BINARY) {        
+        wax_fromObjc(L, "@", &_data);
+    }
+    else {
+        luaL_error(L, "wax_http: Unknown wax_http format '%d'", _format);
+    }
+    
+    wax_fromObjc(L, "@", &_response);
+    if (_error) {
+        wax_fromObjc(L, "@", &_error);
+    }
+    else {
+        lua_pushnil(L);
+    }
+
+    
+    
+    if (hasCallback && wax_pcall(L, 3, 0)) {
+        const char* error_string = lua_tostring(L, -1);
+        luaL_error(L, "Problem calling Lua function '%s' from wax_http.\n%s", WAX_HTTP_CALLBACK_FUNCTION_NAME, error_string);
+    }
+    
+    _finished = YES;
+    
+    END_STACK_MODIFY(L, 3)
+}
+
+@end