oj 2.18.5 → 3.16.11

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,24 +5,23 @@ 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
     # @return [Boolean] true for any method that matches an instance
     #                   variable reader, otherwise false.
-    def respond_to?(m)
+    def respond_to?(m, include_all = false)
       return true if super
-      return true if has_key?(key)
-      return true if has_key?(key.to_s)
-      has_key?(key.to_sym)
+      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
 
@@ -33,10 +31,20 @@ module Oj
     # @raise [ArgumentError] if an argument is given. Zero arguments expected.
     # @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 with #{m}) to method #{m}") unless args.nil? or args.empty?
-      return fetch(m, nil) if has_key?(m)
-      return fetch(m.to_s, nil) if has_key?(m.to_s)
-      return fetch(m.to_sym, nil) if has_key?(m.to_sym)
+      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?
+        return fetch(m, nil) if has_key?(m)
+        return fetch(m.to_s, nil) if has_key?(m.to_s)
+        return fetch(m.to_sym, nil) if has_key?(m.to_sym)
+      end
       raise NoMethodError.new("undefined method #{m}", m)
     end
 

data/lib/oj/error.rb

@@ -1,23 +1,21 @@
-
 module Oj
 
-  class Error < StandardError
-  end # Error
+  # Inherit Error class from StandardError.
+  Error = Class.new(StandardError)
+
+  # Following classes inherit from the Error class.
+  # -----------------------------------------------
 
   # An Exception that is raised as a result of a parse error while parsing a JSON document.
-  class ParseError < Error
-  end # ParseError
+  ParseError = Class.new(Error)
 
   # An Exception that is raised as a result of a path being too deep.
-  class DepthError < Error
-  end # DepthError
+  DepthError = Class.new(Error)
 
   # An Exception that is raised if a file fails to load.
-  class LoadError < Error
-  end # LoadError
+  LoadError = Class.new(Error)
 
-  # An Exception that is raised if there is a conflict with mimicing JSON
-  class MimicError < Error
-  end # MimicError
+  # An Exception that is raised if there is a conflict with mimicking JSON
+  MimicError = Class.new(Error)
 
 end # Oj

data/lib/oj/json.rb

@@ -0,0 +1,188 @@
+require 'ostruct'
+require 'oj/state'
+
+if defined?(JSON::PRETTY_STATE_PROTOTYPE)
+  # There are enough people that try to use both the json gen and oj in mimic
+  # mode so don't display the warning.
+
+  # warn "WARNING: oj/json is a compatability shim used by Oj. Requiring the file explicitly is not recommended."
+end
+
+unless defined?(JSON::PRETTY_STATE_PROTOTYPE)
+  module JSON
+    NaN = 0.0/0.0 unless defined?(::JSON::NaN)
+    Infinity = 1.0/0.0 unless defined?(::JSON::Infinity)
+    MinusInfinity = -1.0/0.0 unless defined?(::JSON::MinusInfinity)
+    # Taken from the unit test. Note that items like check_circular? are not
+    # present.
+    PRETTY_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                                                :allow_nan             => false,
+                                                                :array_nl              => "\n",
+                                                                :ascii_only            => false,
+                                                                :buffer_initial_length => 1024,
+                                                                :depth                 => 0,
+                                                                :indent                => "  ",
+                                                                :max_nesting           => 100,
+                                                                :object_nl             => "\n",
+                                                                :space                 => " ",
+                                                                :space_before          => "",
+                                                              }) unless defined?(::JSON::PRETTY_STATE_PROTOTYPE)
+    SAFE_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                                              :allow_nan             => false,
+                                                              :array_nl              => "",
+                                                              :ascii_only            => false,
+                                                              :buffer_initial_length => 1024,
+                                                              :depth                 => 0,
+                                                              :indent                => "",
+                                                              :max_nesting           => 100,
+                                                              :object_nl             => "",
+                                                              :space                 => "",
+                                                              :space_before          => "",
+                                                            }) unless defined?(::JSON::SAFE_STATE_PROTOTYPE)
+    FAST_STATE_PROTOTYPE = Ext::Generator::State.from_state({
+                                                              :allow_nan             => false,
+                                                              :array_nl              => "",
+                                                              :ascii_only            => false,
+                                                              :buffer_initial_length => 1024,
+                                                              :depth                 => 0,
+                                                              :indent                => "",
+                                                              :max_nesting           => 0,
+                                                              :object_nl             => "",
+                                                              :space                 => "",
+                                                              :space_before          => "",
+                                                            }) unless defined?(::JSON::FAST_STATE_PROTOTYPE)
+
+    def self.dump_default_options
+      Oj::MimicDumpOption.new
+    end
+
+    def self.dump_default_options=(h)
+      m = Oj::MimicDumpOption.new
+      h.each do |k, v|
+        m[k] = v
+      end
+    end
+
+    def self.parser=(p)
+      @@parser = p
+    end
+
+    def self.parser()
+      @@parser
+    end
+
+    def self.generator=(g)
+      @@generator = g
+    end
+
+    def self.generator()
+      @@generator
+    end
+
+    module Ext
+      class Parser
+        def initialize(src)
+          raise TypeError.new("already initialized") unless @source.nil?
+
+          @source = src
+        end
+
+        def source()
+          raise TypeError.new("already initialized") if @source.nil?
+
+          @source
+        end
+
+        def parse()
+          raise TypeError.new("already initialized") if @source.nil?
+
+          JSON.parse(@source)
+        end
+
+      end # Parser
+    end # Ext
+
+    State = ::JSON::Ext::Generator::State unless defined?(::JSON::State)
+
+    begin
+      send(:remove_const, :Parser)
+    rescue
+      # ignore and move on
+    end
+    Parser = ::JSON::Ext::Parser unless defined?(::JSON::Parser)
+    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
+
+  end # JSON
+end

data/lib/oj/mimic.rb

@@ -1,12 +1,56 @@
+# frozen_string_literal: false
 
-begin
-  require 'ostruct'
-rescue Exception
-  # ignore
-end
+require 'bigdecimal'
+require 'ostruct'
 
 module Oj
 
+  ##
+  # Custom mode can be used to emulate the compat mode with some minor
+  # differences. These are the options that setup the custom mode to be like
+  # the compat mode.
+  CUSTOM_MIMIC_JSON_OPTIONS = {
+    allow_gc: true,
+    allow_invalid_unicode: false,
+    allow_nan: false,
+    array_class: nil,
+    array_nl: nil,
+    auto_define: false,
+    bigdecimal_as_decimal: false,
+    bigdecimal_load: :auto,
+    circular: false,
+    class_cache: false,
+    cache_keys: true,
+    cache_str: 5,
+    create_additions: false,
+    create_id: "json_class",
+    empty_string: false,
+    escape_mode: :unicode_xss,
+    float_precision: 0,
+    hash_class: nil,
+    ignore: nil,
+    ignore_under: false,
+    indent: 0,
+    integer_range: nil,
+    mode: :custom,
+    nan: :raise,
+    nilnil: false,
+    object_nl: nil,
+    omit_nil: false,
+    quirks_mode: true,
+    safe: false,
+    second_precision: 3,
+    space: nil,
+    space_before: nil,
+    symbol_keys: false,
+    time_format: :ruby,
+    trace: false,
+    use_as_json: false,
+    use_raw_json: false,
+    use_to_hash: false,
+    use_to_json: true,
+  }
+
   # A bit hack-ish but does the trick. The JSON.dump_default_options is a Hash
   # but in mimic we use a C struct to store defaults. This class creates a view
   # onto that struct.
@@ -17,6 +61,8 @@ module Oj
       self.store(:allow_nan, true)
       self.store(:quirks_mode, oo[:quirks_mode])
       self.store(:ascii_only, (:ascii == oo[:escape_mode]))
+
+      super
     end
 
     def []=(key, value)
@@ -29,20 +75,25 @@ module Oj
     end
   end
 
+  # Loads mimic-ed JSON paths. Used by Oj.mimic_JSON().
+  # @param mimic_paths [Array] additional paths to add to the Ruby loaded features.
   def self.mimic_loaded(mimic_paths=[])
     $LOAD_PATH.each do |d|
       next unless File.exist?(d)
 
       jfile = File.join(d, 'json.rb')
       $LOADED_FEATURES << jfile unless $LOADED_FEATURES.include?(jfile) if File.exist?(jfile)
-      
+
       Dir.glob(File.join(d, 'json', '**', '*.rb')).each do |file|
-        $LOADED_FEATURES << file unless $LOADED_FEATURES.include?(file)
+        # allow json/add/xxx to be loaded. User can override with Oj.add_to_json(xxx).
+        $LOADED_FEATURES << file unless $LOADED_FEATURES.include?(file) unless file.include?('add')
       end
     end
     mimic_paths.each { |p| $LOADED_FEATURES << p }
     $LOADED_FEATURES << 'json' unless $LOADED_FEATURES.include?('json')
 
+    require 'oj/json'
+
     if Object.const_defined?('OpenStruct')
       OpenStruct.class_eval do
         # Both the JSON gem and Rails monkey patch as_json. Let them battle it out.
@@ -50,13 +101,93 @@ module Oj
           def as_json(*)
             name = self.class.name.to_s
             raise JSON::JSONError, "Only named structs are supported!" if 0 == name.length
+
             { JSON.create_id => name, 't' => table }
           end
         end
         def self.json_create(h)
-          new(h['t'])
+          new(h['t'] || h[:t])
+        end
+      end
+    end
+
+    BigDecimal.class_eval do
+      # Both the JSON gem and Rails monkey patch as_json. Let them battle it out.
+      unless defined?(self.as_json)
+        def as_json(*)
+          {JSON.create_id => 'BigDecimal', 'b' => _dump }
+        end
+      end
+      def self.json_create(h)
+        BigDecimal._load(h['b'])
+      end
+    end
+
+    Complex.class_eval do
+      # Both the JSON gem and Rails monkey patch as_json. Let them battle it out.
+      unless defined?(self.as_json)
+        def as_json(*)
+          {JSON.create_id => 'Complex', 'r' => real, 'i' => imag }
+        end
+      end
+      def self.json_create(h)
+        Complex(h['r'], h['i'])
+      end
+    end
+
+    DateTime.class_eval do
+      # Both the JSON gem and Rails monkey patch as_json. Let them battle it out.
+      unless defined?(self.as_json)
+        def as_json(*)
+          { JSON.create_id => 'DateTime',
+            'y' => year,
+            'm' => month,
+            'd' => day,
+            'H' => hour,
+            'M' => min,
+            'S' => sec,
+            'of' => offset.to_s,
+            'sg' => start }
+        end
+      end
+      def self.json_create(h)
+        # offset is a rational as a string
+        as, bs = h['of'].split('/')
+        a = as.to_i
+        b = bs.to_i
+        if 0 == b
+          off = a
+        else
+          off = Rational(a, b)
+        end
+        civil(h['y'], h['m'], h['d'], h['H'], h['M'], h['S'], off, h['sg'])
+      end
+    end
+
+    Date.class_eval do
+      # Both the JSON gem and Rails monkey patch as_json. Let them battle it out.
+      unless defined?(self.as_json)
+        def as_json(*)
+          { JSON.create_id => 'Date', 'y' => year, 'm' => month, 'd' => day, 'sg' => start }
+        end
+      end
+      def self.json_create(h)
+        civil(h['y'], h['m'], h['d'], h['sg'])
+      end
+    end
+
+    Exception.class_eval do
+      # Both the JSON gem and Rails monkey patch as_json. Let them battle it out.
+      unless defined?(self.as_json)
+        def as_json(*)
+          {JSON.create_id => self.class.name, 'm' => message, 'b' => backtrace }
         end
       end
+      def self.json_create(h)
+        e = new(h['m'])
+        e.set_backtrace(h['b'])
+        e
+      end
     end
 
     Range.class_eval do
@@ -67,7 +198,7 @@ module Oj
         end
       end
       def self.json_create(h)
-        new(h['a'])
+        new(*h['a'])
       end
     end
 
@@ -101,11 +232,12 @@ module Oj
         def as_json(*)
           name = self.class.name.to_s
           raise JSON::JSONError, "Only named structs are supported!" if 0 == name.length
+
           { JSON.create_id => name, 'v' => values }
         end
       end
       def self.json_create(h)
-        new(h['v'])
+        new(*h['v'])
       end
     end
 
@@ -125,7 +257,6 @@ module Oj
       # Both the JSON gem and Rails monkey patch as_json. Let them battle it out.
       unless defined?(self.as_json)
         def as_json(*)
-          {JSON.create_id => 'Symbol', 's' => to_s }
           nsecs = [ tv_usec * 1000 ]
           nsecs << tv_nsec if respond_to?(:tv_nsec)
           nsecs = nsecs.max
@@ -133,7 +264,7 @@ module Oj
         end
       end
       def self.json_create(h)
-        if usec = h.delete('u')
+        if (usec = h.delete('u'))
           h['n'] = usec * 1000
         end
         if instance_methods.include?(:tv_nsec)
@@ -143,20 +274,28 @@ module Oj
         end
       end
     end
-
-    JSON.module_eval do
-      def self.dump_default_options
-        Oj::MimicDumpOption.new
-      end
-
-      def self.dump_default_options=(h)
-        m = Oj::MimicDumpOption.new
-        h.each do |k,v|
-          m[k] = v
-        end
-      end
-    end
-
   end # self.mimic_loaded
 
 end # Oj
+
+# More monkey patches.
+class String
+  def to_json_raw_object
+    {
+      JSON.create_id => self.class.name,
+      'raw' => self.bytes
+    }
+  end
+  def to_json_raw(*)
+   to_json_raw_object().to_json()
+  end
+  def self.json_create(obj)
+    s = ''
+    s.encode!(Encoding::ASCII_8BIT) if s.respond_to?(:encode!)
+    raw = obj['raw']
+    if raw.is_a? Array
+      raw.each { |v| s << v }
+    end
+    s
+  end
+end

data/lib/oj/saj.rb

@@ -1,11 +1,17 @@
 module Oj
-  # A SAX style parse handler for JSON hence the acronym SAJ for Simple API for
-  # JSON. The Oj::Saj handler class should be subclassed and then used with the
-  # Oj::Saj key_parse() method. The Saj methods will then be called as the file
-  # is parsed.
+  # A SAX style parse handler for JSON hence the acronym SAJ for Simple API
+  # for JSON. The Oj::Saj handler class can be subclassed and then used with
+  # the Oj::Saj key_parse() method or with the more resent
+  # Oj::Parser.new(:saj). The Saj methods will then be called as the file is
+  # parsed.
+  #
+  # With Oj::Parser.new(:saj) each method can also include a line and column
+  # argument so hash_start(key) could also be hash_start(key, line,
+  # column). The error() method is no used with Oj::Parser.new(:saj) so it
+  # will never be called.
   #
   # @example
-  # 
+  #
   #  require 'oj'
   #
   #  class MySaj < ::Oj::Saj
@@ -23,6 +29,14 @@ module Oj
   #    Oj.saj_parse(cnt, f)
   #  end
   #
+  # or
+  #
+  #  p = Oj::Parser.new(:saj)
+  #  p.handler = MySaj.new()
+  #  File.open('any.json', 'r') do |f|
+  #    p.parse(f.read)
+  #  end
+  #
   # To make the desired methods active while parsing the desired method should
   # be made public in the subclasses. If the methods remain private they will
   # not be called during parsing.
@@ -61,6 +75,6 @@ module Oj
 
     def error(message, line, column)
     end
-    
+
   end # Saj
 end # Oj

data/lib/oj/schandler.rb

@@ -64,13 +64,14 @@ module Oj
   #
   #    hash_end
   #
-  # When a hash key is encountered the hash_key method is called with the parsed
-  # hash value key. The return value from the call is then used as the key in
-  # the key-value pair that follows.
+  #  At the end of a JSON object element the hash_end() callback is called if
+  #  public.
   #
   #    hash_key
   #
-  # At the end of a JSON object element the hash_end() callback is called if public.
+  # When a hash key is encountered the hash_key() method is called with the
+  # parsed hash value key. The return value from the call is then used as the
+  # key in the key-value pair that follows.
   #
   #    hash_set
   #