oj 3.13.17 → 3.16.3

data/ext/oj/usual.h

@@ -0,0 +1,69 @@
+// Copyright (c) 2022, Peter Ohler, All rights reserved.
+
+#include <ruby.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+struct _cache;
+struct _ojParser;
+
+// Used to mark the start of each Hash, Array, or Object. The members point at
+// positions of the start in the value stack and if not an Array into the key
+// stack.
+typedef struct _col {
+    long vi;  // value stack index
+    long ki;  // key stack index if an hash else -1 for an array
+} *Col;
+
+typedef union _key {
+    struct {
+        int16_t len;
+        char    buf[30];
+    };
+    struct {
+        int16_t xlen;  // should be the same as len
+        char   *key;
+    };
+} *Key;
+
+#define MISS_AUTO 'A'
+#define MISS_RAISE 'R'
+#define MISS_IGNORE 'I'
+
+typedef struct _usual {
+    VALUE *vhead;
+    VALUE *vtail;
+    VALUE *vend;
+
+    Col chead;
+    Col ctail;
+    Col cend;
+
+    Key khead;
+    Key ktail;
+    Key kend;
+
+    VALUE (*get_key)(struct _ojParser *p, Key kp);
+    struct _cache *key_cache;  // same as str_cache or sym_cache
+    struct _cache *str_cache;
+    struct _cache *sym_cache;
+    struct _cache *class_cache;
+    struct _cache *attr_cache;
+
+    VALUE array_class;
+    VALUE hash_class;
+
+    char   *create_id;
+    uint8_t create_id_len;
+    uint8_t cache_str;
+    uint8_t cache_xrate;
+    uint8_t miss_class;
+    bool    cache_keys;
+    bool    ignore_json_create;
+    bool    raise_on_empty;
+} *Usual;
+
+// Initialize the parser with the usual delegate. If the usual delegate is
+// wrapped then this function is called first and then the parser functions
+// can be replaced.
+extern void oj_init_usual(struct _ojParser *p, Usual d);

data/ext/oj/util.h

@@ -13,7 +13,7 @@ typedef struct _timeInfo {
     int day;
     int mon;
     int year;
-} * TimeInfo;
+}* TimeInfo;
 
 extern void sec_as_time(int64_t secs, TimeInfo ti);
 

data/ext/oj/val_stack.c

@@ -8,11 +8,11 @@
 #include "odd.h"
 #include "oj.h"
 
-static void mark(void *ptr) {
+static void stack_mark(void *ptr) {
     ValStack stack = (ValStack)ptr;
     Val      v;
 
-    if (0 == ptr) {
+    if (NULL == ptr) {
         return;
     }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
@@ -46,6 +46,17 @@ static void mark(void *ptr) {
 #endif
 }
 
+static const rb_data_type_t oj_stack_type = {
+    "Oj/stack",
+    {
+        stack_mark,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
 VALUE
 oj_stack_init(ValStack stack) {
 #ifdef HAVE_PTHREAD_MUTEX_INIT
@@ -70,7 +81,7 @@ oj_stack_init(ValStack stack) {
     stack->head->clen      = 0;
     stack->head->next      = NEXT_NONE;
 
-    return Data_Wrap_Struct(oj_cstack_class, mark, 0, stack);
+    return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);
 }
 
 const char *oj_stack_next_string(ValNext n) {

data/ext/oj/val_stack.h

@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 
+#include "mem.h"
 #include "odd.h"
 #include "ruby.h"
 #ifdef HAVE_PTHREAD_MUTEX_INIT
@@ -28,10 +29,10 @@ typedef enum {
 
 typedef struct _val {
     volatile VALUE val;
-    const char *   key;
+    const char    *key;
     char           karray[32];
     volatile VALUE key_val;
-    const char *   classname;
+    const char    *classname;
     VALUE          clas;
     OddArgs        odd_args;
     uint16_t       klen;
@@ -39,7 +40,7 @@ typedef struct _val {
     char           next;  // ValNext
     char           k1;    // first original character in the key
     char           kalloc;
-} * Val;
+} *Val;
 
 typedef struct _valStack {
     struct _val base[STACK_INC];
@@ -52,7 +53,7 @@ typedef struct _valStack {
     VALUE mutex;
 #endif
 
-} * ValStack;
+} *ValStack;
 
 extern VALUE oj_stack_init(ValStack stack);
 
@@ -62,7 +63,7 @@ inline static int stack_empty(ValStack stack) {
 
 inline static void stack_cleanup(ValStack stack) {
     if (stack->base != stack->head) {
-        xfree(stack->head);
+        OJ_R_FREE(stack->head);
         stack->head = NULL;
     }
 }
@@ -76,10 +77,10 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
         // A realloc can trigger a GC so make sure it happens outside the lock
         // but lock before changing pointers.
         if (stack->base == stack->head) {
-            head = ALLOC_N(struct _val, len + STACK_INC);
+            head = OJ_R_ALLOC_N(struct _val, len + STACK_INC);
             memcpy(head, stack->base, sizeof(struct _val) * len);
         } else {
-            REALLOC_N(head, struct _val, len + STACK_INC);
+            OJ_R_REALLOC_N(head, struct _val, len + STACK_INC);
         }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
         pthread_mutex_lock(&stack->mutex);

data/ext/oj/wab.c

@@ -76,15 +76,13 @@ static VALUE resolve_uri_http_class(void) {
 }
 
 static void raise_wab(VALUE obj) {
-    rb_raise(rb_eTypeError,
-             "Failed to dump %s Object to JSON in wab mode.\n",
-             rb_class2name(rb_obj_class(obj)));
+    rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in wab mode.\n", rb_class2name(rb_obj_class(obj)));
 }
 
 // Removed dependencies on math due to problems with CentOS 5.4.
 static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
-    char * b;
+    char  *b;
     double d   = rb_num2dbl(obj);
     int    cnt = 0;
 
@@ -226,13 +224,13 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
     if (rb_cTime == clas) {
         dump_time(obj, out);
     } else if (oj_bigdecimal_class == clas) {
-        volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
+        volatile VALUE rstr = oj_safe_string_convert(obj);
 
         oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
     } else if (resolve_wab_uuid_class() == clas) {
-        oj_dump_str(rb_funcall(obj, oj_to_s_id, 0), depth, out, false);
+        oj_dump_str(oj_safe_string_convert(obj), depth, out, false);
     } else if (resolve_uri_http_class() == clas) {
-        oj_dump_str(rb_funcall(obj, oj_to_s_id, 0), depth, out, false);
+        oj_dump_str(oj_safe_string_convert(obj), depth, out, false);
     } else {
         raise_wab(obj);
     }
@@ -266,9 +264,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);
-    }
+    TRACE(out->opts->trace, "dump", obj, depth, TraceIn);
     if (MAX_DEPTH < depth) {
         rb_raise(rb_eNoMemError, "Too deeply nested.\n");
     }
@@ -277,9 +273,7 @@ void oj_dump_wab_val(VALUE obj, int depth, Out out) {
 
         if (NULL != f) {
             f(obj, depth, out, false);
-            if (Yes == out->opts->trace) {
-                oj_trace("dump", obj, __FILE__, __LINE__, depth, TraceOut);
-            }
+            TRACE(out->opts->trace, "dump", obj, depth, TraceOut);
             return;
         }
     }
@@ -303,7 +297,7 @@ static VALUE calc_hash_key(ParseInfo pi, Val parent) {
 #if HAVE_RB_ENC_INTERNED_STR
         rkey = rb_enc_interned_str(parent->key, parent->klen, oj_utf8_encoding);
 #else
-	rkey = rb_utf8_str_new(parent->key, parent->klen);
+        rkey = rb_utf8_str_new(parent->key, parent->klen);
         rkey = rb_str_intern(rkey);
         OBJ_FREEZE(rkey);
 #endif
@@ -312,15 +306,11 @@ static VALUE calc_hash_key(ParseInfo pi, Val parent) {
 }
 
 static void hash_end(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_HASH_END(pi->options.trace, pi);
 }
 
 static void array_end(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_array_end(pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_ARRAY_END(pi->options.trace, pi);
 }
 
 static VALUE noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
@@ -328,9 +318,7 @@ static VALUE noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
 }
 
 static void add_value(ParseInfo pi, VALUE val) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_value", pi, val);
     pi->stack.head->val = val;
 }
 
@@ -454,14 +442,14 @@ static VALUE protect_uri(VALUE rstr) {
 static VALUE cstr_to_rstr(ParseInfo pi, 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 (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;
         }
     }
-    if (36 == len && '-' == str[8] && '-' == str[13] && '-' == str[18] && '-' == str[23] &&
-        uuid_check(str, (int)len) && Qnil != resolve_wab_uuid_class()) {
+    if (36 == len && '-' == str[8] && '-' == str[13] && '-' == str[18] && '-' == str[23] && uuid_check(str, (int)len) &&
+        Qnil != resolve_wab_uuid_class()) {
         return rb_funcall(wab_uuid_clas, oj_new_id, 1, rb_str_new(str, len));
     }
     if (7 < len && 0 == strncasecmp("http://", str, 7)) {
@@ -478,9 +466,7 @@ static VALUE cstr_to_rstr(ParseInfo pi, const char *str, size_t len) {
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
     pi->stack.head->val = cstr_to_rstr(pi, str, len);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_string", pi, pi->stack.head->val);
 }
 
 static void add_num(ParseInfo pi, NumInfo ni) {
@@ -488,15 +474,11 @@ static void add_num(ParseInfo pi, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     pi->stack.head->val = oj_num_as_value(ni);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, pi->stack.head->val);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "add_number", pi, pi->stack.head->val);
 }
 
 static VALUE start_hash(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_hash", pi);
     if (Qnil != pi->options.hash_class) {
         return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
@@ -507,9 +489,7 @@ static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len,
     volatile VALUE rval = cstr_to_rstr(pi, str, len);
 
     rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rval);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_string", pi, rval);
 }
 
 static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
@@ -520,22 +500,16 @@ static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
     }
     rval = oj_num_as_value(ni);
     rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rval);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_number", pi, rval);
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
     rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), value);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, value);
 }
 
 static VALUE start_array(ParseInfo pi) {
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_in("start_array", pi, __FILE__, __LINE__);
-    }
+    TRACE_PARSE_IN(pi->options.trace, "start_array", pi);
     return rb_ary_new();
 }
 
@@ -543,9 +517,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rval = cstr_to_rstr(pi, str, len);
 
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "set_value", pi, rval);
 }
 
 static void array_append_num(ParseInfo pi, NumInfo ni) {
@@ -556,16 +528,12 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     }
     rval = oj_num_as_value(ni);
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, rval);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_number", pi, rval);
 }
 
 static void array_append_value(ParseInfo pi, VALUE value) {
     rb_ary_push(stack_peek(&pi->stack)->val, value);
-    if (RB_UNLIKELY(Yes == pi->options.trace)) {
-        oj_trace_parse_call("append_value", pi, __FILE__, __LINE__, value);
-    }
+    TRACE_PARSE_CALL(pi->options.trace, "append_value", pi, value);
 }
 
 void oj_set_wab_callbacks(ParseInfo pi) {

data/lib/oj/active_support_helper.rb

@@ -1,16 +1,14 @@
+# frozen_string_literal: true
 
 require 'active_support/time'
 
 module Oj
-
   # Exists only to handle the ActiveSupport::TimeWithZone.
   class ActiveSupportHelper
-
     def self.createTimeWithZone(utc, zone)
       ActiveSupport::TimeWithZone.new(utc - utc.gmt_offset, ActiveSupport::TimeZone[zone])
     end
   end
-
 end
 
 Oj.register_odd(ActiveSupport::TimeWithZone, Oj::ActiveSupportHelper, :createTimeWithZone, :utc, 'time_zone.name')

data/lib/oj/bag.rb

@@ -15,7 +15,7 @@ module Oj
     # @example Oj::Bag.new(:@x => 42, :@y => 57)
     # @param [Hash] args instance variable symbols and their values
     def initialize(args = {})
-      args.each do |k,v|
+      args.each do |k, v|
         self.instance_variable_set(k, v)
       end
     end
@@ -26,6 +26,7 @@ module Oj
     #                   variable reader, otherwise false.
     def respond_to?(m)
       return true if super
+
       instance_variables.include?(:"@#{m}")
     end
 
@@ -37,8 +38,10 @@ module Oj
     # @raise [NoMethodError] if the instance variable is not defined.
     def method_missing(m, *args, &block)
       raise ArgumentError.new("wrong number of arguments (#{args.size} for 0) to method #{m}") unless args.nil? or args.empty?
+
       at_m = :"@#{m}"
       raise NoMethodError.new("undefined method #{m}", m) unless instance_variable_defined?(at_m)
+
       instance_variable_get(at_m)
     end
 
@@ -47,9 +50,11 @@ module Oj
     # @return [Boolean] true if each variable and value are the same, otherwise false.
     def eql?(other)
       return false if (other.nil? or self.class != other.class)
+
       ova = other.instance_variables
       iv = instance_variables
       return false if ova.size != iv.size
+
       iv.all? { |vid| instance_variable_get(vid) != other.instance_variable_get(vid) }
     end
     alias == eql?
@@ -65,6 +70,7 @@ module Oj
       classname = classname.to_s unless classname.is_a?(String)
       tokens = classname.split('::').map(&:to_sym)
       raise NameError.new("Invalid classname '#{classname}") if tokens.empty?
+
       m = Object
       tokens[0..-2].each do |sym|
         if m.const_defined?(sym)

data/lib/oj/easy_hash.rb

@@ -1,4 +1,3 @@
-
 module Oj
 
   # A Hash subclass that normalizes the hash keys to allow lookup by the
@@ -6,10 +5,6 @@ module Oj
   # that match the keys.
   class EasyHash < Hash
 
-    # Initializes the instance to an empty Hash.
-    def initialize()
-    end
-
     # Replaces the Object.respond_to?() method.
     # @param [Symbol] m method symbol
     # @param [Boolean] include_all whether to include private and protected methods in the search
@@ -19,12 +14,14 @@ module Oj
       return true if super
       return true if has_key?(m)
       return true if has_key?(m.to_s)
+
       has_key?(m.to_sym)
     end
 
     def [](key)
       return fetch(key, nil) if has_key?(key)
       return fetch(key.to_s, nil) if has_key?(key.to_s)
+
       fetch(key.to_sym, nil)
     end
 
@@ -36,9 +33,11 @@ module Oj
     def method_missing(m, *args, &block)
       if m.to_s.end_with?('=')
         raise ArgumentError.new("wrong number of arguments (#{args.size} for 1 with #{m}) to method #{m}") if args.nil? or 1 != args.length
+
         m = m[0..-2]
         return store(m.to_s, args[0]) if has_key?(m.to_s)
         return store(m.to_sym, args[0]) if has_key?(m.to_sym)
+
         return store(m, args[0])
       else
         raise ArgumentError.new("wrong number of arguments (#{args.size} for 0 with #{m}) to method #{m}") unless args.nil? or args.empty?

data/lib/oj/error.rb

@@ -1,4 +1,3 @@
-
 module Oj
 
   # Inherit Error class from StandardError.