oj 1.2.9 → 1.2.10

data/README.md

@@ -24,9 +24,17 @@ A fast JSON parser and Object marshaller as a Ruby gem.
 
 ## <a name="release">Release Notes</a>
 
-### Release 1.2.9
+### Release 1.2.10
 
- - Changed the error message for invalid keys in compat mode to identify offending type.
+ - Added check for circular on loading of circular dumped JSON.
+
+ - Added support for direct serialization of BigDecimal, Rational, Date, and DateTime.
+
+ - Added json.rb to $" in mimic mode to avoid pulling in the real JSON by accident.
+
+ - Oj is now thread safe for all functions.
+
+ - The / (solidus) character is now placed in strings without being escaped.
 
 ## <a name="description">Description</a>
 
@@ -55,7 +63,10 @@ to_hash() is more flexible and produces more consistent output so it has a
 preference over the to_json() method. If neither the to_json() or to_hash()
 methods exist then the Oj internal Object variable encoding is used.
 
-Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, JRuby, RBX, and the latest 2.0dev.
+Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, JRuby, RBX, and the latest
+2.0dev. Note that JRuby now disables support for extentions by default. JRuby
+can be build with extensions enabled. Check the documenation for JRuby
+installs in your environment.
 
 Oj is also compatible with Rails. Just make sure the Oj gem is installed and
 [multi_json](https://github.com/intridea/multi_json) will pick it up and use it.
@@ -352,13 +363,16 @@ excaping the first character so that it appears as `\u005e` or `\u003a` instead
 class. The sequence `{"^c":"Oj::Bag"}` is read as the Oj::Bag class.
 
 6. A `"^t"` JSON Object key indicates the value should be converted to a Ruby
-Time. The sequence `{"^t":1325775487.000000}` is read as Jan 5, 2012 at 23:58:07.
+Time. The sequence `{"^t":1325775487.000000}` is read as Jan 5, 2012 at
+23:58:07.
 
-87. A `"^o"` JSON Object key indicates the value should be converted to a Ruby
+7. A `"^o"` JSON Object key indicates the value should be converted to a Ruby
 Object. The first entry in the JSON Object must be a class with the `"^o"`
 key. After that each entry is treated as a variable of the Object where the
 key is the variable name without the preceeding `@`. An example is
-`{"^o":"Oj::Bag","x":58,"y":"marbles"}`.
+`{"^o":"Oj::Bag","x":58,"y":"marbles"}`. `"^O"` is the same except that it is
+for built in or odd classes that don't obey the normal Ruby rules. Examples
+are Rational, Date, and DateTime.
 
 8. A `"^u"` JSON Object key indicates the value should be converted to a Ruby
 Struct. The first entry in the JSON Object must be a class with the `"^u"`

data/ext/oj/dump.c

@@ -67,6 +67,7 @@ static void	dump_false(Out out);
 static void	dump_fixnum(VALUE obj, Out out);
 static void	dump_bignum(VALUE obj, Out out);
 static void	dump_float(VALUE obj, Out out);
+static void	dump_raw(const char *str, size_t cnt, Out out);
 static void	dump_cstr(const char *str, size_t cnt, int is_sym, int escape1, Out out);
 static void	dump_hex(u_char c, Out out);
 static void	dump_str_comp(VALUE obj, Out out);
@@ -82,7 +83,7 @@ static int	hash_cb_object(VALUE key, VALUE value, Out out);
 static void	dump_hash(VALUE obj, int depth, int mode, Out out);
 static void	dump_time(VALUE obj, Out out);
 static void	dump_data_comp(VALUE obj, Out out);
-static void	dump_data_obj(VALUE obj, Out out);
+static void	dump_data_obj(VALUE obj, int depth, Out out);
 static void	dump_obj_comp(VALUE obj, int depth, Out out);
 static void	dump_obj_obj(VALUE obj, int depth, Out out);
 #if HAS_RSTRUCT
@@ -92,7 +93,8 @@ static void	dump_struct_obj(VALUE obj, int depth, Out out);
 #if HAS_IVAR_HELPERS
 static int	dump_attr_cb(ID key, VALUE value, Out out);
 #endif
-static void	dump_obj_attrs(VALUE obj, int with_class, slot_t id, int depth, Out out);
+static void	dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out);
+static void	dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out);
 
 static void	grow(Out out, size_t len);
 static size_t	hibit_friendly_size(const u_char *str, size_t len);
@@ -111,7 +113,7 @@ static const char	hex_chars[17] = "0123456789abcdef";
 
 static char	hibit_friendly_chars[256] = "\
 66666666222622666666666666666666\
-11211111111111121111111111111111\
+11211111111111111111111111111111\
 11111111111111111111111111112111\
 11111111111111111111111111111111\
 11111111111111111111111111111111\
@@ -223,6 +225,16 @@ dump_hex(u_char c, Out out) {
     *out->cur++ = hex_chars[d];
 }
 
+static void
+dump_raw(const char *str, size_t cnt, Out out) {
+    if (out->end - out->cur <= (long)cnt + 10) {
+	grow(out, cnt + 10);
+    }
+    memcpy(out->cur, str, cnt);
+    out->cur += cnt;
+    *out->cur = '\0';
+}
+
 const char*
 dump_unicode(const char *str, const char *end, Out out) {
     uint32_t	code = 0;
@@ -635,6 +647,7 @@ dump_array(VALUE a, int depth, Out out) {
 	    }
 	    if (0 < out->opts->dump_opts->indent_size) {
 		int	i;
+
 		for (i = depth; 0 < i; i--) {
 		    strcpy(out->cur, out->opts->dump_opts->indent);
 		    out->cur += out->opts->dump_opts->indent_size;
@@ -934,18 +947,27 @@ dump_time(VALUE obj, Out out) {
 
 static void
 dump_data_comp(VALUE obj, Out out) {
-    VALUE   clas = rb_obj_class(obj);
+    VALUE	clas = rb_obj_class(obj);
 
     if (rb_cTime == clas) {
 	dump_time(obj, out);
     } else {
-	dump_nil(out);
+	VALUE	rstr;
+
+	if (oj_bigdecimal_class == clas) {
+	    //rstr = rb_funcall(obj, oj_to_s_id, 1, rb_intern("E"));
+	    rstr = rb_funcall(obj, oj_to_s_id, 0);
+	    dump_raw(StringValuePtr(rstr), RSTRING_LEN(rstr), out);
+	} else {
+	    rstr = rb_funcall(obj, oj_to_s_id, 0);
+	    dump_cstr(StringValuePtr(rstr), RSTRING_LEN(rstr), 0, 0, out);
+	}
     }
 }
 
 static void
-dump_data_obj(VALUE obj, Out out) {
-    VALUE   clas = rb_obj_class(obj);
+dump_data_obj(VALUE obj, int depth, Out out) {
+    VALUE	clas = rb_obj_class(obj);
 
     if (rb_cTime == clas) {
 	if (out->end - out->cur <= 6) {
@@ -961,7 +983,14 @@ dump_data_obj(VALUE obj, Out out) {
 	*out->cur++ = '}';
 	*out->cur = '\0';
     } else {
-	dump_nil(out);
+	VALUE	clas = rb_obj_class(obj);
+	Odd	odd = oj_get_odd(clas);
+
+	if (0 == odd) {
+	    dump_nil(out);
+	} else {
+	    dump_odd(obj, odd, clas, depth + 1, out);
+	}
     }
 }
 
@@ -987,7 +1016,21 @@ dump_obj_comp(VALUE obj, int depth, Out out) {
 	memcpy(out->cur, s, len);
 	out->cur += len;
     } else {
-	dump_obj_attrs(obj, 0, 0, depth, out);
+	VALUE	clas = rb_obj_class(obj);
+
+	if (oj_bigdecimal_class == clas) {
+	    VALUE	rstr = rb_funcall(obj, oj_to_s_id, 0);
+
+	    dump_raw(StringValuePtr(rstr), RSTRING_LEN(rstr), out);
+	} else {
+	    Odd	odd = oj_get_odd(clas);
+
+	    if (0 == odd) {
+		dump_obj_attrs(obj, 0, 0, depth, out);
+	    } else {
+		dump_odd(obj, odd, 0, depth + 1, out);
+	    }
+	}
     }
     *out->cur = '\0';
 }
@@ -997,7 +1040,14 @@ dump_obj_obj(VALUE obj, int depth, Out out) {
     long	id = check_circular(obj, out);
 
     if (0 <= id) {
-	dump_obj_attrs(obj, 1, id, depth, out);
+	VALUE	clas = rb_obj_class(obj);
+	Odd	odd = oj_get_odd(clas);
+
+	if (0 == odd) {
+	    dump_obj_attrs(obj, clas, id, depth, out);
+	} else {
+	    dump_odd(obj, odd, clas, depth + 1, out);
+	}
     }
 }
 
@@ -1033,7 +1083,7 @@ dump_attr_cb(ID key, VALUE value, Out out) {
 #endif
 
 static void
-dump_obj_attrs(VALUE obj, int with_class, slot_t id, int depth, Out out) {
+dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out) {
     size_t	size;
     int		d2 = depth + 1;
 
@@ -1041,8 +1091,8 @@ dump_obj_attrs(VALUE obj, int with_class, slot_t id, int depth, Out out) {
 	grow(out, 2);
     }
     *out->cur++ = '{';
-    if (with_class) {
-	const char	*class_name = rb_class2name(rb_obj_class(obj));
+    if (0 != clas) {
+	const char	*class_name = rb_class2name(clas);
 	int		clen = (int)strlen(class_name);
 
 	size = d2 * out->indent + clen + 10;
@@ -1085,13 +1135,15 @@ dump_obj_attrs(VALUE obj, int with_class, slot_t id, int depth, Out out) {
 
 	cnt = (int)RARRAY_LEN(vars);
 #endif
-	if (with_class && 0 < cnt) {
+	if (0 != clas && 0 < cnt) {
 	    *out->cur++ = ',';
 	}
 	out->depth = depth + 1;
 #if HAS_IVAR_HELPERS
 	rb_ivar_foreach(obj, dump_attr_cb, (VALUE)out);
-	out->cur--; // backup to overwrite last comma
+	if (',' == *(out->cur - 1)) {
+	    out->cur--; // backup to overwrite last comma
+	}
 #else
 	size = d2 * out->indent + 1;
 	for (i = cnt; 0 < i; i--, np++) {
@@ -1197,6 +1249,56 @@ dump_struct_obj(VALUE obj, int depth, Out out) {
 }
 #endif
 
+static void
+dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
+    ID		*idp;
+    VALUE	v;
+    const char	*name;
+    size_t	size;
+    int		d2 = depth + 1;
+
+    if (out->end - out->cur <= 2) {
+	grow(out, 2);
+    }
+    *out->cur++ = '{';
+    if (0 != clas) {
+	const char	*class_name = rb_class2name(clas);
+	int		clen = (int)strlen(class_name);
+
+	size = d2 * out->indent + clen + 10;
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	fill_indent(out, d2);
+	*out->cur++ = '"';
+	*out->cur++ = '^';
+	*out->cur++ = 'O';
+	*out->cur++ = '"';
+	*out->cur++ = ':';
+	dump_cstr(class_name, clen, 0, 0, out);
+	*out->cur++ = ',';
+    }
+    size = d2 * out->indent + 1;
+    for (idp = odd->attrs; 0 != *idp; idp++) {
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	name = rb_id2name(*idp);
+	v = rb_funcall(obj, *idp, 0);
+	fill_indent(out, d2);
+	dump_cstr(name, strlen(name), 0, 0, out);
+	*out->cur++ = ':';
+	dump_val(v, d2, out);
+	if (out->end - out->cur <= 2) {
+	    grow(out, 2);
+	}
+	*out->cur++ = ',';
+    }
+    out->cur--;
+    *out->cur++ = '}';
+    *out->cur = '\0';
+}
+
 static void
 raise_strict(VALUE obj) {
     rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in strict mode.\n", rb_class2name(rb_obj_class(obj)));
@@ -1240,6 +1342,9 @@ dump_val(VALUE obj, int depth, Out out) {
 	default:		dump_class_obj(obj, out);	break;
 	}
 	break;
+#if (defined T_RATIONAL && defined RRATIONAL)
+    case T_RATIONAL:
+#endif
     case T_OBJECT:
 	switch (out->opts->mode) {
 	case StrictMode:	raise_strict(obj);		break;
@@ -1255,7 +1360,7 @@ dump_val(VALUE obj, int depth, Out out) {
 	case NullMode:		dump_nil(out);			break;
 	case CompatMode:	dump_data_comp(obj, out);	break;
 	case ObjectMode:
-	default:		dump_data_obj(obj, out);	break;
+	default:		dump_data_obj(obj, depth, out);	break;
 	}
 	break;
 #if HAS_RSTRUCT
@@ -1271,9 +1376,6 @@ dump_val(VALUE obj, int depth, Out out) {
 #endif
 #if (defined T_COMPLEX && defined RCOMPLEX)
     case T_COMPLEX:
-#endif
-#if (defined T_RATIONAL && defined RRATIONAL)
-    case T_RATIONAL:
 #endif
     case T_REGEXP:
 	switch (out->opts->mode) {

data/ext/oj/extconf.rb

@@ -24,6 +24,7 @@ dflags = {
   'HAS_IVAR_HELPERS' => ('ruby' == type && ('1' == version[0] && '9' == version[1]) || '2' <= version[0]) ? 1 : 0,
   'HAS_PROC_WITH_BLOCK' => ('ruby' == type && ('1' == version[0] && '9' == version[1]) || '2' <= version[0]) ? 1 : 0,
   'HAS_TOP_LEVEL_ST_H' => ('ree' == type || ('ruby' == type &&  '1' == version[0] && '8' == version[1])) ? 1 : 0,
+  'SAFE_CACHE' => nil,
 }
 # This is a monster hack to get around issues with 1.9.3-p0 on CentOS 5.4. SO
 # some reason math.h and string.h contents are not processed. Might be a

data/ext/oj/load.c

@@ -28,6 +28,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <pthread.h> // TBD LOCK
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -157,6 +158,9 @@ classname2class(const char *name, ParseInfo pi) {
     VALUE	*slot;
     int		auto_define = (Yes == pi->options->auto_define);
 
+#ifdef SAFE_CACHE
+    pthread_mutex_lock(&oj_cache_mutex);
+#endif
     if (Qundef == (clas = oj_cache_get(oj_class_cache, name, &slot))) {
 	char		class_name[1024];
 	char		*s;
@@ -183,6 +187,9 @@ classname2class(const char *name, ParseInfo pi) {
 	    *slot = clas;
 	}
     }
+#ifdef SAFE_CACHE
+    pthread_mutex_unlock(&oj_cache_mutex);
+#endif
     return clas;
 }
 
@@ -370,6 +377,9 @@ read_obj(ParseInfo pi) {
     int		obj_type = T_NONE;
     const char	*json_class_name = 0;
     Mode	mode = pi->options->mode;
+    Odd		odd = 0;
+    VALUE	odd_args[MAX_ODD_ARGS];
+    VALUE	*vp;
     
     pi->s++;
     next_non_white(pi);
@@ -420,6 +430,16 @@ read_obj(ParseInfo pi) {
 		    obj_type = T_OBJECT;
 		    key = Qundef;
 		    break;
+		case 'O': // Odd class
+		    if (0 == (odd = oj_get_odd(read_next(pi, T_CLASS)))) {
+			raise_error("Not a valid build in class.", pi->str, pi->s);
+		    }
+		    obj = Qundef;
+		    key = Qundef;
+		    for (vp = odd_args + MAX_ODD_ARGS - 1; odd_args <=vp; vp--) {
+			*vp = Qnil;
+		    }
+		    break;
 		case 'u': // Struct
 		    obj = read_next(pi, T_STRUCT);
 		    obj_type = T_STRUCT;
@@ -435,7 +455,7 @@ read_obj(ParseInfo pi) {
 	    if (Qundef == val && Qundef == (val = read_next(pi, 0))) {
 		raise_error("unexpected character", pi->str, pi->s);
 	    }
-	    if (Qundef == obj) {
+	    if (Qundef == obj && 0 == odd) {
 		obj = rb_hash_new();
 		obj_type = T_HASH;
 	    }
@@ -455,10 +475,25 @@ read_obj(ParseInfo pi) {
 		}
 	    }
 	    if (Qundef != key) {
-		if (T_OBJECT == obj_type) {
+		if (0 != odd) {
+		    ID	*idp;
+
+		    for (idp = odd->attrs, vp = odd_args; 0 != *idp; idp++, vp++) {
+			if (0 == strcmp(rb_id2name(*idp), ks)) {
+			    *vp = val;
+			    break;
+			}
+		    }
+		    if (odd_args + MAX_ODD_ARGS <= vp) {
+			raise_error("invalid attribute", pi->str, pi->s);
+		    }
+		} else if (T_OBJECT == obj_type) {
 		    VALUE	*slot;
 		    ID		var_id;
 
+#ifdef SAFE_CACHE
+		    pthread_mutex_lock(&oj_cache_mutex);
+#endif
 		    if (Qundef == (var_id = oj_cache_get(oj_attr_cache, ks, &slot))) {
 			char	attr[1024];
 
@@ -472,6 +507,9 @@ read_obj(ParseInfo pi) {
 			var_id = rb_intern(attr);
 			*slot = var_id;
 		    }
+#ifdef SAFE_CACHE
+		    pthread_mutex_unlock(&oj_cache_mutex);
+#endif
 		    rb_ivar_set(obj, var_id, val);
 		} else if (T_HASH == obj_type) {
 		    if (Yes == pi->options->sym_key) {
@@ -501,7 +539,9 @@ read_obj(ParseInfo pi) {
 	    raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
 	}
     }
-    if (0 != json_class_name) {
+    if (0 != odd) {
+	obj = rb_funcall2(odd->create_obj, odd->create_op, odd->attr_cnt, odd_args);
+    } else if (0 != json_class_name) {
 	VALUE	clas = classname2class(json_class_name, pi);
 	VALUE	args[1];
 
@@ -625,7 +665,7 @@ read_str(ParseInfo pi, int hint) {
 	} else if (ObjectMode == pi->options->mode && '^' == *text && '\0' != text[2]) {
 	    char	c1 = text[1];
 
-	    if ('r' == c1) {
+	    if ('r' == c1 && 0 != pi->circ_array) {
 		obj = circ_array_get(pi->circ_array, read_ulong(text + 2, pi));
 	    } else if ('i' == c1) {
 		obj = ULONG2NUM(read_ulong(text + 2, pi));
@@ -691,6 +731,9 @@ read_num(ParseInfo pi) {
 	for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
 	    a = a * 10 + (*pi->s - '0');
 	    div *= 10;
+	    if (NUM_MAX <= div) {
+		big = 1;
+	    }
 	}
     }
     if ('e' == *pi->s || 'E' == *pi->s) {
@@ -703,6 +746,9 @@ read_num(ParseInfo pi) {
 	}
 	for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
 	    e = e * 10 + (*pi->s - '0');
+	    if (NUM_MAX <= e) {
+		big = 1;
+	    }
 	}
     }
     if (0 == e && 0 == a && 1 == div) {
@@ -721,22 +767,33 @@ read_num(ParseInfo pi) {
 	    }
 	    return LONG2NUM(n);
 	}
-    } else {
-	double	d = (double)n + (double)a / (double)div;
+    } else { // decimal
+	if (big) {
+	    char	c = *pi->s;
+	    VALUE	num;
+	
+	    *pi->s = '\0';
+	    num = rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(start));
+	    *pi->s = c;
 
-	if (neg) {
-	    d = -d;
-	}
-	if (1 < big) {
-	    e += big - 1;
-	}
-	if (0 != e) {
-	    if (eneg) {
-		e = -e;
+	    return num;
+	} else {
+	    double	d = (double)n + (double)a / (double)div;
+
+	    if (neg) {
+		d = -d;
+	    }
+	    if (1 < big) {
+		e += big - 1;
+	    }
+	    if (0 != e) {
+		if (eneg) {
+		    e = -e;
+		}
+		d *= pow(10.0, e);
 	    }
-	    d *= pow(10.0, e);
+	    return rb_float_new(d);
 	}
-	return rb_float_new(d);
     }
 }