oj 2.14.6 → 2.15.0

data/README.md

@@ -157,11 +157,26 @@ Oj.default_options = {:mode => :compat }
  * `:quirks_mode` [Boolean] Allow single JSON values instead of
    documents, default is true (allow).
 
+* `:nan` [:null|:huge|:word|:raise|:auto] How to dump Infinity, -Infinity, and
+  NaN in null, strict, and compat mode. :null places a null, :huge places a huge
+  number, :word places Infinity or NaN, :raise raises and exception, :auto uses
+  default for each mode which are :raise for :strict, :null for :null, and :word
+  for :compat. Default is :auto.
+
 ## Releases
 
-**Release 2.14.6**
+** Release 2.15.0**
+
+ - Fixed bug where encoded strings could be GCed.
+
+ - :nan option added for dumping Infinity, -Infinity, and NaN. This is an
+   edition to the API. The default value for the :non option is :auto which uses
+   the previous NaN handling on dumping of non-object modes.
+
+**Release 2.14.7**
 
- - Changed JSON::ParserError to inherit from JSON::JSONError which inherits from StandardError.
+ - Fixed bug where a comment before another JSON element caused an
+   error. Comments are not part of the spec but this keep support consistent.
 
 [Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
 

data/ext/oj/dump.c

@@ -441,13 +441,17 @@ dump_bignum(VALUE obj, Out out) {
     *out->cur = '\0';
 }
 
+static const char	inf_val[] = INF_VAL;
+static const char	ninf_val[] = NINF_VAL;
+static const char	nan_val[] = NAN_VAL;
+
 // Removed dependencies on math due to problems with CentOS 5.4.
 static void
 dump_float(VALUE obj, Out out) {
     char	buf[64];
     char	*b;
     double	d = rb_num2dbl(obj);
-    int		cnt;
+    int		cnt = 0;
 
     if (0.0 == d) {
 	b = buf;
@@ -457,43 +461,106 @@ dump_float(VALUE obj, Out out) {
 	*b++ = '\0';
 	cnt = 3;
     } else if (OJ_INFINITY == d) {
-	switch (out->opts->mode) {
-	case StrictMode:
-	    raise_strict(obj);
-	case NullMode:
-	    strcpy(buf, "null");
-	    cnt = 4;
-	    break;
-	default:
-	    strcpy(buf, "Infinity");
-	    cnt = 8;
-	    break;
+	if (ObjectMode == out->opts->mode) {
+	    strcpy(buf, inf_val);
+	    cnt = sizeof(inf_val) - 1;
+	} else {
+	    NanDump	nd = out->opts->dump_opts.nan_dump;
+	    
+	    if (AutoNan == nd) {
+		switch (out->opts->mode) {
+		case CompatMode:	nd = WordNan;	break;
+		case StrictMode:	nd = RaiseNan;	break;
+		case NullMode:		nd = NullNan;	break;
+		default:				break;
+		}
+	    }
+	    switch (nd) {
+	    case RaiseNan:
+		raise_strict(obj);
+		break;
+	    case WordNan:
+		strcpy(buf, "Infinity");
+		cnt = 8;
+		break;
+	    case NullNan:
+		strcpy(buf, "null");
+		cnt = 4;
+		break;
+	    case HugeNan:
+	    default:
+		strcpy(buf, inf_val);
+		cnt = sizeof(inf_val) - 1;
+		break;
+	    }
 	}
     } else if (-OJ_INFINITY == d) {
-	switch (out->opts->mode) {
-	case StrictMode:
-	    raise_strict(obj);
-	case NullMode:
-	    strcpy(buf, "null");
-	    cnt = 4;
-	    break;
-	default:
-	    strcpy(buf, "-Infinity");
-	    cnt = 9;
-	    break;
+	if (ObjectMode == out->opts->mode) {
+	    strcpy(buf, ninf_val);
+	    cnt = sizeof(ninf_val) - 1;
+	} else {
+	    NanDump	nd = out->opts->dump_opts.nan_dump;
+	    
+	    if (AutoNan == nd) {
+		switch (out->opts->mode) {
+		case CompatMode:	nd = WordNan;	break;
+		case StrictMode:	nd = RaiseNan;	break;
+		case NullMode:		nd = NullNan;	break;
+		default:				break;
+		}
+	    }
+	    switch (nd) {
+	    case RaiseNan:
+		raise_strict(obj);
+		break;
+	    case WordNan:
+		strcpy(buf, "-Infinity");
+		cnt = 9;
+		break;
+	    case NullNan:
+		strcpy(buf, "null");
+		cnt = 4;
+		break;
+	    case HugeNan:
+	    default:
+		strcpy(buf, ninf_val);
+		cnt = sizeof(ninf_val) - 1;
+		break;
+	    }
 	}
     } else if (isnan(d)) {
-	switch (out->opts->mode) {
-	case StrictMode:
-	    raise_strict(obj);
-	case NullMode:
-	    strcpy(buf, "null");
-	    cnt = 4;
-	    break;
-	default:
-	    strcpy(buf, "NaN");
-	    cnt = 3;
-	    break;
+	if (ObjectMode == out->opts->mode) {
+	    strcpy(buf, nan_val);
+	    cnt = sizeof(nan_val) - 1;
+	} else {
+	    NanDump	nd = out->opts->dump_opts.nan_dump;
+	    
+	    if (AutoNan == nd) {
+		switch (out->opts->mode) {
+		case CompatMode:	nd = WordNan;	break;
+		case StrictMode:	nd = RaiseNan;	break;
+		case NullMode:		nd = NullNan;	break;
+		default:				break;
+		}
+	    }
+	    switch (nd) {
+	    case RaiseNan:
+		raise_strict(obj);
+		break;
+	    case WordNan:
+		strcpy(buf, "NaN");
+		cnt = 3;
+		break;
+	    case NullNan:
+		strcpy(buf, "null");
+		cnt = 4;
+		break;
+	    case HugeNan:
+	    default:
+		strcpy(buf, nan_val);
+		cnt = sizeof(nan_val) - 1;
+		break;
+	    }
 	}
     } else if (d == (double)(long long int)d) {
 	cnt = snprintf(buf, sizeof(buf), "%.1f", d);

data/ext/oj/oj.c

@@ -120,15 +120,18 @@ static VALUE	create_id_sym;
 static VALUE	escape_mode_sym;
 static VALUE	float_prec_sym;
 static VALUE	float_sym;
+static VALUE	huge_sym;
 static VALUE	indent_sym;
-static VALUE	json_sym;
 static VALUE	json_parser_error_class;
+static VALUE	json_sym;
 static VALUE	mode_sym;
+static VALUE	nan_sym;
 static VALUE	newline_sym;
 static VALUE	nilnil_sym;
 static VALUE	null_sym;
 static VALUE	object_sym;
 static VALUE	quirks_mode_sym;
+static VALUE	raise_sym;
 static VALUE	ruby_sym;
 static VALUE	sec_prec_sym;
 static VALUE	strict_sym;
@@ -137,6 +140,7 @@ static VALUE	time_format_sym;
 static VALUE	unix_sym;
 static VALUE	unix_zone_sym;
 static VALUE	use_to_json_sym;
+static VALUE	word_sym;
 static VALUE	xmlschema_sym;
 static VALUE	xss_safe_sym;
 
@@ -194,6 +198,7 @@ struct _Options	oj_default_options = {
 	0,	// after_size
 	0,	// hash_size
 	0,	// array_size
+	AutoNan,// nan_dump
     }
 };
 
@@ -224,6 +229,7 @@ static VALUE	define_mimic_json(int argc, VALUE *argv, VALUE self);
  * - space_before: [String|nil] String to use before the colon separator in JSON object fields
  * - object_nl: [String|nil] String to use after a JSON object field value
  * - array_nl: [String|nil] String to use after a JSON array value
+ * - nan: [:null|:huge|:word|:raise|:auto] how to dump Infinity and NaN in null, strict, and compat mode. :null places a null, :huge places a huge number, :word places Infinity or NaN, :raise raises and exception, :auto uses default for each mode.
  * @return [Hash] all current option settings.
  */
 static VALUE
@@ -279,6 +285,14 @@ get_def_opts(VALUE self) {
     rb_hash_aset(opts, object_nl_sym, (0 == oj_default_options.dump_opts.hash_size) ? Qnil : rb_str_new2(oj_default_options.dump_opts.hash_nl));
     rb_hash_aset(opts, array_nl_sym, (0 == oj_default_options.dump_opts.array_size) ? Qnil : rb_str_new2(oj_default_options.dump_opts.array_nl));
 
+    switch (oj_default_options.dump_opts.nan_dump) {
+    case NullNan:	rb_hash_aset(opts, nan_sym, null_sym);	break;
+    case RaiseNan:	rb_hash_aset(opts, nan_sym, raise_sym);	break;
+    case WordNan:	rb_hash_aset(opts, nan_sym, word_sym);	break;
+    case HugeNan:	rb_hash_aset(opts, nan_sym, huge_sym);	break;
+    case AutoNan:
+    default:		rb_hash_aset(opts, nan_sym, auto_sym);	break;
+    }
     return opts;
 }
 
@@ -321,6 +335,7 @@ get_def_opts(VALUE self) {
  * @param [String|nil] :space_before String to use before the colon separator in JSON object fields
  * @param [String|nil] :object_nl String to use after a JSON object field value
  * @param [String|nil] :array_nl String to use after a JSON array value
+ * @param [:null|:huge|:word|:raise] :nan how to dump Infinity and NaN in null, strict, and compat mode. :null places a null, :huge places a huge number, :word places Infinity or NaN, :raise raises and exception, :auto uses default for each mode.
  * @return [nil]
  */
 static VALUE
@@ -546,6 +561,21 @@ oj_parse_options(VALUE ropts, Options copts) {
 	    copts->dump_opts.array_size = (uint8_t)len;
 	}
     }
+    if (Qnil != (v = rb_hash_lookup(ropts, nan_sym))) {
+	if (null_sym == v) {
+	    copts->dump_opts.nan_dump = NullNan;
+	} else if (huge_sym == v) {
+	    copts->dump_opts.nan_dump = HugeNan;
+	} else if (word_sym == v) {
+	    copts->dump_opts.nan_dump = WordNan;
+	} else if (raise_sym == v) {
+	    copts->dump_opts.nan_dump = RaiseNan;
+	} else if (auto_sym == v) {
+	    copts->dump_opts.nan_dump = AutoNan;
+	} else {
+	    rb_raise(rb_eArgError, ":nan must be :null, :huge, :word, :raise, or :auto.");
+	}
+    }
     copts->dump_opts.use = (0 < copts->dump_opts.indent_size ||
 			    0 < copts->dump_opts.after_size ||
 			    0 < copts->dump_opts.before_size ||
@@ -1832,6 +1862,7 @@ static struct _Options	mimic_object_to_json_options = {
 	0,	// after_size
 	0,	// hash_size
 	0,	// array_size
+	AutoNan,// nan_dump
     }
 };
 
@@ -2120,11 +2151,11 @@ void Init_oj() {
     json_parser_error_class = Qnil; // replaced if mimic is called
 
     allow_gc_sym = ID2SYM(rb_intern("allow_gc"));	rb_gc_register_address(&allow_gc_sym);
+    array_nl_sym = ID2SYM(rb_intern("array_nl"));	rb_gc_register_address(&array_nl_sym);
     ascii_only_sym = ID2SYM(rb_intern("ascii_only"));	rb_gc_register_address(&ascii_only_sym);
     ascii_sym = ID2SYM(rb_intern("ascii"));		rb_gc_register_address(&ascii_sym);
     auto_define_sym = ID2SYM(rb_intern("auto_define"));	rb_gc_register_address(&auto_define_sym);
     auto_sym = ID2SYM(rb_intern("auto"));		rb_gc_register_address(&auto_sym);
-    array_nl_sym = ID2SYM(rb_intern("array_nl"));	rb_gc_register_address(&array_nl_sym);
     bigdecimal_as_decimal_sym = ID2SYM(rb_intern("bigdecimal_as_decimal"));rb_gc_register_address(&bigdecimal_as_decimal_sym);
     bigdecimal_load_sym = ID2SYM(rb_intern("bigdecimal_load"));rb_gc_register_address(&bigdecimal_load_sym);
     bigdecimal_sym = ID2SYM(rb_intern("bigdecimal"));	rb_gc_register_address(&bigdecimal_sym);
@@ -2135,15 +2166,18 @@ void Init_oj() {
     escape_mode_sym = ID2SYM(rb_intern("escape_mode"));	rb_gc_register_address(&escape_mode_sym);
     float_prec_sym = ID2SYM(rb_intern("float_precision"));rb_gc_register_address(&float_prec_sym);
     float_sym = ID2SYM(rb_intern("float"));		rb_gc_register_address(&float_sym);
+    huge_sym = ID2SYM(rb_intern("huge"));		rb_gc_register_address(&huge_sym);
     indent_sym = ID2SYM(rb_intern("indent"));		rb_gc_register_address(&indent_sym);
     json_sym = ID2SYM(rb_intern("json"));		rb_gc_register_address(&json_sym);
     mode_sym = ID2SYM(rb_intern("mode"));		rb_gc_register_address(&mode_sym);
+    nan_sym = ID2SYM(rb_intern("nan"));		rb_gc_register_address(&nan_sym);
     newline_sym = ID2SYM(rb_intern("newline"));		rb_gc_register_address(&newline_sym);
     nilnil_sym = ID2SYM(rb_intern("nilnil"));		rb_gc_register_address(&nilnil_sym);
     null_sym = ID2SYM(rb_intern("null"));		rb_gc_register_address(&null_sym);
     object_nl_sym = ID2SYM(rb_intern("object_nl"));	rb_gc_register_address(&object_nl_sym);
     object_sym = ID2SYM(rb_intern("object"));		rb_gc_register_address(&object_sym);
     quirks_mode_sym = ID2SYM(rb_intern("quirks_mode"));	rb_gc_register_address(&quirks_mode_sym);
+    raise_sym = ID2SYM(rb_intern("raise"));		rb_gc_register_address(&raise_sym);
     ruby_sym = ID2SYM(rb_intern("ruby"));		rb_gc_register_address(&ruby_sym);
     sec_prec_sym = ID2SYM(rb_intern("second_precision"));rb_gc_register_address(&sec_prec_sym);
     space_before_sym = ID2SYM(rb_intern("space_before"));rb_gc_register_address(&space_before_sym);
@@ -2154,6 +2188,7 @@ void Init_oj() {
     unix_sym = ID2SYM(rb_intern("unix"));		rb_gc_register_address(&unix_sym);
     unix_zone_sym = ID2SYM(rb_intern("unix_zone"));	rb_gc_register_address(&unix_zone_sym);
     use_to_json_sym = ID2SYM(rb_intern("use_to_json"));	rb_gc_register_address(&use_to_json_sym);
+    word_sym = ID2SYM(rb_intern("word"));		rb_gc_register_address(&word_sym);
     xmlschema_sym = ID2SYM(rb_intern("xmlschema"));	rb_gc_register_address(&xmlschema_sym);
     xss_safe_sym = ID2SYM(rb_intern("xss_safe"));	rb_gc_register_address(&xss_safe_sym);
 

data/ext/oj/oj.h

@@ -68,6 +68,10 @@ enum st_retval {ST_CONTINUE = 0, ST_STOP = 1, ST_DELETE = 2, ST_CHECK};
 
 #include "err.h"
 
+#define INF_VAL		"3.0e14159265358979323846"
+#define NINF_VAL	"-3.0e14159265358979323846"
+#define NAN_VAL		"3.3e14159265358979323846"
+
 typedef enum {
     Yes	   = 'y',
     No	   = 'n',
@@ -108,6 +112,14 @@ typedef enum {
     ObjectType	= 'o',
 } DumpType;
 
+typedef enum {
+    AutoNan	= 'a',
+    NullNan	= 'n',
+    HugeNan	= 'h',
+    WordNan	= 'w',
+    RaiseNan	= 'r',
+} NanDump;
+
 typedef enum {
     STRING_IO	= 'c',
     STREAM_IO	= 's',
@@ -126,6 +138,7 @@ typedef struct _DumpOpts {
     uint8_t	after_size;
     uint8_t	hash_size;
     uint8_t	array_size;
+    char	nan_dump;	// NanDump
 } *DumpOpts;
 
 typedef struct _Options {

data/ext/oj/parse.c

@@ -481,6 +481,17 @@ read_num(ParseInfo pi) {
 	}
 	ni.len = pi->cur - ni.str;
     }
+    // Check for special reserved values for Infinity and NaN.
+    if (ni.big) {
+	if (0 == strcasecmp(INF_VAL, ni.str)) {
+	    ni.infinity = 1;
+	} else if (0 == strcasecmp(NINF_VAL, ni.str)) {
+	    ni.infinity = 1;
+	    ni.neg = 1;
+	} else if (0 == strcasecmp(NAN_VAL, ni.str)) {
+	    ni.nan = 1;
+	}
+    }
     if (BigDec == pi->options.bigdec_load) {
 	ni.big = 1;
     }
@@ -644,6 +655,9 @@ oj_parse2(ParseInfo pi) {
 	    break;
 	case '/':
 	    skip_comment(pi);
+	    if (first) {
+		continue;
+	    }
 	    break;
 	case '\0':
 	    pi->cur--;
@@ -772,17 +786,18 @@ protect_parse(VALUE pip) {
 }
 
 extern int oj_utf8_index;
-void
-oj_pi_set_input_str(ParseInfo pi, volatile VALUE input) {
+
+static void
+oj_pi_set_input_str(ParseInfo pi, volatile VALUE *inputp) {
 #if HAS_ENCODING_SUPPORT
-    rb_encoding	*enc = rb_to_encoding(rb_obj_encoding(input));
+    rb_encoding	*enc = rb_to_encoding(rb_obj_encoding(*inputp));
 
     if (rb_utf8_encoding() != enc) {
-	input = rb_str_conv_enc(input, enc, rb_utf8_encoding());
+	*inputp = rb_str_conv_enc(*inputp, enc, rb_utf8_encoding());
     }
 #endif
-    pi->json = rb_string_value_ptr((VALUE*)&input);
-    pi->end = pi->json + RSTRING_LEN(input);
+    pi->json = rb_string_value_ptr((VALUE*)inputp);
+    pi->end = pi->json + RSTRING_LEN(*inputp);
 }
 
 VALUE
@@ -811,7 +826,7 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
 	pi->end = json + len;
 	free_json = 1;
     } else if (T_STRING == rb_type(input)) {
-	oj_pi_set_input_str(pi, input);
+	oj_pi_set_input_str(pi, &input);
     } else if (Qnil == input && Yes == pi->options.nilnil) {
 	return Qnil;
     } else {
@@ -820,7 +835,7 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
 
 	if (oj_stringio_class == clas) {
 	    s = rb_funcall2(input, oj_string_id, 0, 0);
-	    oj_pi_set_input_str(pi, s);
+	    oj_pi_set_input_str(pi, &s);
 #if !IS_WINDOWS
 	} else if (rb_cFile == clas && 0 == FIX2INT(rb_funcall(input, oj_pos_id, 0))) {
 	    int		fd = FIX2INT(rb_funcall(input, oj_fileno_id, 0));

data/ext/oj/parse.h

@@ -93,7 +93,6 @@ typedef struct _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 void	oj_pi_set_input_str(ParseInfo pi, volatile VALUE input);
 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);
 

data/ext/oj/sparse.c

@@ -487,11 +487,22 @@ read_num(ParseInfo pi) {
 	    reader_backup(&pi->rd);
 	}
     }
+    ni.str = pi->rd.str;
+    ni.len = pi->rd.tail - pi->rd.str;
+    // Check for special reserved values for Infinity and NaN.
+    if (ni.big) {
+	if (0 == strcasecmp(INF_VAL, ni.str)) {
+	    ni.infinity = 1;
+	} else if (0 == strcasecmp(NINF_VAL, ni.str)) {
+	    ni.infinity = 1;
+	    ni.neg = 1;
+	} else if (0 == strcasecmp(NAN_VAL, ni.str)) {
+	    ni.nan = 1;
+	}
+    }
     if (BigDec == pi->options.bigdec_load) {
 	ni.big = 1;
     }
-    ni.str = pi->rd.str;
-    ni.len = pi->rd.tail - pi->rd.str;
     add_num_value(pi, &ni);
     reader_release(&pi->rd);
 }