wankel 0.1.0

data/ext/wankel/wankel_sax_encoder.c

@@ -0,0 +1,290 @@
+#include "wankel_sax_encoder.h"
+
+typedef struct {
+    yajl_gen g;
+	VALUE output;
+	int write_buffer_size;
+} wankel_encoder;
+
+static VALUE wankelSaxEncoder_initialize(int argc, VALUE * argv, VALUE self);
+static VALUE wankelSaxEncoder_number(VALUE self, VALUE number);
+static VALUE wankelSaxEncoder_string(VALUE self, VALUE string);
+static VALUE wankelSaxEncoder_null(VALUE self);
+static VALUE wankelSaxEncoder_bool(VALUE self, VALUE b);
+static VALUE wankelSaxEncoder_map_open(VALUE self);
+static VALUE wankelSaxEncoder_map_close(VALUE self);
+static VALUE wankelSaxEncoder_array_open(VALUE self);
+static VALUE wankelSaxEncoder_array_close(VALUE self);
+static VALUE wankelSaxEncoder_complete(VALUE self);
+static void wankelSaxEncoder_flush(wankel_encoder * p);
+static VALUE wankel_sax_encoder_alloc(VALUE klass);
+static void wankel_sax_encoder_free(void * handle);
+static void wankel_sax_encoder_mark(void * handle);
+
+static VALUE c_wankel, c_wankelSaxEncoder, e_encodeError;
+
+static ID intern_to_s, intern_keys, intern_io_write, intern_to_json, intern_clone, intern_merge, intern_DEFAULTS;
+
+static ID sym_beautify, sym_indent_string, sym_validate_utf8, sym_escape_solidus;
+
+/*
+ * Document-method: new
+ *
+ * call-seq: new([options])
+ *
+ * +:beautify+ generate indented (beautiful) output. Default `false`.
+ *
+ * +:indent_string+ Set an indent string which is used when yajl_gen_beautify
+ *                  is enabled. Maybe something like \\t or some number of
+ *                  spaces. The default is four spaces ' '.
+ *
+ * +:validate_utf8+ Normally the generator does not validate that strings you
+ *                  pass to it are valid UTF8. Enabling this option will cause
+ *                  it to do so.
+ *
+ * +:escape_solidus+ the forward solidus (slash or '/' in human) is not required
+ *                   to be escaped in json text. By default, YAJL will not escape
+ *                   it in the iterest of saving bytes. Setting this flag will
+ *                   cause YAJL to always escape '/' in generated JSON strings.
+ */
+static VALUE wankelSaxEncoder_initialize(int argc, VALUE * argv, VALUE self) {
+    VALUE defaults = rb_const_get(c_wankel, intern_DEFAULTS);
+    VALUE io, options;
+	wankel_encoder * p;
+    yajl_alloc_funcs alloc_funcs;
+	
+    rb_scan_args(argc, argv, "11", &io, &options);
+
+    if(options == Qnil) {
+        rb_iv_set(self, "@options", rb_funcall(defaults, intern_clone, 0) );
+    } else {
+        Check_Type(options, T_HASH);
+        rb_iv_set(self, "@options", rb_funcall(defaults, intern_merge, 1, options) );
+    }
+	options = rb_iv_get(self, "@options");
+	
+	if (!rb_respond_to(io, intern_io_write)) {
+		rb_raise(e_encodeError, "output must be a an IO");
+	}
+    Data_Get_Struct(self, wankel_encoder, p);
+	p->output = io;
+
+	alloc_funcs.malloc = yajl_helper_malloc;
+	alloc_funcs.realloc = yajl_helper_realloc;
+	alloc_funcs.free = yajl_helper_free;
+	p->g = yajl_gen_alloc(&alloc_funcs);
+	yajl_gen_configure(p->g, options);
+
+	p->write_buffer_size = FIX2INT(rb_hash_aref(options, ID2SYM(rb_intern("write_buffer_size"))));
+		
+    return self;
+}
+
+static VALUE wankelSaxEncoder_number(VALUE self, VALUE number) {
+    size_t len;
+    const char * cptr;
+	wankel_encoder * p;
+	yajl_gen_status status;
+	VALUE str = rb_funcall(number, intern_to_s, 0);
+
+    Data_Get_Struct(self, wankel_encoder, p);
+    cptr = RSTRING_PTR(str);
+    len = RSTRING_LEN(str);
+	
+    if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) {
+        rb_raise(e_encodeError, "'%s' is an invalid number", cptr);
+    }
+	
+    status = yajl_gen_number(p->g, cptr, len);
+	yajl_helper_check_gen_status(status);
+
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_string(VALUE self, VALUE string) {
+    size_t len;
+    const char * cptr;
+	wankel_encoder * p;
+	yajl_gen_status status;
+	
+	Check_Type(string, T_STRING);
+	
+    Data_Get_Struct(self, wankel_encoder, p);
+    cptr = RSTRING_PTR(string);
+    len = RSTRING_LEN(string);
+	
+    status = yajl_gen_string(p->g, (const unsigned char *)cptr, len);
+	yajl_helper_check_gen_status(status);
+
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_null(VALUE self) {
+	wankel_encoder * p;
+	yajl_gen_status status;
+    Data_Get_Struct(self, wankel_encoder, p);
+	
+    status = yajl_gen_null(p->g);
+	yajl_helper_check_gen_status(status);
+	
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_bool(VALUE self, VALUE b) {
+	wankel_encoder * p;
+	yajl_gen_status status;
+    Data_Get_Struct(self, wankel_encoder, p);
+
+	status = yajl_gen_bool(p->g, RTEST(b));
+	yajl_helper_check_gen_status(status);
+	
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_map_open(VALUE self) {
+	wankel_encoder * p;
+	yajl_gen_status status;
+    Data_Get_Struct(self, wankel_encoder, p);
+	
+    status = yajl_gen_map_open(p->g);
+	yajl_helper_check_gen_status(status);
+	
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_map_close(VALUE self) {
+	wankel_encoder * p;
+	yajl_gen_status status;
+    Data_Get_Struct(self, wankel_encoder, p);
+	
+    status = yajl_gen_map_close(p->g);
+	yajl_helper_check_gen_status(status);
+	
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_array_open(VALUE self) {
+	wankel_encoder * p;
+	yajl_gen_status status;
+    Data_Get_Struct(self, wankel_encoder, p);
+	
+    status = yajl_gen_array_open(p->g);
+	yajl_helper_check_gen_status(status);
+	
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_array_close(VALUE self) {
+	wankel_encoder * p;
+	yajl_gen_status status;
+    Data_Get_Struct(self, wankel_encoder, p);
+	
+    status = yajl_gen_array_close(p->g);
+	yajl_helper_check_gen_status(status);
+	
+	wankelSaxEncoder_flush(p);
+	
+	return Qnil;
+}
+
+static VALUE wankelSaxEncoder_complete(VALUE self) {
+    size_t len;
+	VALUE rbBuffer;
+	wankel_encoder * p;
+	yajl_gen_status status;
+    const unsigned char * buffer;
+    Data_Get_Struct(self, wankel_encoder, p);
+	
+	status = yajl_gen_get_buf(p->g, &buffer, &len);
+	yajl_helper_check_gen_status(status);
+	
+	rbBuffer = rb_str_new((const char *)buffer, len);
+	rb_enc_associate(rbBuffer, rb_utf8_encoding());
+	rb_io_write(p->output, rbBuffer);
+	yajl_gen_clear(p->g);
+
+	return Qnil;
+}
+
+void wankelSaxEncoder_flush(wankel_encoder * p) {
+	VALUE rbBuffer;
+    yajl_gen_status status;
+    const unsigned char * buffer;
+    size_t len;
+	
+	status = yajl_gen_get_buf(p->g, &buffer, &len);
+	yajl_helper_check_gen_status(status);
+	
+	if (len >= (size_t)p->write_buffer_size) {
+		rbBuffer = rb_str_new((const char *)buffer, len);
+		rb_enc_associate(rbBuffer, rb_utf8_encoding());
+		rb_io_write(p->output, rbBuffer);
+		yajl_gen_clear(p->g);
+	}
+}
+
+void Init_wankel_sax_encoder() {
+    c_wankel = rb_const_get(rb_cObject, rb_intern("Wankel"));
+    c_wankelSaxEncoder = rb_define_class_under(c_wankel, "SaxEncoder", rb_cObject);
+    e_encodeError = rb_const_get(c_wankel, rb_intern("EncodeError"));
+
+	rb_define_alloc_func(c_wankelSaxEncoder, wankel_sax_encoder_alloc);
+    rb_define_method(c_wankelSaxEncoder, "initialize", wankelSaxEncoder_initialize, -1);
+    rb_define_method(c_wankelSaxEncoder, "number", wankelSaxEncoder_number, 1);
+    rb_define_method(c_wankelSaxEncoder, "string", wankelSaxEncoder_string, 1);
+    rb_define_method(c_wankelSaxEncoder, "null", wankelSaxEncoder_null, 0);
+    rb_define_method(c_wankelSaxEncoder, "bool", wankelSaxEncoder_bool, 1);
+    rb_define_method(c_wankelSaxEncoder, "map_open", wankelSaxEncoder_map_open, 0);
+    rb_define_method(c_wankelSaxEncoder, "map_close", wankelSaxEncoder_map_close, 0);
+    rb_define_method(c_wankelSaxEncoder, "array_open", wankelSaxEncoder_array_open, 0);
+    rb_define_method(c_wankelSaxEncoder, "array_close", wankelSaxEncoder_array_close, 0);
+    rb_define_method(c_wankelSaxEncoder, "complete", wankelSaxEncoder_complete, 0);
+
+    
+	intern_to_s = rb_intern("to_s");
+	intern_io_write = rb_intern("write");
+	intern_to_json = rb_intern("to_json");
+	intern_keys = rb_intern("keys");
+    intern_clone = rb_intern("clone");
+    intern_merge = rb_intern("merge");
+    intern_DEFAULTS = rb_intern("DEFAULTS");
+    sym_beautify = ID2SYM(rb_intern("beautify"));
+    sym_indent_string = ID2SYM(rb_intern("indent_string"));
+    sym_validate_utf8 = ID2SYM(rb_intern("validate_utf8"));
+    sym_escape_solidus = ID2SYM(rb_intern("escape_solidus"));
+}
+
+// Ruby GC ===================================================================
+static VALUE wankel_sax_encoder_alloc(VALUE klass) {
+	VALUE self;
+    wankel_encoder * p;
+	self = Data_Make_Struct(klass, wankel_encoder, wankel_sax_encoder_mark, wankel_sax_encoder_free, p);
+	p->g = 0;
+	return self;
+}
+
+static void wankel_sax_encoder_free(void * handle) {
+    wankel_encoder * p = handle;
+	if (p->g){
+		yajl_gen_free(p->g);
+	}
+}
+
+static void wankel_sax_encoder_mark(void * handle) {
+    wankel_encoder * p = handle;
+    rb_gc_mark(p->output);
+}

data/ext/wankel/wankel_sax_encoder.h

@@ -0,0 +1,13 @@
+#ifndef WANKEL_SAX_ENCODER
+#define WANKEL_SAX_ENCODER
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <yajl/yajl_common.h>
+#include <yajl/yajl_gen.h>
+
+#include "yajl_helpers.h"
+
+void Init_wankel_sax_encoder();
+
+#endif

data/ext/wankel/wankel_sax_parser.c

@@ -0,0 +1,232 @@
+#include "wankel_sax_parser.h"
+
+static VALUE sax_parser_initialize(int argc, VALUE * argv, VALUE self);
+
+static ID  sym_read_buffer_size, sym_symbolize_keys;
+
+static ID  intern_io_read, intern_merge, intern_clone, intern_DEFAULTS;
+
+static ID  intern_on_null, intern_on_boolean, intern_on_integer,
+    intern_on_double, intern_on_string, intern_on_map_start, intern_on_map_key,
+    intern_on_map_end, intern_on_array_start, intern_on_array_end;
+	
+static VALUE c_wankel, c_wankelParser, c_saxParser, e_parseError, e_encodeError;
+		   
+// Callbacks =================================================================
+yajl_callbacks sax_parser_callbacks(VALUE self);
+int sax_parser_callback_on_null(void *ctx);
+int sax_parser_callback_on_boolean(void *ctx, int boolVal);
+int sax_parser_callback_on_number(void *ctx, const char * numberVal, size_t numberLen);
+int sax_parser_callback_on_string(void *ctx, const unsigned char * stringVal, size_t stringLen);
+int sax_parser_callback_on_map_start(void *ctx);
+int sax_parser_callback_on_map_key(void *ctx, const unsigned char * key, size_t keyLen);
+int sax_parser_callback_on_map_end(void *ctx);
+int sax_parser_callback_on_array_start(void *ctx);
+int sax_parser_callback_on_array_end(void *ctx);
+
+// Ruby GC ===================================================================
+VALUE sax_parser_alloc(VALUE);
+//void sax_parser_mark(void *);
+void sax_parser_free(void * parser);
+
+VALUE sax_parser_initialize(int argc, VALUE * argv, VALUE self) {
+    VALUE defaults = rb_const_get(c_wankel, intern_DEFAULTS);
+    VALUE klass = rb_funcall(self, rb_intern("class"), 0);
+    VALUE options, rbufsize;
+    sax_parser * p;
+
+    rb_scan_args(argc, argv, "01", &options);
+    if (rb_const_defined(klass, intern_DEFAULTS)) { 
+        defaults = rb_funcall(defaults, intern_merge, 1, rb_const_get(klass, intern_DEFAULTS));
+    }
+    if(options == Qnil) {
+        rb_iv_set(self, "@options", rb_funcall(defaults, intern_clone, 0) );
+    } else {
+        Check_Type(options, T_HASH);
+        rb_iv_set(self, "@options", rb_funcall(defaults, intern_merge, 1, options) );
+    }
+    options = rb_iv_get(self, "@options");
+
+    Data_Get_Struct(self, sax_parser, p);
+    p->callbacks = sax_parser_callbacks(self);
+    p->alloc_funcs.malloc = yajl_helper_malloc;
+    p->alloc_funcs.realloc = yajl_helper_realloc;
+    p->alloc_funcs.free = yajl_helper_free;
+    p->h = yajl_alloc(&p->callbacks, &p->alloc_funcs, (void *)self);
+    
+    yajl_configure(p->h, options);
+        
+    rbufsize = rb_hash_aref(options, sym_read_buffer_size);
+    Check_Type(rbufsize, T_FIXNUM);
+    p->rbufsize = rbufsize;
+    
+    if(rb_hash_aref(options, sym_symbolize_keys) == Qtrue) {
+        p->symbolize_keys = 1;
+    } else {
+        p->symbolize_keys = 0;
+    }
+    
+    return self;
+}
+
+static VALUE sax_parser_parse(int argc, VALUE * argv, VALUE self) {
+    const char * cptr;
+    size_t len;
+    yajl_status status;
+    sax_parser * p;
+    VALUE input;
+    Data_Get_Struct(self, sax_parser, p);
+	
+    rb_scan_args(argc, argv, "10", &input);
+    if (TYPE(input) == T_STRING) {
+        cptr = RSTRING_PTR(input);
+        len = RSTRING_LEN(input);
+        status = yajl_parse(p->h, (const unsigned char*)cptr, len);
+        yajl_helper_check_status(p->h, status, 1, (const unsigned char*)cptr, len);
+    } else if (rb_respond_to(input, intern_io_read)) {
+        VALUE chunk = rb_str_new(0, FIX2LONG(p->rbufsize));
+        while (rb_funcall(input, intern_io_read, 2, p->rbufsize, chunk) != Qnil) {
+            cptr = RSTRING_PTR(chunk);
+            len = RSTRING_LEN(chunk);
+            status = yajl_parse(p->h, (const unsigned char*)cptr, len);
+            yajl_helper_check_status(p->h, status, 1, (const unsigned char*)cptr, len);
+        }
+    } else {
+        rb_raise(e_parseError, "input must be a string or an IO");
+    }
+    
+    status = yajl_complete_parse(p->h);
+    yajl_helper_check_status(p->h, status, 0, NULL, 0);
+    
+    return Qnil;
+}
+
+void Init_wankel_sax_parser() {
+    c_wankel = rb_const_get(rb_cObject, rb_intern("Wankel"));
+    c_wankelParser = rb_const_get(c_wankel, rb_intern("Parser"));
+    c_saxParser = rb_define_class_under(c_wankel, "SaxParser", rb_cObject);
+    e_parseError = rb_const_get(c_wankel, rb_intern("ParseError"));
+    e_encodeError = rb_const_get(c_wankel, rb_intern("EncodeError"));
+    
+    rb_define_alloc_func(c_saxParser, sax_parser_alloc);
+    rb_define_method(c_saxParser, "initialize", sax_parser_initialize, -1);
+    rb_define_method(c_saxParser, "parse", sax_parser_parse, -1);
+    
+    intern_merge = rb_intern("merge");
+    intern_clone = rb_intern("clone");
+    intern_DEFAULTS = rb_intern("DEFAULTS");
+    
+    sym_read_buffer_size = ID2SYM(rb_intern("read_buffer_size"));
+    sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
+    
+    intern_on_null = rb_intern("on_null");
+    intern_on_boolean = rb_intern("on_boolean");
+    intern_on_integer = rb_intern("on_integer");
+    intern_on_double = rb_intern("on_double");
+    intern_on_string = rb_intern("on_string");
+    intern_on_map_start = rb_intern("on_map_start");
+    intern_on_map_key = rb_intern("on_map_key");
+    intern_on_map_end = rb_intern("on_map_end");
+    intern_on_array_start = rb_intern("on_array_start");
+    intern_on_array_end = rb_intern("on_array_end");
+}
+
+// Callbacks =================================================================
+yajl_callbacks sax_parser_callbacks(VALUE self) {
+    yajl_callbacks callbacks = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+    if(rb_respond_to(self, intern_on_null)) {
+        callbacks.yajl_null = sax_parser_callback_on_null;
+    }
+    if(rb_respond_to(self, intern_on_boolean)) {
+        callbacks.yajl_boolean = sax_parser_callback_on_boolean;
+    }
+    if(rb_respond_to(self, intern_on_integer) || rb_respond_to(self, intern_on_double)) {
+        callbacks.yajl_number = sax_parser_callback_on_number;
+    }
+    if(rb_respond_to(self, intern_on_string)) {
+        callbacks.yajl_string = sax_parser_callback_on_string;
+    }
+
+    if(rb_respond_to(self, intern_on_map_start)) {
+        callbacks.yajl_start_map = sax_parser_callback_on_map_start;
+    }
+    if(rb_respond_to(self, intern_on_map_key)) {
+        callbacks.yajl_map_key = sax_parser_callback_on_map_key;
+    }
+    if(rb_respond_to(self, intern_on_map_end)) {
+        callbacks.yajl_end_map = sax_parser_callback_on_map_end;
+     }
+    if(rb_respond_to(self, intern_on_array_start)) {
+        callbacks.yajl_start_array = sax_parser_callback_on_array_start;
+    }
+    if(rb_respond_to(self, intern_on_array_end)) {
+        callbacks.yajl_end_array = sax_parser_callback_on_array_end;
+    }
+
+    return callbacks;
+}
+
+int sax_parser_callback_on_null(void *ctx) {
+    rb_funcall((VALUE)ctx, intern_on_null, 0);
+    return 1;
+}
+
+int sax_parser_callback_on_boolean(void *ctx, int boolVal) {
+    rb_funcall((VALUE)ctx, intern_on_boolean, 1, (boolVal ? Qtrue : Qfalse));
+    return 1;
+}
+
+int sax_parser_callback_on_number(void *ctx, const char * numberVal, size_t numberLen) {
+	char buf[numberLen+1];
+	buf[numberLen] = 0;
+	memcpy(buf, numberVal, numberLen);
+	VALUE obj = (VALUE)ctx;
+
+	if (memchr(buf, '.', numberLen) || memchr(buf, 'e', numberLen) || memchr(buf, 'E', numberLen)) {
+		if (rb_respond_to(obj, intern_on_double)) {
+			rb_funcall((VALUE)ctx, intern_on_double, 1, rb_float_new(strtod(buf, NULL)));			
+		}
+	} else {
+		if (rb_respond_to(obj, intern_on_integer)) {
+			rb_funcall((VALUE)ctx, intern_on_integer, 1, rb_cstr2inum(buf, 10));
+		}
+	}
+	return 1;
+}
+
+int sax_parser_callback_on_string(void *ctx, const unsigned char * stringVal, size_t stringLen) {
+    rb_funcall((VALUE)ctx, intern_on_string, 1, rb_str_new((const char *) stringVal, stringLen));
+    return 1;
+}
+int sax_parser_callback_on_map_start(void *ctx) {
+    rb_funcall((VALUE)ctx, intern_on_map_start, 0);
+    return 1;
+}
+int sax_parser_callback_on_map_key(void *ctx, const unsigned char * key, size_t keyLen) {
+    rb_funcall((VALUE)ctx, intern_on_map_key, 1, rb_str_new((const char *)key, keyLen));
+    return 1;
+}
+int sax_parser_callback_on_map_end(void *ctx) {
+    rb_funcall((VALUE)ctx, intern_on_map_end, 0);
+    return 1;
+}
+int sax_parser_callback_on_array_start(void *ctx) {
+    rb_funcall((VALUE)ctx, intern_on_array_start, 0);
+    return 1;
+}
+int sax_parser_callback_on_array_end(void *ctx) {
+    rb_funcall((VALUE)ctx, intern_on_array_end, 0);
+    return 1;
+}
+
+// Ruby GC ===================================================================
+VALUE sax_parser_alloc(VALUE klass) {
+    sax_parser * p;
+    return Data_Make_Struct(klass, sax_parser, 0, sax_parser_free, p);
+}
+
+void sax_parser_free(void * handle) {
+    sax_parser * p = handle;
+	yajl_free(p->h);
+}

data/ext/wankel/wankel_sax_parser.h

@@ -0,0 +1,23 @@
+#ifndef WANKEL_SAX_PARSER
+#define WANKEL_SAX_PARSER
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <yajl/yajl_common.h>
+#include <yajl/yajl_parse.h>
+
+#include "wankel.h"
+#include "yajl_helpers.h"
+
+void Init_wankel_sax_parser();
+
+typedef struct {
+    yajl_handle h;
+	yajl_callbacks callbacks;
+    yajl_alloc_funcs alloc_funcs;
+    int symbolize_keys;
+    VALUE rbufsize;
+} sax_parser;
+
+
+#endif

data/ext/wankel/yajl_helpers.c

@@ -0,0 +1,124 @@
+#include "wankel.h"
+#include "yajl_helpers.h"
+
+static VALUE sym_allow_comments;
+static VALUE sym_validate_strings;
+static VALUE sym_trailing_garbage;
+static VALUE sym_multiple_values;
+static VALUE sym_partial_values;
+static VALUE sym_beautify;
+static VALUE sym_indent_string;
+static VALUE sym_validate_utf8;
+static VALUE sym_escape_solidus;
+
+void Init_yajl_helpers() {
+    sym_allow_comments = ID2SYM(rb_intern("allow_comments")); rb_gc_register_address(&sym_allow_comments);
+    sym_validate_strings = ID2SYM(rb_intern("validate_strings")); rb_gc_register_address(&sym_validate_strings);
+    sym_trailing_garbage = ID2SYM(rb_intern("trailing_garbage")); rb_gc_register_address(&sym_trailing_garbage);
+    sym_multiple_values = ID2SYM(rb_intern("multiple_values")); rb_gc_register_address(&sym_multiple_values);
+    sym_partial_values = ID2SYM(rb_intern("partial_values")); rb_gc_register_address(&sym_partial_values);
+    sym_beautify = ID2SYM(rb_intern("beautify")); rb_gc_register_address(&sym_beautify);
+    sym_indent_string = ID2SYM(rb_intern("indent_string")); rb_gc_register_address(&sym_indent_string);
+    sym_validate_utf8 = ID2SYM(rb_intern("validate_utf8")); rb_gc_register_address(&sym_validate_utf8);
+    sym_escape_solidus = ID2SYM(rb_intern("escape_solidus")); rb_gc_register_address(&sym_escape_solidus);
+}
+
+// Yajl Helpers ==============================================================
+void yajl_helper_check_status(yajl_handle handle, yajl_status status, int verbose, const unsigned char * jsonText, size_t jsonTextLength) {
+    if(status != yajl_status_ok) {
+        unsigned char * str = yajl_get_error(handle, verbose, jsonText, jsonTextLength);
+        yajl_free_error(handle, str);
+        rb_raise(rb_const_get(rb_const_get(rb_cObject, rb_intern("Wankel")), rb_intern("ParseError")), (const char*) str);
+    }
+}
+
+void yajl_helper_check_gen_status(yajl_gen_status status) {
+	VALUE error = rb_const_get(rb_const_get(rb_cObject, rb_intern("Wankel")), rb_intern("EncodeError"));
+	
+	if (status == yajl_gen_status_ok || status == yajl_gen_generation_complete) {
+		return;
+	}
+	
+	if (status == yajl_gen_keys_must_be_strings) {
+        rb_raise(error, "at a point where a map key is generated, a function other than yajl_gen_string was called");
+	} else if (status == yajl_max_depth_exceeded) {
+        rb_raise(error, "YAJL's maximum generation depth was exceeded. see YAJL_MAX_DEPTH");
+	} else if (status == yajl_gen_in_error_state) {
+        rb_raise(error, "A generator function (yajl_gen_XXX) was called while in an error state");
+	} else if (status == yajl_gen_invalid_number) {
+        rb_raise(error, "yajl_gen_double was passed an invalid floating point value (infinity or NaN).");
+	} else if (status == yajl_gen_no_buf) {
+        rb_raise(error, "A print callback was passed in, so there is no internal buffer to get from");
+	} else if (status == yajl_gen_invalid_string) {
+        rb_raise(error, "returned from yajl_gen_string() when the yajl_gen_validate_utf8 option is enabled and an invalid was passed by client code.");
+	} else {
+        rb_raise(error, "unkown yajl_gen_status error");
+	}
+}
+
+
+// Memory funcs
+void * yajl_helper_malloc(void *ctx, size_t size) {
+    return xmalloc(size);
+}
+void * yajl_helper_realloc(void *ctx, void *ptr, size_t size) {
+    return xrealloc(ptr, size);
+}
+void yajl_helper_free(void *ctx, void *ptr) {
+    return xfree(ptr);
+}
+
+// Configure
+void yajl_configure(yajl_handle handle, VALUE options) {
+    if(rb_hash_aref(options, sym_allow_comments) == Qtrue) {
+        yajl_config(handle, yajl_allow_comments, 1);
+    } else {
+        yajl_config(handle, yajl_allow_comments, 0);
+    }
+
+    if(rb_hash_aref(options, sym_validate_strings) == Qtrue) {
+        yajl_config(handle, yajl_dont_validate_strings, 0);
+    } else {
+        yajl_config(handle, yajl_dont_validate_strings, 1);
+    }
+
+    if(rb_hash_aref(options, sym_trailing_garbage) == Qtrue) {
+        yajl_config(handle, yajl_allow_trailing_garbage, 1);
+    } else {
+        yajl_config(handle, yajl_allow_trailing_garbage, 0);
+    }
+
+    if(rb_hash_aref(options, sym_multiple_values) == Qtrue) {
+        yajl_config(handle, yajl_allow_multiple_values, 1);
+    } else {
+        yajl_config(handle, yajl_allow_multiple_values, 0);
+    }
+
+    if(rb_hash_aref(options, sym_partial_values) == Qtrue) {
+        yajl_config(handle, yajl_allow_partial_values, 1);
+    } else {
+        yajl_config(handle, yajl_allow_partial_values, 0);
+    }
+}
+
+void yajl_gen_configure(yajl_gen g, VALUE options) {
+    if(rb_hash_aref(options, sym_beautify) == Qtrue) {
+		yajl_gen_config(g, yajl_gen_beautify, 1);
+	} else {
+		yajl_gen_config(g, yajl_gen_beautify, 0);
+	}
+	
+ 	yajl_gen_config(g, yajl_gen_indent_string, RSTRING_PTR(rb_hash_aref(options, sym_indent_string)));
+	
+    if(rb_hash_aref(options, sym_validate_utf8) == Qtrue) {
+		yajl_gen_config(g, yajl_gen_validate_utf8, 1);
+	} else {
+		yajl_gen_config(g, yajl_gen_validate_utf8, 0);
+	}
+	
+    if(rb_hash_aref(options, sym_escape_solidus ) == Qtrue) {
+		yajl_gen_config(g, yajl_gen_escape_solidus, 1);
+	} else {
+		yajl_gen_config(g, yajl_gen_escape_solidus, 0);
+	}
+}