oj 3.17.4 → 3.17.5

data/ext/oj/sparse.c

@@ -290,13 +290,13 @@ static void read_escaped_str(ParseInfo pi) {
         case NEXT_HASH_NEW:
         case NEXT_HASH_KEY:
             if (Qundef == (parent->key_val = pi->hash_key(pi, buf.head, buf_len(&buf)))) {
-                parent->klen = buf_len(&buf);
-                parent->key  = malloc(parent->klen + 1);
-                memcpy((char *)parent->key, buf.head, parent->klen);
-                *(char *)(parent->key + parent->klen) = '\0';
+                parent->klen   = buf_len(&buf);
+                parent->key    = oj_strndup(buf.head, parent->klen);
+                parent->kalloc = 1;
             } else {
-                parent->key  = "";
-                parent->klen = 0;
+                parent->key    = "";
+                parent->klen   = 0;
+                parent->kalloc = 0;
             }
             parent->k1   = *pi->rd.str;
             parent->next = NEXT_HASH_COLON;
@@ -906,6 +906,7 @@ CLEANUP:
     if (0 != pi->circ_array) {
         oj_circ_array_free(pi->circ_array);
     }
+    reader_cleanup(&pi->rd);
     stack_cleanup(&pi->stack);
     // A :match_string option builds a chain of regexps for this call that has to
     // be freed. Without the option the member aliases the chain owned by the

data/ext/oj/string_writer.c

@@ -78,6 +78,8 @@ void oj_str_writer_init(StrWriter sw, int buf_size) {
     sw->out.argv       = NULL;
     sw->out.ropts      = NULL;
     sw->out.omit_nil   = oj_default_options.dump_opts.omit_nil;
+    // oj_str_writer_init does not call oj_out_init, so clear this here too.
+    sw->out.key_filter_off = false;
 }
 
 void oj_str_writer_push_key(StrWriter sw, const char *key) {

data/ext/oj/usual.c

@@ -831,6 +831,7 @@ static VALUE opt_create_id_set(ojParser p, VALUE value) {
     Usual d = (Usual)p->ctx;
 
     if (Qnil == value) {
+        OJ_R_FREE(d->create_id);
         d->create_id                 = NULL;
         d->create_id_len             = 0;
         p->funcs[OBJECT_FUN].add_str = add_str_key;
@@ -850,12 +851,15 @@ static VALUE opt_create_id_set(ojParser p, VALUE value) {
         if (1 << (8 * sizeof(d->create_id_len)) <= len) {
             rb_raise(rb_eArgError, "The create_id values is limited to %d bytes.", 1 << (8 * sizeof(d->create_id_len)));
         }
-        d->create_id_len                  = (uint8_t)len;
+        char *prev = d->create_id;
+
         d->create_id                      = str_dup(RSTRING_PTR(value), len);
+        d->create_id_len                  = (uint8_t)len;
         p->funcs[OBJECT_FUN].add_str      = add_str_key_create;
         p->funcs[TOP_FUN].close_object    = close_object_create;
         p->funcs[ARRAY_FUN].close_object  = close_object_create;
         p->funcs[OBJECT_FUN].close_object = close_object_create;
+        OJ_R_FREE(prev);
     }
     return opt_create_id(p, value);
 }

data/ext/oj/util.c

@@ -134,3 +134,30 @@ void sec_as_time(int64_t secs, TimeInfo ti) {
     secs     = secs - (int64_t)ti->min * 60LL;
     ti->sec  = (int)secs;
 }
+
+// The inverse of sec_as_time(). The days are counted with the civil calendar
+// algorithm from Howard Hinnant's date library so that no libc call is needed.
+// timegm() is not available on Windows and the mktime() based replacement that
+// was used there returned the wrong value in any timezone east of UTC.
+int64_t time_as_sec(TimeInfo ti) {
+    int64_t year = (int64_t)ti->year;
+    int64_t mon  = (int64_t)ti->mon;
+    int64_t era;
+    int64_t yoe;   // year of the era, [0, 399]
+    int64_t doy;   // day of the year, [0, 365]
+    int64_t doe;   // day of the era, [0, 146096]
+    int64_t days;  // days since 1970-01-01
+
+    // Start the year on March 1st so that a leap day falls on the last day of
+    // the year and the day of the year is a simple expression.
+    if (mon <= 2) {
+        year--;
+    }
+    era  = (0 <= year ? year : year - 399) / 400;
+    yoe  = year - era * 400;
+    doy  = (153 * (mon + (2 < mon ? -3 : 9)) + 2) / 5 + (int64_t)ti->day - 1;
+    doe  = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    days = era * 146097 + doe - 719468;
+
+    return days * SECS_PER_DAY + (int64_t)ti->hour * 3600LL + (int64_t)ti->min * 60LL + (int64_t)ti->sec;
+}

data/ext/oj/util.h

@@ -15,6 +15,7 @@ typedef struct _timeInfo {
     int year;
 }* TimeInfo;
 
-extern void sec_as_time(int64_t secs, TimeInfo ti);
+extern void    sec_as_time(int64_t secs, TimeInfo ti);
+extern int64_t time_as_sec(TimeInfo ti);
 
 #endif /* OJ_UTIL_H */

data/ext/oj/val_stack.h

@@ -35,8 +35,8 @@ typedef struct _val {
     const char    *classname;
     VALUE          clas;
     OddArgs        odd_args;
-    uint16_t       klen;
-    uint16_t       clen;
+    size_t         klen;
+    size_t         clen;
     char           next;  // ValNext
     char           k1;    // first original character in the key
     char           kalloc;
@@ -62,6 +62,16 @@ inline static int stack_empty(ValStack stack) {
 }
 
 inline static void stack_cleanup(ValStack stack) {
+    Val v;
+
+    // end_hash() frees the args of a completed odd class. Anything still here
+    // belongs to a parse that was abandoned part way through.
+    for (v = stack->head; v < stack->tail; v++) {
+        if (NULL != v->odd_args) {
+            oj_odd_free(v->odd_args);
+            v->odd_args = NULL;
+        }
+    }
     if (stack->base != stack->head) {
         OJ_R_FREE(stack->head);
         stack->head = NULL;
@@ -70,9 +80,11 @@ inline static void stack_cleanup(ValStack stack) {
 
 inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
     if (stack->end <= stack->tail) {
-        size_t len  = stack->end - stack->head;
-        size_t toff = stack->tail - stack->head;
-        Val    head = stack->head;
+        size_t      len  = stack->end - stack->head;
+        size_t      toff = stack->tail - stack->head;
+        Val         head = stack->head;
+        const char *old  = (const char *)stack->head;
+        size_t      i;
 
         // A realloc can trigger a GC so make sure it happens outside the lock
         // but lock before changing pointers.
@@ -82,6 +94,13 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
         } else {
             OJ_R_REALLOC_N(head, struct _val, len + STACK_INC);
         }
+        // A key short enough to be kept in the Val itself points into the
+        // block that just moved.
+        for (i = 0; i < toff; i++) {
+            if (old <= head[i].key && head[i].key < old + sizeof(struct _val) * len) {
+                head[i].key = head[i].karray;
+            }
+        }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_lock(&stack->mutex);
 #else

data/ext/oj/wab.c

@@ -375,44 +375,41 @@ static const char *read_num(const char *s, int len, int *vp) {
 }
 
 static VALUE time_parse(const char *s, int len) {
-    struct tm tm;
-    bool      neg   = false;
-    long      nsecs = 0;
-    int       i;
-    time_t    secs;
+    struct _timeInfo ti;
+    bool             neg   = false;
+    long             nsecs = 0;
+    int              i;
 
-    memset(&tm, 0, sizeof(tm));
+    memset(&ti, 0, sizeof(ti));
     if ('-' == *s) {
         s++;
         neg = true;
     }
-    if (NULL == (s = read_num(s, 4, &tm.tm_year))) {
+    if (NULL == (s = read_num(s, 4, &ti.year))) {
         return Qnil;
     }
     if (neg) {
-        tm.tm_year = -tm.tm_year;
-        neg        = false;
+        ti.year = -ti.year;
+        neg     = false;
     }
-    tm.tm_year -= 1900;
     s++;
-    if (NULL == (s = read_num(s, 2, &tm.tm_mon))) {
+    if (NULL == (s = read_num(s, 2, &ti.mon))) {
         return Qnil;
     }
-    tm.tm_mon--;
     s++;
-    if (NULL == (s = read_num(s, 2, &tm.tm_mday))) {
+    if (NULL == (s = read_num(s, 2, &ti.day))) {
         return Qnil;
     }
     s++;
-    if (NULL == (s = read_num(s, 2, &tm.tm_hour))) {
+    if (NULL == (s = read_num(s, 2, &ti.hour))) {
         return Qnil;
     }
     s++;
-    if (NULL == (s = read_num(s, 2, &tm.tm_min))) {
+    if (NULL == (s = read_num(s, 2, &ti.min))) {
         return Qnil;
     }
     s++;
-    if (NULL == (s = read_num(s, 2, &tm.tm_sec))) {
+    if (NULL == (s = read_num(s, 2, &ti.sec))) {
         return Qnil;
     }
     s++;
@@ -424,16 +421,7 @@ static VALUE time_parse(const char *s, int len) {
             return Qnil;
         }
     }
-#if IS_WINDOWS
-    secs = (time_t)mktime(&tm);
-    memset(&tm, 0, sizeof(tm));
-    tm.tm_year = 70;
-    tm.tm_mday = 1;
-    secs -= (time_t)mktime(&tm);
-#else
-    secs = (time_t)timegm(&tm);
-#endif
-    return rb_funcall(rb_time_nano_new(secs, nsecs), oj_utc_id, 0);
+    return rb_funcall(rb_time_nano_new((time_t)time_as_sec(&ti), nsecs), oj_utc_id, 0);
 }
 
 static VALUE protect_uri(VALUE rstr) {

data/lib/oj/version.rb

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

data/pages/Compatibility.md

@@ -2,7 +2,7 @@
 
 **Ruby**
 
-Oj is compatible with Ruby 2.4+ and RBX.
+Oj is compatible with Ruby 2.7+ 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.
 

data/pages/Custom.md

@@ -8,9 +8,8 @@ for object dumping and loading. The `:compat` mode mimic the json gem
 including methods called for encoding and inconsistencies between
 `JSON.dump()`, `JSON.generate()`, and `JSON()`.
 
-The `:custom` mode is the default mode. It can be configured either by passing
-options to the `Oj.dump()` and `Oj.load()` methods or by modifying the default
-options.
+The `:custom` mode can be configured either by passing options to the
+`Oj.dump()` and `Oj.load()` methods or by modifying the default options.
 
 The ability to create objects from JSON object elements is supported and
 considers the `:create_additions` option. Special treatment is given to the

data/pages/InstallOptions.md

@@ -10,11 +10,13 @@ To enable Oj trace feature, it uses `--enable-trace-log` option when installing
 Then, the trace logs will be displayed when `:trace` option is set to `true`.
 
 
-### Enable SIMD instructions
+### SIMD instructions
 
-```
-$ gem install oj -- --with-sse42
-```
+SIMD optimizations are enabled automatically, so no install option is
+required. At runtime Oj detects the CPU features that are available and
+selects the best implementation: SSE4.2 or SSE2 on x86 / x86_64, NEON on ARM,
+and a scalar fallback when none is available.
 
-To enable the use of SIMD instructions in Oj, it uses the `--with-sse42` option when installing the gem.
-This will enable the use of the SSE4.2 instructions in the internal.
+Earlier versions required a `--with-sse42` option at install time to turn on
+SSE4.2. That option has been removed (#982); SSE4.2 is now selected
+automatically when the CPU supports it.

data/pages/Modes.md

@@ -121,7 +121,7 @@ information.
 | :object_nl             | String  |         |         |       x |       x |         |       x |         |
 | :omit_nil              | Boolean |       x |       x |       x |       x |       x |       x |         |
 | :quirks_mode           | Boolean |         |         |       6 |         |         |       x |         |
-| :safe                  | String  |         |         |       x |         |         |         |         |
+| :safe                  | Boolean |         |         |       x |         |         |         |         |
 | :second_precision      | Fixnum  |         |         |         |         |       x |       x |         |
 | :space                 | String  |         |         |       x |       x |         |       x |         |
 | :space_before          | String  |         |         |       x |       x |         |       x |         |

data/pages/Options.md

@@ -213,8 +213,7 @@ for json gem compatibility.
 
 Primary behavior for loading and dumping. The :mode option controls which
 other options are in effect. For more details see the {file:Modes.md} page. By
-default Oj uses the :custom mode which is provides the highest degree of
-customization.
+default Oj uses the :object mode.
 
 ### :nan [Symbol]
 
@@ -249,6 +248,10 @@ integer gives better performance.
 
 If true, Hash and Object attributes with nil values are omitted.
 
+### :omit_null_byte [Boolean]
+
+If true, null bytes in strings will be omitted when dumping.
+
 ### :quirks_mode [Boolean]
 
 Allow single JSON values instead of documents, default is true (allow). This
@@ -265,10 +268,6 @@ to true.
 
 The number of digits after the decimal when dumping the seconds of time.
 
-### :skip_null_byte [Boolean]
-
-If true, null bytes in strings will be omitted when dumping.
-
 ### :space
 
 String inserted after the ':' character when dumping a JSON object. The

data/pages/Parser.md

@@ -280,7 +280,7 @@ Oj::Parser.usual       0.452      110544.876
        JSON::Ext       1.009       49555.094
 ```
 
-The `Oj::Parser.new(:saj)` is **1.55** times faster than `Oj.load` and
+The `Oj::Parser.new(:usual)` is **1.55** times faster than `Oj.load` and
 **2.23** times faster than the JSON gem.
 
 ### Object
@@ -298,7 +298,7 @@ Oj::Parser.usual       0.071      703502.033
        JSON::Ext       0.401      124638.859
 ```
 
-The `Oj::Parser.new(:saj)` is **3.17** times faster than
+The `Oj::Parser.new(:usual)` is **3.17** times faster than
 `Oj.compat_load` and **5.64** times faster than the JSON gem.
 
 ## Summary

data/pages/Rails.md

@@ -89,6 +89,8 @@ The classes that can be put in optimized mode and are optimized when
  * any class inheriting from ActiveRecord::Base
  * any other class where all attributes should be dumped
 
+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.
+
 The ActiveSupport decoder is the `JSON.parse()` method. Calling the
 `Oj::Rails.set_decoder()` method replaces that method with the Oj equivalent.
 

data/pages/Security.md

@@ -11,10 +11,24 @@ auto defined is used with an untrusted source. The `Oj.safe_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 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.
+The options in Oj are designed to provide flexibility to the developer. This flexibility allows Objects to be serialized and deserialized. An Object is deserialized by allocating it without calling its initializer and then setting its instance variables. A few methods are called on what that builds: `exception` and `set_backtrace` on an `Exception`, and `replace` on a subclass of `Hash`, `Array` or `String` for a `self` key. 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.
+
+## The mode a document is loaded in
+
+`Oj.load()` uses the `:object` mode unless the mode is changed. That mode takes the class of an Object from the document, so the document decides which of the classes already loaded in the process is allocated and what its instance variables are. Classes are looked up and not created unless `:auto_define` is turned on.
+
+For a document from an untrusted source, ask for a mode that does not do that:
+
+```ruby
+Oj.load(json, mode: :strict)
+Oj.strict_load(json)
+Oj.safe_load(json)
+```
+
+or set it for the process:
+
+```ruby
+Oj.default_options = {mode: :strict}
+```
+
+`Oj.object_load()` is the explicit form of the current default and stays in `:object` mode whatever the default is set to.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.17.4
+  version: 3.17.5
 platform: ruby
 authors:
 - Peter Ohler
@@ -231,7 +231,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.17
 specification_version: 4
 summary: A fast JSON parser and serializer.
 test_files: []