oj 3.9.2 → 3.10.5

data/ext/oj/oj.h

@@ -149,8 +149,10 @@ typedef struct _options {
     char		allow_nan;	// YEsyNo for parsing only
     char		trace;		// YesNo
     char		safe;		// YesNo
-    int64_t		integer_range_min; // dump numbers outside range as string
-    int64_t		integer_range_max;
+    char		sec_prec_set;	// boolean (0 or 1)
+    char		ignore_under;	// YesNo - ignore attrs starting with _ if true in object and custom modes
+    int64_t		int_range_min;	// dump numbers below as string
+    int64_t		int_range_max;	// dump numbers above as string
     const char		*create_id;	// 0 or string
     size_t		create_id_len;	// length of create_id
     int			sec_prec;	// second precision when dumping time

data/ext/oj/parse.c

@@ -400,6 +400,10 @@ read_num(ParseInfo pi) {
 	pi->cur++;
 	ni.neg = 1;
     } else if ('+' == *pi->cur) {
+	if (StrictMode == pi->options.mode) {
+	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
+	    return;
+	}
 	pi->cur++;
     }
     if ('I' == *pi->cur) {
@@ -446,8 +450,13 @@ read_num(ParseInfo pi) {
 	if ('.' == *pi->cur) {
 	    pi->cur++;
 	    // A trailing . is not a valid decimal but if encountered allow it
-	    // except when mimicing the JSON gem.
-	    if (CompatMode == pi->options.mode) {
+	    // except when mimicing the JSON gem or in strict mode.
+	    if (StrictMode == pi->options.mode || CompatMode == pi->options.mode) {
+		int	pos = (int)(pi->cur - ni.str);
+		if (1 == pos || (2 == pos && ni.neg)) {
+		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
+		    return;
+		}
 		if (*pi->cur < '0' || '9' < *pi->cur) {
 		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
 		    return;
@@ -731,7 +740,7 @@ oj_parse2(ParseInfo pi) {
 }
 
 static VALUE
-rescue_big_decimal(VALUE str) {
+rescue_big_decimal(VALUE str, VALUE ignore) {
     rb_raise(oj_parse_error_class, "Invalid value for BigDecimal()");
     return Qnil;
 }
@@ -786,13 +795,13 @@ oj_num_as_value(NumInfo ni) {
 	    }
 	} else {
 	    // All these machinations are to get rounding to work better.
-	    long double	d = (long double)ni->i * (long double)ni->div + (long double)ni->num;
+	    long double	ld = (long double)ni->i * (long double)ni->div + (long double)ni->num;
 	    int		x = (int)((int64_t)ni->exp - ni->di);
 
 	    // Rounding sometimes cuts off the last digit even if there are only
 	    // 15 digits. This attempts to fix those few cases where this
 	    // occurs.
-	    if ((long double)INT64_MAX > d && (int64_t)d != (ni->i * ni->div + ni->num)) {
+	    if ((long double)INT64_MAX > ld && (int64_t)ld != (ni->i * ni->div + ni->num)) {
 		volatile VALUE	bd = rb_str_new(ni->str, ni->len);
 
 		rnum = rb_rescue2(parse_big_decimal, bd, rescue_big_decimal, bd, rb_eException, 0);
@@ -800,16 +809,23 @@ oj_num_as_value(NumInfo ni) {
 		    rnum = rb_funcall(rnum, rb_intern("to_f"), 0);
 		}
 	    } else {
-		d = roundl(d);
+		double	d;
+
+		ld = roundl(ld);
+		// You would expect that staying with a long double would be
+		// more accurate but it fails to match what Ruby generates so
+		// drop down to a double.
 		if (0 < x) {
-		    d *= powl(10.0L, x);
+		    d = (double)ld * pow(10.0, x);
 		} else if (0 > x) {
-		    d /= powl(10.0L, -x);
+		    d = (double)ld / pow(10.0, -x);
+		} else {
+		    d = (double)ld;
 		}
 		if (ni->neg) {
 		    d = -d;
 		}
-		rnum = rb_float_new((double)d);
+		rnum = rb_float_new(d);
 	    }
 	}
     }
@@ -1050,7 +1066,7 @@ CLEANUP:
 	    }
 	    args[0] = msg;
 	    if (pi->err.clas == oj_parse_error_class) {
-		// The error was an Oj::ParseError so change to a JSON::ParseError.
+		// The error was an Oj::ParseError so change to a JSON::ParserError.
 		pi->err.clas = oj_json_parser_error_class;
 	    }
 	    rb_exc_raise(rb_class_new_instance(1, args, pi->err.clas));

data/ext/oj/parse.h

@@ -80,6 +80,7 @@ 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_custom_callbacks(ParseInfo pi);
 extern void	oj_set_wab_callbacks(ParseInfo pi);
 
 extern void	oj_sparse2(ParseInfo pi);

data/ext/oj/rails.c

@@ -87,7 +87,8 @@ copy_opts(ROptTable src, ROptTable dest) {
 }
 
 static int
-dump_attr_cb(ID key, VALUE value, Out out) {
+dump_attr_cb(ID key, VALUE value, VALUE ov) {
+    Out		out = (Out)ov;
     int		depth = out->depth;
     size_t	size = depth * out->indent + 1;
     const char	*attr = rb_id2name(key);
@@ -214,6 +215,8 @@ 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);
     } else if (Yes == out->opts->bigdec_as_num) {
 	oj_dump_raw(str, (int)RSTRING_LEN(rstr), out);
     } else {
@@ -1012,6 +1015,7 @@ rails_encode(int argc, VALUE *argv, VALUE self) {
 static VALUE
 rails_use_standard_json_time_format(VALUE self, VALUE state) {
     if (Qtrue == state || Qfalse == state) {
+	// no change needed
     } else if (Qnil == state) {
 	state = Qfalse;
     } else {
@@ -1023,6 +1027,11 @@ rails_use_standard_json_time_format(VALUE self, VALUE state) {
     return state;
 }
 
+static VALUE
+rails_use_standard_json_time_format_get(VALUE self) {
+    return xml_time ? Qtrue : Qfalse;
+}
+
 static VALUE
 rails_escape_html_entities_in_json(VALUE self, VALUE state) {
     rb_iv_set(self, "@escape_html_entities_in_json", state);
@@ -1031,10 +1040,16 @@ rails_escape_html_entities_in_json(VALUE self, VALUE state) {
     return state;
 }
 
+static VALUE
+rails_escape_html_entities_in_json_get(VALUE self) {
+    return escape_html ? Qtrue : Qfalse;
+}
+
 static VALUE
 rails_time_precision(VALUE self, VALUE prec) {
     rb_iv_set(self, "@time_precision", prec);
     oj_default_options.sec_prec = NUM2INT(prec);
+    oj_default_options.sec_prec_set = true;
 
     return prec;
 }
@@ -1053,7 +1068,12 @@ rails_set_encoder(VALUE self) {
     VALUE	encoding;
     VALUE	pv;
     VALUE	verbose;
+    VALUE	enc = resolve_classpath("ActiveSupport::JSON::Encoding");
 
+    if (Qnil != enc) {
+	escape_html = Qtrue == rb_iv_get(self, "@escape_html_entities_in_json");
+	xml_time = Qtrue == rb_iv_get(enc, "@use_standard_json_time_format");
+    }
     if (rb_const_defined_at(rb_cObject, rb_intern("ActiveSupport"))) {
 	active = rb_const_get_at(rb_cObject, rb_intern("ActiveSupport"));
     } else {
@@ -1070,14 +1090,19 @@ rails_set_encoder(VALUE self) {
     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, "use_standard_json_time_format");
+    rb_define_module_function(encoding, "use_standard_json_time_format", rails_use_standard_json_time_format_get, 0);
 
     pv = rb_iv_get(encoding, "@escape_html_entities_in_json");
     escape_html = Qtrue == pv;
     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);
+    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_get, 0);
 
     pv = rb_iv_get(encoding, "@time_precision");
     oj_default_options.sec_prec = NUM2INT(pv);
+    oj_default_options.sec_prec_set = true;
     rb_undef_method(encoding, "time_precision=");
     rb_define_module_function(encoding, "time_precision=", rails_time_precision, 1);
     rb_gv_set("$VERBOSE", verbose);
@@ -1285,7 +1310,8 @@ dump_array(VALUE a, int depth, Out out, bool as_ok) {
 }
 
 static int
-hash_cb(VALUE key, VALUE value, Out out) {
+hash_cb(VALUE key, VALUE value, VALUE ov) {
+    Out		out = (Out)ov;
     int		depth = out->depth;
     long	size;
     int		rtype = rb_type(key);
@@ -1398,14 +1424,17 @@ dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void
 dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
+    VALUE	clas;
+
     if (oj_code_dump(oj_compat_codes, obj, depth, out)) {
 	out->argc = 0;
 	return;
     }
+    clas = rb_obj_class(obj);
     if (as_ok) {
 	ROpt	ro;
 
-	if (NULL != (ro = oj_rails_get_opt(out->ropts, rb_obj_class(obj))) && ro->on) {
+	if (NULL != (ro = oj_rails_get_opt(out->ropts, clas)) && ro->on) {
 	    ro->dump(obj, depth, out, as_ok);
 	} else if (Yes == out->opts->raw_json && rb_respond_to(obj, oj_raw_json_id)) {
 	    oj_dump_raw_json(obj, depth, out);
@@ -1413,6 +1442,8 @@ dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
 	    dump_as_json(obj, depth, out, true);
 	} else if (rb_respond_to(obj, oj_to_hash_id)) {
 	    dump_to_hash(obj, depth, out);
+	} else if (oj_bigdecimal_class == clas) {
+	    dump_bigdecimal(obj, depth, out, false);
 	} else {
 	    oj_dump_obj_to_s(obj, out);
 	}
@@ -1421,6 +1452,8 @@ dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
     } else if (rb_respond_to(obj, oj_to_hash_id)) {
 	// Always attempt to_hash.
 	dump_to_hash(obj, depth, out);
+    } else if (oj_bigdecimal_class == clas) {
+	dump_bigdecimal(obj, depth, out, false);
     } else {
 	oj_dump_obj_to_s(obj, out);
     }
@@ -1439,7 +1472,7 @@ static DumpFunc	rails_funcs[] = {
     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_as_string,	// 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

data/ext/oj/sparse.c

@@ -773,6 +773,7 @@ oj_sparse2(ParseInfo pi) {
 		first = 0;
 	    }
 	    start = pi->rd.pos;
+	    // TBD break if option set to allow that
 	}
     }
 }
@@ -899,7 +900,7 @@ CLEANUP:
 	    VALUE	args[] = { oj_encode(rb_str_new2(pi->err.msg)) };
 
 	    if (pi->err.clas == oj_parse_error_class) {
-		// The error was an Oj::ParseError so change to a JSON::ParseError.
+		// The error was an Oj::ParseError so change to a JSON::ParserError.
 		pi->err.clas = oj_json_parser_error_class;
 	    }
 	    rb_exc_raise(rb_class_new_instance(1, args, pi->err.clas));

data/ext/oj/wab.c

@@ -148,11 +148,12 @@ dump_array(VALUE a, int depth, Out out, bool as_ok) {
 }
 
 static int
-hash_cb(VALUE key, VALUE value, Out out) {
+hash_cb(VALUE key, VALUE value, VALUE ov) {
+    Out		out = (Out)ov;
     int		depth = out->depth;
     long	size;
     int		rtype = rb_type(key);
-    
+
     if (rtype != T_SYMBOL) {
 	rb_raise(rb_eTypeError, "In :wab mode all Hash keys must be Symbols, not %s.\n", rb_class2name(rb_obj_class(key)));
     }
@@ -270,7 +271,7 @@ static DumpFunc	wab_funcs[] = {
 void
 oj_dump_wab_val(VALUE obj, int depth, Out out) {
     int	type = rb_type(obj);
-    
+
     if (Yes == out->opts->trace) {
 	oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceIn);
     }
@@ -324,7 +325,7 @@ add_value(ParseInfo pi, VALUE val) {
 static bool
 uuid_check(const char *str, int len) {
     int		i;
-    
+
     for (i = 0; i < 8; i++, str++) {
 	if ('x' != hex_chars[*(uint8_t*)str]) {
 	    return false;
@@ -380,7 +381,7 @@ time_parse(const char *s, int len) {
     long	nsecs = 0;
     int		i;
     time_t	secs;
-    
+
     memset(&tm, 0, sizeof(tm));
     if ('-' == *s) {
 	s++;
@@ -444,7 +445,7 @@ protect_uri(VALUE rstr) {
 static VALUE
 cstr_to_rstr(const char *str, size_t len) {
     volatile VALUE	v = Qnil;
-    
+
     if (30 == len && '-' == str[4] && '-' == str[7] && 'T' == str[10] && ':' == str[13] && ':' == str[16]  && '.' == str[19] && 'Z' == str[29]) {
 	if (Qnil != (v = time_parse(str, (int)len))) {
 	    return v;
@@ -521,7 +522,7 @@ hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char
 static void
 hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
     volatile VALUE	rval = Qnil;
-    
+
     if (ni->infinity || ni->nan) {
 	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
@@ -551,7 +552,7 @@ start_array(ParseInfo pi) {
 static void
 array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
     volatile VALUE	rval = cstr_to_rstr(str, len);
-    
+
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
     if (Yes == pi->options.trace) {
 	oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, rval);
@@ -628,4 +629,3 @@ oj_wab_parse_cstr(int argc, VALUE *argv, char *json, size_t len) {
 
     return oj_pi_parse(argc, argv, &pi, json, len, true);
 }
-

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module.
-  VERSION = '3.9.2'
+  VERSION = '3.10.5'
 end

data/pages/Rails.md

@@ -26,44 +26,44 @@ directly. If Rails mode is also desired then use the `Oj.default_options` to
 change the default mode.
 
 Some of the Oj options are supported as arguments to the encoder if called
-from Oj::Rails.encode() but when using the Oj::Rails::Encoder class the
-encode() method does not support optional arguments as required by the
+from `Oj::Rails.encode()` but when using the `Oj::Rails::Encoder` class the
+`encode()` method does not support optional arguments as required by the
 ActiveSupport compliance guidelines. The general approach Rails takes for
 configuring encoding options is to either set global values or to create a new
 instance of the Encoder class and provide options in the initializer.
 
 The globals that ActiveSupport uses for encoding are:
 
- * ActiveSupport::JSON::Encoding.use_standard_json_time_format
- * ActiveSupport::JSON::Encoding.escape_html_entities_in_json
- * ActiveSupport::JSON::Encoding.time_precision
- * ActiveSupport::JSON::Encoding.json_encoder
+ * `ActiveSupport::JSON::Encoding.use_standard_json_time_format`
+ * `ActiveSupport::JSON::Encoding.escape_html_entities_in_json`
+ * `ActiveSupport::JSON::Encoding.time_precision`
+ * `ActiveSupport::JSON::Encoding.json_encoder`
 
 Those globals are aliased to also be accessed from the ActiveSupport module
-directly so ActiveSupport::JSON::Encoding.time_precision can also be accessed
-from ActiveSupport.time_precision. Oj makes use of these globals in mimicing
-Rails after the Oj::Rails.set_encode() method is called. That also sets the
-ActiveSupport.json_encoder to the Oj::Rails::Encoder class.
+directly so `ActiveSupport::JSON::Encoding.time_precision` can also be accessed
+from `ActiveSupport.time_precision`. Oj makes use of these globals in mimicing
+Rails after the `Oj::Rails.set_encode()` method is called. That also sets the
+`ActiveSupport.json_encoder` to the `Oj::Rails::Encoder` class.
 
-Options passed into a call to to_json() are passed to the as_json()
+Options passed into a call to `to_json()` are passed to the `as_json()`
 methods. These are mostly ignored by Oj and simply passed on without
 modifications as per the guidelines. The exception to this are the options
-specific to Oj such as the :circular option which it used to detect circular
+specific to Oj such as the `:circular` option which it used to detect circular
 references while encoding.
 
 By default Oj acts like the ActiveSupport encoder and honors any changes in
-the as_json() methods. There are some optimized Oj encoders for some
-classes. When the optimized encoder it toggled the as_json() methods will not
+the `as_json()` methods. There are some optimized Oj encoders for some
+classes. When the optimized encoder it toggled the `as_json()` methods will not
 be called for that class but instead the optimized version will be called. The
 optimized version is the same as the ActiveSupport default encoding for a
-given class. The optimized versions are toggled with the optimize() and
-deoptimize() methods. There is a default optimized version for every class
+given class. The optimized versions are toggled with the `optimize()` and
+`deoptimize()` methods. There is a default optimized version for every class
 that takes the visible attributes and encodes them but that may not be the
 same as what Rails uses. Trial and error is the best approach for classes not
 listed here.
 
 The classes that can be put in optimized mode and are optimized when
-Oj::Rails.optimize is called with no arguments are:
+`Oj::Rails.optimize` is called with no arguments are:
 
  * Array
  * BigDecimal
@@ -77,8 +77,47 @@ Oj::Rails.optimize is called with no arguments are:
  * any class inheriting from ActiveRecord::Base
  * any other class where all attributes should be dumped
 
-The ActiveSupport decoder is the JSON.parse() method. Calling the
-Oj::Rails.set_decoder() method replaces that method with the Oj equivalent.
+The ActiveSupport decoder is the `JSON.parse()` method. Calling the
+`Oj::Rails.set_decoder()` method replaces that method with the Oj equivalent.
+
+### Usage in Rails 3
+
+To support Rails 3 you can create a new module mixin to prepend to controllers:
+
+```ruby
+require 'oj'
+
+module OjJsonEncoder
+  def render(options = nil, extra_options = {}, &block)
+    if options && options.is_a?(Hash) && options[:json]
+      obj = options.delete(:json)
+      obj = Oj.dump(obj, :mode => :rails) unless obj.is_a?(String)
+      options[:text] = obj
+      response.content_type ||= Mime::JSON
+    end
+    super
+  end
+end
+```
+
+Usage:
+
+```ruby
+class MyController < ApplicationController
+  prepend OjJsonEncoder
+  def index
+    render :json => { :hello => 'world' }
+  end
+end
+```
+
+### Older Ruby Version Support (Pre 2.3.0)
+
+If you are using an older version of Ruby, you can pin `oj` to an earlier version in your Gemfile:
+
+```ruby
+gem 'oj', '3.7.12'
+```
 
 ### Notes:
 
@@ -87,8 +126,8 @@ Oj::Rails.set_decoder() method replaces that method with the Oj equivalent.
    significant digits which can be either 16 or 17 depending on the value.
 
 2. Optimized Hashs do not collapse keys that become the same in the output. As
-   an example, a non-String object that has a to_s() method will become the
-   return value of the to_s() method in the output without checking to see if
+   an example, a non-String object that has a `to_s()` method will become the
+   return value of the `to_s()` method in the output without checking to see if
    that has already been used. This could occur is a mix of String and Symbols
    are used as keys or if a other non-String objects such as Numerics are mixed
    with numbers as Strings.