oj 3.17.7 → 3.17.8

data/ext/oj/resolve.h

@@ -4,9 +4,18 @@
 #ifndef OJ_RESOLVE_H
 #define OJ_RESOLVE_H
 
+#include <stdbool.h>
+#include <string.h>
+
 #include "ruby.h"
 
 extern VALUE oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class);
 extern VALUE oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class);
 
+inline static bool oj_is_backtrace_name(const char *name, size_t len) {
+    static const char backtrace[] = "Thread::Backtrace";
+
+    return sizeof(backtrace) - 1 == len && 0 == memcmp(backtrace, name, len);
+}
+
 #endif /* OJ_RESOLVE_H */

data/ext/oj/saj.c

@@ -646,13 +646,14 @@ static VALUE protect_saj_parse(VALUE x) {
  */
 VALUE
 oj_saj_parse(int argc, VALUE *argv, VALUE self) {
-    char  *json  = 0;
-    size_t len   = 0;
-    VALUE  input = argv[1];
+    char  *json = 0;
+    size_t len  = 0;
+    VALUE  input;
 
     if (argc < 2) {
         rb_raise(rb_eArgError, "Wrong number of arguments to saj_parse.\n");
     }
+    input = argv[1];
     if (rb_type(input) == T_STRING) {
         // the json string gets modified so make a copy of it
         len  = RSTRING_LEN(input) + 1;
@@ -663,16 +664,20 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
         volatile VALUE s;
 
         if (oj_stringio_class == clas) {
-            s    = rb_funcall2(input, oj_string_id, 0, 0);
+            s = rb_funcall2(input, oj_string_id, 0, 0);
+            StringValueCStr(s);
             len  = RSTRING_LEN(s) + 1;
             json = OJ_R_ALLOC_N(char, len);
-            strcpy(json, StringValueCStr(s));
+            strcpy(json, RSTRING_PTR(s));
 #if !IS_WINDOWS
         } else if (rb_cFile == clas && 0 == FIX2INT(rb_funcall(input, oj_pos_id, 0))) {
             int     fd = FIX2INT(rb_funcall(input, oj_fileno_id, 0));
             ssize_t cnt;
 
             len = lseek(fd, 0, SEEK_END);
+            if ((size_t)-1 == len) {
+                rb_raise(rb_eIOError, "failed to read from IO Object.");
+            }
             lseek(fd, 0, SEEK_SET);
             json = OJ_R_ALLOC_N(char, len + 1);
             {
@@ -681,6 +686,7 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
                 while (total < len) {
                     cnt = read(fd, json + total, len - total);
                     if (cnt <= 0) {
+                        OJ_R_FREE(json);
                         rb_raise(rb_eIOError, "failed to read from IO Object.");
                     }
                     total += cnt;
@@ -689,10 +695,11 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
             json[len] = '\0';
 #endif
         } else if (rb_respond_to(input, oj_read_id)) {
-            s    = rb_funcall2(input, oj_read_id, 0, 0);
+            s = rb_funcall2(input, oj_read_id, 0, 0);
+            StringValueCStr(s);
             len  = RSTRING_LEN(s) + 1;
             json = OJ_R_ALLOC_N(char, len);
-            strcpy(json, StringValueCStr(s));
+            strcpy(json, RSTRING_PTR(s));
         } else {
             rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
         }

data/ext/oj/saj2.c

@@ -33,9 +33,30 @@ static void push_key(Saj d, VALUE key) {
     d->tail++;
 }
 
+static VALUE pop_key(Saj d) {
+    if (d->tail <= d->keys) {
+        rb_raise(rb_eIndexError, "accessing key stack");
+    }
+    d->tail--;
+
+    return *d->tail;
+}
+
 static void noop(ojParser p) {
 }
 
+static void open_push_key(ojParser p) {
+    push_key((Saj)p->ctx, get_key(p));
+}
+
+static void close_pop_key(ojParser p) {
+    Saj d = (Saj)p->ctx;
+
+    if (d->keys < d->tail) {
+        d->tail--;
+    }
+}
+
 static void open_object(ojParser p) {
     rb_funcall(((Saj)p->ctx)->handler, oj_hash_start_id, 1, Qnil);
 }
@@ -89,11 +110,7 @@ static void close_object(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_hash_end_id, 1, key);
 }
@@ -103,11 +120,7 @@ static void close_object_loc(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_hash_end_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
 }
@@ -117,11 +130,7 @@ static void close_array(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_array_end_id, 1, key);
 }
@@ -131,11 +140,7 @@ static void close_array_loc(ojParser p) {
     VALUE key = Qnil;
 
     if (OBJECT_FUN == p->stack[p->depth]) {
-        d->tail--;
-        if (d->tail < d->keys) {
-            rb_raise(rb_eIndexError, "accessing key stack");
-        }
-        key = *d->tail;
+        key = pop_key(d);
     }
     rb_funcall(d->handler, oj_array_end_id, 3, key, LONG2FIX(p->line), LONG2FIX(p->cur - p->col));
 }
@@ -380,10 +385,15 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
         return d->handler;
     }
     if (0 == strcmp(key, "handler=")) {
+        int hash_start  = rb_respond_to(value, oj_hash_start_id);
+        int hash_end    = rb_respond_to(value, oj_hash_end_id);
+        int array_start = rb_respond_to(value, oj_array_start_id);
+        int array_end   = rb_respond_to(value, oj_array_end_id);
+
         d->tail    = d->keys;
         d->handler = value;
         reset(p);
-        if (rb_respond_to(value, oj_hash_start_id)) {
+        if (hash_start) {
             if (1 == rb_obj_method_arity(value, oj_hash_start_id)) {
                 p->funcs[TOP_FUN].open_object    = open_object;
                 p->funcs[ARRAY_FUN].open_object  = open_object;
@@ -393,8 +403,10 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].open_object  = open_object_loc;
                 p->funcs[OBJECT_FUN].open_object = open_object_loc_key;
             }
+        } else if (hash_end) {
+            p->funcs[OBJECT_FUN].open_object = open_push_key;
         }
-        if (rb_respond_to(value, oj_array_start_id)) {
+        if (array_start) {
             if (1 == rb_obj_method_arity(value, oj_array_start_id)) {
                 p->funcs[TOP_FUN].open_array    = open_array;
                 p->funcs[ARRAY_FUN].open_array  = open_array;
@@ -404,8 +416,10 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].open_array  = open_array_loc;
                 p->funcs[OBJECT_FUN].open_array = open_array_loc_key;
             }
+        } else if (array_end) {
+            p->funcs[OBJECT_FUN].open_array = open_push_key;
         }
-        if (rb_respond_to(value, oj_hash_end_id)) {
+        if (hash_end) {
             if (1 == rb_obj_method_arity(value, oj_hash_end_id)) {
                 p->funcs[TOP_FUN].close_object    = close_object;
                 p->funcs[ARRAY_FUN].close_object  = close_object;
@@ -415,8 +429,10 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].close_object  = close_object_loc;
                 p->funcs[OBJECT_FUN].close_object = close_object_loc;
             }
+        } else if (hash_start) {
+            p->funcs[OBJECT_FUN].close_object = close_pop_key;
         }
-        if (rb_respond_to(value, oj_array_end_id)) {
+        if (array_end) {
             if (1 == rb_obj_method_arity(value, oj_array_end_id)) {
                 p->funcs[TOP_FUN].close_array    = close_array;
                 p->funcs[ARRAY_FUN].close_array  = close_array;
@@ -426,6 +442,8 @@ static VALUE option(ojParser p, const char *key, VALUE value) {
                 p->funcs[ARRAY_FUN].close_array  = close_array_loc;
                 p->funcs[OBJECT_FUN].close_array = close_array_loc;
             }
+        } else if (array_start) {
+            p->funcs[OBJECT_FUN].close_array = close_pop_key;
         }
         if (rb_respond_to(value, oj_add_value_id)) {
             if (2 == rb_obj_method_arity(value, oj_add_value_id)) {
@@ -547,10 +565,8 @@ static void mark(ojParser p) {
     if (Qnil != d->handler) {
         rb_gc_mark(d->handler);
     }
-    if (!d->cache_keys) {
-        for (kp = d->keys; kp < d->tail; kp++) {
-            rb_gc_mark(*kp);
-        }
+    for (kp = d->keys; kp < d->tail; kp++) {
+        rb_gc_mark(*kp);
     }
 }
 

data/ext/oj/simd.h

@@ -98,12 +98,10 @@ static inline int oj_ctz64_fallback(uint64_t x) {
 #elif defined(__GNUC__) || defined(__clang__)
 // GCC/Clang: check for header availability and include them
 // We include headers but use target attributes to enable instructions per-function
-// Include cpuid.h for __get_cpuid fallback when __builtin_cpu_supports is unavailable
-#ifdef __has_include
-#if __has_include(<cpuid.h>)
+// Include cpuid.h for __get_cpuid fallback when __builtin_cpu_supports is unavailable.
+// cpuid.h is available on all GCC since 4.3 and all Clang versions, so include
+// it unconditionally rather than gating on __has_include (which GCC < 5 lacks).
 #include <cpuid.h>
-#endif
-#endif
 #if defined(__SSE4_2__) || defined(__SSE2__)
 // If any SSE is enabled globally, x86intrin.h should be available
 #include <x86intrin.h>

data/ext/oj/sparse.c

@@ -274,6 +274,10 @@ static void read_escaped_str(ParseInfo pi) {
                 buf_cleanup(&buf);
                 return;
             }
+        } else if ((unsigned char)c < 0x20 && (StrictMode == pi->options.mode || CompatMode == pi->options.mode)) {
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid control character in string");
+            buf_cleanup(&buf);
+            return;
         } else {
             buf_append(&buf, c);
         }
@@ -341,6 +345,9 @@ static void read_str(ParseInfo pi) {
             read_escaped_str(pi);
             reader_release(&pi->rd);
             return;
+        } else if ((unsigned char)c < 0x20 && (StrictMode == pi->options.mode || CompatMode == pi->options.mode)) {
+            oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid control character in string");
+            return;
         }
     }
     if (0 == parent) {  // simple add

data/ext/oj/stream_writer.c

@@ -16,6 +16,9 @@ static void stream_writer_free(void *ptr) {
         return;
     }
     sw = (StreamWriter)ptr;
+    if (NULL != sw->sw.out.circ_cache) {
+        oj_cache8_delete(sw->sw.out.circ_cache);
+    }
     oj_options_release(&sw->sw.opts);
     OJ_R_FREE(sw->sw.out.buf);
     OJ_R_FREE(sw->sw.types);

data/ext/oj/string_writer.c

@@ -169,6 +169,11 @@ void oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key) {
             *out->cur++ = ':';
         }
     }
+    if (NULL != out->circ_cache) {
+        oj_cache8_delete(out->circ_cache);
+        out->circ_cache = NULL;
+    }
+    out->circ_cnt = 0;
     switch (out->opts->mode) {
     case StrictMode: oj_dump_strict_val(val, sw->depth, out); break;
     case NullMode: oj_dump_null_val(val, sw->depth, out); break;
@@ -178,6 +183,10 @@ void oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key) {
     case CustomMode: oj_dump_custom_val(val, sw->depth, out, true); break;
     default: oj_dump_custom_val(val, sw->depth, out, true); break;
     }
+    if (NULL != out->circ_cache) {
+        oj_cache8_delete(out->circ_cache);
+        out->circ_cache = NULL;
+    }
 }
 
 void oj_str_writer_push_json(StrWriter sw, const char *json, const char *key) {
@@ -203,16 +212,17 @@ void oj_str_writer_push_json(StrWriter sw, const char *json, const char *key) {
 
 void oj_str_writer_pop(StrWriter sw) {
     long     size;
-    DumpType type = sw->types[sw->depth];
+    DumpType type;
 
     if (sw->keyWritten) {
         sw->keyWritten = 0;
         rb_raise(rb_eStandardError, "Can not pop after writing a key but no value.");
     }
-    sw->depth--;
-    if (0 > sw->depth) {
+    if (0 >= sw->depth) {
         rb_raise(rb_eStandardError, "Can not pop with no open array or object.");
     }
+    type = sw->types[sw->depth];
+    sw->depth--;
     size = sw->depth * sw->out.indent + 2;
     assure_size(&sw->out, size);
     fill_indent(&sw->out, sw->depth);
@@ -241,6 +251,10 @@ static void string_writer_free(void *ptr) {
     }
     sw = (StrWriter)ptr;
 
+    if (NULL != sw->out.circ_cache) {
+        oj_cache8_delete(sw->out.circ_cache);
+        sw->out.circ_cache = NULL;
+    }
     oj_out_free(&sw->out);
     oj_options_release(&sw->opts);
 

data/ext/oj/usual.c

@@ -85,6 +85,9 @@ static VALUE resolve_classname(VALUE mod, const char *classname, bool auto_defin
 
     if (rb_const_defined_at(mod, ci)) {
         clas = rb_const_get_at(mod, ci);
+        if (!RB_TYPE_P(clas, T_CLASS) && !RB_TYPE_P(clas, T_MODULE)) {
+            clas = Qundef;
+        }
     } else if (auto_define) {
         clas = rb_define_class_under(mod, classname, oj_bag_class);
     } else {
@@ -814,7 +817,7 @@ static VALUE opt_class_cache_set(ojParser p, VALUE value) {
 
     if (Qtrue == value) {
         if (NULL == d->class_cache) {
-            d->class_cache = cache_create(0, form_class_auto, MISS_AUTO == d->miss_class, false);
+            d->class_cache = cache_create(0, form_class_auto, true, false);
         }
     } else if (NULL != d->class_cache) {
         cache_free(d->class_cache);

data/ext/oj/val_stack.c

@@ -3,8 +3,6 @@
 
 #include "val_stack.h"
 
-#include <string.h>
-
 #include "odd.h"
 #include "oj.h"
 
@@ -15,12 +13,6 @@ static void stack_mark(void *ptr) {
     if (NULL == ptr) {
         return;
     }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_lock(&stack->mutex);
-#else
-    rb_mutex_lock(stack->mutex);
-    rb_gc_mark(stack->mutex);
-#endif
     {
         size_t i;
 
@@ -46,11 +38,6 @@ static void stack_mark(void *ptr) {
             }
         }
     }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_unlock(&stack->mutex);
-#else
-    rb_mutex_unlock(stack->mutex);
-#endif
 }
 
 static const rb_data_type_t oj_stack_type = {
@@ -66,15 +53,6 @@ static const rb_data_type_t oj_stack_type = {
 
 VALUE
 oj_stack_init(ValStack stack) {
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    int err;
-
-    if (0 != (err = pthread_mutex_init(&stack->mutex, 0))) {
-        rb_raise(rb_eException, "failed to initialize a mutex. %s", strerror(err));
-    }
-#else
-    stack->mutex = rb_mutex_new();
-#endif
     stack->head            = stack->base;
     stack->end             = stack->base + sizeof(stack->base) / sizeof(struct _val);
     stack->tail            = stack->head;

data/ext/oj/val_stack.h

@@ -9,9 +9,6 @@
 #include "mem.h"
 #include "odd.h"
 #include "ruby.h"
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-#include <pthread.h>
-#endif
 
 #define STACK_INC 64
 
@@ -58,12 +55,6 @@ typedef struct _valStack {
     Val    head;  // current stack
     Val    end;   // stack end
     Val    tail;  // pointer to one past last element name on stack
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_t mutex;
-#else
-    VALUE mutex;
-#endif
-
 } *ValStack;
 
 extern VALUE oj_stack_init(ValStack stack);
@@ -102,8 +93,8 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
         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.
+        // A realloc can trigger a GC that marks the stack, so change the
+        // pointers only after it returns.
         if (stack->base == stack->head) {
             head = OJ_R_ALLOC_N(struct _val, len + STACK_INC);
             memcpy(head, stack->base, sizeof(struct _val) * len);
@@ -117,19 +108,9 @@ inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
                 head[i].key = head[i].karray;
             }
         }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-        pthread_mutex_lock(&stack->mutex);
-#else
-        rb_mutex_lock(stack->mutex);
-#endif
         stack->head = head;
         stack->tail = stack->head + toff;
         stack->end  = stack->head + len + STACK_INC;
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-        pthread_mutex_unlock(&stack->mutex);
-#else
-        rb_mutex_unlock(stack->mutex);
-#endif
     }
     stack->tail->val       = val;
     stack->tail->next      = next;
@@ -183,9 +164,8 @@ inline static Val stack_pop(ValStack stack) {
 }
 
 // Append one key/value pair to the pair buffer. The same GC discipline as
-// stack_push: the allocation happens outside the mutex (it can trigger a GC
-// which takes the mutex in stack_mark) and the buffer pointer only changes
-// under the mutex.
+// stack_push: the allocation can trigger a GC that marks the pairs, so the
+// buffer pointer only changes after it returns.
 inline static void stack_pair_push(ValStack stack, VALUE key, VALUE value) {
     if (stack->pend <= stack->pcnt + 2) {
         size_t cnt = stack->pend * 2;
@@ -198,18 +178,8 @@ inline static void stack_pair_push(ValStack stack, VALUE key, VALUE value) {
             pairs = stack->pairs;
             OJ_R_REALLOC_N(pairs, VALUE, cnt);
         }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-        pthread_mutex_lock(&stack->mutex);
-#else
-        rb_mutex_lock(stack->mutex);
-#endif
         stack->pairs = pairs;
         stack->pend  = cnt;
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-        pthread_mutex_unlock(&stack->mutex);
-#else
-        rb_mutex_unlock(stack->mutex);
-#endif
     }
     stack->pairs[stack->pcnt]     = key;
     stack->pairs[stack->pcnt + 1] = value;

data/ext/oj/wab.c

@@ -40,6 +40,7 @@ static VALUE resolve_wab_uuid_class(void) {
         volatile VALUE wab_module;
 
         wab_uuid_clas = Qnil;
+        rb_gc_register_address(&wab_uuid_clas);
         if (rb_const_defined_at(rb_cObject, rb_intern("WAB"))) {
             wab_module = rb_const_get_at(rb_cObject, rb_intern("WAB"));
             if (rb_const_defined_at(wab_module, rb_intern("UUID"))) {
@@ -53,6 +54,7 @@ static VALUE resolve_wab_uuid_class(void) {
 static VALUE resolve_uri_class(void) {
     if (Qundef == uri_clas) {
         uri_clas = Qnil;
+        rb_gc_register_address(&uri_clas);
         if (rb_const_defined_at(rb_cObject, rb_intern("URI"))) {
             uri_clas = rb_const_get_at(rb_cObject, rb_intern("URI"));
         }
@@ -65,6 +67,7 @@ static VALUE resolve_uri_http_class(void) {
         volatile VALUE uri_module;
 
         uri_http_clas = Qnil;
+        rb_gc_register_address(&uri_http_clas);
         if (rb_const_defined_at(rb_cObject, rb_intern("URI"))) {
             uri_module = rb_const_get_at(rb_cObject, rb_intern("URI"));
             if (rb_const_defined_at(uri_module, rb_intern("HTTP"))) {

data/lib/oj/generic_object.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Loaded on first use of JSON::GenericObject so that requiring Oj does not
+# also require ostruct, which is no longer a default gem as of Ruby 4.0.
+begin
+  require 'ostruct'
+rescue LoadError
+  raise LoadError.new("JSON::GenericObject requires 'ostruct'. Add it to your Gemfile or install it with `gem install ostruct`.")
+end
+
+module JSON
+  # Taken directly from the json gem. Shamelessly copied. It is similar in
+  # some ways to the Oj::Bag class or the Oj::EasyHash class.
+  class GenericObject < OpenStruct
+    class << self
+      alias [] new
+
+      def json_creatable?
+        @json_creatable
+      end
+
+      attr_writer :json_creatable
+
+      def json_create(data)
+        data = data.dup
+        data.delete JSON.create_id
+        self[data]
+      end
+
+      def from_hash(object)
+        case
+        when object.respond_to?(:to_hash)
+          result = new
+          object.to_hash.each do |key, value|
+            result[key] = from_hash(value)
+          end
+          result
+        when object.respond_to?(:to_ary)
+          object.to_ary.map { |a| from_hash(a) }
+        else
+          object
+        end
+      end
+
+      def load(source, proc = nil, opts = {})
+        result = ::JSON.load(source, proc, opts.merge(:object_class => self))
+        result.nil? ? new : result
+      end
+
+      def dump(obj, *args)
+        ::JSON.dump(obj, *args)
+      end
+
+    end # self
+
+    self.json_creatable = false
+
+    def to_hash
+      table
+    end
+
+    def [](name)
+      __send__(name)
+    end unless method_defined?(:[])
+
+    def []=(name, value)
+      __send__("#{name}=", value)
+    end unless method_defined?(:[]=)
+
+    def |(other)
+      self.class[other.to_hash.merge(to_hash)]
+    end
+
+    def as_json(*)
+      { JSON.create_id => self.class.name }.merge to_hash
+    end
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+  end
+end # JSON

data/lib/oj/json.rb

@@ -1,4 +1,3 @@
-require 'ostruct'
 require 'oj/state'
 
 if defined?(JSON::PRETTY_STATE_PROTOTYPE)
@@ -113,76 +112,7 @@ unless defined?(JSON::PRETTY_STATE_PROTOTYPE)
     self.parser = ::JSON::Ext::Parser
     self.generator = ::JSON::Ext::Generator
 
-    # Taken directly from the json gem. Shamelessly copied. It is similar in
-    # some ways to the Oj::Bag class or the Oj::EasyHash class.
-    class GenericObject < OpenStruct
-      class << self
-        alias [] new
-
-        def json_creatable?
-          @json_creatable
-        end
-
-        attr_writer :json_creatable
-
-        def json_create(data)
-          data = data.dup
-          data.delete JSON.create_id
-          self[data]
-        end
-
-        def from_hash(object)
-          case
-          when object.respond_to?(:to_hash)
-            result = new
-            object.to_hash.each do |key, value|
-              result[key] = from_hash(value)
-            end
-            result
-          when object.respond_to?(:to_ary)
-            object.to_ary.map { |a| from_hash(a) }
-          else
-            object
-          end
-        end
-
-        def load(source, proc = nil, opts = {})
-          result = ::JSON.load(source, proc, opts.merge(:object_class => self))
-          result.nil? ? new : result
-        end
-
-        def dump(obj, *args)
-          ::JSON.dump(obj, *args)
-        end
-
-      end # self
-
-      self.json_creatable = false
-
-      def to_hash
-        table
-      end
-
-      def [](name)
-        __send__(name)
-      end unless method_defined?(:[])
-
-      def []=(name, value)
-        __send__("#{name}=", value)
-      end unless method_defined?(:[]=)
-
-      def |(other)
-        self.class[other.to_hash.merge(to_hash)]
-      end
-
-      def as_json(*)
-        { JSON.create_id => self.class.name }.merge to_hash
-      end
-
-      def to_json(*a)
-        as_json.to_json(*a)
-      end
-    end
+    autoload :GenericObject, 'oj/generic_object'
 
   end # JSON
 end

data/lib/oj/mimic.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: false
 
 require 'bigdecimal'
-require 'ostruct'
 
 module Oj