oj 3.7.12

data/ext/oj/parse.h

@@ -0,0 +1,111 @@
+/* parse.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef OJ_PARSE_H
+#define OJ_PARSE_H
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "ruby.h"
+#include "oj.h"
+#include "val_stack.h"
+#include "circarray.h"
+#include "reader.h"
+#include "rxclass.h"
+
+struct _rxClass;
+
+typedef struct _numInfo {
+    int64_t	i;
+    int64_t	num;
+    int64_t	div;
+    int64_t	di;
+    const char	*str;
+    size_t	len;
+    long	exp;
+    int		big;
+    int		infinity;
+    int		nan;
+    int		neg;
+    int		hasExp;
+    int		no_big;
+} *NumInfo;
+
+typedef struct _parseInfo {
+    // used for the string parser
+    const char		*json;
+    const char		*cur;
+    const char		*end;
+    // used for the stream parser
+    struct _reader	rd;
+
+    struct _err		err;
+    struct _options	options;
+    VALUE		handler;
+    struct _valStack	stack;
+    CircArray		circ_array;
+    struct _rxClass	str_rx;
+    int			expect_value;
+    int			max_depth; // just for the json gem
+    VALUE		proc;
+    VALUE		(*start_hash)(struct _parseInfo *pi);
+    void		(*end_hash)(struct _parseInfo *pi);
+    VALUE		(*hash_key)(struct _parseInfo *pi, const char *key, size_t klen);
+    void		(*hash_set_cstr)(struct _parseInfo *pi, Val kval, const char *str, size_t len, const char *orig);
+    void		(*hash_set_num)(struct _parseInfo *pi, Val kval, NumInfo ni);
+    void		(*hash_set_value)(struct _parseInfo *pi, Val kval, VALUE value);
+
+    VALUE		(*start_array)(struct _parseInfo *pi);
+    void		(*end_array)(struct _parseInfo *pi);
+    void		(*array_append_cstr)(struct _parseInfo *pi, const char *str, size_t len, const char *orig);
+    void		(*array_append_num)(struct _parseInfo *pi, NumInfo ni);
+    void		(*array_append_value)(struct _parseInfo *pi, VALUE value);
+
+    void		(*add_cstr)(struct _parseInfo *pi, const char *str, size_t len, const char *orig);
+    void		(*add_num)(struct _parseInfo *pi, NumInfo ni);
+    void		(*add_value)(struct _parseInfo *pi, VALUE val);
+    VALUE		err_class;
+    bool		has_callbacks;
+} *ParseInfo;
+
+extern void	oj_parse2(ParseInfo pi);
+extern void	oj_set_error_at(ParseInfo pi, VALUE err_clas, const char* file, int line, const char *format, ...);
+extern VALUE	oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yieldOk);
+extern VALUE	oj_num_as_value(NumInfo ni);
+
+extern void	oj_set_strict_callbacks(ParseInfo pi);
+extern void	oj_set_object_callbacks(ParseInfo pi);
+extern void	oj_set_compat_callbacks(ParseInfo pi);
+extern void	oj_set_wab_callbacks(ParseInfo pi);
+
+extern void	oj_sparse2(ParseInfo pi);
+extern VALUE	oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd);
+
+static inline void
+parse_info_init(ParseInfo pi) {
+    memset(pi, 0, sizeof(struct _parseInfo));
+}
+
+static inline bool
+empty_ok(Options options) {
+    switch (options->mode) {
+    case ObjectMode:
+    case WabMode:
+	return true;
+    case CompatMode:
+    case RailsMode:
+	return false;
+    case StrictMode:
+    case NullMode:
+    case CustomMode:
+    default:
+	break;
+    }
+    return Yes == options->empty_string;
+}
+
+#endif /* OJ_PARSE_H */

data/ext/oj/rails.c

@@ -0,0 +1,1485 @@
+/* rails.c
+ * Copyright (c) 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "rails.h"
+#include "encode.h"
+#include "code.h"
+#include "encode.h"
+#include "trace.h"
+#include "util.h"
+
+#define OJ_INFINITY (1.0/0.0)
+
+// TBD keep static array of strings and functions to help with rails optimization
+typedef struct _encoder {
+    struct _rOptTable	ropts;
+    struct _options	opts;
+    VALUE		arg;
+} *Encoder;
+
+bool	oj_rails_hash_opt = false;
+bool	oj_rails_array_opt = false;
+bool	oj_rails_float_opt = false;
+
+extern void	oj_mimic_json_methods(VALUE json);
+
+static void	dump_rails_val(VALUE obj, int depth, Out out, bool as_ok);
+
+extern VALUE	Oj;
+
+static struct _rOptTable	ropts = { 0, 0, NULL };
+
+static VALUE	encoder_class = Qnil;
+static bool	escape_html = true;
+static bool	xml_time = true;
+
+static ROpt	create_opt(ROptTable rot, VALUE clas);
+
+ROpt
+oj_rails_get_opt(ROptTable rot, VALUE clas) {
+    if (NULL == rot) {
+	rot = &ropts;
+    }
+    if (0 < rot->len) {
+	int	lo = 0;
+	int	hi = rot->len - 1;
+	int	mid;
+	VALUE	v;
+
+	if (clas < rot->table->clas || rot->table[hi].clas < clas) {
+	    return NULL;
+	}
+	if (rot->table[lo].clas == clas) {
+	    return rot->table;
+	}
+	if (rot->table[hi].clas == clas) {
+	    return &rot->table[hi];
+	}
+	while (2 <= hi - lo) {
+	    mid = (hi + lo) / 2;
+	    v = rot->table[mid].clas;
+	    if (v == clas) {
+		return &rot->table[mid];
+	    }
+	    if (v < clas) {
+		lo = mid;
+	    } else {
+		hi = mid;
+	    }
+	}
+    }
+    return NULL;
+}
+
+static ROptTable
+copy_opts(ROptTable src, ROptTable dest) {
+    dest->len = src->len;
+    dest->alen = src->alen;
+    if (NULL == src->table) {
+	dest->table = NULL;
+    } else {
+	dest->table = ALLOC_N(struct _rOpt, dest->alen);
+	memcpy(dest->table, src->table, sizeof(struct _rOpt) * dest->alen);
+    }
+    return NULL;
+}
+
+static int
+dump_attr_cb(ID key, VALUE value, Out out) {
+    int		depth = out->depth;
+    size_t	size = depth * out->indent + 1;
+    const char	*attr = rb_id2name(key);
+
+    // Some exceptions such as NoMethodError have an invisible attribute where
+    // the key name is NULL. Not an empty string but NULL.
+    if (NULL == attr) {
+	attr = "";
+    }
+    if (0 == strcmp("bt", attr) || 0 == strcmp("mesg", attr)) {
+	return ST_CONTINUE;
+    }
+    assure_size(out, size);
+    fill_indent(out, depth);
+    if ('@' == *attr) {
+	attr++;
+	oj_dump_cstr(attr, strlen(attr), 0, 0, out);
+    } else {
+	char	buf[32];
+
+	*buf = '~';
+	strncpy(buf + 1, attr, sizeof(buf) - 2);
+	buf[sizeof(buf) - 1] = '\0';
+	oj_dump_cstr(buf, strlen(buf), 0, 0, out);
+    }
+    *out->cur++ = ':';
+    dump_rails_val(value, depth, out, true);
+    out->depth = depth;
+    *out->cur++ = ',';
+
+    return ST_CONTINUE;
+}
+
+static void
+dump_obj_attrs(VALUE obj, int depth, Out out, bool as_ok) {
+    assure_size(out, 2);
+    *out->cur++ = '{';
+    out->depth = depth + 1;
+    rb_ivar_foreach(obj, dump_attr_cb, (VALUE)out);
+    if (',' == *(out->cur - 1)) {
+	out->cur--; // backup to overwrite last comma
+    }
+    out->depth = depth;
+    fill_indent(out, depth);
+    *out->cur++ = '}';
+    *out->cur = '\0';
+}
+
+static void
+dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
+    int			d3 = depth + 2;
+    size_t		size = d3 * out->indent + 2;
+    size_t		sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+    volatile VALUE	ma;
+    volatile VALUE	v;
+    int			cnt;
+    int			i;
+    int			len;
+    const char		*name;
+
+#ifdef RSTRUCT_LEN
+#if RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
+    cnt = (int)NUM2LONG(RSTRUCT_LEN(obj));
+#else // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
+    cnt = (int)RSTRUCT_LEN(obj);
+#endif // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
+#else
+    // This is a bit risky as a struct in C ruby is not the same as a Struct
+    // class in interpreted Ruby so length() may not be defined.
+    cnt = FIX2INT(rb_funcall(obj, oj_length_id, 0));
+#endif
+    ma = rb_struct_s_members(rb_obj_class(obj));
+    assure_size(out, 2);
+    *out->cur++ = '{';
+    for (i = 0; i < cnt; i++) {
+	volatile VALUE	s = rb_sym_to_s(rb_ary_entry(ma, i));
+
+	name = rb_string_value_ptr((VALUE*)&s);
+	len = (int)RSTRING_LEN(s);
+	assure_size(out, size + sep_len + 6);
+	if (0 < i) {
+	    *out->cur++ = ',';
+	}
+	fill_indent(out, d3);
+	*out->cur++ = '"';
+	memcpy(out->cur, name, len);
+	out->cur += len;
+	*out->cur++ = '"';
+	if (0 < out->opts->dump_opts.before_size) {
+	    strcpy(out->cur, out->opts->dump_opts.before_sep);
+	    out->cur += out->opts->dump_opts.before_size;
+	}
+	*out->cur++ = ':';
+	if (0 < out->opts->dump_opts.after_size) {
+	    strcpy(out->cur, out->opts->dump_opts.after_sep);
+	    out->cur += out->opts->dump_opts.after_size;
+	}
+#ifdef RSTRUCT_LEN
+	v = RSTRUCT_GET(obj, i);
+#else
+	v = rb_struct_aref(obj, INT2FIX(i));
+#endif
+	dump_rails_val(v, d3, out, true);
+    }
+    fill_indent(out, depth);
+    *out->cur++ = '}';
+    *out->cur = '\0';
+}
+
+static ID	to_a_id = 0;
+
+static void
+dump_enumerable(VALUE obj, int depth, Out out, bool as_ok) {
+    if (0 == to_a_id) {
+	to_a_id = rb_intern("to_a");
+    }
+    dump_rails_val(rb_funcall(obj, to_a_id, 0), depth, out, false);
+}
+
+static void
+dump_bigdecimal(VALUE obj, int depth, Out out, bool as_ok) {
+    volatile VALUE	rstr = rb_funcall(obj, oj_to_s_id, 0);
+    const char		*str = rb_string_value_ptr((VALUE*)&rstr);
+
+    if ('I' == *str || 'N' == *str || ('-' == *str && 'I' == str[1])) {
+	oj_dump_nil(Qnil, depth, out, false);
+    } else if (Yes == out->opts->bigdec_as_num) {
+	oj_dump_raw(str, (int)RSTRING_LEN(rstr), out);
+    } else {
+	oj_dump_cstr(str, (int)RSTRING_LEN(rstr), 0, 0, out);
+    }
+}
+
+static void
+dump_sec_nano(VALUE obj, int64_t sec, long nsec, Out out) {
+    char		buf[64];
+    struct _timeInfo	ti;
+    long		one = 1000000000;
+    long		tzsecs = NUM2LONG(rb_funcall2(obj, oj_utc_offset_id, 0, 0));
+    int			tzhour, tzmin;
+    char		tzsign = '+';
+    int			len;
+
+    if (out->end - out->cur <= 36) {
+	assure_size(out, 36);
+    }
+    if (9 > out->opts->sec_prec) {
+	int	i;
+
+	// Rails does not round when reducing precision but instead floors,
+	for (i = 9 - out->opts->sec_prec; 0 < i; i--) {
+	    nsec = nsec / 10;
+	    one /= 10;
+	}
+	if (one <= nsec) {
+	    nsec -= one;
+	    sec++;
+	}
+    }
+    // 2012-01-05T23:58:07.123456000+09:00 or 2012/01/05 23:58:07 +0900
+    sec += tzsecs;
+    sec_as_time(sec, &ti);
+    if (0 > tzsecs) {
+        tzsign = '-';
+        tzhour = (int)(tzsecs / -3600);
+        tzmin = (int)(tzsecs / -60) - (tzhour * 60);
+    } else {
+        tzhour = (int)(tzsecs / 3600);
+        tzmin = (int)(tzsecs / 60) - (tzhour * 60);
+    }
+    if (!xml_time) {
+	len = sprintf(buf, "%04d/%02d/%02d %02d:%02d:%02d %c%02d%02d", ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, tzsign, tzhour, tzmin);
+    } else if (0 == out->opts->sec_prec) {
+	if (0 == tzsecs && rb_funcall2(obj, oj_utcq_id, 0, 0)) {
+	    len = sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02dZ", ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec);
+	} else {
+	    len = sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d", ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, tzsign, tzhour, tzmin);
+	}
+    } else if (0 == tzsecs && rb_funcall2(obj, oj_utcq_id, 0, 0)) {
+	char	format[64] = "%04d-%02d-%02dT%02d:%02d:%02d.%09ldZ";
+
+	len = 30;
+	if (9 > out->opts->sec_prec) {
+	    format[32] = '0' + out->opts->sec_prec;
+	    len -= 9 - out->opts->sec_prec;
+	}
+	len = sprintf(buf, format, ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, nsec);
+    } else {
+	char	format[64] = "%04d-%02d-%02dT%02d:%02d:%02d.%09ld%c%02d:%02d";
+
+	len = 35;
+	if (9 > out->opts->sec_prec) {
+	    format[32] = '0' + out->opts->sec_prec;
+	    len -= 9 - out->opts->sec_prec;
+	}
+	len = sprintf(buf, format, ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, nsec, tzsign, tzhour, tzmin);
+    }
+    oj_dump_cstr(buf, len, 0, 0, out);
+}
+
+static void
+dump_time(VALUE obj, int depth, Out out, bool as_ok) {
+    long long	sec;
+    long long	nsec;
+
+#ifdef HAVE_RB_TIME_TIMESPEC
+    if (16 <= sizeof(struct timespec)) {
+	struct timespec	ts = rb_time_timespec(obj);
+
+	sec = (long long)ts.tv_sec;
+	nsec = ts.tv_nsec;
+    } else {
+	sec = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+	nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+    }
+#else
+    sec = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+    nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+#endif
+    dump_sec_nano(obj, sec, nsec, out);
+}
+
+static void
+dump_timewithzone(VALUE obj, int depth, Out out, bool as_ok) {
+    int64_t	sec = NUM2LONG(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+    long long	nsec = 0;
+
+    if (rb_respond_to(obj, oj_tv_nsec_id)) {
+	nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+    } else if (rb_respond_to(obj, oj_tv_usec_id)) {
+	nsec = rb_num2ll(rb_funcall2(obj, oj_tv_usec_id, 0, 0)) * 1000;
+    }
+    dump_sec_nano(obj, sec, nsec, out);
+}
+
+static void
+dump_to_s(VALUE obj, int depth, Out out, bool as_ok) {
+    volatile VALUE	rstr = rb_funcall(obj, oj_to_s_id, 0);
+
+    oj_dump_cstr(rb_string_value_ptr((VALUE*)&rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+}
+
+static ID	parameters_id = 0;
+
+typedef struct _strLen {
+    const char	*str;
+    int		len;
+} *StrLen;
+
+static void
+dump_actioncontroller_parameters(VALUE obj, int depth, Out out, bool as_ok) {
+    if (0 == parameters_id) {
+	parameters_id = rb_intern("@parameters");
+    }
+    out->argc = 0;
+    dump_rails_val(rb_ivar_get(obj, parameters_id), depth, out, true);
+}
+
+static StrLen
+columns_array(VALUE rcols, int *ccnt) {
+    volatile VALUE	v;
+    StrLen		cp;
+    StrLen		cols;
+    int			i;
+    int			cnt = (int)RARRAY_LEN(rcols);
+
+    *ccnt = cnt;
+    cols = ALLOC_N(struct _strLen, cnt);
+    for (i = 0, cp = cols; i < cnt; i++, cp++) {
+	v = rb_ary_entry(rcols, i);
+	if (T_STRING != rb_type(v)) {
+	    v = rb_funcall(v, oj_to_s_id, 0);
+	}
+	cp->str = StringValuePtr(v);
+	cp->len = (int)RSTRING_LEN(v);
+    }
+    return cols;
+}
+
+static void
+dump_row(VALUE row, StrLen cols, int ccnt, int depth, Out out) {
+    size_t	size;
+    int		d2 = depth + 1;
+    int		i;
+
+    assure_size(out, 2);
+    *out->cur++ = '{';
+    size = depth * out->indent + 3;
+    for (i = 0; i < ccnt; i++, cols++) {
+	assure_size(out, size);
+	if (out->opts->dump_opts.use) {
+	    if (0 < out->opts->dump_opts.array_size) {
+		strcpy(out->cur, out->opts->dump_opts.array_nl);
+		out->cur += out->opts->dump_opts.array_size;
+	    }
+	    if (0 < out->opts->dump_opts.indent_size) {
+		int	i;
+		for (i = d2; 0 < i; i--) {
+		    strcpy(out->cur, out->opts->dump_opts.indent_str);
+		    out->cur += out->opts->dump_opts.indent_size;
+		}
+	    }
+	} else {
+	    fill_indent(out, d2);
+	}
+	oj_dump_cstr(cols->str, cols->len, 0, 0, out);
+	*out->cur++ = ':';
+	dump_rails_val(rb_ary_entry(row, i), depth, out, true);
+	if (i < ccnt - 1) {
+	    *out->cur++ = ',';
+	}
+    }
+    size = depth * out->indent + 1;
+    assure_size(out, size);
+    if (out->opts->dump_opts.use) {
+	if (0 < out->opts->dump_opts.array_size) {
+	    strcpy(out->cur, out->opts->dump_opts.array_nl);
+	    out->cur += out->opts->dump_opts.array_size;
+	}
+	if (0 < out->opts->dump_opts.indent_size) {
+	    int	i;
+
+	    for (i = depth; 0 < i; i--) {
+		strcpy(out->cur, out->opts->dump_opts.indent_str);
+		out->cur += out->opts->dump_opts.indent_size;
+	    }
+	}
+    } else {
+	fill_indent(out, depth);
+    }
+    *out->cur++ = '}';
+}
+
+static ID	rows_id = 0;
+static ID	columns_id = 0;
+
+static void
+dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok) {
+    volatile VALUE	rows;
+    StrLen		cols;
+    int			ccnt = 0;
+    int			i, rcnt;
+    size_t		size;
+    int			d2 = depth + 1;
+
+    if (0 == rows_id) {
+	rows_id = rb_intern("@rows");
+	columns_id = rb_intern("@columns");
+    }
+    out->argc = 0;
+    cols = columns_array(rb_ivar_get(obj, columns_id), &ccnt);
+    rows = rb_ivar_get(obj, rows_id);
+    rcnt = (int)RARRAY_LEN(rows);
+    assure_size(out, 2);
+    *out->cur++ = '[';
+    if (out->opts->dump_opts.use) {
+	size = d2 * out->opts->dump_opts.indent_size + out->opts->dump_opts.array_size + 1;
+    } else {
+	size = d2 * out->indent + 2;
+    }
+    assure_size(out, 2);
+    for (i = 0; i < rcnt; i++) {
+	assure_size(out, size);
+	if (out->opts->dump_opts.use) {
+	    if (0 < out->opts->dump_opts.array_size) {
+		strcpy(out->cur, out->opts->dump_opts.array_nl);
+		out->cur += out->opts->dump_opts.array_size;
+	    }
+	    if (0 < out->opts->dump_opts.indent_size) {
+		int	i;
+		for (i = d2; 0 < i; i--) {
+		    strcpy(out->cur, out->opts->dump_opts.indent_str);
+		    out->cur += out->opts->dump_opts.indent_size;
+		}
+	    }
+	} else {
+	    fill_indent(out, d2);
+	}
+	dump_row(rb_ary_entry(rows, i), cols, ccnt, d2, out);
+	if (i < rcnt - 1) {
+	    *out->cur++ = ',';
+	}
+    }
+    xfree(cols);
+    size = depth * out->indent + 1;
+    assure_size(out, size);
+    if (out->opts->dump_opts.use) {
+	if (0 < out->opts->dump_opts.array_size) {
+	    strcpy(out->cur, out->opts->dump_opts.array_nl);
+	    out->cur += out->opts->dump_opts.array_size;
+	}
+	if (0 < out->opts->dump_opts.indent_size) {
+	    int	i;
+
+	    for (i = depth; 0 < i; i--) {
+		strcpy(out->cur, out->opts->dump_opts.indent_str);
+		out->cur += out->opts->dump_opts.indent_size;
+	    }
+	}
+    } else {
+	fill_indent(out, depth);
+    }
+    *out->cur++ = ']';
+}
+
+typedef struct _namedFunc {
+    const char	*name;
+    DumpFunc	func;
+} *NamedFunc;
+
+static void
+dump_as_string(VALUE obj, int depth, Out out, bool as_ok) {
+    if (oj_code_dump(oj_compat_codes, obj, depth, out)) {
+	out->argc = 0;
+	return;
+    }
+    oj_dump_obj_to_s(obj, out);
+}
+
+static void
+dump_as_json(VALUE obj, int depth, Out out, bool as_ok) {
+    volatile VALUE	ja;
+
+    if (Yes == out->opts->trace) {
+	oj_trace("as_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyIn);
+    }
+    // Some classes elect to not take an options argument so check the arity
+    // of as_json.
+    if (0 == rb_obj_method_arity(obj, oj_as_json_id)) {
+	ja = rb_funcall(obj, oj_as_json_id, 0);
+    } else {
+	ja = rb_funcall2(obj, oj_as_json_id, out->argc, out->argv);
+    }
+    if (Yes == out->opts->trace) {
+	oj_trace("as_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
+    }
+
+    out->argc = 0;
+    if (ja == obj || !as_ok) {
+	// Once as_json is called it should never be called again on the same
+	// object with as_ok.
+	dump_rails_val(ja, depth, out, false);
+    } else {
+	int	type = rb_type(ja);
+
+	if (T_HASH == type || T_ARRAY == type) {
+	    dump_rails_val(ja, depth, out, true);
+	} else {
+	    dump_rails_val(ja, depth, out, true);
+	}
+    }
+}
+
+static void
+dump_regexp(VALUE obj, int depth, Out out, bool as_ok) {
+    if (as_ok && rb_respond_to(obj, oj_as_json_id)) {
+	dump_as_json(obj, depth, out, false);
+	return;
+    }
+    dump_as_string(obj, depth, out, as_ok);
+}
+
+static struct _namedFunc	dump_map[] = {
+    { "ActionController::Parameters", dump_actioncontroller_parameters },
+    { "ActiveRecord::Result", dump_activerecord_result },
+    { "ActiveSupport::TimeWithZone", dump_timewithzone },
+    { "BigDecimal", dump_bigdecimal },
+    { "Range", dump_to_s },
+    { "Regexp", dump_regexp },
+    //{ "Regexp", dump_to_s },
+    { "Time", dump_time },
+    { NULL, NULL },
+};
+
+static VALUE	activerecord_base = Qundef;
+static ID	attributes_id = 0;
+
+static void
+dump_activerecord(VALUE obj, int depth, Out out, bool as_ok) {
+    if (0 == attributes_id) {
+	attributes_id = rb_intern("@attributes");
+    }
+    out->argc = 0;
+    dump_rails_val(rb_ivar_get(obj, attributes_id), depth, out, true);
+}
+
+static ROpt
+create_opt(ROptTable rot, VALUE clas) {
+    ROpt	ro;
+    NamedFunc	nf;
+    const char	*classname = rb_class2name(clas);
+    int		olen = rot->len;
+
+    rot->len++;
+    if (NULL == rot->table) {
+	rot->alen = 256;
+	rot->table = ALLOC_N(struct _rOpt, rot->alen);
+	memset(rot->table, 0, sizeof(struct _rOpt) * rot->alen);
+    } else if (rot->alen <= rot->len) {
+	rot->alen *= 2;
+	REALLOC_N(rot->table, struct _rOpt, rot->alen);
+	memset(rot->table + olen, 0, sizeof(struct _rOpt) * olen);
+    }
+    if (0 == olen) {
+	ro = rot->table;
+    } else if (rot->table[olen - 1].clas < clas) {
+	ro = &rot->table[olen];
+    } else {
+	int	i;
+
+	for (i = 0, ro = rot->table; i < olen; i++, ro++) {
+	    if (clas < ro->clas) {
+		memmove(ro + 1, ro, sizeof(struct _rOpt) * (olen - i));
+		break;
+	    }
+	}
+    }
+    ro->clas = clas;
+    ro->on = true;
+    ro->dump = dump_obj_attrs;
+    for (nf = dump_map; NULL != nf->name; nf++) {
+	if (0 == strcmp(nf->name, classname)) {
+	    ro->dump = nf->func;
+	    break;
+	}
+    }
+    if (ro->dump == dump_obj_attrs) {
+	if (Qundef == activerecord_base) {
+	    // If not defined let an exception be raised.
+	    VALUE	ar = rb_const_get_at(rb_cObject, rb_intern("ActiveRecord"));
+
+	    if (Qundef != ar) {
+		activerecord_base = rb_const_get_at(ar, rb_intern("Base"));
+	    }
+	}
+	if (Qundef != activerecord_base && Qtrue == rb_class_inherited_p(clas, activerecord_base)) {
+	    ro->dump = dump_activerecord;
+	} else if (Qtrue == rb_class_inherited_p(clas, rb_cStruct)) { // check before enumerable
+	    ro->dump = dump_struct;
+	} else if (Qtrue == rb_class_inherited_p(clas, rb_mEnumerable)) {
+	    ro->dump = dump_enumerable;
+	} else if (Qtrue == rb_class_inherited_p(clas, rb_eException)) {
+	    ro->dump = dump_to_s;
+	}
+    }
+    return ro;
+}
+
+static void
+encoder_free(void *ptr) {
+    if (NULL != ptr) {
+	Encoder	e = (Encoder)ptr;
+
+	if (NULL != e->ropts.table) {
+	    xfree(e->ropts.table);
+	}
+	xfree(ptr);
+    }
+}
+
+static void
+encoder_mark(void *ptr) {
+    if (NULL != ptr) {
+	Encoder	e = (Encoder)ptr;
+
+	if (Qnil != e->arg) {
+	    rb_gc_mark(e->arg);
+	}
+    }
+}
+
+/* Document-method: new
+ *	call-seq: new(options=nil)
+ *
+ * Creates a new Encoder.
+ * - *options* [_Hash_] formatting options
+ */
+static VALUE
+encoder_new(int argc, VALUE *argv, VALUE self) {
+    Encoder	e = ALLOC(struct _encoder);
+
+    e->opts = oj_default_options;
+    e->arg = Qnil;
+    copy_opts(&ropts, &e->ropts);
+
+    if (1 <= argc && Qnil != *argv) {
+	oj_parse_options(*argv, &e->opts);
+	e->arg = *argv;
+    }
+    return Data_Wrap_Struct(encoder_class, encoder_mark, encoder_free, e);
+}
+
+static VALUE
+resolve_classpath(const char *name) {
+    char	class_name[1024];
+    VALUE	clas;
+    char	*end = class_name + sizeof(class_name) - 1;
+    char	*s;
+    const char	*n = name;
+    ID		cid;
+
+    clas = rb_cObject;
+    for (s = class_name; '\0' != *n; n++) {
+	if (':' == *n) {
+	    *s = '\0';
+	    n++;
+	    if (':' != *n) {
+		return Qnil;
+	    }
+	    cid = rb_intern(class_name);
+	    if (!rb_const_defined_at(clas, cid)) {
+		return Qnil;
+	    }
+	    clas = rb_const_get_at(clas, cid);
+	    s = class_name;
+	} else if (end <= s) {
+	    return Qnil;
+	} else {
+	    *s++ = *n;
+	}
+    }
+    *s = '\0';
+    cid = rb_intern(class_name);
+    if (!rb_const_defined_at(clas, cid)) {
+	return Qnil;
+    }
+    clas = rb_const_get_at(clas, cid);
+
+    return clas;
+}
+
+static void
+optimize(int argc, VALUE *argv, ROptTable rot, bool on) {
+    ROpt	ro;
+
+    if (0 == argc) {
+	int		i;
+	NamedFunc	nf;
+	VALUE		clas;
+
+	oj_rails_hash_opt = on;
+	oj_rails_array_opt = on;
+	oj_rails_float_opt = on;
+
+	for (nf = dump_map; NULL != nf->name; nf++) {
+	    if (Qnil != (clas = resolve_classpath(nf->name))) {
+		if (NULL == oj_rails_get_opt(rot, clas)) {
+		    create_opt(rot, clas);
+		}
+	    }
+	}
+	for (i = 0; i < rot->len; i++) {
+	    rot->table[i].on = on;
+	}
+    }
+    for (; 0 < argc; argc--, argv++) {
+	if (rb_cHash == *argv) {
+	    oj_rails_hash_opt = on;
+	} else if (rb_cArray == *argv) {
+	    oj_rails_array_opt = on;
+	} else if (rb_cFloat == *argv) {
+	    oj_rails_float_opt = on;
+	} else if (NULL != (ro = oj_rails_get_opt(rot, *argv)) ||
+		   NULL != (ro = create_opt(rot, *argv))) {
+	    ro->on = on;
+	}
+    }
+}
+
+/* Document-method optimize
+ *	call-seq: optimize(*classes)
+ *
+ * Use Oj rails optimized routines to encode the specified classes. This
+ * ignores the as_json() method on the class and uses an internal encoding
+ * instead. Passing in no classes indicates all should use the optimized
+ * version of encoding for all previously optimized classes. Passing in the
+ * Object class set a global switch that will then use the optimized behavior
+ * for all classes.
+ *
+ * - *classes* [_Class_] a list of classes to optimize
+ */
+static VALUE
+encoder_optimize(int argc, VALUE *argv, VALUE self) {
+    Encoder	e = (Encoder)DATA_PTR(self);
+
+    optimize(argc, argv, &e->ropts, true);
+
+    return Qnil;
+}
+
+/* Document-method: optimize
+ *	call-seq: optimize(*classes)
+ *
+ * Use Oj rails optimized routines to encode the specified classes. This
+ * ignores the as_json() method on the class and uses an internal encoding
+ * instead. Passing in no classes indicates all should use the optimized
+ * version of encoding for all previously optimized classes. Passing in the
+ * Object class set a global switch that will then use the optimized behavior
+ * for all classes.
+ *
+ * - *classes* [_Class_] a list of classes to optimize
+ */
+static VALUE
+rails_optimize(int argc, VALUE *argv, VALUE self) {
+    optimize(argc, argv, &ropts, true);
+
+    return Qnil;
+}
+
+/* Document-module: mimic_JSON
+ *	call-seq: mimic_JSON()
+ *
+ * Sets the JSON method to use Oj similar to Oj.mimic_JSON except with the
+ * ActiveSupport monkey patches instead of the json gem monkey patches.
+ */
+VALUE
+rails_mimic_json(VALUE self) {
+    VALUE	json;
+
+    if (rb_const_defined_at(rb_cObject, rb_intern("JSON"))) {
+	json = rb_const_get_at(rb_cObject, rb_intern("JSON"));
+    } else {
+	json = rb_define_module("JSON");
+    }
+    oj_mimic_json_methods(json);
+    //oj_default_options.mode = RailsMode;
+
+    return Qnil;
+}
+
+/* Document-method: deoptimize
+ *	call-seq: deoptimize(*classes)
+ *
+ * Turn off Oj rails optimization on the specified classes.
+ *
+ * - *classes* [_Class_] a list of classes to deoptimize
+ */
+static VALUE
+encoder_deoptimize(int argc, VALUE *argv, VALUE self) {
+    Encoder	e = (Encoder)DATA_PTR(self);
+
+    optimize(argc, argv, &e->ropts, false);
+
+    return Qnil;
+}
+
+/* Document-method: deoptimize
+ *	call-seq: deoptimize(*classes)
+ *
+ * Turn off Oj rails optimization on the specified classes.
+ *
+ * - *classes* [_Class_] a list of classes to deoptimize
+ */
+static VALUE
+rails_deoptimize(int argc, VALUE *argv, VALUE self) {
+    optimize(argc, argv, &ropts, false);
+
+    return Qnil;
+}
+
+/* Document-method:optimized?
+ *	call-seq: optimized?(clas)
+ *
+ * - *clas* [_Class_] Class to check
+ *
+ * @return true if the class is being optimized for rails and false otherwise
+ */
+static VALUE
+encoder_optimized(VALUE self, VALUE clas) {
+    Encoder	e = (Encoder)DATA_PTR(self);
+    ROpt	ro = oj_rails_get_opt(&e->ropts, clas);
+
+    if (NULL == ro) {
+	return Qfalse;
+    }
+    return (ro->on) ? Qtrue : Qfalse;
+}
+
+/* Document-method: optimized?
+ *	call-seq: optimized?(clas)
+ *
+ * Returns true if the specified Class is being optimized.
+ */
+static VALUE
+rails_optimized(VALUE self, VALUE clas) {
+    ROpt	ro = oj_rails_get_opt(&ropts, clas);
+
+    if (NULL == ro) {
+	return Qfalse;
+    }
+    return (ro->on) ? Qtrue : Qfalse;
+}
+
+typedef struct _oo {
+    Out		out;
+    VALUE	obj;
+} *OO;
+
+static VALUE
+protect_dump(VALUE ov) {
+    OO	oo = (OO)ov;
+
+    dump_rails_val(oo->obj, 0, oo->out, true);
+
+    return Qnil;
+}
+
+static VALUE
+encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *argv) {
+    char		buf[4096];
+    struct _out		out;
+    struct _options	copts = *opts;
+    volatile VALUE	rstr = Qnil;
+    struct _oo		oo;
+    int			line = 0;
+
+    oo.out = &out;
+    oo.obj = obj;
+    copts.str_rx.head = NULL;
+    copts.str_rx.tail = NULL;
+    copts.mode = RailsMode;
+    if (escape_html) {
+	copts.escape_mode = RailsXEsc;
+    } else {
+	copts.escape_mode = RailsEsc;
+    }
+    out.buf = buf;
+    out.end = buf + sizeof(buf) - 10;
+    out.allocated = false;
+    out.omit_nil = copts.dump_opts.omit_nil;
+    out.caller = 0;
+    out.cur = out.buf;
+    out.circ_cnt = 0;
+    out.opts = &copts;
+    out.hash_cnt = 0;
+    out.indent = copts.indent;
+    out.argc = argc;
+    out.argv = argv;
+    out.ropts = ropts;
+    if (Yes == copts.circular) {
+	oj_cache8_new(&out.circ_cache);
+    }
+    //dump_rails_val(*argv, 0, &out, true);
+    rb_protect(protect_dump, (VALUE)&oo, &line);
+
+    if (0 == line) {
+	if (0 < out.indent) {
+	    switch (*(out.cur - 1)) {
+	    case ']':
+	    case '}':
+		assure_size(&out, 2);
+		*out.cur++ = '\n';
+	    default:
+		break;
+	    }
+	}
+	*out.cur = '\0';
+
+	if (0 == out.buf) {
+	    rb_raise(rb_eNoMemError, "Not enough memory.");
+	}
+	rstr = rb_str_new2(out.buf);
+	rstr = oj_encode(rstr);
+    }
+    if (Yes == copts.circular) {
+	oj_cache8_delete(out.circ_cache);
+    }
+    if (out.allocated) {
+	xfree(out.buf);
+    }
+    if (0 != line) {
+	rb_jump_tag(line);
+    }
+    return rstr;
+}
+
+/* Document-method: encode
+ *	call-seq: encode(obj)
+ *
+ * - *obj* [_Object_] object to encode
+ *
+ * Returns encoded object as a JSON string.
+ */
+static VALUE
+encoder_encode(VALUE self, VALUE obj) {
+    Encoder	e = (Encoder)DATA_PTR(self);
+
+    if (Qnil != e->arg) {
+	VALUE	argv[1] = { e->arg };
+
+	return encode(obj, &e->ropts, &e->opts, 1, argv);
+    }
+    return encode(obj, &e->ropts, &e->opts, 0, NULL);
+}
+
+/* Document-method: encode
+ *	call-seq: encode(obj, opts=nil)
+ *
+ * Encode obj as a JSON String.
+ *
+ * - *obj* [_Object_|Hash|Array] object to convert to a JSON String
+ * - *opts* [_Hash_] options
+ *
+ * Returns [_String_]
+ */
+static VALUE
+rails_encode(int argc, VALUE *argv, VALUE self) {
+    if (1 > argc) {
+	rb_raise(rb_eArgError, "wrong number of arguments (0 for 1).");
+    }
+    if (1 == argc) {
+	return encode(*argv, NULL, &oj_default_options, 0, NULL);
+    } else {
+	return encode(*argv, NULL, &oj_default_options, argc - 1, argv + 1);
+    }
+}
+
+static VALUE
+rails_use_standard_json_time_format(VALUE self, VALUE state) {
+    if (Qtrue == state || Qfalse == state) {
+    } else if (Qnil == state) {
+	state = Qfalse;
+    } else {
+	state = Qtrue;
+    }
+    rb_iv_set(self, "@use_standard_json_time_format", state);
+    xml_time = Qtrue == state;
+
+    return state;
+}
+
+static VALUE
+rails_escape_html_entities_in_json(VALUE self, VALUE state) {
+    rb_iv_set(self, "@escape_html_entities_in_json", state);
+    escape_html = Qtrue == state;
+
+    return state;
+}
+
+static VALUE
+rails_time_precision(VALUE self, VALUE prec) {
+    rb_iv_set(self, "@time_precision", prec);
+    oj_default_options.sec_prec = NUM2INT(prec);
+
+    return prec;
+}
+
+/* Document-method: set_encoder
+ *	call-seq: set_encoder()
+ *
+ * Sets the ActiveSupport.encoder to Oj::Rails::Encoder and wraps some of the
+ * formatting globals used by ActiveSupport to allow the use of those globals
+ * in the Oj::Rails optimizations.
+ */
+static VALUE
+rails_set_encoder(VALUE self) {
+    VALUE	active;
+    VALUE	json;
+    VALUE	encoding;
+    VALUE	pv;
+    VALUE	verbose;
+
+    if (rb_const_defined_at(rb_cObject, rb_intern("ActiveSupport"))) {
+	active = rb_const_get_at(rb_cObject, rb_intern("ActiveSupport"));
+    } else {
+	rb_raise(rb_eStandardError, "ActiveSupport not loaded.");
+    }
+    rb_funcall(active, rb_intern("json_encoder="), 1, encoder_class);
+
+    json = rb_const_get_at(active, rb_intern("JSON"));
+    encoding = rb_const_get_at(json, rb_intern("Encoding"));
+
+    // 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(encoding, "use_standard_json_time_format=");
+    rb_define_module_function(encoding, "use_standard_json_time_format=", rails_use_standard_json_time_format, 1);
+
+    rb_undef_method(encoding, "escape_html_entities_in_json=");
+    rb_define_module_function(encoding, "escape_html_entities_in_json=", rails_escape_html_entities_in_json, 1);
+
+    pv = rb_iv_get(encoding, "@time_precision");
+    oj_default_options.sec_prec = NUM2INT(pv);
+    rb_undef_method(encoding, "time_precision=");
+    rb_define_module_function(encoding, "time_precision=", rails_time_precision, 1);
+    rb_gv_set("$VERBOSE", verbose);
+
+    return Qnil;
+}
+
+/* Document-method: set_decoder
+ *	call-seq: set_decoder()
+ *
+ * Sets the JSON.parse function to be the Oj::parse function which is json gem
+ * compatible.
+ */
+static VALUE
+rails_set_decoder(VALUE self) {
+    VALUE	json;
+    VALUE	json_error;
+    VALUE	verbose;
+
+    if (rb_const_defined_at(rb_cObject, rb_intern("JSON"))) {
+	json = rb_const_get_at(rb_cObject, rb_intern("JSON"));
+    } else {
+	json = rb_define_module("JSON");
+    }
+    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);
+    }
+    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);
+    }
+    // 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, "parse");
+    rb_define_module_function(json, "parse", oj_mimic_parse, -1);
+    rb_gv_set("$VERBOSE", verbose);
+
+    return Qnil;
+}
+
+/* Document-module: Oj.optimize_rails()
+ *
+ * Sets the Oj as the Rails encoder and decoder. Oj::Rails.optimize is also
+ * called.
+ */
+VALUE
+oj_optimize_rails(VALUE self) {
+    rails_set_encoder(self);
+    rails_set_decoder(self);
+    rails_optimize(0, NULL, self);
+    rails_mimic_json(self);
+
+    return Qnil;
+}
+
+/* Document-module: Oj::Rails
+ *
+ * Module that provides rails and active support compatibility.
+ */
+/* Document-class: Oj::Rails::Encoder
+ *
+ * The Oj ActiveSupport compliant encoder.
+ */
+void
+oj_mimic_rails_init() {
+    VALUE	rails = rb_define_module_under(Oj, "Rails");
+
+    rb_define_module_function(rails, "encode", rails_encode, -1);
+
+    encoder_class = rb_define_class_under(rails, "Encoder", rb_cObject);
+    rb_define_module_function(encoder_class, "new", encoder_new, -1);
+    rb_define_module_function(rails, "optimize", rails_optimize, -1);
+    rb_define_module_function(rails, "deoptimize", rails_deoptimize, -1);
+    rb_define_module_function(rails, "optimized?", rails_optimized, 1);
+    rb_define_module_function(rails, "mimic_JSON", rails_mimic_json, 0);
+
+    rb_define_module_function(rails, "set_encoder", rails_set_encoder, 0);
+    rb_define_module_function(rails, "set_decoder", rails_set_decoder, 0);
+
+    rb_define_method(encoder_class, "encode", encoder_encode, 1);
+    rb_define_method(encoder_class, "optimize", encoder_optimize, -1);
+    rb_define_method(encoder_class, "deoptimize", encoder_deoptimize, -1);
+    rb_define_method(encoder_class, "optimized?", encoder_optimized, 1);
+}
+
+static void
+dump_to_hash(VALUE obj, int depth, Out out) {
+    dump_rails_val(rb_funcall(obj, oj_to_hash_id, 0), depth, out, true);
+}
+
+static void
+dump_float(VALUE obj, int depth, Out out, bool as_ok) {
+    char	buf[64];
+    char	*b;
+    double	d = rb_num2dbl(obj);
+    int		cnt = 0;
+
+    if (0.0 == d) {
+	b = buf;
+	*b++ = '0';
+	*b++ = '.';
+	*b++ = '0';
+	*b++ = '\0';
+	cnt = 3;
+    } else {
+	if (isnan(d) || OJ_INFINITY == d || -OJ_INFINITY == d) {
+	    strcpy(buf, "null");
+	    cnt = 4;
+	} else if (d == (double)(long long int)d) {
+	    cnt = snprintf(buf, sizeof(buf), "%.1f", d);
+	} else if (oj_rails_float_opt) {
+	    cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, "%0.16g");
+	} else {
+	    volatile VALUE	rstr = rb_funcall(obj, oj_to_s_id, 0);
+
+	    strcpy(buf, rb_string_value_ptr((VALUE*)&rstr));
+	    cnt = (int)RSTRING_LEN(rstr);
+	}
+    }
+    assure_size(out, cnt);
+    for (b = buf; '\0' != *b; b++) {
+	*out->cur++ = *b;
+    }
+    *out->cur = '\0';
+}
+
+static void
+dump_array(VALUE a, int depth, Out out, bool as_ok) {
+    size_t	size;
+    int		i, cnt;
+    int		d2 = depth + 1;
+
+    if (Yes == out->opts->circular) {
+	if (0 > oj_check_circular(a, out)) {
+	    oj_dump_nil(Qnil, 0, out, false);
+	    return;
+	}
+    }
+    //if (!oj_rails_array_opt && as_ok && 0 < out->argc && rb_respond_to(a, oj_as_json_id)) {
+    if (as_ok && 0 < out->argc && rb_respond_to(a, oj_as_json_id)) {
+	dump_as_json(a, depth, out, false);
+	return;
+    }
+    cnt = (int)RARRAY_LEN(a);
+    *out->cur++ = '[';
+    size = 2;
+    assure_size(out, size);
+    if (0 == cnt) {
+	*out->cur++ = ']';
+    } else {
+	if (out->opts->dump_opts.use) {
+	    size = d2 * out->opts->dump_opts.indent_size + out->opts->dump_opts.array_size + 1;
+	} else {
+	    size = d2 * out->indent + 2;
+	}
+	cnt--;
+	for (i = 0; i <= cnt; i++) {
+	    assure_size(out, size);
+	    if (out->opts->dump_opts.use) {
+		if (0 < out->opts->dump_opts.array_size) {
+		    strcpy(out->cur, out->opts->dump_opts.array_nl);
+		    out->cur += out->opts->dump_opts.array_size;
+		}
+		if (0 < out->opts->dump_opts.indent_size) {
+		    int	i;
+		    for (i = d2; 0 < i; i--) {
+			strcpy(out->cur, out->opts->dump_opts.indent_str);
+			out->cur += out->opts->dump_opts.indent_size;
+		    }
+		}
+	    } else {
+		fill_indent(out, d2);
+	    }
+	    dump_rails_val(rb_ary_entry(a, i), d2, out, true);
+	    if (i < cnt) {
+		*out->cur++ = ',';
+	    }
+	}
+	size = depth * out->indent + 1;
+	assure_size(out, size);
+	if (out->opts->dump_opts.use) {
+	    if (0 < out->opts->dump_opts.array_size) {
+		strcpy(out->cur, out->opts->dump_opts.array_nl);
+		out->cur += out->opts->dump_opts.array_size;
+	    }
+	    if (0 < out->opts->dump_opts.indent_size) {
+		int	i;
+
+		for (i = depth; 0 < i; i--) {
+		    strcpy(out->cur, out->opts->dump_opts.indent_str);
+		    out->cur += out->opts->dump_opts.indent_size;
+		}
+	    }
+	} else {
+	    fill_indent(out, depth);
+	}
+	*out->cur++ = ']';
+    }
+    *out->cur = '\0';
+}
+
+static int
+hash_cb(VALUE key, VALUE value, Out out) {
+    int		depth = out->depth;
+    long	size;
+    int		rtype = rb_type(key);
+
+    if (out->omit_nil && Qnil == value) {
+	return ST_CONTINUE;
+    }
+    if (rtype != T_STRING && rtype != T_SYMBOL) {
+	key = rb_funcall(key, oj_to_s_id, 0);
+	rtype = rb_type(key);
+    }
+    if (!out->opts->dump_opts.use) {
+	size = depth * out->indent + 1;
+	assure_size(out, size);
+	fill_indent(out, depth);
+	if (rtype == T_STRING) {
+	    oj_dump_str(key, 0, out, false);
+	} else {
+	    oj_dump_sym(key, 0, out, false);
+	}
+	*out->cur++ = ':';
+    } else {
+	size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
+	assure_size(out, size);
+	if (0 < out->opts->dump_opts.hash_size) {
+	    strcpy(out->cur, out->opts->dump_opts.hash_nl);
+	    out->cur += out->opts->dump_opts.hash_size;
+	}
+	if (0 < out->opts->dump_opts.indent_size) {
+	    int	i;
+	    for (i = depth; 0 < i; i--) {
+		strcpy(out->cur, out->opts->dump_opts.indent_str);
+		out->cur += out->opts->dump_opts.indent_size;
+	    }
+	}
+	if (rtype == T_STRING) {
+	    oj_dump_str(key, 0, out, false);
+	} else {
+	    oj_dump_sym(key, 0, out, false);
+	}
+	size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+	assure_size(out, size);
+	if (0 < out->opts->dump_opts.before_size) {
+	    strcpy(out->cur, out->opts->dump_opts.before_sep);
+	    out->cur += out->opts->dump_opts.before_size;
+	}
+	*out->cur++ = ':';
+	if (0 < out->opts->dump_opts.after_size) {
+	    strcpy(out->cur, out->opts->dump_opts.after_sep);
+	    out->cur += out->opts->dump_opts.after_size;
+	}
+    }
+    dump_rails_val(value, depth, out, true);
+    out->depth = depth;
+    *out->cur++ = ',';
+
+    return ST_CONTINUE;
+}
+
+static void
+dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
+    int		cnt;
+    size_t	size;
+
+    if (Yes == out->opts->circular) {
+	if (0 > oj_check_circular(obj, out)) {
+	    oj_dump_nil(Qnil, 0, out, false);
+	    return;
+	}
+    }
+    if ((!oj_rails_hash_opt || 0 < out->argc) && as_ok && rb_respond_to(obj, oj_as_json_id)) {
+	dump_as_json(obj, depth, out, false);
+	return;
+    }
+    cnt = (int)RHASH_SIZE(obj);
+    size = depth * out->indent + 2;
+    assure_size(out, 2);
+    *out->cur++ = '{';
+    if (0 == cnt) {
+	*out->cur++ = '}';
+    } else {
+	out->depth = depth + 1;
+	rb_hash_foreach(obj, hash_cb, (VALUE)out);
+	if (',' == *(out->cur - 1)) {
+	    out->cur--; // backup to overwrite last comma
+	}
+	if (!out->opts->dump_opts.use) {
+	    assure_size(out, size);
+	    fill_indent(out, depth);
+	} else {
+	    size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
+	    assure_size(out, size);
+	    if (0 < out->opts->dump_opts.hash_size) {
+		strcpy(out->cur, out->opts->dump_opts.hash_nl);
+		out->cur += out->opts->dump_opts.hash_size;
+	    }
+	    if (0 < out->opts->dump_opts.indent_size) {
+		int	i;
+
+		for (i = depth; 0 < i; i--) {
+		    strcpy(out->cur, out->opts->dump_opts.indent_str);
+		    out->cur += out->opts->dump_opts.indent_size;
+		}
+	    }
+	}
+	*out->cur++ = '}';
+    }
+    *out->cur = '\0';
+}
+
+static void
+dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
+    if (oj_code_dump(oj_compat_codes, obj, depth, out)) {
+	out->argc = 0;
+	return;
+    }
+    if (as_ok) {
+	ROpt	ro;
+
+	if (NULL != (ro = oj_rails_get_opt(out->ropts, rb_obj_class(obj))) && ro->on) {
+	    ro->dump(obj, depth, out, as_ok);
+	} else if (rb_respond_to(obj, oj_as_json_id)) {
+	    dump_as_json(obj, depth, out, true);
+	} else if (rb_respond_to(obj, oj_to_hash_id)) {
+	    dump_to_hash(obj, depth, out);
+	} else {
+	    oj_dump_obj_to_s(obj, out);
+	}
+    } else if (rb_respond_to(obj, oj_to_hash_id)) {
+	// Always attempt to_hash.
+	dump_to_hash(obj, depth, out);
+    } else {
+	oj_dump_obj_to_s(obj, out);
+    }
+}
+
+static DumpFunc	rails_funcs[] = {
+    NULL,	 	// RUBY_T_NONE     = 0x00,
+    dump_obj,		// RUBY_T_OBJECT   = 0x01,
+    oj_dump_class, 	// RUBY_T_CLASS    = 0x02,
+    oj_dump_class,	// RUBY_T_MODULE   = 0x03,
+    dump_float, 	// RUBY_T_FLOAT    = 0x04,
+    oj_dump_str, 	// RUBY_T_STRING   = 0x05,
+    dump_regexp,	// RUBY_T_REGEXP   = 0x06,
+    //dump_as_string,	// RUBY_T_REGEXP   = 0x06,
+    dump_array,		// RUBY_T_ARRAY    = 0x07,
+    dump_hash,	 	// RUBY_T_HASH     = 0x08,
+    dump_obj,		// RUBY_T_STRUCT   = 0x09,
+    oj_dump_bignum,	// RUBY_T_BIGNUM   = 0x0a,
+    NULL, 		// RUBY_T_FILE     = 0x0b,
+    dump_obj,		// RUBY_T_DATA     = 0x0c,
+    NULL, 		// RUBY_T_MATCH    = 0x0d,
+    // Rails raises a stack error on Complex and Rational. It also corrupts
+    // something which causes a segfault on the next call. Oj will not mimic
+    // that behavior.
+    dump_as_string, 	// RUBY_T_COMPLEX  = 0x0e,
+    dump_as_string, 	// RUBY_T_RATIONAL = 0x0f,
+    NULL, 		// 0x10
+    oj_dump_nil, 	// RUBY_T_NIL      = 0x11,
+    oj_dump_true, 	// RUBY_T_TRUE     = 0x12,
+    oj_dump_false,	// RUBY_T_FALSE    = 0x13,
+    oj_dump_sym,	// RUBY_T_SYMBOL   = 0x14,
+    oj_dump_fixnum,	// RUBY_T_FIXNUM   = 0x15,
+};
+
+static void
+dump_rails_val(VALUE obj, int depth, Out out, bool as_ok) {
+    int	type = rb_type(obj);
+
+    if (Yes == out->opts->trace) {
+	oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceIn);
+    }
+    if (MAX_DEPTH < depth) {
+	rb_raise(rb_eNoMemError, "Too deeply nested.\n");
+    }
+    if (0 < type && type <= RUBY_T_FIXNUM) {
+	DumpFunc	f = rails_funcs[type];
+
+	if (NULL != f) {
+	    f(obj, depth, out, as_ok);
+	    if (Yes == out->opts->trace) {
+		oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
+	    }
+	    return;
+	}
+    }
+    oj_dump_nil(Qnil, depth, out, false);
+    if (Yes == out->opts->trace) {
+	oj_trace("dump", Qnil, __FILE__, __LINE__, depth, TraceOut);
+    }
+}
+
+void
+oj_dump_rails_val(VALUE obj, int depth, Out out) {
+    out->opts->str_rx.head = NULL;
+    out->opts->str_rx.tail = NULL;
+    if (escape_html) {
+	out->opts->escape_mode = RailsXEsc;
+    } else {
+	out->opts->escape_mode = RailsEsc;
+    }
+    dump_rails_val(obj, depth, out, true);
+}