oj 3.9.1 → 3.16.11

data/ext/oj/mimic_json.c

@@ -1,27 +1,24 @@
-/* mimic_json.c
- * Copyright (c) 2012, 2017, Peter Ohler
- * All rights reserved.
- */
+// Copyright (c) 2012, 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include "oj.h"
-#include "encode.h"
 #include "dump.h"
+#include "encode.h"
+#include "mem.h"
+#include "oj.h"
 #include "parse.h"
 
-static VALUE	symbolize_names_sym = Qundef;
-
-extern const char	oj_json_class[];
+extern const char oj_json_class[];
 
-VALUE	oj_array_nl_sym;
-VALUE	oj_ascii_only_sym;
-VALUE	oj_json_generator_error_class;
-VALUE	oj_json_parser_error_class;
-VALUE	oj_max_nesting_sym;
-VALUE	oj_object_nl_sym;
-VALUE	oj_space_before_sym;
-VALUE	oj_space_sym;
+VALUE oj_array_nl_sym;
+VALUE oj_ascii_only_sym;
+VALUE oj_json_generator_error_class;
+VALUE oj_json_parser_error_class;
+VALUE oj_max_nesting_sym;
+VALUE oj_object_nl_sym;
+VALUE oj_space_before_sym;
+VALUE oj_space_sym;
 
-static VALUE	state_class;
+static VALUE state_class = Qundef;
 
 // mimic JSON documentation
 
@@ -56,14 +53,14 @@ static VALUE	state_class;
 
 VALUE
 oj_get_json_err_class(const char *err_classname) {
-    volatile VALUE	json_module;
-    volatile VALUE	clas;
-    volatile VALUE	json_error_class;
+    volatile VALUE json_module;
+    volatile VALUE clas;
+    volatile VALUE json_error_class;
 
     if (rb_const_defined_at(rb_cObject, rb_intern("JSON"))) {
-	json_module = rb_const_get_at(rb_cObject, rb_intern("JSON"));
+        json_module = rb_const_get_at(rb_cObject, rb_intern("JSON"));
     } else {
-	json_module = rb_define_module("JSON");
+        json_module = rb_define_module("JSON");
     }
     if (rb_const_defined_at(json_module, rb_intern("JSONError"))) {
         json_error_class = rb_const_get(json_module, rb_intern("JSONError"));
@@ -71,113 +68,121 @@ oj_get_json_err_class(const char *err_classname) {
         json_error_class = rb_define_class_under(json_module, "JSONError", rb_eStandardError);
     }
     if (0 == strcmp(err_classname, "JSONError")) {
-	clas = json_error_class;
+        clas = json_error_class;
     } else {
-	if (rb_const_defined_at(json_module, rb_intern(err_classname))) {
-	    clas = rb_const_get(json_module, rb_intern(err_classname));
-	} else {
-	    clas = rb_define_class_under(json_module, err_classname, json_error_class);
-	}
+        if (rb_const_defined_at(json_module, rb_intern(err_classname))) {
+            clas = rb_const_get(json_module, rb_intern(err_classname));
+        } else {
+            clas = rb_define_class_under(json_module, err_classname, json_error_class);
+        }
     }
     return clas;
 }
 
-void
-oj_parse_mimic_dump_options(VALUE ropts, Options copts) {
-    VALUE	v;
-    size_t	len;
+void oj_parse_mimic_dump_options(VALUE ropts, Options copts) {
+    VALUE  v;
+    size_t len;
 
     if (T_HASH != rb_type(ropts)) {
-	if (rb_respond_to(ropts, oj_to_hash_id)) {
-	    ropts = rb_funcall(ropts, oj_to_hash_id, 0);
-	} else if (rb_respond_to(ropts, oj_to_h_id)) {
-	    ropts = rb_funcall(ropts, oj_to_h_id, 0);
-	} else if (Qnil == ropts) {
-	    return;
-	} else {
-	    rb_raise(rb_eArgError, "options must be a hash.");
-	}
+        if (rb_respond_to(ropts, oj_to_hash_id)) {
+            ropts = rb_funcall(ropts, oj_to_hash_id, 0);
+        } else if (rb_respond_to(ropts, oj_to_h_id)) {
+            ropts = rb_funcall(ropts, oj_to_h_id, 0);
+        } else if (Qnil == ropts) {
+            return;
+        } else {
+            rb_raise(rb_eArgError, "options must be a hash.");
+        }
     }
     v = rb_hash_lookup(ropts, oj_max_nesting_sym);
     if (Qtrue == v) {
-	copts->dump_opts.max_depth = 100;
+        copts->dump_opts.max_depth = 100;
     } else if (Qfalse == v || Qnil == v) {
-	copts->dump_opts.max_depth = MAX_DEPTH;
+        copts->dump_opts.max_depth = MAX_DEPTH;
     } else if (T_FIXNUM == rb_type(v)) {
-	copts->dump_opts.max_depth = NUM2INT(v);
-	if (0 >= copts->dump_opts.max_depth) {
-	    copts->dump_opts.max_depth = MAX_DEPTH;
-	}
+        copts->dump_opts.max_depth = NUM2INT(v);
+        if (0 >= copts->dump_opts.max_depth) {
+            copts->dump_opts.max_depth = MAX_DEPTH;
+        }
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_allow_nan_sym))) {
-	if (Qtrue == v) {
-	    copts->dump_opts.nan_dump = WordNan;
-	} else {
-	    copts->dump_opts.nan_dump = RaiseNan;
-	}
+        if (Qtrue == v) {
+            copts->dump_opts.nan_dump = WordNan;
+        } else {
+            copts->dump_opts.nan_dump = RaiseNan;
+        }
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_indent_sym))) {
-	rb_check_type(v, T_STRING);
-	if (sizeof(copts->dump_opts.indent_str) <= (len = RSTRING_LEN(v))) {
-	    rb_raise(rb_eArgError, "indent string is limited to %lu characters.", (unsigned long)sizeof(copts->dump_opts.indent_str));
-	}
-	strcpy(copts->dump_opts.indent_str, StringValuePtr(v));
-	copts->dump_opts.indent_size = (uint8_t)len;
-	copts->dump_opts.use = true;
+        rb_check_type(v, T_STRING);
+        if (sizeof(copts->dump_opts.indent_str) <= (len = RSTRING_LEN(v))) {
+            rb_raise(rb_eArgError,
+                     "indent string is limited to %lu characters.",
+                     (unsigned long)sizeof(copts->dump_opts.indent_str));
+        }
+        strcpy(copts->dump_opts.indent_str, StringValuePtr(v));
+        copts->dump_opts.indent_size = (uint8_t)len;
+        copts->dump_opts.use         = true;
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_space_sym))) {
-	rb_check_type(v, T_STRING);
-	if (sizeof(copts->dump_opts.after_sep) <= (len = RSTRING_LEN(v))) {
-	    rb_raise(rb_eArgError, "space string is limited to %lu characters.", (unsigned long)sizeof(copts->dump_opts.after_sep));
-	}
-	strcpy(copts->dump_opts.after_sep, StringValuePtr(v));
-	copts->dump_opts.after_size = (uint8_t)len;
-	copts->dump_opts.use = true;
+        rb_check_type(v, T_STRING);
+        if (sizeof(copts->dump_opts.after_sep) <= (len = RSTRING_LEN(v))) {
+            rb_raise(rb_eArgError,
+                     "space string is limited to %lu characters.",
+                     (unsigned long)sizeof(copts->dump_opts.after_sep));
+        }
+        strcpy(copts->dump_opts.after_sep, StringValuePtr(v));
+        copts->dump_opts.after_size = (uint8_t)len;
+        copts->dump_opts.use        = true;
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_space_before_sym))) {
-	rb_check_type(v, T_STRING);
-	if (sizeof(copts->dump_opts.before_sep) <= (len = RSTRING_LEN(v))) {
-	    rb_raise(rb_eArgError, "space_before string is limited to %lu characters.", (unsigned long)sizeof(copts->dump_opts.before_sep));
-	}
-	strcpy(copts->dump_opts.before_sep, StringValuePtr(v));
-	copts->dump_opts.before_size = (uint8_t)len;
-	copts->dump_opts.use = true;
+        rb_check_type(v, T_STRING);
+        if (sizeof(copts->dump_opts.before_sep) <= (len = RSTRING_LEN(v))) {
+            rb_raise(rb_eArgError,
+                     "space_before string is limited to %lu characters.",
+                     (unsigned long)sizeof(copts->dump_opts.before_sep));
+        }
+        strcpy(copts->dump_opts.before_sep, StringValuePtr(v));
+        copts->dump_opts.before_size = (uint8_t)len;
+        copts->dump_opts.use         = true;
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_object_nl_sym))) {
-	rb_check_type(v, T_STRING);
-	if (sizeof(copts->dump_opts.hash_nl) <= (len = RSTRING_LEN(v))) {
-	    rb_raise(rb_eArgError, "object_nl string is limited to %lu characters.", (unsigned long)sizeof(copts->dump_opts.hash_nl));
-	}
-	strcpy(copts->dump_opts.hash_nl, StringValuePtr(v));
-	copts->dump_opts.hash_size = (uint8_t)len;
-	copts->dump_opts.use = true;
+        rb_check_type(v, T_STRING);
+        if (sizeof(copts->dump_opts.hash_nl) <= (len = RSTRING_LEN(v))) {
+            rb_raise(rb_eArgError,
+                     "object_nl string is limited to %lu characters.",
+                     (unsigned long)sizeof(copts->dump_opts.hash_nl));
+        }
+        strcpy(copts->dump_opts.hash_nl, StringValuePtr(v));
+        copts->dump_opts.hash_size = (uint8_t)len;
+        copts->dump_opts.use       = true;
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_array_nl_sym))) {
-	rb_check_type(v, T_STRING);
-	if (sizeof(copts->dump_opts.array_nl) <= (len = RSTRING_LEN(v))) {
-	    rb_raise(rb_eArgError, "array_nl string is limited to %lu characters.", (unsigned long)sizeof(copts->dump_opts.array_nl));
-	}
-	strcpy(copts->dump_opts.array_nl, StringValuePtr(v));
-	copts->dump_opts.array_size = (uint8_t)len;
-	copts->dump_opts.use = true;
+        rb_check_type(v, T_STRING);
+        if (sizeof(copts->dump_opts.array_nl) <= (len = RSTRING_LEN(v))) {
+            rb_raise(rb_eArgError,
+                     "array_nl string is limited to %lu characters.",
+                     (unsigned long)sizeof(copts->dump_opts.array_nl));
+        }
+        strcpy(copts->dump_opts.array_nl, StringValuePtr(v));
+        copts->dump_opts.array_size = (uint8_t)len;
+        copts->dump_opts.use        = true;
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_quirks_mode_sym))) {
-	copts->quirks_mode = (Qtrue == v) ? Yes : No;
+        copts->quirks_mode = (Qtrue == v) ? Yes : No;
     }
     if (Qnil != (v = rb_hash_lookup(ropts, oj_ascii_only_sym))) {
-	// generate seems to assume anything except nil and false are true.
-	if (Qfalse == v) {
-	    copts->escape_mode = JXEsc;
-	} else {
-	    copts->escape_mode = ASCIIEsc;
-	}
+        // generate seems to assume anything except nil and false are true.
+        if (Qfalse == v) {
+            copts->escape_mode = JXEsc;
+        } else {
+            copts->escape_mode = ASCIIEsc;
+        }
     }
 }
 
-static int
-mimic_limit_arg(VALUE a) {
+static int mimic_limit_arg(VALUE a) {
     if (Qnil == a || T_FIXNUM != rb_type(a)) {
-	return -1;
+        return -1;
     }
     return NUM2INT(a);
 }
@@ -193,92 +198,93 @@ mimic_limit_arg(VALUE a) {
  *
  * Returns [_String_] a JSON string.
  */
-static VALUE
-mimic_dump(int argc, VALUE *argv, VALUE self) {
-    char		buf[4096];
-    struct _out		out;
-    struct _options	copts = oj_default_options;
-    VALUE		rstr;
+static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
+    struct _out     out;
+    struct _options copts = oj_default_options;
+    VALUE           rstr;
+    VALUE           active_hack[1];
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf = buf;
-    out.end = buf + sizeof(buf) - 10;
-    out.allocated = false;
-    out.caller = CALLER_DUMP;
+
+    oj_out_init(&out);
+
     copts.escape_mode = JXEsc;
-    copts.mode = CompatMode;
+    copts.mode        = CompatMode;
 
     /* seems like this is not correct
     if (No == copts.nilnil && Qnil == *argv) {
-	rb_raise(rb_eTypeError, "nil not allowed.");
+        rb_raise(rb_eTypeError, "nil not allowed.");
     }
     */
-    copts.dump_opts.max_depth = MAX_DEPTH; // when using dump there is no limit
-    out.omit_nil = copts.dump_opts.omit_nil;
+    copts.dump_opts.max_depth = MAX_DEPTH;  // when using dump there is no limit
+    out.omit_nil              = copts.dump_opts.omit_nil;
+
     if (2 <= argc) {
-	int	limit;
-
-	// The json gem take a more liberal approach to optional
-	// arguments. Expected are (obj, anIO=nil, limit=nil) yet the io
-	// argument can be left off completely and the 2nd argument is then
-	// the limit.
-	if (0 <= (limit = mimic_limit_arg(argv[1]))) {
-	    copts.dump_opts.max_depth = limit;
-	}
-	if (3 <= argc && 0 <= (limit = mimic_limit_arg(argv[2]))) {
-	    copts.dump_opts.max_depth = limit;
-	}
-    }
-    oj_dump_obj_to_json(*argv, &copts, &out);
+        int limit;
+
+        // The json gem take a more liberal approach to optional
+        // arguments. Expected are (obj, anIO=nil, limit=nil) yet the io
+        // argument can be left off completely and the 2nd argument is then
+        // the limit.
+        if (0 <= (limit = mimic_limit_arg(argv[1]))) {
+            copts.dump_opts.max_depth = limit;
+        }
+        if (3 <= argc && 0 <= (limit = mimic_limit_arg(argv[2]))) {
+            copts.dump_opts.max_depth = limit;
+        }
+    }
+    // ActiveSupport in active_support/core_ext/object/json.rb check the
+    // optional argument type to to_json and it the argument is a
+    // ::JSON::State it calls the JSON gem code otherwise it calls the active
+    // support encoder code. To make sure the desired branch is called a
+    // default ::JSON::State argument is passed in. Basically a hack to get
+    // around the active support hack so two wrongs make a right this time.
+    active_hack[0] = rb_funcall(state_class, oj_new_id, 0);
+    oj_dump_obj_to_json_using_params(*argv, &copts, &out, 1, active_hack);
+
     if (0 == out.buf) {
-	rb_raise(rb_eNoMemError, "Not enough memory.");
+        rb_raise(rb_eNoMemError, "Not enough memory.");
     }
-    rstr = rb_str_new2(out.buf);
-    rstr = oj_encode(rstr);
+    rstr = rb_utf8_str_new_cstr(out.buf);
     if (2 <= argc && Qnil != argv[1] && rb_respond_to(argv[1], oj_write_id)) {
-	VALUE	io = argv[1];
-	VALUE	args[1];
+        VALUE io = argv[1];
+        VALUE args[1];
 
-	*args = rstr;
-	rb_funcall2(io, oj_write_id, 1, args);
-	rstr = io;
-    }
-    if (out.allocated) {
-	xfree(out.buf);
+        *args = rstr;
+        rb_funcall2(io, oj_write_id, 1, args);
+        rstr = io;
     }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
 // This is the signature for the hash_foreach callback also.
-static int
-mimic_walk(VALUE key, VALUE obj, VALUE proc) {
+static int mimic_walk(VALUE key, VALUE obj, VALUE proc) {
     switch (rb_type(obj)) {
-    case T_HASH:
-	rb_hash_foreach(obj, mimic_walk, proc);
-	break;
-    case T_ARRAY:
-	{
-	    size_t	cnt = RARRAY_LEN(obj);
-	    size_t	i;
-
-	    for (i = 0; i < cnt; i++) {
-		mimic_walk(Qnil, rb_ary_entry(obj, i), proc);
-	    }
-	    break;
-	}
-    default:
-	break;
+    case T_HASH: rb_hash_foreach(obj, mimic_walk, proc); break;
+    case T_ARRAY: {
+        size_t cnt = RARRAY_LEN(obj);
+        size_t i;
+
+        for (i = 0; i < cnt; i++) {
+            mimic_walk(Qnil, RARRAY_AREF(obj, i), proc);
+        }
+        break;
+    }
+    default: break;
     }
     if (Qnil == proc) {
-	if (rb_block_given_p()) {
-	    rb_yield(obj);
-	}
+        if (rb_block_given_p()) {
+            rb_yield(obj);
+        }
     } else {
-	VALUE	args[1];
+        VALUE args[1];
 
-	*args = obj;
-	rb_proc_call_with_block(proc, 1, args, Qnil);
+        *args = obj;
+        rb_proc_call_with_block(proc, 1, args, Qnil);
     }
     return ST_CONTINUE;
 }
@@ -308,20 +314,19 @@ mimic_walk(VALUE key, VALUE obj, VALUE proc) {
  *
  * Returns [_Object_] the decode Object.
  */
-static VALUE
-mimic_load(int argc, VALUE *argv, VALUE self) {
-    VALUE	obj;
-    VALUE	p = Qnil;
+static VALUE mimic_load(int argc, VALUE *argv, VALUE self) {
+    VALUE obj;
+    VALUE p = Qnil;
 
     obj = oj_compat_load(argc, argv, self);
     if (2 <= argc) {
-	if (rb_cProc == rb_obj_class(argv[1])) {
-	    p = argv[1];
-	} else if (3 <= argc) {
-	    if (rb_cProc == rb_obj_class(argv[2])) {
-		p = argv[2];
-	    }
-	}
+        if (rb_cProc == rb_obj_class(argv[1])) {
+            p = argv[1];
+        } else if (3 <= argc) {
+            if (rb_cProc == rb_obj_class(argv[2])) {
+                p = argv[2];
+            }
+        }
     }
     mimic_walk(Qnil, obj, p);
 
@@ -339,55 +344,61 @@ mimic_load(int argc, VALUE *argv, VALUE self) {
  *
  * Returns [_Object_]
  */
-static VALUE
-mimic_dump_load(int argc, VALUE *argv, VALUE self) {
+static VALUE mimic_dump_load(int argc, VALUE *argv, VALUE self) {
     if (1 > argc) {
-	rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
-    } else if (T_STRING == rb_type(*argv)) {
-	return mimic_load(argc, argv, self);
-    } else {
-	return mimic_dump(argc, argv, self);
+        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
     }
-    return Qnil;
+    if (T_STRING == rb_type(*argv)) {
+        return mimic_load(argc, argv, self);
+    }
+    return mimic_dump(argc, argv, self);
 }
 
-static VALUE
-mimic_generate_core(int argc, VALUE *argv, Options copts) {
-    char	buf[4096];
-    struct _out	out;
-    VALUE	rstr;
+static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
+    struct _out out;
+    VALUE       rstr;
 
-    // TBD
-    memset(buf, 0, sizeof(buf));
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    memset(out.stack_buffer, 0, sizeof(out.stack_buffer));
+
+    oj_out_init(&out);
 
-    out.buf = buf;
-    out.end = buf + sizeof(buf) - 10;
-    out.allocated = false;
     out.omit_nil = copts->dump_opts.omit_nil;
-    out.caller = CALLER_GENERATE;
     // For obj.to_json or generate nan is not allowed but if called from dump
     // it is.
     copts->dump_opts.nan_dump = RaiseNan;
-    copts->mode = CompatMode;
-    copts->to_json = Yes;
+    copts->mode               = CompatMode;
+    copts->to_json            = Yes;
     if (2 == argc && Qnil != argv[1]) {
-	oj_parse_mimic_dump_options(argv[1], copts);
+        oj_parse_mimic_dump_options(argv[1], copts);
     }
     /* seems like this is not correct
     if (No == copts->nilnil && Qnil == *argv) {
-	rb_raise(rb_eTypeError, "nil not allowed.");
+        rb_raise(rb_eTypeError, "nil not allowed.");
     }
     */
-    oj_dump_obj_to_json_using_params(*argv, copts, &out, argc - 1, argv + 1);
+    if (1 < argc) {
+        oj_dump_obj_to_json_using_params(*argv, copts, &out, argc - 1, argv + 1);
+    } else {
+        VALUE active_hack[1];
 
-    if (0 == out.buf) {
-	rb_raise(rb_eNoMemError, "Not enough memory.");
+        if (Qundef == state_class) {
+            rb_warn("Oj::Rails.mimic_JSON was called implicitly. "
+                    "Call it explicitly beforehand if you want to remove this warning.");
+            oj_define_mimic_json(0, NULL, Qnil);
+        }
+        active_hack[0] = rb_funcall(state_class, oj_new_id, 0);
+        oj_dump_obj_to_json_using_params(*argv, copts, &out, 1, active_hack);
     }
-    rstr = rb_str_new2(out.buf);
-    rstr = oj_encode(rstr);
-    if (out.allocated) {
-	xfree(out.buf);
+    if (0 == out.buf) {
+        rb_raise(rb_eNoMemError, "Not enough memory.");
     }
+    rstr = rb_utf8_str_new_cstr(out.buf);
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -411,13 +422,14 @@ mimic_generate_core(int argc, VALUE *argv, Options copts) {
  *   - *:space_before*  [_String_] String placed before a : delimiter
  *   - *:object_nl* [_String_] String placed after a JSON object
  *   - *:array_nl* [_String_] String placed after a JSON array
- *   - *:ascii_only* [_Boolean_] if not nil or false then use only ascii characters in the output. Note JSON.generate does support this even if it is not documented.
+ *   - *:ascii_only* [_Boolean_] if not nil or false then use only ascii characters in the output.
+ *     Note JSON.generate does support this even if it is not documented.
  *
  * Returns [_String_] generated JSON.
  */
 VALUE
 oj_mimic_generate(int argc, VALUE *argv, VALUE self) {
-    struct _options	copts = oj_default_options;
+    struct _options copts = oj_default_options;
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
@@ -435,33 +447,41 @@ oj_mimic_generate(int argc, VALUE *argv, VALUE self) {
  */
 VALUE
 oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
-    struct _options	copts = oj_default_options;
-    VALUE		rargs[2];
-    volatile VALUE	h;
+    struct _options copts = oj_default_options;
+    VALUE           rargs[2];
+    volatile VALUE  h;
 
     // Some (all?) json gem to_json methods need a State instance and not just
     // a Hash. I haven't dug deep enough to find out why but using a State
     // instance and not a Hash gives the desired behavior.
     *rargs = *argv;
-    if (1 == argc) {
-	h = rb_hash_new();
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    if (1 == argc || Qnil == argv[1]) {
+        h = rb_hash_new();
     } else {
-	h = argv[1];
+        h = argv[1];
+    }
+    if (!oj_hash_has_key(h, oj_indent_sym)) {
+        rb_hash_aset(h, oj_indent_sym, rb_str_new2("  "));
     }
-    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_indent_sym)) {
-	rb_hash_aset(h, oj_indent_sym, rb_str_new2("  "));
+    if (!oj_hash_has_key(h, oj_space_before_sym)) {
+        rb_hash_aset(h, oj_space_before_sym, rb_str_new2(""));
     }
-    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_space_before_sym)) {
-	rb_hash_aset(h, oj_space_before_sym, rb_str_new2(""));
+    if (!oj_hash_has_key(h, oj_space_sym)) {
+        rb_hash_aset(h, oj_space_sym, rb_str_new2(" "));
     }
-    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_space_sym)) {
-	rb_hash_aset(h, oj_space_sym, rb_str_new2(" "));
+    if (!oj_hash_has_key(h, oj_object_nl_sym)) {
+        rb_hash_aset(h, oj_object_nl_sym, rb_str_new2("\n"));
     }
-    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_object_nl_sym)) {
-	rb_hash_aset(h, oj_object_nl_sym, rb_str_new2("\n"));
+    if (!oj_hash_has_key(h, oj_array_nl_sym)) {
+        rb_hash_aset(h, oj_array_nl_sym, rb_str_new2("\n"));
     }
-    if (Qfalse == rb_funcall(h, oj_has_key_id, 1, oj_array_nl_sym)) {
-	rb_hash_aset(h, oj_array_nl_sym, rb_str_new2("\n"));
+    if (Qundef == state_class) {
+        rb_warn("Oj::Rails.mimic_JSON was called implicitly. "
+                "Call it explicitly beforehand if you want to remove this warning.");
+        oj_define_mimic_json(0, NULL, Qnil);
     }
     rargs[1] = rb_funcall(state_class, oj_new_id, 1, h);
 
@@ -477,101 +497,99 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     copts.dump_opts.hash_size = (uint8_t)strlen(copts.dump_opts.hash_nl);
     strcpy(copts.dump_opts.array_nl, "\n");
     copts.dump_opts.array_size = (uint8_t)strlen(copts.dump_opts.array_nl);
-    copts.dump_opts.use = true;
+    copts.dump_opts.use        = true;
 
     return mimic_generate_core(2, rargs, &copts);
 }
 
-static VALUE
-mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
-    struct _parseInfo	pi;
-    VALUE		ropts;
-    VALUE		args[1];
+static int parse_options_cb(VALUE k, VALUE v, VALUE info) {
+    struct _parseInfo *pi = (struct _parseInfo *)info;
+
+    if (oj_symbolize_names_sym == k) {
+        pi->options.sym_key = (Qtrue == v) ? Yes : No;
+    } else if (oj_quirks_mode_sym == k) {
+        pi->options.quirks_mode = (Qtrue == v) ? Yes : No;
+    } else if (oj_create_additions_sym == k) {
+        pi->options.create_ok = (Qtrue == v) ? Yes : No;
+    } else if (oj_allow_nan_sym == k) {
+        pi->options.allow_nan = (Qtrue == v) ? Yes : No;
+    } else if (oj_hash_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_object_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_array_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.array_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.array_class = v;
+        }
+    } else if (oj_decimal_class_sym == k) {
+        pi->options.compat_bigdec = (oj_bigdecimal_class == v);
+    }
+    return ST_CONTINUE;
+}
+
+static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
+    struct _parseInfo pi;
+    VALUE             ropts;
+    VALUE             args[1];
 
     rb_scan_args(argc, argv, "11", NULL, &ropts);
     parse_info_init(&pi);
     oj_set_compat_callbacks(&pi);
 
     pi.err_class = oj_json_parser_error_class;
-    //pi.err_class = Qnil;
-
-    pi.options = oj_default_options;
-    pi.options.auto_define = No;
-    pi.options.quirks_mode = Yes;
-    pi.options.allow_invalid = No;
-    pi.options.empty_string = No;
-    pi.options.create_ok = No;
-    pi.options.allow_nan = (bang ? Yes : No);
-    pi.options.nilnil = No;
-    pi.options.bigdec_load = FloatDec;
-    pi.options.mode = CompatMode;
-    pi.max_depth = 100;
+    // pi.err_class = Qnil;
+
+    pi.options               = oj_default_options;
+    pi.options.auto_define   = No;
+    pi.options.quirks_mode   = Yes;
+    pi.options.allow_invalid = Yes;
+    pi.options.empty_string  = No;
+    pi.options.create_ok     = No;
+    pi.options.allow_nan     = (bang ? Yes : No);
+    pi.options.nilnil        = No;
+    pi.options.bigdec_load   = RubyDec;
+    pi.options.mode          = CompatMode;
+    pi.max_depth             = 100;
 
     if (Qnil != ropts) {
-	VALUE	v;
-
-	if (T_HASH != rb_type(ropts)) {
-	    rb_raise(rb_eArgError, "options must be a hash.");
-	}
-	if (Qundef == symbolize_names_sym) {
-	    symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));	rb_gc_register_address(&symbolize_names_sym);
-	}
-	if (Qnil != (v = rb_hash_lookup(ropts, symbolize_names_sym))) {
-	    pi.options.sym_key = (Qtrue == v) ? Yes : No;
-	}
-	if (Qnil != (v = rb_hash_lookup(ropts, oj_quirks_mode_sym))) {
-	    pi.options.quirks_mode = (Qtrue == v) ? Yes : No;
-	}
-	if (Qnil != (v = rb_hash_lookup(ropts, oj_create_additions_sym))) {
-	    pi.options.create_ok = (Qtrue == v) ? Yes : No;
-	}
-	if (Qnil != (v = rb_hash_lookup(ropts, oj_allow_nan_sym))) {
-	    pi.options.allow_nan = (Qtrue == v) ? Yes : No;
-	}
-
-	if (Qtrue == rb_funcall(ropts, oj_has_key_id, 1, oj_hash_class_sym)) {
-	    if (Qnil == (v = rb_hash_lookup(ropts, oj_hash_class_sym))) {
-		pi.options.hash_class = Qnil;
-	    } else {
-		rb_check_type(v, T_CLASS);
-		pi.options.hash_class = v;
-	    }
-	}
-	if (Qtrue == rb_funcall(ropts, oj_has_key_id, 1, oj_object_class_sym)) {
-	    if (Qnil == (v = rb_hash_lookup(ropts, oj_object_class_sym))) {
-		pi.options.hash_class = Qnil;
-	    } else {
-		rb_check_type(v, T_CLASS);
-		pi.options.hash_class = v;
-	    }
-	}
-	if (Qtrue == rb_funcall(ropts, oj_has_key_id, 1, oj_array_class_sym)) {
-	    if (Qnil == (v = rb_hash_lookup(ropts, oj_array_class_sym))) {
-		pi.options.array_class = Qnil;
-	    } else {
-		rb_check_type(v, T_CLASS);
-		pi.options.array_class = v;
-	    }
-	}
-	v = rb_hash_lookup(ropts, oj_max_nesting_sym);
-	if (Qtrue == v) {
-	    pi.max_depth = 100;
-	} else if (Qfalse == v || Qnil == v) {
-	    pi.max_depth = 0;
-	} else if (T_FIXNUM == rb_type(v)) {
-	    pi.max_depth = NUM2INT(v);
-	}
-	oj_parse_opt_match_string(&pi.options.str_rx, ropts);
-	if (Yes == pi.options.create_ok && Yes == pi.options.sym_key) {
-	    rb_raise(rb_eArgError, ":symbolize_names and :create_additions can not both be true.");
-	}
+        VALUE v;
+
+        if (T_HASH != rb_type(ropts)) {
+            rb_raise(rb_eArgError, "options must be a hash.");
+        }
+        rb_hash_foreach(ropts, parse_options_cb, (VALUE)&pi);
+        v = rb_hash_lookup(ropts, oj_max_nesting_sym);
+        if (Qtrue == v) {
+            pi.max_depth = 100;
+        } else if (Qfalse == v || Qnil == v) {
+            pi.max_depth = 0;
+        } else if (T_FIXNUM == rb_type(v)) {
+            pi.max_depth = NUM2INT(v);
+        }
+        oj_parse_opt_match_string(&pi.options.str_rx, ropts);
+        if (Yes == pi.options.create_ok && Yes == pi.options.sym_key) {
+            rb_raise(rb_eArgError, ":symbolize_names and :create_additions can not both be true.");
+        }
     }
     *args = *argv;
 
     if (T_STRING == rb_type(*args)) {
-	return oj_pi_parse(1, args, &pi, 0, 0, false);
+        return oj_pi_parse(1, args, &pi, 0, 0, false);
     } else {
-	return oj_pi_sparse(1, args, &pi, 0);
+        return oj_pi_sparse(1, args, &pi, 0);
     }
 }
 
@@ -584,8 +602,10 @@ mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
  *
  * - *source* [_String_|IO] source to parse
  * - *opts* [_Hash_] options
- *   - *:symbolize* [Boolean] _names flag indicating JSON object keys should be Symbols instead of Strings
- *   - *:create_additions* [Boolean] flag indicating a key matching +create_id+ in a JSON object should trigger the creation of Ruby Object
+ *   - *:symbolize* [Boolean] _names flag indicating JSON object keys should be Symbols instead of
+ *     Strings
+ *   - *:create_additions* [Boolean] flag indicating a key matching +create_id+ in a JSON object
+ *     should trigger the creation of Ruby Object
  *
  * Returns [Object]
  * @see create_id=
@@ -601,8 +621,7 @@ oj_mimic_parse(int argc, VALUE *argv, VALUE self) {
  * Same as parse().
  * @see parse
  */
-static VALUE
-mimic_parse_bang(int argc, VALUE *argv, VALUE self) {
+static VALUE mimic_parse_bang(int argc, VALUE *argv, VALUE self) {
     return mimic_parse_core(argc, argv, self, true);
 }
 
@@ -614,8 +633,7 @@ mimic_parse_bang(int argc, VALUE *argv, VALUE self) {
  * - *obj* [_Hash_|Array] object to walk
  * - *proc* [_Proc_] to yield to on each element
  */
-static VALUE
-mimic_recurse_proc(VALUE self, VALUE obj) {
+static VALUE mimic_recurse_proc(VALUE self, VALUE obj) {
     rb_need_block();
     mimic_walk(Qnil, obj, Qnil);
 
@@ -630,25 +648,23 @@ mimic_recurse_proc(VALUE self, VALUE obj) {
  *
  * - *id* [_nil_|String] new create_id
  *
- * Returns [_String_] the id.
+ * Returns [_nil_|_String_] the id.
  */
-static VALUE
-mimic_set_create_id(VALUE self, VALUE id) {
-    Check_Type(id, T_STRING);
-
+static VALUE mimic_set_create_id(VALUE self, VALUE id) {
     if (NULL != oj_default_options.create_id) {
-	if (oj_json_class != oj_default_options.create_id) {
-	    xfree((char*)oj_default_options.create_id);
-	}
-	oj_default_options.create_id = NULL;
-	oj_default_options.create_id_len = 0;
+        if (oj_json_class != oj_default_options.create_id) {
+            OJ_R_FREE((char *)oj_default_options.create_id);
+        }
+        oj_default_options.create_id     = NULL;
+        oj_default_options.create_id_len = 0;
     }
     if (Qnil != id) {
-	size_t	len = RSTRING_LEN(id) + 1;
+        const char *ptr = StringValueCStr(id);
+        size_t      len = RSTRING_LEN(id) + 1;
 
-	oj_default_options.create_id = ALLOC_N(char, len);
-	strcpy((char*)oj_default_options.create_id, StringValuePtr(id));
-	oj_default_options.create_id_len = len - 1;
+        oj_default_options.create_id = OJ_R_ALLOC_N(char, len);
+        strcpy((char *)oj_default_options.create_id, ptr);
+        oj_default_options.create_id_len = len - 1;
     }
     return id;
 }
@@ -658,100 +674,102 @@ mimic_set_create_id(VALUE self, VALUE id) {
  *
  * Returns [_String_] the create_id.
  */
-static VALUE
-mimic_create_id(VALUE self) {
+static VALUE mimic_create_id(VALUE self) {
     if (NULL != oj_default_options.create_id) {
-	return oj_encode(rb_str_new_cstr(oj_default_options.create_id));
+        return rb_utf8_str_new(oj_default_options.create_id, oj_default_options.create_id_len);
     }
     return rb_str_new_cstr(oj_json_class);
 }
 
-static struct _options	mimic_object_to_json_options = {
-    0,		// indent
-    No,		// circular
-    No,		// auto_define
-    No,		// sym_key
-    JXEsc,	// escape_mode
-    CompatMode,	// mode
-    No,		// class_cache
-    RubyTime,	// time_format
-    No,		// bigdec_as_num
-    FloatDec,	// bigdec_load
-    No,		// to_hash
-    No,		// to_json
-    No,		// as_json
-    No,		// raw_json
-    No,		// nilnil
-    No,		// empty_string
-    Yes,	// allow_gc
-    Yes,	// quirks_mode
-    No,		// allow_invalid
-    No,		// create_ok
-    No,		// allow_nan
-    No,		// trace
-    No,		// safe
-    0,		// integer_range_min
-    0,		// integer_range_max
-    oj_json_class,// create_id
-    10,		// create_id_len
-    3,		// sec_prec
-    16,		// float_prec
-    "%0.16g",	// float_fmt
-    Qnil,	// hash_class
-    Qnil,	// array_class
-    {		// dump_opts
-	false,	//use
-	"",	// indent
-	"",	// before_sep
-	"",	// after_sep
-	"",	// hash_nl
-	"",	// array_nl
-	0,	// indent_size
-	0,	// before_size
-	0,	// after_size
-	0,	// hash_size
-	0,	// array_size
-	RaiseNan,// nan_dump
-	false,	// omit_nil
-	100, // max_depth
-    },
-    {		// str_rx
-	NULL,	// head
-	NULL,	// tail
-	{ '\0' }, // err
-    }
-};
-
-static VALUE
-mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
-    char		buf[4096];
-    struct _out		out;
-    VALUE		rstr;
-    struct _options	copts = oj_default_options;
+static struct _options mimic_object_to_json_options = {0,              // indent
+                                                       No,             // circular
+                                                       No,             // auto_define
+                                                       No,             // sym_key
+                                                       JXEsc,          // escape_mode
+                                                       CompatMode,     // mode
+                                                       No,             // class_cache
+                                                       RubyTime,       // time_format
+                                                       No,             // bigdec_as_num
+                                                       RubyDec,        // bigdec_load
+                                                       false,          // compat_bigdec
+                                                       No,             // to_hash
+                                                       No,             // to_json
+                                                       No,             // as_json
+                                                       No,             // raw_json
+                                                       No,             // nilnil
+                                                       No,             // empty_string
+                                                       Yes,            // allow_gc
+                                                       Yes,            // quirks_mode
+                                                       Yes,            // allow_invalid
+                                                       No,             // create_ok
+                                                       No,             // allow_nan
+                                                       No,             // trace
+                                                       No,             // safe
+                                                       false,          // sec_prec_set
+                                                       No,             // ignore_under
+                                                       Yes,            // cache_keys
+                                                       0,              // cache_str
+                                                       0,              // int_range_min
+                                                       0,              // int_range_max
+                                                       oj_json_class,  // create_id
+                                                       10,             // create_id_len
+                                                       3,              // sec_prec
+                                                       0,              // float_prec
+                                                       "%0.16g",       // float_fmt
+                                                       Qnil,           // hash_class
+                                                       Qnil,           // array_class
+                                                       {
+                                                           // dump_opts
+                                                           false,     // use
+                                                           "",        // indent
+                                                           "",        // before_sep
+                                                           "",        // after_sep
+                                                           "",        // hash_nl
+                                                           "",        // array_nl
+                                                           0,         // indent_size
+                                                           0,         // before_size
+                                                           0,         // after_size
+                                                           0,         // hash_size
+                                                           0,         // array_size
+                                                           RaiseNan,  // nan_dump
+                                                           false,     // omit_nil
+                                                           false,     // omit_null_byte
+                                                           100,       // max_depth
+                                                       },
+                                                       {
+                                                           // str_rx
+                                                           NULL,    // head
+                                                           NULL,    // tail
+                                                           {'\0'},  // err
+                                                       }};
+
+static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
+    struct _out     out;
+    VALUE           rstr;
+    struct _options copts = oj_default_options;
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf = buf;
-    out.end = buf + sizeof(buf) - 10;
-    out.allocated = false;
-    out.omit_nil = copts.dump_opts.omit_nil;
-    copts.mode = CompatMode;
+
+    oj_out_init(&out);
+
+    out.omit_nil  = copts.dump_opts.omit_nil;
+    copts.mode    = CompatMode;
     copts.to_json = No;
     if (1 <= argc && Qnil != argv[0]) {
-	oj_parse_mimic_dump_options(argv[0], &copts);
+        oj_parse_mimic_dump_options(argv[0], &copts);
     }
     // To be strict the mimic_object_to_json_options should be used but people
     // seem to prefer the option of changing that.
-    //oj_dump_obj_to_json(self, &mimic_object_to_json_options, &out);
+    // oj_dump_obj_to_json(self, &mimic_object_to_json_options, &out);
     oj_dump_obj_to_json_using_params(self, &copts, &out, argc, argv);
-    if (0 == out.buf) {
-	rb_raise(rb_eNoMemError, "Not enough memory.");
-    }
-    rstr = rb_str_new2(out.buf);
-    rstr = oj_encode(rstr);
-    if (out.allocated) {
-	xfree(out.buf);
+    if (NULL == out.buf) {
+        rb_raise(rb_eNoMemError, "Not enough memory.");
     }
+    rstr = rb_utf8_str_new_cstr(out.buf);
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -760,77 +778,98 @@ mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
  *
  * Returns [_JSON::State_] the JSON::State class.
  */
-static VALUE
-mimic_state(VALUE self) {
+static VALUE mimic_state(VALUE self) {
     return state_class;
 }
 
-void
-oj_mimic_json_methods(VALUE json) {
-    VALUE	json_error;
-    VALUE	generator;
-    VALUE	ext;
+void oj_mimic_json_methods(VALUE json) {
+    VALUE json_error;
+    VALUE generator;
+    VALUE ext;
+    VALUE verbose;
+
+    // rb_undef_method doesn't work for modules or maybe sometimes
+    // doesn't. Anyway setting verbose should hide the warning.
+    verbose = rb_gv_get("$VERBOSE");
+    rb_gv_set("$VERBOSE", Qfalse);
 
+    rb_undef_method(json, "create_id=");
     rb_define_module_function(json, "create_id=", mimic_set_create_id, 1);
+    rb_undef_method(json, "create_id");
     rb_define_module_function(json, "create_id", mimic_create_id, 0);
 
+    rb_undef_method(json, "dump");
     rb_define_module_function(json, "dump", mimic_dump, -1);
+    rb_undef_method(json, "load");
     rb_define_module_function(json, "load", mimic_load, -1);
     rb_define_module_function(json, "restore", mimic_load, -1);
+    rb_undef_method(json, "recurse_proc");
     rb_define_module_function(json, "recurse_proc", mimic_recurse_proc, 1);
+    rb_undef_method(json, "[]");
     rb_define_module_function(json, "[]", mimic_dump_load, -1);
 
+    rb_undef_method(json, "generate");
     rb_define_module_function(json, "generate", oj_mimic_generate, -1);
+    rb_undef_method(json, "fast_generate");
     rb_define_module_function(json, "fast_generate", oj_mimic_generate, -1);
+    rb_undef_method(json, "pretty_generate");
     rb_define_module_function(json, "pretty_generate", oj_mimic_pretty_generate, -1);
     // For older versions of JSON, the deprecated unparse methods.
+    rb_undef_method(json, "unparse");
     rb_define_module_function(json, "unparse", oj_mimic_generate, -1);
     rb_define_module_function(json, "fast_unparse", oj_mimic_generate, -1);
     rb_define_module_function(json, "pretty_unparse", oj_mimic_pretty_generate, -1);
 
+    rb_undef_method(json, "parse");
     rb_define_module_function(json, "parse", oj_mimic_parse, -1);
+    rb_undef_method(json, "parse!");
     rb_define_module_function(json, "parse!", mimic_parse_bang, -1);
 
+    rb_undef_method(json, "state");
     rb_define_module_function(json, "state", mimic_state, 0);
+    rb_gv_set("$VERBOSE", verbose);
 
     if (rb_const_defined_at(json, rb_intern("JSONError"))) {
         json_error = rb_const_get(json, rb_intern("JSONError"));
     } else {
         json_error = rb_define_class_under(json, "JSONError", rb_eStandardError);
     }
+
+    rb_global_variable(&oj_json_parser_error_class);
     if (rb_const_defined_at(json, rb_intern("ParserError"))) {
         oj_json_parser_error_class = rb_const_get(json, rb_intern("ParserError"));
     } else {
-    	oj_json_parser_error_class = rb_define_class_under(json, "ParserError", json_error);
+        oj_json_parser_error_class = rb_define_class_under(json, "ParserError", json_error);
     }
+
+    rb_global_variable(&oj_json_generator_error_class);
     if (rb_const_defined_at(json, rb_intern("GeneratorError"))) {
         oj_json_generator_error_class = rb_const_get(json, rb_intern("GeneratorError"));
     } else {
-    	oj_json_generator_error_class = rb_define_class_under(json, "GeneratorError", json_error);
+        oj_json_generator_error_class = rb_define_class_under(json, "GeneratorError", json_error);
     }
     if (rb_const_defined_at(json, rb_intern("NestingError"))) {
         rb_const_get(json, rb_intern("NestingError"));
     } else {
-    	rb_define_class_under(json, "NestingError", json_error);
+        rb_define_class_under(json, "NestingError", json_error);
     }
 
     if (rb_const_defined_at(json, rb_intern("Ext"))) {
-	ext = rb_const_get_at(json, rb_intern("Ext"));
-     } else {
-	ext = rb_define_module_under(json, "Ext");
+        ext = rb_const_get_at(json, rb_intern("Ext"));
+    } else {
+        ext = rb_define_module_under(json, "Ext");
     }
     if (rb_const_defined_at(ext, rb_intern("Generator"))) {
-	generator = rb_const_get_at(ext, rb_intern("Generator"));
-     } else {
-	generator = rb_define_module_under(ext, "Generator");
+        generator = rb_const_get_at(ext, rb_intern("Generator"));
+    } else {
+        generator = rb_define_module_under(ext, "Generator");
     }
     if (!rb_const_defined_at(generator, rb_intern("State"))) {
-	rb_require("oj/state");
+        rb_require("oj/state");
     }
     // Pull in the JSON::State mimic file.
+    rb_global_variable(&state_class);
     state_class = rb_const_get_at(generator, rb_intern("State"));
-
-    symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));	rb_gc_register_address(&symbolize_names_sym);
 }
 
 /* Document-module: JSON
@@ -839,39 +878,41 @@ oj_mimic_json_methods(VALUE json) {
  */
 VALUE
 oj_define_mimic_json(int argc, VALUE *argv, VALUE self) {
-    VALUE	dummy;
-    VALUE	verbose;
-    VALUE	json;
+    VALUE dummy;
+    VALUE verbose;
+    VALUE json;
 
     // Either set the paths to indicate JSON has been loaded or replaces the
     // methods if it has been loaded.
     if (rb_const_defined_at(rb_cObject, rb_intern("JSON"))) {
-	json = rb_const_get_at(rb_cObject, rb_intern("JSON"));
+        json = rb_const_get_at(rb_cObject, rb_intern("JSON"));
     } else {
-	json = rb_define_module("JSON");
+        json = rb_define_module("JSON");
     }
     verbose = rb_gv_get("$VERBOSE");
     rb_gv_set("$VERBOSE", Qfalse);
     rb_define_module_function(rb_cObject, "JSON", mimic_dump_load, -1);
     dummy = rb_gv_get("$LOADED_FEATURES");
     if (rb_type(dummy) == T_ARRAY) {
-	rb_ary_push(dummy, rb_str_new2("json"));
-	if (0 < argc) {
-	    VALUE	mimic_args[1];
+        rb_ary_push(dummy, rb_str_new2("json"));
+        if (0 < argc) {
+            VALUE mimic_args[1];
 
-	    *mimic_args = *argv;
-	    rb_funcall2(Oj, rb_intern("mimic_loaded"), 1, mimic_args);
-	} else {
-	    rb_funcall2(Oj, rb_intern("mimic_loaded"), 0, 0);
-	}
+            *mimic_args = *argv;
+            rb_funcall2(Oj, rb_intern("mimic_loaded"), 1, mimic_args);
+        } else {
+            rb_funcall2(Oj, rb_intern("mimic_loaded"), 0, 0);
+        }
     }
     oj_mimic_json_methods(json);
 
-    rb_define_method(rb_cObject, "to_json", mimic_object_to_json, -1);
+    if (!rb_const_defined(rb_cObject, rb_intern("ActiveSupport"))) {
+        rb_define_method(rb_cObject, "to_json", mimic_object_to_json, -1);
+    }
 
     rb_gv_set("$VERBOSE", verbose);
 
-    oj_default_options = mimic_object_to_json_options;
+    oj_default_options         = mimic_object_to_json_options;
     oj_default_options.to_json = Yes;
 
     return json;