oj 3.17.5 → 3.17.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62e3d04685cbc7e063801fd45fc2e9c86a3695ac1fff9235d49944fb19a1ba50
-  data.tar.gz: 98cd36664b62b1d774998a5c39d4ea1610fbeb5a4d789de2bd80894bf9121fbe
+  metadata.gz: af3a1f2b343eefacdaeb1f82d4b48fe67bece49e4aae63ad46aa878f726ae3de
+  data.tar.gz: 8cd6e1ac300706f39d434cbbba52ea780a96b761ba2090d3d3624185bc021819
 SHA512:
-  metadata.gz: '029e6458460f15ae5bcbf26bb25ff959b5c3a0b70cf04b5eded0b2ff50930bbd3470b51410590fbf6621640590257360e0d20b290af8c28efbb31ee0a602998b'
-  data.tar.gz: c2442be3533074487f3fa7b7e84fac719748cd3f99c40217dc6f6dbc09600e491b2925905f400e2ac7de5639d78d15f76f01f5865a41dda2f963e6ccfd59223c
+  metadata.gz: e081fafa7bd5af792fef91dc58612d6ea85bdae7b3d709bbd945773a5ad9d1feec4c88e3844aa403098c3fa267814ef61dcbba5fb4d9ee86a239eecf5b3926fa
+  data.tar.gz: 339ba6bedb36fb30a382f8cb5037053a4197d4e9364bb11f50b79ec6ec3002cdd687868e140fec1dacabdc9cfa972a45cfcd6cb8a85e4c4148cd484f56278004

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 3.17.6 - 2026-08-10
+
+- Fixed issue #1092, where the encoder ActiveSupport 8.1 caches with `escape: false` froze the options as they stood before `set_encoder` wrote `time_precision` into them, so `to_json(escape: false)` emitted 9 fractional digits. An options hash that names no option Oj knows no longer detaches an encoder from the defaults. (#1093)
+
 ## 3.17.5 - 2026-07-31
 
 Most of this release comes out of a security review of the C extension. There are no API changes.

data/ext/oj/oj.c

@@ -836,12 +836,14 @@ static const char *make_only_value(VALUE v) {
     return NULL;
 }
 
-static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
-    Options copts = (Options)opts;
-    size_t  len;
+// Apply one key and value to copts. Returns true if the key named an option Oj
+// knows and false if it did not. An unrecognized key is still ignored rather
+// than an error; the return only lets a caller tell the two cases apart.
+static bool parse_one_option(VALUE k, VALUE v, Options copts) {
+    size_t len;
 
     if (set_yesno_options(k, v, copts)) {
-        return ST_CONTINUE;
+        return true;
     }
     if (oj_indent_sym == k) {
         switch (rb_type(v)) {
@@ -967,7 +969,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (bigdecimal_load_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
 
         if (bigdecimal_sym == v || Qtrue == v) {
@@ -983,7 +985,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (compat_bigdecimal_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         copts->compat_bigdec = (Qtrue == v);
     } else if (oj_decimal_class_sym == k) {
@@ -1078,7 +1080,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (nan_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (null_sym == v) {
             copts->dump_opts.nan_dump = NullNan;
@@ -1095,7 +1097,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (omit_nil_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (Qtrue == v) {
             copts->dump_opts.omit_nil = true;
@@ -1106,7 +1108,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (omit_null_byte_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (Qtrue == v) {
             copts->dump_opts.omit_null_byte = true;
@@ -1167,7 +1169,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (integer_range_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         if (rb_obj_class(v) == rb_cRange) {
             VALUE min = rb_funcall(v, oj_begin_id, 0);
@@ -1198,7 +1200,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (symbol_keys_sym == k || oj_symbolize_names_sym == k) {
         if (Qnil == v) {
-            return ST_CONTINUE;
+            return true;
         }
         copts->sym_key = (Qtrue == v) ? Yes : No;
 
@@ -1233,21 +1235,51 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
             OJ_R_FREE((void *)copts->dump_opts.except);
         }
         copts->dump_opts.except = make_only_value(v);
+    } else {
+        return false;
+    }
+    return true;
+}
+
+// Collects the return of parse_one_option() over every key in a hash.
+struct _optsParse {
+    Options copts;
+    bool    consumed;
+};
+
+static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
+    struct _optsParse *op = (struct _optsParse *)opts;
+
+    if (parse_one_option(k, v, op->copts)) {
+        op->consumed = true;
     }
     return ST_CONTINUE;
 }
 
-void oj_parse_options(VALUE ropts, Options copts) {
+// Apply the options in ropts to copts and report whether any key was
+// recognized. A hash of nothing but unknown keys leaves copts untouched and
+// returns false.
+bool oj_parse_options_consumed(VALUE ropts, Options copts) {
+    struct _optsParse op = {copts, false};
+
     if (T_HASH != rb_type(ropts)) {
-        return;
+        return false;
+    }
+    rb_hash_foreach(ropts, parse_options_cb, (VALUE)&op);
+    if (Qnil != rb_hash_lookup(ropts, match_string_sym)) {
+        op.consumed = true;
     }
-    rb_hash_foreach(ropts, parse_options_cb, (VALUE)copts);
     oj_parse_opt_match_string(&copts->str_rx, ropts);
 
     copts->dump_opts.use = (0 < copts->dump_opts.indent_size || 0 < copts->dump_opts.after_size ||
                             0 < copts->dump_opts.before_size || 0 < copts->dump_opts.hash_size ||
                             0 < copts->dump_opts.array_size);
-    return;
+
+    return op.consumed;
+}
+
+void oj_parse_options(VALUE ropts, Options copts) {
+    oj_parse_options_consumed(ropts, copts);
 }
 
 // Free the option buffers that oj_parse_options() allocated for a single call.

data/ext/oj/oj.h

@@ -257,6 +257,7 @@ extern VALUE oj_custom_parse_cstr(int argc, VALUE *argv, char *json, size_t len)
 
 extern bool oj_hash_has_key(VALUE hash, VALUE key);
 extern void oj_parse_options(VALUE ropts, Options copts);
+extern bool oj_parse_options_consumed(VALUE ropts, Options copts);
 extern void oj_free_call_options(Options copts);
 extern void oj_options_take_ownership(Options copts);
 extern void oj_options_release(Options copts);

data/ext/oj/rails.c

@@ -765,11 +765,15 @@ static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
         e->arg = rb_hash_new();
     }
     // An encoder given no options of its own reads oj_default_options at encode
-    // time rather than copying it here. ActiveSupport keeps one option-less
-    // encoder for the life of the process, so a copy taken now would freeze
-    // every later Oj.default_options and ActiveSupport::JSON::Encoding change
-    // out of it - including the time_precision that set_encoder itself writes
-    // after ActiveSupport has already built and cached that encoder.
+    // time rather than copying it here. ActiveSupport keeps such an encoder for
+    // the life of the process, so a copy taken now would freeze every later
+    // Oj.default_options and ActiveSupport::JSON::Encoding change out of it -
+    // including the time_precision that set_encoder itself writes after
+    // ActiveSupport has already built and cached that encoder.
+    //
+    // A hash counts as options only if at least one key names an option Oj
+    // knows. Non-empty is not enough: ActiveSupport 8.1 caches a second encoder
+    // built with {escape: false}, a key Oj has never had.
     e->own_opts = T_HASH == rb_type(e->arg) && 0 < RHASH_SIZE(e->arg);
     if (e->own_opts) {
         e->opts = oj_default_options;
@@ -778,9 +782,13 @@ static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
         // its own that is freed with the encoder.
         e->opts.str_rx.head = NULL;
         e->opts.str_rx.tail = NULL;
-        oj_parse_options(e->arg, &e->opts);
+        e->own_opts         = oj_parse_options_consumed(e->arg, &e->opts);
+    }
+    if (e->own_opts) {
         oj_options_take_ownership(&e->opts);
     } else {
+        // Nothing to free: every option that allocates is reached through a
+        // recognized key, and ownership is not taken until after that check.
         memset(&e->opts, 0, sizeof(e->opts));
     }
 
@@ -1176,8 +1184,6 @@ static VALUE rails_set_encoder(VALUE self) {
     } else {
         rb_raise(rb_eStandardError, "ActiveSupport not loaded.");
     }
-    rb_funcall(active, rb_intern("json_encoder="), 1, encoder_class);
-
     json     = rb_const_get_at(active, rb_intern("JSON"));
     encoding = rb_const_get_at(json, rb_intern("Encoding"));
 
@@ -1204,6 +1210,12 @@ static VALUE rails_set_encoder(VALUE self) {
     rb_define_module_function(encoding, "time_precision=", rails_time_precision, 1);
     rb_gv_set("$VERBOSE", verbose);
 
+    // Last, because ActiveSupport builds and caches encoders inside
+    // json_encoder= and they should see the settings above already in the
+    // defaults. escape_html and xml_time are read ahead of it for the same
+    // reason.
+    rb_funcall(active, rb_intern("json_encoder="), 1, encoder_class);
+
     return Qnil;
 }
 

data/lib/oj/version.rb

@@ -1,4 +1,4 @@
 module Oj
   # Current version of the module.
-  VERSION = '3.17.5'
+  VERSION = '3.17.6'
 end

data/pages/Rails.md

@@ -91,6 +91,10 @@ The classes that can be put in optimized mode and are optimized when
 
 Both `Oj::Rails` and each `Oj::Rails::Encoder` have `optimize()`, `deoptimize()`, and `optimized?()` methods. The module level methods change the setting for the whole process. An encoder follows those process wide settings until `optimize()` or `deoptimize()` is called on the encoder itself. From then on the encoder keeps a set of its own and later module level changes do not reach it.
 
+Options work the same way. An encoder reads `Oj.default_options` when it encodes, so later changes to the defaults reach it, unless it was given options of its own, in which case it keeps the copy it took when it was created. An encoder counts as having options of its own only if the hash it was built with names at least one option Oj knows. A hash of nothing but keys Oj does not have, such as the `escape: false` ActiveSupport 8.1 builds one of its cached encoders with, leaves the encoder on the defaults.
+
+Once a class is optimized its `as_json()` method is no longer called, so an application that defines its own `as_json()` on an optimized class, `BigDecimal` for example, will not see it used. Call `Oj::Rails.deoptimize(BigDecimal)` after `Oj.optimize_rails` to put that one class back on the `as_json()` path and leave the rest optimized.
+
 The ActiveSupport decoder is the `JSON.parse()` method. Calling the
 `Oj::Rails.set_decoder()` method replaces that method with the Oj equivalent.
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.17.5
+  version: 3.17.6
 platform: ruby
 authors:
 - Peter Ohler