oj 3.16.6 → 3.17.3

data/ext/oj/parser.c

@@ -75,7 +75,7 @@ enum {
 
 /*
 0123456789abcdef0123456789abcdef */
-static const char value_map[257] = "\
+static const char value_map[258] = "\
 X........ab..a..................\
 a.i..........f..ghhhhhhhhh......\
 ...........................k.m..\
@@ -85,7 +85,7 @@ a.i..........f..ghhhhhhhhh......\
 ................................\
 ................................v";
 
-static const char null_map[257] = "\
+static const char null_map[258] = "\
 ................................\
 ............o...................\
 ................................\
@@ -95,7 +95,7 @@ static const char null_map[257] = "\
 ................................\
 ................................N";
 
-static const char true_map[257] = "\
+static const char true_map[258] = "\
 ................................\
 ............o...................\
 ................................\
@@ -105,7 +105,7 @@ static const char true_map[257] = "\
 ................................\
 ................................T";
 
-static const char false_map[257] = "\
+static const char false_map[258] = "\
 ................................\
 ............o...................\
 ................................\
@@ -115,7 +115,7 @@ static const char false_map[257] = "\
 ................................\
 ................................F";
 
-static const char comma_map[257] = "\
+static const char comma_map[258] = "\
 .........ab..a..................\
 a.i..........f..ghhhhhhhhh......\
 ...........................k....\
@@ -125,7 +125,7 @@ a.i..........f..ghhhhhhhhh......\
 ................................\
 ................................,";
 
-static const char after_map[257] = "\
+static const char after_map[258] = "\
 X........ab..a..................\
 a...........o...................\
 .............................m..\
@@ -135,7 +135,7 @@ a...........o...................\
 ................................\
 ................................a";
 
-static const char key1_map[257] = "\
+static const char key1_map[258] = "\
 .........ab..a..................\
 a.p.............................\
 ................................\
@@ -145,7 +145,7 @@ a.p.............................\
 ................................\
 ................................K";
 
-static const char key_map[257] = "\
+static const char key_map[258] = "\
 .........ab..a..................\
 a.p.............................\
 ................................\
@@ -155,7 +155,7 @@ a.p.............................\
 ................................\
 ................................k";
 
-static const char colon_map[257] = "\
+static const char colon_map[258] = "\
 .........ab..a..................\
 a.........................q.....\
 ................................\
@@ -165,7 +165,7 @@ a.........................q.....\
 ................................\
 ................................:";
 
-static const char neg_map[257] = "\
+static const char neg_map[258] = "\
 ................................\
 ................O---------......\
 ................................\
@@ -175,7 +175,7 @@ static const char neg_map[257] = "\
 ................................\
 ................................-";
 
-static const char zero_map[257] = "\
+static const char zero_map[258] = "\
 .........rs..r..................\
 r...........u.t.................\
 .............................H..\
@@ -185,7 +185,7 @@ r...........u.t.................\
 ................................\
 ................................0";
 
-static const char digit_map[257] = "\
+static const char digit_map[258] = "\
 .........rs..r..................\
 r...........u.t.NNNNNNNNNN......\
 .....w.......................H..\
@@ -195,7 +195,7 @@ r...........u.t.NNNNNNNNNN......\
 ................................\
 ................................d";
 
-static const char dot_map[257] = "\
+static const char dot_map[258] = "\
 ................................\
 ................vvvvvvvvvv......\
 ................................\
@@ -205,7 +205,7 @@ static const char dot_map[257] = "\
 ................................\
 .................................";
 
-static const char frac_map[257] = "\
+static const char frac_map[258] = "\
 .........rs..r..................\
 r...........u...vvvvvvvvvv......\
 .....w.......................H..\
@@ -215,7 +215,7 @@ r...........u...vvvvvvvvvv......\
 ................................\
 ................................f";
 
-static const char exp_sign_map[257] = "\
+static const char exp_sign_map[258] = "\
 ................................\
 ...........x.x..yyyyyyyyyy......\
 ................................\
@@ -225,7 +225,7 @@ static const char exp_sign_map[257] = "\
 ................................\
 ................................x";
 
-static const char exp_zero_map[257] = "\
+static const char exp_zero_map[258] = "\
 ................................\
 ................yyyyyyyyyy......\
 ................................\
@@ -235,7 +235,7 @@ static const char exp_zero_map[257] = "\
 ................................\
 ................................z";
 
-static const char exp_map[257] = "\
+static const char exp_map[258] = "\
 .........rs..r..................\
 r...........u...yyyyyyyyyy......\
 .............................H..\
@@ -245,7 +245,7 @@ r...........u...yyyyyyyyyy......\
 ................................\
 ................................X";
 
-static const char big_digit_map[257] = "\
+static const char big_digit_map[258] = "\
 .........rs..r..................\
 r...........u.D.CCCCCCCCCC......\
 .....J.......................H..\
@@ -255,7 +255,7 @@ r...........u.D.CCCCCCCCCC......\
 ................................\
 ................................D";
 
-static const char big_dot_map[257] = "\
+static const char big_dot_map[258] = "\
 ................................\
 ................IIIIIIIIII......\
 ................................\
@@ -265,7 +265,7 @@ static const char big_dot_map[257] = "\
 ................................\
 ................................o";
 
-static const char big_frac_map[257] = "\
+static const char big_frac_map[258] = "\
 .........rs..r..................\
 r...........u...IIIIIIIIII......\
 .....J.......................H..\
@@ -275,7 +275,7 @@ r...........u...IIIIIIIIII......\
 ................................\
 ................................g";
 
-static const char big_exp_sign_map[257] = "\
+static const char big_exp_sign_map[258] = "\
 ................................\
 ...........K.K..LLLLLLLLLL......\
 ................................\
@@ -285,7 +285,7 @@ static const char big_exp_sign_map[257] = "\
 ................................\
 ................................B";
 
-static const char big_exp_zero_map[257] = "\
+static const char big_exp_zero_map[258] = "\
 ................................\
 ................LLLLLLLLLL......\
 ................................\
@@ -295,7 +295,7 @@ static const char big_exp_zero_map[257] = "\
 ................................\
 ................................Z";
 
-static const char big_exp_map[257] = "\
+static const char big_exp_map[258] = "\
 .........rs..r..................\
 r...........u...LLLLLLLLLL......\
 .............................H..\
@@ -305,7 +305,7 @@ r...........u...LLLLLLLLLL......\
 ................................\
 ................................Y";
 
-static const char string_map[257] = "\
+static const char string_map[258] = "\
 ................................\
 RRzRRRRRRRRRRRRRRRRRRRRRRRRRRRRR\
 RRRRRRRRRRRRRRRRRRRRRRRRRRRRARRR\
@@ -315,7 +315,7 @@ RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR\
 MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM\
 PPPPPPPPPPPPPPPPQQQQQQQQ........s";
 
-static const char esc_map[257] = "\
+static const char esc_map[258] = "\
 ................................\
 ..B............B................\
 ............................B...\
@@ -325,7 +325,7 @@ static const char esc_map[257] = "\
 ................................\
 ................................~";
 
-static const char esc_byte_map[257] = "\
+static const char esc_byte_map[258] = "\
 ................................\
 ..\"............/................\
 ............................\\...\
@@ -335,7 +335,7 @@ static const char esc_byte_map[257] = "\
 ................................\
 ................................b";
 
-static const char u_map[257] = "\
+static const char u_map[258] = "\
 ................................\
 ................EEEEEEEEEE......\
 .EEEEEE.........................\
@@ -345,7 +345,7 @@ static const char u_map[257] = "\
 ................................\
 ................................u";
 
-static const char utf_map[257] = "\
+static const char utf_map[258] = "\
 ................................\
 ................................\
 ................................\
@@ -355,7 +355,7 @@ SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS\
 ................................\
 ................................8";
 
-static const char space_map[257] = "\
+static const char space_map[258] = "\
 .........ab..a..................\
 a...............................\
 ................................\
@@ -365,7 +365,7 @@ a...............................\
 ................................\
 ................................S";
 
-static const char trail_map[257] = "\
+static const char trail_map[258] = "\
 .........ab..a..................\
 a...............................\
 ................................\
@@ -375,7 +375,7 @@ a...............................\
 ................................\
 ................................R";
 
-static const byte hex_map[256] = "\
+static const byte hex_map[257] = "\
 ................................\
 ................\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09......\
 .\x0a\x0b\x0c\x0d\x0e\x0f.........................\
@@ -594,7 +594,7 @@ static void big_change(ojParser p) {
     }
 }
 
-static void parse(ojParser p, const byte *json) {
+static void parse(ojParser p, const byte *json, bool more) {
     const byte *start;
     const byte *b = json;
     int         i;
@@ -635,6 +635,9 @@ static void parse(ojParser p, const byte *json) {
             if ('"' == *b) {
                 p->map = colon_map;
                 break;
+            } else if ('\0' == *b && !more) {
+                parse_error(p, "quoted string not terminated");
+                break;
             }
             b--;
             p->map      = string_map;
@@ -659,6 +662,9 @@ static void parse(ojParser p, const byte *json) {
                 p->funcs[p->stack[p->depth]].add_str(p);
                 p->map = (0 == p->depth) ? value_map : after_map;
                 break;
+            } else if ('\0' == *b && !more) {
+                parse_error(p, "quoted string not terminated");
+                break;
             }
             b--;
             p->map      = string_map;
@@ -668,6 +674,10 @@ static void parse(ojParser p, const byte *json) {
             p->cur = b - json;
             p->funcs[p->stack[p->depth]].open_object(p);
             p->depth++;
+            if ((int)sizeof(p->stack) <= p->depth) {
+                parse_error(p, "too deeply nested");
+                break;
+            }
             p->stack[p->depth] = OBJECT_FUN;
             p->map             = key1_map;
             break;
@@ -690,6 +700,10 @@ static void parse(ojParser p, const byte *json) {
             p->cur = b - json;
             p->funcs[p->stack[p->depth]].open_array(p);
             p->depth++;
+            if ((int)sizeof(p->stack) <= p->depth) {
+                parse_error(p, "too deeply nested");
+                break;
+            }
             p->stack[p->depth] = ARRAY_FUN;
             p->map             = value_map;
             break;
@@ -1161,7 +1175,7 @@ static void parser_mark(void *ptr) {
     }
 }
 
-static const rb_data_type_t oj_parser_type = {
+const rb_data_type_t oj_parser_type = {
     "Oj/parser",
     {
         parser_mark,
@@ -1176,6 +1190,8 @@ extern void oj_set_parser_validator(ojParser p);
 extern void oj_set_parser_saj(ojParser p);
 extern void oj_set_parser_usual(ojParser p);
 extern void oj_set_parser_debug(ojParser p);
+extern void oj_set_parser_safe(ojParser p, VALUE options);
+extern void oj_safe_init(VALUE parser_class);
 
 static int opt_cb(VALUE rkey, VALUE value, VALUE ptr) {
     ojParser    p   = (ojParser)ptr;
@@ -1354,6 +1370,34 @@ static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
     return p->option(p, key, rv);
 }
 
+static void validate_primitives_are_complete(ojParser p) {
+    if (0 >= p->ri) {
+        return;
+    }
+
+    switch (p->map[256]) {
+    case 'N': parse_error(p, "expected null"); break;
+    case 'F': parse_error(p, "expected false"); break;
+    case 'T': parse_error(p, "expected true"); break;
+    }
+}
+
+static void validate_non_primitives_are_complete(ojParser p) {
+    if (0 >= p->depth) {
+        return;
+    }
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        parse_error(p, "Object is not closed");
+    } else {
+        parse_error(p, "Array is not closed");
+    }
+}
+
+static void validate_document_end(ojParser p) {
+    validate_primitives_are_complete(p);
+    validate_non_primitives_are_complete(p);
+}
+
 /* Document-method: parse(json)
  * call-seq: parse(json)
  *
@@ -1363,13 +1407,20 @@ static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
  */
 static VALUE parser_parse(VALUE self, VALUE json) {
     ojParser    p;
-    const byte *ptr = (const byte *)StringValuePtr(json);
+    int         frozen = OBJ_FROZEN(json);
+    const byte *ptr;
+
+    if (!frozen) {
+        rb_str_freeze(json);
+    }
+    ptr = (const byte *)StringValuePtr(json);
 
     TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
     parser_reset(p);
     p->start(p);
-    parse(p, ptr);
+    parse(p, ptr, false);
+    validate_document_end(p);
 
     return p->result(p);
 }
@@ -1389,7 +1440,7 @@ static VALUE load(VALUE self) {
     while (true) {
         rb_funcall(p->reader, oj_readpartial_id, 2, INT2NUM(16385), rbuf);
         if (0 < RSTRING_LEN(rbuf)) {
-            parse(p, (byte *)StringValuePtr(rbuf));
+            parse(p, (byte *)StringValuePtr(rbuf), true);
         }
         if (Qtrue == rb_funcall(p->reader, oj_eofq_id, 0)) {
             if (0 < p->depth) {
@@ -1459,7 +1510,7 @@ static VALUE parser_file(VALUE self, VALUE filename) {
     while (true) {
         if (0 < (rsize = read(fd, buf, size))) {
             buf[rsize] = '\0';
-            parse(p, buf);
+            parse(p, buf, true);
         }
         if (rsize <= 0) {
             if (0 != rsize) {
@@ -1570,6 +1621,28 @@ static VALUE parser_validate(VALUE self) {
     return validate_parser;
 }
 
+static VALUE parser_safe(int argc, VALUE *argv, VALUE self) {
+    VALUE options;
+
+    if (1 == argc) {
+        options = argv[0];
+
+        Check_Type(options, T_HASH);
+    } else {
+        options = rb_hash_new();
+    }
+
+    ojParser p = OJ_R_ALLOC(struct _ojParser);
+
+    memset(p, 0, sizeof(struct _ojParser));
+    buf_init(&p->key);
+    buf_init(&p->buf);
+    p->map = value_map;
+    oj_set_parser_safe(p, options);
+
+    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
+}
+
 /* Document-class: Oj::Parser
  *
  * A reusable parser that makes use of named delegates to determine the
@@ -1597,4 +1670,7 @@ void oj_parser_init(void) {
     rb_define_module_function(parser_class, "usual", parser_usual, 0);
     rb_define_module_function(parser_class, "saj", parser_saj, 0);
     rb_define_module_function(parser_class, "validate", parser_validate, 0);
+    rb_define_module_function(parser_class, "safe", parser_safe, -1);
+
+    oj_safe_init(parser_class);
 }

data/ext/oj/parser.h

@@ -42,6 +42,8 @@ typedef struct _num {
 
 struct _ojParser;
 
+extern const rb_data_type_t oj_parser_type;
+
 typedef struct _funcs {
     void (*add_null)(struct _ojParser *p);
     void (*add_true)(struct _ojParser *p);

data/ext/oj/rails.c

@@ -140,7 +140,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE v;
     int            cnt;
     int            i;
-    int            len;
+    size_t         len;
     const char    *name;
 
 #ifdef RSTRUCT_LEN
@@ -161,7 +161,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
         name = RSTRING_PTR(s);
-        len  = (int)RSTRING_LEN(s);
+        len  = RSTRING_LEN(s);
         assure_size(out, size + sep_len + 6);
         if (0 < i) {
             *out->cur++ = ',';
@@ -205,11 +205,11 @@ static void dump_bigdecimal(VALUE obj, int depth, Out out, bool as_ok) {
     if ('I' == *str || 'N' == *str || ('-' == *str && 'I' == str[1])) {
         oj_dump_nil(Qnil, depth, out, false);
     } else if (out->opts->int_range_max != 0 || out->opts->int_range_min != 0) {
-        oj_dump_cstr(str, (int)RSTRING_LEN(rstr), 0, 0, out);
+        oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
     } else if (Yes == out->opts->bigdec_as_num) {
-        oj_dump_raw(str, (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(str, RSTRING_LEN(rstr), out);
     } else {
-        oj_dump_cstr(str, (int)RSTRING_LEN(rstr), 0, 0, out);
+        oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
     }
 }
 
@@ -330,14 +330,14 @@ static void dump_timewithzone(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_to_s(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE rstr = oj_safe_string_convert(obj);
 
-    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), RSTRING_LEN(rstr), 0, 0, out);
 }
 
 static ID parameters_id = 0;
 
 typedef struct _strLen {
     const char *str;
-    int         len;
+    size_t      len;
 } *StrLen;
 
 static void dump_actioncontroller_parameters(VALUE obj, int depth, Out out, bool as_ok) {
@@ -352,10 +352,10 @@ static StrLen columns_array(VALUE rcols, int *ccnt) {
     volatile VALUE v;
     StrLen         cp;
     StrLen         cols;
-    int            i;
-    int            cnt = (int)RARRAY_LEN(rcols);
+    size_t         i;
+    size_t         cnt = RARRAY_LEN(rcols);
 
-    *ccnt = cnt;
+    *ccnt = (int)cnt;
     cols  = OJ_R_ALLOC_N(struct _strLen, cnt);
     for (i = 0, cp = cols; i < cnt; i++, cp++) {
         v = RARRAY_AREF(rcols, i);
@@ -363,7 +363,7 @@ static StrLen columns_array(VALUE rcols, int *ccnt) {
             v = oj_safe_string_convert(v);
         }
         cp->str = StringValuePtr(v);
-        cp->len = (int)RSTRING_LEN(v);
+        cp->len = RSTRING_LEN(v);
     }
     return cols;
 }
@@ -424,7 +424,8 @@ 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         i;
+    size_t         rcnt;
     size_t         size;
     int            d2 = depth + 1;
 
@@ -435,7 +436,7 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
     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);
+    rcnt      = RARRAY_LEN(rows);
     assure_size(out, 2);
     *out->cur++ = '[';
     if (out->opts->dump_opts.use) {
@@ -660,13 +661,15 @@ static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
     Encoder e = OJ_R_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;
+    } else {
+        e->arg = rb_hash_new();
     }
+    oj_parse_options(e->arg, &e->opts);
+
     return TypedData_Wrap_Struct(encoder_class, &oj_encoder_type, e);
 }
 
@@ -917,7 +920,7 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
     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) {
@@ -933,8 +936,7 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
         if (0 == out.buf) {
             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 (Yes == copts.circular) {
         oj_cache8_delete(out.circ_cache);
@@ -1101,6 +1103,8 @@ static VALUE rails_set_decoder(VALUE self) {
     } 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 {
@@ -1172,7 +1176,7 @@ 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;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -1193,7 +1197,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
 
             strcpy(buf, RSTRING_PTR(rstr));
-            cnt = (int)RSTRING_LEN(rstr);
+            cnt = RSTRING_LEN(rstr);
         }
     }
     assure_size(out, cnt);
@@ -1205,7 +1209,8 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
 
     if (Yes == out->opts->circular) {
@@ -1214,12 +1219,11 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
             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)) {
+    if (!oj_rails_array_opt && as_ok && rb_respond_to(a, oj_as_json_id)) {
         dump_as_json(a, depth, out, false);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     size        = 2;
     assure_size(out, size);
@@ -1282,18 +1286,19 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
-    if (rtype != T_STRING && rtype != T_SYMBOL) {
-        key   = oj_safe_string_convert(key);
-        rtype = rb_type(key);
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
     }
     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);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         *out->cur++ = ':';
     } else {
@@ -1308,10 +1313,10 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
                 APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, 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);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         assure_size(out, size);
@@ -1340,7 +1345,7 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
             return;
         }
     }
-    if ((!oj_rails_hash_opt || 0 < out->argc) && as_ok && rb_respond_to(obj, oj_as_json_id)) {
+    if (!oj_rails_hash_opt && as_ok && rb_respond_to(obj, oj_as_json_id)) {
         dump_as_json(obj, depth, out, false);
         return;
     }

data/ext/oj/rxclass.c

@@ -96,7 +96,7 @@ int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
 }
 
 VALUE
-oj_rxclass_match(RxClass rc, const char *str, int len) {
+oj_rxclass_match(RxClass rc, const char *str, size_t len) {
     RxC  rxc;
     char buf[4096];