oj 2.0.0 → 3.0.0

data/lib/oj/mimic.rb

@@ -1,12 +1,267 @@
 
+require 'bigdecimal'
+begin
+  require 'ostruct'
+rescue Exception
+  # ignore
+end
+
 module Oj
-  
+
+  # 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.
+  class MimicDumpOption < Hash
+    def initialize()
+      oo = Oj.default_options
+      self.store(:max_nesting, false)
+      self.store(:allow_nan, true)
+      self.store(:quirks_mode, oo[:quirks_mode])
+      self.store(:ascii_only, (:ascii == oo[:escape_mode]))
+    end
+
+    def []=(key, value)
+      case key
+      when :quirks_mode
+        Oj.default_options = {:quirks_mode => value}
+      when :ascii_only
+        Oj.default_options = {:ascii_only => value}
+      end
+    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=[])
-    gems_dir = File.dirname(File.dirname(File.dirname(File.dirname(__FILE__))))
-    Dir.foreach(gems_dir) do |gem|
-      next unless (gem.start_with?('json-') || gem.start_with?('json_pure'))
-      $LOADED_FEATURES << File.join(gems_dir, gem, 'lib', 'json.rb')
+    $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|
+        # 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.
+        unless defined?(self.as_json)
+          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'] || 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
+      # 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 => 'Range', 'a' => [first, last, exclude_end?]}
+        end
+      end
+      def self.json_create(h)
+        new(*h['a'])
+      end
+    end
+
+    Rational.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 => 'Rational', 'n' => numerator, 'd' => denominator }
+        end
+      end
+      def self.json_create(h)
+        Rational(h['n'], h['d'])
+      end
+    end
+
+    Regexp.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 => 'Regexp', 'o' => options, 's' => source }
+        end
+      end
+      def self.json_create(h)
+        new(h['s'], h['o'])
+      end
+    end
+
+    Struct.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(*)
+          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'])
+      end
+    end
+
+    Symbol.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 => 'Symbol', 's' => to_s }
+        end
+      end
+      def self.json_create(h)
+        h['s'].to_sym
+      end
+    end
+
+    Time.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(*)
+          nsecs = [ tv_usec * 1000 ]
+          nsecs << tv_nsec if respond_to?(:tv_nsec)
+          nsecs = nsecs.max
+          { JSON.create_id => 'Time', 's' => tv_sec, 'n' => nsecs }
+        end
+      end
+      def self.json_create(h)
+        if usec = h.delete('u')
+          h['n'] = usec * 1000
+        end
+        if instance_methods.include?(:tv_nsec)
+          at(h['s'], Rational(h['n'], 1000))
+        else
+          at(h['s'], h['n'] / 1000)
+        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,7 +1,9 @@
 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_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 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.
+  #
   # @example
   # 
   #  require 'oj'
@@ -11,18 +13,19 @@ module Oj
   #      @hash_cnt = 0
   #    end
   #
-  #    def start_hash(key)
+  #    def hash_start(key)
   #      @hash_cnt += 1
   #    end
   #  end
   #
   #  cnt = MySaj.new()
-  #  File.open('any.xml', 'r') do |f|
+  #  File.open('any.json', 'r') do |f|
   #    Oj.saj_parse(cnt, f)
   #  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.
+  # 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.
   #
   #    def hash_start(key); end
   #    def hash_end(key); end
@@ -36,9 +39,9 @@ module Oj
     def initialize()
     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.
+    # 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.
     private
 
     def hash_start(key)

data/lib/oj/schandler.rb

@@ -0,0 +1,142 @@
+module Oj
+  # A Simple Callback Parser (SCP) for JSON. The Oj::ScHandler class should be
+  # subclassed and then used with the Oj.sc_parse() method. The Scp methods will
+  # then be called as the file is parsed. The handler does not have to be a
+  # subclass of the ScHandler class as long as it responds to the desired
+  # methods.
+  #
+  # @example
+  #
+  #  require 'oj'
+  #
+  #  class MyHandler < ::Oj::ScHandler
+  #    def hash_start
+  #      {}
+  #    end
+  #
+  #    def hash_set(h,k,v)
+  #      h[k] = v
+  #    end
+  #
+  #    def array_start
+  #      []
+  #    end
+  #
+  #    def array_append(a,v)
+  #      a << v
+  #    end
+  #
+  #    def add_value(v)
+  #      p v
+  #    end
+  #
+  #    def error(message, line, column)
+  #      p "ERROR: #{message}"
+  #    end
+  #  end
+  #
+  #  File.open('any.json', 'r') do |f|
+  #    Oj.sc_parse(MyHandler.new, f)
+  #  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.
+  #
+  #    def hash_start(); end
+  #    def hash_end(); end
+  #    def hash_key(key); end
+  #    def hash_set(h, key, value); end
+  #    def array_start(); end
+  #    def array_end(); end
+  #    def array_append(a, value); end
+  #    def add_value(value); end
+  #
+  # As certain elements of a JSON document are reached during parsing the
+  # callbacks are called. The parser helps by keeping track of objects created
+  # by the callbacks but does not create those objects itself.
+  #
+  #    hash_start
+  #
+  # When a JSON object element starts the hash_start() callback is called if
+  # public. It should return what ever Ruby Object is to be used as the element
+  # that will later be included in the hash_set() callback.
+  #
+  #    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.
+  #
+  #    hash_key
+  #
+  # At the end of a JSON object element the hash_end() callback is called if public.
+  #
+  #    hash_set
+  #
+  # When a key value pair is encountered during parsing the hash_set() callback
+  # is called if public. The first element will be the object returned from the
+  # enclosing hash_start() callback. The second argument is the key and the last
+  # is the value.
+  #
+  #    array_start
+  #
+  # When a JSON array element is started the array_start() callback is called if
+  # public. It should return what ever Ruby Object is to be used as the element
+  # that will later be included in the array_append() callback.
+  #
+  #    array_end
+  #
+  # At the end of a JSON array element the array_end() callback is called if public.
+  #
+  #    array_append
+  #
+  # When a element is encountered that is an element of an array the
+  # array_append() callback is called if public. The first argument to the
+  # callback is the Ruby object returned from the enclosing array_start()
+  # callback.
+  #
+  #    add_value
+  #
+  # The handler is expected to handle multiple JSON elements in one stream,
+  # file, or string. When a top level JSON has been read completely the
+  # add_value() callback is called. Even if only one element was ready this
+  # callback returns the Ruby object that was constructed during the parsing.
+  #
+  class ScHandler
+    # Create a new instance of the ScHandler class.
+    def initialize()
+    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.
+    private
+
+    def hash_start()
+    end
+
+    def hash_end()
+    end
+
+    def hash_key(key)
+      key
+    end
+
+    def hash_set(h, key, value)
+    end
+
+    def array_start()
+    end
+
+    def array_end()
+    end
+
+    def add_value(value)
+    end
+
+    def array_append(a, value)
+    end
+
+  end # ScHandler
+end # Oj

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

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module. 
-  VERSION = '2.0.0'
+  VERSION = '3.0.0'
 end

data/lib/oj.rb

@@ -1,33 +1,21 @@
-# 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
 
+begin
+  # This require exists to get around Rubinius failing to load bigdecimal from
+  # the C extension.
+  require 'bigdecimal'
+rescue Exception
+  # ignore
+end
+
 require 'oj/version'
 require 'oj/bag'
+require 'oj/easy_hash'
 require 'oj/error'
 require 'oj/mimic'
 require 'oj/saj'
+require 'oj/schandler'
 
 require 'oj/oj' # C extension

data/pages/Advanced.md

@@ -0,0 +1,22 @@
+# Advanced Features
+
+Optimized JSON (Oj), as the name implies, was written to provide speed optimized
+JSON handling. It was designed as a faster alternative to Yajl and other
+common Ruby JSON parsers. So far it has achieved that, and is about 2 times faster
+than any other Ruby JSON parser, and 3 or more times faster at serializing JSON.
+
+Oj has several `dump` or serialization modes which control how Ruby `Object`s 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. In addition to
+the various options there are also alternative APIs for parsing JSON.
+
+The fastest alternative parser API is the `Oj::Doc` API. The `Oj::Doc` API takes
+a completely different approach by opening a JSON document and providing calls
+to navigate around the JSON while it is open. With this approach, JSON access
+can be well over 20 times faster than conventional JSON parsing.
+
+The `Oj::Saj` and `Oj::ScHandler` APIs are callback parsers that
+walk the JSON document depth first and makes callbacks for each element.
+Both callback parser are useful when only portions of the JSON are of
+interest. Performance up to 20 times faster than conventional JSON is
+possible if only a few elements of the JSON are of interest.

data/pages/Compatibility.md

@@ -0,0 +1,25 @@
+# Compatibility
+
+**Ruby**
+
+Oj is compatible with Ruby 1.9.3, 2.0.0, 2.1, 2.2, 2.3, 2.4 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.
+
+**Rails**
+
+Although up until 4.1 Rails uses [multi_json](https://github.com/intridea/multi_json), an [issue in Rails](https://github.com/rails/rails/issues/9212) causes ActiveSupport to fail to make use Oj for JSON handling.
+There is a
+[gem to patch this](https://github.com/GoodLife/rails-patch-json-encode) for
+Rails 3.2 and 4.0. As of the Oj 2.6.0 release the default behavior is to not use
+the `to_json()` method unless the `:use_to_json` option is set. This provides
+another work around to the rails older and newer behavior.
+
+The latest ActiveRecord is able to work with Oj by simply using the line:
+
+```
+serialize :metadata, Oj
+```
+
+In version Rails 4.1, multi_json has been removed, and this patch is unnecessary and will no longer work.
+See {file:Rails.md}.