candle 0.0.1

data/lib/candle/generators/lua/wax/lib/extensions/filesystem/wax_filesystem.h

@@ -0,0 +1,9 @@
+//
+//  Created by Corey Johnson on 10/5/09.
+//  Copyright 2009 Probably Interactive. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "lua.h"
+
+int luaopen_wax_filesystem(lua_State *L);

data/lib/candle/generators/lua/wax/lib/extensions/filesystem/wax_filesystem.m

@@ -0,0 +1,273 @@
+//
+//  Created by Corey Johnson on 10/5/09.
+//  Copyright 2009 Probably Interactive. All rights reserved.
+//
+
+#import "wax_filesystem.h"
+
+#import "wax_instance.h"
+#import "wax_helpers.h"
+
+#import "lua.h"
+#import "lauxlib.h"
+
+#define TABLE_NAME "wax.filesystem"
+
+// wax.filesystem.search(searchPath, [pattern]) => table
+//     searchPath: string # where to start search (must be a directory)
+//     pattern: string # only include files that match the pattern
+static int search(lua_State *L) {
+    NSString *searchPath = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+    const char *searchPattern = nil;
+
+    if (lua_gettop(L) > 1) {
+        searchPattern = luaL_checkstring(L, 2);
+    }
+    
+    NSFileManager *fm = [NSFileManager defaultManager];
+    NSError *error = nil;
+    
+    NSArray *filenames = [fm subpathsOfDirectoryAtPath:searchPath error:&error];
+    NSMutableArray *paths = [NSMutableArray array];
+    
+    for (NSString *filename in filenames) {        
+        [paths addObject:[searchPath stringByAppendingPathComponent:filename]];
+    }
+    
+    if (error) {
+        luaL_error(L, "Could not read directory path at '%s'. Error: %s", [searchPath UTF8String], [[error localizedDescription] UTF8String]);
+    }
+    
+    if (searchPattern) { 
+        NSMutableArray *matchedPaths = [NSMutableArray array];
+        
+        lua_getglobal(L, "string");
+        
+        for (NSString *path in paths) {
+            lua_getfield(L, -1, "match");
+            lua_pushstring(L, [path UTF8String]);
+            lua_pushstring(L, searchPattern);            
+            lua_call(L, 2, 1);
+            
+            if (!lua_isnil(L, -1)) {
+                [matchedPaths addObject:path];
+            }
+            lua_pop(L, 1);            
+        }
+        
+        lua_pop(L, 1); // pop string table off the stack
+        
+        paths = matchedPaths;
+    }
+    
+    wax_fromObjc(L, "@", &paths);
+    
+    return 1;
+}
+
+
+// wax.filesystem.contents(path) => NSData | table
+//     path: string #if filepath is a directory, the result will be a table. A file will return NSData
+static int contents(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+    
+    NSFileManager *fm = [NSFileManager defaultManager];
+    BOOL directory;
+    BOOL exists = [fm fileExistsAtPath:path isDirectory:&directory];
+
+    if (!exists) {
+        lua_pushnil(L);
+    }    
+    else if (directory) {
+        NSError *error = nil;
+        NSArray *contents = [fm contentsOfDirectoryAtPath:path error:&error];   
+        
+        if (error) {
+            wax_log(LOG_DEBUG, @"Could not get contents for directory at '%@'\n%@", path, [error localizedDescription]);
+        }
+        
+        wax_fromObjc(L, "@", &contents);
+    }
+    else {
+        NSData *contents = [fm contentsAtPath:path];
+        wax_fromObjc(L, "@", &contents);
+    }
+    
+    return 1;
+}
+
+static int basename(lua_State *L) {
+    const char *path = luaL_checkstring(L, 1);
+    char *basename = strrchr(path, '/');
+    lua_pushstring(L, basename ? basename + 1 : path);
+    return 1;    
+}
+
+static int isDir(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+
+    NSFileManager *fm = [NSFileManager defaultManager];
+    BOOL directory;
+    BOOL exists = [fm fileExistsAtPath:path isDirectory:&directory];
+    
+    lua_pushboolean(L, exists && directory);
+    
+    return 1;    
+}
+
+static int isFile(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+    
+    NSFileManager *fm = [NSFileManager defaultManager];
+    BOOL directory;
+    BOOL exists = [fm fileExistsAtPath:path isDirectory:&directory];
+    
+    lua_pushboolean(L, exists && !directory);
+    
+    return 1;    
+}
+
+static int exists(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+    
+    NSFileManager *fm = [NSFileManager defaultManager];
+    BOOL exists = [fm fileExistsAtPath:path isDirectory:nil];
+    
+    lua_pushboolean(L, exists);
+    
+    return 1;    
+}
+
+// wax.filesystem.attributes(path) => table
+//     path: string 
+// 
+// # contains some simple mappings to some attributes (just look at the code to find out what is mapped)
+static int attributes(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+    
+    NSFileManager *fm = [NSFileManager defaultManager];    
+    NSError *error = nil;
+    NSMutableDictionary *attributes = [NSMutableDictionary dictionaryWithDictionary:[fm attributesOfItemAtPath:path error:&error]];
+    
+    if (error) {
+        wax_log(LOG_DEBUG, @"No attributes found for '%@'\n%@", path, [error localizedDescription]);
+        lua_pushnil(L);
+        return  1;
+    }
+
+    // Make some helper accessors
+    NSTimeInterval modifiedAt = [[attributes objectForKey:NSFileModificationDate] timeIntervalSince1970];
+    [attributes setObject:[NSNumber numberWithDouble:modifiedAt] forKey:@"modifiedAt"];
+
+    NSTimeInterval createdAt = [[attributes objectForKey:NSFileCreationDate] timeIntervalSince1970];
+    [attributes setObject:[NSNumber numberWithDouble:createdAt] forKey:@"createdAt"];
+
+    NSNumber *fileSize = [attributes objectForKey:NSFileSize];
+    [attributes setObject:fileSize forKey:@"size"];
+    
+    wax_fromObjc(L, "@", &attributes);
+    
+    return 1;
+}
+
+// wax.filesystem.createFile(path, content) => boolean
+//     path: string # filepath
+//     content: NSData | string # contents of file
+static int createFile(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+    NSData *data = nil;
+
+    if (lua_isstring(L, 2)) {
+        size_t contentLength;
+        const char *content = luaL_checklstring(L, 2, &contentLength);  
+        data = [NSData dataWithBytesNoCopy:(char *)content length:contentLength freeWhenDone:NO];
+    }
+    else { // Assume it is an NSData object
+        wax_instance_userdata *instanceUserdata = (wax_instance_userdata *)luaL_checkudata(L, 2, WAX_INSTANCE_METATABLE_NAME);
+        data = instanceUserdata->instance;
+    }
+        
+    NSError *error = nil;
+    BOOL success = [data writeToFile:path atomically:NO];
+    
+    if (!success) {
+        wax_log(LOG_DEBUG, @"Could not create file at '%@'\n%@", path, [error localizedDescription]);
+    }
+    
+    lua_pushboolean(L, success);
+    
+    return 1;
+}
+
+// wax.filesystem.createDir(path, createParentDirs) => boolean
+//     path: string # dir path
+//     createParentDirs: boolean # (optional) should intermediate parent dirs be created÷
+static int createDir(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+    BOOL createParentDirs = NO;
+    if (lua_gettop(L) > 1) createParentDirs = lua_toboolean(L, 2);
+    
+    NSError *error = nil;
+    NSFileManager *fm = [NSFileManager defaultManager];    
+    BOOL success = [fm createDirectoryAtPath:path withIntermediateDirectories:createParentDirs attributes:nil error:&error];
+    
+    if (!success) {
+        wax_log(LOG_DEBUG, @"Could not create dir at '%@'\n%@", path, [error localizedDescription]);
+    }
+    
+    lua_pushboolean(L, success);
+    
+    return 1;
+}
+
+
+// wax.filesystem.delete(path, [force]) => boolean
+//     path: string # deletes the path or directory (EVEN IF DIRECTORY HAS CONTENTS)
+static int delete(lua_State *L) {
+    NSString *path = [NSString stringWithUTF8String:luaL_checkstring(L, 1)];
+	
+	BOOL success = YES;
+    NSFileManager *fm = [NSFileManager defaultManager];    
+	if ([fm fileExistsAtPath:path]) {	
+		NSError *error = nil;
+		success = [fm removeItemAtPath:path error:&error];
+
+		if (!success) {
+			wax_log(LOG_DEBUG, @"Could not delete file at '%@'\n%@", path, [error localizedDescription]);
+		}
+	}
+	else {
+		wax_log(LOG_DEBUG, @"Trying to delete path that does not exist '%@'", path);
+	}
+	
+	lua_pushboolean(L, success);
+    
+    return 1;
+}
+
+static const struct luaL_Reg functions[] = {
+    {"search", search},
+    {"contents", contents},    
+    {"basename", basename},
+    {"exists", exists},
+    {"isDir", isDir},
+    {"isFile", isFile},
+    
+    {"attributes", attributes},
+    
+    {"createDir", createDir},   
+    {"createFile", createFile},    
+    {"delete", delete},
+
+    {NULL, NULL}
+};
+
+int luaopen_wax_filesystem(lua_State *L) {
+    BEGIN_STACK_MODIFY(L);
+    
+    luaL_register(L, TABLE_NAME, functions);    
+    
+    END_STACK_MODIFY(L, 0)
+    
+    return 1;
+}

data/lib/candle/generators/lua/wax/lib/extensions/json/Rakefile

@@ -0,0 +1,10 @@
+task :default do
+  sh 'tar zxvf yajl-1.0.9.tar.gz -- yajl-1.0.9/src/*.{c,h}'
+  rm_rf 'yajl'
+  mv 'yajl-1.0.9/src', 'yajl'
+  sh %[sed -i '' -e 's,include <yajl/yajl_common.h>,include "yajl_common.h",g' yajl/api/yajl_{parse,gen}.h]
+  ln_sf 'api/yajl_parse.h',  'yajl/'
+  ln_sf 'api/yajl_gen.h',    'yajl/'
+  ln_sf 'api/yajl_common.h', 'yajl/'
+  rm_rf 'yajl-1.0.9'
+end

data/lib/candle/generators/lua/wax/lib/extensions/json/wax_json.c

@@ -0,0 +1,304 @@
+#include "wax_json.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+
+#include "lua.h"
+#include "lauxlib.h"
+
+static int parse(lua_State *L);
+static int generate(lua_State *L);
+
+static const struct luaL_Reg metaFunctions[] = {
+    {NULL, NULL}
+};
+
+static const struct luaL_Reg functions[] = {
+    {"parse", parse},
+    {"generate", generate},
+    {NULL, NULL}
+};
+
+int luaopen_wax_json(lua_State *L) {    
+    luaL_newmetatable(L, JSON_METATABLE_NAME);        
+    luaL_register(L, NULL, metaFunctions);
+    luaL_register(L, JSON_METATABLE_NAME, functions);    
+    
+    lua_pop(L, 2); // Remove tables from stack,
+    
+    return 0;
+}
+
+#include "yajl/yajl_parse.h"
+#include "yajl/yajl_lex.h"
+#include "yajl/yajl_parser.h"
+#include "yajl/yajl_bytestack.h"
+#include "yajl/yajl_gen.h"
+#include <string.h>
+
+static yajl_gen gen;
+static yajl_handle hand;
+static yajl_bytestack state;
+enum {
+    state_begin,
+    state_array,
+    state_hash
+};
+
+void push_hash_or_array(lua_State *L) {
+    switch (yajl_bs_current(state)) {
+        case state_hash:
+            lua_rawset(L, -3);
+            break;
+        case state_array:
+            lua_rawseti(L, -2, lua_objlen(L, -2) + 1);
+            break;
+    }
+}
+
+static int push_null(void *ctx) {
+    lua_State *L = (lua_State *) ctx;
+    lua_pushnil(L);
+    push_hash_or_array(L);
+    return 1;
+}
+
+static int push_boolean(void *ctx, int boolean) {
+    lua_State *L = (lua_State *) ctx;
+    lua_pushboolean(L, boolean ? true : false);
+    push_hash_or_array(L);
+    return 1;
+}
+
+static int push_integer(void *ctx, long num) {
+    lua_State *L = (lua_State *) ctx;
+    lua_pushinteger(L, num);
+    push_hash_or_array(L);
+    return 1;
+}
+
+static int push_double(void *ctx, double num) {
+    lua_State *L = (lua_State *) ctx;
+    lua_pushnumber(L, num);
+    push_hash_or_array(L);
+    return 1;
+}
+
+static int push_string(void *ctx, const unsigned char *string, unsigned int len) {
+    lua_State *L = (lua_State *) ctx;
+    lua_pushlstring(L, (const char *)string, len);
+    push_hash_or_array(L);
+    return 1;
+}
+
+static int push_start_map(void *ctx) {
+    lua_State *L = (lua_State *) ctx;
+    yajl_bs_push(state, state_hash);
+    lua_newtable(L);
+    return 1;
+}
+
+static int push_map_key(void *ctx, const unsigned char *string, unsigned int len) {
+    lua_State *L = (lua_State *) ctx;
+    lua_pushlstring(L, (const char *)string, len);
+    return 1;
+}
+
+static int push_end_map(void *ctx) {
+    lua_State *L = (lua_State *) ctx;
+    yajl_bs_pop(state);
+    push_hash_or_array(L);
+    return 1;
+}
+
+static int push_start_array(void *ctx) {
+    lua_State *L = (lua_State *) ctx;
+    yajl_bs_push(state, state_array);
+    lua_newtable(L);
+    return 1;
+}
+
+static int push_end_array(void *ctx) {
+    lua_State *L = (lua_State *) ctx;
+    yajl_bs_pop(state);
+    push_hash_or_array(L);
+    return 1;
+}
+
+static yajl_callbacks callbacks = {
+    push_null,
+    push_boolean,
+    push_integer,
+    push_double,
+    NULL,
+    push_string,
+    push_start_map,
+    push_map_key,
+    push_end_map,
+    push_start_array,
+    push_end_array
+};
+
+static int parse_string(lua_State *L, const unsigned char* input, unsigned int len) {
+    yajl_parser_config cfg = { .allowComments = 1, .checkUTF8 = 0 };
+    yajl_status stat;
+    unsigned char* error = NULL;
+    char buffer[1024];
+
+    hand = yajl_alloc(&callbacks, &cfg, NULL, (void *) L);
+    yajl_bs_init(state, &(hand->alloc));
+    yajl_bs_push(state, state_begin);
+
+    stat = yajl_parse(hand, input, len);
+    if (stat == yajl_status_ok || stat == yajl_status_insufficient_data) {
+        stat = yajl_parse_complete(hand);
+    }
+
+    if (stat != yajl_status_ok) {
+        error = yajl_get_error(hand, 1, input, len);
+        strncpy(buffer, (const char *)error, 1024);
+        yajl_free_error(hand, error);
+        yajl_bs_free(state);
+        yajl_free(hand);
+        lua_pushstring(L, "ERROR: Could not parse JSON string");
+    } else {
+        yajl_bs_free(state);
+        yajl_free(hand);
+    }
+
+    return 1;
+}
+
+static int parse(lua_State *L) {
+    size_t len;
+    const char *input = lua_tolstring(L, -1, &len);
+
+    if (!input) {
+		lua_pushstring(L, "ERROR: Could not parse JSON string");
+		return 1;
+	}
+	
+	// Nothing to parse!
+	if (len == 0) {
+		lua_pushnil(L);
+		return 1;
+	}
+
+    return parse_string(L, (const unsigned char *)input, len);
+}
+
+void json_parseString(lua_State *L, const char *input) {
+    parse_string(L, (const unsigned char *)input, strlen(input));
+}
+
+void generate_value(yajl_gen gen, lua_State *L) {
+    yajl_gen_status stat;
+    int type = lua_type(L, -1);
+
+    switch (type) {
+        case LUA_TNIL:
+        case LUA_TNONE:
+            stat = yajl_gen_null(gen);
+            break;
+
+        case LUA_TBOOLEAN:
+            stat = yajl_gen_bool(gen, lua_toboolean(L, -1));
+            break;
+
+        case LUA_TNUMBER:
+        case LUA_TSTRING: {
+            size_t len;
+            const char *str;
+
+            if (type == LUA_TNUMBER) {
+                lua_pushvalue(L, -1); // copy of the number
+                str = lua_tolstring(L, -1, &len); // converts value on stack to a string
+                lua_pop(L, 1); // pop off copy
+                stat = yajl_gen_number(gen, str, (unsigned int)len);
+            } else {
+                str = lua_tolstring(L, -1, &len);
+                stat = yajl_gen_string(gen, (const unsigned char*)str, (unsigned int)len);
+            }
+            break;
+        }
+
+        case LUA_TTABLE: {
+            bool dictionary = false;
+            bool empty = true;
+
+            lua_pushvalue(L, -1); // Push the table reference on the top
+            lua_pushnil(L);  /* first key */
+            while (lua_next(L, -2)) {
+                empty = false;
+                if (lua_type(L, -2) != LUA_TNUMBER) {
+                    dictionary = true;
+                    lua_pop(L, 2); // pop key and value off the stack
+                    break;
+                }
+                else {
+                    lua_pop(L, 1);
+                }
+            }
+
+            if (empty)
+                dictionary = true;
+
+            if (dictionary)
+                yajl_gen_map_open(gen);
+            else
+                yajl_gen_array_open(gen);
+
+            lua_pushnil(L);  /* first key */
+            while (lua_next(L, -2)) {
+                if (dictionary) {
+                    size_t len;
+                    const char *str;
+                    if (lua_type(L, -2) == LUA_TNUMBER) {
+                        lua_pushvalue(L, -2); // copy of the number
+                        str = lua_tolstring(L, -1, &len); // converts value on stack to a string
+                        lua_pop(L, 1); // pop off copy
+                    } else {
+                        str = lua_tolstring(L, -2, &len);
+                    }
+                    stat = yajl_gen_string(gen, (const unsigned char*)str, (unsigned int)len);
+                }
+                generate_value(gen, L);
+                lua_pop(L, 1); // Pop off the value
+            }
+
+            if (dictionary)
+                yajl_gen_map_close(gen);
+            else
+                yajl_gen_array_close(gen);
+
+            lua_pop(L, 1); // Pop the table reference off
+            break;
+        }
+
+        case LUA_TFUNCTION:
+        case LUA_TUSERDATA:
+        case LUA_TTHREAD:
+        case LUA_TLIGHTUSERDATA:
+        default:
+            stat = yajl_gen_null(gen);
+            break;
+    }
+}
+
+static int generate(lua_State *L) {
+    const unsigned char * buf;
+    unsigned int len;
+    yajl_gen_config conf = { .beautify = 0, .indentString = "  " };
+    gen = yajl_gen_alloc(&conf, NULL);
+
+    generate_value(gen, L);
+
+    yajl_gen_get_buf(gen, &buf, &len);
+    lua_pushlstring(L, (const char *)buf, len);
+
+    yajl_gen_clear(gen);
+    yajl_gen_free(gen);
+    return 1;
+}