oj 3.8.1

data/lib/oj.rb

@@ -0,0 +1,21 @@
+
+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/lib/oj/active_support_helper.rb

@@ -0,0 +1,41 @@
+
+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')
+
+# This is a hack to work around an oddness with DateTime and the ActiveSupport
+# that causes a hang when some methods are called from C. Hour, min(ute),
+# sec(ond) and other methods are special but they can be called from C until
+# activesupport/time is required. After that they can not be even though
+# resond_to? returns true. By defining methods to call super the problem goes
+# away. There is obviously some magic going on under the covers that I don't
+# understand.
+class DateTime
+  def hour()
+    super
+  end
+  def min()
+    super
+  end
+  def sec()
+    super
+  end
+  def sec_fraction()
+    super
+  end
+  def offset()
+    super
+  end
+end

data/lib/oj/bag.rb

@@ -0,0 +1,88 @@
+
+module Oj
+
+  # A generic class that is used only for storing attributes. It is the base
+  # Class for auto-generated classes in the storage system. Instance variables
+  # are added using the instance_variable_set() method. All instance variables
+  # can be accessed using the variable name (without the @ prefix). No setters
+  # are provided as the Class is intended for reading only.
+  class Bag
+
+    # The initializer can take multiple arguments in the form of key values
+    # where the key is the variable name and the value is the variable
+    # value. This is intended for testing purposes only.
+    # @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|
+        self.instance_variable_set(k, v)
+      end
+    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
+      instance_variables.include?(:"@#{m}")
+    end
+
+    # Handles requests for variable values. Others cause an Exception to be
+    # raised.
+    # @param [Symbol] 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)
+      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
+
+    # Replaces eql?() with something more reasonable for this Class.
+    # @param [Object] other Object to compare self to
+    # @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?
+
+    # Define a new class based on the Oj::Bag class. This is used internally in
+    # the Oj module and is available to service wrappers that receive XML
+    # requests that include Objects of Classes not defined in the storage
+    # process.
+    # @param [String] classname Class name or symbol that includes Module names.
+    # @return [Object] an instance of the specified Class.
+    # @raise [NameError] if the classname is invalid.
+    def self.define_class(classname)
+      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)
+          m = m.const_get(sym)
+        else
+          c = Module.new
+          m.const_set(sym, c)
+          m = c
+        end
+      end
+      sym = tokens[-1]
+      if m.const_defined?(sym)
+        c = m.const_get(sym)
+      else
+        c = Class.new(Oj::Bag)
+        m.const_set(sym, c)
+      end
+      c
+    end
+
+  end # Bag
+end # Oj

data/lib/oj/easy_hash.rb

@@ -0,0 +1,52 @@
+
+module Oj
+
+  # A Hash subclass that normalizes the hash keys to allow lookup by the
+  # key.to_s or key.to_sym. It also supports looking up hash values by methods
+  # 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
+    # @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)
+      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
+
+    # 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[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
+
+  end # EasyHash
+end # Oj

data/lib/oj/error.rb

@@ -0,0 +1,22 @@
+
+module Oj
+
+  # 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.
+  ParseError = Class.new(Error)
+
+  # An Exception that is raised as a result of a path being too deep.
+  DepthError = Class.new(Error)
+
+  # An Exception that is raised if a file fails to load.
+  LoadError = Class.new(Error)
+
+  # An Exception that is raised if there is a conflict with mimicing JSON
+  MimicError = Class.new(Error)
+
+end # Oj

data/lib/oj/json.rb

@@ -0,0 +1,176 @@
+
+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 unless defined?(::JSON::State)
+
+  begin
+    send(:remove_const, :Parser)
+  rescue
+  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

data/lib/oj/mimic.rb

@@ -0,0 +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_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|
+        # 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