oj 2.18.5 → 3.0.0

data/ext/oj/val_stack.h

@@ -58,7 +58,10 @@ typedef struct _Val {
     char		karray[32];
     volatile VALUE	key_val;
     union {
-	const char	*classname;
+	struct {
+	    const char	*classname;
+	    VALUE	clas;
+	};
 	OddArgs		odd_args;
     };
     uint16_t		klen;
@@ -127,7 +130,8 @@ stack_push(ValStack stack, VALUE val, ValNext next) {
     }
     stack->tail->val = val;
     stack->tail->next = next;
-    stack->tail->classname = 0;
+    stack->tail->classname = NULL;
+    stack->tail->clas = Qundef;
     stack->tail->key = 0;
     stack->tail->key_val = Qundef;
     stack->tail->clen = 0;

data/lib/oj.rb

@@ -1,26 +1,4 @@
-# Optimized JSON (Oj), as the name implies was written to provide speed
-# optimized JSON handling.
-# 
-# Oj has several dump or serialization modes which control how Objects are
-# converted to JSON. These modes are set with the :mode option in either the
-# default options or as one of the options to the dump() method.
-# 
-# - :strict mode will only allow the 7 basic JSON types to be serialized. Any other Object
-#   will raise and Exception. 
-# 
-# - :null mode replaces any Object that is not one of the JSON types is replaced by a JSON null.
-# 
-# - :object mode will dump any Object as a JSON Object with keys that match
-#   the Ruby Object's variable names without the '@' character. This is the
-#   highest performance mode.
-# 
-# - :compat mode is is the compatible with other systems. It will serialize
-#   any Object but will check to see if the Object implements a to_hash() or
-#   to_json() method. If either exists that method is used for serializing the
-#   Object. The to_hash() is more flexible and produces more consistent output
-#   so it has a preference over the to_json() method. If neither the to_json()
-#   or to_hash() methods exist then the Oj internal Object variable encoding
-#   is used.
+
 module Oj
 end
 

data/lib/oj/easy_hash.rb

@@ -33,10 +33,18 @@ 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/json.rb

@@ -0,0 +1,172 @@
+
+require 'ostruct'
+require 'oj/state'
+
+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
+
+  Parser = ::JSON::Ext::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

data/lib/oj/mimic.rb

@@ -1,4 +1,5 @@
 
+require 'bigdecimal'
 begin
   require 'ostruct'
 rescue Exception
@@ -29,6 +30,8 @@ module Oj
     end
   end
 
+  # Loads mimic-ed JSON paths. Used by Oj.mimic_JSON().
+  # @param mimic_path [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)
@@ -37,12 +40,15 @@ module Oj
       $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.
@@ -54,9 +60,100 @@ module Oj
           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
+
+    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
+
+    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 +164,7 @@ module Oj
         end
       end
       def self.json_create(h)
-        new(h['a'])
+        new(*h['a'])
       end
     end
 
@@ -105,7 +202,7 @@ module Oj
         end
       end
       def self.json_create(h)
-        new(h['v'])
+        new(*h['v'])
       end
     end
 
@@ -125,7 +222,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
@@ -144,19 +240,28 @@ module Oj
       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/state.rb

@@ -0,0 +1,131 @@
+
+module JSON
+  module Ext
+    module Generator 
+      unless defined?(::JSON::Ext::Generator::State)
+        # This class exists for json gem compatibility only. While it can be
+        # used as the options for other than compatibility a simple Hash is
+        # recommended as it is simpler and performs better. The only bit
+        # missing by not using a state object is the depth availability which
+        # may be the depth during dumping or maybe not since it can be set and
+        # the docs for depth= is the same as max_nesting. Note: Had to make
+        # this a subclass of Object instead of Hash like EashyHash due to
+        # conflicts with the json gem.
+        class State
+
+          def self.from_state(opts)
+            s = self.new()
+            s.clear()
+            s.merge(opts)
+            s
+          end
+
+          def initialize(opts = {})
+            @attrs = {}
+
+            # Populate with all vars then merge in opts. This class deviates from
+            # the json gem in that any of the options can be set with the opts
+            # argument. The json gem limits the opts use to 7 of the options.
+            @attrs[:indent] = ''
+            @attrs[:space] = ''
+            @attrs[:space_before] = ''
+            @attrs[:array_nl] = ''
+            @attrs[:object_nl] = ''
+            @attrs[:allow_nan] = false
+            @attrs[:buffer_initial_length] = 1024 # completely ignored by Oj
+            @attrs[:depth] = 0
+            @attrs[:max_nesting] = 100
+            @attrs[:check_circular?] = true
+            @attrs[:ascii_only] = false
+
+            @attrs.merge!(opts)
+          end
+
+          def to_h()
+            return @attrs.dup
+          end
+          
+          def to_hash()
+            return @attrs.dup
+          end
+          
+          def allow_nan?()
+            @attrs[:allow_nan]
+          end
+
+          def ascii_only?()
+            @attrs[:ascii_only]
+          end
+
+          def configure(opts)
+            raise TypeError.new('expected a Hash') unless opts.respond_to?(:to_h)
+            @attrs.merge!(opts.to_h)
+          end
+
+          def generate(obj)
+            JSON.generate(obj)
+          end
+
+          def merge(opts)
+            @attrs.merge!(opts)
+          end
+
+          # special rule for this.
+          def buffer_initial_length=(len)
+            len = 1024 if 0 >= len
+            @attrs[:buffer_initial_length] = len
+          end
+
+          # Replaces the Object.respond_to?() method.
+          # @param [Symbol] m method symbol
+          # @return [Boolean] true for any method that matches an instance
+          #                   variable reader, otherwise false.
+          def respond_to?(m)
+            return true if super
+            return true if has_key?(key)
+            return true if has_key?(key.to_s)
+            has_key?(key.to_sym)
+          end
+
+          def [](key)
+            key = key.to_sym
+            @attrs.fetch(key, nil)
+          end
+
+          def []=(key, value)
+            key = key.to_sym
+            @attrs[key] = value
+          end
+
+          def clear()
+            @attrs.clear()
+          end
+
+          def has_key?(k)
+            @attrs.has_key?(key.to_sym)
+          end
+          
+          # Handles requests for Hash values. Others cause an Exception to be raised.
+          # @param [Symbol|String] m method symbol
+          # @return [Boolean] the value of the specified instance variable.
+          # @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)
+            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.to_s[0..-2]
+              m = m.to_sym
+              return @attrs.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 @attrs[m.to_sym]
+            end
+            raise NoMethodError.new("undefined method #{m}", m)
+          end
+
+        end # State
+      end # defined check
+    end # Generator
+  end # Ext
+
+end # JSON