oj 2.5.5 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75e4043274574e794d054c174097302ccb304834
-  data.tar.gz: 3088bfa698221df3861f69b262533c5e177c732b
+  metadata.gz: 88d1b989da1bbd42c7fa90ba96baa9c71f289631
+  data.tar.gz: 2d1643092b53fbf33db538856179f7385516346e
 SHA512:
-  metadata.gz: 52c90ff21f5800a96ae30c48eb6fd7c3c4fb1c8c4fd643ae614c66ea94095e742651e716b1ffc7e8e818bc9d8522169dd7c6a50d13fca78e32113bc8be31bf38
-  data.tar.gz: 3d2371fcca9ff478b420292b3f6d6b4739dff8e45e25b8daa4a3d396ded515db17d19b87aa8c555c025d5d1f5437d52555379f2c2e9c66fcd535b1ac1cc26847
+  metadata.gz: 6433a3aa13a1afdabda2e44c732cc85989a38772702edf5ca70a984e9dbdc275f7a255cb405897e8b6898aced26490f11c17b55413638dd885bba2c9a7ed8a54
+  data.tar.gz: 79540125a8c5a1553622f786e5aee3a12c8e256060f545a87ae0d9bb5896ab7dc0e5bb4bcdc1f72d6a354d35c5a536adb8cde20bc11a128464405460b8e8a112

data/README.md

@@ -2,7 +2,13 @@
 A fast JSON parser and Object marshaller as a Ruby gem.
 
 ## Installation
-    gem install oj
+```
+gem install oj
+```
+or in Bundler:
+```
+gem 'oj'
+```
 
 ## Documentation
 
@@ -20,80 +26,82 @@ Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announceme
 
 [![Build Status](https://secure.travis-ci.org/ohler55/oj.png?branch=master)](http://travis-ci.org/ohler55/oj)
 
-### Current Release 2.5.5
-
- - Worked around the Rubinius failure to load bigdecimal from a require within
-   the C code.
-
-### Current Release 2.5.4
+### Current Release 2.6.0
 
- - Fixed bug where unterminated JSON did not raise an exception.
+ - Added the `:use_to_json` option for Oj.dump(). If this option is set to false
+   the `to_json()` method on objects will not be calledwhen dumping. This is the
+   default behavior. The reason behind the option and change is to better
+   support Rails and ActiveSupport. Previous works arounds have been removed.
 
 [Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
 
 ## Description
 
-Optimized JSON (Oj), as the name implies was written to provide speed optimized
-JSON handling. It was designed as a faster alternative to Yajl and other the
-common Ruby JSON parsers. So far is has achieved that at about 2 time faster
-than any other Ruby JSON parser and 3 or more times faster writing JSON.
+Optimized JSON (Oj), as the name implies, was written to provide speed optimized
+JSON handling. It was designed as a faster alternative to Yajl and other
+common Ruby JSON parsers. So far it has achieved that, and is about 2 times faster
+than any other Ruby JSON parser, and 3 or more times faster at serializing JSON.
 
-Oj has several dump or serialization modes which control how Objects are
-converted to JSON. These modes are set with the :mode option in either the
-default options or as one of the options to the dump() method. The default mode
-is the :object mode.
+Oj has several `dump` or serialization modes which control how Ruby `Object`s are
+converted to JSON. These modes are set with the `:mode` option in either the
+default options or as one of the options to the `dump` method. The default mode
+is the `:object` mode.
 
-- :strict mode will only allow the 7 basic JSON types to be serialized. Any
-  other Object will raise and Exception.
+- `:strict` mode will only allow the 7 basic JSON types to be serialized. Any
+  other `Object` will raise an `Exception`.
 
-- :null mode replaces any Object that is not one of the JSON types is replaced by a JSON null.
+- `:null` mode replaces any `Object` that is not one of the JSON types with a JSON `null`.
 
-- :object mode will dump any Object as a JSON Object with keys that match the
-  Ruby Object's variable names without the '@' character. This is the highest
+- `:object` mode will dump any `Object` as a JSON `Object` with keys that match the
+  Ruby `Object`'s variable names without the '@' prefix character. This is the highest
   performance mode.
 
-- :compat mode is is the compatible with other systems. It will serialize any
-  Object but will check to see if the Object implements a to_hash() or to_json()
-  method. If either exists that method is used for serializing the Object. The
-  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.
+- `:compat` mode attempts to be compatible with other systems. It will serialize any
+  `Object`, but will check to see if the `Object` implements an `as_hash` or `to_json`
+  method. If either exists, that method is used for serializing the `Object`.
+  Since `as_json` is more flexible and produces more consistent output, it is
+  preferred over the `to_json` method. If neither the `to_json` or `to_hash`
+  methods exists, then the Oj internal `Object` variable encoding is used.
 
-Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, and RBX. Support for
+
+## Compatibility
+
+### Ruby
+Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1.1 and RBX. Support for
 JRuby has been removed as JRuby no longer supports C extensions and there are
 bugs in the older versions that are not being fixed.
 
-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.
-
-Oj offers a few alternative APIs for processing JSON. The fastest one is the Oj::Doc API. The Oj::Doc API takes a
-completely different approach by opening a JSON document and providing calls to navigate around the JSON while it is
-open. With this approach JSON access can be well over 20 times faster than conventional JSON parsing.
+### Rails
+Although up until 4.1 Rails uses [multi_json](https://github.com/intridea/multi_json), an [issue in Rails](https://github.com/rails/rails/issues/9212) causes ActiveSupport to fail to make use Oj for JSON handling.
+There is a
+[gem to patch this](https://github.com/GoodLife/rails-patch-json-encode) for
+Rails 3.2 and 4.0. As of the Oj 2.6.0 release the default behavior is to not use
+the `to_json()` method unless the `:use_to_json` option is set. This provides
+another work around to the rails older and newer behavior.
 
-Other parsers, the Oj::Saj and the Oj::ScHandler API are callback parsers that
-walk the JSON document depth first and makes callbacks for each element. Both
-callback parser are useful when only portions of the JSON are of
-interest. Performance up to 20 times faster than conventional JSON are
-possible. The API is simple to use but does require a different approach than
-the conventional parse followed by access approach used by conventional JSON
-parsing.
+In version Rails 4.1, multi_json has been removed, and this patch is unnecessary and will no longer work.
+Instead, use the `oj_mimic_json` [gem](https://github.com/ohler55/oj_mimic_json) along with `oj` in your `Gemfile` to have Oj mimic the JSON gem and be used in its place by `ActiveSupport` JSON handling:
+```
+gem 'oj'
+gem 'oj_mimic_json'
+```
 
 ## Proper Use
 
-Two settings in Oj are useful for parsing but do expose a vunerability if used from an untrusted source. Symbolizing
-keys can be used to cause memory to be filled up since Ruby does not garbage collect Symbols. The same is true for auto
-defining classes. Memory can be exhausted if too many classes are automatically defined. Auto defining is a useful
-feature during development and from trusted sources but it does allow too many classes to be created in the object load
-mode and auto defined is used with an untrusted source. The Oj.strict_load() method sets uses the most strict and safest
-options. It should be used by developers who find it difficult to understand the options available in Oj.
+Two settings in Oj are useful for parsing but do expose a vunerability if used from an untrusted source. Symbolized
+keys can cause memory to be filled since Ruby does not garbage collect Symbols. The same is true for auto
+defining classes; memory will also be exhausted if too many classes are automatically defined. Auto defining is a useful
+feature during development and from trusted sources but it allows too many classes to be created in the object load
+mode and auto defined is used with an untrusted source. The `Oj.strict_load()` method sets and uses the most strict and safest options. It should be used by developers who find it difficult to understand the options available in Oj.
 
 The options in Oj are designed to provide flexibility to the developer. This flexibility allows Objects to be serialized
 and deserialized. No methods are ever called on these created Objects but that does not stop the developer from calling
-methods on the Objects created. As in any system, check your inputs before working with them. Taking an arbitrary String
-from a user and evaluating it is never a good idea from an unsecure source. The same is true for Object attributes as
-they are not more than Strings. Always check inputs from untrusted sources.
+methods on them. As in any system, check your inputs before working with them. Taking an arbitrary `String`
+from a user and evaluating it is never a good idea from an unsecure source. The same is true for `Object` attributes as
+they are not more than `String`s. Always check inputs from untrusted sources.
 
-## Simple JSON Writing and Parsing:
+
+## Simple JSON Writing and Parsing Example
 
 ```ruby
 require 'oj'
@@ -115,6 +123,21 @@ puts "Same? #{h == h2}"
 # true
 ```
 
+## Alternative JSON Processing APIs
+
+Oj offers a few alternative APIs for processing JSON. The fastest one is the `Oj::Doc` API. The `Oj::Doc` API takes a
+completely different approach by opening a JSON document and providing calls to navigate around the JSON while it is
+open. With this approach, JSON access can be well over 20 times faster than conventional JSON parsing.
+
+The `Oj::Saj` and `Oj::ScHandler` APIs are callback parsers that
+walk the JSON document depth first and makes callbacks for each element.
+Both callback parser are useful when only portions of the JSON are of
+interest. Performance up to 20 times faster than conventional JSON is
+possible. The API is simple to use but does require a different approach than
+the conventional parse followed by access approach used by conventional JSON
+parsing.
+
+
 # Links
 
 ## Performance Comparisons

data/ext/oj/dump.c

@@ -107,11 +107,6 @@ static void	dump_leaf_float(Leaf leaf, Out out);
 static void	dump_leaf_array(Leaf leaf, int depth, Out out);
 static void	dump_leaf_hash(Leaf leaf, int depth, Out out);
 
-// These are used to detect rails re-call of Oj.dump() inside the to_json()
-// method. It is not thread safe.
-static VALUE	last_obj = Qundef;
-static int	oj_rails_hack = -1;
-
 static const char	hex_chars[17] = "0123456789abcdef";
 
 static char	hibit_friendly_chars[256] = "\
@@ -1156,14 +1151,12 @@ dump_data_comp(VALUE obj, int depth, Out out) {
 	dump_hash(h, depth, out->opts->mode, out);
     } else if (rb_respond_to(obj, oj_as_json_id) && obj != (o2 = rb_funcall(obj, oj_as_json_id, 0))) {
 	dump_val(o2, depth, out);
-    } else if (rb_respond_to(obj, oj_to_json_id) && (!oj_rails_hack || last_obj != obj)) {
+    } else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
 	volatile VALUE	rs;
 	const char	*s;
 	int		len;
 
-	last_obj = obj;
 	rs = rb_funcall(obj, oj_to_json_id, 0);
-	last_obj = Qundef;
 	s = rb_string_value_ptr((VALUE*)&rs);
 	len = (int)RSTRING_LEN(rs);
 
@@ -1248,14 +1241,12 @@ dump_obj_comp(VALUE obj, int depth, Out out) {
 	dump_hash(h, depth, out->opts->mode, out);
     } else if (rb_respond_to(obj, oj_as_json_id)) {
 	dump_val(rb_funcall(obj, oj_as_json_id, 0), depth, out);
-    } else if (rb_respond_to(obj, oj_to_json_id) && (!oj_rails_hack || last_obj != obj)) {
+    } else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
 	volatile VALUE	rs;
 	const char	*s;
 	int		len;
 
-	last_obj = obj;
 	rs = rb_funcall(obj, oj_to_json_id, 0);
-	last_obj = Qundef;
 	s = rb_string_value_ptr((VALUE*)&rs);
 	len = (int)RSTRING_LEN(rs);
 
@@ -1731,9 +1722,6 @@ oj_dump_obj_to_json(VALUE obj, Options copts, Out out) {
 	oj_cache8_new(&out->circ_cache);
     }
     out->indent = copts->indent;
-    if (0 > oj_rails_hack) {
-	oj_rails_hack = (rb_const_defined_at(rb_cObject, rb_intern("ActiveSupport")));
-    }
     dump_val(obj, 0, out);
     if (Yes == copts->circular) {
 	oj_cache8_delete(out->circ_cache);

data/ext/oj/oj.c

@@ -118,6 +118,7 @@ static VALUE	strict_sym;
 static VALUE	symbol_keys_sym;
 static VALUE	time_format_sym;
 static VALUE	unix_sym;
+static VALUE	use_to_json_sym;
 static VALUE	xmlschema_sym;
 static VALUE	xss_safe_sym;
 
@@ -154,6 +155,7 @@ struct _Options	oj_default_options = {
     UnixTime,		// time_format
     Yes,		// bigdec_as_num
     AutoDec,		// bigdec_load
+    No,			// to_json
     json_class,		// create_id
     10,			// create_id_len
     9,			// sec_prec
@@ -178,6 +180,7 @@ static VALUE	define_mimic_json(int argc, VALUE *argv, VALUE self);
  * - bigdecimal_load: [:bigdecimal|:float|:auto] load decimals as BigDecimal instead of as a Float. :auto pick the most precise for the number of digits.
  * - create_id: [String|nil] create id for json compatible object encoding, default is 'json_create'
  * - second_precision: [Fixnum|nil] number of digits after the decimal when dumping the seconds portion of time
+ * - use_to_json: [true|false|nil] call to_json() methods on dump, default is false
  * - allow_gc: [true|false|nil] allow or prohibit GC during parsing, default is true (allow)
  * @return [Hash] all current option settings.
  */
@@ -192,6 +195,7 @@ get_def_opts(VALUE self) {
     rb_hash_aset(opts, auto_define_sym, (Yes == oj_default_options.auto_define) ? Qtrue : ((No == oj_default_options.auto_define) ? Qfalse : Qnil));
     rb_hash_aset(opts, symbol_keys_sym, (Yes == oj_default_options.sym_key) ? Qtrue : ((No == oj_default_options.sym_key) ? Qfalse : Qnil));
     rb_hash_aset(opts, bigdecimal_as_decimal_sym, (Yes == oj_default_options.bigdec_as_num) ? Qtrue : ((No == oj_default_options.bigdec_as_num) ? Qfalse : Qnil));
+    rb_hash_aset(opts, use_to_json_sym, (Yes == oj_default_options.to_json) ? Qtrue : ((No == oj_default_options.to_json) ? Qfalse : Qnil));
     rb_hash_aset(opts, allow_gc_sym, (Yes == oj_default_options.allow_gc) ? Qtrue : ((No == oj_default_options.allow_gc) ? Qfalse : Qnil));
     switch (oj_default_options.mode) {
     case StrictMode:	rb_hash_aset(opts, mode_sym, strict_sym);	break;
@@ -251,6 +255,7 @@ get_def_opts(VALUE self) {
  *        :ruby Time.to_s formatted String
  * @param [String|nil] :create_id create id for json compatible object encoding
  * @param [Fixnum|nil] :second_precision number of digits after the decimal when dumping the seconds portion of time
+ * @param [true|false|nil] :use_to_json call to_json() methods on dump, default is false
  * @param [true|false|nil] :allow_gc allow or prohibit GC during parsing, default is true (allow)
  * @return [nil]
  */
@@ -262,6 +267,7 @@ set_def_opts(VALUE self, VALUE opts) {
 	{ symbol_keys_sym, &oj_default_options.sym_key },
 	{ class_cache_sym, &oj_default_options.class_cache },
 	{ bigdecimal_as_decimal_sym, &oj_default_options.bigdec_as_num },
+	{ use_to_json_sym, &oj_default_options.to_json },
 	{ allow_gc_sym, &oj_default_options.allow_gc },
 	{ Qnil, 0 }
     };
@@ -392,6 +398,7 @@ oj_parse_options(VALUE ropts, Options copts) {
 	{ symbol_keys_sym, &copts->sym_key },
 	{ class_cache_sym, &copts->class_cache },
 	{ bigdecimal_as_decimal_sym, &copts->bigdec_as_num },
+	{ use_to_json_sym, &copts->to_json },
 	{ allow_gc_sym, &copts->allow_gc },
 	{ Qnil, 0 }
     };
@@ -1821,6 +1828,7 @@ void Init_oj() {
     symbol_keys_sym = ID2SYM(rb_intern("symbol_keys"));	rb_gc_register_address(&symbol_keys_sym);
     time_format_sym = ID2SYM(rb_intern("time_format"));	rb_gc_register_address(&time_format_sym);
     unix_sym = ID2SYM(rb_intern("unix"));		rb_gc_register_address(&unix_sym);
+    use_to_json_sym = ID2SYM(rb_intern("use_to_json"));	rb_gc_register_address(&use_to_json_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

@@ -135,6 +135,7 @@ typedef struct _Options {
     char	time_format;	// TimeFormat
     char	bigdec_as_num;	// YesNo
     char	bigdec_load;	// BigLoad
+    char	to_json;	// YesNo
     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/lib/oj/version.rb

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

data/test/test_compat.rb

@@ -32,8 +32,8 @@ class Jeez
   end
   alias == eql?
   
-  def to_json(*a)
-    %{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
+  def as_json()
+    {"json_class" => self.class.to_s,"x" => @x,"y" => @y}
   end
 
   def self.json_create(h)

data/test/test_mimic.rb

@@ -31,8 +31,8 @@ class Jam
   end
   alias == eql?
 
-  def to_json()
-    %{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
+  def as_json()
+    {"json_class" => self.class.to_s,"x" => @x,"y" => @y}
   end
 
   def self.json_create(h)

data/test/tests.rb

@@ -134,6 +134,7 @@ class Juice < ::Test::Unit::TestCase
                    :time_format=>:unix,
                    :bigdecimal_as_decimal=>true,
                    :bigdecimal_load=>:auto,
+                   :use_to_json=>false,
                    :allow_gc=>true,
                    :create_id=>'json_class'}, opts)
   end
@@ -151,6 +152,7 @@ class Juice < ::Test::Unit::TestCase
       :time_format=>:unix,
       :bigdecimal_as_decimal=>true,
       :bigdecimal_load=>:auto,
+      :use_to_json=>true,
       :allow_gc=>true,
       :create_id=>'json_class'}
     o2 = {
@@ -165,6 +167,7 @@ class Juice < ::Test::Unit::TestCase
       :time_format=>:ruby,
       :bigdecimal_as_decimal=>false,
       :bigdecimal_load=>:bigdecimal,
+      :use_to_json=>false,
       :allow_gc=>false,
       :create_id=>nil}
     o3 = { :indent => 4 }
@@ -561,12 +564,13 @@ class Juice < ::Test::Unit::TestCase
     assert_equal('null', json)
   end
   def test_json_object_compat
-    Oj.default_options = { :mode => :compat }
+    Oj.default_options = { :mode => :compat, :use_to_json => true }
     obj = Jeez.new(true, 58)
     json = Oj.dump(obj, :indent => 2)
     assert(%{{"json_class":"Jeez","x":true,"y":58}} == json ||
            %{{"json_class":"Jeez","y":58,"x":true}} == json)
     dump_and_load(obj, false)
+    Oj.default_options = { :mode => :compat, :use_to_json => false }
   end
   def test_json_object_create_id
     Oj.default_options = { :mode => :compat, :create_id => 'kson_class' }
@@ -862,15 +866,15 @@ class Juice < ::Test::Unit::TestCase
     assert_equal(Float, bg.class)
     assert_equal(orig.to_f, bg)
   end
-  def test_bigdecimal_compat_to_json
+  def test_bigdecimal_compat_as_json
     orig = BigDecimal.new('80.51')
-    BigDecimal.send(:define_method, :to_json) do
-      %{"this is big"}
+    BigDecimal.send(:define_method, :as_json) do
+      %{this is big}
     end
     json = Oj.dump(orig, :mode => :compat)
     bg = Oj.load(json, :mode => :compat)
     assert_equal("this is big", bg)
-    BigDecimal.send(:remove_method, :to_json) # cleanup
+    BigDecimal.send(:remove_method, :as_json) # cleanup
   end
   def test_bigdecimal_object
     mode = Oj.default_options[:mode]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 2.5.5
+  version: 2.6.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-18 00:00:00.000000000 Z
+date: 2014-03-11 00:00:00.000000000 Z
 dependencies: []
 description: 'The fastest JSON parser and object serializer. '
 email: peter@ohler.com
@@ -123,9 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: oj
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A fast JSON parser and serializer.
 test_files: []
-has_rdoc: true