oj-2.17.4/ 0000755 0000041 0000041 00000000000 12766161570 012260 5 ustar www-data www-data oj-2.17.4/lib/ 0000755 0000041 0000041 00000000000 12766161567 013034 5 ustar www-data www-data oj-2.17.4/lib/oj.rb 0000644 0000041 0000041 00000003027 12766161567 013773 0 ustar www-data www-data # 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
oj-2.17.4/lib/oj/ 0000755 0000041 0000041 00000000000 12766161567 013444 5 ustar www-data www-data oj-2.17.4/lib/oj/schandler.rb 0000644 0000041 0000041 00000007570 12766161567 015745 0 ustar www-data www-data 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
oj-2.17.4/lib/oj/saj.rb 0000644 0000041 0000041 00000002774 12766161567 014560 0 ustar www-data www-data 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.
#
# @example
#
# require 'oj'
#
# class MySaj < ::Oj::Saj
# def initialize()
# @hash_cnt = 0
# end
#
# def hash_start(key)
# @hash_cnt += 1
# end
# end
#
# cnt = MySaj.new()
# 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.
#
# def hash_start(key); end
# def hash_end(key); end
# def array_start(key); end
# def array_end(key); end
# def add_value(value, key); end
# def error(message, line, column); end
#
class Saj
# Create a new instance of the Saj handler 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(key)
end
def hash_end(key)
end
def array_start(key)
end
def array_end(key)
end
def add_value(value, key)
end
def error(message, line, column)
end
end # Saj
end # Oj
oj-2.17.4/lib/oj/version.rb 0000644 0000041 0000041 00000000110 12766161567 015446 0 ustar www-data www-data
module Oj
# Current version of the module.
VERSION = '2.17.4'
end
oj-2.17.4/lib/oj/active_support_helper.rb 0000644 0000041 0000041 00000002025 12766161567 020376 0 ustar www-data www-data
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
oj-2.17.4/lib/oj/bag.rb 0000644 0000041 0000041 00000006553 12766161567 014533 0 ustar www-data www-data
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
oj-2.17.4/lib/oj/mimic.rb 0000644 0000041 0000041 00000010665 12766161567 015077 0 ustar www-data www-data
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
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)
end
end
mimic_paths.each { |p| $LOADED_FEATURES << p }
$LOADED_FEATURES << 'json' unless $LOADED_FEATURES.include?('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'])
end
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(*)
{JSON.create_id => 'Symbol', 's' => to_s }
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
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
oj-2.17.4/lib/oj/error.rb 0000644 0000041 0000041 00000001041 12766161567 015116 0 ustar www-data www-data
module Oj
class Error < StandardError
end # Error
# An Exception that is raised as a result of a parse error while parsing a JSON document.
class ParseError < Error
end # ParseError
# An Exception that is raised as a result of a path being too deep.
class DepthError < Error
end # DepthError
# An Exception that is raised if a file fails to load.
class LoadError < Error
end # LoadError
# An Exception that is raised if there is a conflict with mimicing JSON
class MimicError < Error
end # MimicError
end # Oj
oj-2.17.4/lib/oj/easy_hash.rb 0000644 0000041 0000041 00000003064 12766161567 015740 0 ustar www-data www-data
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)
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)
raise NoMethodError.new("undefined method #{m}", m)
end
end # EasyHash
end # Oj
oj-2.17.4/test/ 0000755 0000041 0000041 00000000000 12766161567 013245 5 ustar www-data www-data oj-2.17.4/test/test_hash.rb 0000755 0000041 0000041 00000001042 12766161567 015554 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class Hashi < Minitest::Test
module TestModule
end
def test_dump
h = Oj::EasyHash.new()
h['abc'] = 3
out = Oj.dump(h, :mode => :compat)
assert_equal(%|{"abc":3}|, out)
end
def test_load
obj = Oj.load(%|{"abc":3}|, :mode => :compat, :hash_class => Oj::EasyHash)
assert_equal(Oj::EasyHash, obj.class)
assert_equal(3, obj['abc'])
assert_equal(3, obj[:abc])
assert_equal(3, obj.abc())
end
end # HashTest
oj-2.17.4/test/perf_simple.rb 0000644 0000041 0000041 00000016026 12766161567 016104 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
require 'optparse'
require 'yajl'
require 'json'
require 'json/pure'
require 'json/ext'
require 'msgpack'
require 'oj'
require 'ox'
class Jazz
def initialize()
@boolean = true
@number = 58
@string = "A string"
@array = [true, false, nil]
@hash = { 'one' => 1, 'two' => 2 }
end
def to_json()
%{
{ "boolean":#{@boolean},
"number":#{@number},
"string":#{@string},
"array":#{@array},
"hash":#{@hash},
}
}
end
def to_hash()
{ 'boolean' => @boolean,
'number' => @number,
'string' => @string,
'array' => @array,
'hash' => @hash,
}
end
def to_msgpack(out='')
to_hash().to_msgpack(out)
end
end
$indent = 2
$iter = 10000
$with_object = true
$with_bignum = true
$with_nums = true
opts = OptionParser.new
opts.on("-c", "--count [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-i", "--indent [Int]", Integer, "indentation") { |i| $indent = i }
opts.on("-o", "without objects") { $with_object = false }
opts.on("-b", "without bignum") { $with_bignum = false }
opts.on("-n", "without numbers") { $with_nums = false }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
if $with_nums
obj = {
'a' => 'Alpha',
'b' => true,
'c' => 12345,
'd' => [ true, [false, [12345, nil], 3.967, ['something', false], nil]],
'e' => { 'one' => 1, 'two' => 2 },
'f' => nil,
}
obj['g'] = Jazz.new() if $with_object
obj['h'] = 12345678901234567890123456789 if $with_bignum
else
obj = {
'a' => 'Alpha',
'b' => true,
'c' => '12345',
'd' => [ true, [false, ['12345', nil], '3.967', ['something', false], nil]],
'e' => { 'one' => '1', 'two' => '2' },
'f' => nil,
}
end
Oj.default_options = { :indent => $indent, :mode => :object }
s = Oj.dump(obj)
xml = Ox.dump(obj, :indent => $indent)
puts
# Put Oj in strict mode so it only create JSON native types instead of the
# original Ruby Objects. None of the other packages other than Ox support
# Object recreation so no need for Oj to do it in the performance tests.
Oj.default_options = { :mode => :strict }
parse_results = { :oj => 0.0, :yajl => 0.0, :msgpack => 0.0, :pure => 0.0, :ext => 0.0, :ox => 0.0 }
start = Time.now
$iter.times do
Oj.load(s)
end
dt = Time.now - start
base_dt = dt
parse_results[:oj] = dt
puts "%d Oj.load()s in %0.3f seconds or %0.1f loads/msec" % [$iter, dt, $iter/dt/1000.0]
start = Time.now
$iter.times do
Yajl::Parser.parse(s)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'Yajl'
end
parse_results[:yajl] = dt
puts "%d Yajl::Parser.parse()s in %0.3f seconds or %0.1f parses/msec" % [$iter, dt, $iter/dt/1000.0]
begin
JSON.parser = JSON::Ext::Parser
start = Time.now
$iter.times do
JSON.parse(s)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'JSON::Ext'
end
parse_results[:ext] = dt
puts "%d JSON::Ext::Parser parse()s in %0.3f seconds or %0.1f parses/msec" % [$iter, dt, $iter/dt/1000.0]
rescue Exception => e
puts "JSON::Ext failed: #{e.class}: #{e.message}"
end
begin
JSON.parser = JSON::Pure::Parser
start = Time.now
$iter.times do
JSON.parse(s)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'JSON::Pure'
end
parse_results[:pure] = dt
puts "%d JSON::Pure::Parser parse()s in %0.3f seconds or %0.1f parses/msec" % [$iter, dt, $iter/dt/1000.0]
rescue Exception => e
puts "JSON::Pure failed: #{e.class}: #{e.message}"
end
begin
mp = MessagePack.pack(obj)
start = Time.now
$iter.times do
MessagePack.unpack(mp)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'MessagePack'
end
parse_results[:msgpack] = dt
puts "%d MessagePack.unpack()s in %0.3f seconds or %0.1f packs/msec" % [$iter, dt, $iter/dt/1000.0]
rescue Exception => e
puts "MessagePack failed: #{e.class}: #{e.message}"
end
start = Time.now
$iter.times do
Ox.load(xml)
end
dt = Time.now - start
parse_results[:ox] = dt
puts "%d Ox.load()s in %0.3f seconds or %0.1f loads/msec" % [$iter, dt, $iter/dt/1000.0]
puts "Parser results:"
puts "gem seconds parses/msec X faster than #{base_name} (higher is better)"
parse_results.each do |name,dt|
if 0.0 == dt
puts "#{name} failed to generate JSON"
next
end
puts "%-7s %6.3f %5.1f %4.1f" % [name, dt, $iter/dt/1000.0, base_dt/dt]
end
puts
# Back to object mode for best performance when dumping.
Oj.default_options = { :indent => $indent, :mode => :object }
dump_results = { :oj => 0.0, :yajl => 0.0, :msgpack => 0.0, :pure => 0.0, :ext => 0.0, :ox => 0.0 }
start = Time.now
$iter.times do
Oj.dump(obj)
end
dt = Time.now - start
base_dt = dt
base_name = 'Oj'
parse_results[:oj] = dt
puts "%d Oj.dump()s in %0.3f seconds or %0.1f dumps/msec" % [$iter, dt, $iter/dt/1000.0]
start = Time.now
$iter.times do
Yajl::Encoder.encode(obj)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'Yajl'
end
parse_results[:yajl] = dt
puts "%d Yajl::Encoder.encode()s in %0.3f seconds or %0.1f encodes/msec" % [$iter, dt, $iter/dt/1000.0]
begin
JSON.parser = JSON::Ext::Parser
start = Time.now
$iter.times do
JSON.generate(obj)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'JSON::Ext'
end
parse_results[:pure] = dt
puts "%d JSON::Ext generate()s in %0.3f seconds or %0.1f generates/msec" % [$iter, dt, $iter/dt/1000.0]
rescue Exception => e
parse_results[:ext] = 0.0
puts "JSON::Ext failed: #{e.class}: #{e.message}"
end
begin
JSON.parser = JSON::Pure::Parser
start = Time.now
$iter.times do
JSON.generate(obj)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'JSON::Pure'
end
parse_results[:pure] = dt
puts "%d JSON::Pure generate()s in %0.3f seconds or %0.1f generates/msec" % [$iter, dt, $iter/dt/1000.0]
rescue Exception => e
parse_results[:pure] = 0.0
puts "JSON::Pure failed: #{e.class}: #{e.message}"
end
begin
start = Time.now
$iter.times do
MessagePack.pack(obj)
end
dt = Time.now - start
if base_dt < dt
base_dt = dt
base_name = 'MessagePack'
end
parse_results[:msgpack] = dt
puts "%d Msgpack()s in %0.3f seconds or %0.1f unpacks/msec" % [$iter, dt, $iter/dt/1000.0]
rescue Exception => e
parse_results[:msgpack] = 0.0
puts "MessagePack failed: #{e.class}: #{e.message}"
end
start = Time.now
$iter.times do
Ox.dump(obj)
end
dt = Time.now - start
parse_results[:ox] = dt
puts "%d Ox.dump()s in %0.3f seconds or %0.1f dumps/msec" % [$iter, dt, $iter/dt/1000.0]
puts "Parser results:"
puts "gem seconds dumps/msec X faster than #{base_name} (higher is better)"
parse_results.each do |name,dt|
if 0.0 == dt
puts "#{name} failed to generate JSON"
next
end
puts "%-7s %6.3f %5.1f %4.1f" % [name, dt, $iter/dt/1000.0, base_dt/dt]
end
puts
oj-2.17.4/test/activesupport_datetime_test.rb 0000755 0000041 0000041 00000000621 12766161567 021417 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
require "active_support" # v5.0.0
require "oj" #v2.17.1
puts "ActiveSupport + OJ.dump(DateTime.now)"
puts
puts Oj.dump(DateTime.now)
puts
require "oj/active_support_helper"
#require 'active_support/time'
puts "ActiveSupport + OJ + active_support_helper dump(DateTime.now)"
puts
puts Oj.dump(DateTime.now)
puts
oj-2.17.4/test/test_scp.rb 0000755 0000041 0000041 00000022556 12766161567 015433 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
require 'socket'
$json = %{{
"array": [
{
"num" : 3,
"string": "message",
"hash" : {
"h2" : {
"a" : [ 1, 2, 3 ]
}
}
}
],
"boolean" : true
}}
class NoHandler < Oj::ScHandler
def initialize()
end
end
class AllHandler < Oj::ScHandler
attr_accessor :calls
def initialize()
@calls = []
end
def hash_start()
@calls << [:hash_start]
{}
end
def hash_end()
@calls << [:hash_end]
end
def hash_key(key)
@calls << [:hash_key, key]
return 'too' if 'two' == key
return :symbol if 'symbol' == key
key
end
def array_start()
@calls << [:array_start]
[]
end
def array_end()
@calls << [:array_end]
end
def add_value(value)
@calls << [:add_value, value]
end
def hash_set(h, key, value)
@calls << [:hash_set, key, value]
end
def array_append(a, value)
@calls << [:array_append, value]
end
end # AllHandler
class Closer < AllHandler
attr_accessor :io
def initialize(io)
super()
@io = io
end
def hash_start()
@calls << [:hash_start]
@io.close
{}
end
def hash_set(h, key, value)
@calls << [:hash_set, key, value]
@io.close
end
end # Closer
class ScpTest < Minitest::Test
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_nil
handler = AllHandler.new()
json = %{null}
Oj.sc_parse(handler, json)
assert_equal([[:add_value, nil]], handler.calls)
end
def test_true
handler = AllHandler.new()
json = %{true}
Oj.sc_parse(handler, json)
assert_equal([[:add_value, true]], handler.calls)
end
def test_false
handler = AllHandler.new()
json = %{false}
Oj.sc_parse(handler, json)
assert_equal([[:add_value, false]], handler.calls)
end
def test_string
handler = AllHandler.new()
json = %{"a string"}
Oj.sc_parse(handler, json)
assert_equal([[:add_value, 'a string']], handler.calls)
end
def test_fixnum
handler = AllHandler.new()
json = %{12345}
Oj.sc_parse(handler, json)
assert_equal([[:add_value, 12345]], handler.calls)
end
def test_float
handler = AllHandler.new()
json = %{12345.6789}
Oj.sc_parse(handler, json)
assert_equal([[:add_value, 12345.6789]], handler.calls)
end
def test_float_exp
handler = AllHandler.new()
json = %{12345.6789e7}
Oj.sc_parse(handler, json)
assert_equal(1, handler.calls.size)
assert_equal(:add_value, handler.calls[0][0])
assert_equal((12345.6789e7 * 10000).to_i, (handler.calls[0][1] * 10000).to_i)
end
def test_array_empty
handler = AllHandler.new()
json = %{[]}
Oj.sc_parse(handler, json)
assert_equal([[:array_start],
[:array_end],
[:add_value, []]], handler.calls)
end
def test_array
handler = AllHandler.new()
json = %{[true,false]}
Oj.sc_parse(handler, json)
assert_equal([[:array_start],
[:array_append, true],
[:array_append, false],
[:array_end],
[:add_value, []]], handler.calls)
end
def test_hash_empty
handler = AllHandler.new()
json = %{{}}
Oj.sc_parse(handler, json)
assert_equal([[:hash_start],
[:hash_end],
[:add_value, {}]], handler.calls)
end
def test_hash
handler = AllHandler.new()
json = %{{"one":true,"two":false}}
Oj.sc_parse(handler, json)
assert_equal([[:hash_start],
[:hash_key, 'one'],
[:hash_set, 'one', true],
[:hash_key, 'two'],
[:hash_set, 'too', false],
[:hash_end],
[:add_value, {}]], handler.calls)
end
def test_hash_sym
handler = AllHandler.new()
json = %{{"one":true,"two":false}}
Oj.sc_parse(handler, json, :symbol_keys => true)
assert_equal([[:hash_start],
[:hash_key, 'one'],
[:hash_set, 'one', true],
[:hash_key, 'two'],
[:hash_set, 'too', false],
[:hash_end],
[:add_value, {}]], handler.calls)
end
def test_symbol_hash_key_without_symbol_keys
handler = AllHandler.new()
json = %{{"one":true,"symbol":false}}
Oj.sc_parse(handler, json)
assert_equal([[:hash_start],
[:hash_key, 'one'],
[:hash_set, 'one', true],
[:hash_key, 'symbol'],
[:hash_set, :symbol, false],
[:hash_end],
[:add_value, {}]], handler.calls)
end
def test_full
handler = AllHandler.new()
Oj.sc_parse(handler, $json)
assert_equal([[:hash_start],
[:hash_key, 'array'],
[:array_start],
[:hash_start],
[:hash_key, 'num'],
[:hash_set, "num", 3],
[:hash_key, 'string'],
[:hash_set, "string", "message"],
[:hash_key, 'hash'],
[:hash_start],
[:hash_key, 'h2'],
[:hash_start],
[:hash_key, 'a'],
[:array_start],
[:array_append, 1],
[:array_append, 2],
[:array_append, 3],
[:array_end],
[:hash_set, "a", []],
[:hash_end],
[:hash_set, "h2", {}],
[:hash_end],
[:hash_set, "hash", {}],
[:hash_end],
[:array_append, {}],
[:array_end],
[:hash_set, "array", []],
[:hash_key, 'boolean'],
[:hash_set, "boolean", true],
[:hash_end],
[:add_value, {}]], handler.calls)
end
def test_double
handler = AllHandler.new()
json = %{{"one":true,"two":false}{"three":true,"four":false}}
Oj.sc_parse(handler, json) { |j| j }
assert_equal([[:hash_start],
[:hash_key, 'one'],
[:hash_set, 'one', true],
[:hash_key, 'two'],
[:hash_set, 'too', false],
[:hash_end],
[:add_value, {}],
[:hash_start],
[:hash_key, 'three'],
[:hash_set, 'three', true],
[:hash_key, 'four'],
[:hash_set, 'four', false],
[:hash_end],
[:add_value, {}]], handler.calls)
end
def test_none
handler = NoHandler.new()
Oj.sc_parse(handler, $json)
end
def test_fixnum_bad
handler = AllHandler.new()
json = %{12345xyz}
assert_raises Oj::ParseError do
Oj.sc_parse(handler, json)
end
end
def test_null_string
handler = AllHandler.new()
json = %{"\0"}
assert_raises Oj::ParseError do
Oj.sc_parse(handler, json)
end
end
def test_pipe
handler = AllHandler.new()
json = %{{"one":true,"two":false}}
IO.pipe do |read_io, write_io|
if fork
write_io.close
Oj.sc_parse(handler, read_io) {|v| p v}
read_io.close
assert_equal([[:hash_start],
[:hash_key, 'one'],
[:hash_set, 'one', true],
[:hash_key, 'two'],
[:hash_set, 'too', false],
[:hash_end],
[:add_value, {}]], handler.calls)
else
read_io.close
write_io.write json
write_io.close
Process.exit(0)
end
end
end
def test_pipe_close
json = %{{"one":true,"two":false}}
IO.pipe do |read_io, write_io|
if fork
write_io.close
handler = Closer.new(read_io)
err = nil
begin
Oj.sc_parse(handler, read_io)
read_io.close
rescue Exception => e
err = e.class.to_s
end
assert_equal("IOError", err)
assert_equal([[:hash_start],
[:hash_key, 'one'],
[:hash_set, 'one', true]], handler.calls)
else
read_io.close
write_io.write json[0..11]
sleep(0.1)
begin
write_io.write json[12..-1]
rescue Exception => e
# ignore, should fail to write
end
write_io.close
Process.exit(0)
end
end
end
def test_socket_close
json = %{{"one":true,"two":false}}
begin
server = TCPServer.new(8080)
rescue
# Not able to open a socket to run the test. Might be Travis.
return
end
Thread.start(json) do |j|
c = server.accept()
c.puts json[0..11]
10.times {
break if c.closed?
sleep(0.1)
}
unless c.closed?
c.puts json[12..-1]
c.close
end
end
begin
sock = TCPSocket.new('localhost', 8080)
rescue
# Not able to open a socket to run the test. Might be Travis.
return
end
handler = Closer.new(sock)
err = nil
begin
Oj.sc_parse(handler, sock)
rescue Exception => e
err = e.class.to_s
end
assert_equal("IOError", err)
assert_equal([[:hash_start],
[:hash_key, 'one'],
[:hash_set, 'one', true]], handler.calls)
end
end
oj-2.17.4/test/files.rb 0000755 0000041 0000041 00000000760 12766161567 014702 0 ustar www-data www-data #!/usr/bin/env ruby -wW2
if $0 == __FILE__
$: << '.'
$: << '..'
$: << '../lib'
$: << '../ext'
end
require 'pp'
require 'sample/file'
require 'sample/dir'
def files(dir)
d = ::Sample::Dir.new(dir)
Dir.new(dir).each do |fn|
next if fn.start_with?('.')
filename = File.join(dir, fn)
#filename = '.' == dir ? fn : File.join(dir, fn)
if File.directory?(filename)
d << files(filename)
else
d << ::Sample::File.new(filename)
end
end
#pp d
d
end
oj-2.17.4/test/test_bigd.rb 0000755 0000041 0000041 00000003020 12766161567 015534 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$VERBOSE = true
%w(lib ext test).each do |dir|
$LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
end
require 'rubygems' if RUBY_VERSION.start_with?('1.8.')
#require "minitest/spec"
require "minitest/autorun"
require "oj"
# Uncomment this line and test_big_decimal will fail
require "active_support/json"
# With ActiveSupport 4.0, neither of these settings affect BigDecimal#to_json,
# only BigDecimal#as_json
#
# ActiveSupport.encode_big_decimal_as_string = false
# ActiveSupport::JSON::Encoding.encode_big_decimal_as_string = false
describe Oj do
# Options set by default in Rails 4.0 / Rabl
def options
{
:bigdecimal_as_decimal=>true, # default = true
:use_to_json=>true, # default = false
:mode=>:compat, # default = object
:time_format=>:ruby, # default = unix
}
end
def test_big_decimal
orig = BigDecimal.new("3.14159265359")
puts "*** to_s: #{orig.to_s}"
puts "*** to_json: #{orig.to_json}"
puts "*** JSON.dump: #{JSON.dump(orig)}"
json = Oj.dump(orig, options)
puts "*** json: #{json}"
value = Oj.load(json)
puts "*** value: #{value.class}"
assert_equal(value, orig)
# by default, without active support
# assert_equal("0.314159265359E1", json)
# in Rails 4.1, with active support
# assert_equal("3.14159265359", json)
end
# Floats are unaffected
def test_float
orig = 3.14159265359
json = Oj.dump(orig, options)
assert_equal("3.14159265359", json)
end
end
oj-2.17.4/test/helper.rb 0000644 0000041 0000041 00000001355 12766161567 015055 0 ustar www-data www-data # Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
# required. That can be set in the RUBYOPT environment variable.
# export RUBYOPT=-w
$VERBOSE = true
%w(lib ext test).each do |dir|
$LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
end
require 'rubygems' if RUBY_VERSION.start_with?('1.8.')
require 'minitest'
require 'minitest/autorun'
require 'stringio'
require 'date'
require 'bigdecimal'
require 'pp'
require 'oj'
$ruby = RUBY_DESCRIPTION.split(' ')[0]
$ruby = 'ree' if 'ruby' == $ruby && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
class Range
def to_hash()
{ 'begin' => self.begin, 'end' => self.end, 'exclude_end' => self.exclude_end? }
end
end
oj-2.17.4/test/perf_strict.rb 0000755 0000041 0000041 00000010312 12766161567 016116 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << '.'
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
require 'optparse'
require 'perf'
require 'oj'
$verbose = false
$indent = 0
$iter = 20000
$with_bignum = false
$with_nums = true
$size = 0
opts = OptionParser.new
opts.on("-v", "verbose") { $verbose = true }
opts.on("-c", "--count [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-i", "--indent [Int]", Integer, "indentation") { |i| $indent = i }
opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)") { |i| $size = i }
opts.on("-b", "with bignum") { $with_bignum = true }
opts.on("-n", "without numbers") { $with_nums = false }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
if $with_nums
$obj = {
'a' => 'Alpha', # string
'b' => true, # boolean
'c' => 12345, # number
'd' => [ true, [false, [-123456789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
'e' => { 'zero' => nil, 'one' => 1, 'two' => 2, 'three' => [3], 'four' => [0, 1, 2, 3, 4] }, # hash
'f' => nil, # nil
'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
'i' => [[[[[[[nil]]]]]]] # deep array, again, not that deep
}
$obj['g'] = 12345678901234567890123456789 if $with_bignum
else
$obj = {
'a' => 'Alpha',
'b' => true,
'c' => '12345',
'd' => [ true, [false, ['12345', nil], '3.967', ['something', false], nil]],
'e' => { 'zero' => '0', 'one' => '1', 'two' => '2' },
'f' => nil,
'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
'i' => [[[[[[[nil]]]]]]] # deep array, again, not that deep
}
end
Oj.default_options = { :indent => $indent, :mode => :strict }
if 0 < $size
o = $obj
$obj = []
(4 * $size).times do
$obj << o
end
end
$json = Oj.dump($obj)
$obj_json = Oj.dump($obj, :mode => :object)
#puts "*** size: #{$obj_json.size}"
#puts "*** #{$obj_json}"
$failed = {} # key is same as String used in tests later
def capture_error(tag, orig, load_key, dump_key, &blk)
begin
obj = blk.call(orig)
raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
rescue Exception => e
$failed[tag] = "#{e.class}: #{e.message}"
end
end
# Verify that all packages dump and load correctly and return the same Object as the original.
capture_error('Oj:strict', $obj, 'load', 'dump') { |o| Oj.strict_load(Oj.dump(o, :mode => :strict)) }
capture_error('Yajl', $obj, 'encode', 'parse') { |o| require 'yajl'; Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
require 'json'
require 'json/ext'
JSON.generator = JSON::Ext::Generator
JSON.parser = JSON::Ext::Parser
JSON.parse(JSON.generate(o))
}
capture_error('JSON::Pure', $obj, 'generate', 'parse') { |o|
require 'json/pure'
JSON.generator = JSON::Pure::Generator
JSON.parser = JSON::Pure::Parser
JSON.parse(JSON.generate(o))
}
if $verbose
puts "json:\n#{$json}\n"
puts "object json:\n#{$obj_json}\n"
puts "Oj loaded object:\n#{Oj.strict_load($json)}\n"
puts "Yajl loaded object:\n#{Yajl::Parser.parse($json)}\n"
puts "JSON loaded object:\n#{JSON::Ext::Parser.new($json).parse}\n"
end
puts '-' * 80
puts "Strict Parse Performance"
perf = Perf.new()
unless $failed.has_key?('JSON::Ext')
perf.add('JSON::Ext', 'parse') { JSON.parse($json) }
perf.before('JSON::Ext') { JSON.parser = JSON::Ext::Parser }
end
unless $failed.has_key?('JSON::Pure')
perf.add('JSON::Pure', 'parse') { JSON.parse($json) }
perf.before('JSON::Pure') { JSON.parser = JSON::Pure::Parser }
end
unless $failed.has_key?('Oj:strict')
perf.add('Oj:strict', 'strict_load') { Oj.strict_load($json) }
end
perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
perf.run($iter)
puts
puts '-' * 80
puts
unless $failed.empty?
puts "The following packages were not included for the reason listed"
$failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
end
oj-2.17.4/test/test_range.rb 0000755 0000041 0000041 00000000464 12766161567 015734 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$VERBOSE = true
%w(lib ext test).each do |dir|
$LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
end
require 'rubygems' if RUBY_VERSION.start_with?('1.8.')
require 'oj'
Oj.mimic_JSON
#puts Oj.default_options
range = ("01".."12")
puts Oj.dump(range)
oj-2.17.4/test/perf2.rb 0000644 0000041 0000041 00000002727 12766161567 014620 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
#require 'test/unit'
require 'optparse'
require 'yajl'
require 'oj'
$indent = 2
opts = OptionParser.new
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
class Foo
def initialize()
@x = true
@y = 58
end
def to_json()
%{{"x":#{@x},"y":#{@y}}}
end
def to_hash()
{ 'x' => @x, 'y' => @y }
end
end
iter = 100000
s = %{
{ "class": "Foo::Bar",
"attr1": [ true, [false, [12345, null], 3.967, ["something", false], null]],
"attr2": { "one": 1 }
}
}
obj = Oj.load(s)
obj["foo"] = Foo.new()
Oj.default_options = { :indent => 0, :effort => :internal }
puts
start = Time.now
iter.times do
Oj.load(s)
end
dt = Time.now - start
puts "%d Oj.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
start = Time.now
iter.times do
Yajl::Parser.parse(s)
end
dt = Time.now - start
puts "%d Yajl::Parser.parse()s in %0.3f seconds or %0.1f parses/msec" % [iter, dt, iter/dt/1000.0]
puts
start = Time.now
iter.times do
Oj.dump(obj)
end
dt = Time.now - start
puts "%d Oj.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
start = Time.now
iter.times do
Yajl::Encoder.encode(obj)
end
dt = Time.now - start
puts "%d Yajl::Encoder.encode()s in %0.3f seconds or %0.1f encodes/msec" % [iter, dt, iter/dt/1000.0]
puts
oj-2.17.4/test/perf_fast.rb 0000755 0000041 0000041 00000014213 12766161567 015547 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << '.'
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
require 'optparse'
#require 'yajl'
require 'perf'
require 'json'
require 'json/ext'
require 'oj'
$verbose = false
$indent = 0
$iter = 100000
$gets = 0
$fetch = false
$write = false
$read = false
opts = OptionParser.new
opts.on("-v", "verbose") { $verbose = true }
opts.on("-c", "--count [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-i", "--indent [Int]", Integer, "indentation") { |i| $indent = i }
opts.on("-g", "--gets [Int]", Integer, "number of gets") { |i| $gets = i }
opts.on("-f", "fetch") { $fetch = true }
opts.on("-w", "write") { $write = true }
opts.on("-r", "read") { $read = true }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
# This just navigates to each leaf of the JSON structure.
def dig(obj, &blk)
case obj
when Array
obj.each { |e| dig(e, &blk) }
when Hash
obj.values.each { |e| dig(e, &blk) }
else
blk.yield(obj)
end
end
$obj = {
'a' => 'Alpha', # string
'b' => true, # boolean
'c' => 12345, # number
'd' => [ true, [false, {'12345' => 12345, 'nil' => nil}, 3.967, { 'x' => 'something', 'y' => false, 'z' => true}, nil]], # mix it up array
'e' => { 'one' => 1, 'two' => 2 }, # hash
'f' => nil, # nil
'g' => 12345678901234567890123456789, # big number
'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
'i' => [[[[[[[nil]]]]]]] # deep array, again, not that deep
}
Oj.default_options = { :indent => $indent, :mode => :compat }
$json = Oj.dump($obj)
$failed = {} # key is same as String used in tests later
def capture_error(tag, orig, load_key, dump_key, &blk)
begin
obj = blk.call(orig)
raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
rescue Exception => e
$failed[tag] = "#{e.class}: #{e.message}"
end
end
# Verify that all packages dump and load correctly and return the same Object as the original.
capture_error('Oj::Doc', $obj, 'load', 'dump') { |o| Oj::Doc.open(Oj.dump(o, :mode => :strict)) { |f| f.fetch() } }
#capture_error('Yajl', $obj, 'encode', 'parse') { |o| Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o| JSON.generator = JSON::Ext::Generator; JSON::Ext::Parser.new(JSON.generate(o)).parse }
if $verbose
puts "json:\n#{$json}\n"
end
puts '-' * 80
puts "Parse Performance"
perf = Perf.new()
perf.add('Oj::Doc', 'parse') { Oj::Doc.open($json) {|f| } } unless $failed.has_key?('Oj::Doc')
#perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
perf.add('JSON::Ext', 'parse') { JSON::Ext::Parser.new($json).parse } unless $failed.has_key?('JSON::Ext')
perf.run($iter)
puts '-' * 80
puts "JSON generation Performance"
Oj::Doc.open($json) do |doc|
perf = Perf.new()
perf.add('Oj::Doc', 'dump') { doc.dump() }
# perf.add('Yajl', 'encode') { Yajl::Encoder.encode($obj) }
perf.add('JSON::Ext', 'fast_generate') { JSON.fast_generate($obj) }
perf.before('JSON::Ext') { JSON.generator = JSON::Ext::Generator }
perf.run($iter)
end
if 0 < $gets
puts '-' * 80
puts "Parse and get all values Performance"
perf = Perf.new()
perf.add('Oj::Doc', 'parse') { Oj::Doc.open($json) {|f| $gets.times { f.each_value() {} } } } unless $failed.has_key?('Oj::Doc')
# perf.add('Yajl', 'parse') { $gets.times { dig(Yajl::Parser.parse($json)) {} } } unless $failed.has_key?('Yajl')
perf.add('JSON::Ext', 'parse') { $gets.times { dig(JSON::Ext::Parser.new($json).parse) {} } } unless $failed.has_key?('JSON::Ext')
perf.run($iter)
end
if $fetch
puts '-' * 80
puts "fetch nested Performance"
json_hash = Oj.load($json, :mode => :strict)
Oj::Doc.open($json) do |fast|
#puts "*** C fetch: #{fast.fetch('/d/2/4/y')}"
#puts "*** Ruby fetch: #{json_hash.fetch('d', []).fetch(1, []).fetch(3, []).fetch('x', nil)}"
perf = Perf.new()
perf.add('Oj::Doc', 'fetch') { fast.fetch('/d/2/4/x'); fast.fetch('/h/a/b/c/d/e/f/g'); fast.fetch('/i/1/1/1/1/1/1/1') }
# version that fails gracefully
perf.add('Ruby', 'fetch') do
json_hash.fetch('d', []).fetch(1, []).fetch(3, []).fetch('x', nil)
json_hash.fetch('h', {}).fetch('a', {}).fetch('b', {}).fetch('c', {}).fetch('d', {}).fetch('e', {}).fetch('f', {}).fetch('g', {})
json_hash.fetch('i', []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, []).fetch(0, nil)
end
# version that raises if the path is incorrect
# perf.add('Ruby', 'fetch') { $fetch.times { json_hash['d'][1][3][1] } }
perf.run($iter)
end
end
if $write
puts '-' * 80
puts "JSON write to file Performance"
Oj::Doc.open($json) do |doc|
perf = Perf.new()
perf.add('Oj::Doc', 'dump') { doc.dump(nil, 'oj.json') }
# perf.add('Yajl', 'encode') { File.open('yajl.json', 'w') { |f| Yajl::Encoder.encode($obj, f) } }
perf.add('JSON::Ext', 'fast_generate') { File.open('json_ext.json', 'w') { |f| f.write(JSON.fast_generate($obj)) } }
perf.before('JSON::Ext') { JSON.generator = JSON::Ext::Generator }
perf.run($iter)
end
end
if $read
puts '-' * 80
puts "JSON read from file Performance"
Oj::Doc.open($json) { |doc| doc.dump(nil, 'oj.json') }
# File.open('yajl.json', 'w') { |f| Yajl::Encoder.encode($obj, f) }
JSON.generator = JSON::Ext::Generator
File.open('json_ext.json', 'w') { |f| f.write(JSON.fast_generate($obj)) }
Oj::Doc.open($json) do |doc|
perf = Perf.new()
perf.add('Oj::Doc', 'open_file') { ::Oj::Doc.open_file('oj.json') }
# perf.add('Yajl', 'decode') { Yajl::decoder.decode(File.read('yajl.json')) }
perf.add('JSON::Ext', '') { JSON.parse(File.read('json_ext.json')) }
perf.before('JSON::Ext') { JSON.parser = JSON::Ext::Parser }
perf.run($iter)
end
end
unless $failed.empty?
puts "The following packages were not included for the reason listed"
$failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
end
oj-2.17.4/test/perf.rb 0000644 0000041 0000041 00000004636 12766161567 014537 0 ustar www-data www-data
class Perf
def initialize()
@items = []
end
def add(title, op, &blk)
@items << Item.new(title, op, &blk)
end
def before(title, &blk)
@items.each do |i|
if title == i.title
i.set_before(&blk)
break
end
end
end
def run(iter)
base = Item.new(nil, nil) { }
base.run(iter, 0.0)
@items.each do |i|
i.run(iter, base.duration)
if i.error.nil?
puts "#{i.title}.#{i.op} #{iter} times in %0.3f seconds or %0.3f #{i.op}/sec." % [i.duration, iter / i.duration]
else
puts "***** #{i.title}.#{i.op} failed! #{i.error}"
end
end
summary()
end
def summary()
fastest = nil
slowest = nil
width = 6
@items.each do |i|
next if i.duration.nil?
width = i.title.size if width < i.title.size
end
iva = @items.clone
iva.delete_if { |i| i.duration.nil? }
iva = iva.sort_by { |i| i.duration }
puts
puts "Summary:"
puts "%*s time (secs) rate (ops/sec)" % [width, 'System']
puts "#{'-' * width} ----------- --------------"
iva.each do |i|
if i.duration.nil?
else
puts "%*s %11.3f %14.3f" % [width, i.title, i.duration, i.rate ]
end
end
puts
puts "Comparison Matrix\n(performance factor, 2.0 means row is twice as fast as column)"
puts ([' ' * width] + iva.map { |i| "%*s" % [width, i.title] }).join(' ')
puts (['-' * width] + iva.map { |i| '-' * width }).join(' ')
iva.each do |i|
line = ["%*s" % [width, i.title]]
iva.each do |o|
line << "%*.2f" % [width, o.duration / i.duration]
end
puts line.join(' ')
end
puts
end
class Item
attr_accessor :title
attr_accessor :op
attr_accessor :blk
attr_accessor :duration
attr_accessor :rate
attr_accessor :error
def initialize(title, op, &blk)
@title = title
@blk = blk
@op = op
@duration = nil
@rate = nil
@error = nil
@before = nil
end
def set_before(&blk)
@before = blk
end
def run(iter, base)
begin
GC.start
@before.call unless @before.nil?
start = Time.now
iter.times { @blk.call }
@duration = Time.now - start - base
@duration = 0.0 if @duration < 0.0
@rate = iter / @duration
rescue Exception => e
@error = "#{e.class}: #{e.message}"
end
end
end # Item
end # Perf
oj-2.17.4/test/perf_saj.rb 0000755 0000041 0000041 00000006244 12766161567 015374 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << '.'
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
require 'optparse'
require 'yajl'
require 'perf'
require 'json'
require 'json/ext'
require 'oj'
$verbose = false
$indent = 0
$iter = 10000
$gets = 0
$fetch = false
$write = false
$read = false
opts = OptionParser.new
opts.on("-v", "verbose") { $verbose = true }
opts.on("-c", "--count [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-i", "--indent [Int]", Integer, "indentation") { |i| $indent = i }
opts.on("-g", "--gets [Int]", Integer, "number of gets") { |i| $gets = i }
opts.on("-f", "fetch") { $fetch = true }
opts.on("-w", "write") { $write = true }
opts.on("-r", "read") { $read = true }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
class AllSaj < Oj::Saj
def initialize()
end
def hash_start(key)
end
def hash_end(key)
end
def array_start(key)
end
def array_end(key)
end
def add_value(value, key)
end
end # AllSaj
class NoSaj < Oj::Saj
def initialize()
end
end # NoSaj
saj_handler = AllSaj.new()
no_saj = NoSaj.new()
$obj = {
'a' => 'Alpha', # string
'b' => true, # boolean
'c' => 12345, # number
'd' => [ true, [false, {'12345' => 12345, 'nil' => nil}, 3.967, { 'x' => 'something', 'y' => false, 'z' => true}, nil]], # mix it up array
'e' => { 'one' => 1, 'two' => 2 }, # hash
'f' => nil, # nil
'g' => 12345678901234567890123456789, # big number
'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
'i' => [[[[[[[nil]]]]]]] # deep array, again, not that deep
}
Oj.default_options = { :indent => $indent, :mode => :compat }
$json = Oj.dump($obj)
$failed = {} # key is same as String used in tests later
def capture_error(tag, orig, load_key, dump_key, &blk)
begin
obj = blk.call(orig)
raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
rescue Exception => e
$failed[tag] = "#{e.class}: #{e.message}"
end
end
# Verify that all packages dump and load correctly and return the same Object as the original.
capture_error('Yajl', $obj, 'encode', 'parse') { |o| Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o| JSON.generator = JSON::Ext::Generator; JSON::Ext::Parser.new(JSON.generate(o)).parse }
if $verbose
puts "json:\n#{$json}\n"
end
puts '-' * 80
puts "Parse Performance"
perf = Perf.new()
perf.add('Oj::Saj', 'all') { Oj.saj_parse(saj_handler, $json) }
perf.add('Oj::Saj', 'none') { Oj.saj_parse(no_saj, $json) }
perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
perf.add('JSON::Ext', 'parse') { JSON::Ext::Parser.new($json).parse } unless $failed.has_key?('JSON::Ext')
perf.run($iter)
unless $failed.empty?
puts "The following packages were not included for the reason listed"
$failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
end
oj-2.17.4/test/perf_file.rb 0000755 0000041 0000041 00000003530 12766161567 015531 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
$: << '.'
$: << '../lib'
$: << '../ext'
if __FILE__ == $0
if (i = ARGV.index('-I'))
x,path = ARGV.slice!(i, 2)
$: << path
end
end
require 'optparse'
require 'oj'
require 'perf'
$indent = 0
$iter = 1
$size = 1
opts = OptionParser.new
opts.on("-r", "read") { do_read = true }
opts.on("-c", "--count [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-i", "--indent [Int]", Integer, "indent") { |i| $indent = i }
opts.on("-s", "--size [Int]", Integer, "size in Mbytes") { |s| $size = s }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
$obj = {
'a' => 'Alpha', # string
'b' => true, # boolean
'c' => 12345, # number
'd' => [ true, [false, [-123456789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
'e' => { 'zero' => nil, 'one' => 1, 'two' => 2, 'three' => [3], 'four' => [0, 1, 2, 3, 4] }, # hash
'f' => nil, # nil
'g' => 12345678901234567890123456789, #_bignum
'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
'i' => [[[[[[[nil]]]]]]] # deep array, again, not that deep
}
json = Oj.dump($obj, :indent => $indent)
cnt = ($size * 1024 * 1024 + json.size) / json.size
cnt = 1 if 0 == $size
filename = 'tmp.json'
File.open(filename, "w") { |f|
cnt.times do
Oj.to_stream(f, $obj, :indent => $indent)
end
}
Oj.default_options = { :mode => :strict, :indent => $indent }
puts '-' * 80
puts "Read from #{cnt * json.size / (1024 * 1024)} Mb file Performance"
perf = Perf.new()
perf.add('Oj.load_file', '') { Oj.load_file(filename) }
perf.add('Oj.load(string)', '') { Oj.load(File.read(filename)) }
perf.add('Oj.load(file)', '') { File.open(filename, 'r') { |f| Oj.load(f) } }
perf.run($iter)
oj-2.17.4/test/test_saj.rb 0000755 0000041 0000041 00000010523 12766161567 015412 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
$json = %{{
"array": [
{
"num" : 3,
"string": "message",
"hash" : {
"h2" : {
"a" : [ 1, 2, 3 ]
}
}
}
],
"boolean" : true
}}
class AllSaj < Oj::Saj
attr_accessor :calls
def initialize()
@calls = []
end
def hash_start(key)
@calls << [:hash_start, key]
end
def hash_end(key)
@calls << [:hash_end, key]
end
def array_start(key)
@calls << [:array_start, key]
end
def array_end(key)
@calls << [:array_end, key]
end
def add_value(value, key)
@calls << [:add_value, value, key]
end
def error(message, line, column)
@calls << [:error, message, line, column]
end
end # AllSaj
class SajTest < Minitest::Test
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_nil
handler = AllSaj.new()
json = %{null}
Oj.saj_parse(handler, json)
assert_equal([[:add_value, nil, nil]], handler.calls)
end
def test_true
handler = AllSaj.new()
json = %{true}
Oj.saj_parse(handler, json)
assert_equal([[:add_value, true, nil]], handler.calls)
end
def test_false
handler = AllSaj.new()
json = %{false}
Oj.saj_parse(handler, json)
assert_equal([[:add_value, false, nil]], handler.calls)
end
def test_string
handler = AllSaj.new()
json = %{"a string"}
Oj.saj_parse(handler, json)
assert_equal([[:add_value, 'a string', nil]], handler.calls)
end
def test_fixnum
handler = AllSaj.new()
json = %{12345}
Oj.saj_parse(handler, json)
assert_equal([[:add_value, 12345, nil]], handler.calls)
end
def test_float
handler = AllSaj.new()
json = %{12345.6789}
Oj.saj_parse(handler, json)
assert_equal([[:add_value, 12345.6789, nil]], handler.calls)
end
def test_float_exp
handler = AllSaj.new()
json = %{12345.6789e7}
Oj.saj_parse(handler, json)
assert_equal(1, handler.calls.size)
assert_equal(:add_value, handler.calls[0][0])
assert_equal((12345.6789e7 * 10000).to_i, (handler.calls[0][1] * 10000).to_i)
end
def test_array_empty
handler = AllSaj.new()
json = %{[]}
Oj.saj_parse(handler, json)
assert_equal([[:array_start, nil],
[:array_end, nil]], handler.calls)
end
def test_array
handler = AllSaj.new()
json = %{[true,false]}
Oj.saj_parse(handler, json)
assert_equal([[:array_start, nil],
[:add_value, true, nil],
[:add_value, false, nil],
[:array_end, nil]], handler.calls)
end
def test_hash_empty
handler = AllSaj.new()
json = %{{}}
Oj.saj_parse(handler, json)
assert_equal([[:hash_start, nil],
[:hash_end, nil]], handler.calls)
end
def test_hash
handler = AllSaj.new()
json = %{{"one":true,"two":false}}
Oj.saj_parse(handler, json)
assert_equal([[:hash_start, nil],
[:add_value, true, 'one'],
[:add_value, false, 'two'],
[:hash_end, nil]], handler.calls)
end
def test_full
handler = AllSaj.new()
Oj.saj_parse(handler, $json)
assert_equal([[:hash_start, nil],
[:array_start, 'array'],
[:hash_start, nil],
[:add_value, 3, 'num'],
[:add_value, 'message', 'string'],
[:hash_start, 'hash'],
[:hash_start, 'h2'],
[:array_start, 'a'],
[:add_value, 1, nil],
[:add_value, 2, nil],
[:add_value, 3, nil],
[:array_end, 'a'],
[:hash_end, 'h2'],
[:hash_end, 'hash'],
[:hash_end, nil],
[:array_end, 'array'],
[:add_value, true, 'boolean'],
[:hash_end, nil]], handler.calls)
end
def test_fixnum_bad
handler = AllSaj.new()
json = %{12345xyz}
Oj.saj_parse(handler, json)
assert_equal([:add_value, 12345, nil], handler.calls.first)
type, message, line, column = handler.calls.last
assert_equal([:error, 1, 6], [type, line, column])
assert_match(%r{invalid format, extra characters at line 1, column 6 \[(?:[a-z\.]+/)*saj\.c:\d+\]}, message)
end
end
oj-2.17.4/test/test_fast.rb 0000755 0000041 0000041 00000026171 12766161567 015600 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
$json1 = %|{
"array": [
{
"num" : 3,
"string": "message",
"hash" : {
"h2" : {
"a" : [ 1, 2, 3 ]
}
}
}
],
"boolean" : true
}|
class DocTest < Minitest::Test
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_nil
json = %{null}
Oj::Doc.open(json) do |doc|
assert_equal(NilClass, doc.type)
assert_equal(nil, doc.fetch())
end
end
def test_true
json = %{true}
Oj::Doc.open(json) do |doc|
assert_equal(TrueClass, doc.type)
assert_equal(true, doc.fetch())
end
end
def test_false
json = %{false}
Oj::Doc.open(json) do |doc|
assert_equal(FalseClass, doc.type)
assert_equal(false, doc.fetch())
end
end
def test_string
json = %{"a string"}
Oj::Doc.open(json) do |doc|
assert_equal(String, doc.type)
assert_equal('a string', doc.fetch())
end
end
def test_encoding
json = %{"ぴーたー"}
Oj::Doc.open(json) do |doc|
assert_equal(String, doc.type)
assert_equal("ぴーたー", doc.fetch())
end
end
def test_encoding_escaped
json = %{"\\u3074\\u30fc\\u305f\\u30fc"}
Oj::Doc.open(json) do |doc|
assert_equal(String, doc.type)
assert_equal("ぴーたー", doc.fetch())
end
end
def test_fixnum
json = %{12345}
Oj::Doc.open(json) do |doc|
assert_equal(Fixnum, doc.type)
assert_equal(12345, doc.fetch())
end
end
def test_float
json = %{12345.6789}
Oj::Doc.open(json) do |doc|
assert_equal(Float, doc.type)
assert_equal(12345.6789, doc.fetch())
end
end
def test_float_exp
json = %{12345.6789e7}
Oj::Doc.open(json) do |doc|
assert_equal(Float, doc.type)
#assert_equal(12345.6789e7, doc.fetch())
assert_equal(12345.6789e7.to_i, doc.fetch().to_i)
end
end
def test_array_empty
json = %{[]}
Oj::Doc.open(json) do |doc|
assert_equal(Array, doc.type)
assert_equal([], doc.fetch())
end
end
def test_array
json = %{[true,false]}
Oj::Doc.open(json) do |doc|
assert_equal(Array, doc.type)
assert_equal([true, false], doc.fetch())
end
end
def test_hash_empty
json = %{{}}
Oj::Doc.open(json) do |doc|
assert_equal(Hash, doc.type)
assert_equal({}, doc.fetch())
end
end
def test_hash
json = %{{"one":true,"two":false}}
Oj::Doc.open(json) do |doc|
assert_equal(Hash, doc.type)
assert_equal({'one' => true, 'two' => false}, doc.fetch())
end
end
# move() and where?()
def test_move_hash
json = %{{"one":{"two":false}}}
Oj::Doc.open(json) do |doc|
doc.move('/one')
assert_equal('/one', doc.where?)
doc.move('/one/two')
assert_equal('/one/two', doc.where?)
end
end
def test_move_array
json = %{[1,[2,true]]}
Oj::Doc.open(json) do |doc|
doc.move('/1')
assert_equal('/1', doc.where?)
doc.move('/2/1')
assert_equal('/2/1', doc.where?)
end
end
def test_move
Oj::Doc.open($json1) do |doc|
[ '/',
'/array',
'/boolean',
'/array/1/hash/h2/a/3',
].each do |p|
doc.move(p)
assert_equal(p, doc.where?)
end
begin
doc.move('/array/x')
rescue Exception
assert_equal('/', doc.where?)
assert(true)
end
end
end
def test_move_relative
Oj::Doc.open($json1) do |doc|
[['/', 'array', '/array'],
['/array', '1/num', '/array/1/num'],
['/array/1/hash', 'h2/a', '/array/1/hash/h2/a'],
['/array/1', 'hash/h2/a/2', '/array/1/hash/h2/a/2'],
['/array/1/hash', '../string', '/array/1/string'],
['/array/1/hash', '..', '/array/1'],
].each do |start,path,where|
doc.move(start)
doc.move(path)
assert_equal(where, doc.where?)
end
end
end
def test_type
Oj::Doc.open($json1) do |doc|
[['/', Hash],
['/array', Array],
['/array/1', Hash],
['/array/1/num', Fixnum],
['/array/1/string', String],
['/array/1/hash/h2/a', Array],
['/array/1/hash/../num', Fixnum],
['/array/1/hash/../..', Array],
].each do |path,type|
assert_equal(type, doc.type(path))
end
end
end
def test_local_key
Oj::Doc.open($json1) do |doc|
[['/', nil],
['/array', 'array'],
['/array/1', 1],
['/array/1/num', 'num'],
['/array/1/string', 'string'],
['/array/1/hash/h2/a', 'a'],
['/array/1/hash/../num', 'num'],
['/array/1/hash/..', 1],
['/array/1/hash/../..', 'array'],
].each do |path,key|
doc.move(path)
assert_equal(key, doc.local_key())
end
end
end
def test_fetch_move
Oj::Doc.open($json1) do |doc|
[['/array/1/num', 3],
['/array/1/string', 'message'],
['/array/1/hash/h2/a', [1, 2, 3]],
['/array/1/hash/../num', 3],
['/array/1/hash/..', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
['/array/1/hash/../..', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
['/array/1', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
['/array', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
['/', {'array' => [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}], 'boolean' => true}],
].each do |path,val|
doc.move(path)
assert_equal(val, doc.fetch())
end
end
end
def test_fetch_path
Oj::Doc.open($json1) do |doc|
[['/array/1/num', 3],
['/array/1/string', 'message'],
['/array/1/hash/h2/a', [1, 2, 3]],
['/array/1/hash/../num', 3],
['/array/1/hash/..', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
['/array/1/hash/../..', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
['/array/1', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
['/array', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
['/', {'array' => [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}], 'boolean' => true}],
].each do |path,val|
assert_equal(val, doc.fetch(path))
end
end
end
def test_move_fetch_path
Oj::Doc.open($json1) do |doc|
[['/array/1', 'num', 3],
['/array/1', 'string', 'message'],
['/array/1/hash', 'h2/a', [1, 2, 3]],
].each do |path,fetch_path,val|
doc.move(path)
assert_equal(val, doc.fetch(fetch_path))
end
end
end
def test_home
Oj::Doc.open($json1) do |doc|
doc.move('/array/1/num')
doc.home()
assert_equal('/', doc.where?)
end
end
def test_each_value_root
Oj::Doc.open($json1) do |doc|
values = []
doc.each_value() { |v| values << v.to_s }
assert_equal(['1', '2', '3', '3', 'message', 'true'], values.sort)
end
end
def test_each_value_move
Oj::Doc.open($json1) do |doc|
doc.move('/array/1/hash')
values = []
doc.each_value() { |v| values << v.to_s }
assert_equal(['1', '2', '3'], values.sort)
end
end
def test_each_value_path
Oj::Doc.open($json1) do |doc|
values = []
doc.each_value('/array/1/hash') { |v| values << v.to_s }
assert_equal(['1', '2', '3'], values.sort)
end
end
def test_each_child_move
Oj::Doc.open($json1) do |doc|
locations = []
doc.move('/array/1/hash/h2/a')
doc.each_child() { |d| locations << d.where? }
assert_equal(['/array/1/hash/h2/a/1', '/array/1/hash/h2/a/2', '/array/1/hash/h2/a/3'], locations)
locations = []
doc.move('/array/1')
doc.each_child() { |d| locations << d.where? }
assert_equal(['/array/1/num', '/array/1/string', '/array/1/hash'], locations)
end
end
def test_each_child_path
Oj::Doc.open($json1) do |doc|
locations = []
doc.each_child('/array/1/hash/h2/a') { |d| locations << d.where? }
assert_equal(['/array/1/hash/h2/a/1', '/array/1/hash/h2/a/2', '/array/1/hash/h2/a/3'], locations)
locations = []
doc.each_child('/array/1') { |d| locations << d.where? }
assert_equal(['/array/1/num', '/array/1/string', '/array/1/hash'], locations)
end
end
def test_size
Oj::Doc.open('[1,2,3]') do |doc|
assert_equal(4, doc.size)
end
Oj::Doc.open('{"a":[1,2,3]}') do |doc|
assert_equal(5, doc.size)
end
end
def test_open_file
filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
File.open(filename, 'w') { |f| f.write('{"a":[1,2,3]}') }
Oj::Doc.open_file(filename) do |doc|
assert_equal(5, doc.size)
end
end
def test_open_close
json = %{{"a":[1,2,3]}}
doc = Oj::Doc.open(json)
assert_equal(Oj::Doc, doc.class)
assert_equal(5, doc.size)
assert_equal('/', doc.where?)
doc.move('a/1')
doc.home()
assert_equal(2, doc.fetch('/a/2'))
assert_equal(2, doc.fetch('a/2'))
doc.close()
begin
doc.home()
rescue Exception
assert(true)
end
end
def test_file_open_close
filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
File.open(filename, 'w') { |f| f.write('{"a":[1,2,3]}') }
doc = Oj::Doc.open_file(filename)
assert_equal(Oj::Doc, doc.class)
assert_equal(5, doc.size)
assert_equal('/', doc.where?)
doc.move('a/1')
doc.home()
assert_equal(2, doc.fetch('/a/2'))
assert_equal(2, doc.fetch('a/2'))
doc.close()
begin
doc.home()
rescue Exception
assert(true)
end
end
def test_open_no_close
json = %{{"a":[1,2,3]}}
doc = Oj::Doc.open(json)
assert_equal(Oj::Doc, doc.class)
assert_equal(5, doc.size)
assert_equal('/', doc.where?)
doc.move('a/1')
doc.home()
assert_equal(2, doc.fetch('/a/2'))
assert_equal(2, doc.fetch('a/2'))
doc = nil
GC.start
# a print statement confirms close is called
end
def test_dump
Oj::Doc.open('[1,[2,3]]') do |doc|
assert_equal('[1,[2,3]]', doc.dump())
end
Oj::Doc.open('[1,[2,3]]') do |doc|
assert_equal('[2,3]', doc.dump('/2'))
end
end
def test_each_leaf
results = Oj::Doc.open('[1,[2,3]]') do |doc|
h = {}
doc.each_leaf() { |d| h[d.where?] = d.fetch() }
h
end
assert_equal({'/1' => 1, '/2/1' => 2, '/2/2' => 3}, results)
end
def test_each_leaf_hash
results = Oj::Doc.open('{"a":{"x":2},"b":{"y":4}}') do |doc|
h = {}
doc.each_leaf() { |d| h[d.where?] = d.fetch() }
h
end
assert_equal({'/a/x' => 2, '/b/y' => 4}, results)
end
def test_comment
json = %{{
"x"/*one*/:/*two*/true,//three
"y":58/*four*/,
"z": [1,2/*five*/,
3 // six
]
}
}
results = Oj::Doc.open(json) do |doc|
h = {}
doc.each_leaf() { |d| h[d.where?] = d.fetch() }
h
end
assert_equal({'/x' => true, '/y' => 58, '/z/1' => 1, '/z/2' => 2, '/z/3' => 3}, results)
end
end # DocTest
oj-2.17.4/test/test_file.rb 0000755 0000041 0000041 00000013620 12766161567 015555 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class FileJuice < Minitest::Test
class Jam
attr_accessor :x, :y
def initialize(x, y)
@x = x
@y = y
end
def eql?(o)
self.class == o.class && @x == o.x && @y == o.y
end
alias == eql?
end# Jam
class Jeez < Jam
def initialize(x, y)
super
end
def to_json()
%{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end# Jeez
class Orange < Jam
def initialize(x, y)
super
end
def as_json()
{ :json_class => self.class,
:x => @x,
:y => @y }
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_nil
dump_and_load(nil, false)
end
def test_true
dump_and_load(true, false)
end
def test_false
dump_and_load(false, false)
end
def test_fixnum
dump_and_load(0, false)
dump_and_load(12345, false)
dump_and_load(-54321, false)
dump_and_load(1, false)
end
def test_float
mode = Oj.default_options()[:mode]
Oj.default_options = {:mode => :object}
dump_and_load(0.0, false)
dump_and_load(12345.6789, false)
dump_and_load(70.35, false)
dump_and_load(-54321.012, false)
dump_and_load(1.7775, false)
dump_and_load(2.5024, false)
dump_and_load(2.48e16, false)
dump_and_load(2.48e100 * 1.0e10, false)
dump_and_load(-2.48e100 * 1.0e10, false)
dump_and_load(1/0.0, false)
Oj.default_options = {:mode => mode}
end
def test_string
dump_and_load('', false)
dump_and_load('abc', false)
dump_and_load("abc\ndef", false)
dump_and_load("a\u0041", false)
assert_equal("a\u0000a", dump_and_load("a\u0000a", false))
end
def test_string_object
dump_and_load('abc', false)
dump_and_load(':abc', false)
end
def test_array
dump_and_load([], false)
dump_and_load([true, false], false)
dump_and_load(['a', 1, nil], false)
dump_and_load([[nil]], false)
dump_and_load([[nil], 58], false)
end
# Symbol
def test_symbol_object
Oj.default_options = { :mode => :object }
#dump_and_load(''.to_sym, false)
dump_and_load(:abc, false)
dump_and_load(':xyz'.to_sym, false)
end
# Time
def test_time_object
t = Time.now()
Oj.default_options = { :mode => :object, :time_format => :unix_zone }
dump_and_load(t, false)
end
def test_time_object_early
t = Time.xmlschema("1954-01-05T00:00:00.123456")
Oj.default_options = { :mode => :object, :time_format => :unix_zone }
dump_and_load(t, false)
end
# Hash
def test_hash
Oj.default_options = { :mode => :strict }
dump_and_load({}, false)
dump_and_load({ 'true' => true, 'false' => false}, false)
dump_and_load({ 'true' => true, 'array' => [], 'hash' => { }}, false)
end
# Object with to_json()
def test_json_object_compat
Oj.default_options = { :mode => :compat, :use_to_json => true }
obj = Jeez.new(true, 58)
json = Oj.dump(obj, :indent => 2)
assert(%{{"json_class":"FileJuice::Jeez","x":true,"y":58}
} == json ||
%{{"json_class":"FileJuice::Jeez","y":58,"x":true}
} == json)
dump_and_load(obj, false)
Oj.default_options = { :mode => :compat, :use_to_json => false }
end
def test_as_json_object_compat_hash
Oj.default_options = { :mode => :compat, :use_to_json => true }
obj = Orange.new(true, 58)
json = Oj.dump(obj, :indent => 2)
assert(!json.nil?)
dump_and_load(obj, false)
end
# Range
def test_range_object
unless RUBY_VERSION.start_with?('1.8')
Oj.default_options = { :mode => :object }
json = Oj.dump(1..7, :mode => :object, :indent => 0)
if 'rubinius' == $ruby
assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
elsif 'jruby' == $ruby
assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
else
assert_equal(%{{"^u":["Range",1,7,false]}}, json)
end
dump_and_load(1..7, false)
dump_and_load(1..1, false)
dump_and_load(1...7, false)
end
end
# BigNum
def test_bignum_object
Oj.default_options = { :mode => :compat }
dump_and_load(7 ** 55, false)
end
# BigDecimal
def test_bigdecimal_strict
mode = Oj.default_options[:mode]
Oj.default_options = {:mode => :strict}
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
Oj.default_options = {:mode => mode}
end
def test_bigdecimal_null
mode = Oj.default_options[:mode]
Oj.default_options = {:mode => :null}
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
Oj.default_options = {:mode => mode}
end
def test_bigdecimal_object
Oj.default_options = {:mode => :object}
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
end
# Date
def test_date_object
Oj.default_options = { :mode => :object }
dump_and_load(Date.new(2012, 6, 19), false)
end
# DateTime
def test_datetime_object
Oj.default_options = { :mode => :object }
dump_and_load(DateTime.new(2012, 6, 19), false)
end
def dump_and_load(obj, trace=false)
filename = File.join(File.dirname(__FILE__), 'file_test.json')
File.open(filename, "w") { |f|
Oj.to_stream(f, obj, :indent => 2)
}
puts "\n*** file: '#{File.read(filename)}'" if trace
loaded = Oj.load_file(filename)
if obj.is_a?(Time) && loaded.is_a?(Time)
assert_equal(obj.tv_sec, loaded.tv_sec)
if obj.respond_to?(:tv_nsec)
assert_equal(obj.tv_nsec, loaded.tv_nsec)
else
assert_equal(obj.tv_usec, loaded.tv_usec)
end
assert_equal(obj.utc?, loaded.utc?)
assert_equal(obj.utc_offset, loaded.utc_offset)
else
assert_equal(obj, loaded)
end
loaded
end
end
oj-2.17.4/test/test_various.rb 0000755 0000041 0000041 00000111004 12766161567 016321 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class Juice < Minitest::Test
module TestModule
end
class Jam
attr_accessor :x, :y
def initialize(x, y)
@x = x
@y = y
end
def eql?(o)
self.class == o.class && @x == o.x && @y == o.y
end
alias == eql?
end# Jam
class Jeez < Jam
def initialize(x, y)
super
end
def to_json()
%{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end# Jeez
# contributed by sauliusg to fix as_json
class Orange < Jam
def initialize(x, y)
super
end
def as_json()
{ :json_class => self.class,
:x => @x,
:y => @y }
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end
class Melon < Jam
def initialize(x, y)
super
end
def as_json()
"#{x} #{y}"
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end
class Jazz < Jam
def initialize(x, y)
super
end
def to_hash()
{ 'json_class' => self.class.to_s, 'x' => @x, 'y' => @y }
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end# Jazz
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
=begin
# Depending on the order the values may have changed. The set_options sets
# should cover the function itself.
def test_get_options
opts = Oj.default_options()
assert_equal({ :indent=>0,
:second_precision=>9,
:circular=>false,
:class_cache=>true,
:auto_define=>false,
:symbol_keys=>false,
:bigdecimal_as_decimal=>true,
:use_to_json=>true,
:nilnil=>false,
:allow_gc=>true,
:quirks_mode=>true,
:allow_invalid_unicode=>false,
:float_precision=>15,
:mode=>:object,
:escape_mode=>:json,
:time_format=>:unix_zone,
:bigdecimal_load=>:auto,
:create_id=>'json_class'}, opts)
end
=end
def test_set_options
orig = Oj.default_options()
alt ={
:indent=>" - ",
:second_precision=>5,
:circular=>true,
:class_cache=>false,
:auto_define=>true,
:symbol_keys=>true,
:bigdecimal_as_decimal=>false,
:use_to_json=>false,
:nilnil=>true,
:allow_gc=>false,
:quirks_mode=>false,
:allow_invalid_unicode=>true,
:float_precision=>13,
:mode=>:strict,
:escape_mode=>:ascii,
:time_format=>:unix_zone,
:bigdecimal_load=>:float,
:create_id=>'classy',
:space=>'z',
:array_nl=>'a',
:object_nl=>'o',
:space_before=>'b',
:nan=>:huge,
:hash_class=>Hash,
:omit_nil=>false,
}
Oj.default_options = alt
opts = Oj.default_options()
assert_equal(alt, opts);
Oj.default_options = orig # return to original
# verify back to original
opts = Oj.default_options()
assert_equal(orig, opts);
end
def test_nil
dump_and_load(nil, false)
end
def test_true
dump_and_load(true, false)
end
def test_false
dump_and_load(false, false)
end
def test_fixnum
dump_and_load(0, false)
dump_and_load(12345, false)
dump_and_load(-54321, false)
dump_and_load(1, false)
end
def test_float_parse
Oj.default_options = { :float_precision => 16, :bigdecimal_load => :auto }
n = Oj.load('0.00001234567890123456')
assert_equal(Float, n.class)
assert_equal('1.234567890123456e-05', "%0.15e" % [n])
n = Oj.load('-0.00001234567890123456')
assert_equal(Float, n.class)
assert_equal('-1.234567890123456e-05', "%0.15e" % [n])
n = Oj.load('1000.0000123456789')
assert_equal(BigDecimal, n.class)
assert_equal('0.10000000123456789E4', n.to_s)
n = Oj.load('-0.000012345678901234567')
assert_equal(BigDecimal, n.class)
assert_equal('-0.12345678901234567E-4', n.to_s)
end
def test_float_dump
Oj.default_options = { :float_precision => 16 }
assert_equal('1405460727.723866', Oj.dump(1405460727.723866))
Oj.default_options = { :float_precision => 5 }
assert_equal('1.4055', Oj.dump(1.405460727))
Oj.default_options = { :float_precision => 0 }
if RUBY_VERSION.start_with?('1.8')
assert_equal('1405460727.72387', Oj.dump(1405460727.723866))
else
assert_equal('1405460727.723866', Oj.dump(1405460727.723866))
end
Oj.default_options = { :float_precision => 15 }
assert_equal('0.56', Oj.dump(0.56))
assert_equal('0.5773', Oj.dump(0.5773))
assert_equal('0.6768', Oj.dump(0.6768))
assert_equal('0.685', Oj.dump(0.685))
assert_equal('0.7032', Oj.dump(0.7032))
assert_equal('0.7051', Oj.dump(0.7051))
assert_equal('0.8274', Oj.dump(0.8274))
assert_equal('0.9149', Oj.dump(0.9149))
assert_equal('64.4', Oj.dump(64.4))
assert_equal('71.6', Oj.dump(71.6))
assert_equal('73.4', Oj.dump(73.4))
assert_equal('80.6', Oj.dump(80.6))
assert_equal('-95.640172', Oj.dump(-95.640172))
end
def test_nan_dump
assert_equal('null', Oj.dump(0/0.0, :mode => :strict, :nan => :null))
assert_equal('NaN', Oj.dump(0/0.0, :mode => :strict, :nan => :word))
assert_equal('3.3e14159265358979323846', Oj.dump(0/0.0, :mode => :strict, :nan => :huge))
end
def test_infinity_dump
assert_equal('null', Oj.dump(1/0.0, :mode => :strict, :nan => :null))
assert_equal('Infinity', Oj.dump(1/0.0, :mode => :strict, :nan => :word))
assert_equal('3.0e14159265358979323846', Oj.dump(1/0.0, :mode => :strict, :nan => :huge))
end
def test_neg_infinity_dump
assert_equal('null', Oj.dump(-1/0.0, :mode => :strict, :nan => :null))
assert_equal('-Infinity', Oj.dump(-1/0.0, :mode => :strict, :nan => :word))
assert_equal('-3.0e14159265358979323846', Oj.dump(-1/0.0, :mode => :strict, :nan => :huge))
end
def test_float
mode = Oj.default_options()[:mode]
Oj.default_options = {:mode => :object}
dump_and_load(0.0, false)
dump_and_load(12345.6789, false)
dump_and_load(70.35, false)
dump_and_load(-54321.012, false)
dump_and_load(1.7775, false)
dump_and_load(2.5024, false)
dump_and_load(2.48e16, false)
dump_and_load(2.48e100 * 1.0e10, false)
dump_and_load(-2.48e100 * 1.0e10, false)
dump_and_load(1/0.0, false)
# NaN does not always == NaN
json = Oj.dump(0/0.0)
assert_equal('3.3e14159265358979323846', json)
loaded = Oj.load(json);
assert_equal(true, loaded.nan?)
Oj.default_options = {:mode => mode}
end
def test_string
dump_and_load('', false)
dump_and_load('abc', false)
dump_and_load("abc\ndef", false)
dump_and_load("a\u0041", false)
assert_equal("a\u0000a", dump_and_load("a\u0000a", false))
end
def test_string_object
Oj.default_options = {:mode => :object}
dump_and_load('abc', false)
dump_and_load(':abc', false)
end
def test_encode
opts = Oj.default_options
Oj.default_options = { :ascii_only => false }
dump_and_load("ぴーたー", false)
Oj.default_options = { :ascii_only => true }
json = Oj.dump("ぴーたー")
assert_equal(%{"\\u3074\\u30fc\\u305f\\u30fc"}, json)
dump_and_load("ぴーたー", false)
Oj.default_options = opts
end
def test_unicode
# hits the 3 normal ranges and one extended surrogate pair
json = %{"\\u019f\\u05e9\\u3074\\ud834\\udd1e"}
obj = Oj.load(json)
json2 = Oj.dump(obj, :ascii_only => true)
assert_equal(json, json2)
end
def test_invalid_unicode_raise
# validate that an invalid unicode raises unless the :allow_invalid_unicode is true
json = %{"x\\ud83dy"}
begin
Oj.load(json)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_invalid_unicode_ok
# validate that an invalid unicode raises unless the :allow_invalid_unicode is true
json = %{"x\\ud83dy"}
obj = Oj.load(json, :allow_invalid_unicode => true)
# The same as what ruby would do with the invalid encoding.
assert_equal("x\xED\xA0\xBDy", obj.to_s)
end
def test_dump_options
json = Oj.dump({ 'a' => 1, 'b' => [true, false]},
:mode => :compat,
:indent => "--",
:array_nl => "\n",
:object_nl => "#\n",
:space => "*",
:space_before => "~")
assert(%{{#
--"a"~:*1,#
--"b"~:*[
----true,
----false
--]#
}} == json ||
%{{#
--"b"~:*[
----true,
----false
--],#
--"a"~:*1#
}} == json)
end
def test_null_char
assert_raises(Oj::ParseError) { Oj.load("\"\0\"") }
assert_raises(Oj::ParseError) { Oj.load("\"\\\0\"") }
end
def test_array
dump_and_load([], false)
dump_and_load([true, false], false)
dump_and_load(['a', 1, nil], false)
dump_and_load([[nil]], false)
dump_and_load([[nil], 58], false)
end
def test_array_not_closed
begin
Oj.load('[')
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
# multiple JSON in one string
def test_multiple_json_callback
json = %{{"a":1}
[1,2][3,4]
{"b":2}
}
results = []
Oj.load(json) { |x| results << x }
assert_equal([{"a"=>1}, [1,2], [3,4], {"b"=>2}], results)
end
def test_multiple_json_no_callback
json = %{{"a":1}
[1,2][3,4]
{"b":2}
}
assert_raises(Oj::ParseError) { Oj.load(json) }
end
# encoding tests
def test_does_not_escape_entities_by_default
Oj.default_options = { :escape_mode => :ascii } # set in mimic mode
# use Oj to create the hash since some Rubies don't deal nicely with unicode.
json = %{{"key":"I <3 this\\u2028space"}}
hash = Oj.load(json)
out = Oj.dump(hash)
assert_equal(json, out)
end
def test_escapes_entities_by_default_when_configured_to_do_so
hash = {'key' => "I <3 this"}
Oj.default_options = {:escape_mode => :xss_safe}
out = Oj.dump hash
assert_equal(%{{"key":"I \\u003c3 this"}}, out)
end
def test_escapes_entities_when_asked_to
hash = {'key' => "I <3 this"}
out = Oj.dump(hash, :escape_mode => :xss_safe)
assert_equal(%{{"key":"I \\u003c3 this"}}, out)
end
def test_does_not_escape_entities_when_not_asked_to
hash = {'key' => "I <3 this"}
out = Oj.dump(hash, :escape_mode => :json)
assert_equal(%{{"key":"I <3 this"}}, out)
end
def test_escapes_common_xss_vectors
hash = {'key' => ""}
out = Oj.dump(hash, :escape_mode => :xss_safe)
assert_equal(%{{"key":"\\u003cscript\\u003ealert(123) \\u0026\\u0026 formatHD()\\u003c\\/script\\u003e"}}, out)
end
def test_escape_newline_by_default
Oj.default_options = { :escape_mode => :json }
json = %{["one","two\\n2"]}
x = Oj.load(json)
out = Oj.dump(x)
assert_equal(json, out)
end
def test_does_not_escape_newline
Oj.default_options = { :escape_mode => :newline }
json = %{["one","two\n2"]}
x = Oj.load(json)
out = Oj.dump(x)
assert_equal(json, out)
end
# Symbol
def test_symbol_strict
begin
Oj.dump(:abc, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_symbol_null
json = Oj.dump(:abc, :mode => :null)
assert_equal('null', json)
end
def test_symbol_compat
json = Oj.dump(:abc, :mode => :compat)
assert_equal('"abc"', json)
end
def test_symbol_object
Oj.default_options = { :mode => :object }
#dump_and_load(''.to_sym, false)
dump_and_load(:abc, false)
dump_and_load(':xyz'.to_sym, false)
end
# Time
def test_time_strict
t = Time.local(2012, 1, 5, 23, 58, 7)
begin
Oj.dump(t, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_time_null
t = Time.local(2012, 1, 5, 23, 58, 7)
json = Oj.dump(t, :mode => :null)
assert_equal('null', json)
end
def test_unix_time_compat
t = Time.xmlschema("2012-01-05T23:58:07.123456000+09:00")
#t = Time.local(2012, 1, 5, 23, 58, 7, 123456)
json = Oj.dump(t, :mode => :compat, :time_format => :unix)
assert_equal(%{1325775487.123456000}, json)
end
def test_unix_time_compat_precision
t = Time.xmlschema("2012-01-05T23:58:07.123456789+09:00")
#t = Time.local(2012, 1, 5, 23, 58, 7, 123456)
json = Oj.dump(t, :mode => :compat, :second_precision => 5, :time_format => :unix)
assert_equal(%{1325775487.12346}, json)
t = Time.xmlschema("2012-01-05T23:58:07.999600+09:00")
json = Oj.dump(t, :mode => :compat, :second_precision => 3, :time_format => :unix)
assert_equal(%{1325775488.000}, json)
end
def test_unix_time_compat_early
t = Time.xmlschema("1954-01-05T00:00:00.123456789+00:00")
json = Oj.dump(t, :mode => :compat, :second_precision => 5, :time_format => :unix)
assert_equal(%{-504575999.87654}, json)
end
def test_unix_time_compat_1970
t = Time.xmlschema("1970-01-01T00:00:00.123456789+00:00")
json = Oj.dump(t, :mode => :compat, :second_precision => 5, :time_format => :unix)
assert_equal(%{0.12346}, json)
end
def test_ruby_time_compat
t = Time.xmlschema("2012-01-05T23:58:07.123456000+09:00")
json = Oj.dump(t, :mode => :compat, :time_format => :ruby)
#assert_equal(%{"2012-01-05 23:58:07 +0900"}, json)
assert_equal(%{"#{t.to_s}"}, json)
end
def test_xml_time_compat
begin
t = Time.new(2012, 1, 5, 23, 58, 7.123456000, 34200)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema)
assert_equal(%{"2012-01-05T23:58:07.123456000+09:30"}, json)
rescue Exception
# some Rubies (1.8.7) do not allow the timezome to be set
t = Time.local(2012, 1, 5, 23, 58, 7, 123456)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema)
tz = t.utc_offset
# Ruby does not handle a %+02d properly so...
sign = '+'
if 0 > tz
sign = '-'
tz = -tz
end
assert_equal(%{"2012-01-05T23:58:07.123456000%s%02d:%02d"} % [sign, tz / 3600, tz / 60 % 60], json)
end
end
def test_xml_time_compat_no_secs
begin
t = Time.new(2012, 1, 5, 23, 58, 7.0, 34200)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema)
assert_equal(%{"2012-01-05T23:58:07+09:30"}, json)
rescue Exception
# some Rubies (1.8.7) do not allow the timezome to be set
t = Time.local(2012, 1, 5, 23, 58, 7, 0)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema)
tz = t.utc_offset
# Ruby does not handle a %+02d properly so...
sign = '+'
if 0 > tz
sign = '-'
tz = -tz
end
assert_equal(%{"2012-01-05T23:58:07%s%02d:%02d"} % [sign, tz / 3600, tz / 60 % 60], json)
end
end
def test_xml_time_compat_precision
begin
t = Time.new(2012, 1, 5, 23, 58, 7.123456789, 32400)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 5)
assert_equal(%{"2012-01-05T23:58:07.12346+09:00"}, json)
rescue Exception
# some Rubies (1.8.7) do not allow the timezome to be set
t = Time.local(2012, 1, 5, 23, 58, 7, 123456)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 5)
tz = t.utc_offset
# Ruby does not handle a %+02d properly so...
sign = '+'
if 0 > tz
sign = '-'
tz = -tz
end
assert_equal(%{"2012-01-05T23:58:07.12346%s%02d:%02d"} % [sign, tz / 3600, tz / 60 % 60], json)
end
end
def test_xml_time_compat_precision_round
begin
t = Time.new(2012, 1, 5, 23, 58, 7.9996, 32400)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 3)
assert_equal(%{"2012-01-05T23:58:08+09:00"}, json)
rescue Exception
# some Rubies (1.8.7) do not allow the timezome to be set
t = Time.local(2012, 1, 5, 23, 58, 7, 999600)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 3)
tz = t.utc_offset
# Ruby does not handle a %+02d properly so...
sign = '+'
if 0 > tz
sign = '-'
tz = -tz
end
assert_equal(%{"2012-01-05T23:58:08%s%02d:%02d"} % [sign, tz / 3600, tz / 60 % 60], json)
end
end
def test_xml_time_compat_zulu
begin
t = Time.new(2012, 1, 5, 23, 58, 7.0, 0)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema)
assert_equal(%{"2012-01-05T23:58:07Z"}, json)
rescue Exception
# some Rubies (1.8.7) do not allow the timezome to be set
t = Time.utc(2012, 1, 5, 23, 58, 7, 0)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema)
#tz = t.utc_offset
assert_equal(%{"2012-01-05T23:58:07Z"}, json)
end
end
# Class
def test_class_strict
begin
Oj.dump(Juice, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_class_null
json = Oj.dump(Juice, :mode => :null)
assert_equal('null', json)
end
def test_class_compat
json = Oj.dump(Juice, :mode => :compat)
assert_equal(%{"Juice"}, json)
end
def test_class_object
Oj.default_options = { :mode => :object }
dump_and_load(Juice, false)
end
# Module
def test_module_strict
begin
Oj.dump(TestModule, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_module_null
json = Oj.dump(TestModule, :mode => :null)
assert_equal('null', json)
end
def test_module_compat
json = Oj.dump(TestModule, :mode => :compat)
assert_equal(%{"Juice::TestModule"}, json)
end
def test_module_object
Oj.default_options = { :mode => :object }
dump_and_load(TestModule, false)
end
# Hash
def test_hash
Oj.default_options = { :mode => :strict }
dump_and_load({}, false)
dump_and_load({ 'true' => true, 'false' => false}, false)
dump_and_load({ 'true' => true, 'array' => [], 'hash' => { }}, false)
end
def test_non_str_hash_strict
begin
Oj.dump({ 1 => true, 0 => false }, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_non_str_hash_null
begin
Oj.dump({ 1 => true, 0 => false }, :mode => :null)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_non_str_hash_compat
json = Oj.dump({ 1 => true, 0 => false }, :mode => :compat)
h = Oj.load(json, :mode => :strict)
assert_equal({ "1" => true, "0" => false }, h)
end
def test_non_str_hash_object
Oj.default_options = { :mode => :object }
json = Oj.dump({ 1 => true, :sim => nil })
h = Oj.load(json, :mode => :strict)
assert_equal({"^#1" => [1, true], ":sim" => nil}, h)
h = Oj.load(json)
assert_equal({ 1 => true, :sim => nil }, h)
end
def test_mixed_hash_object
Oj.default_options = { :mode => :object }
json = Oj.dump({ 1 => true, 'nil' => nil, :sim => 4 })
h = Oj.load(json, :mode => :strict)
assert_equal({"^#1" => [1, true], "nil" => nil, ":sim" => 4}, h)
h = Oj.load(json)
assert_equal({ 1 => true, 'nil' => nil, :sim => 4 }, h)
end
def test_hash_not_closed
begin
Oj.load('{')
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
# Object with to_json()
def test_json_object_strict
obj = Jeez.new(true, 58)
begin
Oj.dump(obj, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_json_object_null
obj = Jeez.new(true, 58)
json = Oj.dump(obj, :mode => :null)
assert_equal('null', json)
end
def test_json_object_compat
Oj.default_options = { :mode => :compat, :use_to_json => true }
obj = Jeez.new(true, 58)
json = Oj.dump(obj, :indent => 2)
assert(%{{"json_class":"Juice::Jeez","x":true,"y":58}
} == json ||
%{{"json_class":"Juice::Jeez","y":58,"x":true}
} == json)
dump_and_load(obj, false)
Oj.default_options = { :mode => :compat, :use_to_json => false }
end
def test_json_object_create_id
Oj.default_options = { :mode => :compat, :create_id => 'kson_class' }
expected = Jeez.new(true, 58)
json = %{{"kson_class":"Juice::Jeez","x":true,"y":58}}
obj = Oj.load(json)
assert_equal(expected, obj)
Oj.default_options = { :create_id => 'json_class' }
end
def test_json_object_object
obj = Jeez.new(true, 58)
json = Oj.dump(obj, :mode => :object, :indent => 2)
assert(%{{
"^o":"Juice::Jeez",
"x":true,
"y":58
}
} == json ||
%{{
"^o":"Juice::Jeez",
"y":58,
"x":true
}
} == json)
obj2 = Oj.load(json, :mode => :object)
assert_equal(obj, obj2)
end
# Object with to_hash()
def test_to_hash_object_strict
obj = Jazz.new(true, 58)
begin
Oj.dump(obj, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_to_hash_object_null
obj = Jazz.new(true, 58)
json = Oj.dump(obj, :mode => :null)
assert_equal('null', json)
end
def test_to_hash_object_compat
obj = Jazz.new(true, 58)
json = Oj.dump(obj, :mode => :compat, :indent => 2)
h = Oj.load(json, :mode => :strict)
assert_equal(obj.to_hash, h)
end
def test_to_hash_object_object
obj = Jazz.new(true, 58)
json = Oj.dump(obj, :mode => :object, :indent => 2)
assert(%{{
"^o":"Juice::Jazz",
"x":true,
"y":58
}
} == json ||
%{{
"^o":"Juice::Jazz",
"y":58,
"x":true
}
} == json)
obj2 = Oj.load(json, :mode => :object)
assert_equal(obj, obj2)
end
# Object with as_json() # contributed by sauliusg
def test_as_json_object_strict
obj = Orange.new(true, 58)
begin
Oj.dump(obj, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_as_json_object_null
obj = Orange.new(true, 58)
json = Oj.dump(obj, :mode => :null)
assert_equal('null', json)
end
def test_as_json_object_compat_hash
Oj.default_options = { :mode => :compat, :use_to_json => true }
obj = Orange.new(true, 58)
json = Oj.dump(obj, :indent => 2)
assert(!json.nil?)
dump_and_load(obj, false)
end
def test_as_json_object_compat_non_hash
Oj.default_options = { :mode => :compat, :use_to_json => true }
obj = Melon.new(true, 58)
json = Oj.dump(obj, :indent => 2)
assert_equal(%{"true 58"}, json)
end
def test_as_json_object_object
obj = Orange.new(true, 58)
json = Oj.dump(obj, :mode => :object, :indent => 2)
assert(%{{
"^o":"Juice::Orange",
"x":true,
"y":58
}
} == json ||
%{{
"^o":"Juice::Orange",
"y":58,
"x":true
}
} == json)
obj2 = Oj.load(json, :mode => :object)
assert_equal(obj, obj2)
end
# Object without to_json() or to_hash()
def test_object_strict
obj = Jam.new(true, 58)
begin
Oj.dump(obj, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_object_null
obj = Jam.new(true, 58)
json = Oj.dump(obj, :mode => :null)
assert_equal('null', json)
end
def test_object_compat
obj = Jam.new(true, 58)
json = Oj.dump(obj, :mode => :compat, :indent => 2)
assert(%{{
"x":true,
"y":58
}
} == json ||
%{{
"y":58,
"x":true
}
} == json)
end
def test_object_object
obj = Jam.new(true, 58)
json = Oj.dump(obj, :mode => :object, :indent => 2)
assert(%{{
"^o":"Juice::Jam",
"x":true,
"y":58
}
} == json ||
%{{
"^o":"Juice::Jam",
"y":58,
"x":true
}
} == json)
obj2 = Oj.load(json, :mode => :object)
assert_equal(obj, obj2)
end
def test_object_object_no_cache
obj = Jam.new(true, 58)
json = Oj.dump(obj, :mode => :object, :indent => 2)
assert(%{{
"^o":"Juice::Jam",
"x":true,
"y":58
}
} == json ||
%{{
"^o":"Juice::Jam",
"y":58,
"x":true
}
} == json)
obj2 = Oj.load(json, :mode => :object, :class_cache => false)
assert_equal(obj, obj2)
end
# Exception
def test_exception
err = nil
begin
raise StandardError.new('A Message')
rescue Exception => e
err = e
end
json = Oj.dump(err, :mode => :object, :indent => 2)
#puts "*** #{json}"
e2 = Oj.load(json, :mode => :strict)
assert_equal(err.class.to_s, e2['^o'])
assert_equal(err.message, e2['~mesg'])
assert_equal(err.backtrace, e2['~bt'])
e2 = Oj.load(json, :mode => :object)
if RUBY_VERSION.start_with?('1.8') || 'rubinius' == $ruby
assert_equal(e.class, e2.class);
assert_equal(e.message, e2.message);
assert_equal(e.backtrace, e2.backtrace);
else
assert_equal(e, e2);
end
end
# Range
def test_range_strict
begin
Oj.dump(1..7, :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_range_null
json = Oj.dump(1..7, :mode => :null)
assert_equal('null', json)
end
def test_range_compat
json = Oj.dump(1..7, :mode => :compat)
h = Oj.load(json, :mode => :strict)
assert_equal({'begin' => 1, 'end' => 7, 'exclude_end' => false}, h)
json = Oj.dump(1...7, :mode => :compat)
h = Oj.load(json, :mode => :strict)
assert_equal({'begin' => 1, 'end' => 7, 'exclude_end' => true}, h)
end
def test_range_object
unless RUBY_VERSION.start_with?('1.8')
Oj.default_options = { :mode => :object }
json = Oj.dump(1..7, :mode => :object, :indent => 0)
if 'rubinius' == $ruby
assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
else
assert_equal(%{{"^u":["Range",1,7,false]}}, json)
end
dump_and_load(1..7, false)
dump_and_load(1..1, false)
dump_and_load(1...7, false)
end
end
# BigNum
def test_bignum_strict
json = Oj.dump(7 ** 55, :mode => :strict)
assert_equal('30226801971775055948247051683954096612865741943', json)
end
def test_bignum_null
json = Oj.dump(7 ** 55, :mode => :null)
assert_equal('30226801971775055948247051683954096612865741943', json)
end
def test_bignum_compat
json = Oj.dump(7 ** 55, :mode => :compat)
b = Oj.load(json, :mode => :strict)
assert_equal(30226801971775055948247051683954096612865741943, b)
end
def test_bignum_object
dump_and_load(7 ** 55, false)
dump_and_load(10 ** 19, false)
end
# BigDecimal
def test_bigdecimal_strict
mode = Oj.default_options[:mode]
Oj.default_options = {:mode => :strict}
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
Oj.default_options = {:mode => mode}
end
def test_bigdecimal_null
mode = Oj.default_options[:mode]
Oj.default_options = {:mode => :null}
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
Oj.default_options = {:mode => mode}
end
def test_bigdecimal_compat
orig = BigDecimal.new('80.51')
json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => false)
bg = Oj.load(json, :mode => :compat)
assert_equal(orig.to_s, bg)
orig = BigDecimal.new('3.14159265358979323846')
json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => false)
bg = Oj.load(json, :mode => :compat)
assert_equal(orig.to_s, bg)
end
def test_bigdecimal_load
orig = BigDecimal.new('80.51')
json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => true)
bg = Oj.load(json, :mode => :compat, :bigdecimal_load => true)
assert_equal(BigDecimal, bg.class)
assert_equal(orig, bg)
end
def test_float_load
orig = BigDecimal.new('80.51')
json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => true)
bg = Oj.load(json, :mode => :compat, :bigdecimal_load => :float)
assert_equal(Float, bg.class)
assert_equal(orig.to_f, bg)
end
def test_bigdecimal_compat_as_json
orig = BigDecimal.new('80.51')
BigDecimal.send(:define_method, :as_json) do
%{this is big}
end
json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => false)
bg = Oj.load(json, :mode => :compat)
assert_equal("this is big", bg)
BigDecimal.send(:remove_method, :as_json) # cleanup
end
def test_bigdecimal_object
mode = Oj.default_options[:mode]
Oj.default_options = {:mode => :object}
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
Oj.default_options = {:mode => mode}
# Infinity is the same for Float and BigDecimal
json = Oj.dump(BigDecimal.new('Infinity'), :mode => :object)
assert_equal('Infinity', json)
json = Oj.dump(BigDecimal.new('-Infinity'), :mode => :object)
assert_equal('-Infinity', json)
end
def test_infinity
n = Oj.load('Infinity', :mode => :object)
assert_equal(BigDecimal.new('Infinity').to_f, n);
begin
Oj.load('Infinity', :mode => :strict)
fail()
rescue Oj::ParseError
assert(true)
end
x = Oj.load('Infinity', :mode => :compat)
assert_equal('Infinity', x.to_s)
end
# Date
def test_date_strict
begin
Oj.dump(Date.new(2012, 6, 19), :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_date_null
json = Oj.dump(Date.new(2012, 6, 19), :mode => :null)
assert_equal('null', json)
end
def test_date_compat
orig = Date.new(2012, 6, 19)
json = Oj.dump(orig, :mode => :compat)
x = Oj.load(json, :mode => :compat)
# Some Rubies implement Date as data and some as a real Object. Either are
# okay for the test.
if x.is_a?(String)
assert_equal(orig.to_s, x)
else # better be a Hash
assert_equal({"year" => orig.year, "month" => orig.month, "day" => orig.day, "start" => orig.start}, x)
end
end
def test_date_object
Oj.default_options = {:mode => :object}
dump_and_load(Date.new(2012, 6, 19), false)
end
# DateTime
def test_datetime_strict
begin
Oj.dump(DateTime.new(2012, 6, 19, 20, 19, 27), :mode => :strict)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_datetime_null
json = Oj.dump(DateTime.new(2012, 6, 19, 20, 19, 27), :mode => :null)
assert_equal('null', json)
end
def test_datetime_compat
orig = DateTime.new(2012, 6, 19, 20, 19, 27)
json = Oj.dump(orig, :mode => :compat)
x = Oj.load(json, :mode => :compat)
# Some Rubies implement Date as data and some as a real Object. Either are
# okay for the test.
assert_equal(orig.to_s, x)
end
def test_datetime_object
Oj.default_options = {:mode => :object}
dump_and_load(DateTime.new(2012, 6, 19), false)
end
# autodefine Oj::Bag
def test_bag
json = %{{
"^o":"Juice::Jem",
"x":true,
"y":58 }}
obj = Oj.load(json, :mode => :object, :auto_define => true)
assert_equal('Juice::Jem', obj.class.name)
assert_equal(true, obj.x)
assert_equal(58, obj.y)
end
# Circular
def test_circular_object
obj = Jam.new(nil, 58)
obj.x = obj
json = Oj.dump(obj, :mode => :object, :indent => 2, :circular => true)
assert(%{{
"^o":"Juice::Jam",
"^i":1,
"x":"^r1",
"y":58
}
} == json ||
%{{
"^o":"Juice::Jam",
"^i":1,
"y":58,
"x":"^r1"
}
} == json)
obj2 = Oj.load(json, :mode => :object, :circular => true)
assert_equal(obj2.x.__id__, obj2.__id__)
end
def test_circular_hash
h = { 'a' => 7 }
h['b'] = h
json = Oj.dump(h, :mode => :object, :indent => 2, :circular => true)
ha = Oj.load(json, :mode => :strict)
assert_equal({'^i' => 1, 'a' => 7, 'b' => '^r1'}, ha)
Oj.load(json, :mode => :object, :circular => true)
assert_equal(h['b'].__id__, h.__id__)
end
def test_circular_array
a = [7]
a << a
json = Oj.dump(a, :mode => :object, :indent => 2, :circular => true)
assert_equal(%{[
"^i1",
7,
"^r1"
]
}, json)
a2 = Oj.load(json, :mode => :object, :circular => true)
assert_equal(a2[1].__id__, a2.__id__)
end
def test_circular
h = { 'a' => 7 }
obj = Jam.new(h, 58)
obj.x['b'] = obj
json = Oj.dump(obj, :mode => :object, :indent => 2, :circular => true)
ha = Oj.load(json, :mode => :strict)
assert_equal({'^o' => 'Juice::Jam', '^i' => 1, 'x' => { '^i' => 2, 'a' => 7, 'b' => '^r1' }, 'y' => 58 }, ha)
Oj.load(json, :mode => :object, :circular => true)
assert_equal(obj.x.__id__, h.__id__)
assert_equal(h['b'].__id__, obj.__id__)
end
# Stream Deeply Nested
def test_deep_nest
begin
n = 10000
Oj.strict_load('[' * n + ']' * n)
rescue Exception => e
assert(false, e.message)
end
end
def test_deep_nest_dump
begin
a = []
10000.times { a << [a] }
Oj.dump(a)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
# Stream IO
def test_io_string
src = { 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}
output = StringIO.open("", "w+")
Oj.to_stream(output, src)
input = StringIO.new(output.string())
obj = Oj.load(input, :mode => :strict)
assert_equal(src, obj)
end
def test_io_file
src = { 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}
filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
File.open(filename, "w") { |f|
Oj.to_stream(f, src)
}
f = File.new(filename)
obj = Oj.load(f, :mode => :strict)
f.close()
assert_equal(src, obj)
end
# symbol_keys option
def test_symbol_keys
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
obj = Oj.load(json, :mode => :strict, :symbol_keys => true)
assert_equal({ :x => true, :y => 58, :z => [1, 2, 3]}, obj)
end
# comments
def test_comment_slash
json = %{{
"x":true,//three
"y":58,
"z": [1,2,
3 // six
]}
}
obj = Oj.load(json, :mode => :strict)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment_c
json = %{/*before*/
{
"x"/*one*/:/*two*/true,
"y":58,
"z": [1,2,3]}
}
obj = Oj.load(json, :mode => :strict)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment
json = %{{
"x"/*one*/:/*two*/true,//three
"y":58/*four*/,
"z": [1,2/*five*/,
3 // six
]
}
}
obj = Oj.load(json, :mode => :strict)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_nilnil_false
begin
Oj.load(nil)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_nilnil_true
obj = Oj.load(nil, :nilnil => true)
assert_equal(nil, obj)
end
def test_quirks_null_mode
assert_raises(Oj::ParseError) { Oj.load("null", :quirks_mode => false) }
assert_equal(nil, Oj.load("null", :quirks_mode => true))
end
def test_quirks_bool_mode
assert_raises(Oj::ParseError) { Oj.load("true", :quirks_mode => false) }
assert_equal(true, Oj.load("true", :quirks_mode => true))
end
def test_quirks_number_mode
assert_raises(Oj::ParseError) { Oj.load("123", :quirks_mode => false) }
assert_equal(123, Oj.load("123", :quirks_mode => true))
end
def test_quirks_decimal_mode
assert_raises(Oj::ParseError) { Oj.load("123.45", :quirks_mode => false) }
assert_equal(123.45, Oj.load("123.45", :quirks_mode => true))
end
def test_quirks_string_mode
assert_raises(Oj::ParseError) { Oj.load('"string"', :quirks_mode => false) }
assert_equal('string', Oj.load('"string"', :quirks_mode => true))
end
def test_quirks_array_mode
assert_equal([], Oj.load("[]", :quirks_mode => false))
assert_equal([], Oj.load("[]", :quirks_mode => true))
end
def test_quirks_object_mode
assert_equal({}, Oj.load("{}", :quirks_mode => false))
assert_equal({}, Oj.load("{}", :quirks_mode => true))
end
def test_omit_nil
jam = Jam.new({'a' => 1, 'b' => nil }, nil)
json = Oj.dump(jam, :omit_nil => true, :mode => :object)
assert_equal(%|{"^o":"Juice::Jam","x":{"a":1}}|, json)
json = Oj.dump(jam, :omit_nil => true, :mode => :compat)
assert_equal(%|{"x":{"a":1}}|, json)
json = Oj.dump({'x' => {'a' => 1, 'b' => nil }, 'y' => nil}, :omit_nil => true, :mode => :strict)
assert_equal(%|{"x":{"a":1}}|, json)
json = Oj.dump({'x' => {'a' => 1, 'b' => nil }, 'y' => nil}, :omit_nil => true, :mode => :null)
assert_equal(%|{"x":{"a":1}}|, json)
end
def dump_and_load(obj, trace=false)
json = Oj.dump(obj, :indent => 2)
puts json if trace
loaded = Oj.load(json)
assert_equal(obj, loaded)
loaded
end
end
oj-2.17.4/test/_test_active_mimic.rb 0000755 0000041 0000041 00000003466 12766161567 017435 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
%w(lib ext test).each do |dir|
$LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
end
require 'minitest'
require 'minitest/autorun'
require 'sqlite3'
require 'active_record'
require 'oj'
Oj.mimic_JSON()
Oj.default_options = {mode: :compat, indent: 2}
#ActiveRecord::Base.logger = Logger.new(STDERR)
ActiveRecord::Base.establish_connection(
:adapter => "sqlite3",
:database => ":memory:"
)
ActiveRecord::Schema.define do
create_table :users do |table|
table.column :first_name, :string
table.column :last_name, :string
table.column :email, :string
end
end
class User < ActiveRecord::Base
end
class ActiveTest < Minitest::Test
def test_active
User.find_or_create_by(first_name: "John", last_name: "Smith", email: "john@example.com")
User.find_or_create_by(first_name: "Joan", last_name: "Smith", email: "joan@example.com")
# Single instance.
assert_equal(%|{
"id":1,
"first_name":"John",
"last_name":"Smith",
"email":"john@example.com"
}
|, Oj.dump(User.first))
# Array of instances.
assert_equal(%|[
{
"id":1,
"first_name":"John",
"last_name":"Smith",
"email":"john@example.com"
},
{
"id":2,
"first_name":"Joan",
"last_name":"Smith",
"email":"joan@example.com"
}
]
|, Oj.dump(User.all))
# Single instance as json. (not Oj)
assert_equal(%|{
"id":1,
"first_name":"John",
"last_name":"Smith",
"email":"john@example.com"
}
|, User.first.to_json)
# Array of instances as json. (not Oj)
assert_equal(%|[
{
"id":1,
"first_name":"John",
"last_name":"Smith",
"email":"john@example.com"
},
{
"id":2,
"first_name":"Joan",
"last_name":"Smith",
"email":"joan@example.com"
}
]
|, User.all.to_json)
end
end
oj-2.17.4/test/perf_object.rb 0000755 0000041 0000041 00000007607 12766161567 016071 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
$: << '.'
$: << '../lib'
$: << '../ext'
if __FILE__ == $0
if (i = ARGV.index('-I'))
x,path = ARGV.slice!(i, 2)
$: << path
end
end
require 'optparse'
require 'ox'
require 'oj'
require 'perf'
require 'sample'
require 'files'
$circular = false
$indent = 0
$allow_gc = true
do_sample = false
do_files = false
do_load = false
do_dump = false
do_read = false
do_write = false
$iter = 1000
$mult = 1
opts = OptionParser.new
opts.on("-c", "circular options") { $circular = true }
opts.on("-x", "use sample instead of files") { do_sample = true }
opts.on("-g", "no GC during parsing") { $allow_gc = false }
opts.on("-s", "load and dump as sample Ruby object") { do_sample = true }
opts.on("-f", "load and dump as files Ruby object") { do_files = true }
opts.on("-l", "load") { do_load = true }
opts.on("-d", "dump") { do_dump = true }
opts.on("-r", "read") { do_read = true }
opts.on("-w", "write") { do_write = true }
opts.on("-a", "load, dump, read and write") { do_load = true; do_dump = true; do_read = true; do_write = true }
opts.on("-i", "--iterations [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-m", "--multiply [Int]", Integer, "multiplier") { |i| $mult = i }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
$obj = nil
$xml = nil
$mars = nil
$json = nil
unless do_load || do_dump || do_read || do_write
do_load = true
do_dump = true
do_read = true
do_write = true
end
# prepare all the formats for input
if files.empty?
$obj = []
$mult.times do
$obj << (do_sample ? sample_doc(2) : files('..'))
end
$mars = Marshal.dump($obj)
$xml = Ox.dump($obj, :indent => $indent, :circular => $circular)
$json = Oj.dump($obj, :indent => $indent, :circular => $circular, :mode => :object)
File.open('sample.xml', 'w') { |f| f.write($xml) }
File.open('sample.json', 'w') { |f| f.write($json) }
File.open('sample.marshal', 'w') { |f| f.write($mars) }
else
puts "loading and parsing #{files}\n\n"
data = files.map do |f|
$xml = File.read(f)
$obj = Ox.load($xml);
$mars = Marshal.dump($obj)
$json = Oj.dump($obj, :indent => $indent, :circular => $circular)
end
end
Oj.default_options = { :mode => :object, :indent => $indent, :circular => $circular, :allow_gc => $allow_gc }
#puts "json: #{$json.size}"
#puts "xml: #{$xml.size}"
#puts "marshal: #{$mars.size}"
if do_load
puts '-' * 80
puts "Load Performance"
perf = Perf.new()
perf.add('Oj.object', 'load') { Oj.object_load($json) }
perf.add('Ox', 'load') { Ox.load($xml, :mode => :object) }
perf.add('Marshal', 'load') { Marshal.load($mars) }
perf.run($iter)
end
if do_dump
puts '-' * 80
puts "Dump Performance"
perf = Perf.new()
perf.add('Oj', 'dump') { Oj.dump($obj) }
perf.add('Ox', 'dump') { Ox.dump($obj, :indent => $indent, :circular => $circular) }
perf.add('Marshal', 'dump') { Marshal.dump($obj) }
perf.run($iter)
end
if do_read
puts '-' * 80
puts "Read from file Performance"
perf = Perf.new()
perf.add('Oj', 'load') { Oj.load_file('sample.json') }
#perf.add('Oj', 'load') { Oj.load(File.read('sample.json')) }
perf.add('Ox', 'load_file') { Ox.load_file('sample.xml', :mode => :object) }
perf.add('Marshal', 'load') { Marshal.load(File.new('sample.marshal')) }
perf.run($iter)
end
if do_write
puts '-' * 80
puts "Write to file Performance"
perf = Perf.new()
perf.add('Oj', 'to_file') { Oj.to_file('sample.json', $obj) }
perf.add('Ox', 'to_file') { Ox.to_file('sample.xml', $obj, :indent => $indent, :circular => $circular) }
perf.add('Marshal', 'dump') { Marshal.dump($obj, File.new('sample.marshal', 'w')) }
perf.run($iter)
end
oj-2.17.4/test/isolated/ 0000755 0000041 0000041 00000000000 12766161567 015051 5 ustar www-data www-data oj-2.17.4/test/isolated/test_mimic_define.rb 0000755 0000041 0000041 00000001073 12766161567 021051 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), '..')
require 'helper'
class MimicDefine < Minitest::Test
def test_mimic_define
assert(defined?(JSON).nil?)
Oj.mimic_JSON
# Test constants
assert(!defined?(JSON).nil?)
assert(!defined?(JSON::ParserError).nil?)
assert(Object.respond_to?(:to_json))
# Test loaded features
assert(!require('json'))
begin
require('json_spec')
assert(false, '** should raise LoadError')
rescue LoadError
assert(true)
end
end
end # MimicSingle
oj-2.17.4/test/isolated/test_mimic_before.rb 0000755 0000041 0000041 00000000326 12766161567 021061 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), '..')
require 'helper'
require 'isolated/shared'
Oj.mimic_JSON
require 'json'
class MimicBefore < SharedMimicTest
end # MimicBefore
oj-2.17.4/test/isolated/test_mimic_rails_after.rb 0000755 0000041 0000041 00000000537 12766161567 022116 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), '..')
require 'helper'
begin
require 'rails/all'
rescue Exception => e
puts "*** #{e.class}: #{e.message}"
Process.exit!(false)
end
Oj.mimic_JSON
require 'isolated/shared'
$rails_monkey = true
class MimicRailsAfter < SharedMimicRailsTest
end # MimicRailsAfter
oj-2.17.4/test/isolated/shared.rb 0000644 0000041 0000041 00000017134 12766161567 016652 0 ustar www-data www-data # encoding: UTF-8
# The rails tests set this to true. Both Rails and the JSON gem monkey patch the
# as_json methods on several base classes. Depending on which one replaces the
# method last the behavior will be different. Oj.mimic_JSON abides by the same
# conflicting behavior and the tests reflect that.
$rails_monkey = false unless defined?($rails_monkey)
class SharedMimicTest < Minitest::Test
class Jam
attr_accessor :x, :y
def initialize(x, y)
@x = x
@y = y
end
def eql?(o)
self.class == o.class && @x == o.x && @y == o.y
end
alias == eql?
def as_json()
{"json_class" => self.class.to_s,"x" => @x,"y" => @y}
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end # Jam
def setup
@default_options = Oj.default_options
@time = Time.at(1400000000).utc
@expected_time_string =
if defined?(Rails)
%{"2014-05-13T16:53:20.000Z"}
elsif RUBY_VERSION.start_with?('1.8')
%{"Tue May 13 16:53:20 UTC 2014"}
else
%{"2014-05-13 16:53:20 UTC"}
end
end
def teardown
Oj.default_options = @default_options
end
# exception
def test_exception
begin
JSON.parse("{")
puts "Failed"
rescue JSON::ParserError
assert(true)
rescue Exception
assert(false, 'Expected a JSON::ParserError')
end
end
# dump
def test_dump_string
json = JSON.dump([1, true, nil, @time])
if $rails_monkey
assert_equal(%{[1,true,null,#{@expected_time_string}]}, json)
else
assert_equal(%{[1,true,null,{"json_class":"Time","s":1400000000,"n":0}]}, json)
end
end
def test_dump_with_options
Oj.default_options= {:indent => 2} # JSON this will not change anything
json = JSON.dump([1, true, nil, @time])
if $rails_monkey
assert_equal(%{[
1,
true,
null,
#{@expected_time_string}
]
}, json)
else
assert_equal(%{[
1,
true,
null,
{
"json_class":"Time",
"s":1400000000,
"n\":0
}
]
}, json)
end
end
def test_dump_io
s = StringIO.new()
json = JSON.dump([1, true, nil, @time], s)
assert_equal(s, json)
if $rails_monkey
assert_equal(%{[1,true,null,#{@expected_time_string}]}, s.string)
else
assert_equal(%{[1,true,null,{"json_class":"Time","s":1400000000,"n":0}]}, s.string)
end
end
# TBD options
def test_dump_struct
# anonymous Struct not supported by json so name it
if Object.const_defined?("Struct::Abc")
s = Struct::Abc
else
s = Struct.new("Abc", :a, :b, :c)
end
o = s.new(1, 'two', [true, false])
json = JSON.dump(o)
if o.respond_to?(:as_json)
if $rails_monkey
assert_equal(%|{"a":1,"b":"two","c":[true,false]}|, json)
else
assert_equal(%|{"json_class":"Struct::Abc","v":[1,"two",[true,false]]}|, json)
end
else
j = '"' + o.to_s.gsub('"', '\\"') + '"'
assert_equal(j, json)
end
end
# load
def test_load_string
json = %{{"a":1,"b":[true,false]}}
obj = JSON.load(json)
assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
end
def test_load_io
json = %{{"a":1,"b":[true,false]}}
obj = JSON.load(StringIO.new(json))
assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
end
def test_load_proc
Oj.mimic_JSON
children = []
json = %{{"a":1,"b":[true,false]}}
if 'rubinius' == $ruby || '1.8.7' == RUBY_VERSION
obj = JSON.load(json) {|x| children << x }
else
p = Proc.new {|x| children << x }
obj = JSON.load(json, p)
end
assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
assert([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}] == children ||
[true, false, [true, false], 1, { 'a' => 1, 'b' => [true, false]}] == children,
"children don't match")
end
def test_parse_with_quirks_mode
json = %{null}
assert_equal(nil, JSON.parse(json, :quirks_mode => true))
assert_raises(JSON::ParserError) { JSON.parse(json, :quirks_mode => false) }
assert_raises(JSON::ParserError) { JSON.parse(json) }
end
# []
def test_bracket_load
json = %{{"a":1,"b":[true,false]}}
obj = JSON[json]
assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
end
def test_bracket_dump
json = JSON[[1, true, nil]]
assert_equal(%{[1,true,null]}, json)
end
# generate
def test_generate
json = JSON.generate({ 'a' => 1, 'b' => [true, false]})
assert(%{{"a":1,"b":[true,false]}} == json ||
%{{"b":[true,false],"a":1}} == json)
end
def test_generate_options
json = JSON.generate({ 'a' => 1, 'b' => [true, false]},
:indent => "--",
:array_nl => "\n",
:object_nl => "#\n",
:space => "*",
:space_before => "~")
assert(%{{#
--"a"~:*1,#
--"b"~:*[
----true,
----false
--]#
}} == json ||
%{{#
--"b"~:*[
----true,
----false
--],#
--"a"~:*1#
}} == json)
end
# fast_generate
def test_fast_generate
json = JSON.generate({ 'a' => 1, 'b' => [true, false]})
assert(%{{"a":1,"b":[true,false]}} == json ||
%{{"b":[true,false],"a":1}} == json)
end
# pretty_generate
def test_pretty_generate
json = JSON.pretty_generate({ 'a' => 1, 'b' => [true, false]})
assert(%{{
"a" : 1,
"b" : [
true,
false
]
}} == json ||
%{{
"b" : [
true,
false
],
"a" : 1
}} == json)
end
# parse
def test_parse
json = %{{"a":1,"b":[true,false]}}
obj = JSON.parse(json)
assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
end
def test_parse_sym_names
json = %{{"a":1,"b":[true,false]}}
obj = JSON.parse(json, :symbolize_names => true)
assert_equal({ :a => 1, :b => [true, false]}, obj)
end
def test_parse_additions
jam = Jam.new(true, 58)
json = Oj.dump(jam, :mode => :compat, :use_to_json => true)
obj = JSON.parse(json)
assert_equal(jam, obj)
obj = JSON.parse(json, :create_additions => true)
assert_equal(jam, obj)
obj = JSON.parse(json, :create_additions => false)
assert_equal({'json_class' => 'SharedMimicTest::Jam', 'x' => true, 'y' => 58}, obj)
json.gsub!('json_class', 'kson_class')
JSON.create_id = 'kson_class'
obj = JSON.parse(json, :create_additions => true)
JSON.create_id = 'json_class'
assert_equal(jam, obj)
end
def test_parse_bang
json = %{{"a":1,"b":[true,false]}}
obj = JSON.parse!(json)
assert_equal({ 'a' => 1, 'b' => [true, false]}, obj)
end
# recurse_proc
def test_recurse_proc
children = []
JSON.recurse_proc({ 'a' => 1, 'b' => [true, false]}) { |x| children << x }
# JRuby 1.7.0 rb_yield() is broken and converts the [true, false] array into true
unless 'jruby' == $ruby && '1.9.3' == RUBY_VERSION
assert([1, true, false, [true, false], { 'a' => 1, 'b' => [true, false]}] == children ||
[true, false, [true, false], 1, { 'b' => [true, false], 'a' => 1}] == children)
end
end
# make sure to_json is defined for object.
def test_mimic_to_json
{'a' => 1}.to_json()
Object.new().to_json()
end
end # SharedMimicTest
if defined?(ActiveSupport)
class SharedMimicRailsTest < SharedMimicTest
def test_activesupport_exception
begin
ActiveSupport::JSON.decode("{")
puts "Failed"
rescue ActiveSupport::JSON.parse_error
assert(true)
rescue Exception
assert(false, 'Expected a JSON::ParserError')
end
end
def test_activesupport_encode
Oj.default_options= {:indent => 0}
json = ActiveSupport::JSON.encode([1, true, nil])
assert_equal(%{[1,true,null]}, json)
end
end # SharedMimicRailsTest
end
oj-2.17.4/test/isolated/test_mimic_as_json.rb 0000755 0000041 0000041 00000001671 12766161567 021257 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
require 'oj'
class ObjectFolder < Minitest::Test
class Raccoon
attr_accessor :name
def initialize(name)
@name = name
end
def as_json(options={})
{:name => @name}.merge(options)
end
end
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_as_json_options
Oj.mimic_JSON()
raccoon = Raccoon.new('Rocket')
json = raccoon.to_json()
assert_equal(json, '{"name":"Rocket"}')
json = raccoon.to_json(:occupation => 'bounty hunter')
# depending on the ruby version the order of the hash members maybe different.
if (json.start_with?('{"name'))
assert_equal(json, '{"name":"Rocket","occupation":"bounty hunter"}')
else
assert_equal(json, '{"occupation":"bounty hunter","name":"Rocket"}')
end
end
end
oj-2.17.4/test/isolated/test_mimic_alone.rb 0000755 0000041 0000041 00000000305 12766161567 020712 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), '..')
require 'helper'
require 'isolated/shared'
Oj.mimic_JSON
class MimicAlone < SharedMimicTest
end # MimicAlone
oj-2.17.4/test/isolated/test_mimic_rails_before.rb 0000755 0000041 0000041 00000000531 12766161567 022251 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), '..')
require 'helper'
Oj.mimic_JSON
begin
require 'rails/all'
rescue Exception
puts "*** require of rails failed"
Process.exit!(true)
end
require 'isolated/shared'
$rails_monkey = true
class MimicRailsBefore < SharedMimicRailsTest
end # MimicRailsBefore
oj-2.17.4/test/isolated/test_mimic_after.rb 0000755 0000041 0000041 00000000324 12766161567 020716 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), '..')
require 'helper'
require 'isolated/shared'
require 'json'
Oj.mimic_JSON
class MimicAfter < SharedMimicTest
end # MimicAfter
oj-2.17.4/test/_test_mimic_rails.rb 0000755 0000041 0000041 00000005532 12766161567 017270 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
#Oj.mimic_JSON
require 'rails/all'
require 'active_model'
require 'active_model_serializers'
require 'active_support/json'
require 'active_support/time'
require 'active_support/all'
require 'oj/active_support_helper'
Oj.mimic_JSON
class Category
include ActiveModel::Model
include ActiveModel::SerializerSupport
attr_accessor :id, :name
def initialize(id, name)
@id = id
@name = name
end
end
class CategorySerializer < ActiveModel::Serializer
attributes :id, :name
end
class MimicRails < Minitest::Test
def test_mimic_exception
begin
ActiveSupport::JSON.decode("{")
puts "Failed"
rescue ActiveSupport::JSON.parse_error
assert(true)
rescue Exception
assert(false, 'Expected a JSON::ParserError')
end
end
def test_dump_string
Oj.default_options= {:indent => 2}
json = ActiveSupport::JSON.encode([1, true, nil])
assert_equal(%{[
1,
true,
null
]
}, json)
end
def test_dump_rational
Oj.default_options= {:indent => 2}
json = ActiveSupport::JSON.encode([1, true, Rational(1)])
assert_equal(%{[
1,
true,
"1/1"
]
}, json)
end
def test_dump_range
Oj.default_options= {:indent => 2}
json = ActiveSupport::JSON.encode([1, true, '01'..'12'])
assert_equal(%{[
1,
true,
"01..12"
]
}, json)
end
def test_dump_object
Oj.default_options= {:indent => 2}
category = Category.new(1, 'test')
serializer = CategorySerializer.new(category)
json = serializer.to_json()
puts "*** serializer.to_json() #{serializer.to_json()}"
json = serializer.as_json()
puts "*** serializer.as_json() #{serializer.as_json()}"
json = JSON.dump(serializer)
puts "*** JSON.dump(serializer) #{JSON.dump(serializer)}"
puts "*** category.to_json() #{category.to_json()}"
puts "*** category.as_json() #{category.as_json()}"
puts "*** JSON.dump(serializer) #{JSON.dump(category)}"
puts "*** Oj.dump(serializer) #{Oj.dump(category)}"
end
def test_dump_object_array
Oj.default_options= {:indent => 2}
cat1 = Category.new(1, 'test')
cat2 = Category.new(2, 'test')
a = Array.wrap([cat1, cat2])
#serializer = CategorySerializer.new(a)
puts "*** a.to_json() #{a.to_json()}"
puts "*** a.as_json() #{a.as_json()}"
puts "*** JSON.dump(a) #{JSON.dump(a)}"
puts "*** Oj.dump(a) #{Oj.dump(a)}"
end
def test_dump_time
Oj.default_options= {:indent => 2}
now = ActiveSupport::TimeZone['America/Chicago'].parse("2014-11-01 13:20:47")
json = Oj.dump(now, mode: :object, time_format: :xmlschema)
#puts "*** json: #{json}"
oj_dump = Oj.load(json, mode: :object, time_format: :xmlschema)
#puts "Now: #{now}\n Oj: #{oj_dump}"
assert_equal("2014-11-01T13:20:47-05:00", oj_dump.xmlschema)
end
end # MimicRails
oj-2.17.4/test/_test_active.rb 0000755 0000041 0000041 00000003363 12766161567 016253 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
%w(lib ext test).each do |dir|
$LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
end
require 'minitest'
require 'minitest/autorun'
require 'sqlite3'
require 'active_record'
require 'oj'
#Oj.mimic_JSON()
Oj.default_options = {mode: :compat, indent: 2}
#ActiveRecord::Base.logger = Logger.new(STDERR)
ActiveRecord::Base.establish_connection(
:adapter => "sqlite3",
:database => ":memory:"
)
ActiveRecord::Schema.define do
create_table :users do |table|
table.column :first_name, :string
table.column :last_name, :string
table.column :email, :string
end
end
class User < ActiveRecord::Base
end
class ActiveTest < Minitest::Test
def test_active
User.find_or_create_by(first_name: "John", last_name: "Smith", email: "john@example.com")
User.find_or_create_by(first_name: "Joan", last_name: "Smith", email: "joan@example.com")
# Single instance.
assert_equal(%|{
"id":1,
"first_name":"John",
"last_name":"Smith",
"email":"john@example.com"
}
|, Oj.dump(User.first))
# Array of instances.
assert_equal(%|[
{
"id":1,
"first_name":"John",
"last_name":"Smith",
"email":"john@example.com"
},
{
"id":2,
"first_name":"Joan",
"last_name":"Smith",
"email":"joan@example.com"
}
]
|, Oj.dump(User.all))
# Single instance as json. (not Oj)
assert_equal(%|{"id":1,"first_name":"John","last_name":"Smith","email":"john@example.com"}|, User.first.to_json)
# Array of instances as json. (not Oj)
assert_equal(%|[{"id":1,"first_name":"John","last_name":"Smith","email":"john@example.com"},{"id":2,"first_name":"Joan","last_name":"Smith","email":"joan@example.com"}]|, User.all.to_json)
end
end
oj-2.17.4/test/test_debian.rb 0000755 0000041 0000041 00000001722 12766161567 016060 0 ustar www-data www-data # encoding: UTF-8
require 'helper'
class DebJuice < Minitest::Test
class Jam
attr_accessor :x, :y
def initialize(x, y)
@x = x
@y = y
end
def eql?(o)
self.class == o.class && @x == o.x && @y == o.y
end
alias == eql?
end# Jam
# contributed by sauliusg to fix as_json
class Orange < Jam
def initialize(x, y)
super
end
def as_json()
{ :json_class => self.class,
:x => @x,
:y => @y }
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end
def test_as_json_object_compat_hash_cached
Oj.default_options = { :mode => :compat, :class_cache => true, :use_to_json => true }
obj = Orange.new(true, 58)
json = Oj.dump(obj, :indent => 2)
assert(!json.nil?)
dump_and_load(obj, true)
end
def dump_and_load(obj, trace=false)
json = Oj.dump(obj, :indent => 2)
loaded = Oj.load(json);
assert_equal(obj, loaded)
loaded
end
end
oj-2.17.4/test/test_object.rb 0000755 0000041 0000041 00000045613 12766161567 016113 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class ObjectJuice < Minitest::Test
class Jeez
attr_accessor :x, :y
def initialize(x, y)
@x = x
@y = y
end
def eql?(o)
self.class == o.class && @x == o.x && @y == o.y
end
alias == eql?
def to_json(*a)
%{{"json_class":"#{self.class}","x":#{@x},"y":#{@y}}}
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end # Jeez
module One
module Two
module Three
class Deep
def initialize()
end
def eql?(o)
self.class == o.class
end
alias == eql?
def to_hash()
{'json_class' => "#{self.class.name}"}
end
def to_json(*a)
%{{"json_class":"#{self.class.name}"}}
end
def self.json_create(h)
self.new()
end
end # Deep
end # Three
end # Two
class Stuck2 < Struct.new(:a, :b)
end
end # One
class Stuck < Struct.new(:a, :b)
end
class Strung < String
def initialize(str, safe)
super(str)
@safe = safe
end
def safe?()
@safe
end
def self.create(str, safe)
new(str, safe)
end
def eql?(o)
super && self.class == o.class && @safe == o.safe?
end
alias == eql?
def inspect()
return super + '(' + @safe + ')'
end
end
class AutoStrung < String
attr_accessor :safe
def initialize(str, safe)
super(str)
@safe = safe
end
def eql?(o)
self.class == o.class && super(o) && @safe == o.safe
end
alias == eql?
end
class AutoArray < Array
attr_accessor :safe
def initialize(a, safe)
super(a)
@safe = safe
end
def eql?(o)
self.class == o.class && super(o) && @safe == o.safe
end
alias == eql?
end
class AutoHash < Hash
attr_accessor :safe
def initialize(h, safe)
super(h)
@safe = safe
end
def eql?(o)
self.class == o.class && super(o) && @safe == o.safe
end
alias == eql?
end
class Raw
attr_accessor :json
def initialize(j)
@json = j
end
def to_json(*a)
@json
end
def self.create(h)
h
end
end # Raw
module Ichi
module Ni
def self.direct(h)
h
end
module San
class Shi
attr_accessor :hash
def initialize(h)
@hash = h
end
def dump()
@hash
end
end # Shi
end # San
end # Ni
end # Ichi
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_nil
dump_and_load(nil, false)
end
def test_true
dump_and_load(true, false)
end
def test_false
dump_and_load(false, false)
end
def test_fixnum
dump_and_load(0, false)
dump_and_load(12345, false)
dump_and_load(-54321, false)
dump_and_load(1, false)
end
def test_float
dump_and_load(0.0, false)
dump_and_load(12345.6789, false)
dump_and_load(70.35, false)
dump_and_load(-54321.012, false)
dump_and_load(1.7775, false)
dump_and_load(2.5024, false)
dump_and_load(2.48e16, false)
dump_and_load(2.48e100 * 1.0e10, false)
dump_and_load(-2.48e100 * 1.0e10, false)
end
def test_string
dump_and_load('', false)
dump_and_load('abc', false)
dump_and_load("abc\ndef", false)
dump_and_load("a\u0041", false)
end
def test_symbol
dump_and_load(:abc, false)
dump_and_load(":abc", false)
end
def test_encode
opts = Oj.default_options
Oj.default_options = { :ascii_only => false }
dump_and_load("ぴーたー", false)
Oj.default_options = { :ascii_only => true }
json = Oj.dump("ぴーたー")
assert_equal(%{"\\u3074\\u30fc\\u305f\\u30fc"}, json)
dump_and_load("ぴーたー", false)
Oj.default_options = opts
end
def test_unicode
# hits the 3 normal ranges and one extended surrogate pair
json = %{"\\u019f\\u05e9\\u3074\\ud834\\udd1e"}
obj = Oj.load(json)
json2 = Oj.dump(obj, :ascii_only => true)
assert_equal(json, json2)
end
def test_array
dump_and_load([], false)
dump_and_load([true, false], false)
dump_and_load(['a', 1, nil], false)
dump_and_load([[nil]], false)
dump_and_load([[nil], 58], false)
end
def test_array_deep
dump_and_load([1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20]]]]]]]]]]]]]]]]]]]], false)
end
# Hash
def test_hash
dump_and_load({}, false)
dump_and_load({ 'true' => true, 'false' => false}, false)
dump_and_load({ 'true' => true, 'array' => [], 'hash' => { }}, false)
end
def test_hash_deep
dump_and_load({'1' => {
'2' => {
'3' => {
'4' => {
'5' => {
'6' => {
'7' => {
'8' => {
'9' => {
'10' => {
'11' => {
'12' => {
'13' => {
'14' => {
'15' => {
'16' => {
'17' => {
'18' => {
'19' => {
'20' => {}}}}}}}}}}}}}}}}}}}}}, false)
end
def test_hash_escaped_key
json = %{{"a\nb":true,"c\td":false}}
obj = Oj.object_load(json)
assert_equal({"a\nb" => true, "c\td" => false}, obj)
end
def test_bignum_object
dump_and_load(7 ** 55, false)
end
# BigDecimal
def test_bigdecimal_object
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
end
def test_bigdecimal_load
orig = BigDecimal.new('80.51')
json = Oj.dump(orig, :mode => :object, :bigdecimal_as_decimal => true)
bg = Oj.load(json, :mode => :object, :bigdecimal_load => true)
assert_equal(BigDecimal, bg.class)
assert_equal(orig, bg)
end
# Stream IO
def test_io_string
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
input = StringIO.new(json)
obj = Oj.object_load(input)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_io_file
filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
File.open(filename, 'w') { |f| f.write(%{{
"x":true,
"y":58,
"z": [1,2,3]
}
}) }
f = File.new(filename)
obj = Oj.object_load(f)
f.close()
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
# symbol_keys option
def test_symbol_keys
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
obj = Oj.object_load(json, :symbol_keys => true)
assert_equal({ :x => true, :y => 58, :z => [1, 2, 3]}, obj)
end
# comments
def test_comment_slash
json = %{{
"x":true,//three
"y":58,
"z": [1,2,
3 // six
]}
}
obj = Oj.object_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment_c
json = %{{
"x"/*one*/:/*two*/true,
"y":58,
"z": [1,2,3]}
}
obj = Oj.object_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment
json = %{{
"x"/*one*/:/*two*/true,//three
"y":58/*four*/,
"z": [1,2/*five*/,
3 // six
]
}
}
obj = Oj.object_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_json_module_object
obj = One::Two::Three::Deep.new()
dump_and_load(obj, false)
end
def test_xml_time
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456789-08:00')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456789, -8 * 3600)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :xmlschema)
#puts "*** json for test_xml_time '#{json}'"
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
def test_xml_time_utc
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456789Z')
else
t = Time.utc(2015, 1, 5, 21, 37, 7.123456789)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :xmlschema)
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
def test_ruby_time
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456789-08:00')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456789, -8 * 3600)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :ruby)
#puts "*** json for test_ruby_time '#{json}'"
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
def test_ruby_time_12345
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456789+03:25')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456789, 12345/60*60)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :ruby)
#puts "*** json for test_ruby_time '#{json}'"
loaded = Oj.object_load(json);
#puts "*** loaded: #{loaded}"
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
def test_ruby_time_utc
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456789Z')
else
t = Time.utc(2015, 1, 5, 21, 37, 7.123456789)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :ruby)
#puts json
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
def test_time_early
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('1954-01-05T21:37:07.123456789-08:00')
else
t = Time.new(1954, 1, 5, 21, 37, 7.123456789, -8 * 3600)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :unix_zone)
#puts json
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
def test_time_unix_zone
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456789-08:00')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456789, -8 * 3600)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :unix_zone)
#puts json
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
unless RUBY_VERSION.start_with?('1.8')
def test_time_unix_zone_12345
t = Time.new(2015, 1, 5, 21, 37, 7.123456789, 12345)
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :unix_zone)
#puts json
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
end
def test_time_unix_zone_utc
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456789Z')
else
t = Time.utc(2015, 1, 5, 21, 37, 7.123456789)
end
# The fractional seconds are not always recreated exactly which causes a
# mismatch so instead the seconds, nsecs, and gmt_offset are checked
# separately along with utc.
json = Oj.dump(t, :mode => :object, :time_format => :unix_zone)
#puts json
loaded = Oj.object_load(json);
assert_equal(t.tv_sec, loaded.tv_sec)
if t.respond_to?(:tv_nsec)
assert_equal(t.tv_nsec, loaded.tv_nsec)
else
assert_equal(t.tv_usec, loaded.tv_usec)
end
assert_equal(t.utc?, loaded.utc?)
assert_equal(t.utc_offset, loaded.utc_offset)
end
def test_json_object
obj = Jeez.new(true, 58)
dump_and_load(obj, false)
end
def test_json_object_create_deep
obj = One::Two::Three::Deep.new()
dump_and_load(obj, false)
end
def test_json_object_bad
json = %{{"^o":"Junk","x":true}}
begin
Oj.object_load(json)
rescue Exception => e
assert_equal("Oj::ParseError", e.class().name)
return
end
assert(false, "*** expected an exception")
end
def test_json_object_not_hat_hash
json = %{{"^#x":[1,2]}}
h = Oj.object_load(json)
assert_equal({1 => 2}, h);
json = %{{"~#x":[1,2]}}
h = Oj.object_load(json)
assert_equal({'~#x' => [1,2]}, h);
end
def test_json_struct
obj = Stuck.new(false, 7)
dump_and_load(obj, false)
end
def test_json_struct2
obj = One::Stuck2.new(false, 7)
dump_and_load(obj, false)
end
def test_json_anonymous_struct
s = Struct.new(:x, :y)
obj = s.new(1, 2)
json = Oj.dump(obj, :indent => 2, :mode => :object)
#puts json
loaded = Oj.object_load(json);
assert_equal(obj.members, loaded.members)
assert_equal(obj.values, loaded.values)
end
def test_json_non_str_hash
obj = { 59 => "young", false => true }
dump_and_load(obj, false)
end
def test_mixed_hash_object
Oj.default_options = { :mode => :object }
json = Oj.dump({ 1 => true, 'nil' => nil, :sim => 4 })
h = Oj.object_load(json)
assert_equal({ 1 => true, 'nil' => nil, :sim => 4 }, h)
end
def test_circular_hash
h = { 'a' => 7 }
h['b'] = h
json = Oj.dump(h, :mode => :object, :indent => 2, :circular => true)
h2 = Oj.object_load(json, :circular => true)
assert_equal(h2['b'].__id__, h2.__id__)
end
def test_circular_array
a = [7]
a << a
json = Oj.dump(a, :mode => :object, :indent => 2, :circular => true)
a2 = Oj.object_load(json, :circular => true)
assert_equal(a2[1].__id__, a2.__id__)
end
def test_circular_object
obj = Jeez.new(nil, 58)
obj.x = obj
json = Oj.dump(obj, :mode => :object, :indent => 2, :circular => true)
obj2 = Oj.object_load(json, :circular => true)
assert_equal(obj2.x.__id__, obj2.__id__)
end
def test_circular
h = { 'a' => 7 }
obj = Jeez.new(h, 58)
obj.x['b'] = obj
json = Oj.dump(obj, :mode => :object, :indent => 2, :circular => true)
Oj.object_load(json, :circular => true)
assert_equal(obj.x.__id__, h.__id__)
assert_equal(h['b'].__id__, obj.__id__)
end
def test_odd_date
dump_and_load(Date.new(2012, 6, 19), false)
end
def test_odd_datetime
dump_and_load(DateTime.new(2012, 6, 19, 13, 5, Rational(4, 3)), false)
dump_and_load(DateTime.new(2012, 6, 19, 13, 5, Rational(7123456789, 1000000000)), false)
end
def test_odd_string
Oj.register_odd(Strung, Strung, :create, :to_s, 'safe?')
s = Strung.new("Pete", true)
dump_and_load(s, false)
end
def test_odd_date_replaced
Oj.register_odd(Date, Date, :jd, :jd)
json = Oj.dump(Date.new(2015, 3, 7), :mode => :object)
assert_equal(%|{"^O":"Date","jd":2457089}|, json)
dump_and_load(Date.new(2012, 6, 19), false)
end
def test_odd_raw
Oj.register_odd_raw(Raw, Raw, :create, :to_json)
json = Oj.dump(Raw.new(%|{"a":1}|), :mode => :object)
assert_equal(%|{"^O":"ObjectJuice::Raw","to_json":{"a":1}}|, json)
h = Oj.load(json, :mode => :object)
assert_equal({'a' => 1}, h)
end
def test_odd_mod
Oj.register_odd(Ichi::Ni, Ichi::Ni, :direct, :dump)
json = Oj.dump(Ichi::Ni::San::Shi.new({'a' => 1}), :mode => :object)
assert_equal(%|{"^O":"ObjectJuice::Ichi::Ni::San::Shi","dump":{"a":1}}|, json)
h = Oj.load(json, :mode => :object)
assert_equal({'a' => 1}, h)
end
def test_auto_string
s = AutoStrung.new("Pete", true)
dump_and_load(s, false)
end
def test_auto_array
a = AutoArray.new([1, 'abc', nil], true)
dump_and_load(a, false)
end
def test_auto_hash
h = AutoHash.new(nil, true)
h['a'] = 1
h['b'] = 2
dump_and_load(h, false)
end
def dump_and_load(obj, trace=false)
json = Oj.dump(obj, :indent => 2, :mode => :object)
puts json if trace
loaded = Oj.object_load(json);
assert_equal(obj, loaded)
loaded
end
end
oj-2.17.4/test/test_writer.rb 0000755 0000041 0000041 00000013704 12766161567 016155 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class OjWriter < Minitest::Test
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_string_writer_empty_array
w = Oj::StringWriter.new(:indent => 0)
w.push_array()
w.pop()
assert_equal("[]\n", w.to_s)
end
def test_string_writer_nested_array
w = Oj::StringWriter.new(:indent => 0)
w.push_array()
w.push_array()
w.pop()
w.push_array()
w.push_array()
w.pop()
w.pop()
w.push_array()
w.pop()
w.pop()
assert_equal("[[],[[]],[]]\n", w.to_s)
end
def test_string_writer_empty_object
w = Oj::StringWriter.new(:indent => 0)
w.push_object()
w.pop()
assert_equal("{}\n", w.to_s)
end
def test_string_writer_nested_object
w = Oj::StringWriter.new(:indent => 0)
w.push_object()
w.push_object("a1")
w.pop()
w.push_object("a2")
w.push_object("b")
w.pop()
w.pop()
w.push_object("a3")
w.pop()
w.pop()
assert_equal(%|{"a1":{},"a2":{"b":{}},"a3":{}}\n|, w.to_s)
end
def test_string_writer_nested_key
w = Oj::StringWriter.new(:indent => 0)
w.push_object()
w.push_key('a1')
w.push_object()
w.pop()
w.push_key('a2')
w.push_object('x')
w.push_object('b')
w.pop()
w.pop()
w.push_key('a3')
w.push_object()
w.push_key('a4')
w.push_value(37)
w.pop()
w.pop()
assert_equal(%|{"a1":{},"a2":{"b":{}},"a3":{"a4":37}}\n|, w.to_s)
end
def test_string_writer_value_array
w = Oj::StringWriter.new(:indent => 2)
w.push_array()
w.push_value(7)
w.push_value(7.3)
w.push_value(true)
w.push_value(nil)
w.push_value("a string")
w.push_value({'a' => 65})
w.push_value([1,2])
w.pop()
assert_equal(%|[
7,
7.3,
true,
null,
"a string",
{
"a":65
},
[
1,
2
]
]
|, w.to_s)
end
def test_string_writer_block
w = Oj::StringWriter.new(:indent => 0)
w.push_object() {
w.push_object("a1") {
w.push_value(7, 'a7')
}
w.push_array("a2") {
w.push_value('x')
w.push_value(3)
}
}
assert_equal(%|{"a1":{"a7":7},"a2":["x",3]}\n|, w.to_s)
end
def test_string_writer_json
w = Oj::StringWriter.new(:indent => 0)
w.push_array()
w.push_json('7')
w.push_json('true')
w.push_json(%|"a string"|)
w.push_object()
w.push_json('{"a":65}', 'x')
w.pop()
w.pop()
assert_equal(%|[7,true,"a string",{"x":{"a":65}}]\n|, w.to_s)
end
def test_string_writer_pop_excess
w = Oj::StringWriter.new(:indent => 0)
begin
w.push_object() {
w.push_key('key')
}
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_string_writer_array_key
w = Oj::StringWriter.new(:indent => 0)
begin
w.push_array() {
w.push_key('key')
w.push_value(7)
}
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_string_writer_pop_with_key
w = Oj::StringWriter.new(:indent => 0)
begin
w.pop()
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_string_writer_obj_no_key
w = Oj::StringWriter.new(:indent => 0)
w.push_object()
begin
w.push_value(59)
rescue Exception
assert(true)
return
end
assert(false, "*** expected an exception")
end
def test_string_writer_deep
cnt = 1000
w = Oj::StringWriter.new(:indent => 0)
cnt.times do
w.push_array()
end
cnt.times do
w.pop()
end
# if no exception then passed
assert(true)
end
def test_string_writer_pop_all
w = Oj::StringWriter.new(:indent => 0)
w.push_object()
w.push_object("a1")
w.pop()
w.push_array("a2")
w.push_value(3)
w.push_array()
w.pop_all()
assert_equal(%|{"a1":{},"a2":[3,[]]}\n|, w.to_s)
end
def test_string_writer_reset
w = Oj::StringWriter.new(:indent => 0)
w.push_array()
w.pop()
w.reset()
assert_equal('', w.to_s)
end
# Stream Writer
def test_stream_writer_empty_array
output = StringIO.open("", "w+")
w = Oj::StreamWriter.new(output, :indent => 0)
w.push_array()
w.pop()
assert_equal("[]\n", output.string())
end
def test_stream_writer_mixed_stringio
output = StringIO.open("", "w+")
w = Oj::StreamWriter.new(output, :indent => 0)
w.push_object()
w.push_object("a1")
w.pop()
w.push_object("a2")
w.push_array("b")
w.push_value(7)
w.push_value(true)
w.push_value("string")
w.pop()
w.pop()
w.push_object("a3")
w.pop()
w.pop()
assert_equal(%|{"a1":{},"a2":{"b":[7,true,"string"]},"a3":{}}\n|, output.string())
end
def test_stream_writer_mixed_file
filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
File.open(filename, "w") do |f|
w = Oj::StreamWriter.new(f, :indent => 0)
w.push_object()
w.push_object("a1")
w.pop()
w.push_object("a2")
w.push_array("b")
w.push_value(7)
w.push_value(true)
w.push_value("string")
w.pop()
w.pop()
w.push_object("a3")
w.pop()
w.pop()
end
content = File.read(filename)
assert_equal(%|{"a1":{},"a2":{"b":[7,true,"string"]},"a3":{}}\n|, content)
end
def test_stream_writer_nested_key_object
output = StringIO.open("", "w+")
w = Oj::StreamWriter.new(output, :indent => 0)
w.push_object()
w.push_key('a1')
w.push_object()
w.pop()
w.push_key('a2')
w.push_object('x')
w.push_object('b')
w.pop()
w.pop()
w.push_key('a3')
w.push_object()
w.push_key('a4')
w.push_value(37)
w.pop()
w.pop()
assert_equal(%|{"a1":{},"a2":{"b":{}},"a3":{"a4":37}}\n|, output.string())
end
end # OjWriter
oj-2.17.4/test/test_gc.rb 0000755 0000041 0000041 00000001640 12766161567 015226 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class GCTest < Minitest::Test
class Goo
attr_accessor :x, :child
def initialize(x, child)
@x = x
@child = child
end
def to_hash()
{ 'json_class' => "#{self.class}", 'x' => x, 'child' => child }
end
def self.json_create(h)
GC.start
self.new(h['x'], h['child'])
end
end # Goo
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
# if no crash then the GC marking is working
def test_parse_compat_gc
g = Goo.new(0, nil)
100.times { |i| g = Goo.new(i, g) }
json = Oj.dump(g, :mode => :compat)
Oj.compat_load(json)
end
def test_parse_object_gc
g = Goo.new(0, nil)
100.times { |i| g = Goo.new(i, g) }
json = Oj.dump(g, :mode => :object)
Oj.object_load(json)
end
end
oj-2.17.4/test/perf_obj_old.rb 0000755 0000041 0000041 00000013442 12766161567 016225 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
$: << '.'
$: << '..'
$: << '../lib'
$: << '../ext'
if __FILE__ == $0
if (i = ARGV.index('-I'))
x,path = ARGV.slice!(i, 2)
$: << path
end
end
require 'optparse'
require 'ox'
require 'oj'
require 'perf'
require 'sample'
require 'files'
$verbose = 0
$circular = false
$indent = 0
do_sample = false
do_files = false
do_load = false
do_dump = false
do_read = false
do_write = false
$iter = 1000
opts = OptionParser.new
opts.on("-v", "increase verbosity") { $verbose += 1 }
opts.on("-c", "circular options") { $circular = true }
opts.on("-s", "load and dump as sample Ruby object") { do_sample = true }
opts.on("-f", "load and dump as files Ruby object") { do_files = true }
opts.on("-l", "load") { do_load = true }
opts.on("-d", "dump") { do_dump = true }
opts.on("-r", "read") { do_read = true }
opts.on("-w", "write") { do_write = true }
opts.on("-a", "load, dump, read and write") { do_load = true; do_dump = true; do_read = true; do_write = true }
opts.on("-i", "--iterations [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
if files.empty?
data = []
obj = do_sample ? sample_doc(2) : files('..')
mars = Marshal.dump(obj)
xml = Ox.dump(obj, :indent => $indent, circular: $circular)
json = Oj.dump(obj, :indent => $indent, circular: $circular)
File.open('sample.xml', 'w') { |f| f.write(xml) }
File.open('sample.json', 'w') { |f| f.write(json) }
File.open('sample.marshal', 'w') { |f| f.write(mars) }
data << { :file => 'sample.xml', :obj => obj, :xml => xml, :marshal => mars, :json => json }
else
puts "loading and parsing #{files}\n\n"
# TBD change to allow xml and json
data = files.map do |f|
xml = File.read(f)
obj = Ox.load(xml);
mars = Marshal.dump(obj)
json = Oj.dump(obj, :indent => $indent, circular: $circular)
{ :file => f, :obj => obj, :xml => xml, :marshal => mars, :json => json }
end
end
$ox_load_time = 0
$mars_load_time = 0
$ox_dump_time = 0
$oj_dump_time = 0
$mars_dump_time = 0
def perf_load(d)
filename = d[:file]
marshal_filename = 'sample.marshal'
xml = d[:xml]
mars = d[:marshal]
json = d[:json]
if 0 < $verbose
obj = Ox.load(xml, :mode => :object, :trace => $verbose)
return
end
start = Time.now
(1..$iter).each do
obj = Ox.load(xml, :mode => :object)
end
$ox_load_time = Time.now - start
puts "Parsing #{$iter} times with Ox took #{$ox_load_time} seconds."
start = Time.now
(1..$iter).each do
obj = Oj.load(json, :mode => :object)
end
$oj_load_time = Time.now - start
puts "Parsing #{$iter} times with Oj took #{$oj_load_time} seconds."
start = Time.now
(1..$iter).each do
obj = Marshal.load(mars)
end
$mars_load_time = Time.now - start
puts "Marshalling #{$iter} times took #{$mars_load_time} seconds."
puts ">>> Ox is %0.1f faster than Marshal loading.\n\n" % [$mars_load_time/$ox_load_time]
end
def perf_dump(d)
obj = d[:obj]
start = Time.now
(1..$iter).each do
xml = Ox.dump(obj, :indent => $indent, :circular => $circular)
#puts "*** ox:\n#{xml}"
end
$ox_dump_time = Time.now - start
puts "Ox dumping #{$iter} times with ox took #{$ox_dump_time} seconds."
Oj.default_options = {:indent => $indent}
start = Time.now
(1..$iter).each do
json = Oj.dump(obj)
end
$oj_dump_time = Time.now - start
puts "Oj dumping #{$iter} times with oj took #{$oj_dump_time} seconds."
obj = d[:obj]
start = Time.now
(1..$iter).each do
m = Marshal.dump(obj)
end
$mars_dump_time = Time.now - start
puts "Marshal dumping #{$iter} times took #{$mars_dump_time} seconds."
puts ">>> Ox is %0.1f faster than Marshal dumping.\n\n" % [$mars_dump_time/$ox_dump_time]
end
def perf_read(d)
ox_read_time = 0
mars_read_time = 0
filename = d[:file]
marshal_filename = 'sample.marshal'
xml = d[:xml]
mars = d[:marshal]
# now load from the file
start = Time.now
(1..$iter).each do
obj = Ox.load_file(filename, :mode => :object)
end
ox_read_time = Time.now - start
puts "Loading and parsing #{$iter} times with ox took #{ox_read_time} seconds."
start = Time.now
(1..$iter).each do
m = File.read(marshal_filename)
obj = Marshal.load(m)
end
mars_read_time = Time.now - start
puts "Reading and marshalling #{$iter} times took #{mars_read_time} seconds."
puts ">>> Ox is %0.1f faster than Marshal loading and parsing.\n\n" % [mars_read_time/ox_read_time]
end
def perf_write(d)
ox_write_time = 0
mars_write_time = 0
ox_filename = 'out.xml'
marshal_filename = 'out.marshal'
obj = d[:obj]
start = Time.now
(1..$iter).each do
xml = Ox.to_file(ox_filename, obj, :indent => $indent)
end
ox_write_time = Time.now - start
puts "Ox dumping #{$iter} times with ox took #{ox_write_time} seconds."
start = Time.now
(1..$iter).each do
m = Marshal.dump(obj, circular: $circular)
File.open(marshal_filename, "w") { |f| f.write(m) }
end
mars_write_time = Time.now - start
puts "Marshal dumping and writing #{$iter} times took #{mars_write_time} seconds."
puts ">>> Ox is %0.1f faster than Marshal dumping.\n\n" % [mars_write_time/ox_write_time]
end
#if do_sample or do_files
data.each do |d|
puts "Using file #{d[:file]}."
perf_load(d) if do_load
perf_dump(d) if do_dump
if do_load and do_dump
puts ">>> Ox is %0.1f faster than Marshal dumping and loading.\n\n" % [($mars_load_time + $mars_dump_time)/($ox_load_time + $ox_dump_time)] unless 0 == $mars_load_time
end
perf_read(d) if do_read
perf_write(d) if do_write
end
#end
oj-2.17.4/test/test_strict.rb 0000755 0000041 0000041 00000013775 12766161567 016161 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class StrictJuice < Minitest::Test
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_nil
dump_and_load(nil, false)
end
def test_true
dump_and_load(true, false)
end
def test_false
dump_and_load(false, false)
end
def test_fixnum
dump_and_load(0, false)
dump_and_load(12345, false)
dump_and_load(-54321, false)
dump_and_load(1, false)
end
def test_float
dump_and_load(0.0, false)
dump_and_load(12345.6789, false)
dump_and_load(70.35, false)
dump_and_load(-54321.012, false)
dump_and_load(1.7775, false)
dump_and_load(2.5024, false)
dump_and_load(2.48e16, false)
dump_and_load(2.48e100 * 1.0e10, false)
dump_and_load(-2.48e100 * 1.0e10, false)
end
def test_string
dump_and_load('', false)
dump_and_load('abc', false)
dump_and_load("abc\ndef", false)
dump_and_load("a\u0041", false)
end
def test_encode
opts = Oj.default_options
Oj.default_options = { :ascii_only => false }
unless 'jruby' == $ruby
dump_and_load("ぴーたー", false)
end
Oj.default_options = { :ascii_only => true }
json = Oj.dump("ぴーたー")
assert_equal(%{"\\u3074\\u30fc\\u305f\\u30fc"}, json)
unless 'jruby' == $ruby
dump_and_load("ぴーたー", false)
end
Oj.default_options = opts
end
def test_unicode
# hits the 3 normal ranges and one extended surrogate pair
json = %{"\\u019f\\u05e9\\u3074\\ud834\\udd1e"}
obj = Oj.load(json)
json2 = Oj.dump(obj, :ascii_only => true)
assert_equal(json, json2)
end
def test_unicode_long
# tests buffer overflow
json = %{"\\u019f\\u05e9\\u3074\\ud834\\udd1e #{'x' * 2000}"}
obj = Oj.load(json)
json2 = Oj.dump(obj, :ascii_only => true)
assert_equal(json, json2)
end
def test_array
dump_and_load([], false)
dump_and_load([true, false], false)
dump_and_load(['a', 1, nil], false)
dump_and_load([[nil]], false)
dump_and_load([[nil], 58], false)
end
def test_array_deep
dump_and_load([1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20]]]]]]]]]]]]]]]]]]]], false)
end
# Hash
def test_hash
dump_and_load({}, false)
dump_and_load({ 'true' => true, 'false' => false}, false)
dump_and_load({ 'true' => true, 'array' => [], 'hash' => { }}, false)
end
def test_hash_deep
dump_and_load({'1' => {
'2' => {
'3' => {
'4' => {
'5' => {
'6' => {
'7' => {
'8' => {
'9' => {
'10' => {
'11' => {
'12' => {
'13' => {
'14' => {
'15' => {
'16' => {
'17' => {
'18' => {
'19' => {
'20' => {}}}}}}}}}}}}}}}}}}}}}, false)
end
def test_hash_escaped_key
json = %{{"a\nb":true,"c\td":false}}
obj = Oj.strict_load(json)
assert_equal({"a\nb" => true, "c\td" => false}, obj)
end
def test_bignum_object
dump_and_load(7 ** 55, false)
end
# BigDecimal
def test_bigdecimal_strict
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
end
def test_bigdecimal_load
orig = BigDecimal.new('80.51')
json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => true)
bg = Oj.load(json, :mode => :compat, :bigdecimal_load => true)
assert_equal(BigDecimal, bg.class)
assert_equal(orig, bg)
end
# Stream IO
def test_io_string
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
input = StringIO.new(json)
obj = Oj.strict_load(input)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_io_file
filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
File.open(filename, 'w') { |f| f.write(%{{
"x":true,
"y":58,
"z": [1,2,3]
}
}) }
f = File.new(filename)
obj = Oj.strict_load(f)
f.close()
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
# symbol_keys option
def test_symbol_keys
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
obj = Oj.strict_load(json, :symbol_keys => true)
assert_equal({ :x => true, :y => 58, :z => [1, 2, 3]}, obj)
end
def test_symbol_keys_safe
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
obj = Oj.safe_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
# comments
def test_comment_slash
json = %{{
"x":true,//three
"y":58,
"z": [1,2,
3 // six
]}
}
obj = Oj.strict_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment_c
json = %{{
"x"/*one*/:/*two*/true,
"y":58,
"z": [1,2,3]}
}
obj = Oj.strict_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment
json = %{{
"x"/*one*/:/*two*/true,//three
"y":58/*four*/,
"z": [1,2/*five*/,
3 // six
]
}
}
obj = Oj.strict_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_double
json = %{{ "x": 1}{ "y": 2}}
results = []
Oj.load(json, :mode => :strict) { |x| results << x }
assert_equal([{ 'x' => 1 }, { 'y' => 2 }], results)
end
def dump_and_load(obj, trace=false)
json = Oj.dump(obj, :indent => 2)
puts json if trace
loaded = Oj.strict_load(json);
assert_equal(obj, loaded)
loaded
end
end
oj-2.17.4/test/pact.rb 0000755 0000041 0000041 00000000560 12766161567 014525 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
['ext', 'lib'].each do |dir|
$: << File.join(File.dirname(File.expand_path(File.dirname(__FILE__))), dir)
end
#require 'json'
require 'oj'
Oj.mimic_JSON()
require 'pact'
puts "*** responds? #{Regexp.respond_to?(:json_create)}"
j = /1/.to_json
puts "json: #{j}"
puts "regexp: #{JSON.load(j)}"
oj-2.17.4/test/aaa.rb 0000755 0000041 0000041 00000000603 12766161567 014316 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$VERBOSE = true
%w(lib ext test).each do |dir|
$LOAD_PATH.unshift File.expand_path("../../#{dir}", __FILE__)
end
#require 'json'
require 'oj'
Oj.mimic_JSON
JSON.dump_default_options[:ascii_only]=true
puts JSON.dump_default_options
puts JSON.dump(["a😬sdf"])
JSON.dump_default_options = {:ascii_only=>false}
puts JSON.dump_default_options
oj-2.17.4/test/sample_json.rb 0000755 0000041 0000041 00000001337 12766161567 016113 0 ustar www-data www-data #!/usr/bin/env ruby -wW2
if $0 == __FILE__
$: << '.'
$: << '..'
$: << '../lib'
$: << '../ext'
end
require 'pp'
require 'oj'
def sample_json(size=3)
colors = [ :black, :gray, :white, :red, :blue, :yellow, :green, :purple, :orange ]
container = []
size.times do |i|
box = {
'color' => colors[i % colors.size],
'fragile' => (0 == (i % 2)),
'width' => i,
'height' => i,
'depth' => i,
'weight' => i * 1.3,
'address' => {
'street' => "#{i} Main Street",
'city' => 'Sity',
'state' => nil
}
}
container << box
end
container
end
if $0 == __FILE__
File.open('sample.json', "w") { |f| f.write(Oj.dump(sample_json(3), :indent => 2)) }
end
oj-2.17.4/test/perf1.rb 0000644 0000041 0000041 00000002422 12766161567 014607 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
#require 'test/unit'
require 'optparse'
require 'oj'
require 'ox'
$indent = 2
opts = OptionParser.new
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
iter = 100000
s = %{
{ "class": "Foo::Bar",
"attr1": [ true, [false, [12345, null], 3.967, ["something", false], null]],
"attr2": { "one": 1 }
}
}
#s = File.read('sample.json')
Oj.default_options = { :indent => 0 }
obj = Oj.load(s)
xml = Ox.dump(obj, :indent => 0)
puts xml
start = Time.now
iter.times do
Oj.load(s)
end
dt = Time.now - start
puts "%d Oj.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
start = Time.now
iter.times do
Ox.load(xml)
end
dt = Time.now - start
puts "%d Ox.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
puts
start = Time.now
iter.times do
Oj.dump(obj)
end
dt = Time.now - start
puts "%d Oj.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
start = Time.now
iter.times do
Ox.dump(obj)
end
dt = Time.now - start
puts "%d Ox.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
puts
oj-2.17.4/test/sample/ 0000755 0000041 0000041 00000000000 12766161567 014526 5 ustar www-data www-data oj-2.17.4/test/sample/oval.rb 0000644 0000041 0000041 00000000211 12766161567 016006 0 ustar www-data www-data module Sample
class Oval < Shape
def initialize(left, top, wide, high, color=nil)
super
end
end # Oval
end # Sample
oj-2.17.4/test/sample/hasprops.rb 0000644 0000041 0000041 00000000456 12766161567 016717 0 ustar www-data www-data
module Sample
module HasProps
def add_prop(key, value)
@props = { } unless self.instance_variable_defined?(:@props)
@props[key] = value
end
def props
@props = { } unless self.instance_variable_defined?(:@props)
@props
end
end # HasProps
end # Sample
oj-2.17.4/test/sample/layer.rb 0000644 0000041 0000041 00000000234 12766161567 016166 0 ustar www-data www-data
module Sample
class Layer < Group
attr_accessor :name
def initialize(name)
super()
@name = name
end
end # Layer
end # Sample
oj-2.17.4/test/sample/rect.rb 0000644 0000041 0000041 00000000211 12766161567 016002 0 ustar www-data www-data
module Sample
class Rect < Shape
def initialize(left, top, wide, high, color=nil)
super
end
end # Rect
end # Sample
oj-2.17.4/test/sample/text.rb 0000644 0000041 0000041 00000000644 12766161567 016043 0 ustar www-data www-data
module Sample
class Text < Shape
attr_accessor :text
attr_accessor :font
attr_accessor :font_size
attr_accessor :just
attr_accessor :text_color
def initialize(text, left, top, wide, high, color=nil)
super(left, top, wide, high, color)
@text = text
@font = 'helvetica'
@font_size = 14
@just = 'left'
@text_color = 'black'
end
end # Text
end # Sample
oj-2.17.4/test/sample/doc.rb 0000644 0000041 0000041 00000001370 12766161567 015621 0 ustar www-data www-data
require 'sample/hasprops'
require 'sample/group'
require 'sample/layer'
require 'sample/line'
require 'sample/shape'
require 'sample/oval'
require 'sample/rect'
require 'sample/text'
require 'sample/change'
module Sample
class Doc
include HasProps
attr_accessor :title
attr_accessor :create_time
attr_accessor :user
# Hash of layers in the document indexed by layer name.
attr_reader :layers
attr_reader :change_history
def initialize(title)
@title = title
@user = ENV['USER']
@create_time = Time.now
@layers = { }
@change_history = []
end
def add_change(comment, time=nil, user=nil)
@change_history << Change.new(comment, time, user)
end
end # Doc
end # Sample
oj-2.17.4/test/sample/change.rb 0000644 0000041 0000041 00000000441 12766161567 016277 0 ustar www-data www-data
module Sample
class Change
attr_accessor :time
attr_accessor :user
attr_accessor :comment
def initialize(comment=nil, time=nil, user=nil)
@user = user || ENV['USER']
@time = time || Time.now
@comment = comment
end
end # Change
end # Sample
oj-2.17.4/test/sample/line.rb 0000644 0000041 0000041 00000000500 12766161567 015775 0 ustar www-data www-data module Sample
class Line
include HasProps
attr_accessor :x, :y, :dx, :dy
attr_accessor :color
attr_accessor :thick
def initialize(x, y, dx, dy, thick, color)
@x = x
@y = y
@dx = dx
@dy = dy
@thick = thick
@color = color
end
end # Line
end # Sample
oj-2.17.4/test/sample/shape.rb 0000644 0000041 0000041 00000001105 12766161567 016150 0 ustar www-data www-data
module Sample
class Shape
include HasProps
attr_accessor :bounds
attr_accessor :color
attr_accessor :border, :border_color
def initialize(left, top, wide, high, color=nil)
@bounds = [[left, top], [left + wide, top + high]]
@color = color
@border = 1
@border_color = :black
end
def left
@bounds[0][0]
end
def top
@bounds[0][1]
end
def width
@bounds[1][0] - @bounds[0][0]
end
def height
@bounds[1][1] - @bounds[0][1]
end
end # Shape
end # Sample
oj-2.17.4/test/sample/file.rb 0000644 0000041 0000041 00000003200 12766161567 015765 0 ustar www-data www-data
require 'etc'
module Sample
class File
attr_accessor :name, :ctime, :mtime, :size, :owner, :group, :permissions
def initialize(filename)
@name = ::File.basename(filename)
stat = ::File.stat(filename)
@ctime = stat.ctime
@mtime = stat.mtime
@size = stat.size
@owner = Etc.getpwuid(stat.uid).name
@group = Etc.getgrgid(stat.gid).name
if false
@permissions = {
'user' => {
'read' => (0 != (stat.mode & 0x0100)),
'write' => (0 != (stat.mode & 0x0080)),
'execute' => (0 != (stat.mode & 0x0040))},
'group' => {
'read' => (0 != (stat.mode & 0x0020)),
'write' => (0 != (stat.mode & 0x0010)),
'execute' => (0 != (stat.mode & 0x0008))},
'other' => {
'read' => (0 != (stat.mode & 0x0004)),
'write' => (0 != (stat.mode & 0x0002)),
'execute' => (0 != (stat.mode & 0x0001))}
}
else
@permissions = {
'user' => [(0 != (stat.mode & 0x0100)) ? 'r' : '-',
(0 != (stat.mode & 0x0080)) ? 'w' : '-',
(0 != (stat.mode & 0x0040)) ? 'x' : '-'].join(''),
'group' => [(0 != (stat.mode & 0x0020)) ? 'r' : '-',
(0 != (stat.mode & 0x0010)) ? 'w' : '-',
(0 != (stat.mode & 0x0008)) ? 'x' : '-'].join(''),
'other' => [(0 != (stat.mode & 0x0004)) ? 'r' : '-',
(0 != (stat.mode & 0x0002)) ? 'w' : '-',
(0 != (stat.mode & 0x0001)) ? 'x' : '-'].join('')
}
end
end
end # File
end # Sample
oj-2.17.4/test/sample/group.rb 0000644 0000041 0000041 00000000306 12766161567 016206 0 ustar www-data www-data
module Sample
class Group
attr_reader :members
def initialize()
@members = []
end
def <<(member)
@members << member
end
end # Group
end # Sample
oj-2.17.4/test/sample/dir.rb 0000644 0000041 0000041 00000000326 12766161567 015632 0 ustar www-data www-data
require 'etc'
module Sample
class Dir < File
attr_accessor :files
def initialize(filename)
super
@files = []
end
def <<(f)
@files << f
end
end # Dir
end # Sample
oj-2.17.4/test/perf_scp.rb 0000755 0000041 0000041 00000007253 12766161567 015405 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << '.'
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
require 'optparse'
require 'yajl'
require 'perf'
require 'json'
require 'json/ext'
require 'oj'
$verbose = false
$indent = 0
$iter = 50000
$with_bignum = false
$size = 0
opts = OptionParser.new
opts.on("-v", "verbose") { $verbose = true }
opts.on("-c", "--count [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-i", "--indent [Int]", Integer, "indentation") { |i| $indent = i }
opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)") { |i| $size = i }
opts.on("-b", "with bignum") { $with_bignum = true }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
$obj = {
'a' => 'Alpha', # string
'b' => true, # boolean
'c' => 12345, # number
'd' => [ true, [false, [-123456789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
'e' => { 'zero' => nil, 'one' => 1, 'two' => 2, 'three' => [3], 'four' => [0, 1, 2, 3, 4] }, # hash
'f' => nil, # nil
'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
'i' => [[[[[[[nil]]]]]]] # deep array, again, not that deep
}
$obj['g'] = 12345678901234567890123456789 if $with_bignum
if 0 < $size
o = $obj
$obj = []
(4 * $size).times do
$obj << o
end
end
Oj.default_options = { :indent => $indent, :mode => :compat }
$json = Oj.dump($obj)
$failed = {} # key is same as String used in tests later
class AllSaj < Oj::Saj
def initialize()
end
def hash_start(key)
end
def hash_end(key)
end
def array_start(key)
end
def array_end(key)
end
def add_value(value, key)
end
end # AllSaj
class NoSaj < Oj::Saj
def initialize()
end
end # NoSaj
class NoHandler < Oj::ScHandler
def initialize()
end
end # NoHandler
class AllHandler < Oj::ScHandler
def initialize()
end
def hash_start()
return nil
end
def hash_end()
end
def array_start()
return nil
end
def array_end()
end
def add_value(value)
end
def hash_set(h, key, value)
end
def array_append(a, value)
end
end # AllHandler
saj_handler = AllSaj.new()
no_saj = NoSaj.new()
sc_handler = AllHandler.new()
no_handler = NoHandler.new()
def capture_error(tag, orig, load_key, dump_key, &blk)
begin
obj = blk.call(orig)
raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
rescue Exception => e
$failed[tag] = "#{e.class}: #{e.message}"
end
end
# Verify that all packages dump and load correctly and return the same Object as the original.
capture_error('Yajl', $obj, 'encode', 'parse') { |o| Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o| JSON.generator = JSON::Ext::Generator; JSON::Ext::Parser.new(JSON.generate(o)).parse }
if $verbose
puts "json:\n#{$json}\n"
end
puts '-' * 80
puts "Parse Performance"
perf = Perf.new()
perf.add('Oj::Saj', 'all') { Oj.saj_parse(saj_handler, $json) }
perf.add('Oj::Saj', 'none') { Oj.saj_parse(no_saj, $json) }
perf.add('Oj::Scp', 'all') { Oj.sc_parse(sc_handler, $json) }
perf.add('Oj::Scp', 'none') { Oj.sc_parse(no_handler, $json) }
perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
perf.add('JSON::Ext', 'parse') { JSON::Ext::Parser.new($json).parse } unless $failed.has_key?('JSON::Ext')
perf.run($iter)
unless $failed.empty?
puts "The following packages were not included for the reason listed"
$failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
end
oj-2.17.4/test/test_compat.rb 0000755 0000041 0000041 00000024153 12766161567 016124 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
class CompatJuice < Minitest::Test
class Jeez
attr_accessor :x, :y
def initialize(x, y)
@x = x
@y = y
end
def eql?(o)
self.class == o.class && @x == o.x && @y == o.y
end
alias == eql?
def as_json()
{"json_class" => self.class.to_s,"x" => @x,"y" => @y}
end
def self.json_create(h)
self.new(h['x'], h['y'])
end
end # Jeez
module One
module Two
module Three
class Deep
def initialize()
end
def eql?(o)
self.class == o.class
end
alias == eql?
def to_hash()
{'json_class' => "#{self.class.name}"}
end
def to_json(*a)
%{{"json_class":"#{self.class.name}"}}
end
def self.json_create(h)
self.new()
end
end # Deep
end # Three
end # Two
end # One
def setup
@default_options = Oj.default_options
end
def teardown
Oj.default_options = @default_options
end
def test_nil
dump_and_load(nil, false)
end
def test_true
dump_and_load(true, false)
end
def test_false
dump_and_load(false, false)
end
def test_fixnum
dump_and_load(0, false)
dump_and_load(12345, false)
dump_and_load(-54321, false)
dump_and_load(1, false)
end
def test_float
dump_and_load(0.0, false)
dump_and_load(12345.6789, false)
dump_and_load(70.35, false)
dump_and_load(-54321.012, false)
dump_and_load(1.7775, false)
dump_and_load(2.5024, false)
dump_and_load(2.48e16, false)
dump_and_load(2.48e100 * 1.0e10, false)
dump_and_load(-2.48e100 * 1.0e10, false)
end
def test_string
dump_and_load('', false)
dump_and_load('abc', false)
dump_and_load("abc\ndef", false)
dump_and_load("a\u0041", false)
end
def test_encode
opts = Oj.default_options
Oj.default_options = { :ascii_only => false }
unless 'jruby' == $ruby
dump_and_load("ぴーたー", false)
end
Oj.default_options = { :ascii_only => true }
json = Oj.dump("ぴーたー")
assert_equal(%{"\\u3074\\u30fc\\u305f\\u30fc"}, json)
unless 'jruby' == $ruby
dump_and_load("ぴーたー", false)
end
Oj.default_options = opts
end
def test_unicode
# hits the 3 normal ranges and one extended surrogate pair
json = %{"\\u019f\\u05e9\\u3074\\ud834\\udd1e"}
obj = Oj.load(json)
json2 = Oj.dump(obj, :ascii_only => true)
assert_equal(json, json2)
end
def test_array
dump_and_load([], false)
dump_and_load([true, false], false)
dump_and_load(['a', 1, nil], false)
dump_and_load([[nil]], false)
dump_and_load([[nil], 58], false)
end
def test_array_deep
dump_and_load([1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20]]]]]]]]]]]]]]]]]]]], false)
end
# Hash
def test_hash
dump_and_load({}, false)
dump_and_load({ 'true' => true, 'false' => false}, false)
dump_and_load({ 'true' => true, 'array' => [], 'hash' => { }}, false)
end
def test_hash_deep
dump_and_load({'1' => {
'2' => {
'3' => {
'4' => {
'5' => {
'6' => {
'7' => {
'8' => {
'9' => {
'10' => {
'11' => {
'12' => {
'13' => {
'14' => {
'15' => {
'16' => {
'17' => {
'18' => {
'19' => {
'20' => {}}}}}}}}}}}}}}}}}}}}}, false)
end
def test_hash_escaped_key
json = %{{"a\nb":true,"c\td":false}}
obj = Oj.compat_load(json)
assert_equal({"a\nb" => true, "c\td" => false}, obj)
end
def test_bignum_object
dump_and_load(7 ** 55, false)
end
# BigDecimal
def test_bigdecimal_compat
dump_and_load(BigDecimal.new('3.14159265358979323846'), false)
end
def test_bigdecimal_load
orig = BigDecimal.new('80.51')
json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => true)
bg = Oj.load(json, :mode => :compat, :bigdecimal_load => true)
assert_equal(BigDecimal, bg.class)
assert_equal(orig, bg)
end
# Time
def test_time_ruby
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456-08:00')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
end
expect = '"' + t.to_s + '"'
json = Oj.dump(t, :mode => :compat, :time_format => :ruby)
assert_equal(expect, json)
end
def test_time_xml
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456-08:00')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
end
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 6)
assert_equal('"2015-01-05T21:37:07.123456-08:00"', json)
end
unless RUBY_VERSION.start_with?('1.8')
def test_time_xml_12345
t = Time.new(2015, 1, 5, 21, 37, 7.123456, 12345)
json = Oj.dump(t, :mode => :compat, :time_format => :xmlschema, :second_precision => 6)
assert_equal('"2015-01-05T21:37:07.123456+03:25"', json)
end
end
def test_time_unix
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456-08:00')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
end
json = Oj.dump(t, :mode => :compat, :time_format => :unix, :second_precision => 6)
assert_equal('1420522627.123456', json)
end
def test_time_unix_zone
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('2015-01-05T21:37:07.123456-08:00')
else
t = Time.new(2015, 1, 5, 21, 37, 7.123456, -8 * 3600)
end
json = Oj.dump(t, :mode => :compat, :time_format => :unix_zone, :second_precision => 6)
assert_equal('1420522627.123456e-28800', json)
end
unless RUBY_VERSION.start_with?('1.8')
def test_time_unix_zone_12345
t = Time.new(2015, 1, 5, 21, 37, 7.123456, 12345)
json = Oj.dump(t, :mode => :compat, :time_format => :unix_zone, :second_precision => 6)
assert_equal('1420481482.123456e12345', json)
end
end
def test_time_unix_zone_early
if RUBY_VERSION.start_with?('1.8')
t = Time.parse('1954-01-05T21:37:07.123456-08:00')
else
t = Time.new(1954, 1, 5, 21, 37, 7.123456, -8 * 3600)
end
json = Oj.dump(t, :mode => :compat, :time_format => :unix_zone, :second_precision => 6)
assert_equal('-504469372.876544e-28800', json)
end
# Stream IO
def test_io_string
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
input = StringIO.new(json)
obj = Oj.compat_load(input)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_io_file
filename = File.join(File.dirname(__FILE__), 'open_file_test.json')
File.open(filename, 'w') { |f| f.write(%{{
"x":true,
"y":58,
"z": [1,2,3]
}
}) }
f = File.new(filename)
obj = Oj.compat_load(f)
f.close()
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
# symbol_keys option
def test_symbol_keys
json = %{{
"x":true,
"y":58,
"z": [1,2,3]
}
}
obj = Oj.compat_load(json, :symbol_keys => true)
assert_equal({ :x => true, :y => 58, :z => [1, 2, 3]}, obj)
end
# comments
def test_comment_slash
json = %{{
"x":true,//three
"y":58,
"z": [1,2,
3 // six
]}
}
obj = Oj.compat_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment_c
json = %{{
"x"/*one*/:/*two*/true,
"y":58,
"z": [1,2,3]}
}
obj = Oj.compat_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_comment
json = %{{
"x"/*one*/:/*two*/true,//three
"y":58/*four*/,
"z": [1,2/*five*/,
3 // six
]
}
}
obj = Oj.compat_load(json)
assert_equal({ 'x' => true, 'y' => 58, 'z' => [1, 2, 3]}, obj)
end
def test_json_object_compat
obj = Jeez.new(true, 58)
Oj.default_options = { :mode => :compat, :use_to_json => true }
dump_and_load(obj, false)
end
def test_json_module_object
obj = One::Two::Three::Deep.new()
dump_and_load(obj, false)
end
def test_json_object_create_id
expected = Jeez.new(true, 58)
json = Oj.dump(expected, :indent => 2, :mode => :compat, :use_to_json => true)
obj = Oj.compat_load(json)
assert_equal(expected, obj)
end
def test_json_object_bad
json = %{{"json_class":"CompatJuice::Junk","x":true}}
begin
Oj.compat_load(json)
rescue Exception => e
assert_equal("Oj::ParseError", e.class().name)
return
end
assert(false, "*** expected an exception")
end
def test_json_object_create_cache
expected = Jeez.new(true, 58)
json = Oj.dump(expected, :indent => 2, :mode => :compat, :use_to_json => true)
obj = Oj.compat_load(json, :class_cache => true)
assert_equal(expected, obj)
obj = Oj.compat_load(json, :class_cache => false)
assert_equal(expected, obj)
end
def test_json_object_create_id_other
expected = Jeez.new(true, 58)
json = Oj.dump(expected, :indent => 2, :mode => :compat, :use_to_json => true)
json.gsub!('json_class', '_class_')
obj = Oj.compat_load(json, :create_id => "_class_")
assert_equal(expected, obj)
end
def test_json_object_create_deep
expected = One::Two::Three::Deep.new()
json = Oj.dump(expected, :indent => 2, :mode => :compat)
obj = Oj.compat_load(json)
assert_equal(expected, obj)
end
def dump_and_load(obj, trace=false)
json = Oj.dump(obj, :indent => 2, :mode => :compat)
puts json if trace
loaded = Oj.compat_load(json);
assert_equal(obj, loaded)
loaded
end
end
oj-2.17.4/test/perf_compat.rb 0000755 0000041 0000041 00000006601 12766161567 016077 0 ustar www-data www-data #!/usr/bin/env ruby -wW1
# encoding: UTF-8
$: << '.'
$: << File.join(File.dirname(__FILE__), "../lib")
$: << File.join(File.dirname(__FILE__), "../ext")
require 'optparse'
require 'perf'
require 'oj'
$verbose = false
$indent = 0
$iter = 20000
$with_bignum = false
$with_nums = true
$size = 0
opts = OptionParser.new
opts.on("-v", "verbose") { $verbose = true }
opts.on("-c", "--count [Int]", Integer, "iterations") { |i| $iter = i }
opts.on("-i", "--indent [Int]", Integer, "indentation") { |i| $indent = i }
opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)") { |i| $size = i }
opts.on("-h", "--help", "Show this display") { puts opts; Process.exit!(0) }
files = opts.parse(ARGV)
module One
module Two
module Three
class Empty
def initialize()
end
def eql?(o)
self.class == o.class
end
alias == eql?
def to_hash()
{'json_class' => "#{self.class.name}"}
end
def to_json(*a)
%{{"json_class":"#{self.class.name}"}}
end
def self.json_create(h)
self.new()
end
end # Empty
end # Three
end # Two
end # One
$obj = {
'a' => 'Alpha', # string
'b' => true, # boolean
'c' => 12345, # number
'd' => [ true, [false, [-123456789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
'e' => { 'zero' => nil, 'one' => 1, 'two' => 2, 'three' => [3], 'four' => [0, 1, 2, 3, 4] }, # hash
'f' => nil, # nil
'g' => One::Two::Three::Empty.new(),
'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
'i' => [[[[[[[nil]]]]]]] # deep array, again, not that deep
}
Oj.default_options = { :indent => $indent, :mode => :compat }
if 0 < $size
s = Oj.dump($obj).size + 1
cnt = $size * 1024 / s
o = $obj
$obj = []
cnt.times do
$obj << o
end
end
$json = Oj.dump($obj)
$failed = {} # key is same as String used in tests later
def capture_error(tag, orig, load_key, dump_key, &blk)
begin
obj = blk.call(orig)
raise "#{tag} #{dump_key} and #{load_key} did not return the same object as the original." unless orig == obj
rescue Exception => e
$failed[tag] = "#{e.class}: #{e.message}"
end
end
# Verify that all packages dump and load correctly and return the same Object as the original.
capture_error('Oj:compat', $obj, 'load', 'dump') { |o| Oj.compat_load(Oj.dump(o, :mode => :compat)) }
capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
require 'json'
require 'json/ext'
JSON.generator = JSON::Ext::Generator
JSON.parser = JSON::Ext::Parser
JSON.load(JSON.generate(o))
}
if $verbose
puts "size: #{$json.size}"
puts "json:\n#{$json}\n"
puts "Oj:compat loaded object:\n#{Oj.compat_load($json)}\n"
puts "JSON loaded object:\n#{JSON::Ext::Parser.new($json).parse}\n"
end
puts '-' * 80
puts "Compat Parse Performance"
perf = Perf.new()
unless $failed.has_key?('JSON::Ext')
perf.add('JSON::Ext', 'parse') { JSON.load($json) }
perf.before('JSON::Ext') { JSON.parser = JSON::Ext::Parser }
end
unless $failed.has_key?('Oj:compat')
perf.add('Oj:compat', 'compat_load') { Oj.compat_load($json) }
end
perf.run($iter)
puts
puts '-' * 80
puts
unless $failed.empty?
puts "The following packages were not included for the reason listed"
$failed.each { |tag,msg| puts "***** #{tag}: #{msg}" }
end
oj-2.17.4/test/sample.rb 0000644 0000041 0000041 00000002441 12766161567 015054 0 ustar www-data www-data #!/usr/bin/env ruby -wW2
if $0 == __FILE__
$: << '.'
$: << '..'
$: << '../lib'
$: << '../ext'
end
require 'pp'
require 'sample/doc'
def sample_doc(size=3)
colors = [ :black, :gray, :white, :red, :blue, :yellow, :green, :purple, :orange ]
d = ::Sample::Doc.new('Sample')
# add some history
(0..size * 10).each do |i|
d.add_change("Changed at t+#{i}.")
end
# add some layers
(1..size).each do |i|
layer = ::Sample::Layer.new("Layer-#{i}")
(1..size).each do |j|
g = ::Sample::Group.new
(1..size).each do |k|
g2 = ::Sample::Group.new
r = ::Sample::Rect.new(j * 40 + 10.0, i * 10.0,
10.123456 / k, 10.0 / k, colors[(i + j + k) % colors.size])
r.add_prop(:part_of, layer.name)
g2 << r
g2 << ::Sample::Text.new("#{k} in #{j}", r.left, r.top, r.width, r.height)
g << g2
end
g2 = ::Sample::Group.new
(1..size).each do |k|
o = ::Sample::Oval.new(j * 40 + 12.0, i * 10.0 + 2.0,
6.0 / k, 6.0 / k, colors[(i + j + k) % colors.size])
o.add_prop(:inside, true)
g << o
end
g << g2
layer << g
end
d.layers[layer.name] = layer
end
# some properties
d.add_prop(:purpose, 'an example')
d
end
oj-2.17.4/test/bug.rb 0000755 0000041 0000041 00000002704 12766161567 014355 0 ustar www-data www-data #!/usr/bin/env ruby
# encoding: UTF-8
$: << File.dirname(__FILE__)
require 'helper'
require 'oj'
require 'securerandom'
class Handler
def hash_start() {} end
def hash_set(h,k,v) h.store(k,v) end
def array_start() [] end
def array_append(a,v) a << v end
def error(message, line, column)
raise Exception.new(message, line, column)
end
end
json = Oj.dump({"this"=>"object"})
if true
name = "/tmp/#{SecureRandom.uuid}"
`mkfifo #{name}`
if fork
open(name, 'r+') do |read_io|
p "start reading #{read_io.stat.ftype}"
Oj.sc_parse(Handler.new, read_io) {|v| p v}
p "stop reading"
end
else
open(name, 'w+') do |write_io|
p "start writing #{write_io.stat.ftype} autoclose: #{write_io.autoclose?}"
write_io.write json
write_io.write json
p "stop writing"
end
sleep(1) # make it obvious that there are two threads
open(name, 'w+') do |write_io|
p "start writing #{write_io.stat.ftype}"
write_io.write json
write_io.write json
p "stop writing"
end
end
else
IO.pipe do |read_io, write_io|
if fork
write_io.close
p "start reading #{read_io.stat.ftype}"
Oj.sc_parse(Handler.new, read_io) {|v| p v}
p "stop reading"
read_io.close
else
read_io.close
p "start writing #{write_io.stat.ftype}"
write_io.write json
write_io.write json
p "stop writing"
write_io.close
end
end
end
oj-2.17.4/LICENSE 0000644 0000041 0000041 00000002066 12766161567 013277 0 ustar www-data www-data The MIT License (MIT)
Copyright (c) 2012 Peter Ohler
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
oj-2.17.4/oj.gemspec 0000644 0000041 0000041 00000011752 12766161570 014243 0 ustar www-data www-data #########################################################
# This file has been automatically generated by gem2tgz #
#########################################################
# -*- encoding: utf-8 -*-
Gem::Specification.new do |s|
s.name = "oj"
s.version = "2.17.4"
s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
s.authors = ["Peter Ohler"]
s.date = "2016-09-04"
s.description = "The fastest JSON parser and object serializer. "
s.email = "peter@ohler.com"
s.extensions = ["ext/oj/extconf.rb"]
s.extra_rdoc_files = ["README.md"]
s.files = ["LICENSE", "README.md", "ext/oj/buf.h", "ext/oj/cache8.c", "ext/oj/cache8.h", "ext/oj/circarray.c", "ext/oj/circarray.h", "ext/oj/compat.c", "ext/oj/dump.c", "ext/oj/encode.h", "ext/oj/err.c", "ext/oj/err.h", "ext/oj/extconf.rb", "ext/oj/fast.c", "ext/oj/hash.c", "ext/oj/hash.h", "ext/oj/hash_test.c", "ext/oj/object.c", "ext/oj/odd.c", "ext/oj/odd.h", "ext/oj/oj.c", "ext/oj/oj.h", "ext/oj/parse.c", "ext/oj/parse.h", "ext/oj/reader.c", "ext/oj/reader.h", "ext/oj/resolve.c", "ext/oj/resolve.h", "ext/oj/saj.c", "ext/oj/scp.c", "ext/oj/sparse.c", "ext/oj/strict.c", "ext/oj/val_stack.c", "ext/oj/val_stack.h", "lib/oj.rb", "lib/oj/active_support_helper.rb", "lib/oj/bag.rb", "lib/oj/easy_hash.rb", "lib/oj/error.rb", "lib/oj/mimic.rb", "lib/oj/saj.rb", "lib/oj/schandler.rb", "lib/oj/version.rb", "test/_test_active.rb", "test/_test_active_mimic.rb", "test/_test_mimic_rails.rb", "test/aaa.rb", "test/activesupport_datetime_test.rb", "test/bug.rb", "test/files.rb", "test/helper.rb", "test/isolated/shared.rb", "test/isolated/test_mimic_after.rb", "test/isolated/test_mimic_alone.rb", "test/isolated/test_mimic_as_json.rb", "test/isolated/test_mimic_before.rb", "test/isolated/test_mimic_define.rb", "test/isolated/test_mimic_rails_after.rb", "test/isolated/test_mimic_rails_before.rb", "test/pact.rb", "test/perf.rb", "test/perf1.rb", "test/perf2.rb", "test/perf_compat.rb", "test/perf_fast.rb", "test/perf_file.rb", "test/perf_obj_old.rb", "test/perf_object.rb", "test/perf_saj.rb", "test/perf_scp.rb", "test/perf_simple.rb", "test/perf_strict.rb", "test/sample.rb", "test/sample/change.rb", "test/sample/dir.rb", "test/sample/doc.rb", "test/sample/file.rb", "test/sample/group.rb", "test/sample/hasprops.rb", "test/sample/layer.rb", "test/sample/line.rb", "test/sample/oval.rb", "test/sample/rect.rb", "test/sample/shape.rb", "test/sample/text.rb", "test/sample_json.rb", "test/test_bigd.rb", "test/test_compat.rb", "test/test_debian.rb", "test/test_fast.rb", "test/test_file.rb", "test/test_gc.rb", "test/test_hash.rb", "test/test_object.rb", "test/test_range.rb", "test/test_saj.rb", "test/test_scp.rb", "test/test_strict.rb", "test/test_various.rb", "test/test_writer.rb"]
s.homepage = "http://www.ohler.com/oj"
s.licenses = ["MIT"]
s.rdoc_options = ["--main", "README.md"]
s.require_paths = ["lib"]
s.rubyforge_project = "oj"
s.rubygems_version = "1.8.23"
s.summary = "A fast JSON parser and serializer."
s.test_files = ["test/_test_active.rb", "test/_test_active_mimic.rb", "test/_test_mimic_rails.rb", "test/aaa.rb", "test/activesupport_datetime_test.rb", "test/bug.rb", "test/files.rb", "test/helper.rb", "test/isolated/shared.rb", "test/isolated/test_mimic_after.rb", "test/isolated/test_mimic_alone.rb", "test/isolated/test_mimic_as_json.rb", "test/isolated/test_mimic_before.rb", "test/isolated/test_mimic_define.rb", "test/isolated/test_mimic_rails_after.rb", "test/isolated/test_mimic_rails_before.rb", "test/pact.rb", "test/perf.rb", "test/perf1.rb", "test/perf2.rb", "test/perf_compat.rb", "test/perf_fast.rb", "test/perf_file.rb", "test/perf_obj_old.rb", "test/perf_object.rb", "test/perf_saj.rb", "test/perf_scp.rb", "test/perf_simple.rb", "test/perf_strict.rb", "test/sample.rb", "test/sample/change.rb", "test/sample/dir.rb", "test/sample/doc.rb", "test/sample/file.rb", "test/sample/group.rb", "test/sample/hasprops.rb", "test/sample/layer.rb", "test/sample/line.rb", "test/sample/oval.rb", "test/sample/rect.rb", "test/sample/shape.rb", "test/sample/text.rb", "test/sample_json.rb", "test/test_bigd.rb", "test/test_compat.rb", "test/test_debian.rb", "test/test_fast.rb", "test/test_file.rb", "test/test_gc.rb", "test/test_hash.rb", "test/test_object.rb", "test/test_range.rb", "test/test_saj.rb", "test/test_scp.rb", "test/test_strict.rb", "test/test_various.rb", "test/test_writer.rb"]
if s.respond_to? :specification_version then
s.specification_version = 3
if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
s.add_development_dependency(%q, ["~> 5"])
s.add_development_dependency(%q, ["~> 4"])
s.add_development_dependency(%q, ["~> 0.9"])
else
s.add_dependency(%q, ["~> 5"])
s.add_dependency(%q, ["~> 4"])
s.add_dependency(%q, ["~> 0.9"])
end
else
s.add_dependency(%q, ["~> 5"])
s.add_dependency(%q, ["~> 4"])
s.add_dependency(%q, ["~> 0.9"])
end
end
oj-2.17.4/ext/ 0000755 0000041 0000041 00000000000 12766161567 013066 5 ustar www-data www-data oj-2.17.4/ext/oj/ 0000755 0000041 0000041 00000000000 12766161567 013476 5 ustar www-data www-data oj-2.17.4/ext/oj/resolve.c 0000644 0000041 0000041 00000007541 12766161567 015330 0 ustar www-data www-data /* resolve.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#if USE_PTHREAD_MUTEX
#include
#endif
#include "oj.h"
#include "err.h"
#include "parse.h"
#include "hash.h"
inline static VALUE
resolve_classname(VALUE mod, const char *classname, int auto_define) {
VALUE clas;
ID ci = rb_intern(classname);
if (rb_const_defined_at(mod, ci)) {
clas = rb_const_get_at(mod, ci);
} else if (auto_define) {
clas = rb_define_class_under(mod, classname, oj_bag_class);
} else {
clas = Qundef;
}
return clas;
}
static VALUE
resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define) {
char class_name[1024];
VALUE clas;
char *end = class_name + sizeof(class_name) - 1;
char *s;
const char *n = name;
clas = rb_cObject;
for (s = class_name; 0 < len; n++, len--) {
if (':' == *n) {
*s = '\0';
n++;
len--;
if (':' != *n) {
return Qundef;
}
if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
return Qundef;
}
s = class_name;
} else if (end <= s) {
return Qundef;
} else {
*s++ = *n;
}
}
*s = '\0';
if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
if (sizeof(class_name) - 1 < len) {
len = sizeof(class_name) - 1;
}
memcpy(class_name, name, len);
class_name[len] = '\0';
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "class %s is not defined", class_name);
}
return clas;
}
VALUE
oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define) {
VALUE clas;
VALUE *slot;
if (No == pi->options.class_cache) {
return resolve_classpath(pi, name, len, auto_define);
}
#if USE_PTHREAD_MUTEX
pthread_mutex_lock(&oj_cache_mutex);
#elif USE_RB_MUTEX
rb_mutex_lock(oj_cache_mutex);
#endif
if (Qnil == (clas = oj_class_hash_get(name, len, &slot))) {
if (Qundef != (clas = resolve_classpath(pi, name, len, auto_define))) {
*slot = clas;
}
}
#if USE_PTHREAD_MUTEX
pthread_mutex_unlock(&oj_cache_mutex);
#elif USE_RB_MUTEX
rb_mutex_unlock(oj_cache_mutex);
#endif
return clas;
}
VALUE
oj_name2struct(ParseInfo pi, VALUE nameVal) {
size_t len = RSTRING_LEN(nameVal);
const char *str = StringValuePtr(nameVal);
return resolve_classpath(pi, str, len, 0);
}
oj-2.17.4/ext/oj/object.c 0000644 0000041 0000041 00000053366 12766161567 015125 0 ustar www-data www-data /* object.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include "oj.h"
#include "err.h"
#include "parse.h"
#include "resolve.h"
#include "hash.h"
#include "odd.h"
#include "encode.h"
inline static long
read_long(const char *str, size_t len) {
long n = 0;
for (; 0 < len; str++, len--) {
if ('0' <= *str && *str <= '9') {
n = n * 10 + (*str - '0');
} else {
return -1;
}
}
return n;
}
static VALUE
calc_hash_key(ParseInfo pi, Val kval, char k1) {
volatile VALUE rkey;
if (':' == k1) {
rkey = rb_str_new(kval->key + 1, kval->klen - 1);
rkey = oj_encode(rkey);
rkey = rb_funcall(rkey, oj_to_sym_id, 0);
} else {
rkey = rb_str_new(kval->key, kval->klen);
rkey = oj_encode(rkey);
if (Yes == pi->options.sym_key) {
rkey = rb_str_intern(rkey);
}
}
return rkey;
}
static VALUE
str_to_value(ParseInfo pi, const char *str, size_t len, const char *orig) {
volatile VALUE rstr = Qnil;
if (':' == *orig && 0 < len) {
rstr = rb_str_new(str + 1, len - 1);
rstr = oj_encode(rstr);
rstr = rb_funcall(rstr, oj_to_sym_id, 0);
} else if (pi->circ_array && 3 <= len && '^' == *orig && 'r' == orig[1]) {
long i = read_long(str + 2, len - 2);
if (0 > i) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a valid ID number");
return Qnil;
}
rstr = oj_circ_array_get(pi->circ_array, i);
} else {
rstr = rb_str_new(str, len);
rstr = oj_encode(rstr);
}
return rstr;
}
#if (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
static VALUE
parse_xml_time(const char *str, int len) {
return rb_funcall(rb_cTime, oj_parse_id, 1, rb_str_new(str, len));
}
#else
// The much faster approach (4x faster)
static int
parse_num(const char *str, const char *end, int cnt) {
int n = 0;
char c;
int i;
for (i = cnt; 0 < i; i--, str++) {
c = *str;
if (end <= str || c < '0' || '9' < c) {
return -1;
}
n = n * 10 + (c - '0');
}
return n;
}
static VALUE
parse_xml_time(const char *str, int len) {
VALUE args[8];
const char *end = str + len;
int n;
// year
if (0 > (n = parse_num(str, end, 4))) {
return Qnil;
}
str += 4;
args[0] = LONG2NUM(n);
if ('-' != *str++) {
return Qnil;
}
// month
if (0 > (n = parse_num(str, end, 2))) {
return Qnil;
}
str += 2;
args[1] = LONG2NUM(n);
if ('-' != *str++) {
return Qnil;
}
// day
if (0 > (n = parse_num(str, end, 2))) {
return Qnil;
}
str += 2;
args[2] = LONG2NUM(n);
if ('T' != *str++) {
return Qnil;
}
// hour
if (0 > (n = parse_num(str, end, 2))) {
return Qnil;
}
str += 2;
args[3] = LONG2NUM(n);
if (':' != *str++) {
return Qnil;
}
// minute
if (0 > (n = parse_num(str, end, 2))) {
return Qnil;
}
str += 2;
args[4] = LONG2NUM(n);
if (':' != *str++) {
return Qnil;
}
// second
if (0 > (n = parse_num(str, end, 2))) {
return Qnil;
}
str += 2;
if (str == end) {
args[5] = LONG2NUM(n);
args[6] = LONG2NUM(0);
} else {
char c = *str++;
if ('.' == c) {
long long nsec = 0;
for (; str < end; str++) {
c = *str;
if (c < '0' || '9' < c) {
str++;
break;
}
nsec = nsec * 10 + (c - '0');
}
args[5] = rb_float_new((double)n + ((double)nsec + 0.5) / 1000000000.0);
} else {
args[5] = rb_ll2inum(n);
}
if (end < str) {
args[6] = LONG2NUM(0);
} else {
if ('Z' == c) {
return rb_funcall2(rb_cTime, oj_utc_id, 6, args);
} else if ('+' == c) {
int hr = parse_num(str, end, 2);
int min;
str += 2;
if (0 > hr || ':' != *str++) {
return Qnil;
}
min = parse_num(str, end, 2);
if (0 > min) {
return Qnil;
}
args[6] = LONG2NUM(hr * 3600 + min * 60);
} else if ('-' == c) {
int hr = parse_num(str, end, 2);
int min;
str += 2;
if (0 > hr || ':' != *str++) {
return Qnil;
}
min = parse_num(str, end, 2);
if (0 > min) {
return Qnil;
}
args[6] = LONG2NUM(-(hr * 3600 + min * 60));
} else {
args[6] = LONG2NUM(0);
}
}
}
return rb_funcall2(rb_cTime, oj_new_id, 7, args);
}
#endif
static int
hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t len) {
const char *key = kval->key;
int klen = kval->klen;
if (2 == klen) {
switch (key[1]) {
case 'o': // object
{ // name2class sets and error if the class is not found or created
VALUE clas = oj_name2class(pi, str, len, Yes == pi->options.auto_define);
if (Qundef != clas) {
parent->val = rb_obj_alloc(clas);
}
}
break;
case 'O': // odd object
{
Odd odd = oj_get_oddc(str, len);
if (0 == odd) {
return 0;
}
parent->val = odd->clas;
parent->odd_args = oj_odd_alloc_args(odd);
}
break;
case 'm':
parent->val = rb_str_new(str + 1, len - 1);
parent->val = oj_encode(parent->val);
parent->val = rb_funcall(parent->val, oj_to_sym_id, 0);
break;
case 's':
parent->val = rb_str_new(str, len);
parent->val = oj_encode(parent->val);
break;
case 'c': // class
{
VALUE clas = oj_name2class(pi, str, len, Yes == pi->options.auto_define);
if (Qundef == clas) {
return 0;
} else {
parent->val = clas;
}
}
break;
case 't': // time
parent->val = parse_xml_time(str, len);
break;
default:
return 0;
break;
}
return 1; // handled
}
return 0;
}
static int
hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
if (2 == kval->klen) {
switch (kval->key[1]) {
case 't': // time as a float
{
int64_t nsec = ni->num * 1000000000LL / ni->div;
if (ni->neg) {
ni->i = -ni->i;
if (0 < nsec) {
ni->i--;
nsec = 1000000000LL - nsec;
}
}
if (86400 == ni->exp) { // UTC time
#if HAS_NANO_TIME
parent->val = rb_time_nano_new(ni->i, (long)nsec);
#else
parent->val = rb_time_new(ni->i, (long)(nsec / 1000));
#endif
// Since the ruby C routines alway create local time, the
// offset and then a convertion to UTC keeps makes the time
// match the expected value.
parent->val = rb_funcall2(parent->val, oj_utc_id, 0, 0);
} else if (ni->hasExp) {
time_t t = (time_t)(ni->i + ni->exp);
struct tm *st = gmtime(&t);
#if RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8
// The only methods that allow the UTC offset to be set in
// 1.8.7 is the parse() and xmlschema() methods. The
// xmlschema() method always returns a Time instance that is
// UTC time. (true on some platforms anyway) Time.parse()
// fails on other Ruby versions until 2.2.0.
char buf[64];
int z = (0 > ni->exp ? -ni->exp : ni->exp) / 60;
int tzhour = z / 60;
int tzmin = z - tzhour * 60;
int cnt;
cnt = sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02d.%09ld%c%02d:%02d",
1900 + st->tm_year, 1 + st->tm_mon, st->tm_mday,
st->tm_hour, st->tm_min, st->tm_sec, (long)nsec,
(0 > ni->exp ? '-' : '+'), tzhour, tzmin);
parent->val = rb_funcall(rb_cTime, oj_parse_id, 1, rb_str_new(buf, cnt));
#else
VALUE args[8];
args[0] = LONG2NUM(1900 + st->tm_year);
args[1] = LONG2NUM(1 + st->tm_mon);
args[2] = LONG2NUM(st->tm_mday);
args[3] = LONG2NUM(st->tm_hour);
args[4] = LONG2NUM(st->tm_min);
#if NO_TIME_ROUND_PAD
args[5] = rb_float_new((double)st->tm_sec + ((double)nsec) / 1000000000.0);
#else
args[5] = rb_float_new((double)st->tm_sec + ((double)nsec + 0.5) / 1000000000.0);
#endif
args[6] = LONG2NUM(ni->exp);
parent->val = rb_funcall2(rb_cTime, oj_new_id, 7, args);
#endif
} else {
#if HAS_NANO_TIME
parent->val = rb_time_nano_new(ni->i, (long)nsec);
#else
parent->val = rb_time_new(ni->i, (long)(nsec / 1000));
#endif
}
}
break;
case 'i': // circular index
if (!ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp && 0 != pi->circ_array) { // fixnum
if (Qnil == parent->val) {
parent->val = rb_hash_new();
}
oj_circ_array_set(pi->circ_array, parent->val, ni->i);
} else {
return 0;
}
break;
default:
return 0;
break;
}
return 1; // handled
}
return 0;
}
static int
hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, volatile VALUE value) {
if (T_ARRAY == rb_type(value)) {
int len = (int)RARRAY_LEN(value);
if (2 == klen && 'u' == key[1]) {
volatile VALUE sc;
volatile VALUE e1;
if (0 == len) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
return 1;
}
e1 = *RARRAY_PTR(value);
// check for anonymous Struct
if (T_ARRAY == rb_type(e1)) {
VALUE args[1024];
volatile VALUE rstr;
int i, cnt = (int)RARRAY_LEN(e1);
for (i = 0; i < cnt; i++) {
rstr = rb_ary_entry(e1, i);
args[i] = rb_funcall(rstr, oj_to_sym_id, 0);
}
sc = rb_funcall2(rb_cStruct, oj_new_id, cnt, args);
} else {
// If struct is not defined then we let this fail and raise an exception.
sc = oj_name2struct(pi, *RARRAY_PTR(value));
}
// Create a properly initialized struct instance without calling the initialize method.
parent->val = rb_obj_alloc(sc);
// If the JSON array has more entries than the struct class allows, we record an error.
#ifdef RSTRUCT_LEN
// MRI >= 1.9
if (len - 1 > RSTRUCT_LEN(parent->val)) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
} else {
MEMCPY(RSTRUCT_PTR(parent->val), RARRAY_PTR(value) + 1, VALUE, len - 1);
}
#else
{
// MRI < 1.9 or Rubinius
int slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
int i;
if (len - 1 > slen) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
} else {
for (i = 0; i < slen; i++) {
rb_struct_aset(parent->val, INT2FIX(i), RARRAY_PTR(value)[i + 1]);
}
}
}
#endif
return 1;
} else if (3 <= klen && '#' == key[1]) {
volatile VALUE *a;
if (2 != len) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
return 1;
}
parent->val = rb_hash_new();
a = RARRAY_PTR(value);
rb_hash_aset(parent->val, *a, a[1]);
return 1;
}
}
return 0;
}
static void
copy_ivars(VALUE target, VALUE src) {
volatile VALUE vars = rb_funcall(src, oj_instance_variables_id, 0);
volatile VALUE *np = RARRAY_PTR(vars);
ID vid;
int i, cnt = (int)RARRAY_LEN(vars);
const char *attr;
for (i = cnt; 0 < i; i--, np++) {
vid = rb_to_id(*np);
attr = rb_id2name(vid);
if ('@' == *attr) {
rb_ivar_set(target, vid, rb_ivar_get(src, vid));
}
}
}
static void
set_obj_ivar(Val parent, Val kval, VALUE value) {
const char *key = kval->key;
int klen = kval->klen;
ID var_id;
ID *slot;
if ('~' == *key && Qtrue == rb_obj_is_kind_of(parent->val, rb_eException)) {
if (5 == klen && 0 == strncmp("~mesg", key, klen)) {
VALUE args[1];
volatile VALUE prev = parent->val;
args[0] = value;
parent->val = rb_class_new_instance(1, args, rb_class_of(parent->val));
copy_ivars(parent->val, prev);
} else if (3 == klen && 0 == strncmp("~bt", key, klen)) {
rb_funcall(parent->val, rb_intern("set_backtrace"), 1, value);
}
}
#if USE_PTHREAD_MUTEX
pthread_mutex_lock(&oj_cache_mutex);
#elif USE_RB_MUTEX
rb_mutex_lock(oj_cache_mutex);
#endif
if (0 == (var_id = oj_attr_hash_get(key, klen, &slot))) {
char attr[256];
if ((int)sizeof(attr) <= klen + 2) {
char *buf = ALLOC_N(char, klen + 2);
if ('~' == *key) {
strncpy(buf, key + 1, klen - 1);
buf[klen - 1] = '\0';
} else {
*buf = '@';
strncpy(buf + 1, key, klen);
buf[klen + 1] = '\0';
}
var_id = rb_intern(buf);
xfree(buf);
} else {
if ('~' == *key) {
strncpy(attr, key + 1, klen - 1);
attr[klen - 1] = '\0';
} else {
*attr = '@';
strncpy(attr + 1, key, klen);
attr[klen + 1] = '\0';
}
var_id = rb_intern(attr);
}
*slot = var_id;
}
#if USE_PTHREAD_MUTEX
pthread_mutex_unlock(&oj_cache_mutex);
#elif USE_RB_MUTEX
rb_mutex_unlock(oj_cache_mutex);
#endif
rb_ivar_set(parent->val, var_id, value);
}
static void
hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
const char *key = kval->key;
int klen = kval->klen;
Val parent = stack_peek(&pi->stack);
WHICH_TYPE:
switch (rb_type(parent->val)) {
case T_NIL:
parent->odd_args = 0; // make sure it is 0 in case not odd
if ('^' != *key || !hat_cstr(pi, parent, kval, str, len)) {
parent->val = rb_hash_new();
goto WHICH_TYPE;
}
break;
case T_HASH:
rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), str_to_value(pi, str, len, orig));
break;
case T_STRING:
if (4 == klen && 's' == *key && 'e' == key[1] && 'l' == key[2] && 'f' == key[3]) {
rb_funcall(parent->val, oj_replace_id, 1, str_to_value(pi, str, len, orig));
} else {
set_obj_ivar(parent, kval, str_to_value(pi, str, len, orig));
}
break;
case T_OBJECT:
set_obj_ivar(parent, kval, str_to_value(pi, str, len, orig));
break;
case T_CLASS:
if (0 == parent->odd_args) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "%s is not an odd class", rb_class2name(rb_obj_class(parent->val)));
return;
} else if (0 != oj_odd_set_arg(parent->odd_args, kval->key, kval->klen, str_to_value(pi, str, len, orig))) {
char buf[256];
if ((int)sizeof(buf) - 1 <= klen) {
klen = sizeof(buf) - 2;
}
memcpy(buf, key, klen);
buf[klen] = '\0';
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "%s is not an attribute of %s", buf, rb_class2name(rb_obj_class(parent->val)));
}
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "can not add attributes to a %s", rb_class2name(rb_obj_class(parent->val)));
return;
}
}
static void
hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
const char *key = kval->key;
int klen = kval->klen;
Val parent = stack_peek(&pi->stack);
WHICH_TYPE:
switch (rb_type(parent->val)) {
case T_NIL:
parent->odd_args = 0; // make sure it is 0 in case not odd
if ('^' != *key || !hat_num(pi, parent, kval, ni)) {
parent->val = rb_hash_new();
goto WHICH_TYPE;
}
break;
case T_HASH:
rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), oj_num_as_value(ni));
break;
case T_OBJECT:
if (2 == klen && '^' == *key && 'i' == key[1] &&
!ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp && 0 != pi->circ_array) { // fixnum
oj_circ_array_set(pi->circ_array, parent->val, ni->i);
} else {
set_obj_ivar(parent, kval, oj_num_as_value(ni));
}
break;
case T_CLASS:
if (0 == parent->odd_args) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "%s is not an odd class", rb_class2name(rb_obj_class(parent->val)));
return;
} else if (0 != oj_odd_set_arg(parent->odd_args, key, klen, oj_num_as_value(ni))) {
char buf[256];
if ((int)sizeof(buf) - 1 <= klen) {
klen = sizeof(buf) - 2;
}
memcpy(buf, key, klen);
buf[klen] = '\0';
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "%s is not an attribute of %s", buf, rb_class2name(rb_obj_class(parent->val)));
}
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "can not add attributes to a %s", rb_class2name(rb_obj_class(parent->val)));
return;
}
}
static void
hash_set_value(ParseInfo pi, Val kval, VALUE value) {
const char *key = kval->key;
int klen = kval->klen;
Val parent = stack_peek(&pi->stack);
WHICH_TYPE:
switch (rb_type(parent->val)) {
case T_NIL:
parent->odd_args = 0; // make sure it is 0 in case not odd
if ('^' != *key || !hat_value(pi, parent, key, klen, value)) {
parent->val = rb_hash_new();
goto WHICH_TYPE;
}
break;
case T_HASH:
if (rb_cHash != rb_obj_class(parent->val)) {
if (4 == klen && 's' == *key && 'e' == key[1] && 'l' == key[2] && 'f' == key[3]) {
rb_funcall(parent->val, oj_replace_id, 1, value);
} else {
set_obj_ivar(parent, kval, value);
}
} else {
if (3 <= klen && '^' == *key && '#' == key[1] && T_ARRAY == rb_type(value)) {
long len = RARRAY_LEN(value);
volatile VALUE *a = RARRAY_PTR(value);
if (2 != len) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
return;
}
rb_hash_aset(parent->val, *a, a[1]);
} else {
rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), value);
}
}
break;
case T_ARRAY:
if (4 == klen && 's' == *key && 'e' == key[1] && 'l' == key[2] && 'f' == key[3]) {
rb_funcall(parent->val, oj_replace_id, 1, value);
} else {
set_obj_ivar(parent, kval, value);
}
break;
case T_STRING: // for subclassed strings
case T_OBJECT:
set_obj_ivar(parent, kval, value);
break;
case T_MODULE:
case T_CLASS:
if (0 == parent->odd_args) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "%s is not an odd class", rb_class2name(rb_obj_class(parent->val)));
return;
} else if (0 != oj_odd_set_arg(parent->odd_args, key, klen, value)) {
char buf[256];
if ((int)sizeof(buf) - 1 <= klen) {
klen = sizeof(buf) - 2;
}
memcpy(buf, key, klen);
buf[klen] = '\0';
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "%s is not an attribute of %s", buf, rb_class2name(rb_obj_class(parent->val)));
}
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "can not add attributes to a %s", rb_class2name(rb_obj_class(parent->val)));
return;
}
}
static VALUE
start_hash(ParseInfo pi) {
return Qnil;
}
static void
end_hash(struct _ParseInfo *pi) {
Val parent = stack_peek(&pi->stack);
if (Qnil == parent->val) {
parent->val = rb_hash_new();
} else if (0 != parent->odd_args) {
OddArgs oa = parent->odd_args;
parent->val = rb_funcall2(oa->odd->create_obj, oa->odd->create_op, oa->odd->attr_cnt, oa->args);
oj_odd_free(oa);
parent->odd_args = 0;
}
}
static void
array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
if (3 <= len && 0 != pi->circ_array) {
if ('i' == str[1]) {
long i = read_long(str + 2, len - 2);
if (0 < i) {
oj_circ_array_set(pi->circ_array, stack_peek(&pi->stack)->val, i);
return;
}
} else if ('r' == str[1]) {
long i = read_long(str + 2, len - 2);
if (0 < i) {
rb_ary_push(stack_peek(&pi->stack)->val, oj_circ_array_get(pi->circ_array, i));
return;
}
}
}
rb_ary_push(stack_peek(&pi->stack)->val, str_to_value(pi, str, len, orig));
}
static void
array_append_num(ParseInfo pi, NumInfo ni) {
rb_ary_push(stack_peek(&pi->stack)->val, oj_num_as_value(ni));
}
static void
add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
pi->stack.head->val = str_to_value(pi, str, len, orig);
}
static void
add_num(ParseInfo pi, NumInfo ni) {
pi->stack.head->val = oj_num_as_value(ni);
}
void
oj_set_object_callbacks(ParseInfo pi) {
oj_set_strict_callbacks(pi);
pi->end_hash = end_hash;
pi->start_hash = start_hash;
pi->hash_set_cstr = hash_set_cstr;
pi->hash_set_num = hash_set_num;
pi->hash_set_value = hash_set_value;
pi->add_cstr = add_cstr;
pi->add_num = add_num;
pi->array_append_cstr = array_append_cstr;
pi->array_append_num = array_append_num;
}
VALUE
oj_object_parse(int argc, VALUE *argv, VALUE self) {
struct _ParseInfo pi;
pi.options = oj_default_options;
pi.handler = Qnil;
pi.err_class = Qnil;
oj_set_object_callbacks(&pi);
if (T_STRING == rb_type(*argv)) {
return oj_pi_parse(argc, argv, &pi, 0, 0, 1);
} else {
return oj_pi_sparse(argc, argv, &pi, 0);
}
}
VALUE
oj_object_parse_cstr(int argc, VALUE *argv, char *json, size_t len) {
struct _ParseInfo pi;
pi.options = oj_default_options;
pi.handler = Qnil;
pi.err_class = Qnil;
oj_set_strict_callbacks(&pi);
pi.end_hash = end_hash;
pi.start_hash = start_hash;
pi.hash_set_cstr = hash_set_cstr;
pi.hash_set_num = hash_set_num;
pi.hash_set_value = hash_set_value;
pi.add_cstr = add_cstr;
pi.add_num = add_num;
pi.array_append_cstr = array_append_cstr;
pi.array_append_num = array_append_num;
return oj_pi_parse(argc, argv, &pi, json, len, 1);
}
oj-2.17.4/ext/oj/buf.h 0000644 0000041 0000041 00000006117 12766161567 014430 0 ustar www-data www-data /* buf.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_BUF_H__
#define __OJ_BUF_H__
#include "ruby.h"
typedef struct _Buf {
char *head;
char *end;
char *tail;
char base[1024];
} *Buf;
inline static void
buf_init(Buf buf) {
buf->head = buf->base;
buf->end = buf->base + sizeof(buf->base) - 1;
buf->tail = buf->head;
}
inline static void
buf_cleanup(Buf buf) {
if (buf->base != buf->head) {
xfree(buf->head);
}
}
inline static size_t
buf_len(Buf buf) {
return buf->tail - buf->head;
}
inline static void
buf_append_string(Buf buf, const char *s, size_t slen) {
if (buf->end <= buf->tail + slen) {
size_t len = buf->end - buf->head;
size_t toff = buf->tail - buf->head;
size_t new_len = len + slen + len / 2;
if (buf->base == buf->head) {
buf->head = ALLOC_N(char, new_len);
memcpy(buf->head, buf->base, len);
} else {
REALLOC_N(buf->head, char, new_len);
}
buf->tail = buf->head + toff;
buf->end = buf->head + new_len - 1;
}
memcpy(buf->tail, s, slen);
buf->tail += slen;
}
inline static void
buf_append(Buf buf, char c) {
if (buf->end <= buf->tail) {
size_t len = buf->end - buf->head;
size_t toff = buf->tail - buf->head;
size_t new_len = len + len / 2;
if (buf->base == buf->head) {
buf->head = ALLOC_N(char, new_len);
memcpy(buf->head, buf->base, len);
} else {
REALLOC_N(buf->head, char, new_len);
}
buf->tail = buf->head + toff;
buf->end = buf->head + new_len - 1;
}
*buf->tail = c;
buf->tail++;
//*buf->tail = '\0'; // for debugging
}
#endif /* __OJ_BUF_H__ */
oj-2.17.4/ext/oj/extconf.rb 0000644 0000041 0000041 00000005431 12766161567 015474 0 ustar www-data www-data require 'mkmf'
require 'rbconfig'
extension_name = 'oj'
dir_config(extension_name)
parts = RUBY_DESCRIPTION.split(' ')
type = parts[0]
type = type[4..-1] if type.start_with?('tcs-')
type = 'ree' if 'ruby' == type && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
is_windows = RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
platform = RUBY_PLATFORM
version = RUBY_VERSION.split('.')
puts ">>>>> Creating Makefile for #{type} version #{RUBY_VERSION} on #{platform} <<<<<"
dflags = {
'RUBY_TYPE' => type,
(type.upcase + '_RUBY') => nil,
'RUBY_VERSION' => RUBY_VERSION,
'RUBY_VERSION_MAJOR' => version[0],
'RUBY_VERSION_MINOR' => version[1],
'RUBY_VERSION_MICRO' => version[2],
'HAS_RB_TIME_TIMESPEC' => (!is_windows && 'ruby' == type && ('1.9.3' == RUBY_VERSION || '2' <= version[0])) ? 1 : 0,
'HAS_ENCODING_SUPPORT' => (('ruby' == type || 'rubinius' == type) &&
(('1' == version[0] && '9' == version[1]) || '2' <= version[0])) ? 1 : 0,
'HAS_NANO_TIME' => ('ruby' == type && ('1' == version[0] && '9' == version[1]) || '2' <= version[0]) ? 1 : 0,
'HAS_IVAR_HELPERS' => ('ruby' == type && !is_windows && (('1' == version[0] && '9' == version[1]) || '2' <= version[0])) ? 1 : 0,
'HAS_EXCEPTION_MAGIC' => ('ruby' == type && ('1' == version[0] && '9' == version[1])) ? 0 : 1,
'HAS_PROC_WITH_BLOCK' => ('ruby' == type && (('1' == version[0] && '9' == version[1]) || '2' <= version[0])) ? 1 : 0,
'HAS_TOP_LEVEL_ST_H' => ('ree' == type || ('ruby' == type && '1' == version[0] && '8' == version[1])) ? 1 : 0,
'NEEDS_RATIONAL' => ('1' == version[0] && '8' == version[1]) ? 1 : 0,
'IS_WINDOWS' => is_windows ? 1 : 0,
'USE_PTHREAD_MUTEX' => is_windows ? 0 : 1,
'USE_RB_MUTEX' => (is_windows && !('1' == version[0] && '8' == version[1])) ? 1 : 0,
'DATETIME_1_8' => ('ruby' == type && ('1' == version[0] && '8' == version[1])) ? 1 : 0,
'NO_TIME_ROUND_PAD' => ('rubinius' == type) ? 1 : 0,
'HAS_DATA_OBJECT_WRAP' => ('ruby' == type && '2' == version[0] && '3' <= version[1]) ? 1 : 0,
}
# This is a monster hack to get around issues with 1.9.3-p0 on CentOS 5.4. SO
# some reason math.h and string.h contents are not processed. Might be a
# missing #define. This is the quick and easy way around it.
if 'x86_64-linux' == RUBY_PLATFORM && '1.9.3' == RUBY_VERSION && '2011-10-30' == RUBY_RELEASE_DATE
begin
dflags['NEEDS_STPCPY'] = nil if File.read('/etc/redhat-release').include?('CentOS release 5.4')
rescue Exception
end
else
dflags['NEEDS_STPCPY'] = nil if is_windows
end
dflags['OJ_DEBUG'] = true unless ENV['OJ_DEBUG'].nil?
dflags.each do |k,v|
if v.nil?
$CPPFLAGS += " -D#{k}"
else
$CPPFLAGS += " -D#{k}=#{v}"
end
end
$CPPFLAGS += ' -Wall'
#puts "*** $CPPFLAGS: #{$CPPFLAGS}"
create_makefile("#{extension_name}/#{extension_name}")
%x{make clean}
oj-2.17.4/ext/oj/resolve.h 0000644 0000041 0000041 00000003453 12766161567 015333 0 ustar www-data www-data /* resolve.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_RESOLVE_H__
#define __OJ_RESOLVE_H__
#include "ruby.h"
extern VALUE oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define);
extern VALUE oj_name2struct(ParseInfo pi, VALUE nameVal);
#endif /* __OJ_RESOLVE_H__ */
oj-2.17.4/ext/oj/circarray.c 0000644 0000041 0000041 00000005344 12766161567 015627 0 ustar www-data www-data /* circarray.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "circarray.h"
CircArray
oj_circ_array_new() {
CircArray ca;
if (0 == (ca = ALLOC(struct _CircArray))) {
rb_raise(rb_eNoMemError, "not enough memory\n");
}
ca->objs = ca->obj_array;
ca->size = sizeof(ca->obj_array) / sizeof(VALUE);
ca->cnt = 0;
return ca;
}
void
oj_circ_array_free(CircArray ca) {
if (ca->objs != ca->obj_array) {
xfree(ca->objs);
}
xfree(ca);
}
void
oj_circ_array_set(CircArray ca, VALUE obj, unsigned long id) {
if (0 < id && 0 != ca) {
unsigned long i;
if (ca->size < id) {
unsigned long cnt = id + 512;
if (ca->objs == ca->obj_array) {
if (0 == (ca->objs = ALLOC_N(VALUE, cnt))) {
rb_raise(rb_eNoMemError, "not enough memory\n");
}
memcpy(ca->objs, ca->obj_array, sizeof(VALUE) * ca->cnt);
} else {
REALLOC_N(ca->objs, VALUE, cnt);
}
ca->size = cnt;
}
id--;
for (i = ca->cnt; i < id; i++) {
ca->objs[i] = Qnil;
}
ca->objs[id] = obj;
if (ca->cnt <= id) {
ca->cnt = id + 1;
}
}
}
VALUE
oj_circ_array_get(CircArray ca, unsigned long id) {
VALUE obj = Qnil;
if (id <= ca->cnt && 0 != ca) {
obj = ca->objs[id - 1];
}
return obj;
}
oj-2.17.4/ext/oj/strict.c 0000644 0000041 0000041 00000012566 12766161567 015164 0 ustar www-data www-data /* strict.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include "oj.h"
#include "err.h"
#include "parse.h"
#include "encode.h"
static void
noop_end(struct _ParseInfo *pi) {
}
static VALUE
noop_hash_key(struct _ParseInfo *pi, const char *key, size_t klen) {
return Qundef;
}
static void
add_value(ParseInfo pi, VALUE val) {
pi->stack.head->val = val;
}
static void
add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
volatile VALUE rstr = rb_str_new(str, len);
rstr = oj_encode(rstr);
pi->stack.head->val = rstr;
}
static void
add_num(ParseInfo pi, NumInfo ni) {
if (ni->infinity || ni->nan) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
}
pi->stack.head->val = oj_num_as_value(ni);
}
static VALUE
start_hash(ParseInfo pi) {
if (Qnil != pi->options.hash_class) {
return rb_class_new_instance(0, NULL, pi->options.hash_class);
}
return rb_hash_new();
}
static VALUE
calc_hash_key(ParseInfo pi, Val parent) {
volatile VALUE rkey = parent->key_val;
if (Qundef == rkey) {
rkey = rb_str_new(parent->key, parent->klen);
}
rkey = oj_encode(rkey);
if (Yes == pi->options.sym_key) {
rkey = rb_str_intern(rkey);
}
return rkey;
}
static void
hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
volatile VALUE rstr = rb_str_new(str, len);
rstr = oj_encode(rstr);
rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rstr);
}
static void
hash_set_num(struct _ParseInfo *pi, Val parent, NumInfo ni) {
if (ni->infinity || ni->nan) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
}
rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), oj_num_as_value(ni));
}
static void
hash_set_value(ParseInfo pi, Val parent, VALUE value) {
rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), value);
}
static VALUE
start_array(ParseInfo pi) {
return rb_ary_new();
}
static void
array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
volatile VALUE rstr = rb_str_new(str, len);
rstr = oj_encode(rstr);
rb_ary_push(stack_peek(&pi->stack)->val, rstr);
}
static void
array_append_num(ParseInfo pi, NumInfo ni) {
if (ni->infinity || ni->nan) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
}
rb_ary_push(stack_peek(&pi->stack)->val, oj_num_as_value(ni));
}
static void
array_append_value(ParseInfo pi, VALUE value) {
rb_ary_push(stack_peek(&pi->stack)->val, value);
}
void
oj_set_strict_callbacks(ParseInfo pi) {
pi->start_hash = start_hash;
pi->end_hash = noop_end;
pi->hash_key = noop_hash_key;
pi->hash_set_cstr = hash_set_cstr;
pi->hash_set_num = hash_set_num;
pi->hash_set_value = hash_set_value;
pi->start_array = start_array;
pi->end_array = noop_end;
pi->array_append_cstr = array_append_cstr;
pi->array_append_num = array_append_num;
pi->array_append_value = array_append_value;
pi->add_cstr = add_cstr;
pi->add_num = add_num;
pi->add_value = add_value;
pi->expect_value = 1;
}
VALUE
oj_strict_parse(int argc, VALUE *argv, VALUE self) {
struct _ParseInfo pi;
pi.options = oj_default_options;
pi.handler = Qnil;
pi.err_class = Qnil;
oj_set_strict_callbacks(&pi);
if (T_STRING == rb_type(*argv)) {
return oj_pi_parse(argc, argv, &pi, 0, 0, 1);
} else {
return oj_pi_sparse(argc, argv, &pi, 0);
}
}
VALUE
oj_strict_parse_cstr(int argc, VALUE *argv, char *json, size_t len) {
struct _ParseInfo pi;
pi.options = oj_default_options;
pi.handler = Qnil;
pi.err_class = Qnil;
oj_set_strict_callbacks(&pi);
return oj_pi_parse(argc, argv, &pi, json, len, 1);
}
oj-2.17.4/ext/oj/reader.h 0000644 0000041 0000041 00000010413 12766161567 015110 0 ustar www-data www-data /* reader.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_READER_H__
#define __OJ_READER_H__
typedef struct _Reader {
char base[0x00001000];
char *head;
char *end;
char *tail;
char *read_end; /* one past last character read */
char *pro; /* protection start, buffer can not slide past this point */
char *str; /* start of current string being read */
int line;
int col;
int free_head;
int (*read_func)(struct _Reader *reader);
union {
int fd;
VALUE io;
const char *in_str;
};
} *Reader;
extern void oj_reader_init(Reader reader, VALUE io, int fd);
extern int oj_reader_read(Reader reader);
static inline char
reader_get(Reader reader) {
//printf("*** drive get from '%s' from start: %ld buf: %p from read_end: %ld\n", reader->tail, reader->tail - reader->head, reader->head, reader->read_end - reader->tail);
if (reader->read_end <= reader->tail) {
if (0 != oj_reader_read(reader)) {
return '\0';
}
}
if ('\n' == *reader->tail) {
reader->line++;
reader->col = 0;
}
reader->col++;
return *reader->tail++;
}
static inline void
reader_backup(Reader reader) {
reader->tail--;
reader->col--;
if (0 >= reader->col) {
reader->line--;
// allow col to be negative since we never backup twice in a row
}
}
static inline void
reader_protect(Reader reader) {
reader->pro = reader->tail;
reader->str = reader->tail; // can't have str before pro
}
static inline void
reader_release(Reader reader) {
reader->pro = 0;
}
/* Starts by reading a character so it is safe to use with an empty or
* compacted buffer.
*/
static inline char
reader_next_non_white(Reader reader) {
char c;
while ('\0' != (c = reader_get(reader))) {
switch(c) {
case ' ':
case '\t':
case '\f':
case '\n':
case '\r':
break;
default:
return c;
}
}
return '\0';
}
/* Starts by reading a character so it is safe to use with an empty or
* compacted buffer.
*/
static inline char
reader_next_white(Reader reader) {
char c;
while ('\0' != (c = reader_get(reader))) {
switch(c) {
case ' ':
case '\t':
case '\f':
case '\n':
case '\r':
case '\0':
return c;
default:
break;
}
}
return '\0';
}
static inline int
reader_expect(Reader reader, const char *s) {
for (; '\0' != *s; s++) {
if (reader_get(reader) != *s) {
return -1;
}
}
return 0;
}
static inline void
reader_cleanup(Reader reader) {
if (reader->free_head && 0 != reader->head) {
xfree((char*)reader->head);
reader->head = 0;
reader->free_head = 0;
}
}
static inline int
is_white(char c) {
switch(c) {
case ' ':
case '\t':
case '\f':
case '\n':
case '\r':
return 1;
default:
break;
}
return 0;
}
#endif /* __OJ_READER_H__ */
oj-2.17.4/ext/oj/hash.h 0000644 0000041 0000041 00000003651 12766161567 014577 0 ustar www-data www-data /* hash.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_HASH_H__
#define __OJ_HASH_H__
#include "ruby.h"
typedef struct _Hash *Hash;
extern void oj_hash_init();
extern VALUE oj_class_hash_get(const char *key, size_t len, VALUE **slotp);
extern ID oj_attr_hash_get(const char *key, size_t len, ID **slotp);
extern void oj_hash_print();
extern char* oj_strndup(const char *s, size_t len);
#endif /* __OJ_HASH_H__ */
oj-2.17.4/ext/oj/saj.c 0000644 0000041 0000041 00000044520 12766161567 014424 0 ustar www-data www-data /* saj.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if !IS_WINDOWS
#include /* for getrlimit() on linux */
#endif
#include
#include
#include
#include
#include
#include
// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
#define OJ_INFINITY (1.0/0.0)
#include "oj.h"
#include "encode.h"
typedef struct _ParseInfo {
char *str; /* buffer being read from */
char *s; /* current position in buffer */
void *stack_min;
VALUE handler;
int has_hash_start;
int has_hash_end;
int has_array_start;
int has_array_end;
int has_add_value;
int has_error;
} *ParseInfo;
static void read_next(ParseInfo pi, const char *key);
static void read_hash(ParseInfo pi, const char *key);
static void read_array(ParseInfo pi, const char *key);
static void read_str(ParseInfo pi, const char *key);
static void read_num(ParseInfo pi, const char *key);
static void read_true(ParseInfo pi, const char *key);
static void read_false(ParseInfo pi, const char *key);
static void read_nil(ParseInfo pi, const char *key);
static void next_non_white(ParseInfo pi);
static char* read_quoted_value(ParseInfo pi);
static void skip_comment(ParseInfo pi);
/* This JSON parser is a single pass, destructive, callback parser. It is a
* single pass parse since it only make one pass over the characters in the
* JSON document string. It is destructive because it re-uses the content of
* the string for values in the callback and places \0 characters at various
* places to mark the end of tokens and strings. It is a callback parser like
* a SAX parser because it uses callback when document elements are
* encountered.
*
* Parsing is very tolerant. Lack of headers and even mispelled element
* endings are passed over without raising an error. A best attempt is made in
* all cases to parse the string.
*/
inline static void
call_error(const char *msg, ParseInfo pi, const char* file, int line) {
char buf[128];
const char *s = pi->s;
int jline = 1;
int col = 1;
for (; pi->str < s && '\n' != *s; s--) {
col++;
}
for (; pi->str < s; s--) {
if ('\n' == *s) {
jline++;
}
}
sprintf(buf, "%s at line %d, column %d [%s:%d]", msg, jline, col, file, line);
rb_funcall(pi->handler, oj_error_id, 3, rb_str_new2(buf), LONG2NUM(jline), LONG2NUM(col));
}
inline static void
next_non_white(ParseInfo pi) {
for (; 1; pi->s++) {
switch(*pi->s) {
case ' ':
case '\t':
case '\f':
case '\n':
case '\r':
break;
case '/':
skip_comment(pi);
break;
default:
return;
}
}
}
inline static void
call_add_value(VALUE handler, VALUE value, const char *key) {
volatile VALUE k;
if (0 == key) {
k = Qnil;
} else {
k = rb_str_new2(key);
k = oj_encode(k);
}
rb_funcall(handler, oj_add_value_id, 2, value, k);
}
inline static void
call_no_value(VALUE handler, ID method, const char *key) {
volatile VALUE k;
if (0 == key) {
k = Qnil;
} else {
k = rb_str_new2(key);
k = oj_encode(k);
}
rb_funcall(handler, method, 1, k);
}
static void
skip_comment(ParseInfo pi) {
pi->s++; /* skip first / */
if ('*' == *pi->s) {
pi->s++;
for (; '\0' != *pi->s; pi->s++) {
if ('*' == *pi->s && '/' == *(pi->s + 1)) {
pi->s++;
return;
} else if ('\0' == *pi->s) {
if (pi->has_error) {
call_error("comment not terminated", pi, __FILE__, __LINE__);
} else {
raise_error("comment not terminated", pi->str, pi->s);
}
}
}
} else if ('/' == *pi->s) {
for (; 1; pi->s++) {
switch (*pi->s) {
case '\n':
case '\r':
case '\f':
case '\0':
return;
default:
break;
}
}
} else {
if (pi->has_error) {
call_error("invalid comment", pi, __FILE__, __LINE__);
} else {
raise_error("invalid comment", pi->str, pi->s);
}
}
}
static void
read_next(ParseInfo pi, const char *key) {
VALUE obj;
if ((void*)&obj < pi->stack_min) {
rb_raise(rb_eSysStackError, "JSON is too deeply nested");
}
next_non_white(pi); /* skip white space */
switch (*pi->s) {
case '{':
read_hash(pi, key);
break;
case '[':
read_array(pi, key);
break;
case '"':
read_str(pi, key);
break;
case '+':
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
read_num(pi, key);
break;
case 'I':
read_num(pi, key);
break;
case 't':
read_true(pi, key);
break;
case 'f':
read_false(pi, key);
break;
case 'n':
read_nil(pi, key);
break;
case '\0':
return;
default:
return;
}
}
static void
read_hash(ParseInfo pi, const char *key) {
const char *ks;
if (pi->has_hash_start) {
call_no_value(pi->handler, oj_hash_start_id, key);
}
pi->s++;
next_non_white(pi);
if ('}' == *pi->s) {
pi->s++;
} else {
while (1) {
next_non_white(pi);
ks = read_quoted_value(pi);
next_non_white(pi);
if (':' == *pi->s) {
pi->s++;
} else {
if (pi->has_error) {
call_error("invalid format, expected :", pi, __FILE__, __LINE__);
}
raise_error("invalid format, expected :", pi->str, pi->s);
}
read_next(pi, ks);
next_non_white(pi);
if ('}' == *pi->s) {
pi->s++;
break;
} else if (',' == *pi->s) {
pi->s++;
} else {
if (pi->has_error) {
call_error("invalid format, expected , or } while in an object", pi, __FILE__, __LINE__);
}
raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
}
}
}
if (pi->has_hash_end) {
call_no_value(pi->handler, oj_hash_end_id, key);
}
}
static void
read_array(ParseInfo pi, const char *key) {
if (pi->has_array_start) {
call_no_value(pi->handler, oj_array_start_id, key);
}
pi->s++;
next_non_white(pi);
if (']' == *pi->s) {
pi->s++;
} else {
while (1) {
read_next(pi, 0);
next_non_white(pi);
if (',' == *pi->s) {
pi->s++;
} else if (']' == *pi->s) {
pi->s++;
break;
} else {
if (pi->has_error) {
call_error("invalid format, expected , or ] while in an array", pi, __FILE__, __LINE__);
}
raise_error("invalid format, expected , or ] while in an array", pi->str, pi->s);
}
}
}
if (pi->has_array_end) {
call_no_value(pi->handler, oj_array_end_id, key);
}
}
static void
read_str(ParseInfo pi, const char *key) {
char *text;
text = read_quoted_value(pi);
if (pi->has_add_value) {
VALUE s = rb_str_new2(text);
s = oj_encode(s);
call_add_value(pi->handler, s, key);
}
}
#ifdef RUBINIUS_RUBY
#define NUM_MAX 0x07FFFFFF
#else
#define NUM_MAX (FIXNUM_MAX >> 8)
#endif
static void
read_num(ParseInfo pi, const char *key) {
char *start = pi->s;
int64_t n = 0;
long a = 0;
long div = 1;
long e = 0;
int neg = 0;
int eneg = 0;
int big = 0;
if ('-' == *pi->s) {
pi->s++;
neg = 1;
} else if ('+' == *pi->s) {
pi->s++;
}
if ('I' == *pi->s) {
if (0 != strncmp("Infinity", pi->s, 8)) {
if (pi->has_error) {
call_error("number or other value", pi, __FILE__, __LINE__);
}
raise_error("number or other value", pi->str, pi->s);
}
pi->s += 8;
if (neg) {
if (pi->has_add_value) {
call_add_value(pi->handler, rb_float_new(-OJ_INFINITY), key);
}
} else {
if (pi->has_add_value) {
call_add_value(pi->handler, rb_float_new(OJ_INFINITY), key);
}
}
return;
}
for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
if (big) {
big++;
} else {
n = n * 10 + (*pi->s - '0');
if (NUM_MAX <= n) {
big = 1;
}
}
}
if ('.' == *pi->s) {
pi->s++;
for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
a = a * 10 + (*pi->s - '0');
div *= 10;
if (NUM_MAX <= div) {
big = 1;
}
}
}
if ('e' == *pi->s || 'E' == *pi->s) {
pi->s++;
if ('-' == *pi->s) {
pi->s++;
eneg = 1;
} else if ('+' == *pi->s) {
pi->s++;
}
for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
e = e * 10 + (*pi->s - '0');
if (NUM_MAX <= e) {
big = 1;
}
}
}
if (0 == e && 0 == a && 1 == div) {
if (big) {
char c = *pi->s;
*pi->s = '\0';
if (pi->has_add_value) {
call_add_value(pi->handler, rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(start)), key);
}
*pi->s = c;
} else {
if (neg) {
n = -n;
}
if (pi->has_add_value) {
call_add_value(pi->handler, LONG2NUM(n), key);
}
}
return;
} else { /* decimal */
if (big) {
char c = *pi->s;
*pi->s = '\0';
if (pi->has_add_value) {
call_add_value(pi->handler, rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(start)), key);
}
*pi->s = c;
} else {
double d = (double)n + (double)a / (double)div;
if (neg) {
d = -d;
}
if (1 < big) {
e += big - 1;
}
if (0 != e) {
if (eneg) {
e = -e;
}
d *= pow(10.0, e);
}
if (pi->has_add_value) {
call_add_value(pi->handler, rb_float_new(d), key);
}
}
}
}
static void
read_true(ParseInfo pi, const char *key) {
pi->s++;
if ('r' != *pi->s || 'u' != *(pi->s + 1) || 'e' != *(pi->s + 2)) {
if (pi->has_error) {
call_error("invalid format, expected 'true'", pi, __FILE__, __LINE__);
}
raise_error("invalid format, expected 'true'", pi->str, pi->s);
}
pi->s += 3;
if (pi->has_add_value) {
call_add_value(pi->handler, Qtrue, key);
}
}
static void
read_false(ParseInfo pi, const char *key) {
pi->s++;
if ('a' != *pi->s || 'l' != *(pi->s + 1) || 's' != *(pi->s + 2) || 'e' != *(pi->s + 3)) {
if (pi->has_error) {
call_error("invalid format, expected 'false'", pi, __FILE__, __LINE__);
}
raise_error("invalid format, expected 'false'", pi->str, pi->s);
}
pi->s += 4;
if (pi->has_add_value) {
call_add_value(pi->handler, Qfalse, key);
}
}
static void
read_nil(ParseInfo pi, const char *key) {
pi->s++;
if ('u' != *pi->s || 'l' != *(pi->s + 1) || 'l' != *(pi->s + 2)) {
if (pi->has_error) {
call_error("invalid format, expected 'null'", pi, __FILE__, __LINE__);
}
raise_error("invalid format, expected 'null'", pi->str, pi->s);
}
pi->s += 3;
if (pi->has_add_value) {
call_add_value(pi->handler, Qnil, key);
}
}
static uint32_t
read_hex(ParseInfo pi, char *h) {
uint32_t b = 0;
int i;
/* TBD this can be made faster with a table */
for (i = 0; i < 4; i++, h++) {
b = b << 4;
if ('0' <= *h && *h <= '9') {
b += *h - '0';
} else if ('A' <= *h && *h <= 'F') {
b += *h - 'A' + 10;
} else if ('a' <= *h && *h <= 'f') {
b += *h - 'a' + 10;
} else {
pi->s = h;
if (pi->has_error) {
call_error("invalid hex character", pi, __FILE__, __LINE__);
}
raise_error("invalid hex character", pi->str, pi->s);
}
}
return b;
}
static char*
unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
if (0x0000007F >= code) {
*t = (char)code;
} else if (0x000007FF >= code) {
*t++ = 0xC0 | (code >> 6);
*t = 0x80 | (0x3F & code);
} else if (0x0000FFFF >= code) {
*t++ = 0xE0 | (code >> 12);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t = 0x80 | (0x3F & code);
} else if (0x001FFFFF >= code) {
*t++ = 0xF0 | (code >> 18);
*t++ = 0x80 | ((code >> 12) & 0x3F);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t = 0x80 | (0x3F & code);
} else if (0x03FFFFFF >= code) {
*t++ = 0xF8 | (code >> 24);
*t++ = 0x80 | ((code >> 18) & 0x3F);
*t++ = 0x80 | ((code >> 12) & 0x3F);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t = 0x80 | (0x3F & code);
} else if (0x7FFFFFFF >= code) {
*t++ = 0xFC | (code >> 30);
*t++ = 0x80 | ((code >> 24) & 0x3F);
*t++ = 0x80 | ((code >> 18) & 0x3F);
*t++ = 0x80 | ((code >> 12) & 0x3F);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t = 0x80 | (0x3F & code);
} else {
if (pi->has_error) {
call_error("invalid Unicode", pi, __FILE__, __LINE__);
}
raise_error("invalid Unicode", pi->str, pi->s);
}
return t;
}
/* Assume the value starts immediately and goes until the quote character is
* reached again. Do not read the character after the terminating quote.
*/
static char*
read_quoted_value(ParseInfo pi) {
char *value = 0;
char *h = pi->s; /* head */
char *t = h; /* tail */
uint32_t code;
h++; /* skip quote character */
t++;
value = h;
for (; '"' != *h; h++, t++) {
if ('\0' == *h) {
pi->s = h;
raise_error("quoted string not terminated", pi->str, pi->s);
} else if ('\\' == *h) {
h++;
switch (*h) {
case 'n': *t = '\n'; break;
case 'r': *t = '\r'; break;
case 't': *t = '\t'; break;
case 'f': *t = '\f'; break;
case 'b': *t = '\b'; break;
case '"': *t = '"'; break;
case '/': *t = '/'; break;
case '\\': *t = '\\'; break;
case 'u':
h++;
code = read_hex(pi, h);
h += 3;
if (0x0000D800 <= code && code <= 0x0000DFFF) {
uint32_t c1 = (code - 0x0000D800) & 0x000003FF;
uint32_t c2;
h++;
if ('\\' != *h || 'u' != *(h + 1)) {
pi->s = h;
if (pi->has_error) {
call_error("invalid escaped character", pi, __FILE__, __LINE__);
}
raise_error("invalid escaped character", pi->str, pi->s);
}
h += 2;
c2 = read_hex(pi, h);
h += 3;
c2 = (c2 - 0x0000DC00) & 0x000003FF;
code = ((c1 << 10) | c2) + 0x00010000;
}
t = unicode_to_chars(pi, t, code);
break;
default:
pi->s = h;
if (pi->has_error) {
call_error("invalid escaped character", pi, __FILE__, __LINE__);
}
raise_error("invalid escaped character", pi->str, pi->s);
break;
}
} else if (t != h) {
*t = *h;
}
}
*t = '\0'; /* terminate value */
pi->s = h + 1;
return value;
}
static void
saj_parse(VALUE handler, char *json) {
volatile VALUE obj = Qnil;
struct _ParseInfo pi;
if (0 == json) {
if (pi.has_error) {
call_error("Invalid arg, xml string can not be null", &pi, __FILE__, __LINE__);
}
raise_error("Invalid arg, xml string can not be null", json, 0);
}
/* skip UTF-8 BOM if present */
if (0xEF == (uint8_t)*json && 0xBB == (uint8_t)json[1] && 0xBF == (uint8_t)json[2]) {
json += 3;
}
/* initialize parse info */
pi.str = json;
pi.s = json;
#if IS_WINDOWS
pi.stack_min = (void*)((char*)&obj - (512 * 1024)); /* assume a 1M stack and give half to ruby */
#else
{
struct rlimit lim;
if (0 == getrlimit(RLIMIT_STACK, &lim)) {
pi.stack_min = (void*)((char*)&obj - (lim.rlim_cur / 4 * 3)); /* let 3/4ths of the stack be used only */
} else {
pi.stack_min = 0; /* indicates not to check stack limit */
}
}
#endif
pi.handler = handler;
pi.has_hash_start = rb_respond_to(handler, oj_hash_start_id);
pi.has_hash_end = rb_respond_to(handler, oj_hash_end_id);
pi.has_array_start = rb_respond_to(handler, oj_array_start_id);
pi.has_array_end = rb_respond_to(handler, oj_array_end_id);
pi.has_add_value = rb_respond_to(handler, oj_add_value_id);
pi.has_error = rb_respond_to(handler, oj_error_id);
read_next(&pi, 0);
next_non_white(&pi);
if ('\0' != *pi.s) {
if (pi.has_error) {
call_error("invalid format, extra characters", &pi, __FILE__, __LINE__);
} else {
raise_error("invalid format, extra characters", pi.str, pi.s);
}
}
}
/* call-seq: saj_parse(handler, io)
*
* Parses an IO stream or file containing an JSON document. Raises an exception
* if the JSON is malformed.
* @param [Oj::Saj] handler Saj (responds to Oj::Saj methods) like handler
* @param [IO|String] io IO Object to read from
*/
VALUE
oj_saj_parse(int argc, VALUE *argv, VALUE self) {
char *json = 0;
size_t len = 0;
VALUE input = argv[1];
if (argc < 2) {
rb_raise(rb_eArgError, "Wrong number of arguments to saj_parse.\n");
}
if (rb_type(input) == T_STRING) {
// the json string gets modified so make a copy of it
len = RSTRING_LEN(input) + 1;
json = ALLOC_N(char, len);
strcpy(json, StringValuePtr(input));
} else {
VALUE clas = rb_obj_class(input);
volatile VALUE s;
if (oj_stringio_class == clas) {
s = rb_funcall2(input, oj_string_id, 0, 0);
len = RSTRING_LEN(s) + 1;
json = ALLOC_N(char, len);
strcpy(json, rb_string_value_cstr((VALUE*)&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);
lseek(fd, 0, SEEK_SET);
json = ALLOC_N(char, len + 1);
if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
rb_raise(rb_eIOError, "failed to read from IO Object.");
}
json[len] = '\0';
#endif
} else if (rb_respond_to(input, oj_read_id)) {
s = rb_funcall2(input, oj_read_id, 0, 0);
len = RSTRING_LEN(s) + 1;
json = ALLOC_N(char, len);
strcpy(json, rb_string_value_cstr((VALUE*)&s));
} else {
rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
}
}
saj_parse(*argv, json);
xfree(json);
return Qnil;
}
oj-2.17.4/ext/oj/fast.c 0000644 0000041 0000041 00000121335 12766161567 014604 0 ustar www-data www-data /* fast.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if !IS_WINDOWS
#include // for getrlimit() on linux
#endif
#include
#include
#include
#include
#include
#include "oj.h"
#include "encode.h"
// maximum to allocate on the stack, arbitrary limit
#define SMALL_XML 65536
#define MAX_STACK 100
//#define BATCH_SIZE (4096 / sizeof(struct _Leaf) - 1)
#define BATCH_SIZE 100
typedef struct _Batch {
struct _Batch *next;
int next_avail;
struct _Leaf leaves[BATCH_SIZE];
} *Batch;
typedef struct _Doc {
Leaf data;
Leaf *where; // points to current location
Leaf where_path[MAX_STACK]; // points to head of path
char *json;
unsigned long size; // number of leaves/branches in the doc
VALUE self;
Batch batches;
struct _Batch batch0;
} *Doc;
typedef struct _ParseInfo {
char *str; /* buffer being read from */
char *s; /* current position in buffer */
Doc doc;
void *stack_min;
} *ParseInfo;
static void leaf_init(Leaf leaf, int type);
static Leaf leaf_new(Doc doc, int type);
static void leaf_append_element(Leaf parent, Leaf element);
static VALUE leaf_value(Doc doc, Leaf leaf);
static void leaf_fixnum_value(Leaf leaf);
static void leaf_float_value(Leaf leaf);
static VALUE leaf_array_value(Doc doc, Leaf leaf);
static VALUE leaf_hash_value(Doc doc, Leaf leaf);
static Leaf read_next(ParseInfo pi);
static Leaf read_obj(ParseInfo pi);
static Leaf read_array(ParseInfo pi);
static Leaf read_str(ParseInfo pi);
static Leaf read_num(ParseInfo pi);
static Leaf read_true(ParseInfo pi);
static Leaf read_false(ParseInfo pi);
static Leaf read_nil(ParseInfo pi);
static void next_non_white(ParseInfo pi);
static char* read_quoted_value(ParseInfo pi);
static void skip_comment(ParseInfo pi);
static VALUE protect_open_proc(VALUE x);
static VALUE parse_json(VALUE clas, char *json, int given, int allocated);
static void each_leaf(Doc doc, VALUE self);
static int move_step(Doc doc, const char *path, int loc);
static Leaf get_doc_leaf(Doc doc, const char *path);
static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path);
static void each_value(Doc doc, Leaf leaf);
static void doc_init(Doc doc);
static void doc_free(Doc doc);
static VALUE doc_open(VALUE clas, VALUE str);
static VALUE doc_open_file(VALUE clas, VALUE filename);
static VALUE doc_where(VALUE self);
static VALUE doc_local_key(VALUE self);
static VALUE doc_home(VALUE self);
static VALUE doc_type(int argc, VALUE *argv, VALUE self);
static VALUE doc_fetch(int argc, VALUE *argv, VALUE self);
static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self);
static VALUE doc_move(VALUE self, VALUE str);
static VALUE doc_each_child(int argc, VALUE *argv, VALUE self);
static VALUE doc_each_value(int argc, VALUE *argv, VALUE self);
static VALUE doc_dump(int argc, VALUE *argv, VALUE self);
static VALUE doc_size(VALUE self);
VALUE oj_doc_class = 0;
// This is only for CentOS 5.4 with Ruby 1.9.3-p0.
#ifdef NEEDS_STPCPY
char *stpcpy(char *dest, const char *src) {
size_t cnt = strlen(src);
strcpy(dest, src);
return dest + cnt;
}
#endif
inline static void
next_non_white(ParseInfo pi) {
for (; 1; pi->s++) {
switch(*pi->s) {
case ' ':
case '\t':
case '\f':
case '\n':
case '\r':
break;
case '/':
skip_comment(pi);
break;
default:
return;
}
}
}
inline static char*
ulong_fill(char *s, size_t num) {
char buf[32];
char *b = buf + sizeof(buf) - 1;
*b-- = '\0';
for (; 0 < num; num /= 10, b--) {
*b = (num % 10) + '0';
}
b++;
if ('\0' == *b) {
b--;
*b = '0';
}
for (; '\0' != *b; b++, s++) {
*s = *b;
}
return s;
}
inline static void
leaf_init(Leaf leaf, int type) {
leaf->next = 0;
leaf->rtype = type;
leaf->parent_type = T_NONE;
switch (type) {
case T_ARRAY:
case T_HASH:
leaf->elements = 0;
leaf->value_type = COL_VAL;
break;
case T_NIL:
leaf->value = Qnil;
leaf->value_type = RUBY_VAL;
break;
case T_TRUE:
leaf->value = Qtrue;
leaf->value_type = RUBY_VAL;
break;
case T_FALSE:
leaf->value = Qfalse;
leaf->value_type = RUBY_VAL;
break;
case T_FIXNUM:
case T_FLOAT:
case T_STRING:
default:
leaf->value_type = STR_VAL;
break;
}
}
inline static Leaf
leaf_new(Doc doc, int type) {
Leaf leaf;
if (0 == doc->batches || BATCH_SIZE == doc->batches->next_avail) {
Batch b = ALLOC(struct _Batch);
// Initializes all leaves with a NO_VAL value_type
memset(b, 0, sizeof(struct _Batch));
b->next = doc->batches;
doc->batches = b;
b->next_avail = 0;
}
leaf = &doc->batches->leaves[doc->batches->next_avail];
doc->batches->next_avail++;
leaf_init(leaf, type);
return leaf;
}
inline static void
leaf_append_element(Leaf parent, Leaf element) {
if (0 == parent->elements) {
parent->elements = element;
element->next = element;
} else {
element->next = parent->elements->next;
parent->elements->next = element;
parent->elements = element;
}
}
static VALUE
leaf_value(Doc doc, Leaf leaf) {
if (RUBY_VAL != leaf->value_type) {
switch (leaf->rtype) {
case T_NIL:
leaf->value = Qnil;
break;
case T_TRUE:
leaf->value = Qtrue;
break;
case T_FALSE:
leaf->value = Qfalse;
break;
case T_FIXNUM:
leaf_fixnum_value(leaf);
break;
case T_FLOAT:
leaf_float_value(leaf);
break;
case T_STRING:
leaf->value = rb_str_new2(leaf->str);
leaf->value = oj_encode(leaf->value);
leaf->value_type = RUBY_VAL;
break;
case T_ARRAY:
return leaf_array_value(doc, leaf);
break;
case T_HASH:
return leaf_hash_value(doc, leaf);
break;
default:
rb_raise(rb_const_get_at(Oj, rb_intern("Error")), "Unexpected type %02x.", leaf->rtype);
break;
}
}
return leaf->value;
}
inline static Doc
self_doc(VALUE self) {
Doc doc = DATA_PTR(self);
if (0 == doc) {
rb_raise(rb_eIOError, "Document already closed or not open.");
}
return doc;
}
static void
skip_comment(ParseInfo pi) {
pi->s++; // skip first /
if ('*' == *pi->s) {
pi->s++;
for (; '\0' != *pi->s; pi->s++) {
if ('*' == *pi->s && '/' == *(pi->s + 1)) {
pi->s++;
return;
} else if ('\0' == *pi->s) {
raise_error("comment not terminated", pi->str, pi->s);
}
}
} else if ('/' == *pi->s) {
for (; 1; pi->s++) {
switch (*pi->s) {
case '\n':
case '\r':
case '\f':
case '\0':
return;
default:
break;
}
}
} else {
raise_error("invalid comment", pi->str, pi->s);
}
}
#ifdef RUBINIUS_RUBY
#define NUM_MAX 0x07FFFFFF
#else
#define NUM_MAX (FIXNUM_MAX >> 8)
#endif
static void
leaf_fixnum_value(Leaf leaf) {
char *s = leaf->str;
int64_t n = 0;
int neg = 0;
int big = 0;
if ('-' == *s) {
s++;
neg = 1;
} else if ('+' == *s) {
s++;
}
for (; '0' <= *s && *s <= '9'; s++) {
n = n * 10 + (*s - '0');
if (NUM_MAX <= n) {
big = 1;
}
}
if (big) {
char c = *s;
*s = '\0';
leaf->value = rb_cstr_to_inum(leaf->str, 10, 0);
*s = c;
} else {
if (neg) {
n = -n;
}
leaf->value = rb_ll2inum(n);
}
leaf->value_type = RUBY_VAL;
}
static void
leaf_float_value(Leaf leaf) {
leaf->value = rb_float_new(rb_cstr_to_dbl(leaf->str, 1));
leaf->value_type = RUBY_VAL;
}
static VALUE
leaf_array_value(Doc doc, Leaf leaf) {
VALUE a = rb_ary_new();
if (0 != leaf->elements) {
Leaf first = leaf->elements->next;
Leaf e = first;
do {
rb_ary_push(a, leaf_value(doc, e));
e = e->next;
} while (e != first);
}
return a;
}
static VALUE
leaf_hash_value(Doc doc, Leaf leaf) {
VALUE h = rb_hash_new();
if (0 != leaf->elements) {
Leaf first = leaf->elements->next;
Leaf e = first;
VALUE key;
do {
key = rb_str_new2(e->key);
key = oj_encode(key);
rb_hash_aset(h, key, leaf_value(doc, e));
e = e->next;
} while (e != first);
}
return h;
}
static Leaf
read_next(ParseInfo pi) {
Leaf leaf = 0;
if ((void*)&leaf < pi->stack_min) {
rb_raise(rb_eSysStackError, "JSON is too deeply nested");
}
next_non_white(pi); // skip white space
switch (*pi->s) {
case '{':
leaf = read_obj(pi);
break;
case '[':
leaf = read_array(pi);
break;
case '"':
leaf = read_str(pi);
break;
case '+':
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
leaf = read_num(pi);
break;
case 't':
leaf = read_true(pi);
break;
case 'f':
leaf = read_false(pi);
break;
case 'n':
leaf = read_nil(pi);
break;
case '\0':
default:
break; // returns 0
}
pi->doc->size++;
return leaf;
}
static Leaf
read_obj(ParseInfo pi) {
Leaf h = leaf_new(pi->doc, T_HASH);
char *end;
const char *key = 0;
Leaf val = 0;
pi->s++;
next_non_white(pi);
if ('}' == *pi->s) {
pi->s++;
return h;
}
while (1) {
next_non_white(pi);
key = 0;
val = 0;
if ('"' != *pi->s || 0 == (key = read_quoted_value(pi))) {
raise_error("unexpected character", pi->str, pi->s);
}
next_non_white(pi);
if (':' == *pi->s) {
pi->s++;
} else {
raise_error("invalid format, expected :", pi->str, pi->s);
}
if (0 == (val = read_next(pi))) {
//printf("*** '%s'\n", pi->s);
raise_error("unexpected character", pi->str, pi->s);
}
end = pi->s;
val->key = key;
val->parent_type = T_HASH;
leaf_append_element(h, val);
next_non_white(pi);
if ('}' == *pi->s) {
pi->s++;
*end = '\0';
break;
} else if (',' == *pi->s) {
pi->s++;
} else {
//printf("*** '%s'\n", pi->s);
raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
}
*end = '\0';
}
return h;
}
static Leaf
read_array(ParseInfo pi) {
Leaf a = leaf_new(pi->doc, T_ARRAY);
Leaf e;
char *end;
int cnt = 0;
pi->s++;
next_non_white(pi);
if (']' == *pi->s) {
pi->s++;
return a;
}
while (1) {
next_non_white(pi);
if (0 == (e = read_next(pi))) {
raise_error("unexpected character", pi->str, pi->s);
}
cnt++;
e->index = cnt;
e->parent_type = T_ARRAY;
leaf_append_element(a, e);
end = pi->s;
next_non_white(pi);
if (',' == *pi->s) {
pi->s++;
} else if (']' == *pi->s) {
pi->s++;
*end = '\0';
break;
} else {
raise_error("invalid format, expected , or ] while in an array", pi->str, pi->s);
}
*end = '\0';
}
return a;
}
static Leaf
read_str(ParseInfo pi) {
Leaf leaf = leaf_new(pi->doc, T_STRING);
leaf->str = read_quoted_value(pi);
return leaf;
}
static Leaf
read_num(ParseInfo pi) {
char *start = pi->s;
int type = T_FIXNUM;
Leaf leaf;
if ('-' == *pi->s) {
pi->s++;
}
// digits
for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
}
if ('.' == *pi->s) {
type = T_FLOAT;
pi->s++;
for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
}
}
if ('e' == *pi->s || 'E' == *pi->s) {
pi->s++;
if ('-' == *pi->s || '+' == *pi->s) {
pi->s++;
}
for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
}
}
leaf = leaf_new(pi->doc, type);
leaf->str = start;
return leaf;
}
static Leaf
read_true(ParseInfo pi) {
Leaf leaf = leaf_new(pi->doc, T_TRUE);
pi->s++;
if ('r' != *pi->s || 'u' != *(pi->s + 1) || 'e' != *(pi->s + 2)) {
raise_error("invalid format, expected 'true'", pi->str, pi->s);
}
pi->s += 3;
return leaf;
}
static Leaf
read_false(ParseInfo pi) {
Leaf leaf = leaf_new(pi->doc, T_FALSE);
pi->s++;
if ('a' != *pi->s || 'l' != *(pi->s + 1) || 's' != *(pi->s + 2) || 'e' != *(pi->s + 3)) {
raise_error("invalid format, expected 'false'", pi->str, pi->s);
}
pi->s += 4;
return leaf;
}
static Leaf
read_nil(ParseInfo pi) {
Leaf leaf = leaf_new(pi->doc, T_NIL);
pi->s++;
if ('u' != *pi->s || 'l' != *(pi->s + 1) || 'l' != *(pi->s + 2)) {
raise_error("invalid format, expected 'nil'", pi->str, pi->s);
}
pi->s += 3;
return leaf;
}
static uint32_t
read_4hex(ParseInfo pi, const char *h) {
uint32_t b = 0;
int i;
for (i = 0; i < 4; i++, h++) {
b = b << 4;
if ('0' <= *h && *h <= '9') {
b += *h - '0';
} else if ('A' <= *h && *h <= 'F') {
b += *h - 'A' + 10;
} else if ('a' <= *h && *h <= 'f') {
b += *h - 'a' + 10;
} else {
raise_error("invalid hex character", pi->str, pi->s);
}
}
return b;
}
static char*
unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
if (0x0000007F >= code) {
*t++ = (char)code;
} else if (0x000007FF >= code) {
*t++ = 0xC0 | (code >> 6);
*t++ = 0x80 | (0x3F & code);
} else if (0x0000FFFF >= code) {
*t++ = 0xE0 | (code >> 12);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t++ = 0x80 | (0x3F & code);
} else if (0x001FFFFF >= code) {
*t++ = 0xF0 | (code >> 18);
*t++ = 0x80 | ((code >> 12) & 0x3F);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t++ = 0x80 | (0x3F & code);
} else if (0x03FFFFFF >= code) {
*t++ = 0xF8 | (code >> 24);
*t++ = 0x80 | ((code >> 18) & 0x3F);
*t++ = 0x80 | ((code >> 12) & 0x3F);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t++ = 0x80 | (0x3F & code);
} else if (0x7FFFFFFF >= code) {
*t++ = 0xFC | (code >> 30);
*t++ = 0x80 | ((code >> 24) & 0x3F);
*t++ = 0x80 | ((code >> 18) & 0x3F);
*t++ = 0x80 | ((code >> 12) & 0x3F);
*t++ = 0x80 | ((code >> 6) & 0x3F);
*t++ = 0x80 | (0x3F & code);
} else {
raise_error("invalid Unicode character", pi->str, pi->s);
}
return t;
}
/* Assume the value starts immediately and goes until the quote character is
* reached again. Do not read the character after the terminating quote.
*/
static char*
read_quoted_value(ParseInfo pi) {
char *value = 0;
char *h = pi->s; // head
char *t = h; // tail
h++; // skip quote character
t++;
value = h;
for (; '"' != *h; h++, t++) {
if ('\0' == *h) {
pi->s = h;
raise_error("quoted string not terminated", pi->str, pi->s);
} else if ('\\' == *h) {
h++;
switch (*h) {
case 'n': *t = '\n'; break;
case 'r': *t = '\r'; break;
case 't': *t = '\t'; break;
case 'f': *t = '\f'; break;
case 'b': *t = '\b'; break;
case '"': *t = '"'; break;
case '/': *t = '/'; break;
case '\\': *t = '\\'; break;
case 'u': {
uint32_t code;
h++;
code = read_4hex(pi, h);
h += 3;
if (0x0000D800 <= code && code <= 0x0000DFFF) {
uint32_t c1 = (code - 0x0000D800) & 0x000003FF;
uint32_t c2;
h++;
if ('\\' != *h || 'u' != *(h + 1)) {
pi->s = h;
raise_error("invalid escaped character", pi->str, pi->s);
}
h += 2;
c2 = read_4hex(pi, h);
h += 3;
c2 = (c2 - 0x0000DC00) & 0x000003FF;
code = ((c1 << 10) | c2) + 0x00010000;
}
t = unicode_to_chars(pi, t, code);
t--;
break;
}
default:
pi->s = h;
raise_error("invalid escaped character", pi->str, pi->s);
break;
}
} else if (t != h) {
*t = *h;
}
}
*t = '\0'; // terminate value
pi->s = h + 1;
return value;
}
// doc support functions
inline static void
doc_init(Doc doc) {
memset(doc, 0, sizeof(struct _Doc));
doc->where = doc->where_path;
doc->self = Qundef;
doc->batches = &doc->batch0;
}
static void
doc_free(Doc doc) {
if (0 != doc) {
Batch b;
while (0 != (b = doc->batches)) {
doc->batches = doc->batches->next;
if (&doc->batch0 != b) {
xfree(b);
}
}
//xfree(f);
}
}
static VALUE
protect_open_proc(VALUE x) {
ParseInfo pi = (ParseInfo)x;
pi->doc->data = read_next(pi); // parse
*pi->doc->where = pi->doc->data;
pi->doc->where = pi->doc->where_path;
if (rb_block_given_p()) {
return rb_yield(pi->doc->self); // caller processing
}
return Qnil;
}
static void
free_doc_cb(void *x) {
Doc doc = (Doc)x;
if (0 != doc) {
xfree(doc->json);
doc_free(doc);
}
}
static VALUE
parse_json(VALUE clas, char *json, int given, int allocated) {
struct _ParseInfo pi;
VALUE result = Qnil;
Doc doc;
int ex = 0;
if (given) {
doc = ALLOCA_N(struct _Doc, 1);
} else {
doc = ALLOC_N(struct _Doc, 1);
}
/* skip UTF-8 BOM if present */
if (0xEF == (uint8_t)*json && 0xBB == (uint8_t)json[1] && 0xBF == (uint8_t)json[2]) {
pi.str = json + 3;
} else {
pi.str = json;
}
pi.s = pi.str;
doc_init(doc);
pi.doc = doc;
#if IS_WINDOWS
pi.stack_min = (void*)((char*)&pi - (512 * 1024)); // assume a 1M stack and give half to ruby
#else
{
struct rlimit lim;
if (0 == getrlimit(RLIMIT_STACK, &lim)) {
pi.stack_min = (void*)((char*)&lim - (lim.rlim_cur / 4 * 3)); // let 3/4ths of the stack be used only
} else {
pi.stack_min = 0; // indicates not to check stack limit
}
}
#endif
// last arg is free func void* func(void*)
#if HAS_DATA_OBJECT_WRAP
doc->self = rb_data_object_wrap(clas, doc, 0, free_doc_cb);
#else
doc->self = rb_data_object_alloc(clas, doc, 0, free_doc_cb);
#endif
rb_gc_register_address(&doc->self);
doc->json = json;
DATA_PTR(doc->self) = doc;
result = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
if (given || 0 != ex) {
rb_gc_unregister_address(&doc->self);
DATA_PTR(doc->self) = 0;
doc_free(pi.doc);
if (allocated && 0 != ex) { // will jump so caller will not free
xfree(json);
}
} else {
result = doc->self;
}
if (0 != ex) {
rb_jump_tag(ex);
}
return result;
}
static Leaf
get_doc_leaf(Doc doc, const char *path) {
Leaf leaf = *doc->where;
if (0 != doc->data && 0 != path) {
Leaf stack[MAX_STACK];
Leaf *lp;
if ('/' == *path) {
path++;
*stack = doc->data;
lp = stack;
} else if (doc->where == doc->where_path) {
*stack = doc->data;
lp = stack;
} else {
size_t cnt = doc->where - doc->where_path;
if (MAX_STACK <= cnt) {
rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
}
memcpy(stack, doc->where_path, sizeof(Leaf) * (cnt + 1));
lp = stack + cnt;
}
return get_leaf(stack, lp, path);
}
return leaf;
}
static Leaf
get_leaf(Leaf *stack, Leaf *lp, const char *path) {
Leaf leaf = *lp;
if (MAX_STACK <= lp - stack) {
rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
}
if ('\0' != *path) {
if ('.' == *path && '.' == *(path + 1)) {
path += 2;
if ('/' == *path) {
path++;
}
if (stack < lp) {
leaf = get_leaf(stack, lp - 1, path);
} else {
return 0;
}
} else if (COL_VAL == leaf->value_type && 0 != leaf->elements) {
Leaf first = leaf->elements->next;
Leaf e = first;
int type = leaf->rtype;
leaf = 0;
if (T_ARRAY == type) {
int cnt = 0;
for (; '0' <= *path && *path <= '9'; path++) {
cnt = cnt * 10 + (*path - '0');
}
if ('/' == *path) {
path++;
}
do {
if (1 >= cnt) {
lp++;
*lp = e;
leaf = get_leaf(stack, lp, path);
break;
}
cnt--;
e = e->next;
} while (e != first);
} else if (T_HASH == type) {
const char *key = path;
const char *slash = strchr(path, '/');
int klen;
if (0 == slash) {
klen = (int)strlen(key);
path += klen;
} else {
klen = (int)(slash - key);
path += klen + 1;
}
do {
if (0 == strncmp(key, e->key, klen) && '\0' == e->key[klen]) {
lp++;
*lp = e;
leaf = get_leaf(stack, lp, path);
break;
}
e = e->next;
} while (e != first);
}
}
}
return leaf;
}
static void
each_leaf(Doc doc, VALUE self) {
if (COL_VAL == (*doc->where)->value_type) {
if (0 != (*doc->where)->elements) {
Leaf first = (*doc->where)->elements->next;
Leaf e = first;
doc->where++;
if (MAX_STACK <= doc->where - doc->where_path) {
rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
}
do {
*doc->where = e;
each_leaf(doc, self);
e = e->next;
} while (e != first);
doc->where--;
}
} else {
rb_yield(self);
}
}
static int
move_step(Doc doc, const char *path, int loc) {
if (MAX_STACK <= doc->where - doc->where_path) {
rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
}
if ('\0' == *path) {
loc = 0;
} else {
Leaf leaf;
if (0 == doc->where || 0 == (leaf = *doc->where)) {
printf("*** Internal error at %s\n", path);
return loc;
}
if ('.' == *path && '.' == *(path + 1)) {
Leaf init = *doc->where;
path += 2;
if (doc->where == doc->where_path) {
return loc;
}
if ('/' == *path) {
path++;
}
*doc->where = 0;
doc->where--;
loc = move_step(doc, path, loc + 1);
if (0 != loc) {
*doc->where = init;
doc->where++;
}
} else if (COL_VAL == leaf->value_type && 0 != leaf->elements) {
Leaf first = leaf->elements->next;
Leaf e = first;
if (T_ARRAY == leaf->rtype) {
int cnt = 0;
for (; '0' <= *path && *path <= '9'; path++) {
cnt = cnt * 10 + (*path - '0');
}
if ('/' == *path) {
path++;
} else if ('\0' != *path) {
return loc;
}
do {
if (1 >= cnt) {
doc->where++;
*doc->where = e;
loc = move_step(doc, path, loc + 1);
if (0 != loc) {
*doc->where = 0;
doc->where--;
}
break;
}
cnt--;
e = e->next;
} while (e != first);
} else if (T_HASH == leaf->rtype) {
const char *key = path;
const char *slash = strchr(path, '/');
int klen;
if (0 == slash) {
klen = (int)strlen(key);
path += klen;
} else {
klen = (int)(slash - key);
path += klen + 1;
}
do {
if (0 == strncmp(key, e->key, klen) && '\0' == e->key[klen]) {
doc->where++;
*doc->where = e;
loc = move_step(doc, path, loc + 1);
if (0 != loc) {
*doc->where = 0;
doc->where--;
}
break;
}
e = e->next;
} while (e != first);
}
}
}
return loc;
}
static void
each_value(Doc doc, Leaf leaf) {
if (COL_VAL == leaf->value_type) {
if (0 != leaf->elements) {
Leaf first = leaf->elements->next;
Leaf e = first;
do {
each_value(doc, e);
e = e->next;
} while (e != first);
}
} else {
rb_yield(leaf_value(doc, leaf));
}
}
// doc functions
/* call-seq: open(json) { |doc| ... } => Object
*
* Parses a JSON document String and then yields to the provided block if one
* is given with an instance of the Oj::Doc as the single yield parameter. If
* a block is not given then an Oj::Doc instance is returned and must be
* closed with a call to the #close() method when no longer needed.
*
* @param [String] json JSON document string
* @yieldparam [Oj::Doc] doc parsed JSON document
* @yieldreturn [Object] returns the result of the yield as the result of the method call
* @example
* Oj::Doc.open('[1,2,3]') { |doc| doc.size() } #=> 4
* # or as an alternative
* doc = Oj::Doc.open('[1,2,3]')
* doc.size() #=> 4
* doc.close()
*/
static VALUE
doc_open(VALUE clas, VALUE str) {
char *json;
size_t len;
VALUE obj;
int given = rb_block_given_p();
int allocate;
Check_Type(str, T_STRING);
len = RSTRING_LEN(str) + 1;
allocate = (SMALL_XML < len || !given);
if (allocate) {
json = ALLOC_N(char, len);
} else {
json = ALLOCA_N(char, len);
}
memcpy(json, StringValuePtr(str), len);
obj = parse_json(clas, json, given, allocate);
if (given && allocate) {
xfree(json);
}
return obj;
}
/* call-seq: open_file(filename) { |doc| ... } => Object
*
* Parses a JSON document from a file and then yields to the provided block if
* one is given with an instance of the Oj::Doc as the single yield
* parameter. If a block is not given then an Oj::Doc instance is returned and
* must be closed with a call to the #close() method when no longer needed.
*
* @param [String] filename name of file that contains a JSON document
* @yieldparam [Oj::Doc] doc parsed JSON document
* @yieldreturn [Object] returns the result of the yield as the result of the method call
* @example
* File.open('array.json', 'w') { |f| f.write('[1,2,3]') }
* Oj::Doc.open_file(filename) { |doc| doc.size() } #=> 4
* # or as an alternative
* doc = Oj::Doc.open_file(filename)
* doc.size() #=> 4
* doc.close()
*/
static VALUE
doc_open_file(VALUE clas, VALUE filename) {
char *path;
char *json;
FILE *f;
size_t len;
VALUE obj;
int given = rb_block_given_p();
int allocate;
Check_Type(filename, T_STRING);
path = StringValuePtr(filename);
if (0 == (f = fopen(path, "r"))) {
rb_raise(rb_eIOError, "%s", strerror(errno));
}
fseek(f, 0, SEEK_END);
len = ftell(f);
allocate = (SMALL_XML < len || !given);
if (allocate) {
json = ALLOC_N(char, len + 1);
} else {
json = ALLOCA_N(char, len + 1);
}
fseek(f, 0, SEEK_SET);
if (len != fread(json, 1, len, f)) {
fclose(f);
rb_raise(rb_const_get_at(Oj, rb_intern("LoadError")),
"Failed to read %lu bytes from %s.", (unsigned long)len, path);
}
fclose(f);
json[len] = '\0';
obj = parse_json(clas, json, given, allocate);
if (given && allocate) {
xfree(json);
}
return obj;
}
/* Document-method: parse
* @see Oj::Doc.open
*/
/* call-seq: where?() => String
*
* Returns a String that describes the absolute path to the current location
* in the JSON document.
*/
static VALUE
doc_where(VALUE self) {
Doc doc = self_doc(self);
if (0 == *doc->where_path || doc->where == doc->where_path) {
return oj_slash_string;
} else {
Leaf *lp;
Leaf leaf;
size_t size = 3; // leading / and terminating \0
char *path;
char *p;
for (lp = doc->where_path; lp <= doc->where; lp++) {
leaf = *lp;
if (T_HASH == leaf->parent_type) {
size += strlen((*lp)->key) + 1;
} else if (T_ARRAY == leaf->parent_type) {
size += ((*lp)->index < 100) ? 3 : 11;
}
}
path = ALLOCA_N(char, size);
p = path;
for (lp = doc->where_path; lp <= doc->where; lp++) {
leaf = *lp;
if (T_HASH == leaf->parent_type) {
p = stpcpy(p, (*lp)->key);
} else if (T_ARRAY == leaf->parent_type) {
p = ulong_fill(p, (*lp)->index);
}
*p++ = '/';
}
*--p = '\0';
return rb_str_new(path, p - path);
}
}
/* call-seq: local_key() => String, Fixnum, nil
*
* Returns the final key to the current location.
* @example
* Oj::Doc.open('[1,2,3]') { |doc| doc.move('/2'); doc.local_key() } #=> 2
* Oj::Doc.open('{"one":3}') { |doc| doc.move('/one'); doc.local_key() } #=> "one"
* Oj::Doc.open('[1,2,3]') { |doc| doc.local_key() } #=> nil
*/
static VALUE
doc_local_key(VALUE self) {
Doc doc = self_doc(self);
Leaf leaf = *doc->where;
VALUE key = Qnil;
if (T_HASH == leaf->parent_type) {
key = rb_str_new2(leaf->key);
key = oj_encode(key);
} else if (T_ARRAY == leaf->parent_type) {
key = LONG2NUM(leaf->index);
}
return key;
}
/* call-seq: home() => nil
*
* Moves the document marker or location to the hoot or home position. The
* same operation can be performed with a Oj::Doc.move('/').
* @example
* Oj::Doc.open('[1,2,3]') { |doc| doc.move('/2'); doc.home(); doc.where? } #=> '/'
*/
static VALUE
doc_home(VALUE self) {
Doc doc = self_doc(self);
*doc->where_path = doc->data;
doc->where = doc->where_path;
return oj_slash_string;
}
/* call-seq: type(path=nil) => Class
*
* Returns the Class of the data value at the location identified by the path
* or the current location if the path is nil or not provided. This method
* does not create the Ruby Object at the location specified so the overhead
* is low.
* @param [String] path path to the location to get the type of if provided
* @example
* Oj::Doc.open('[1,2]') { |doc| doc.type() } #=> Array
* Oj::Doc.open('[1,2]') { |doc| doc.type('/1') } #=> Fixnum
*/
static VALUE
doc_type(int argc, VALUE *argv, VALUE self) {
Doc doc = self_doc(self);
Leaf leaf;
const char *path = 0;
VALUE type = Qnil;
if (1 <= argc) {
Check_Type(*argv, T_STRING);
path = StringValuePtr(*argv);
}
if (0 != (leaf = get_doc_leaf(doc, path))) {
switch (leaf->rtype) {
case T_NIL: type = rb_cNilClass; break;
case T_TRUE: type = rb_cTrueClass; break;
case T_FALSE: type = rb_cFalseClass; break;
case T_STRING: type = rb_cString; break;
#ifdef RUBY_INTEGER_UNIFICATION
case T_FIXNUM: type = rb_cInteger; break;
#else
case T_FIXNUM: type = rb_cFixnum; break;
#endif
case T_FLOAT: type = rb_cFloat; break;
case T_ARRAY: type = rb_cArray; break;
case T_HASH: type = rb_cHash; break;
default: break;
}
}
return type;
}
/* call-seq: fetch(path=nil) => nil, true, false, Fixnum, Float, String, Array, Hash
*
* Returns the value at the location identified by the path or the current
* location if the path is nil or not provided. This method will create and
* return an Array or Hash if that is the type of Object at the location
* specified. This is more expensive than navigating to the leaves of the JSON
* document.
* @param [String] path path to the location to get the type of if provided
* @example
* Oj::Doc.open('[1,2]') { |doc| doc.fetch() } #=> [1, 2]
* Oj::Doc.open('[1,2]') { |doc| doc.fetch('/1') } #=> 1
*/
static VALUE
doc_fetch(int argc, VALUE *argv, VALUE self) {
Doc doc;
Leaf leaf;
VALUE val = Qnil;
const char *path = 0;
doc = self_doc(self);
if (1 <= argc) {
Check_Type(*argv, T_STRING);
path = StringValuePtr(*argv);
if (2 == argc) {
val = argv[1];
}
}
if (0 != (leaf = get_doc_leaf(doc, path))) {
val = leaf_value(doc, leaf);
}
return val;
}
/* call-seq: each_leaf(path=nil) => nil
*
* Yields to the provided block for each leaf node with the identified
* location of the JSON document as the root. The parameter passed to the
* block on yield is the Doc instance after moving to the child location.
* @param [String] path if provided it identified the top of the branch to process the leaves of
* @yieldparam [Doc] Doc at the child location
* @example
* Oj::Doc.open('[3,[2,1]]') { |doc|
* result = {}
* doc.each_leaf() { |d| result[d.where?] = d.fetch() }
* result
* }
* #=> ["/1" => 3, "/2/1" => 2, "/2/2" => 1]
*/
static VALUE
doc_each_leaf(int argc, VALUE *argv, VALUE self) {
if (rb_block_given_p()) {
Leaf save_path[MAX_STACK];
Doc doc = self_doc(self);
const char *path = 0;
size_t wlen;
wlen = doc->where - doc->where_path;
if (0 < wlen) {
memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
}
if (1 <= argc) {
Check_Type(*argv, T_STRING);
path = StringValuePtr(*argv);
if ('/' == *path) {
doc->where = doc->where_path;
path++;
}
if (0 != move_step(doc, path, 1)) {
if (0 < wlen) {
memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
}
return Qnil;
}
}
each_leaf(doc, self);
if (0 < wlen) {
memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
}
}
return Qnil;
}
/* call-seq: move(path) => nil
*
* Moves the document marker to the path specified. The path can an absolute
* path or a relative path.
* @param [String] path path to the location to move to
* @example
* Oj::Doc.open('{"one":[1,2]') { |doc| doc.move('/one/2'); doc.where? } #=> "/one/2"
*/
static VALUE
doc_move(VALUE self, VALUE str) {
Doc doc = self_doc(self);
const char *path;
int loc;
Check_Type(str, T_STRING);
path = StringValuePtr(str);
if ('/' == *path) {
doc->where = doc->where_path;
path++;
}
if (0 != (loc = move_step(doc, path, 1))) {
rb_raise(rb_eArgError, "Failed to locate element %d of the path %s.", loc, path);
}
return Qnil;
}
/* call-seq: each_child(path=nil) { |doc| ... } => nil
*
* Yields to the provided block for each immediate child node with the
* identified location of the JSON document as the root. The parameter passed
* to the block on yield is the Doc instance after moving to the child
* location.
* @param [String] path if provided it identified the top of the branch to process the chilren of
* @yieldparam [Doc] Doc at the child location
* @example
* Oj::Doc.open('[3,[2,1]]') { |doc|
* result = []
* doc.each_value('/2') { |doc| result << doc.where? }
* result
* }
* #=> ["/2/1", "/2/2"]
*/
static VALUE
doc_each_child(int argc, VALUE *argv, VALUE self) {
if (rb_block_given_p()) {
Leaf save_path[MAX_STACK];
Doc doc = self_doc(self);
const char *path = 0;
size_t wlen;
wlen = doc->where - doc->where_path;
if (0 < wlen) {
memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
}
if (1 <= argc) {
Check_Type(*argv, T_STRING);
path = StringValuePtr(*argv);
if ('/' == *path) {
doc->where = doc->where_path;
path++;
}
if (0 != move_step(doc, path, 1)) {
if (0 < wlen) {
memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
}
return Qnil;
}
}
if (COL_VAL == (*doc->where)->value_type && 0 != (*doc->where)->elements) {
Leaf first = (*doc->where)->elements->next;
Leaf e = first;
doc->where++;
do {
*doc->where = e;
rb_yield(self);
e = e->next;
} while (e != first);
}
if (0 < wlen) {
memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
}
}
return Qnil;
}
/* call-seq: each_value(path=nil) { |val| ... } => nil
*
* Yields to the provided block for each leaf value in the identified location
* of the JSON document. The parameter passed to the block on yield is the
* value of the leaf. Only those leaves below the element specified by the
* path parameter are processed.
* @param [String] path if provided it identified the top of the branch to process the leaf values of
* @yieldparam [Object] val each leaf value
* @example
* Oj::Doc.open('[3,[2,1]]') { |doc|
* result = []
* doc.each_value() { |v| result << v }
* result
* }
* #=> [3, 2, 1]
*
* Oj::Doc.open('[3,[2,1]]') { |doc|
* result = []
* doc.each_value('/2') { |v| result << v }
* result
* }
* #=> [2, 1]
*/
static VALUE
doc_each_value(int argc, VALUE *argv, VALUE self) {
if (rb_block_given_p()) {
Doc doc = self_doc(self);
const char *path = 0;
Leaf leaf;
if (1 <= argc) {
Check_Type(*argv, T_STRING);
path = StringValuePtr(*argv);
}
if (0 != (leaf = get_doc_leaf(doc, path))) {
each_value(doc, leaf);
}
}
return Qnil;
}
/* call-seq: dump(path=nil) => String
*
* Dumps the document or nodes to a new JSON document. It uses the default
* options for generating the JSON.
* @param [String] path if provided it identified the top of the branch to dump to JSON
* @param [String] filename if provided it is the filename to write the output to
* @example
* Oj::Doc.open('[3,[2,1]]') { |doc|
* doc.dump('/2')
* }
* #=> "[2,1]"
*/
static VALUE
doc_dump(int argc, VALUE *argv, VALUE self) {
Doc doc = self_doc(self);
Leaf leaf;
const char *path = 0;
const char *filename = 0;
if (1 <= argc) {
if (Qnil != *argv) {
Check_Type(*argv, T_STRING);
path = StringValuePtr(*argv);
}
if (2 <= argc) {
Check_Type(argv[1], T_STRING);
filename = StringValuePtr(argv[1]);
}
}
if (0 != (leaf = get_doc_leaf(doc, path))) {
VALUE rjson;
if (0 == filename) {
char buf[4096];
struct _Out out;
out.buf = buf;
out.end = buf + sizeof(buf) - 10;
out.allocated = 0;
out.omit_nil = oj_default_options.dump_opts.omit_nil;
oj_dump_leaf_to_json(leaf, &oj_default_options, &out);
rjson = rb_str_new2(out.buf);
if (out.allocated) {
xfree(out.buf);
}
} else {
oj_write_leaf_to_file(leaf, filename, &oj_default_options);
rjson = Qnil;
}
return rjson;
}
return Qnil;
}
/* call-seq: size() => Fixnum
*
* Returns the number of nodes in the JSON document where a node is any one of
* the basic JSON components.
* @return Returns the size of the JSON document.
* @example
* Oj::Doc.open('[1,2,3]') { |doc| doc.size() } #=> 4
*/
static VALUE
doc_size(VALUE self) {
return ULONG2NUM(((Doc)DATA_PTR(self))->size);
}
/* call-seq: close() => nil
*
* Closes an open document. No further calls to the document will be valid
* after closing.
* @example
* doc = Oj::Doc.open('[1,2,3]')
* doc.size() #=> 4
* doc.close()
*/
static VALUE
doc_close(VALUE self) {
Doc doc = self_doc(self);
rb_gc_unregister_address(&doc->self);
DATA_PTR(doc->self) = 0;
if (0 != doc) {
xfree(doc->json);
doc_free(doc);
xfree(doc);
}
return Qnil;
}
#if 0
// hack to keep the doc generator happy
Oj = rb_define_module("Oj");
#endif
static VALUE
doc_not_implemented(VALUE self) {
rb_raise(rb_eNotImpError, "Not implemented.");
return Qnil;
}
/* Document-class: Oj::Doc
*
* The Doc class is used to parse and navigate a JSON document. The model it
* employs is that of a document that while open can be navigated and values
* extracted. Once the document is closed the document can not longer be
* accessed. This allows the parsing and data extraction to be extremely fast
* compared to other JSON parses.
*
* An Oj::Doc class is not created directly but the _open()_ class method is
* used to open a document and the yield parameter to the block of the #open()
* call is the Doc instance. The Doc instance can be moved across, up, and
* down the JSON document. At each element the data associated with the
* element can be extracted. It is also possible to just provide a path to the
* data to be extracted and retrieve the data in that manner.
*
* For many of the methods a path is used to describe the location of an
* element. Paths follow a subset of the XPath syntax. The slash ('/')
* character is the separator. Each step in the path identifies the next
* branch to take through the document. A JSON object will expect a key string
* while an array will expect a positive index. A .. step indicates a move up
* the JSON document.
*
* @example
* json = %{[
* {
* "one" : 1,
* "two" : 2
* },
* {
* "three" : 3,
* "four" : 4
* }
* ]}
* # move and get value
* Oj::Doc.open(json) do |doc|
* doc.move('/1/two')
* # doc location is now at the 'two' element of the hash that is the first element of the array.
* doc.fetch()
* end
* #=> 2
*
* # Now try again using a path to Oj::Doc.fetch() directly and not using a block.
* doc = Oj::Doc.open(json)
* doc.fetch('/2/three') #=> 3
* doc.close()
*/
void
oj_init_doc() {
oj_doc_class = rb_define_class_under(Oj, "Doc", rb_cObject);
rb_define_singleton_method(oj_doc_class, "open", doc_open, 1);
rb_define_singleton_method(oj_doc_class, "open_file", doc_open_file, 1);
rb_define_singleton_method(oj_doc_class, "parse", doc_open, 1);
rb_define_method(oj_doc_class, "where?", doc_where, 0);
rb_define_method(oj_doc_class, "local_key", doc_local_key, 0);
rb_define_method(oj_doc_class, "home", doc_home, 0);
rb_define_method(oj_doc_class, "type", doc_type, -1);
rb_define_method(oj_doc_class, "fetch", doc_fetch, -1);
rb_define_method(oj_doc_class, "each_leaf", doc_each_leaf, -1);
rb_define_method(oj_doc_class, "move", doc_move, 1);
rb_define_method(oj_doc_class, "each_child", doc_each_child, -1);
rb_define_method(oj_doc_class, "each_value", doc_each_value, -1);
rb_define_method(oj_doc_class, "dump", doc_dump, -1);
rb_define_method(oj_doc_class, "size", doc_size, 0);
rb_define_method(oj_doc_class, "close", doc_close, 0);
rb_define_method(oj_doc_class, "clone", doc_not_implemented, 0);
rb_define_method(oj_doc_class, "dup", doc_not_implemented, 0);
}
oj-2.17.4/ext/oj/err.h 0000644 0000041 0000041 00000004714 12766161567 014445 0 ustar www-data www-data /* err.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_ERR_H__
#define __OJ_ERR_H__
#include "ruby.h"
#define set_error(err, eclas, msg, json, current) _oj_err_set_with_location(err, eclas, msg, json, current, __FILE__, __LINE__)
typedef struct _Err {
VALUE clas;
char msg[128];
} *Err;
extern VALUE oj_parse_error_class;
extern void oj_err_set(Err e, VALUE clas, const char *format, ...);
extern void _oj_err_set_with_location(Err err, VALUE eclas, const char *msg, const char *json, const char *current, const char* file, int line);
extern void oj_err_raise(Err e);
#define raise_error(msg, json, current) _oj_raise_error(msg, json, current, __FILE__, __LINE__)
extern void _oj_raise_error(const char *msg, const char *json, const char *current, const char* file, int line);
inline static void
err_init(Err e) {
e->clas = Qnil;
*e->msg = '\0';
}
inline static int
err_has(Err e) {
return (Qnil != e->clas);
}
#endif /* __OJ_ERR_H__ */
oj-2.17.4/ext/oj/sparse.c 0000644 0000041 0000041 00000051637 12766161567 015153 0 ustar www-data www-data /* parse.c
* Copyright (c) 2013, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include "oj.h"
#include "parse.h"
#include "buf.h"
#include "hash.h" // for oj_strndup()
#include "val_stack.h"
// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
#define OJ_INFINITY (1.0/0.0)
#ifdef RUBINIUS_RUBY
#define NUM_MAX 0x07FFFFFF
#else
#define NUM_MAX (FIXNUM_MAX >> 8)
#endif
#define EXP_MAX 100000
#define DEC_MAX 15
static void
skip_comment(ParseInfo pi) {
char c = reader_get(&pi->rd);
if ('*' == c) {
while ('\0' != (c = reader_get(&pi->rd))) {
if ('*' == c) {
c = reader_get(&pi->rd);
if ('/' == c) {
return;
}
}
}
} else if ('/' == c) {
while ('\0' != (c = reader_get(&pi->rd))) {
switch (c) {
case '\n':
case '\r':
case '\f':
case '\0':
return;
default:
break;
}
}
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid comment format");
}
if ('\0' == c) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "comment not terminated");
return;
}
}
static void
add_value(ParseInfo pi, VALUE rval) {
Val parent = stack_peek(&pi->stack);
if (0 == parent) { // simple add
pi->add_value(pi, rval);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_value(pi, rval);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_VALUE:
pi->hash_set_value(pi, parent, rval);
if (parent->kalloc) {
xfree((char*)parent->key);
}
parent->key = 0;
parent->kalloc = 0;
parent->next = NEXT_HASH_COMMA;
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
case NEXT_HASH_COMMA:
case NEXT_NONE:
case NEXT_ARRAY_COMMA:
case NEXT_HASH_COLON:
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s", oj_stack_next_string(parent->next));
break;
}
}
}
static void
add_num_value(ParseInfo pi, NumInfo ni) {
Val parent = stack_peek(&pi->stack);
if (0 == parent) {
pi->add_num(pi, ni);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_num(pi, ni);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_VALUE:
pi->hash_set_num(pi, parent, ni);
if (parent->kalloc) {
xfree((char*)parent->key);
}
parent->key = 0;
parent->kalloc = 0;
parent->next = NEXT_HASH_COMMA;
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s", oj_stack_next_string(parent->next));
break;
}
}
}
static void
read_true(ParseInfo pi) {
if (0 == reader_expect(&pi->rd, "rue")) {
add_value(pi, Qtrue);
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected true");
}
}
static void
read_false(ParseInfo pi) {
if (0 == reader_expect(&pi->rd, "alse")) {
add_value(pi, Qfalse);
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected false");
}
}
static uint32_t
read_hex(ParseInfo pi) {
uint32_t b = 0;
int i;
char c;
for (i = 0; i < 4; i++) {
c = reader_get(&pi->rd);
b = b << 4;
if ('0' <= c && c <= '9') {
b += c - '0';
} else if ('A' <= c && c <= 'F') {
b += c - 'A' + 10;
} else if ('a' <= c && c <= 'f') {
b += c - 'a' + 10;
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hex character");
return 0;
}
}
return b;
}
static void
unicode_to_chars(ParseInfo pi, Buf buf, uint32_t code) {
if (0x0000007F >= code) {
buf_append(buf, (char)code);
} else if (0x000007FF >= code) {
buf_append(buf, 0xC0 | (code >> 6));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x0000FFFF >= code) {
buf_append(buf, 0xE0 | (code >> 12));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x001FFFFF >= code) {
buf_append(buf, 0xF0 | (code >> 18));
buf_append(buf, 0x80 | ((code >> 12) & 0x3F));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x03FFFFFF >= code) {
buf_append(buf, 0xF8 | (code >> 24));
buf_append(buf, 0x80 | ((code >> 18) & 0x3F));
buf_append(buf, 0x80 | ((code >> 12) & 0x3F));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x7FFFFFFF >= code) {
buf_append(buf, 0xFC | (code >> 30));
buf_append(buf, 0x80 | ((code >> 24) & 0x3F));
buf_append(buf, 0x80 | ((code >> 18) & 0x3F));
buf_append(buf, 0x80 | ((code >> 12) & 0x3F));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid Unicode character");
}
}
// entered at backslash
static void
read_escaped_str(ParseInfo pi) {
struct _Buf buf;
char c;
uint32_t code;
Val parent = stack_peek(&pi->stack);
buf_init(&buf);
if (pi->rd.str < pi->rd.tail) {
buf_append_string(&buf, pi->rd.str, pi->rd.tail - pi->rd.str);
}
while ('\"' != (c = reader_get(&pi->rd))) {
if ('\0' == c) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
buf_cleanup(&buf);
return;
} else if ('\\' == c) {
c = reader_get(&pi->rd);
switch (c) {
case 'n': buf_append(&buf, '\n'); break;
case 'r': buf_append(&buf, '\r'); break;
case 't': buf_append(&buf, '\t'); break;
case 'f': buf_append(&buf, '\f'); break;
case 'b': buf_append(&buf, '\b'); break;
case '"': buf_append(&buf, '"'); break;
case '/': buf_append(&buf, '/'); break;
case '\\': buf_append(&buf, '\\'); break;
case 'u':
if (0 == (code = read_hex(pi)) && err_has(&pi->err)) {
buf_cleanup(&buf);
return;
}
if (0x0000D800 <= code && code <= 0x0000DFFF) {
uint32_t c1 = (code - 0x0000D800) & 0x000003FF;
uint32_t c2;
char ch2;
c = reader_get(&pi->rd);
ch2 = reader_get(&pi->rd);
if ('\\' != c || 'u' != ch2) {
if (Yes == pi->options.allow_invalid) {
unicode_to_chars(pi, &buf, code);
reader_backup(&pi->rd);
reader_backup(&pi->rd);
break;
}
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
buf_cleanup(&buf);
return;
}
if (0 == (c2 = read_hex(pi)) && err_has(&pi->err)) {
buf_cleanup(&buf);
return;
}
c2 = (c2 - 0x0000DC00) & 0x000003FF;
code = ((c1 << 10) | c2) + 0x00010000;
}
unicode_to_chars(pi, &buf, code);
if (err_has(&pi->err)) {
buf_cleanup(&buf);
return;
}
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
buf_cleanup(&buf);
return;
}
} else {
buf_append(&buf, c);
}
}
if (0 == parent) {
pi->add_cstr(pi, buf.head, buf_len(&buf), pi->rd.str);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_cstr(pi, buf.head, buf_len(&buf), pi->rd.str);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
if (Qundef == (parent->key_val = pi->hash_key(pi, buf.head, buf_len(&buf)))) {
parent->key = strdup(buf.head);
parent->klen = buf_len(&buf);
} else {
parent->key = "";
parent->klen = 0;
}
parent->k1 = *pi->rd.str;
parent->next = NEXT_HASH_COLON;
break;
case NEXT_HASH_VALUE:
pi->hash_set_cstr(pi, parent, buf.head, buf_len(&buf), pi->rd.str);
if (parent->kalloc) {
xfree((char*)parent->key);
}
parent->key = 0;
parent->kalloc = 0;
parent->next = NEXT_HASH_COMMA;
break;
case NEXT_HASH_COMMA:
case NEXT_NONE:
case NEXT_ARRAY_COMMA:
case NEXT_HASH_COLON:
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not a string", oj_stack_next_string(parent->next));
break;
}
}
buf_cleanup(&buf);
}
static void
read_str(ParseInfo pi) {
Val parent = stack_peek(&pi->stack);
char c;
reader_protect(&pi->rd);
while ('\"' != (c = reader_get(&pi->rd))) {
if ('\0' == c) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
return;
} else if ('\\' == c) {
reader_backup(&pi->rd);
read_escaped_str(pi);
reader_release(&pi->rd);
return;
}
}
if (0 == parent) { // simple add
pi->add_cstr(pi, pi->rd.str, pi->rd.tail - pi->rd.str - 1, pi->rd.str);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_cstr(pi, pi->rd.str, pi->rd.tail - pi->rd.str - 1, pi->rd.str);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
parent->klen = pi->rd.tail - pi->rd.str - 1;
if (sizeof(parent->karray) <= parent->klen) {
parent->key = oj_strndup(pi->rd.str, parent->klen);
parent->kalloc = 1;
} else {
memcpy(parent->karray, pi->rd.str, parent->klen);
parent->karray[parent->klen] = '\0';
parent->key = parent->karray;
parent->kalloc = 0;
}
parent->key_val = pi->hash_key(pi, parent->key, parent->klen);
parent->k1 = *pi->rd.str;
parent->next = NEXT_HASH_COLON;
break;
case NEXT_HASH_VALUE:
pi->hash_set_cstr(pi, parent, pi->rd.str, pi->rd.tail - pi->rd.str - 1, pi->rd.str);
if (parent->kalloc) {
xfree((char*)parent->key);
}
parent->key = 0;
parent->kalloc = 0;
parent->next = NEXT_HASH_COMMA;
break;
case NEXT_HASH_COMMA:
case NEXT_NONE:
case NEXT_ARRAY_COMMA:
case NEXT_HASH_COLON:
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not a string", oj_stack_next_string(parent->next));
break;
}
}
reader_release(&pi->rd);
}
static void
read_num(ParseInfo pi) {
struct _NumInfo ni;
char c;
reader_protect(&pi->rd);
ni.i = 0;
ni.num = 0;
ni.div = 1;
ni.di = 0;
ni.len = 0;
ni.exp = 0;
ni.big = 0;
ni.infinity = 0;
ni.nan = 0;
ni.neg = 0;
ni.hasExp = 0;
ni.no_big = (FloatDec == pi->options.bigdec_load);
c = reader_get(&pi->rd);
if ('-' == c) {
c = reader_get(&pi->rd);
ni.neg = 1;
} else if ('+' == c) {
c = reader_get(&pi->rd);
}
if ('I' == c) {
if (0 != reader_expect(&pi->rd, "nfinity")) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
return;
}
ni.infinity = 1;
} else {
int dec_cnt = 0;
for (; '0' <= c && c <= '9'; c = reader_get(&pi->rd)) {
if (0 < ni.i) {
dec_cnt++;
}
if (ni.big) {
ni.big++;
} else {
int d = (c - '0');
ni.i = ni.i * 10 + d;
if (INT64_MAX <= ni.i || DEC_MAX < dec_cnt) {
ni.big = 1;
}
}
}
if ('.' == c) {
c = reader_get(&pi->rd);
for (; '0' <= c && c <= '9'; c = reader_get(&pi->rd)) {
int d = (c - '0');
if (0 < ni.num || 0 < ni.i) {
dec_cnt++;
}
ni.num = ni.num * 10 + d;
ni.div *= 10;
ni.di++;
if (INT64_MAX <= ni.div || DEC_MAX < dec_cnt) {
ni.big = 1;
}
}
}
if ('e' == c || 'E' == c) {
int eneg = 0;
ni.hasExp = 1;
c = reader_get(&pi->rd);
if ('-' == c) {
c = reader_get(&pi->rd);
eneg = 1;
} else if ('+' == c) {
c = reader_get(&pi->rd);
}
for (; '0' <= c && c <= '9'; c = reader_get(&pi->rd)) {
ni.exp = ni.exp * 10 + (c - '0');
if (EXP_MAX <= ni.exp) {
ni.big = 1;
}
}
if (eneg) {
ni.exp = -ni.exp;
}
}
ni.len = pi->rd.tail - pi->rd.str;
if (0 != c) {
reader_backup(&pi->rd);
}
}
ni.str = pi->rd.str;
ni.len = pi->rd.tail - pi->rd.str;
// Check for special reserved values for Infinity and NaN.
if (ni.big) {
if (0 == strcasecmp(INF_VAL, ni.str)) {
ni.infinity = 1;
} else if (0 == strcasecmp(NINF_VAL, ni.str)) {
ni.infinity = 1;
ni.neg = 1;
} else if (0 == strcasecmp(NAN_VAL, ni.str)) {
ni.nan = 1;
}
}
if (BigDec == pi->options.bigdec_load) {
ni.big = 1;
}
add_num_value(pi, &ni);
reader_release(&pi->rd);
}
static void
read_nan(ParseInfo pi) {
struct _NumInfo ni;
char c;
ni.str = pi->rd.str;
ni.i = 0;
ni.num = 0;
ni.div = 1;
ni.di = 0;
ni.len = 0;
ni.exp = 0;
ni.big = 0;
ni.infinity = 0;
ni.nan = 1;
ni.neg = 0;
ni.no_big = (FloatDec == pi->options.bigdec_load);
if ('a' != reader_get(&pi->rd) ||
('N' != (c = reader_get(&pi->rd)) && 'n' != c)) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
return;
}
if (BigDec == pi->options.bigdec_load) {
ni.big = 1;
}
add_num_value(pi, &ni);
}
static void
array_start(ParseInfo pi) {
VALUE v = pi->start_array(pi);
stack_push(&pi->stack, v, NEXT_ARRAY_NEW);
}
static void
array_end(ParseInfo pi) {
Val array = stack_pop(&pi->stack);
if (0 == array) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected array close");
} else if (NEXT_ARRAY_COMMA != array->next && NEXT_ARRAY_NEW != array->next) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not an array close", oj_stack_next_string(array->next));
} else {
pi->end_array(pi);
add_value(pi, array->val);
}
}
static void
hash_start(ParseInfo pi) {
volatile VALUE v = pi->start_hash(pi);
stack_push(&pi->stack, v, NEXT_HASH_NEW);
}
static void
hash_end(ParseInfo pi) {
volatile Val hash = stack_peek(&pi->stack);
// leave hash on stack until just before
if (0 == hash) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected hash close");
} else if (NEXT_HASH_COMMA != hash->next && NEXT_HASH_NEW != hash->next) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not a hash close", oj_stack_next_string(hash->next));
} else {
pi->end_hash(pi);
stack_pop(&pi->stack);
add_value(pi, hash->val);
}
}
static void
comma(ParseInfo pi) {
Val parent = stack_peek(&pi->stack);
if (0 == parent) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected comma");
} else if (NEXT_ARRAY_COMMA == parent->next) {
parent->next = NEXT_ARRAY_ELEMENT;
} else if (NEXT_HASH_COMMA == parent->next) {
parent->next = NEXT_HASH_KEY;
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected comma");
}
}
static void
colon(ParseInfo pi) {
Val parent = stack_peek(&pi->stack);
if (0 != parent && NEXT_HASH_COLON == parent->next) {
parent->next = NEXT_HASH_VALUE;
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected colon");
}
}
void
oj_sparse2(ParseInfo pi) {
int first = 1;
char c;
err_init(&pi->err);
while (1) {
c = reader_next_non_white(&pi->rd);
if (!first && '\0' != c) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected characters after the JSON document");
}
switch (c) {
case '{':
hash_start(pi);
break;
case '}':
hash_end(pi);
break;
case ':':
colon(pi);
break;
case '[':
array_start(pi);
break;
case ']':
array_end(pi);
break;
case ',':
comma(pi);
break;
case '"':
read_str(pi);
break;
case '+':
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'I':
reader_backup(&pi->rd);
read_num(pi);
break;
case 'N':
read_nan(pi);
break;
case 't':
read_true(pi);
break;
case 'f':
read_false(pi);
break;
case 'n':
c = reader_get(&pi->rd);
if ('u' == c) {
if (0 == reader_expect(&pi->rd, "ll")) {
add_value(pi, Qnil);
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected null");
return;
}
} else if ('a' == c) {
struct _NumInfo ni;
c = reader_get(&pi->rd);
if ('N' != c && 'n' != c) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected NaN");
return;
}
ni.str = pi->rd.str;
ni.i = 0;
ni.num = 0;
ni.div = 1;
ni.di = 0;
ni.len = 0;
ni.exp = 0;
ni.big = 0;
ni.infinity = 0;
ni.nan = 1;
ni.neg = 0;
ni.no_big = (FloatDec == pi->options.bigdec_load);
add_num_value(pi, &ni);
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid token");
return;
}
break;
case '/':
skip_comment(pi);
break;
case '\0':
return;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
return;
}
if (err_has(&pi->err)) {
return;
}
if (stack_empty(&pi->stack)) {
if (Qundef != pi->proc) {
if (Qnil == pi->proc) {
rb_yield(stack_head_val(&pi->stack));
} else {
#if HAS_PROC_WITH_BLOCK
VALUE args[1];
*args = stack_head_val(&pi->stack);
rb_proc_call_with_block(pi->proc, 1, args, Qnil);
#else
oj_set_error_at(pi, rb_eNotImpError, __FILE__, __LINE__,
"Calling a Proc with a block not supported in this version. Use func() {|x| } syntax instead.");
return;
#endif
}
} else {
first = 0;
}
}
}
}
static VALUE
protect_parse(VALUE pip) {
oj_sparse2((ParseInfo)pip);
return Qnil;
}
VALUE
oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd) {
volatile VALUE input;
volatile VALUE wrapped_stack;
VALUE result = Qnil;
int line = 0;
if (argc < 1) {
rb_raise(rb_eArgError, "Wrong number of arguments to parse.");
}
input = argv[0];
if (2 == argc) {
oj_parse_options(argv[1], &pi->options);
}
if (Qnil == input && Yes == pi->options.nilnil) {
return Qnil;
}
if (rb_block_given_p()) {
pi->proc = Qnil;
} else {
pi->proc = Qundef;
}
oj_reader_init(&pi->rd, input, fd);
pi->json = 0; // indicates reader is in use
if (Yes == pi->options.circular) {
pi->circ_array = oj_circ_array_new();
} else {
pi->circ_array = 0;
}
if (No == pi->options.allow_gc) {
rb_gc_disable();
}
// GC can run at any time. When it runs any Object created by C will be
// freed. We protect against this by wrapping the value stack in a ruby
// data object and poviding a mark function for ruby objects on the
// value stack (while it is in scope).
wrapped_stack = oj_stack_init(&pi->stack);
rb_protect(protect_parse, (VALUE)pi, &line);
result = stack_head_val(&pi->stack);
DATA_PTR(wrapped_stack) = 0;
if (No == pi->options.allow_gc) {
rb_gc_enable();
}
if (!err_has(&pi->err)) {
// If the stack is not empty then the JSON terminated early.
Val v;
if (0 != (v = stack_peek(&pi->stack))) {
switch (v->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
case NEXT_ARRAY_COMMA:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Array not terminated");
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
case NEXT_HASH_COLON:
case NEXT_HASH_VALUE:
case NEXT_HASH_COMMA:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Hash/Object not terminated");
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not terminated");
}
}
}
// proceed with cleanup
if (0 != pi->circ_array) {
oj_circ_array_free(pi->circ_array);
}
stack_cleanup(&pi->stack);
if (0 != fd) {
close(fd);
}
if (0 != line) {
rb_jump_tag(line);
}
if (err_has(&pi->err)) {
if (Qnil != pi->err_class) {
pi->err.clas = pi->err_class;
}
oj_err_raise(&pi->err);
}
return result;
}
oj-2.17.4/ext/oj/hash.c 0000644 0000041 0000041 00000010165 12766161567 014570 0 ustar www-data www-data /* hash.c
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "hash.h"
#include
#define HASH_MASK 0x000003FF
#define HASH_SLOT_CNT 1024
typedef struct _KeyVal {
struct _KeyVal *next;
const char *key;
size_t len;
VALUE val;
} *KeyVal;
struct _Hash {
struct _KeyVal slots[HASH_SLOT_CNT];
};
struct _Hash class_hash;
struct _Hash intern_hash;
// almost the Murmur hash algorithm
#define M 0x5bd1e995
#define C1 0xCC9E2D51
#define C2 0x1B873593
#define N 0xE6546B64
static uint32_t
hash_calc(const uint8_t *key, size_t len) {
const uint8_t *end = key + len;
const uint8_t *endless = key + (len / 4 * 4);
uint32_t h = (uint32_t)len;
uint32_t k;
while (key < endless) {
k = (uint32_t)*key++;
k |= (uint32_t)*key++ << 8;
k |= (uint32_t)*key++ << 16;
k |= (uint32_t)*key++ << 24;
k *= M;
k ^= k >> 24;
h *= M;
h ^= k * M;
}
if (1 < end - key) {
uint16_t k16 = (uint16_t)*key++;
k16 |= (uint16_t)*key++ << 8;
h ^= k16 << 8;
}
if (key < end) {
h ^= *key;
}
h *= M;
h ^= h >> 13;
h *= M;
h ^= h >> 15;
return h;
}
void
oj_hash_init() {
memset(class_hash.slots, 0, sizeof(class_hash.slots));
memset(intern_hash.slots, 0, sizeof(intern_hash.slots));
}
// if slotp is 0 then just lookup
static VALUE
hash_get(Hash hash, const char *key, size_t len, VALUE **slotp, VALUE def_value) {
uint32_t h = hash_calc((const uint8_t*)key, len) & HASH_MASK;
KeyVal bucket = hash->slots + h;
if (0 != bucket->key) {
KeyVal b;
for (b = bucket; 0 != b; b = b->next) {
if (len == b->len && 0 == strncmp(b->key, key, len)) {
*slotp = &b->val;
return b->val;
}
bucket = b;
}
}
if (0 != slotp) {
if (0 != bucket->key) {
KeyVal b = ALLOC(struct _KeyVal);
b->next = 0;
bucket->next = b;
bucket = b;
}
bucket->key = oj_strndup(key, len);
bucket->len = len;
bucket->val = def_value;
*slotp = &bucket->val;
}
return def_value;
}
void
oj_hash_print() {
int i;
KeyVal b;
for (i = 0; i < HASH_SLOT_CNT; i++) {
printf("%4d:", i);
for (b = class_hash.slots + i; 0 != b && 0 != b->key; b = b->next) {
printf(" %s", b->key);
}
printf("\n");
}
}
VALUE
oj_class_hash_get(const char *key, size_t len, VALUE **slotp) {
return hash_get(&class_hash, key, len, slotp, Qnil);
}
ID
oj_attr_hash_get(const char *key, size_t len, ID **slotp) {
return (ID)hash_get(&intern_hash, key, len, (VALUE**)slotp, 0);
}
char*
oj_strndup(const char *s, size_t len) {
char *d = ALLOC_N(char, len + 1);
memcpy(d, s, len);
d[len] = '\0';
return d;
}
oj-2.17.4/ext/oj/err.c 0000644 0000041 0000041 00000005331 12766161567 014434 0 ustar www-data www-data /* err.c
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include "err.h"
void
oj_err_set(Err e, VALUE clas, const char *format, ...) {
va_list ap;
va_start(ap, format);
e->clas = clas;
vsnprintf(e->msg, sizeof(e->msg) - 1, format, ap);
va_end(ap);
}
void
oj_err_raise(Err e) {
rb_raise(e->clas, "%s", e->msg);
}
void
_oj_err_set_with_location(Err err, VALUE eclas, const char *msg, const char *json, const char *current, const char* file, int line) {
int n = 1;
int col = 1;
for (; json < current && '\n' != *current; current--) {
col++;
}
for (; json < current; current--) {
if ('\n' == *current) {
n++;
}
}
oj_err_set(err, eclas, "%s at line %d, column %d [%s:%d]", msg, n, col, file, line);
}
void
_oj_raise_error(const char *msg, const char *json, const char *current, const char* file, int line) {
struct _Err err;
int n = 1;
int col = 1;
for (; json < current && '\n' != *current; current--) {
col++;
}
for (; json < current; current--) {
if ('\n' == *current) {
n++;
}
}
oj_err_set(&err, oj_parse_error_class, "%s at line %d, column %d [%s:%d]", msg, n, col, file, line);
rb_raise(err.clas, "%s", err.msg);
}
oj-2.17.4/ext/oj/cache8.c 0000644 0000041 0000041 00000004165 12766161567 015003 0 ustar www-data www-data
#include
#include
#include
#include
#include
#include "ruby.h"
#include "cache8.h"
#define BITS 4
#define MASK 0x000000000000000FULL
#define SLOT_CNT 16
#define DEPTH 16
typedef union {
struct _Cache8 *child;
slot_t value;
} Bucket;
struct _Cache8 {
Bucket buckets[SLOT_CNT];
};
static void cache8_delete(Cache8 cache, int depth);
static void slot_print(Cache8 cache, sid_t key, unsigned int depth);
void
oj_cache8_new(Cache8 *cache) {
Bucket *b;
int i;
*cache = ALLOC(struct _Cache8);
for (i = SLOT_CNT, b = (*cache)->buckets; 0 < i; i--, b++) {
b->value = 0;
}
}
void
oj_cache8_delete(Cache8 cache) {
cache8_delete(cache, 0);
}
static void
cache8_delete(Cache8 cache, int depth) {
Bucket *b;
unsigned int i;
for (i = 0, b = cache->buckets; i < SLOT_CNT; i++, b++) {
if (0 != b->child) {
if (DEPTH - 1 != depth) {
cache8_delete(b->child, depth + 1);
}
}
}
xfree(cache);
}
slot_t
oj_cache8_get(Cache8 cache, sid_t key, slot_t **slot) {
Bucket *b;
int i;
sid_t k8 = (sid_t)key;
sid_t k;
for (i = 64 - BITS; 0 < i; i -= BITS) {
k = (k8 >> i) & MASK;
b = cache->buckets + k;
if (0 == b->child) {
oj_cache8_new(&b->child);
}
cache = b->child;
}
*slot = &(cache->buckets + (k8 & MASK))->value;
return **slot;
}
void
oj_cache8_print(Cache8 cache) {
/*printf("-------------------------------------------\n"); */
slot_print(cache, 0, 0);
}
static void
slot_print(Cache8 c, sid_t key, unsigned int depth) {
Bucket *b;
unsigned int i;
sid_t k8 = (sid_t)key;
sid_t k;
for (i = 0, b = c->buckets; i < SLOT_CNT; i++, b++) {
if (0 != b->child) {
k = (k8 << BITS) | i;
/*printf("*** key: 0x%016llx depth: %u i: %u\n", k, depth, i); */
if (DEPTH - 1 == depth) {
#if IS_WINDOWS
printf("0x%016lx: %4lu\n", (long unsigned int)k, (long unsigned int)b->value);
#else
printf("0x%016llx: %4llu\n", (long long unsigned int)k, (long long unsigned int)b->value);
#endif
} else {
slot_print(b->child, k, depth + 1);
}
}
}
}
oj-2.17.4/ext/oj/val_stack.h 0000644 0000041 0000041 00000011400 12766161567 015612 0 ustar www-data www-data /* val_stack.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_VAL_STACK_H__
#define __OJ_VAL_STACK_H__
#include "ruby.h"
#include "odd.h"
#include
#if USE_PTHREAD_MUTEX
#include
#endif
#define STACK_INC 64
typedef enum {
NEXT_NONE = 0,
NEXT_ARRAY_NEW = 'a',
NEXT_ARRAY_ELEMENT = 'e',
NEXT_ARRAY_COMMA = ',',
NEXT_HASH_NEW = 'h',
NEXT_HASH_KEY = 'k',
NEXT_HASH_COLON = ':',
NEXT_HASH_VALUE = 'v',
NEXT_HASH_COMMA = 'n',
} ValNext;
typedef struct _Val {
volatile VALUE val;
const char *key;
char karray[32];
volatile VALUE key_val;
union {
const char *classname;
OddArgs odd_args;
};
uint16_t klen;
uint16_t clen;
char next; // ValNext
char k1; // first original character in the key
char kalloc;
} *Val;
typedef struct _ValStack {
struct _Val base[STACK_INC];
Val head; // current stack
Val end; // stack end
Val tail; // pointer to one past last element name on stack
#if USE_PTHREAD_MUTEX
pthread_mutex_t mutex;
#elif USE_RB_MUTEX
VALUE mutex;
#endif
} *ValStack;
extern VALUE oj_stack_init(ValStack stack);
inline static int
stack_empty(ValStack stack) {
return (stack->head == stack->tail);
}
inline static void
stack_cleanup(ValStack stack) {
if (stack->base != stack->head) {
xfree(stack->head);
}
}
inline static void
stack_push(ValStack stack, VALUE val, ValNext next) {
if (stack->end <= stack->tail) {
size_t len = stack->end - stack->head;
size_t toff = stack->tail - stack->head;
Val head = stack->head;
// A realloc can trigger a GC so make sure it happens outside the lock
// but lock before changing pointers.
if (stack->base == stack->head) {
head = ALLOC_N(struct _Val, len + STACK_INC);
memcpy(head, stack->base, sizeof(struct _Val) * len);
} else {
REALLOC_N(head, struct _Val, len + STACK_INC);
}
#if USE_PTHREAD_MUTEX
pthread_mutex_lock(&stack->mutex);
#elif USE_RB_MUTEX
rb_mutex_lock(stack->mutex);
#endif
stack->head = head;
stack->tail = stack->head + toff;
stack->end = stack->head + len + STACK_INC;
#if USE_PTHREAD_MUTEX
pthread_mutex_unlock(&stack->mutex);
#elif USE_RB_MUTEX
rb_mutex_unlock(stack->mutex);
#endif
}
stack->tail->val = val;
stack->tail->next = next;
stack->tail->classname = 0;
stack->tail->key = 0;
stack->tail->key_val = Qundef;
stack->tail->clen = 0;
stack->tail->klen = 0;
stack->tail->kalloc = 0;
stack->tail++;
}
inline static size_t
stack_size(ValStack stack) {
return stack->tail - stack->head;
}
inline static Val
stack_peek(ValStack stack) {
if (stack->head < stack->tail) {
return stack->tail - 1;
}
return 0;
}
inline static Val
stack_peek_up(ValStack stack) {
if (stack->head < stack->tail - 1) {
return stack->tail - 2;
}
return 0;
}
inline static Val
stack_prev(ValStack stack) {
return stack->tail;
}
inline static VALUE
stack_head_val(ValStack stack) {
if (Qundef != stack->head->val) {
return stack->head->val;
}
return Qnil;
}
inline static Val
stack_pop(ValStack stack) {
if (stack->head < stack->tail) {
stack->tail--;
return stack->tail;
}
return 0;
}
extern const char* oj_stack_next_string(ValNext n);
#endif /* __OJ_VAL_STACK_H__ */
oj-2.17.4/ext/oj/hash_test.c 0000644 0000041 0000041 00000040025 12766161567 015625 0 ustar www-data www-data /* hash_test.c
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// if windows, comment out the whole file. It's only a performance test.
#ifndef _WIN32
#include
#include
#include "hash.h"
#include
/* Define printf formats for standard types, like PRIu64 for uint64_t. */
#define __STDC_FORMAT_MACROS
#include
typedef struct _StrLen {
const char *str;
size_t len;
} *StrLen;
static struct _StrLen data[] = {
{ "Gem::Version", 12 },
{ "TracePoint", 10 },
{ "Complex::compatible", 19 },
{ "Complex", 7 },
{ "Rational::compatible", 20 },
{ "Rational", 8 },
{ "FiberError", 10 },
{ "Fiber", 5 },
{ "ThreadError", 11 },
{ "Mutex", 5 },
{ "ThreadGroup", 11 },
{ "RubyVM::InstructionSequence", 27 },
{ "Thread::Backtrace::Location", 27 },
{ "Thread::Backtrace", 17 },
{ "Thread", 6 },
{ "RubyVM::Env", 11 },
{ "RubyVM", 6 },
{ "Enumerator::Yielder", 19 },
{ "Enumerator::Generator", 21 },
{ "StopIteration", 13 },
{ "Enumerator::Lazy", 16 },
{ "Enumerator", 10 },
{ "ObjectSpace::WeakMap", 20 },
{ "Math::DomainError", 17 },
{ "Binding", 7 },
{ "UnboundMethod", 13 },
{ "Method", 6 },
{ "SystemStackError", 16 },
{ "LocalJumpError", 14 },
{ "Proc", 4 },
{ "Struct::Tms", 11 },
{ "Process::Status", 15 },
{ "Random", 6 },
{ "Time", 4 },
{ "Dir", 3 },
{ "File::Stat", 10 },
{ "File", 4 },
{ "ARGF.class", 10 },
{ "IO", 2 },
{ "EOFError", 8 },
{ "IOError", 7 },
{ "Range", 5 },
{ "Encoding::Converter", 19 },
{ "Encoding::ConverterNotFoundError", 32 },
{ "Encoding::InvalidByteSequenceError", 34 },
{ "Encoding::UndefinedConversionError", 34 },
{ "MatchData", 9 },
{ "Regexp", 6 },
{ "RegexpError", 11 },
{ "Struct", 6 },
{ "Hash", 4 },
{ "Array", 5 },
{ "Errno::ERPCMISMATCH", 19 },
{ "Errno::EPROGUNAVAIL", 19 },
{ "Errno::EPROGMISMATCH", 20 },
{ "Errno::EPROCUNAVAIL", 19 },
{ "Errno::EPROCLIM", 15 },
{ "Errno::ENOTSUP", 14 },
{ "Errno::ENOATTR", 14 },
{ "Errno::ENEEDAUTH", 16 },
{ "Errno::EFTYPE", 13 },
{ "Errno::EBADRPC", 14 },
{ "Errno::EAUTH", 12 },
{ "Errno::EOWNERDEAD", 17 },
{ "Errno::ENOTRECOVERABLE", 22 },
{ "Errno::ECANCELED", 16 },
{ "Errno::EDQUOT", 13 },
{ "Errno::ESTALE", 13 },
{ "Errno::EINPROGRESS", 18 },
{ "Errno::EALREADY", 15 },
{ "Errno::EHOSTUNREACH", 19 },
{ "Errno::EHOSTDOWN", 16 },
{ "Errno::ECONNREFUSED", 19 },
{ "Errno::ETIMEDOUT", 16 },
{ "Errno::ETOOMANYREFS", 19 },
{ "Errno::ESHUTDOWN", 16 },
{ "Errno::ENOTCONN", 15 },
{ "Errno::EISCONN", 14 },
{ "Errno::ENOBUFS", 14 },
{ "Errno::ECONNRESET", 17 },
{ "Errno::ECONNABORTED", 19 },
{ "Errno::ENETRESET", 16 },
{ "Errno::ENETUNREACH", 18 },
{ "Errno::ENETDOWN", 15 },
{ "Errno::EADDRNOTAVAIL", 20 },
{ "Errno::EADDRINUSE", 17 },
{ "Errno::EAFNOSUPPORT", 19 },
{ "Errno::EPFNOSUPPORT", 19 },
{ "Errno::EOPNOTSUPP", 17 },
{ "Errno::ESOCKTNOSUPPORT", 22 },
{ "Errno::EPROTONOSUPPORT", 22 },
{ "Errno::ENOPROTOOPT", 18 },
{ "Errno::EPROTOTYPE", 17 },
{ "Errno::EMSGSIZE", 15 },
{ "Errno::EDESTADDRREQ", 19 },
{ "Errno::ENOTSOCK", 15 },
{ "Errno::EUSERS", 13 },
{ "Errno::EILSEQ", 13 },
{ "Errno::EOVERFLOW", 16 },
{ "Errno::EBADMSG", 14 },
{ "Errno::EMULTIHOP", 16 },
{ "Errno::EPROTO", 13 },
{ "Errno::ENOLINK", 14 },
{ "Errno::EREMOTE", 14 },
{ "Errno::ENOSR", 12 },
{ "Errno::ETIME", 12 },
{ "Errno::ENODATA", 14 },
{ "Errno::ENOSTR", 13 },
{ "Errno::EIDRM", 12 },
{ "Errno::ENOMSG", 13 },
{ "Errno::ELOOP", 12 },
{ "Errno::ENOTEMPTY", 16 },
{ "Errno::ENOSYS", 13 },
{ "Errno::ENOLCK", 13 },
{ "Errno::ENAMETOOLONG", 19 },
{ "Errno::EDEADLK", 14 },
{ "Errno::ERANGE", 13 },
{ "Errno::EDOM", 11 },
{ "Errno::EPIPE", 12 },
{ "Errno::EMLINK", 13 },
{ "Errno::EROFS", 12 },
{ "Errno::ESPIPE", 13 },
{ "Errno::ENOSPC", 13 },
{ "Errno::EFBIG", 12 },
{ "Errno::ETXTBSY", 14 },
{ "Errno::ENOTTY", 13 },
{ "Errno::EMFILE", 13 },
{ "Errno::ENFILE", 13 },
{ "Errno::EINVAL", 13 },
{ "Errno::EISDIR", 13 },
{ "Errno::ENOTDIR", 14 },
{ "Errno::ENODEV", 13 },
{ "Errno::EXDEV", 12 },
{ "Errno::EEXIST", 13 },
{ "Errno::EBUSY", 12 },
{ "Errno::ENOTBLK", 14 },
{ "Errno::EFAULT", 13 },
{ "Errno::EACCES", 13 },
{ "Errno::ENOMEM", 13 },
{ "Errno::EAGAIN", 13 },
{ "Errno::ECHILD", 13 },
{ "Errno::EBADF", 12 },
{ "Errno::ENOEXEC", 14 },
{ "Errno::E2BIG", 12 },
{ "Errno::ENXIO", 12 },
{ "Errno::EIO", 10 },
{ "Errno::EINTR", 12 },
{ "Errno::ESRCH", 12 },
{ "Errno::ENOENT", 13 },
{ "Errno::EPERM", 12 },
{ "Errno::NOERROR", 14 },
{ "Bignum", 6 },
{ "Float", 5 },
{ "Fixnum", 6 },
{ "Integer", 7 },
{ "Numeric", 7 },
{ "FloatDomainError", 16 },
{ "ZeroDivisionError", 17 },
{ "SystemCallError", 15 },
{ "Encoding::CompatibilityError", 28 },
{ "EncodingError", 13 },
{ "NoMemoryError", 13 },
{ "SecurityError", 13 },
{ "RuntimeError", 12 },
{ "NoMethodError", 13 },
{ "NameError::message", 18 },
{ "NameError", 9 },
{ "NotImplementedError", 19 },
{ "LoadError", 9 },
{ "SyntaxError", 11 },
{ "ScriptError", 11 },
{ "RangeError", 10 },
{ "KeyError", 8 },
{ "IndexError", 10 },
{ "ArgumentError", 13 },
{ "TypeError", 9 },
{ "StandardError", 13 },
{ "Interrupt", 9 },
{ "SignalException", 15 },
{ "SystemExit", 10 },
{ "Exception", 9 },
{ "Symbol", 6 },
{ "String", 6 },
{ "Encoding", 8 },
{ "FalseClass", 10 },
{ "TrueClass", 9 },
{ "Data", 4 },
{ "NilClass", 8 },
{ "Class", 5 },
{ "Module", 6 },
{ "Object", 6 },
{ "BasicObject", 11 },
{ "Gem::Requirement::BadRequirementError", 37 },
{ "Gem::Requirement", 16 },
{ "Gem::SourceFetchProblem", 23 },
{ "Gem::PlatformMismatch", 21 },
{ "Gem::ErrorReason", 16 },
{ "Gem::LoadError", 14 },
{ "Gem::RemoteSourceException", 26 },
{ "Gem::RemoteInstallationSkipped", 30 },
{ "Gem::RemoteInstallationCancelled", 32 },
{ "Gem::RemoteError", 16 },
{ "Gem::OperationNotSupportedError", 31 },
{ "Gem::InvalidSpecificationException", 34 },
{ "Gem::InstallError", 17 },
{ "Gem::Specification", 18 },
{ "Date", 4 },
{ "Gem::Platform", 13 },
{ "Gem::SpecificGemNotFoundException", 33 },
{ "Gem::GemNotFoundException", 25 },
{ "Gem::FormatException", 20 },
{ "Gem::FilePermissionError", 24 },
{ "Gem::EndOfYAMLException", 23 },
{ "Gem::DocumentError", 18 },
{ "Gem::GemNotInHomeException", 26 },
{ "Gem::DependencyRemovalException", 31 },
{ "Gem::DependencyError", 20 },
{ "Gem::CommandLineError", 21 },
{ "Gem::Exception", 14 },
{ "IRB::SLex", 9 },
{ "IRB::Notifier::NoMsgNotifier", 28 },
{ "IRB::Notifier::LeveledNotifier", 30 },
{ "IRB::Notifier::CompositeNotifier", 32 },
{ "IRB::Notifier::AbstractNotifier", 31 },
{ "IRB::Notifier::ErrUnrecognizedLevel", 35 },
{ "IRB::Notifier::ErrUndefinedNotifier", 35 },
{ "IRB::StdioOutputMethod", 22 },
{ "IRB::OutputMethod::NotImplementedError", 38 },
{ "IRB::OutputMethod", 17 },
{ "IRB::IllegalRCGenerator", 23 },
{ "IRB::UndefinedPromptMode", 24 },
{ "IRB::CantChangeBinding", 22 },
{ "IRB::CantShiftToMultiIrbMode", 28 },
{ "IRB::NoSuchJob", 14 },
{ "IRB::IrbSwitchedToCurrentThread", 31 },
{ "IRB::IrbAlreadyDead", 19 },
{ "IRB::IllegalParameter", 21 },
{ "IRB::CantReturnToNormalMode", 27 },
{ "IRB::NotImplementedError", 24 },
{ "IRB::UnrecognizedSwitch", 23 },
{ "IRB::Irb", 8 },
{ "IRB::Abort", 10 },
{ "IRB::Locale", 11 },
{ "IRB::SLex::ErrNodeNothing", 25 },
{ "IRB::SLex::ErrNodeAlreadyExists", 31 },
{ "RubyLex", 7 },
{ "IRB::SLex::Node", 15 },
{ "Gem::SystemExitException", 24 },
{ "Gem::VerificationError", 22 },
{ "RubyToken::TkError", 18 },
{ "RubyToken::TkUnknownChar", 24 },
{ "RubyToken::TkOPASGN", 19 },
{ "RubyToken::TkOp", 15 },
{ "RubyToken::TkVal", 16 },
{ "RubyToken::TkId", 15 },
{ "RubyToken::TkNode", 17 },
{ "RubyToken::Token", 16 },
{ "RubyToken::TkUNDEF", 18 },
{ "RubyToken::TkDEF", 16 },
{ "RubyToken::TkMODULE", 19 },
{ "RubyToken::TkCLASS", 18 },
{ "RubyToken::TkWHILE", 18 },
{ "RubyToken::TkWHEN", 17 },
{ "RubyToken::TkCASE", 17 },
{ "RubyToken::TkELSE", 17 },
{ "RubyToken::TkELSIF", 18 },
{ "RubyToken::TkTHEN", 17 },
{ "RubyToken::TkUNLESS", 19 },
{ "RubyToken::TkIF", 15 },
{ "RubyToken::TkEND", 16 },
{ "RubyToken::TkENSURE", 19 },
{ "RubyToken::TkRESCUE", 19 },
{ "RubyToken::TkBEGIN", 18 },
{ "RubyToken::TkDO", 15 },
{ "RubyToken::TkIN", 15 },
{ "RubyToken::TkRETRY", 18 },
{ "RubyToken::TkREDO", 17 },
{ "RubyToken::TkNEXT", 17 },
{ "RubyToken::TkBREAK", 18 },
{ "RubyToken::TkFOR", 16 },
{ "RubyToken::TkUNTIL", 18 },
{ "RubyToken::TkTRUE", 17 },
{ "RubyToken::TkNIL", 16 },
{ "RubyToken::TkSELF", 17 },
{ "RubyToken::TkSUPER", 18 },
{ "RubyToken::TkYIELD", 18 },
{ "RubyToken::TkRETURN", 19 },
{ "RubyToken::TkAND", 16 },
{ "RubyToken::TkFALSE", 18 },
{ "RubyToken::TkUNLESS_MOD", 23 },
{ "RubyToken::TkIF_MOD", 19 },
{ "RubyToken::TkNOT", 16 },
{ "RubyToken::TkOR", 15 },
{ "RubyToken::TkALIAS", 18 },
{ "RubyToken::TkUNTIL_MOD", 22 },
{ "RubyToken::TkWHILE_MOD", 22 },
{ "RubyToken::TkGVAR", 17 },
{ "RubyToken::TkFID", 16 },
{ "RubyToken::TkIDENTIFIER", 23 },
{ "RubyToken::Tk__FILE__", 21 },
{ "RubyToken::Tk__LINE__", 21 },
{ "RubyToken::TklEND", 17 },
{ "RubyToken::TklBEGIN", 19 },
{ "RubyToken::TkDEFINED", 20 },
{ "RubyToken::TkDREGEXP", 20 },
{ "RubyToken::TkDXSTRING", 21 },
{ "RubyToken::TkDSTRING", 20 },
{ "RubyToken::TkSYMBOL", 19 },
{ "RubyToken::TkREGEXP", 19 },
{ "RubyToken::TkXSTRING", 20 },
{ "RubyToken::TkSTRING", 19 },
{ "RubyToken::TkFLOAT", 18 },
{ "RubyToken::TkINTEGER", 20 },
{ "RubyToken::TkCONSTANT", 21 },
{ "RubyToken::TkIVAR", 17 },
{ "RubyToken::TkCVAR", 17 },
{ "RubyToken::TkNEQ", 16 },
{ "RubyToken::TkEQQ", 16 },
{ "RubyToken::TkEQ", 15 },
{ "RubyToken::TkCMP", 16 },
{ "RubyToken::TkPOW", 16 },
{ "RubyToken::TkUMINUS", 19 },
{ "RubyToken::TkUPLUS", 18 },
{ "Exception2MessageMapper::ErrNotRegisteredException", 50 },
{ "RubyToken::TkBACK_REF", 21 },
{ "RubyToken::TkNTH_REF", 20 },
{ "RubyToken::TkLSHFT", 18 },
{ "RubyToken::TkASET", 17 },
{ "RubyToken::TkAREF", 17 },
{ "RubyToken::TkDOT3", 17 },
{ "RubyToken::TkDOT2", 17 },
{ "RubyToken::TkNMATCH", 19 },
{ "RubyToken::TkMATCH", 18 },
{ "RubyToken::TkOROP", 17 },
{ "RubyToken::TkANDOP", 18 },
{ "RubyToken::TkLEQ", 16 },
{ "RubyToken::TkGEQ", 16 },
{ "RubyToken::TkAMPER", 18 },
{ "RubyToken::TkSTAR", 17 },
{ "RubyToken::TkfLBRACE", 20 },
{ "RubyToken::TkfLBRACK", 20 },
{ "RubyToken::TkfLPAREN", 20 },
{ "RubyToken::TkCOLON", 18 },
{ "RubyToken::TkQUESTION", 21 },
{ "RubyToken::TkASSOC", 18 },
{ "RubyToken::TkCOLON3", 19 },
{ "RubyToken::TkCOLON2", 19 },
{ "RubyToken::TkRSHFT", 18 },
{ "RubyToken::TkBITAND", 19 },
{ "RubyToken::TkBITXOR", 19 },
{ "RubyToken::TkBITOR", 18 },
{ "RubyToken::TkMOD", 16 },
{ "RubyToken::TkDIV", 16 },
{ "RubyToken::TkMULT", 17 },
{ "RubyToken::TkMINUS", 18 },
{ "RubyToken::TkPLUS", 17 },
{ "RubyToken::TkLT", 15 },
{ "RubyToken::TkGT", 15 },
{ "RubyToken::TkSYMBEG", 19 },
{ "IRB::DefaultEncodings", 21 },
{ "RubyToken::TkRPAREN", 19 },
{ "RubyToken::TkLBRACE", 19 },
{ "RubyToken::TkLBRACK", 19 },
{ "RubyToken::TkLPAREN", 19 },
{ "RubyToken::TkDOT", 16 },
{ "RubyToken::TkASSIGN", 19 },
{ "RubyToken::TkBACKQUOTE", 22 },
{ "RubyToken::TkNOTOP", 18 },
{ "RubyToken::TkBITNOT", 19 },
{ "RubyToken::TkDOLLAR", 19 },
{ "RubyToken::TkAT", 15 },
{ "RubyToken::TkBACKSLASH", 22 },
{ "RubyToken::TkEND_OF_SCRIPT", 26 },
{ "RubyToken::TkNL", 15 },
{ "RubyToken::TkSPACE", 18 },
{ "RubyToken::TkRD_COMMENT", 23 },
{ "RubyToken::TkCOMMENT", 20 },
{ "RubyToken::TkSEMICOLON", 22 },
{ "RubyToken::TkCOMMA", 18 },
{ "RubyToken::TkRBRACE", 19 },
{ "RubyToken::TkRBRACK", 19 },
{ "RubyLex::TerminateLineInput", 27 },
{ "RubyLex::SyntaxError", 20 },
{ "RubyLex::TkReading2TokenDuplicateError", 38 },
{ "RubyLex::TkSymbol2TokenNoKey", 28 },
{ "RubyLex::TkReading2TokenNoKey", 29 },
{ "RubyLex::AlreadyDefinedToken", 28 },
{ "IRB::FileInputMethod", 20 },
{ "IRB::StdioInputMethod", 21 },
{ "IRB::InputMethod", 16 },
{ "IRB::ReadlineInputMethod", 24 },
{ "IRB::Context", 12 },
{ "IRB::Inspector", 14 },
{ "IRB::WorkSpace", 14 },
{ 0, 0 }
};
static uint64_t
micro_time() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (uint64_t)tv.tv_sec * 1000000ULL + (uint64_t)tv.tv_usec;
}
static void
perf() {
StrLen d;
VALUE v;
VALUE *slot = 0;
uint64_t dt, start;
int i, iter = 1000000;
int dataCnt = sizeof(data) / sizeof(*data);
oj_hash_init();
start = micro_time();
for (i = iter; 0 < i; i--) {
for (d = data; 0 != d->str; d++) {
v = oj_class_hash_get(d->str, d->len, &slot);
if (Qundef == v) {
if (0 != slot) {
v = ID2SYM(rb_intern(d->str));
*slot = v;
}
}
}
}
dt = micro_time() - start;
#if IS_WINDOWS
printf("%d iterations took %ld msecs, %ld gets/msec\n", iter, (long)(dt / 1000), (long)(iter * dataCnt / (dt / 1000)));
#else
printf("%d iterations took %"PRIu64" msecs, %ld gets/msec\n", iter, dt / 1000, (long)(iter * dataCnt / (dt / 1000)));
#endif
}
void
oj_hash_test() {
StrLen d;
VALUE v;
VALUE *slot = 0;;
oj_hash_init();
for (d = data; 0 != d->str; d++) {
char *s = oj_strndup(d->str, d->len);
v = oj_class_hash_get(d->str, d->len, &slot);
if (Qnil == v) {
if (0 == slot) {
printf("*** failed to get a slot for %s\n", s);
} else {
v = ID2SYM(rb_intern(d->str));
*slot = v;
}
} else {
VALUE rs = rb_funcall2(v, rb_intern("to_s"), 0, 0);
printf("*** get on '%s' returned '%s' (%s)\n", s, StringValuePtr(rs), rb_class2name(rb_obj_class(v)));
}
/*oj_hash_print(c);*/
}
printf("*** ---------- hash table ------------\n");
oj_hash_print();
perf();
}
#endif
oj-2.17.4/ext/oj/odd.c 0000644 0000041 0000041 00000015340 12766161567 014413 0 ustar www-data www-data /* odd.c
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include "odd.h"
static struct _Odd _odds[4]; // bump up if new initial Odd classes are added
static struct _Odd *odds = _odds;
static long odd_cnt = 0;
static ID sec_id;
static ID sec_fraction_id;
static ID to_f_id;
static ID numerator_id;
static ID denominator_id;
static ID rational_id;
static VALUE rational_class;
static void
set_class(Odd odd, const char *classname) {
const char **np;
ID *idp;
odd->classname = classname;
odd->clen = strlen(classname);
odd->clas = rb_const_get(rb_cObject, rb_intern(classname));
odd->create_obj = odd->clas;
odd->create_op = rb_intern("new");
odd->is_module = (T_MODULE == rb_type(odd->clas));
odd->raw = 0;
for (np = odd->attr_names, idp = odd->attrs; 0 != *np; np++, idp++) {
*idp = rb_intern(*np);
}
*idp = 0;
}
static VALUE
get_datetime_secs(VALUE obj) {
VALUE rsecs = rb_funcall(obj, sec_id, 0);
VALUE rfrac = rb_funcall(obj, sec_fraction_id, 0);
long sec = NUM2LONG(rsecs);
long long num = rb_num2ll(rb_funcall(rfrac, numerator_id, 0));
long long den = rb_num2ll(rb_funcall(rfrac, denominator_id, 0));
#if DATETIME_1_8
num *= 86400;
#endif
num += sec * den;
return rb_funcall(rb_cObject, rational_id, 2, rb_ll2inum(num), rb_ll2inum(den));
}
void
oj_odd_init() {
Odd odd;
const char **np;
sec_id = rb_intern("sec");
sec_fraction_id = rb_intern("sec_fraction");
to_f_id = rb_intern("to_f");
numerator_id = rb_intern("numerator");
denominator_id = rb_intern("denominator");
rational_id = rb_intern("Rational");
rational_class = rb_const_get(rb_cObject, rational_id);
memset(_odds, 0, sizeof(_odds));
odd = odds;
// Rational
np = odd->attr_names;
*np++ = "numerator";
*np++ = "denominator";
*np = 0;
set_class(odd, "Rational");
odd->create_obj = rb_cObject;
odd->create_op = rational_id;
odd->attr_cnt = 2;
// Date
odd++;
np = odd->attr_names;
*np++ = "year";
*np++ = "month";
*np++ = "day";
*np++ = "start";
*np++ = 0;
set_class(odd, "Date");
odd->attr_cnt = 4;
// DateTime
odd++;
np = odd->attr_names;
*np++ = "year";
*np++ = "month";
*np++ = "day";
*np++ = "hour";
*np++ = "min";
*np++ = "sec";
*np++ = "offset";
*np++ = "start";
*np++ = 0;
set_class(odd, "DateTime");
odd->attr_cnt = 8;
odd->attrFuncs[5] = get_datetime_secs;
// Range
odd++;
np = odd->attr_names;
*np++ = "begin";
*np++ = "end";
*np++ = "exclude_end?";
*np++ = 0;
set_class(odd, "Range");
odd->attr_cnt = 3;
odd_cnt = odd - odds + 1;
}
Odd
oj_get_odd(VALUE clas) {
Odd odd;
const char *classname = NULL;
for (odd = odds + odd_cnt - 1; odds <= odd; odd--) {
if (clas == odd->clas) {
return odd;
}
if (odd->is_module) {
if (NULL == classname) {
classname = rb_class2name(clas);
}
if (0 == strncmp(odd->classname, classname, odd->clen) &&
':' == classname[odd->clen]) {
return odd;
}
}
}
return NULL;
}
Odd
oj_get_oddc(const char *classname, size_t len) {
Odd odd;
for (odd = odds + odd_cnt - 1; odds <= odd; odd--) {
if (len == odd->clen && 0 == strncmp(classname, odd->classname, len)) {
return odd;
}
if (odd->is_module &&
0 == strncmp(odd->classname, classname, odd->clen) &&
':' == classname[odd->clen]) {
return odd;
}
}
return 0;
}
OddArgs
oj_odd_alloc_args(Odd odd) {
OddArgs oa = ALLOC_N(struct _OddArgs, 1);
VALUE *a;
int i;
oa->odd = odd;
for (i = odd->attr_cnt, a = oa->args; 0 < i; i--, a++) {
*a = Qnil;
}
return oa;
}
void
oj_odd_free(OddArgs args) {
xfree(args);
}
int
oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value) {
const char **np;
VALUE *vp;
int i;
for (i = args->odd->attr_cnt, np = args->odd->attr_names, vp = args->args; 0 < i; i--, np++, vp++) {
if (0 == strncmp(key, *np, klen) && '\0' == *((*np) + klen)) {
*vp = value;
return 0;
}
}
return -1;
}
void
oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members, bool raw) {
Odd odd;
const char **np;
ID *ap;
AttrGetFunc *fp;
if (_odds == odds) {
odds = ALLOC_N(struct _Odd, odd_cnt + 1);
memcpy(odds, _odds, sizeof(struct _Odd) * odd_cnt);
} else {
REALLOC_N(odds, struct _Odd, odd_cnt + 1);
}
odd = odds + odd_cnt;
odd->clas = clas;
odd->classname = strdup(rb_class2name(clas));
odd->clen = strlen(odd->classname);
odd->create_obj = create_object;
odd->create_op = SYM2ID(create_method);
odd->attr_cnt = mcnt;
odd->is_module = (T_MODULE == rb_type(clas));
odd->raw = raw;
for (ap = odd->attrs, np = odd->attr_names, fp = odd->attrFuncs; 0 < mcnt; mcnt--, ap++, np++, members++, fp++) {
*fp = 0;
switch (rb_type(*members)) {
case T_STRING:
*np = strdup(rb_string_value_ptr(members));
break;
case T_SYMBOL:
*np = rb_id2name(SYM2ID(*members));
break;
default:
rb_raise(rb_eArgError, "registered member identifiers must be Strings or Symbols.");
break;
}
*ap = rb_intern(*np);
}
*np = 0;
*ap = 0;
odd_cnt++;
}
oj-2.17.4/ext/oj/scp.c 0000644 0000041 0000041 00000015725 12766161567 014441 0 ustar www-data www-data /* scp.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include "oj.h"
#include "parse.h"
#include "encode.h"
static VALUE
noop_start(ParseInfo pi) {
return Qnil;
}
static void
noop_end(ParseInfo pi) {
}
static void
noop_add_value(ParseInfo pi, VALUE val) {
}
static void
noop_add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
}
static void
noop_add_num(ParseInfo pi, NumInfo ni) {
}
static VALUE
noop_hash_key(struct _ParseInfo *pi, const char *key, size_t klen) {
return Qundef;
}
static void
noop_hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
}
static void
noop_hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
}
static void
noop_hash_set_value(ParseInfo pi, Val kval, VALUE value) {
}
static void
noop_array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
}
static void
noop_array_append_num(ParseInfo pi, NumInfo ni) {
}
static void
noop_array_append_value(ParseInfo pi, VALUE value) {
}
static void
add_value(ParseInfo pi, VALUE val) {
rb_funcall(pi->handler, oj_add_value_id, 1, val);
}
static void
add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
volatile VALUE rstr = rb_str_new(str, len);
rstr = oj_encode(rstr);
rb_funcall(pi->handler, oj_add_value_id, 1, rstr);
}
static void
add_num(ParseInfo pi, NumInfo ni) {
rb_funcall(pi->handler, oj_add_value_id, 1, oj_num_as_value(ni));
}
static VALUE
start_hash(ParseInfo pi) {
return rb_funcall(pi->handler, oj_hash_start_id, 0);
}
static void
end_hash(ParseInfo pi) {
rb_funcall(pi->handler, oj_hash_end_id, 0);
}
static VALUE
start_array(ParseInfo pi) {
return rb_funcall(pi->handler, oj_array_start_id, 0);
}
static void
end_array(ParseInfo pi) {
rb_funcall(pi->handler, oj_array_end_id, 0);
}
static VALUE
calc_hash_key(ParseInfo pi, Val kval) {
volatile VALUE rkey = kval->key_val;
if (Qundef == rkey) {
rkey = rb_str_new(kval->key, kval->klen);
rkey = oj_encode(rkey);
if (Yes == pi->options.sym_key) {
rkey = rb_str_intern(rkey);
}
}
return rkey;
}
static VALUE
hash_key(struct _ParseInfo *pi, const char *key, size_t klen) {
return rb_funcall(pi->handler, oj_hash_key_id, 1, rb_str_new(key, klen));
}
static void
hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
volatile VALUE rstr = rb_str_new(str, len);
rstr = oj_encode(rstr);
rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), rstr);
}
static void
hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), oj_num_as_value(ni));
}
static void
hash_set_value(ParseInfo pi, Val kval, VALUE value) {
rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), value);
}
static void
array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
volatile VALUE rstr = rb_str_new(str, len);
rstr = oj_encode(rstr);
rb_funcall(pi->handler, oj_array_append_id, 2, stack_peek(&pi->stack)->val, rstr);
}
static void
array_append_num(ParseInfo pi, NumInfo ni) {
rb_funcall(pi->handler, oj_array_append_id, 2, stack_peek(&pi->stack)->val, oj_num_as_value(ni));
}
static void
array_append_value(ParseInfo pi, VALUE value) {
rb_funcall(pi->handler, oj_array_append_id, 2, stack_peek(&pi->stack)->val, value);
}
VALUE
oj_sc_parse(int argc, VALUE *argv, VALUE self) {
struct _ParseInfo pi;
VALUE input = argv[1];
pi.err_class = Qnil;
pi.options = oj_default_options;
if (3 == argc) {
oj_parse_options(argv[2], &pi.options);
}
if (rb_block_given_p()) {
pi.proc = Qnil;
} else {
pi.proc = Qundef;
}
pi.handler = *argv;
pi.start_hash = rb_respond_to(pi.handler, oj_hash_start_id) ? start_hash : noop_start;
pi.end_hash = rb_respond_to(pi.handler, oj_hash_end_id) ? end_hash : noop_end;
pi.hash_key = rb_respond_to(pi.handler, oj_hash_key_id) ? hash_key : noop_hash_key;
pi.start_array = rb_respond_to(pi.handler, oj_array_start_id) ? start_array : noop_start;
pi.end_array = rb_respond_to(pi.handler, oj_array_end_id) ? end_array : noop_end;
if (rb_respond_to(pi.handler, oj_hash_set_id)) {
pi.hash_set_value = hash_set_value;
pi.hash_set_cstr = hash_set_cstr;
pi.hash_set_num = hash_set_num;
pi.expect_value = 1;
} else {
pi.hash_set_value = noop_hash_set_value;
pi.hash_set_cstr = noop_hash_set_cstr;
pi.hash_set_num = noop_hash_set_num;
pi.expect_value = 0;
}
if (rb_respond_to(pi.handler, oj_array_append_id)) {
pi.array_append_value = array_append_value;
pi.array_append_cstr = array_append_cstr;
pi.array_append_num = array_append_num;
pi.expect_value = 1;
} else {
pi.array_append_value = noop_array_append_value;
pi.array_append_cstr = noop_array_append_cstr;
pi.array_append_num = noop_array_append_num;
pi.expect_value = 0;
}
if (rb_respond_to(pi.handler, oj_add_value_id)) {
pi.add_cstr = add_cstr;
pi.add_num = add_num;
pi.add_value = add_value;
pi.expect_value = 1;
} else {
pi.add_cstr = noop_add_cstr;
pi.add_num = noop_add_num;
pi.add_value = noop_add_value;
pi.expect_value = 0;
}
if (T_STRING == rb_type(input)) {
return oj_pi_parse(argc - 1, argv + 1, &pi, 0, 0, 1);
} else {
return oj_pi_sparse(argc - 1, argv + 1, &pi, 0);
}
}
oj-2.17.4/ext/oj/val_stack.c 0000644 0000041 0000041 00000006262 12766161567 015617 0 ustar www-data www-data /* val_stack.c
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "oj.h"
#include "val_stack.h"
static void
mark(void *ptr) {
ValStack stack = (ValStack)ptr;
Val v;
if (0 == ptr) {
return;
}
#if USE_PTHREAD_MUTEX
pthread_mutex_lock(&stack->mutex);
#elif USE_RB_MUTEX
rb_mutex_lock(stack->mutex);
rb_gc_mark(stack->mutex);
#endif
for (v = stack->head; v < stack->tail; v++) {
if (Qnil != v->val && Qundef != v->val) {
rb_gc_mark(v->val);
}
}
#if USE_PTHREAD_MUTEX
pthread_mutex_unlock(&stack->mutex);
#elif USE_RB_MUTEX
rb_mutex_unlock(stack->mutex);
#endif
}
VALUE
oj_stack_init(ValStack stack) {
#if USE_PTHREAD_MUTEX
pthread_mutex_init(&stack->mutex, 0);
#elif USE_RB_MUTEX
stack->mutex = rb_mutex_new();
#endif
stack->head = stack->base;
stack->end = stack->base + sizeof(stack->base) / sizeof(struct _Val);
stack->tail = stack->head;
stack->head->val = Qundef;
stack->head->key = 0;
stack->head->key_val = Qundef;
stack->head->classname = 0;
stack->head->klen = 0;
stack->head->clen = 0;
stack->head->next = NEXT_NONE;
return Data_Wrap_Struct(oj_cstack_class, mark, 0, stack);
}
const char*
oj_stack_next_string(ValNext n) {
switch (n) {
case NEXT_ARRAY_NEW: return "array element or close";
case NEXT_ARRAY_ELEMENT: return "array element";
case NEXT_ARRAY_COMMA: return "comma";
case NEXT_HASH_NEW: return "hash pair or close";
case NEXT_HASH_KEY: return "hash key";
case NEXT_HASH_COLON: return "colon";
case NEXT_HASH_VALUE: return "hash value";
case NEXT_HASH_COMMA: return "comma";
case NEXT_NONE: break;
default: break;
}
return "nothing";
}
oj-2.17.4/ext/oj/compat.c 0000644 0000041 0000041 00000010765 12766161567 015136 0 ustar www-data www-data /* compat.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include "oj.h"
#include "err.h"
#include "parse.h"
#include "resolve.h"
#include "hash.h"
#include "encode.h"
static void
hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
const char *key = kval->key;
int klen = kval->klen;
Val parent = stack_peek(&pi->stack);
volatile VALUE rkey = kval->key_val;
if (Qundef == rkey &&
0 != pi->options.create_id &&
*pi->options.create_id == *key &&
(int)pi->options.create_id_len == klen &&
0 == strncmp(pi->options.create_id, key, klen)) {
parent->classname = oj_strndup(str, len);
parent->clen = len;
} else {
volatile VALUE rstr = rb_str_new(str, len);
if (Qundef == rkey) {
rkey = rb_str_new(key, klen);
rstr = oj_encode(rstr);
rkey = oj_encode(rkey);
if (Yes == pi->options.sym_key) {
rkey = rb_str_intern(rkey);
}
}
rb_hash_aset(parent->val, rkey, rstr);
}
}
static void
end_hash(struct _ParseInfo *pi) {
Val parent = stack_peek(&pi->stack);
if (0 != parent->classname) {
VALUE clas;
clas = oj_name2class(pi, parent->classname, parent->clen, 0);
if (Qundef != clas) { // else an error
parent->val = rb_funcall(clas, oj_json_create_id, 1, parent->val);
}
if (0 != parent->classname) {
xfree((char*)parent->classname);
parent->classname = 0;
}
}
}
static VALUE
calc_hash_key(ParseInfo pi, Val parent) {
volatile VALUE rkey = parent->key_val;
if (Qundef == rkey) {
rkey = rb_str_new(parent->key, parent->klen);
}
rkey = oj_encode(rkey);
if (Yes == pi->options.sym_key) {
rkey = rb_str_intern(rkey);
}
return rkey;
}
static void
add_num(ParseInfo pi, NumInfo ni) {
pi->stack.head->val = oj_num_as_value(ni);
}
static void
hash_set_num(struct _ParseInfo *pi, Val parent, NumInfo ni) {
rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), oj_num_as_value(ni));
}
static void
array_append_num(ParseInfo pi, NumInfo ni) {
rb_ary_push(stack_peek(&pi->stack)->val, oj_num_as_value(ni));
}
void
oj_set_compat_callbacks(ParseInfo pi) {
oj_set_strict_callbacks(pi);
pi->end_hash = end_hash;
pi->hash_set_cstr = hash_set_cstr;
pi->add_num = add_num;
pi->hash_set_num = hash_set_num;
pi->array_append_num = array_append_num;
}
VALUE
oj_compat_parse(int argc, VALUE *argv, VALUE self) {
struct _ParseInfo pi;
pi.options = oj_default_options;
pi.handler = Qnil;
pi.err_class = Qnil;
oj_set_compat_callbacks(&pi);
if (T_STRING == rb_type(*argv)) {
return oj_pi_parse(argc, argv, &pi, 0, 0, 1);
} else {
return oj_pi_sparse(argc, argv, &pi, 0);
}
}
VALUE
oj_compat_parse_cstr(int argc, VALUE *argv, char *json, size_t len) {
struct _ParseInfo pi;
pi.options = oj_default_options;
pi.handler = Qnil;
pi.err_class = Qnil;
oj_set_strict_callbacks(&pi);
pi.end_hash = end_hash;
pi.hash_set_cstr = hash_set_cstr;
return oj_pi_parse(argc, argv, &pi, json, len, 1);
}
oj-2.17.4/ext/oj/circarray.h 0000644 0000041 0000041 00000004065 12766161567 015633 0 ustar www-data www-data /* circarray.h
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_CIRCARRAY_H__
#define __OJ_CIRCARRAY_H__
#include "ruby.h"
typedef struct _CircArray {
VALUE obj_array[1024];
VALUE *objs;
unsigned long size; // allocated size or initial array size
unsigned long cnt;
} *CircArray;
extern CircArray oj_circ_array_new(void);
extern void oj_circ_array_free(CircArray ca);
extern void oj_circ_array_set(CircArray ca, VALUE obj, unsigned long id);
extern VALUE oj_circ_array_get(CircArray ca, unsigned long id);
#endif /* __OJ_CIRCARRAY_H__ */
oj-2.17.4/ext/oj/cache8.h 0000644 0000041 0000041 00000003702 12766161567 015004 0 ustar www-data www-data /* cache8.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_CACHE8_H__
#define __OJ_CACHE8_H__
#include "ruby.h"
#include "stdint.h"
typedef struct _Cache8 *Cache8;
typedef uint64_t slot_t;
typedef uint64_t sid_t;
extern void oj_cache8_new(Cache8 *cache);
extern void oj_cache8_delete(Cache8 cache);
extern slot_t oj_cache8_get(Cache8 cache, sid_t key, slot_t **slot);
extern void oj_cache8_print(Cache8 cache);
#endif /* __OJ_CACHE8_H__ */
oj-2.17.4/ext/oj/reader.c 0000644 0000041 0000041 00000016372 12766161567 015115 0 ustar www-data www-data /* reader.c
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#if NEEDS_UIO
#include
#endif
#include
#include
#include "ruby.h"
#include "oj.h"
#include "reader.h"
#define BUF_PAD 4
static VALUE rescue_cb(VALUE rdr, VALUE err);
static VALUE io_cb(VALUE rdr);
static VALUE partial_io_cb(VALUE rdr);
static int read_from_io(Reader reader);
static int read_from_fd(Reader reader);
static int read_from_io_partial(Reader reader);
//static int read_from_str(Reader reader);
void
oj_reader_init(Reader reader, VALUE io, int fd) {
VALUE io_class = rb_obj_class(io);
VALUE stat;
VALUE ftype;
reader->head = reader->base;
*((char*)reader->head) = '\0';
reader->end = reader->head + sizeof(reader->base) - BUF_PAD;
reader->tail = reader->head;
reader->read_end = reader->head;
reader->pro = 0;
reader->str = 0;
reader->line = 1;
reader->col = 0;
reader->free_head = 0;
if (0 != fd) {
reader->read_func = read_from_fd;
reader->fd = fd;
} else if (rb_cString == io_class) {
reader->read_func = 0;
reader->in_str = StringValuePtr(io);
reader->head = (char*)reader->in_str;
reader->tail = reader->head;
reader->read_end = reader->head + RSTRING_LEN(io);
} else if (oj_stringio_class == io_class) {
VALUE s = rb_funcall2(io, oj_string_id, 0, 0);
reader->read_func = 0;
reader->in_str = StringValuePtr(s);
reader->head = (char*)reader->in_str;
reader->tail = reader->head;
reader->read_end = reader->head + RSTRING_LEN(s);
} else if (rb_cFile == io_class &&
Qnil != (stat = rb_funcall(io, oj_stat_id, 0)) &&
Qnil != (ftype = rb_funcall(stat, oj_ftype_id, 0)) &&
0 == strcmp("file", StringValuePtr(ftype)) &&
0 == FIX2INT(rb_funcall(io, oj_pos_id, 0))) {
reader->read_func = read_from_fd;
reader->fd = FIX2INT(rb_funcall(io, oj_fileno_id, 0));
} else if (rb_respond_to(io, oj_readpartial_id)) {
reader->read_func = read_from_io_partial;
reader->io = io;
} else if (rb_respond_to(io, oj_read_id)) {
reader->read_func = read_from_io;
reader->io = io;
} else {
rb_raise(rb_eArgError, "parser io argument must be a String or respond to readpartial() or read().\n");
}
}
int
oj_reader_read(Reader reader) {
int err;
size_t shift = 0;
if (0 == reader->read_func) {
return -1;
}
// if there is not much room to read into, shift or realloc a larger buffer.
if (reader->head < reader->tail && 4096 > reader->end - reader->tail) {
if (0 == reader->pro) {
shift = reader->tail - reader->head;
} else {
shift = reader->pro - reader->head - 1; // leave one character so we can backup one
}
if (0 >= shift) { /* no space left so allocate more */
const char *old = reader->head;
size_t size = reader->end - reader->head + BUF_PAD;
if (reader->head == reader->base) {
reader->head = ALLOC_N(char, size * 2);
memcpy((char*)reader->head, old, size);
} else {
REALLOC_N(reader->head, char, size * 2);
}
reader->free_head = 1;
reader->end = reader->head + size * 2 - BUF_PAD;
reader->tail = reader->head + (reader->tail - old);
reader->read_end = reader->head + (reader->read_end - old);
if (0 != reader->pro) {
reader->pro = reader->head + (reader->pro - old);
}
if (0 != reader->str) {
reader->str = reader->head + (reader->str - old);
}
} else {
memmove((char*)reader->head, reader->head + shift, reader->read_end - (reader->head + shift));
reader->tail -= shift;
reader->read_end -= shift;
if (0 != reader->pro) {
reader->pro -= shift;
}
if (0 != reader->str) {
reader->str -= shift;
}
}
}
err = reader->read_func(reader);
*(char*)reader->read_end = '\0';
return err;
}
static VALUE
rescue_cb(VALUE rbuf, VALUE err) {
VALUE clas = rb_obj_class(err);
if (rb_eTypeError != clas && rb_eEOFError != clas) {
Reader reader = (Reader)rbuf;
rb_raise(clas, "at line %d, column %d\n", reader->line, reader->col);
}
return Qfalse;
}
static VALUE
partial_io_cb(VALUE rbuf) {
Reader reader = (Reader)rbuf;
VALUE args[1];
VALUE rstr;
char *str;
size_t cnt;
args[0] = ULONG2NUM(reader->end - reader->tail);
rstr = rb_funcall2(reader->io, oj_readpartial_id, 1, args);
if (Qnil == rstr) {
return Qfalse;
}
str = StringValuePtr(rstr);
cnt = RSTRING_LEN(rstr);
//printf("*** partial read %lu bytes, str: '%s'\n", cnt, str);
strcpy(reader->tail, str);
reader->read_end = reader->tail + cnt;
return Qtrue;
}
static VALUE
io_cb(VALUE rbuf) {
Reader reader = (Reader)rbuf;
VALUE args[1];
VALUE rstr;
char *str;
size_t cnt;
args[0] = ULONG2NUM(reader->end - reader->tail);
rstr = rb_funcall2(reader->io, oj_read_id, 1, args);
if (Qnil == rstr) {
return Qfalse;
}
str = StringValuePtr(rstr);
cnt = RSTRING_LEN(rstr);
//printf("*** read %lu bytes, str: '%s'\n", cnt, str);
strcpy(reader->tail, str);
reader->read_end = reader->tail + cnt;
return Qtrue;
}
static int
read_from_io_partial(Reader reader) {
return (Qfalse == rb_rescue(partial_io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
}
static int
read_from_io(Reader reader) {
return (Qfalse == rb_rescue(io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
}
static int
read_from_fd(Reader reader) {
ssize_t cnt;
size_t max = reader->end - reader->tail;
cnt = read(reader->fd, reader->tail, max);
if (cnt <= 0) {
return -1;
} else if (0 != cnt) {
reader->read_end = reader->tail + cnt;
}
return 0;
}
// This is only called when the end of the string is reached so just return -1.
/*
static int
read_from_str(Reader reader) {
return -1;
}
*/
oj-2.17.4/ext/oj/dump.c 0000644 0000041 0000041 00000202510 12766161567 014607 0 ustar www-data www-data /* dump.c
* Copyright (c) 2012, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#if !IS_WINDOWS
#include
#endif
#include
#include
#include
#include
#include
#include
#include "oj.h"
#include "cache8.h"
#include "odd.h"
#if !HAS_ENCODING_SUPPORT || defined(RUBINIUS_RUBY)
#define rb_eEncodingError rb_eException
#endif
// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
#define OJ_INFINITY (1.0/0.0)
// Extra padding at end of buffer.
#define BUFFER_EXTRA 10
#define MAX_DEPTH 1000
typedef unsigned long ulong;
static void raise_strict(VALUE obj);
static void dump_val(VALUE obj, int depth, Out out, int argc, VALUE *argv);
static void dump_nil(Out out);
static void dump_true(Out out);
static void dump_false(Out out);
static void dump_fixnum(VALUE obj, Out out);
static void dump_bignum(VALUE obj, Out out);
static void dump_float(VALUE obj, Out out);
static void dump_raw(const char *str, size_t cnt, Out out);
static void dump_cstr(const char *str, size_t cnt, int is_sym, int escape1, Out out);
static void dump_hex(uint8_t c, Out out);
static void dump_str_comp(VALUE obj, Out out);
static void dump_str_obj(VALUE obj, VALUE clas, int depth, Out out);
static void dump_sym_comp(VALUE obj, Out out);
static void dump_sym_obj(VALUE obj, Out out);
static void dump_class_comp(VALUE obj, Out out);
static void dump_class_obj(VALUE obj, Out out);
static void dump_array(VALUE obj, VALUE clas, int depth, Out out);
static int hash_cb_strict(VALUE key, VALUE value, Out out);
static int hash_cb_compat(VALUE key, VALUE value, Out out);
static int hash_cb_object(VALUE key, VALUE value, Out out);
static void dump_hash(VALUE obj, VALUE clas, int depth, int mode, Out out);
static void dump_time(VALUE obj, Out out, int withZone);
static void dump_ruby_time(VALUE obj, Out out);
static void dump_xml_time(VALUE obj, Out out);
static void dump_data_strict(VALUE obj, Out out);
static void dump_data_null(VALUE obj, Out out);
static void dump_data_comp(VALUE obj, int depth, Out out);
static void dump_data_obj(VALUE obj, int depth, Out out);
static void dump_obj_comp(VALUE obj, int depth, Out out, int argc, VALUE *argv);
static void dump_obj_obj(VALUE obj, int depth, Out out);
static void dump_struct_comp(VALUE obj, int depth, Out out);
static void dump_struct_obj(VALUE obj, int depth, Out out);
#if HAS_IVAR_HELPERS
static int dump_attr_cb(ID key, VALUE value, Out out);
#endif
static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out);
static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out);
static void grow(Out out, size_t len);
static size_t hibit_friendly_size(const uint8_t *str, size_t len);
static size_t xss_friendly_size(const uint8_t *str, size_t len);
static size_t ascii_friendly_size(const uint8_t *str, size_t len);
static void dump_leaf(Leaf leaf, int depth, Out out);
static void dump_leaf_str(Leaf leaf, Out out);
static void dump_leaf_fixnum(Leaf leaf, Out out);
static void dump_leaf_float(Leaf leaf, Out out);
static void dump_leaf_array(Leaf leaf, int depth, Out out);
static void dump_leaf_hash(Leaf leaf, int depth, Out out);
static const char hex_chars[17] = "0123456789abcdef";
// JSON standard except newlines are no escaped
static char newline_friendly_chars[256] = "\
66666666221622666666666666666666\
11211111111111111111111111111111\
11111111111111111111111111112111\
11111111111111111111111111111111\
11111111111111111111111111111111\
11111111111111111111111111111111\
11111111111111111111111111111111\
11111111111111111111111111111111";
// JSON standard
static char hibit_friendly_chars[256] = "\
66666666222622666666666666666666\
11211111111111111111111111111111\
11111111111111111111111111112111\
11111111111111111111111111111111\
11111111111111111111111111111111\
11111111111111111111111111111111\
11111111111111111111111111111111\
11111111111111111111111111111111";
// High bit set characters are always encoded as unicode. Worse case is 3
// bytes per character in the output. That makes this conservative.
static char ascii_friendly_chars[256] = "\
66666666222622666666666666666666\
11211111111111111111111111111111\
11111111111111111111111111112111\
11111111111111111111111111111116\
33333333333333333333333333333333\
33333333333333333333333333333333\
33333333333333333333333333333333\
33333333333333333333333333333333";
// XSS safe mode
static char xss_friendly_chars[256] = "\
66666666222622666666666666666666\
11211161111111121111111111116161\
11111111111111111111111111112111\
11111111111111111111111111111116\
33333333333333333333333333333333\
33333333333333333333333333333333\
33333333333333333333333333333333\
33333333333333333333333333333333";
inline static size_t
newline_friendly_size(const uint8_t *str, size_t len) {
size_t size = 0;
for (; 0 < len; str++, len--) {
size += newline_friendly_chars[*str];
}
return size - len * (size_t)'0';
}
inline static size_t
hibit_friendly_size(const uint8_t *str, size_t len) {
size_t size = 0;
for (; 0 < len; str++, len--) {
size += hibit_friendly_chars[*str];
}
return size - len * (size_t)'0';
}
inline static size_t
ascii_friendly_size(const uint8_t *str, size_t len) {
size_t size = 0;
for (; 0 < len; str++, len--) {
size += ascii_friendly_chars[*str];
}
return size - len * (size_t)'0';
}
inline static size_t
xss_friendly_size(const uint8_t *str, size_t len) {
size_t size = 0;
for (; 0 < len; str++, len--) {
size += xss_friendly_chars[*str];
}
return size - len * (size_t)'0';
}
inline static void
fill_indent(Out out, int cnt) {
if (0 < out->indent) {
cnt *= out->indent;
*out->cur++ = '\n';
for (; 0 < cnt; cnt--) {
*out->cur++ = ' ';
}
}
}
inline static void
dump_ulong(unsigned long num, Out out) {
char buf[32];
char *b = buf + sizeof(buf) - 1;
*b-- = '\0';
if (0 < num) {
for (; 0 < num; num /= 10, b--) {
*b = (num % 10) + '0';
}
b++;
} else {
*b = '0';
}
for (; '\0' != *b; b++) {
*out->cur++ = *b;
}
*out->cur = '\0';
}
static void
grow(Out out, size_t len) {
size_t size = out->end - out->buf;
long pos = out->cur - out->buf;
char *buf;
size *= 2;
if (size <= len * 2 + pos) {
size += len;
}
if (out->allocated) {
buf = REALLOC_N(out->buf, char, (size + BUFFER_EXTRA));
} else {
buf = ALLOC_N(char, (size + BUFFER_EXTRA));
out->allocated = 1;
memcpy(buf, out->buf, out->end - out->buf + BUFFER_EXTRA);
}
if (0 == buf) {
rb_raise(rb_eNoMemError, "Failed to create string. [%d:%s]\n", ENOSPC, strerror(ENOSPC));
}
out->buf = buf;
out->end = buf + size;
out->cur = out->buf + pos;
}
inline static void
dump_hex(uint8_t c, Out out) {
uint8_t d = (c >> 4) & 0x0F;
*out->cur++ = hex_chars[d];
d = c & 0x0F;
*out->cur++ = hex_chars[d];
}
static void
dump_raw(const char *str, size_t cnt, Out out) {
if (out->end - out->cur <= (long)cnt + 10) {
grow(out, cnt + 10);
}
memcpy(out->cur, str, cnt);
out->cur += cnt;
*out->cur = '\0';
}
const char*
dump_unicode(const char *str, const char *end, Out out) {
uint32_t code = 0;
uint8_t b = *(uint8_t*)str;
int i, cnt;
if (0xC0 == (0xE0 & b)) {
cnt = 1;
code = b & 0x0000001F;
} else if (0xE0 == (0xF0 & b)) {
cnt = 2;
code = b & 0x0000000F;
} else if (0xF0 == (0xF8 & b)) {
cnt = 3;
code = b & 0x00000007;
} else if (0xF8 == (0xFC & b)) {
cnt = 4;
code = b & 0x00000003;
} else if (0xFC == (0xFE & b)) {
cnt = 5;
code = b & 0x00000001;
} else {
cnt = 0;
rb_raise(rb_eEncodingError, "Invalid Unicode\n");
}
str++;
for (; 0 < cnt; cnt--, str++) {
b = *(uint8_t*)str;
if (end <= str || 0x80 != (0xC0 & b)) {
rb_raise(rb_eEncodingError, "Invalid Unicode\n");
}
code = (code << 6) | (b & 0x0000003F);
}
if (0x0000FFFF < code) {
uint32_t c1;
code -= 0x00010000;
c1 = ((code >> 10) & 0x000003FF) + 0x0000D800;
code = (code & 0x000003FF) + 0x0000DC00;
*out->cur++ = '\\';
*out->cur++ = 'u';
for (i = 3; 0 <= i; i--) {
*out->cur++ = hex_chars[(uint8_t)(c1 >> (i * 4)) & 0x0F];
}
}
*out->cur++ = '\\';
*out->cur++ = 'u';
for (i = 3; 0 <= i; i--) {
*out->cur++ = hex_chars[(uint8_t)(code >> (i * 4)) & 0x0F];
}
return str - 1;
}
// returns 0 if not using circular references, -1 if not further writing is
// needed (duplicate), and a positive value if the object was added to the cache.
static long
check_circular(VALUE obj, Out out) {
slot_t id = 0;
slot_t *slot;
if (ObjectMode == out->opts->mode && Yes == out->opts->circular) {
if (0 == (id = oj_cache8_get(out->circ_cache, obj, &slot))) {
out->circ_cnt++;
id = out->circ_cnt;
*slot = id;
} else {
if (out->end - out->cur <= 18) {
grow(out, 18);
}
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'r';
dump_ulong(id, out);
*out->cur++ = '"';
return -1;
}
}
return (long)id;
}
static void
dump_nil(Out out) {
size_t size = 4;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = 'n';
*out->cur++ = 'u';
*out->cur++ = 'l';
*out->cur++ = 'l';
*out->cur = '\0';
}
static void
dump_true(Out out) {
size_t size = 4;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = 't';
*out->cur++ = 'r';
*out->cur++ = 'u';
*out->cur++ = 'e';
*out->cur = '\0';
}
static void
dump_false(Out out) {
size_t size = 5;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = 'f';
*out->cur++ = 'a';
*out->cur++ = 'l';
*out->cur++ = 's';
*out->cur++ = 'e';
*out->cur = '\0';
}
static void
dump_fixnum(VALUE obj, Out out) {
char buf[32];
char *b = buf + sizeof(buf) - 1;
long long num = rb_num2ll(obj);
int neg = 0;
if (0 > num) {
neg = 1;
num = -num;
}
*b-- = '\0';
if (0 < num) {
for (; 0 < num; num /= 10, b--) {
*b = (num % 10) + '0';
}
if (neg) {
*b = '-';
} else {
b++;
}
} else {
*b = '0';
}
if (out->end - out->cur <= (long)(sizeof(buf) - (b - buf))) {
grow(out, sizeof(buf) - (b - buf));
}
for (; '\0' != *b; b++) {
*out->cur++ = *b;
}
*out->cur = '\0';
}
static void
dump_bignum(VALUE obj, Out out) {
volatile VALUE rs = rb_big2str(obj, 10);
int cnt = (int)RSTRING_LEN(rs);
if (out->end - out->cur <= (long)cnt) {
grow(out, cnt);
}
memcpy(out->cur, rb_string_value_ptr((VALUE*)&rs), cnt);
out->cur += cnt;
*out->cur = '\0';
}
static const char inf_val[] = INF_VAL;
static const char ninf_val[] = NINF_VAL;
static const char nan_val[] = NAN_VAL;
// Removed dependencies on math due to problems with CentOS 5.4.
static void
dump_float(VALUE obj, Out out) {
char buf[64];
char *b;
double d = rb_num2dbl(obj);
int cnt = 0;
if (0.0 == d) {
b = buf;
*b++ = '0';
*b++ = '.';
*b++ = '0';
*b++ = '\0';
cnt = 3;
} else if (OJ_INFINITY == d) {
if (ObjectMode == out->opts->mode) {
strcpy(buf, inf_val);
cnt = sizeof(inf_val) - 1;
} else {
NanDump nd = out->opts->dump_opts.nan_dump;
if (AutoNan == nd) {
switch (out->opts->mode) {
case CompatMode: nd = WordNan; break;
case StrictMode: nd = RaiseNan; break;
case NullMode: nd = NullNan; break;
default: break;
}
}
switch (nd) {
case RaiseNan:
raise_strict(obj);
break;
case WordNan:
strcpy(buf, "Infinity");
cnt = 8;
break;
case NullNan:
strcpy(buf, "null");
cnt = 4;
break;
case HugeNan:
default:
strcpy(buf, inf_val);
cnt = sizeof(inf_val) - 1;
break;
}
}
} else if (-OJ_INFINITY == d) {
if (ObjectMode == out->opts->mode) {
strcpy(buf, ninf_val);
cnt = sizeof(ninf_val) - 1;
} else {
NanDump nd = out->opts->dump_opts.nan_dump;
if (AutoNan == nd) {
switch (out->opts->mode) {
case CompatMode: nd = WordNan; break;
case StrictMode: nd = RaiseNan; break;
case NullMode: nd = NullNan; break;
default: break;
}
}
switch (nd) {
case RaiseNan:
raise_strict(obj);
break;
case WordNan:
strcpy(buf, "-Infinity");
cnt = 9;
break;
case NullNan:
strcpy(buf, "null");
cnt = 4;
break;
case HugeNan:
default:
strcpy(buf, ninf_val);
cnt = sizeof(ninf_val) - 1;
break;
}
}
} else if (isnan(d)) {
if (ObjectMode == out->opts->mode) {
strcpy(buf, nan_val);
cnt = sizeof(nan_val) - 1;
} else {
NanDump nd = out->opts->dump_opts.nan_dump;
if (AutoNan == nd) {
switch (out->opts->mode) {
case CompatMode: nd = WordNan; break;
case StrictMode: nd = RaiseNan; break;
case NullMode: nd = NullNan; break;
default: break;
}
}
switch (nd) {
case RaiseNan:
raise_strict(obj);
break;
case WordNan:
strcpy(buf, "NaN");
cnt = 3;
break;
case NullNan:
strcpy(buf, "null");
cnt = 4;
break;
case HugeNan:
default:
strcpy(buf, nan_val);
cnt = sizeof(nan_val) - 1;
break;
}
}
} else if (d == (double)(long long int)d) {
cnt = snprintf(buf, sizeof(buf), "%.1f", d);
} else if (0 == out->opts->float_prec) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
cnt = RSTRING_LEN(rstr);
if ((int)sizeof(buf) <= cnt) {
cnt = sizeof(buf) - 1;
}
strncpy(buf, rb_string_value_ptr((VALUE*)&rstr), cnt);
buf[cnt] = '\0';
} else {
cnt = snprintf(buf, sizeof(buf), out->opts->float_fmt, d);
}
if (out->end - out->cur <= (long)cnt) {
grow(out, cnt);
}
for (b = buf; '\0' != *b; b++) {
*out->cur++ = *b;
}
*out->cur = '\0';
}
static void
dump_cstr(const char *str, size_t cnt, int is_sym, int escape1, Out out) {
size_t size;
char *cmap;
switch (out->opts->escape_mode) {
case NLEsc:
cmap = newline_friendly_chars;
size = newline_friendly_size((uint8_t*)str, cnt);
break;
case ASCIIEsc:
cmap = ascii_friendly_chars;
size = ascii_friendly_size((uint8_t*)str, cnt);
break;
case XSSEsc:
cmap = xss_friendly_chars;
size = xss_friendly_size((uint8_t*)str, cnt);
break;
case JSONEsc:
default:
cmap = hibit_friendly_chars;
size = hibit_friendly_size((uint8_t*)str, cnt);
}
if (out->end - out->cur <= (long)size + BUFFER_EXTRA) { // extra 10 for escaped first char, quotes, and sym
grow(out, size + BUFFER_EXTRA);
}
*out->cur++ = '"';
if (escape1) {
*out->cur++ = '\\';
*out->cur++ = 'u';
*out->cur++ = '0';
*out->cur++ = '0';
dump_hex((uint8_t)*str, out);
cnt--;
size--;
str++;
is_sym = 0; // just to make sure
}
if (cnt == size) {
if (is_sym) {
*out->cur++ = ':';
}
for (; '\0' != *str; str++) {
*out->cur++ = *str;
}
*out->cur++ = '"';
} else {
const char *end = str + cnt;
if (is_sym) {
*out->cur++ = ':';
}
for (; str < end; str++) {
switch (cmap[(uint8_t)*str]) {
case '1':
*out->cur++ = *str;
break;
case '2':
*out->cur++ = '\\';
switch (*str) {
case '\\': *out->cur++ = '\\'; break;
case '\b': *out->cur++ = 'b'; break;
case '\t': *out->cur++ = 't'; break;
case '\n': *out->cur++ = 'n'; break;
case '\f': *out->cur++ = 'f'; break;
case '\r': *out->cur++ = 'r'; break;
default: *out->cur++ = *str; break;
}
break;
case '3': // Unicode
str = dump_unicode(str, end, out);
break;
case '6': // control characters
*out->cur++ = '\\';
*out->cur++ = 'u';
*out->cur++ = '0';
*out->cur++ = '0';
dump_hex((uint8_t)*str, out);
break;
default:
break; // ignore, should never happen if the table is correct
}
}
*out->cur++ = '"';
}
*out->cur = '\0';
}
static void
dump_str_comp(VALUE obj, Out out) {
dump_cstr(rb_string_value_ptr((VALUE*)&obj), RSTRING_LEN(obj), 0, 0, out);
}
static void
dump_str_obj(VALUE obj, VALUE clas, int depth, Out out) {
if (Qundef != clas && rb_cString != clas) {
dump_obj_attrs(obj, clas, 0, depth, out);
} else {
const char *s = rb_string_value_ptr((VALUE*)&obj);
size_t len = RSTRING_LEN(obj);
char s1 = s[1];
dump_cstr(s, len, 0, (':' == *s || ('^' == *s && ('r' == s1 || 'i' == s1))), out);
}
}
static void
dump_sym_comp(VALUE obj, Out out) {
const char *sym = rb_id2name(SYM2ID(obj));
dump_cstr(sym, strlen(sym), 0, 0, out);
}
static void
dump_sym_obj(VALUE obj, Out out) {
const char *sym = rb_id2name(SYM2ID(obj));
size_t len = strlen(sym);
dump_cstr(sym, len, 1, 0, out);
}
static void
dump_class_comp(VALUE obj, Out out) {
const char *s = rb_class2name(obj);
dump_cstr(s, strlen(s), 0, 0, out);
}
static void
dump_class_obj(VALUE obj, Out out) {
const char *s = rb_class2name(obj);
size_t len = strlen(s);
if (out->end - out->cur <= 6) {
grow(out, 6);
}
*out->cur++ = '{';
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'c';
*out->cur++ = '"';
*out->cur++ = ':';
dump_cstr(s, len, 0, 0, out);
*out->cur++ = '}';
*out->cur = '\0';
}
static void
dump_array(VALUE a, VALUE clas, int depth, Out out) {
size_t size;
int i, cnt;
int d2 = depth + 1;
long id = check_circular(a, out);
if (id < 0) {
return;
}
if (Qundef != clas && rb_cArray != clas && ObjectMode == out->opts->mode) {
dump_obj_attrs(a, clas, 0, depth, out);
return;
}
cnt = (int)RARRAY_LEN(a);
*out->cur++ = '[';
if (0 < id) {
size = d2 * out->indent + 16;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'i';
dump_ulong(id, out);
*out->cur++ = '"';
}
size = 2;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
if (0 == cnt) {
*out->cur++ = ']';
} else {
if (0 < id) {
*out->cur++ = ',';
}
if (out->opts->dump_opts.use) {
size = d2 * out->opts->dump_opts.indent_size + out->opts->dump_opts.array_size + 1;
} else {
size = d2 * out->indent + 2;
}
cnt--;
for (i = 0; i <= cnt; i++) {
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
if (out->opts->dump_opts.use) {
if (0 < out->opts->dump_opts.array_size) {
strcpy(out->cur, out->opts->dump_opts.array_nl);
out->cur += out->opts->dump_opts.array_size;
}
if (0 < out->opts->dump_opts.indent_size) {
int i;
for (i = d2; 0 < i; i--) {
strcpy(out->cur, out->opts->dump_opts.indent_str);
out->cur += out->opts->dump_opts.indent_size;
}
}
} else {
fill_indent(out, d2);
}
dump_val(rb_ary_entry(a, i), d2, out, 0, 0);
if (i < cnt) {
*out->cur++ = ',';
}
}
size = depth * out->indent + 1;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
if (out->opts->dump_opts.use) {
//printf("*** d2: %u indent: %u '%s'\n", d2, out->opts->dump_opts->indent_size, out->opts->dump_opts->indent);
if (0 < out->opts->dump_opts.array_size) {
strcpy(out->cur, out->opts->dump_opts.array_nl);
out->cur += out->opts->dump_opts.array_size;
}
if (0 < out->opts->dump_opts.indent_size) {
int i;
for (i = depth; 0 < i; i--) {
strcpy(out->cur, out->opts->dump_opts.indent_str);
out->cur += out->opts->dump_opts.indent_size;
}
}
} else {
fill_indent(out, depth);
}
*out->cur++ = ']';
}
*out->cur = '\0';
}
static int
hash_cb_strict(VALUE key, VALUE value, Out out) {
int depth = out->depth;
long size;
if (rb_type(key) != T_STRING) {
rb_raise(rb_eTypeError, "In :strict mode all Hash keys must be Strings, not %s.\n", rb_class2name(rb_obj_class(key)));
}
if (out->omit_nil && Qnil == value) {
return ST_CONTINUE;
}
if (!out->opts->dump_opts.use) {
size = depth * out->indent + 1;
if (out->end - out->cur <= size) {
grow(out, size);
}
fill_indent(out, depth);
dump_str_comp(key, out);
*out->cur++ = ':';
} else {
size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
if (out->end - out->cur <= size) {
grow(out, size);
}
if (0 < out->opts->dump_opts.hash_size) {
strcpy(out->cur, out->opts->dump_opts.hash_nl);
out->cur += out->opts->dump_opts.hash_size;
}
if (0 < out->opts->dump_opts.indent_size) {
int i;
for (i = depth; 0 < i; i--) {
strcpy(out->cur, out->opts->dump_opts.indent_str);
out->cur += out->opts->dump_opts.indent_size;
}
}
dump_str_comp(key, out);
size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
if (out->end - out->cur <= size) {
grow(out, size);
}
if (0 < out->opts->dump_opts.before_size) {
strcpy(out->cur, out->opts->dump_opts.before_sep);
out->cur += out->opts->dump_opts.before_size;
}
*out->cur++ = ':';
if (0 < out->opts->dump_opts.after_size) {
strcpy(out->cur, out->opts->dump_opts.after_sep);
out->cur += out->opts->dump_opts.after_size;
}
}
dump_val(value, depth, out, 0, 0);
out->depth = depth;
*out->cur++ = ',';
return ST_CONTINUE;
}
static int
hash_cb_compat(VALUE key, VALUE value, Out out) {
int depth = out->depth;
long size;
if (out->omit_nil && Qnil == value) {
return ST_CONTINUE;
}
if (!out->opts->dump_opts.use) {
size = depth * out->indent + 1;
if (out->end - out->cur <= size) {
grow(out, size);
}
fill_indent(out, depth);
} else {
size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
if (out->end - out->cur <= size) {
grow(out, size);
}
if (0 < out->opts->dump_opts.hash_size) {
strcpy(out->cur, out->opts->dump_opts.hash_nl);
out->cur += out->opts->dump_opts.hash_size;
}
if (0 < out->opts->dump_opts.indent_size) {
int i;
for (i = depth; 0 < i; i--) {
strcpy(out->cur, out->opts->dump_opts.indent_str);
out->cur += out->opts->dump_opts.indent_size;
}
}
}
switch (rb_type(key)) {
case T_STRING:
dump_str_comp(key, out);
break;
case T_SYMBOL:
dump_sym_comp(key, out);
break;
default:
/*rb_raise(rb_eTypeError, "In :compat mode all Hash keys must be Strings or Symbols, not %s.\n", rb_class2name(rb_obj_class(key)));*/
dump_str_comp(rb_funcall(key, oj_to_s_id, 0), out);
break;
}
if (!out->opts->dump_opts.use) {
*out->cur++ = ':';
} else {
size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
if (out->end - out->cur <= size) {
grow(out, size);
}
if (0 < out->opts->dump_opts.before_size) {
strcpy(out->cur, out->opts->dump_opts.before_sep);
out->cur += out->opts->dump_opts.before_size;
}
*out->cur++ = ':';
if (0 < out->opts->dump_opts.after_size) {
strcpy(out->cur, out->opts->dump_opts.after_sep);
out->cur += out->opts->dump_opts.after_size;
}
}
dump_val(value, depth, out, 0, 0);
out->depth = depth;
*out->cur++ = ',';
return ST_CONTINUE;
}
static int
hash_cb_object(VALUE key, VALUE value, Out out) {
int depth = out->depth;
long size = depth * out->indent + 1;
if (out->omit_nil && Qnil == value) {
return ST_CONTINUE;
}
if (out->end - out->cur <= size) {
grow(out, size);
}
fill_indent(out, depth);
if (rb_type(key) == T_STRING) {
dump_str_obj(key, Qundef, depth, out);
*out->cur++ = ':';
dump_val(value, depth, out, 0, 0);
} else if (rb_type(key) == T_SYMBOL) {
dump_sym_obj(key, out);
*out->cur++ = ':';
dump_val(value, depth, out, 0, 0);
} else {
int d2 = depth + 1;
long s2 = size + out->indent + 1;
int i;
int started = 0;
uint8_t b;
if (out->end - out->cur <= s2 + 15) {
grow(out, s2 + 15);
}
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = '#';
out->hash_cnt++;
for (i = 28; 0 <= i; i -= 4) {
b = (uint8_t)((out->hash_cnt >> i) & 0x0000000F);
if ('\0' != b) {
started = 1;
}
if (started) {
*out->cur++ = hex_chars[b];
}
}
*out->cur++ = '"';
*out->cur++ = ':';
*out->cur++ = '[';
fill_indent(out, d2);
dump_val(key, d2, out, 0, 0);
if (out->end - out->cur <= (long)s2) {
grow(out, s2);
}
*out->cur++ = ',';
fill_indent(out, d2);
dump_val(value, d2, out, 0, 0);
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, depth);
*out->cur++ = ']';
}
out->depth = depth;
*out->cur++ = ',';
return ST_CONTINUE;
}
static void
dump_hash(VALUE obj, VALUE clas, int depth, int mode, Out out) {
int cnt;
size_t size;
if (Qundef != clas && rb_cHash != clas && ObjectMode == mode) {
dump_obj_attrs(obj, clas, 0, depth, out);
return;
}
cnt = (int)RHASH_SIZE(obj);
size = depth * out->indent + 2;
if (out->end - out->cur <= 2) {
grow(out, 2);
}
if (0 == cnt) {
*out->cur++ = '{';
*out->cur++ = '}';
} else {
long id = check_circular(obj, out);
if (0 > id) {
return;
}
*out->cur++ = '{';
if (0 < id) {
if (out->end - out->cur <= (long)size + 16) {
grow(out, size + 16);
}
fill_indent(out, depth + 1);
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'i';
*out->cur++ = '"';
*out->cur++ = ':';
dump_ulong(id, out);
*out->cur++ = ',';
}
out->depth = depth + 1;
if (ObjectMode == mode) {
rb_hash_foreach(obj, hash_cb_object, (VALUE)out);
} else if (CompatMode == mode) {
rb_hash_foreach(obj, hash_cb_compat, (VALUE)out);
} else {
rb_hash_foreach(obj, hash_cb_strict, (VALUE)out);
}
if (',' == *(out->cur - 1)) {
out->cur--; // backup to overwrite last comma
}
if (!out->opts->dump_opts.use) {
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, depth);
} else {
size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
if (0 < out->opts->dump_opts.hash_size) {
strcpy(out->cur, out->opts->dump_opts.hash_nl);
out->cur += out->opts->dump_opts.hash_size;
}
if (0 < out->opts->dump_opts.indent_size) {
int i;
for (i = depth; 0 < i; i--) {
strcpy(out->cur, out->opts->dump_opts.indent_str);
out->cur += out->opts->dump_opts.indent_size;
}
}
}
*out->cur++ = '}';
}
*out->cur = '\0';
}
static void
dump_time(VALUE obj, Out out, int withZone) {
char buf[64];
char *b = buf + sizeof(buf) - 1;
long size;
char *dot;
int neg = 0;
long one = 1000000000;
#if HAS_RB_TIME_TIMESPEC
struct timespec ts = rb_time_timespec(obj);
time_t sec = ts.tv_sec;
long nsec = ts.tv_nsec;
#else
time_t sec = NUM2LONG(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
#if HAS_NANO_TIME
long long nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
#else
long long nsec = rb_num2ll(rb_funcall2(obj, oj_tv_usec_id, 0, 0)) * 1000;
#endif
#endif
*b-- = '\0';
if (withZone) {
long tzsecs = NUM2LONG(rb_funcall2(obj, oj_utc_offset_id, 0, 0));
int zneg = (0 > tzsecs);
if (0 == tzsecs && Qtrue == rb_funcall2(obj, oj_utcq_id, 0, 0)) {
tzsecs = 86400;
}
if (zneg) {
tzsecs = -tzsecs;
}
if (0 == tzsecs) {
*b-- = '0';
} else {
for (; 0 < tzsecs; b--, tzsecs /= 10) {
*b = '0' + (tzsecs % 10);
}
if (zneg) {
*b-- = '-';
}
}
*b-- = 'e';
}
if (0 > sec) {
neg = 1;
sec = -sec;
if (0 < nsec) {
nsec = 1000000000 - nsec;
sec--;
}
}
dot = b - 9;
if (0 < out->opts->sec_prec) {
if (9 > out->opts->sec_prec) {
int i;
for (i = 9 - out->opts->sec_prec; 0 < i; i--) {
dot++;
nsec = (nsec + 5) / 10;
one /= 10;
}
}
if (one <= nsec) {
nsec -= one;
sec++;
}
for (; dot < b; b--, nsec /= 10) {
*b = '0' + (nsec % 10);
}
*b-- = '.';
}
if (0 == sec) {
*b-- = '0';
} else {
for (; 0 < sec; b--, sec /= 10) {
*b = '0' + (sec % 10);
}
}
if (neg) {
*b-- = '-';
}
b++;
size = sizeof(buf) - (b - buf) - 1;
if (out->end - out->cur <= size) {
grow(out, size);
}
memcpy(out->cur, b, size);
out->cur += size;
*out->cur = '\0';
}
static void
dump_ruby_time(VALUE obj, Out out) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
}
static void
dump_xml_time(VALUE obj, Out out) {
char buf[64];
struct tm *tm;
long one = 1000000000;
#if HAS_RB_TIME_TIMESPEC
struct timespec ts = rb_time_timespec(obj);
time_t sec = ts.tv_sec;
long nsec = ts.tv_nsec;
#else
time_t sec = NUM2LONG(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
#if HAS_NANO_TIME
long long nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
#else
long long nsec = rb_num2ll(rb_funcall2(obj, oj_tv_usec_id, 0, 0)) * 1000;
#endif
#endif
long tzsecs = NUM2LONG(rb_funcall2(obj, oj_utc_offset_id, 0, 0));
int tzhour, tzmin;
char tzsign = '+';
if (out->end - out->cur <= 36) {
grow(out, 36);
}
if (9 > out->opts->sec_prec) {
int i;
for (i = 9 - out->opts->sec_prec; 0 < i; i--) {
nsec = (nsec + 5) / 10;
one /= 10;
}
if (one <= nsec) {
nsec -= one;
sec++;
}
}
// 2012-01-05T23:58:07.123456000+09:00
//tm = localtime(&sec);
sec += tzsecs;
tm = gmtime(&sec);
#if 1
if (0 > tzsecs) {
tzsign = '-';
tzhour = (int)(tzsecs / -3600);
tzmin = (int)(tzsecs / -60) - (tzhour * 60);
} else {
tzhour = (int)(tzsecs / 3600);
tzmin = (int)(tzsecs / 60) - (tzhour * 60);
}
#else
if (0 > tm->tm_gmtoff) {
tzsign = '-';
tzhour = (int)(tm->tm_gmtoff / -3600);
tzmin = (int)(tm->tm_gmtoff / -60) - (tzhour * 60);
} else {
tzhour = (int)(tm->tm_gmtoff / 3600);
tzmin = (int)(tm->tm_gmtoff / 60) - (tzhour * 60);
}
#endif
if (0 == nsec || 0 == out->opts->sec_prec) {
if (0 == tzsecs && Qtrue == rb_funcall2(obj, oj_utcq_id, 0, 0)) {
sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02dZ",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
dump_cstr(buf, 20, 0, 0, out);
} else {
sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec,
tzsign, tzhour, tzmin);
dump_cstr(buf, 25, 0, 0, out);
}
} else if (0 == tzsecs && Qtrue == rb_funcall2(obj, oj_utcq_id, 0, 0)) {
char format[64] = "%04d-%02d-%02dT%02d:%02d:%02d.%09ldZ";
int len = 30;
if (9 > out->opts->sec_prec) {
format[32] = '0' + out->opts->sec_prec;
len -= 9 - out->opts->sec_prec;
}
sprintf(buf, format,
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, nsec);
dump_cstr(buf, len, 0, 0, out);
} else {
char format[64] = "%04d-%02d-%02dT%02d:%02d:%02d.%09ld%c%02d:%02d";
int len = 35;
if (9 > out->opts->sec_prec) {
format[32] = '0' + out->opts->sec_prec;
len -= 9 - out->opts->sec_prec;
}
sprintf(buf, format,
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, nsec,
tzsign, tzhour, tzmin);
dump_cstr(buf, len, 0, 0, out);
}
}
static void
dump_data_strict(VALUE obj, Out out) {
VALUE clas = rb_obj_class(obj);
if (oj_bigdecimal_class == clas) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_raw(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), out);
} else {
raise_strict(obj);
}
}
static void
dump_data_null(VALUE obj, Out out) {
VALUE clas = rb_obj_class(obj);
if (oj_bigdecimal_class == clas) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_raw(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), out);
} else {
dump_nil(out);
}
}
static void
dump_data_comp(VALUE obj, int depth, Out out) {
VALUE clas = rb_obj_class(obj);
if (rb_respond_to(obj, oj_to_hash_id)) {
volatile VALUE h = rb_funcall(obj, oj_to_hash_id, 0);
if (T_HASH != rb_type(h)) {
// It seems that ActiveRecord implemented to_hash so that it returns
// an Array and not a Hash. To get around that any value returned
// will be dumped.
//rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
dump_val(h, depth, out, 0, 0);
}
dump_hash(h, Qundef, depth, out->opts->mode, out);
} else if (Yes == out->opts->bigdec_as_num && oj_bigdecimal_class == clas) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_raw(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), out);
} else if (rb_respond_to(obj, oj_as_json_id)) {
volatile VALUE aj = rb_funcall(obj, oj_as_json_id, 0);
// Catch the obvious brain damaged recursive dumping.
if (aj == obj) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
} else {
dump_val(aj, depth, out, 0, 0);
}
} else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
volatile VALUE rs;
const char *s;
int len;
rs = rb_funcall(obj, oj_to_json_id, 0);
s = rb_string_value_ptr((VALUE*)&rs);
len = (int)RSTRING_LEN(rs);
if (out->end - out->cur <= len + 1) {
grow(out, len);
}
memcpy(out->cur, s, len);
out->cur += len;
*out->cur = '\0';
} else {
if (rb_cTime == clas) {
switch (out->opts->time_format) {
case RubyTime: dump_ruby_time(obj, out); break;
case XmlTime: dump_xml_time(obj, out); break;
case UnixZTime: dump_time(obj, out, 1); break;
case UnixTime:
default: dump_time(obj, out, 0); break;
}
} else if (oj_bigdecimal_class == clas) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
} else {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
}
}
}
static void
dump_data_obj(VALUE obj, int depth, Out out) {
VALUE clas = rb_obj_class(obj);
if (rb_cTime == clas) {
if (out->end - out->cur <= 6) {
grow(out, 6);
}
*out->cur++ = '{';
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 't';
*out->cur++ = '"';
*out->cur++ = ':';
switch (out->opts->time_format) {
case RubyTime: // Does not output fractional seconds
case XmlTime:
dump_xml_time(obj, out);
break;
case UnixZTime:
dump_time(obj, out, 1);
break;
case UnixTime:
default:
dump_time(obj, out, 0);
break;
}
*out->cur++ = '}';
*out->cur = '\0';
} else {
if (oj_bigdecimal_class == clas) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
if (Yes == out->opts->bigdec_as_num) {
dump_raw(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), out);
} else {
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
}
} else {
dump_nil(out);
}
}
}
static void
dump_obj_comp(VALUE obj, int depth, Out out, int argc, VALUE *argv) {
if (rb_respond_to(obj, oj_to_hash_id)) {
volatile VALUE h = rb_funcall(obj, oj_to_hash_id, 0);
if (T_HASH != rb_type(h)) {
// It seems that ActiveRecord implemented to_hash so that it returns
// an Array and not a Hash. To get around that any value returned
// will be dumped.
//rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
dump_val(h, depth, out, 0, 0);
} else {
dump_hash(h, Qundef, depth, out->opts->mode, out);
}
} else if (rb_respond_to(obj, oj_as_json_id)) {
volatile VALUE aj = rb_funcall2(obj, oj_as_json_id, argc, argv);
// Catch the obvious brain damaged recursive dumping.
if (aj == obj) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
} else {
dump_val(aj, depth, out, 0, 0);
}
} else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
volatile VALUE rs;
const char *s;
int len;
rs = rb_funcall(obj, oj_to_json_id, 0);
s = rb_string_value_ptr((VALUE*)&rs);
len = (int)RSTRING_LEN(rs);
if (out->end - out->cur <= len + 1) {
grow(out, len);
}
memcpy(out->cur, s, len);
out->cur += len;
*out->cur = '\0';
} else {
VALUE clas = rb_obj_class(obj);
if (oj_bigdecimal_class == clas) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
if (Yes == out->opts->bigdec_as_num) {
dump_raw(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), out);
} else {
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
}
#if (defined T_RATIONAL && defined RRATIONAL)
} else if (oj_datetime_class == clas || oj_date_class == clas || rb_cRational == clas) {
#else
} else if (oj_datetime_class == clas || oj_date_class == clas) {
#endif
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
} else {
dump_obj_attrs(obj, Qundef, 0, depth, out);
}
}
*out->cur = '\0';
}
inline static void
dump_obj_obj(VALUE obj, int depth, Out out) {
long id = check_circular(obj, out);
if (0 <= id) {
VALUE clas = rb_obj_class(obj);
if (oj_bigdecimal_class == clas) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_raw(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), out);
} else {
dump_obj_attrs(obj, clas, id, depth, out);
}
}
}
#ifdef RUBINIUS_RUBY
static int
isRbxHashAttr(const char *attr) {
const char *hashAttrs[] = {
"@capacity",
"@max_entries",
"@state",
"@mask",
"@size",
"@entries",
"@default_proc",
0 };
const char **ap;
for (ap = hashAttrs; 0 != *ap; ap++) {
if (0 == strcmp(attr, *ap)) {
return 1;
}
}
return 0;
}
#endif
#if HAS_IVAR_HELPERS
static int
dump_attr_cb(ID key, VALUE value, Out out) {
int depth = out->depth;
size_t size = depth * out->indent + 1;
const char *attr = rb_id2name(key);
if (out->omit_nil && Qnil == value) {
return ST_CONTINUE;
}
#if HAS_EXCEPTION_MAGIC
if (0 == strcmp("bt", attr) || 0 == strcmp("mesg", attr)) {
return ST_CONTINUE;
}
#endif
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, depth);
if ('@' == *attr) {
attr++;
dump_cstr(attr, strlen(attr), 0, 0, out);
} else {
char buf[32];
*buf = '~';
strncpy(buf + 1, attr, sizeof(buf) - 2);
buf[sizeof(buf) - 1] = '\0';
dump_cstr(buf, strlen(buf), 0, 0, out);
}
*out->cur++ = ':';
dump_val(value, depth, out, 0, 0);
out->depth = depth;
*out->cur++ = ',';
return ST_CONTINUE;
}
#endif
static void
dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out) {
size_t size = 0;
int d2 = depth + 1;
int type = rb_type(obj);
if (out->end - out->cur <= 2) {
grow(out, 2);
}
*out->cur++ = '{';
if (Qundef != clas) {
const char *class_name = rb_class2name(clas);
int clen = (int)strlen(class_name);
size = d2 * out->indent + clen + 10;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'o';
*out->cur++ = '"';
*out->cur++ = ':';
dump_cstr(class_name, clen, 0, 0, out);
}
if (0 < id) {
size = d2 * out->indent + 16;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = ',';
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'i';
*out->cur++ = '"';
*out->cur++ = ':';
dump_ulong(id, out);
}
switch (type) {
case T_STRING:
size = d2 * out->indent + 14;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = ',';
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = 's';
*out->cur++ = 'e';
*out->cur++ = 'l';
*out->cur++ = 'f';
*out->cur++ = '"';
*out->cur++ = ':';
dump_cstr(rb_string_value_ptr((VALUE*)&obj), RSTRING_LEN(obj), 0, 0, out);
break;
case T_ARRAY:
size = d2 * out->indent + 14;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = ',';
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = 's';
*out->cur++ = 'e';
*out->cur++ = 'l';
*out->cur++ = 'f';
*out->cur++ = '"';
*out->cur++ = ':';
dump_array(obj, Qundef, depth + 1, out);
break;
case T_HASH:
size = d2 * out->indent + 14;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = ',';
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = 's';
*out->cur++ = 'e';
*out->cur++ = 'l';
*out->cur++ = 'f';
*out->cur++ = '"';
*out->cur++ = ':';
dump_hash(obj, Qundef, depth + 1, out->opts->mode, out);
break;
default:
break;
}
{
int cnt;
#if HAS_IVAR_HELPERS
cnt = (int)rb_ivar_count(obj);
#else
volatile VALUE vars = rb_funcall2(obj, oj_instance_variables_id, 0, 0);
VALUE *np = RARRAY_PTR(vars);
ID vid;
const char *attr;
int i;
int first = 1;
cnt = (int)RARRAY_LEN(vars);
#endif
if (Qundef != clas && 0 < cnt) {
*out->cur++ = ',';
}
out->depth = depth + 1;
#if HAS_IVAR_HELPERS
rb_ivar_foreach(obj, dump_attr_cb, (VALUE)out);
if (',' == *(out->cur - 1)) {
out->cur--; // backup to overwrite last comma
}
#else
size = d2 * out->indent + 1;
for (i = cnt; 0 < i; i--, np++) {
VALUE value;
vid = rb_to_id(*np);
attr = rb_id2name(vid);
#ifdef RUBINIUS_RUBY
if (T_HASH == type && isRbxHashAttr(attr)) {
continue;
}
#endif
value = rb_ivar_get(obj, vid);
if (out->omit_nil && Qnil == value) {
continue;
}
if (first) {
first = 0;
} else {
*out->cur++ = ',';
}
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
if ('@' == *attr) {
attr++;
dump_cstr(attr, strlen(attr), 0, 0, out);
} else {
char buf[32];
*buf = '~';
strncpy(buf + 1, attr, sizeof(buf) - 2);
buf[sizeof(buf) - 1] = '\0';
dump_cstr(buf, strlen(attr) + 1, 0, 0, out);
}
*out->cur++ = ':';
dump_val(value, d2, out, 0, 0);
if (out->end - out->cur <= 2) {
grow(out, 2);
}
}
#endif
#if HAS_EXCEPTION_MAGIC
if (Qtrue == rb_obj_is_kind_of(obj, rb_eException)) {
volatile VALUE rv;
if (',' != *(out->cur - 1)) {
*out->cur++ = ',';
}
// message
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
dump_cstr("~mesg", 5, 0, 0, out);
*out->cur++ = ':';
rv = rb_funcall2(obj, rb_intern("message"), 0, 0);
dump_val(rv, d2, out, 0, 0);
if (out->end - out->cur <= 2) {
grow(out, 2);
}
*out->cur++ = ',';
// backtrace
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
dump_cstr("~bt", 3, 0, 0, out);
*out->cur++ = ':';
rv = rb_funcall2(obj, rb_intern("backtrace"), 0, 0);
dump_val(rv, d2, out, 0, 0);
if (out->end - out->cur <= 2) {
grow(out, 2);
}
}
#endif
out->depth = depth;
}
fill_indent(out, depth);
*out->cur++ = '}';
*out->cur = '\0';
}
static void
dump_struct_comp(VALUE obj, int depth, Out out) {
if (rb_respond_to(obj, oj_to_hash_id)) {
volatile VALUE h = rb_funcall(obj, oj_to_hash_id, 0);
if (T_HASH != rb_type(h)) {
// It seems that ActiveRecord implemented to_hash so that it returns
// an Array and not a Hash. To get around that any value returned
// will be dumped.
//rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
dump_val(h, depth, out, 0, 0);
}
dump_hash(h, Qundef, depth, out->opts->mode, out);
} else if (rb_respond_to(obj, oj_as_json_id)) {
volatile VALUE aj = rb_funcall(obj, oj_as_json_id, 0);
// Catch the obvious brain damaged recursive dumping.
if (aj == obj) {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
} else {
dump_val(aj, depth, out, 0, 0);
}
} else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
volatile VALUE rs = rb_funcall(obj, oj_to_json_id, 0);
const char *s;
int len;
s = rb_string_value_ptr((VALUE*)&rs);
len = (int)RSTRING_LEN(rs);
if (out->end - out->cur <= len) {
grow(out, len);
}
memcpy(out->cur, s, len);
out->cur += len;
} else {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
}
}
static void
dump_struct_obj(VALUE obj, int depth, Out out) {
VALUE clas = rb_obj_class(obj);
const char *class_name = rb_class2name(clas);
int i;
int d2 = depth + 1;
int d3 = d2 + 1;
size_t len = strlen(class_name);
size_t size = d2 * out->indent + d3 * out->indent + 10 + len;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = '{';
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'u';
*out->cur++ = '"';
*out->cur++ = ':';
*out->cur++ = '[';
if ('#' == *class_name) {
VALUE ma = rb_struct_s_members(clas);
const char *name;
int cnt = (int)RARRAY_LEN(ma);
*out->cur++ = '[';
for (i = 0; i < cnt; i++) {
name = rb_id2name(SYM2ID(rb_ary_entry(ma, i)));
len = strlen(name);
size = len + 3;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
if (0 < i) {
*out->cur++ = ',';
}
*out->cur++ = '"';
memcpy(out->cur, name, len);
out->cur += len;
*out->cur++ = '"';
}
*out->cur++ = ']';
} else {
fill_indent(out, d3);
*out->cur++ = '"';
memcpy(out->cur, class_name, len);
out->cur += len;
*out->cur++ = '"';
}
*out->cur++ = ',';
size = d3 * out->indent + 2;
#ifdef RSTRUCT_LEN
{
const VALUE *vp;
#ifndef RSTRUCT_CONST_PTR
# define RSTRUCT_CONST_PTR(st) (const VALUE *)RSTRUCT_PTR(st)
#endif
for (i = (int)RSTRUCT_LEN(obj), vp = RSTRUCT_CONST_PTR(obj); 0 < i; i--, vp++) {
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d3);
dump_val(*vp, d3, out, 0, 0);
*out->cur++ = ',';
}
}
#else
{
// This is a bit risky as a struct in C ruby is not the same as a Struct
// class in interpreted Ruby so length() may not be defined.
int slen = FIX2INT(rb_funcall2(obj, oj_length_id, 0, 0));
for (i = 0; i < slen; i++) {
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d3);
dump_val(rb_struct_aref(obj, INT2FIX(i)), d3, out, 0, 0);
*out->cur++ = ',';
}
}
#endif
out->cur--;
*out->cur++ = ']';
*out->cur++ = '}';
*out->cur = '\0';
}
static void
dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
ID *idp;
AttrGetFunc *fp;
volatile VALUE v;
const char *name;
size_t size;
int d2 = depth + 1;
if (out->end - out->cur <= 2) {
grow(out, 2);
}
*out->cur++ = '{';
if (Qundef != clas) {
const char *class_name = rb_class2name(clas);
int clen = (int)strlen(class_name);
size = d2 * out->indent + clen + 10;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
*out->cur++ = '"';
*out->cur++ = '^';
*out->cur++ = 'O';
*out->cur++ = '"';
*out->cur++ = ':';
dump_cstr(class_name, clen, 0, 0, out);
*out->cur++ = ',';
}
if (odd->raw) {
v = rb_funcall(obj, *odd->attrs, 0);
if (Qundef == v || T_STRING != rb_type(v)) {
rb_raise(rb_eEncodingError, "Invalid type for raw JSON.\n");
} else {
const char *s = rb_string_value_ptr((VALUE*)&v);
int len = RSTRING_LEN(v);
const char *name = rb_id2name(*odd->attrs);
size_t nlen = strlen(name);
size = len + d2 * out->indent + nlen + 10;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
*out->cur++ = '"';
memcpy(out->cur, name, nlen);
out->cur += nlen;
*out->cur++ = '"';
*out->cur++ = ':';
memcpy(out->cur, s, len);
out->cur += len;
*out->cur = '\0';
}
} else {
size = d2 * out->indent + 1;
for (idp = odd->attrs, fp = odd->attrFuncs; 0 != *idp; idp++, fp++) {
size_t nlen;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
name = rb_id2name(*idp);
nlen = strlen(name);
if (0 != *fp) {
v = (*fp)(obj);
} else if (0 == strchr(name, '.')) {
v = rb_funcall(obj, *idp, 0);
} else {
char nbuf[256];
char *n2 = nbuf;
char *n;
char *end;
ID i;
if (sizeof(nbuf) <= nlen) {
n2 = strdup(name);
} else {
strcpy(n2, name);
}
n = n2;
v = obj;
while (0 != (end = strchr(n, '.'))) {
*end = '\0';
i = rb_intern(n);
v = rb_funcall(v, i, 0);
n = end + 1;
}
i = rb_intern(n);
v = rb_funcall(v, i, 0);
if (nbuf != n2) {
free(n2);
}
}
fill_indent(out, d2);
dump_cstr(name, nlen, 0, 0, out);
*out->cur++ = ':';
dump_val(v, d2, out, 0, 0);
if (out->end - out->cur <= 2) {
grow(out, 2);
}
*out->cur++ = ',';
}
out->cur--;
}
*out->cur++ = '}';
*out->cur = '\0';
}
static void
raise_strict(VALUE obj) {
rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in strict mode.\n", rb_class2name(rb_obj_class(obj)));
}
static void
dump_val(VALUE obj, int depth, Out out, int argc, VALUE *argv) {
int type = rb_type(obj);
if (MAX_DEPTH < depth) {
rb_raise(rb_eNoMemError, "Too deeply nested.\n");
}
#ifdef OJ_DEBUG
printf("Oj-debug: dump_val %s\n", rb_class2name(rb_obj_class(obj)));
#endif
switch (type) {
case T_NIL: dump_nil(out); break;
case T_TRUE: dump_true(out); break;
case T_FALSE: dump_false(out); break;
case T_FIXNUM: dump_fixnum(obj, out); break;
case T_FLOAT: dump_float(obj, out); break;
case T_MODULE:
case T_CLASS:
switch (out->opts->mode) {
case StrictMode: raise_strict(obj); break;
case NullMode: dump_nil(out); break;
case CompatMode: dump_class_comp(obj, out); break;
case ObjectMode:
default: dump_class_obj(obj, out); break;
}
break;
case T_SYMBOL:
switch (out->opts->mode) {
case StrictMode: raise_strict(obj); break;
case NullMode: dump_nil(out); break;
case CompatMode: dump_sym_comp(obj, out); break;
case ObjectMode:
default: dump_sym_obj(obj, out); break;
}
break;
case T_STRUCT: // for Range
switch (out->opts->mode) {
case StrictMode: raise_strict(obj); break;
case NullMode: dump_nil(out); break;
case CompatMode: dump_struct_comp(obj, depth, out); break;
case ObjectMode:
default: dump_struct_obj(obj, depth, out); break;
}
break;
default:
// Most developers have enough sense not to subclass primitive types but
// since these classes could potentially be subclassed a check for odd
// classes is performed.
{
VALUE clas = rb_obj_class(obj);
Odd odd;
if (ObjectMode == out->opts->mode && 0 != (odd = oj_get_odd(clas))) {
dump_odd(obj, odd, clas, depth + 1, out);
return;
}
switch (type) {
case T_BIGNUM: dump_bignum(obj, out); break;
case T_STRING:
switch (out->opts->mode) {
case StrictMode:
case NullMode:
case CompatMode: dump_str_comp(obj, out); break;
case ObjectMode:
default: dump_str_obj(obj, clas, depth, out); break;
}
break;
case T_ARRAY: dump_array(obj, clas, depth, out); break;
case T_HASH: dump_hash(obj, clas, depth, out->opts->mode, out); break;
#if (defined T_RATIONAL && defined RRATIONAL)
case T_RATIONAL:
#endif
case T_OBJECT:
switch (out->opts->mode) {
case StrictMode: dump_data_strict(obj, out); break;
case NullMode: dump_data_null(obj, out); break;
case CompatMode: dump_obj_comp(obj, depth, out, argc, argv); break;
case ObjectMode:
default: dump_obj_obj(obj, depth, out); break;
}
break;
case T_DATA:
switch (out->opts->mode) {
case StrictMode: dump_data_strict(obj, out); break;
case NullMode: dump_data_null(obj, out); break;
case CompatMode: dump_data_comp(obj, depth, out);break;
case ObjectMode:
default: dump_data_obj(obj, depth, out); break;
}
break;
#if (defined T_COMPLEX && defined RCOMPLEX)
case T_COMPLEX:
#endif
case T_REGEXP:
switch (out->opts->mode) {
case StrictMode: raise_strict(obj); break;
case NullMode: dump_nil(out); break;
case CompatMode:
case ObjectMode:
default: dump_obj_comp(obj, depth, out, argc, argv); break;
}
break;
default:
switch (out->opts->mode) {
case StrictMode: raise_strict(obj); break;
case NullMode: dump_nil(out); break;
case CompatMode: {
volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
dump_cstr(rb_string_value_ptr((VALUE*)&rstr), RSTRING_LEN(rstr), 0, 0, out);
break;
}
case ObjectMode:
default:
rb_raise(rb_eNotImpError, "Failed to dump '%s' Object (%02x)\n",
rb_class2name(rb_obj_class(obj)), rb_type(obj));
break;
}
break;
}
}
}
}
void
oj_dump_obj_to_json(VALUE obj, Options copts, Out out) {
oj_dump_obj_to_json_using_params(obj, copts, out, 0, 0);
}
void
oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv) {
if (0 == out->buf) {
out->buf = ALLOC_N(char, 4096);
out->end = out->buf + 4095 - BUFFER_EXTRA; // 1 less than end plus extra for possible errors
out->allocated = 1;
}
out->cur = out->buf;
out->circ_cnt = 0;
out->opts = copts;
out->hash_cnt = 0;
if (Yes == copts->circular) {
oj_cache8_new(&out->circ_cache);
}
out->indent = copts->indent;
dump_val(obj, 0, out, argc, argv);
if (0 < out->indent) {
switch (*(out->cur - 1)) {
case ']':
case '}':
grow(out, 1);
*out->cur++ = '\n';
default:
break;
}
}
*out->cur = '\0';
if (Yes == copts->circular) {
oj_cache8_delete(out->circ_cache);
}
}
void
oj_write_obj_to_file(VALUE obj, const char *path, Options copts) {
char buf[4096];
struct _Out out;
size_t size;
FILE *f;
int ok;
out.buf = buf;
out.end = buf + sizeof(buf) - BUFFER_EXTRA;
out.allocated = 0;
out.omit_nil = copts->dump_opts.omit_nil;
oj_dump_obj_to_json(obj, copts, &out);
size = out.cur - out.buf;
if (0 == (f = fopen(path, "w"))) {
if (out.allocated) {
xfree(out.buf);
}
rb_raise(rb_eIOError, "%s\n", strerror(errno));
}
ok = (size == fwrite(out.buf, 1, size, f));
if (out.allocated) {
xfree(out.buf);
}
fclose(f);
if (!ok) {
int err = ferror(f);
rb_raise(rb_eIOError, "Write failed. [%d:%s]\n", err, strerror(err));
}
}
void
oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
char buf[4096];
struct _Out out;
ssize_t size;
VALUE clas = rb_obj_class(stream);
#if !IS_WINDOWS
int fd;
VALUE s;
#endif
out.buf = buf;
out.end = buf + sizeof(buf) - BUFFER_EXTRA;
out.allocated = 0;
oj_dump_obj_to_json(obj, copts, &out);
out.omit_nil = copts->dump_opts.omit_nil;
size = out.cur - out.buf;
if (oj_stringio_class == clas) {
rb_funcall(stream, oj_write_id, 1, rb_str_new(out.buf, size));
#if !IS_WINDOWS
} else if (rb_respond_to(stream, oj_fileno_id) &&
Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
0 != (fd = FIX2INT(s))) {
if (size != write(fd, out.buf, size)) {
if (out.allocated) {
xfree(out.buf);
}
rb_raise(rb_eIOError, "Write failed. [%d:%s]\n", errno, strerror(errno));
}
#endif
} else if (rb_respond_to(stream, oj_write_id)) {
rb_funcall(stream, oj_write_id, 1, rb_str_new(out.buf, size));
} else {
if (out.allocated) {
xfree(out.buf);
}
rb_raise(rb_eArgError, "to_stream() expected an IO Object.");
}
if (out.allocated) {
xfree(out.buf);
}
}
// dump leaf functions
inline static void
dump_chars(const char *s, size_t size, Out out) {
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
memcpy(out->cur, s, size);
out->cur += size;
*out->cur = '\0';
}
static void
dump_leaf_str(Leaf leaf, Out out) {
switch (leaf->value_type) {
case STR_VAL:
dump_cstr(leaf->str, strlen(leaf->str), 0, 0, out);
break;
case RUBY_VAL:
dump_cstr(rb_string_value_cstr(&leaf->value), RSTRING_LEN(leaf->value), 0, 0, out);
break;
case COL_VAL:
default:
rb_raise(rb_eTypeError, "Unexpected value type %02x.\n", leaf->value_type);
break;
}
}
static void
dump_leaf_fixnum(Leaf leaf, Out out) {
switch (leaf->value_type) {
case STR_VAL:
dump_chars(leaf->str, strlen(leaf->str), out);
break;
case RUBY_VAL:
if (T_BIGNUM == rb_type(leaf->value)) {
dump_bignum(leaf->value, out);
} else {
dump_fixnum(leaf->value, out);
}
break;
case COL_VAL:
default:
rb_raise(rb_eTypeError, "Unexpected value type %02x.\n", leaf->value_type);
break;
}
}
static void
dump_leaf_float(Leaf leaf, Out out) {
switch (leaf->value_type) {
case STR_VAL:
dump_chars(leaf->str, strlen(leaf->str), out);
break;
case RUBY_VAL:
dump_float(leaf->value, out);
break;
case COL_VAL:
default:
rb_raise(rb_eTypeError, "Unexpected value type %02x.\n", leaf->value_type);
break;
}
}
static void
dump_leaf_array(Leaf leaf, int depth, Out out) {
size_t size;
int d2 = depth + 1;
size = 2;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = '[';
if (0 == leaf->elements) {
*out->cur++ = ']';
} else {
Leaf first = leaf->elements->next;
Leaf e = first;
size = d2 * out->indent + 2;
do {
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
dump_leaf(e, d2, out);
if (e->next != first) {
*out->cur++ = ',';
}
e = e->next;
} while (e != first);
size = depth * out->indent + 1;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, depth);
*out->cur++ = ']';
}
*out->cur = '\0';
}
static void
dump_leaf_hash(Leaf leaf, int depth, Out out) {
size_t size;
int d2 = depth + 1;
size = 2;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
*out->cur++ = '{';
if (0 == leaf->elements) {
*out->cur++ = '}';
} else {
Leaf first = leaf->elements->next;
Leaf e = first;
size = d2 * out->indent + 2;
do {
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, d2);
dump_cstr(e->key, strlen(e->key), 0, 0, out);
*out->cur++ = ':';
dump_leaf(e, d2, out);
if (e->next != first) {
*out->cur++ = ',';
}
e = e->next;
} while (e != first);
size = depth * out->indent + 1;
if (out->end - out->cur <= (long)size) {
grow(out, size);
}
fill_indent(out, depth);
*out->cur++ = '}';
}
*out->cur = '\0';
}
static void
dump_leaf(Leaf leaf, int depth, Out out) {
switch (leaf->rtype) {
case T_NIL:
dump_nil(out);
break;
case T_TRUE:
dump_true(out);
break;
case T_FALSE:
dump_false(out);
break;
case T_STRING:
dump_leaf_str(leaf, out);
break;
case T_FIXNUM:
dump_leaf_fixnum(leaf, out);
break;
case T_FLOAT:
dump_leaf_float(leaf, out);
break;
case T_ARRAY:
dump_leaf_array(leaf, depth, out);
break;
case T_HASH:
dump_leaf_hash(leaf, depth, out);
break;
default:
rb_raise(rb_eTypeError, "Unexpected type %02x.\n", leaf->rtype);
break;
}
}
void
oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out) {
if (0 == out->buf) {
out->buf = ALLOC_N(char, 4096);
out->end = out->buf + 4095 - BUFFER_EXTRA; // 1 less than end plus extra for possible errors
out->allocated = 1;
}
out->cur = out->buf;
out->circ_cnt = 0;
out->opts = copts;
out->hash_cnt = 0;
out->indent = copts->indent;
dump_leaf(leaf, 0, out);
}
void
oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts) {
char buf[4096];
struct _Out out;
size_t size;
FILE *f;
out.buf = buf;
out.end = buf + sizeof(buf) - BUFFER_EXTRA;
out.allocated = 0;
oj_dump_leaf_to_json(leaf, copts, &out);
out.omit_nil = copts->dump_opts.omit_nil;
size = out.cur - out.buf;
if (0 == (f = fopen(path, "w"))) {
rb_raise(rb_eIOError, "%s\n", strerror(errno));
}
if (size != fwrite(out.buf, 1, size, f)) {
int err = ferror(f);
rb_raise(rb_eIOError, "Write failed. [%d:%s]\n", err, strerror(err));
}
if (out.allocated) {
xfree(out.buf);
}
fclose(f);
}
// string writer functions
static void
key_check(StrWriter sw, const char *key) {
DumpType type = sw->types[sw->depth];
if (0 == key && (ObjectNew == type || ObjectType == type)) {
rb_raise(rb_eStandardError, "Can not push onto an Object without a key.");
}
}
static void
push_type(StrWriter sw, DumpType type) {
if (sw->types_end <= sw->types + sw->depth + 1) {
size_t size = (sw->types_end - sw->types) * 2;
REALLOC_N(sw->types, char, size);
sw->types_end = sw->types + size;
}
sw->depth++;
sw->types[sw->depth] = type;
}
static void
maybe_comma(StrWriter sw) {
switch (sw->types[sw->depth]) {
case ObjectNew:
sw->types[sw->depth] = ObjectType;
break;
case ArrayNew:
sw->types[sw->depth] = ArrayType;
break;
case ObjectType:
case ArrayType:
// Always have a few characters available in the out.buf.
*sw->out.cur++ = ',';
break;
}
}
void
oj_str_writer_push_key(StrWriter sw, const char *key) {
DumpType type = sw->types[sw->depth];
long size;
if (sw->keyWritten) {
rb_raise(rb_eStandardError, "Can not push more than one key before pushing a non-key.");
}
if (ObjectNew != type && ObjectType != type) {
rb_raise(rb_eStandardError, "Can only push a key onto an Object.");
}
size = sw->depth * sw->out.indent + 3;
if (sw->out.end - sw->out.cur <= (long)size) {
grow(&sw->out, size);
}
maybe_comma(sw);
if (0 < sw->depth) {
fill_indent(&sw->out, sw->depth);
}
dump_cstr(key, strlen(key), 0, 0, &sw->out);
*sw->out.cur++ = ':';
sw->keyWritten = 1;
}
void
oj_str_writer_push_object(StrWriter sw, const char *key) {
if (sw->keyWritten) {
sw->keyWritten = 0;
if (sw->out.end - sw->out.cur <= 1) {
grow(&sw->out, 1);
}
} else {
long size;
key_check(sw, key);
size = sw->depth * sw->out.indent + 3;
if (sw->out.end - sw->out.cur <= (long)size) {
grow(&sw->out, size);
}
maybe_comma(sw);
if (0 < sw->depth) {
fill_indent(&sw->out, sw->depth);
}
if (0 != key) {
dump_cstr(key, strlen(key), 0, 0, &sw->out);
*sw->out.cur++ = ':';
}
}
*sw->out.cur++ = '{';
push_type(sw, ObjectNew);
}
void
oj_str_writer_push_array(StrWriter sw, const char *key) {
if (sw->keyWritten) {
sw->keyWritten = 0;
if (sw->out.end - sw->out.cur <= 1) {
grow(&sw->out, 1);
}
} else {
long size;
key_check(sw, key);
size = sw->depth * sw->out.indent + 3;
if (sw->out.end - sw->out.cur <= size) {
grow(&sw->out, size);
}
maybe_comma(sw);
if (0 < sw->depth) {
fill_indent(&sw->out, sw->depth);
}
if (0 != key) {
dump_cstr(key, strlen(key), 0, 0, &sw->out);
*sw->out.cur++ = ':';
}
}
*sw->out.cur++ = '[';
push_type(sw, ArrayNew);
}
void
oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key) {
if (sw->keyWritten) {
sw->keyWritten = 0;
} else {
long size;
key_check(sw, key);
size = sw->depth * sw->out.indent + 3;
if (sw->out.end - sw->out.cur <= size) {
grow(&sw->out, size);
}
maybe_comma(sw);
if (0 < sw->depth) {
fill_indent(&sw->out, sw->depth);
}
if (0 != key) {
dump_cstr(key, strlen(key), 0, 0, &sw->out);
*sw->out.cur++ = ':';
}
}
dump_val(val, sw->depth, &sw->out, 0, 0);
}
void
oj_str_writer_push_json(StrWriter sw, const char *json, const char *key) {
if (sw->keyWritten) {
sw->keyWritten = 0;
} else {
long size;
key_check(sw, key);
size = sw->depth * sw->out.indent + 3;
if (sw->out.end - sw->out.cur <= size) {
grow(&sw->out, size);
}
maybe_comma(sw);
if (0 < sw->depth) {
fill_indent(&sw->out, sw->depth);
}
if (0 != key) {
dump_cstr(key, strlen(key), 0, 0, &sw->out);
*sw->out.cur++ = ':';
}
}
dump_raw(json, strlen(json), &sw->out);
}
void
oj_str_writer_pop(StrWriter sw) {
long size;
DumpType type = sw->types[sw->depth];
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) {
rb_raise(rb_eStandardError, "Can not pop with no open array or object.");
}
size = sw->depth * sw->out.indent + 2;
if (sw->out.end - sw->out.cur <= size) {
grow(&sw->out, size);
}
fill_indent(&sw->out, sw->depth);
switch (type) {
case ObjectNew:
case ObjectType:
*sw->out.cur++ = '}';
break;
case ArrayNew:
case ArrayType:
*sw->out.cur++ = ']';
break;
}
if (0 == sw->depth && 0 <= sw->out.indent) {
*sw->out.cur++ = '\n';
}
}
void
oj_str_writer_pop_all(StrWriter sw) {
while (0 < sw->depth) {
oj_str_writer_pop(sw);
}
}
oj-2.17.4/ext/oj/oj.h 0000644 0000041 0000041 00000021333 12766161567 014261 0 ustar www-data www-data /* oj.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_H__
#define __OJ_H__
#if defined(__cplusplus)
extern "C" {
#if 0
} /* satisfy cc-mode */
#endif
#endif
#define RSTRING_NOT_MODIFIED
#include "ruby.h"
#if HAS_ENCODING_SUPPORT
#include "ruby/encoding.h"
#endif
#include "stdint.h"
#include "stdbool.h"
#if USE_PTHREAD_MUTEX
#include
#endif
#include "cache8.h"
#ifdef RUBINIUS_RUBY
#undef T_RATIONAL
#undef T_COMPLEX
enum st_retval {ST_CONTINUE = 0, ST_STOP = 1, ST_DELETE = 2, ST_CHECK};
#else
#if HAS_TOP_LEVEL_ST_H
// Only on travis, local is where it is for all others. Seems to vary depending on the travis machine picked up.
#include "st.h"
#else
#include "ruby/st.h"
#endif
#endif
#include "err.h"
#define INF_VAL "3.0e14159265358979323846"
#define NINF_VAL "-3.0e14159265358979323846"
#define NAN_VAL "3.3e14159265358979323846"
typedef enum {
Yes = 'y',
No = 'n',
NotSet = 0
} YesNo;
typedef enum {
StrictMode = 's',
ObjectMode = 'o',
NullMode = 'n',
CompatMode = 'c'
} Mode;
typedef enum {
UnixTime = 'u',
UnixZTime = 'z',
XmlTime = 'x',
RubyTime = 'r'
} TimeFormat;
typedef enum {
NLEsc = 'n',
JSONEsc = 'j',
XSSEsc = 'x',
ASCIIEsc = 'a'
} Encoding;
typedef enum {
BigDec = 'b',
FloatDec = 'f',
AutoDec = 'a'
} BigLoad;
typedef enum {
ArrayNew = 'A',
ArrayType = 'a',
ObjectNew = 'O',
ObjectType = 'o',
} DumpType;
typedef enum {
AutoNan = 'a',
NullNan = 'n',
HugeNan = 'h',
WordNan = 'w',
RaiseNan = 'r',
} NanDump;
typedef enum {
STRING_IO = 'c',
STREAM_IO = 's',
FILE_IO = 'f',
} StreamWriterType;
typedef struct _DumpOpts {
bool use;
char indent_str[16];
char before_sep[16];
char after_sep[16];
char hash_nl[16];
char array_nl[16];
uint8_t indent_size;
uint8_t before_size;
uint8_t after_size;
uint8_t hash_size;
uint8_t array_size;
char nan_dump; // NanDump
bool omit_nil;
} *DumpOpts;
typedef struct _Options {
int indent; // indention for dump, default 2
char circular; // YesNo
char auto_define; // YesNo
char sym_key; // YesNo
char escape_mode; // Escape_Mode
char mode; // Mode
char class_cache; // YesNo
char time_format; // TimeFormat
char bigdec_as_num; // YesNo
char bigdec_load; // BigLoad
char to_json; // YesNo
char nilnil; // YesNo
char allow_gc; // allow GC during parse
char quirks_mode; // allow single JSON values instead of documents
char allow_invalid; // YesNo - allow invalid unicode
const char *create_id; // 0 or string
size_t create_id_len; // length of create_id
int sec_prec; // second precision when dumping time
char float_prec; // float precision, linked to float_fmt
char float_fmt[7]; // float format for dumping, if empty use Ruby
VALUE hash_class; // class to use in place of Hash on load
struct _DumpOpts dump_opts;
} *Options;
typedef struct _Out {
char *buf;
char *end;
char *cur;
Cache8 circ_cache;
slot_t circ_cnt;
int indent;
int depth; // used by dump_hash
Options opts;
uint32_t hash_cnt;
int allocated;
bool omit_nil;
} *Out;
typedef struct _StrWriter {
struct _Out out;
struct _Options opts;
int depth;
char *types; // DumpType
char *types_end;
int keyWritten;
} *StrWriter;
typedef struct _StreamWriter {
struct _StrWriter sw;
StreamWriterType type;
VALUE stream;
int fd;
} *StreamWriter;
enum {
NO_VAL = 0x00,
STR_VAL = 0x01,
COL_VAL = 0x02,
RUBY_VAL = 0x03
};
typedef struct _Leaf {
struct _Leaf *next;
union {
const char *key; // hash key
size_t index; // array index, 0 is not set
};
union {
char *str; // pointer to location in json string or allocated
struct _Leaf *elements; // array and hash elements
VALUE value;
};
uint8_t rtype;
uint8_t parent_type;
uint8_t value_type;
} *Leaf;
extern VALUE oj_saj_parse(int argc, VALUE *argv, VALUE self);
extern VALUE oj_sc_parse(int argc, VALUE *argv, VALUE self);
extern VALUE oj_strict_parse(int argc, VALUE *argv, VALUE self);
extern VALUE oj_strict_sparse(int argc, VALUE *argv, VALUE self);
extern VALUE oj_compat_parse(int argc, VALUE *argv, VALUE self);
extern VALUE oj_object_parse(int argc, VALUE *argv, VALUE self);
extern VALUE oj_strict_parse_cstr(int argc, VALUE *argv, char *json, size_t len);
extern VALUE oj_compat_parse_cstr(int argc, VALUE *argv, char *json, size_t len);
extern VALUE oj_object_parse_cstr(int argc, VALUE *argv, char *json, size_t len);
extern void oj_parse_options(VALUE ropts, Options copts);
extern void oj_dump_obj_to_json(VALUE obj, Options copts, Out out);
extern void oj_dump_obj_to_json_using_params(VALUE obj, Options copts, Out out, int argc, VALUE *argv);
extern void oj_write_obj_to_file(VALUE obj, const char *path, Options copts);
extern void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts);
extern void oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out);
extern void oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts);
extern void oj_str_writer_push_key(StrWriter sw, const char *key);
extern void oj_str_writer_push_object(StrWriter sw, const char *key);
extern void oj_str_writer_push_array(StrWriter sw, const char *key);
extern void oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key);
extern void oj_str_writer_push_json(StrWriter sw, const char *json, const char *key);
extern void oj_str_writer_pop(StrWriter sw);
extern void oj_str_writer_pop_all(StrWriter sw);
extern void oj_init_doc(void);
extern VALUE Oj;
extern struct _Options oj_default_options;
#if HAS_ENCODING_SUPPORT
extern rb_encoding *oj_utf8_encoding;
#else
extern VALUE oj_utf8_encoding;
#endif
extern VALUE oj_bag_class;
extern VALUE oj_bigdecimal_class;
extern VALUE oj_cstack_class;
extern VALUE oj_date_class;
extern VALUE oj_datetime_class;
extern VALUE oj_doc_class;
extern VALUE oj_stream_writer_class;
extern VALUE oj_string_writer_class;
extern VALUE oj_stringio_class;
extern VALUE oj_struct_class;
extern VALUE oj_slash_string;
extern ID oj_add_value_id;
extern ID oj_array_append_id;
extern ID oj_array_end_id;
extern ID oj_array_start_id;
extern ID oj_as_json_id;
extern ID oj_error_id;
extern ID oj_file_id;
extern ID oj_fileno_id;
extern ID oj_ftype_id;
extern ID oj_hash_end_id;
extern ID oj_hash_key_id;
extern ID oj_hash_set_id;
extern ID oj_hash_start_id;
extern ID oj_iconv_id;
extern ID oj_instance_variables_id;
extern ID oj_json_create_id;
extern ID oj_length_id;
extern ID oj_new_id;
extern ID oj_parse_id;
extern ID oj_pos_id;
extern ID oj_read_id;
extern ID oj_readpartial_id;
extern ID oj_replace_id;
extern ID oj_stat_id;
extern ID oj_string_id;
extern ID oj_to_hash_id;
extern ID oj_to_json_id;
extern ID oj_to_s_id;
extern ID oj_to_sym_id;
extern ID oj_to_time_id;
extern ID oj_tv_nsec_id;
extern ID oj_tv_sec_id;
extern ID oj_tv_usec_id;
extern ID oj_utc_id;
extern ID oj_utc_offset_id;
extern ID oj_utcq_id;
extern ID oj_write_id;
#if USE_PTHREAD_MUTEX
extern pthread_mutex_t oj_cache_mutex;
#elif USE_RB_MUTEX
extern VALUE oj_cache_mutex;
#endif
#if defined(__cplusplus)
#if 0
{ /* satisfy cc-mode */
#endif
} /* extern "C" { */
#endif
#endif /* __OJ_H__ */
oj-2.17.4/ext/oj/oj.c 0000644 0000041 0000041 00000247611 12766161567 014265 0 ustar www-data www-data /* oj.c
* Copyright (c) 2012, Peter Ohler
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include
#include
#include "oj.h"
#include "parse.h"
#include "hash.h"
#include "odd.h"
#include "encode.h"
typedef struct _YesNoOpt {
VALUE sym;
char *attr;
} *YesNoOpt;
void Init_oj();
VALUE Oj = Qnil;
ID oj_add_value_id;
ID oj_array_append_id;
ID oj_array_end_id;
ID oj_array_start_id;
ID oj_as_json_id;
ID oj_error_id;
ID oj_file_id;
ID oj_fileno_id;
ID oj_ftype_id;
ID oj_hash_end_id;
ID oj_hash_key_id;
ID oj_hash_set_id;
ID oj_hash_start_id;
ID oj_iconv_id;
ID oj_instance_variables_id;
ID oj_json_create_id;
ID oj_length_id;
ID oj_new_id;
ID oj_parse_id;
ID oj_pos_id;
ID oj_read_id;
ID oj_readpartial_id;
ID oj_replace_id;
ID oj_stat_id;
ID oj_string_id;
ID oj_to_hash_id;
ID oj_to_json_id;
ID oj_to_s_id;
ID oj_to_sym_id;
ID oj_to_time_id;
ID oj_tv_nsec_id;
ID oj_tv_sec_id;
ID oj_tv_usec_id;
ID oj_utc_id;
ID oj_utc_offset_id;
ID oj_utcq_id;
ID oj_write_id;
static ID has_key_id;
VALUE oj_bag_class;
VALUE oj_bigdecimal_class;
VALUE oj_cstack_class;
VALUE oj_date_class;
VALUE oj_datetime_class;
VALUE oj_parse_error_class;
VALUE oj_stream_writer_class;
VALUE oj_string_writer_class;
VALUE oj_stringio_class;
VALUE oj_struct_class;
VALUE oj_slash_string;
static VALUE allow_gc_sym;
static VALUE allow_invalid_unicode_sym;
static VALUE ascii_only_sym;
static VALUE ascii_sym;
static VALUE auto_define_sym;
static VALUE auto_sym;
static VALUE bigdecimal_as_decimal_sym;
static VALUE bigdecimal_load_sym;
static VALUE bigdecimal_sym;
static VALUE circular_sym;
static VALUE class_cache_sym;
static VALUE compat_sym;
static VALUE create_id_sym;
static VALUE escape_mode_sym;
static VALUE float_prec_sym;
static VALUE float_sym;
static VALUE hash_class_sym;
static VALUE huge_sym;
static VALUE indent_sym;
static VALUE json_parser_error_class;
static VALUE json_sym;
static VALUE mode_sym;
static VALUE nan_sym;
static VALUE newline_sym;
static VALUE nilnil_sym;
static VALUE null_sym;
static VALUE object_sym;
static VALUE omit_nil_sym;
static VALUE quirks_mode_sym;
static VALUE raise_sym;
static VALUE ruby_sym;
static VALUE sec_prec_sym;
static VALUE strict_sym;
static VALUE symbol_keys_sym;
static VALUE time_format_sym;
static VALUE unix_sym;
static VALUE unix_zone_sym;
static VALUE use_to_json_sym;
static VALUE word_sym;
static VALUE xmlschema_sym;
static VALUE xss_safe_sym;
static VALUE array_nl_sym;
static VALUE create_additions_sym;
static VALUE object_nl_sym;
static VALUE space_before_sym;
static VALUE space_sym;
static VALUE symbolize_names_sym;
static VALUE mimic = Qnil;
#if HAS_ENCODING_SUPPORT
rb_encoding *oj_utf8_encoding = 0;
#else
VALUE oj_utf8_encoding = Qnil;
#endif
#if USE_PTHREAD_MUTEX
pthread_mutex_t oj_cache_mutex;
#elif USE_RB_MUTEX
VALUE oj_cache_mutex = Qnil;
#endif
static const char json_class[] = "json_class";
struct _Options oj_default_options = {
0, // indent
No, // circular
No, // auto_define
No, // sym_key
JSONEsc, // escape_mode
ObjectMode, // mode
Yes, // class_cache
UnixZTime, // time_format
Yes, // bigdec_as_num
AutoDec, // bigdec_load
Yes, // to_json
No, // nilnil
Yes, // allow_gc
Yes, // quirks_mode
No, // allow_invalid
json_class, // create_id
10, // create_id_len
9, // sec_prec
15, // float_prec
"%0.15g", // float_fmt
Qnil, // hash_class
{ // dump_opts
false, //use
"", // indent
"", // before_sep
"", // after_sep
"", // hash_nl
"", // array_nl
0, // indent_size
0, // before_size
0, // after_size
0, // hash_size
0, // array_size
AutoNan,// nan_dump
false, // omit_nil
}
};
static VALUE define_mimic_json(int argc, VALUE *argv, VALUE self);
/* call-seq: default_options() => Hash
*
* Returns the default load and dump options as a Hash. The options are
* - indent: [Fixnum|String|nil] number of spaces to indent each element in an JSON document, zero or nil is no newline between JSON elements, negative indicates no newline between top level JSON elements in a stream, a String indicates the string should be used for indentation
* - circular: [true|false|nil] support circular references while dumping
* - auto_define: [true|false|nil] automatically define classes if they do not exist
* - symbol_keys: [true|false|nil] use symbols instead of strings for hash keys
* - escape_mode: [:newline|:json|:xss_safe|:ascii|nil] determines the characters to escape
* - class_cache: [true|false|nil] cache classes for faster parsing (if dynamically modifying classes or reloading classes then don't use this)
* - mode: [:object|:strict|:compat|:null] load and dump modes to use for JSON
* - time_format: [:unix|:unix_zone|:xmlschema|:ruby] time format when dumping in :compat and :object mode
* - bigdecimal_as_decimal: [true|false|nil] dump BigDecimal as a decimal number or as a String
* - bigdecimal_load: [:bigdecimal|:float|:auto] load decimals as BigDecimal instead of as a Float. :auto pick the most precise for the number of digits.
* - create_id: [String|nil] create id for json compatible object encoding, default is 'json_create'
* - second_precision: [Fixnum|nil] number of digits after the decimal when dumping the seconds portion of time
* - float_precision: [Fixnum|nil] number of digits of precision when dumping floats, 0 indicates use Ruby
* - use_to_json: [true|false|nil] call to_json() methods on dump, default is false
* - nilnil: [true|false|nil] if true a nil input to load will return nil and not raise an Exception
* - allow_gc: [true|false|nil] allow or prohibit GC during parsing, default is true (allow)
* - quirks_mode: [true,|false|nil] Allow single JSON values instead of documents, default is true (allow)
* - allow_invalid_unicode: [true,|false|nil] Allow invalid unicode, default is false (don't allow)
* - indent_str: [String|nil] String to use for indentation, overriding the indent option is not nil
* - space: [String|nil] String to use for the space after the colon in JSON object fields
* - space_before: [String|nil] String to use before the colon separator in JSON object fields
* - object_nl: [String|nil] String to use after a JSON object field value
* - array_nl: [String|nil] String to use after a JSON array value
* - nan: [:null|:huge|:word|:raise|:auto] how to dump Infinity and NaN in null, strict, and compat mode. :null places a null, :huge places a huge number, :word places Infinity or NaN, :raise raises and exception, :auto uses default for each mode.
* - hash_class: [Class|nil] Class to use instead of Hash on load
* - omit_nil: [true|false] if true Hash and Object attributes with nil values are omitted
* @return [Hash] all current option settings.
*/
static VALUE
get_def_opts(VALUE self) {
VALUE opts = rb_hash_new();
if (0 == oj_default_options.dump_opts.indent_size) {
rb_hash_aset(opts, indent_sym, INT2FIX(oj_default_options.indent));
} else {
rb_hash_aset(opts, indent_sym, rb_str_new2(oj_default_options.dump_opts.indent_str));
}
rb_hash_aset(opts, sec_prec_sym, INT2FIX(oj_default_options.sec_prec));
rb_hash_aset(opts, circular_sym, (Yes == oj_default_options.circular) ? Qtrue : ((No == oj_default_options.circular) ? Qfalse : Qnil));
rb_hash_aset(opts, class_cache_sym, (Yes == oj_default_options.class_cache) ? Qtrue : ((No == oj_default_options.class_cache) ? Qfalse : Qnil));
rb_hash_aset(opts, auto_define_sym, (Yes == oj_default_options.auto_define) ? Qtrue : ((No == oj_default_options.auto_define) ? Qfalse : Qnil));
rb_hash_aset(opts, symbol_keys_sym, (Yes == oj_default_options.sym_key) ? Qtrue : ((No == oj_default_options.sym_key) ? Qfalse : Qnil));
rb_hash_aset(opts, bigdecimal_as_decimal_sym, (Yes == oj_default_options.bigdec_as_num) ? Qtrue : ((No == oj_default_options.bigdec_as_num) ? Qfalse : Qnil));
rb_hash_aset(opts, use_to_json_sym, (Yes == oj_default_options.to_json) ? Qtrue : ((No == oj_default_options.to_json) ? Qfalse : Qnil));
rb_hash_aset(opts, nilnil_sym, (Yes == oj_default_options.nilnil) ? Qtrue : ((No == oj_default_options.nilnil) ? Qfalse : Qnil));
rb_hash_aset(opts, allow_gc_sym, (Yes == oj_default_options.allow_gc) ? Qtrue : ((No == oj_default_options.allow_gc) ? Qfalse : Qnil));
rb_hash_aset(opts, quirks_mode_sym, (Yes == oj_default_options.quirks_mode) ? Qtrue : ((No == oj_default_options.quirks_mode) ? Qfalse : Qnil));
rb_hash_aset(opts, allow_invalid_unicode_sym, (Yes == oj_default_options.allow_invalid) ? Qtrue : ((No == oj_default_options.allow_invalid) ? Qfalse : Qnil));
rb_hash_aset(opts, float_prec_sym, INT2FIX(oj_default_options.float_prec));
switch (oj_default_options.mode) {
case StrictMode: rb_hash_aset(opts, mode_sym, strict_sym); break;
case CompatMode: rb_hash_aset(opts, mode_sym, compat_sym); break;
case NullMode: rb_hash_aset(opts, mode_sym, null_sym); break;
case ObjectMode:
default: rb_hash_aset(opts, mode_sym, object_sym); break;
}
switch (oj_default_options.escape_mode) {
case NLEsc: rb_hash_aset(opts, escape_mode_sym, newline_sym); break;
case JSONEsc: rb_hash_aset(opts, escape_mode_sym, json_sym); break;
case XSSEsc: rb_hash_aset(opts, escape_mode_sym, xss_safe_sym); break;
case ASCIIEsc: rb_hash_aset(opts, escape_mode_sym, ascii_sym); break;
default: rb_hash_aset(opts, escape_mode_sym, json_sym); break;
}
switch (oj_default_options.time_format) {
case XmlTime: rb_hash_aset(opts, time_format_sym, xmlschema_sym); break;
case RubyTime: rb_hash_aset(opts, time_format_sym, ruby_sym); break;
case UnixZTime: rb_hash_aset(opts, time_format_sym, unix_zone_sym); break;
case UnixTime:
default: rb_hash_aset(opts, time_format_sym, unix_sym); break;
}
switch (oj_default_options.bigdec_load) {
case BigDec: rb_hash_aset(opts, bigdecimal_load_sym, bigdecimal_sym);break;
case FloatDec: rb_hash_aset(opts, bigdecimal_load_sym, float_sym); break;
case AutoDec:
default: rb_hash_aset(opts, bigdecimal_load_sym, auto_sym); break;
}
rb_hash_aset(opts, create_id_sym, (0 == oj_default_options.create_id) ? Qnil : rb_str_new2(oj_default_options.create_id));
rb_hash_aset(opts, space_sym, (0 == oj_default_options.dump_opts.after_size) ? Qnil : rb_str_new2(oj_default_options.dump_opts.after_sep));
rb_hash_aset(opts, space_before_sym, (0 == oj_default_options.dump_opts.before_size) ? Qnil : rb_str_new2(oj_default_options.dump_opts.before_sep));
rb_hash_aset(opts, object_nl_sym, (0 == oj_default_options.dump_opts.hash_size) ? Qnil : rb_str_new2(oj_default_options.dump_opts.hash_nl));
rb_hash_aset(opts, array_nl_sym, (0 == oj_default_options.dump_opts.array_size) ? Qnil : rb_str_new2(oj_default_options.dump_opts.array_nl));
switch (oj_default_options.dump_opts.nan_dump) {
case NullNan: rb_hash_aset(opts, nan_sym, null_sym); break;
case RaiseNan: rb_hash_aset(opts, nan_sym, raise_sym); break;
case WordNan: rb_hash_aset(opts, nan_sym, word_sym); break;
case HugeNan: rb_hash_aset(opts, nan_sym, huge_sym); break;
case AutoNan:
default: rb_hash_aset(opts, nan_sym, auto_sym); break;
}
rb_hash_aset(opts, omit_nil_sym, oj_default_options.dump_opts.omit_nil ? Qtrue : Qfalse);
rb_hash_aset(opts, hash_class_sym, oj_default_options.hash_class);
return opts;
}
/* call-seq: default_options=(opts)
*
* Sets the default options for load and dump.
* @param [Hash] opts options to change
* @param [Fixnum|String|nil] :indent number of spaces to indent each element in a JSON document or the String to use for identation.
* @param [true|false|nil] :circular support circular references while dumping
* @param [true|false|nil] :auto_define automatically define classes if they do not exist
* @param [true|false|nil] :symbol_keys convert hash keys to symbols
* @param [true|false|nil] :class_cache cache classes for faster parsing
* @param [:newline|:json|:xss_safe|:ascii|nil] :escape mode encodes all high-bit characters as
* escaped sequences if :ascii, :json is standand UTF-8 JSON encoding,
* :newline is the same as :json but newlines are not escaped,
* and :xss_safe escapes &, <, and >, and some others.
* @param [true|false|nil] :bigdecimal_as_decimal dump BigDecimal as a decimal number or as a String
* @param [:bigdecimal|:float|:auto|nil] :bigdecimal_load load decimals as BigDecimal instead of as a Float. :auto pick the most precise for the number of digits.
* @param [:object|:strict|:compat|:null] load and dump mode to use for JSON
* :strict raises an exception when a non-supported Object is
* encountered. :compat attempts to extract variable values from an
* Object using to_json() or to_hash() then it walks the Object's
* variables if neither is found. The :object mode ignores to_hash()
* and to_json() methods and encodes variables using code internal to
* the Oj gem. The :null mode ignores non-supported Objects and
* replaces them with a null.
* @param [:unix|:xmlschema|:ruby] time format when dumping in :compat mode
* :unix decimal number denoting the number of seconds since 1/1/1970,
* :unix_zone decimal number denoting the number of seconds since 1/1/1970 plus the utc_offset in the exponent ,
* :xmlschema date-time format taken from XML Schema as a String,
* :ruby Time.to_s formatted String
* @param [String|nil] :create_id create id for json compatible object encoding
* @param [Fixnum|nil] :second_precision number of digits after the decimal when dumping the seconds portion of time
* @param [Fixnum|nil] :float_precision number of digits of precision when dumping floats, 0 indicates use Ruby
* @param [true|false|nil] :use_to_json call to_json() methods on dump, default is false
* @param [true|false|nil] :nilnil if true a nil input to load will return nil and not raise an Exception
* @param [true|false|nil] :allow_gc allow or prohibit GC during parsing, default is true (allow)
* @param [true|false|nil] :quirks_mode allow single JSON values instead of documents, default is true (allow)
* @param [true|false|nil] :allow_invalid_unicode allow invalid unicode, default is false (don't allow)
* @param [String|nil] :space String to use for the space after the colon in JSON object fields
* @param [String|nil] :space_before String to use before the colon separator in JSON object fields
* @param [String|nil] :object_nl String to use after a JSON object field value
* @param [String|nil] :array_nl String to use after a JSON array value
* @param [:null|:huge|:word|:raise] :nan how to dump Infinity and NaN in null, strict, and compat mode. :null places a null, :huge places a huge number, :word places Infinity or NaN, :raise raises and exception, :auto uses default for each mode.
* @param [Class|nil] :hash_class Class to use instead of Hash on load
* @param [true|false] :omit_nil if true Hash and Object attributes with nil values are omitted
* @return [nil]
*/
static VALUE
set_def_opts(VALUE self, VALUE opts) {
Check_Type(opts, T_HASH);
oj_parse_options(opts, &oj_default_options);
return Qnil;
}
void
oj_parse_options(VALUE ropts, Options copts) {
struct _YesNoOpt ynos[] = {
{ circular_sym, &copts->circular },
{ auto_define_sym, &copts->auto_define },
{ symbol_keys_sym, &copts->sym_key },
{ class_cache_sym, &copts->class_cache },
{ bigdecimal_as_decimal_sym, &copts->bigdec_as_num },
{ use_to_json_sym, &copts->to_json },
{ nilnil_sym, &copts->nilnil },
{ allow_gc_sym, &copts->allow_gc },
{ quirks_mode_sym, &copts->quirks_mode },
{ allow_invalid_unicode_sym, &copts->allow_invalid },
{ Qnil, 0 }
};
YesNoOpt o;
volatile VALUE v;
size_t len;
if (T_HASH != rb_type(ropts)) {
return;
}
if (Qtrue == rb_funcall(ropts, has_key_id, 1, indent_sym)) {
v = rb_hash_lookup(ropts, indent_sym);
switch (rb_type(v)) {
case T_NIL:
copts->dump_opts.indent_size = 0;
*copts->dump_opts.indent_str = '\0';
copts->indent = 0;
break;
case T_FIXNUM:
copts->dump_opts.indent_size = 0;
*copts->dump_opts.indent_str = '\0';
copts->indent = FIX2INT(v);
break;
case T_STRING:
if (sizeof(copts->dump_opts.indent_str) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "indent string is limited to %lu characters.", sizeof(copts->dump_opts.indent_str));
}
strcpy(copts->dump_opts.indent_str, StringValuePtr(v));
copts->dump_opts.indent_size = (uint8_t)len;
copts->indent = 0;
break;
default:
rb_raise(rb_eTypeError, "indent must be a Fixnum, String, or nil.");
break;
}
}
if (Qnil != (v = rb_hash_lookup(ropts, float_prec_sym))) {
int n;
#ifdef RUBY_INTEGER_UNIFICATION
if (rb_cInteger != rb_obj_class(v)) {
rb_raise(rb_eArgError, ":float_precision must be a Integer.");
}
#else
if (rb_cFixnum != rb_obj_class(v)) {
rb_raise(rb_eArgError, ":float_precision must be a Fixnum.");
}
#endif
Check_Type(v, T_FIXNUM);
n = FIX2INT(v);
if (0 >= n) {
*copts->float_fmt = '\0';
copts->float_prec = 0;
} else {
if (20 < n) {
n = 20;
}
sprintf(copts->float_fmt, "%%0.%dg", n);
copts->float_prec = n;
}
}
if (Qnil != (v = rb_hash_lookup(ropts, sec_prec_sym))) {
int n;
#ifdef RUBY_INTEGER_UNIFICATION
if (rb_cInteger != rb_obj_class(v)) {
rb_raise(rb_eArgError, ":second_precision must be a Integer.");
}
#else
if (rb_cFixnum != rb_obj_class(v)) {
rb_raise(rb_eArgError, ":second_precision must be a Fixnum.");
}
#endif
n = NUM2INT(v);
if (0 > n) {
n = 0;
} else if (9 < n) {
n = 9;
}
copts->sec_prec = n;
}
if (Qnil != (v = rb_hash_lookup(ropts, mode_sym))) {
if (object_sym == v) {
copts->mode = ObjectMode;
} else if (strict_sym == v) {
copts->mode = StrictMode;
} else if (compat_sym == v) {
copts->mode = CompatMode;
} else if (null_sym == v) {
copts->mode = NullMode;
} else {
rb_raise(rb_eArgError, ":mode must be :object, :strict, :compat, or :null.");
}
}
if (Qnil != (v = rb_hash_lookup(ropts, time_format_sym))) {
if (unix_sym == v) {
copts->time_format = UnixTime;
} else if (unix_zone_sym == v) {
copts->time_format = UnixZTime;
} else if (xmlschema_sym == v) {
copts->time_format = XmlTime;
} else if (ruby_sym == v) {
copts->time_format = RubyTime;
} else {
rb_raise(rb_eArgError, ":time_format must be :unix, :unix_zone, :xmlschema, or :ruby.");
}
}
if (Qnil != (v = rb_hash_lookup(ropts, escape_mode_sym))) {
if (newline_sym == v) {
copts->escape_mode = NLEsc;
} else if (json_sym == v) {
copts->escape_mode = JSONEsc;
} else if (xss_safe_sym == v) {
copts->escape_mode = XSSEsc;
} else if (ascii_sym == v) {
copts->escape_mode = ASCIIEsc;
} else {
rb_raise(rb_eArgError, ":encoding must be :newline, :json, :xss_safe, or :ascii.");
}
}
if (Qnil != (v = rb_hash_lookup(ropts, bigdecimal_load_sym))) {
if (bigdecimal_sym == v || Qtrue == v) {
copts->bigdec_load = BigDec;
} else if (float_sym == v) {
copts->bigdec_load = FloatDec;
} else if (auto_sym == v || Qfalse == v) {
copts->bigdec_load = AutoDec;
} else {
rb_raise(rb_eArgError, ":bigdecimal_load must be :bigdecimal, :float, or :auto.");
}
}
if (Qtrue == rb_funcall(ropts, has_key_id, 1, create_id_sym)) {
v = rb_hash_lookup(ropts, create_id_sym);
if (Qnil == v) {
if (json_class != oj_default_options.create_id) {
xfree((char*)oj_default_options.create_id);
}
copts->create_id = NULL;
copts->create_id_len = 0;
} else if (T_STRING == rb_type(v)) {
const char *str = StringValuePtr(v);
len = RSTRING_LEN(v);
if (len != copts->create_id_len ||
0 != strcmp(copts->create_id, str)) {
copts->create_id = ALLOC_N(char, len + 1);
strcpy((char*)copts->create_id, str);
copts->create_id_len = len;
}
} else {
rb_raise(rb_eArgError, ":create_id must be string.");
}
}
for (o = ynos; 0 != o->attr; o++) {
if (Qnil != (v = rb_hash_lookup(ropts, o->sym))) {
if (Qtrue == v) {
*o->attr = Yes;
} else if (Qfalse == v) {
*o->attr = No;
} else {
rb_raise(rb_eArgError, "%s must be true or false.", rb_id2name(SYM2ID(o->sym)));
}
}
}
if (Qtrue == rb_funcall(ropts, has_key_id, 1, space_sym)) {
if (Qnil == (v = rb_hash_lookup(ropts, space_sym))) {
copts->dump_opts.after_size = 0;
*copts->dump_opts.after_sep = '\0';
} else {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.after_sep) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "space string is limited to %lu characters.", sizeof(copts->dump_opts.after_sep));
}
strcpy(copts->dump_opts.after_sep, StringValuePtr(v));
copts->dump_opts.after_size = (uint8_t)len;
}
}
if (Qtrue == rb_funcall(ropts, has_key_id, 1, space_before_sym)) {
if (Qnil == (v = rb_hash_lookup(ropts, space_before_sym))) {
copts->dump_opts.before_size = 0;
*copts->dump_opts.before_sep = '\0';
} else {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.before_sep) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "sapce_before string is limited to %lu characters.", sizeof(copts->dump_opts.before_sep));
}
strcpy(copts->dump_opts.before_sep, StringValuePtr(v));
copts->dump_opts.before_size = (uint8_t)len;
}
}
if (Qtrue == rb_funcall(ropts, has_key_id, 1, object_nl_sym)) {
if (Qnil == (v = rb_hash_lookup(ropts, object_nl_sym))) {
copts->dump_opts.hash_size = 0;
*copts->dump_opts.hash_nl = '\0';
} else {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.hash_nl) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "object_nl string is limited to %lu characters.", sizeof(copts->dump_opts.hash_nl));
}
strcpy(copts->dump_opts.hash_nl, StringValuePtr(v));
copts->dump_opts.hash_size = (uint8_t)len;
}
}
if (Qtrue == rb_funcall(ropts, has_key_id, 1, array_nl_sym)) {
if (Qnil == (v = rb_hash_lookup(ropts, array_nl_sym))) {
copts->dump_opts.array_size = 0;
*copts->dump_opts.array_nl = '\0';
} else {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.array_nl) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "array_nl string is limited to %lu characters.", sizeof(copts->dump_opts.array_nl));
}
strcpy(copts->dump_opts.array_nl, StringValuePtr(v));
copts->dump_opts.array_size = (uint8_t)len;
}
}
if (Qnil != (v = rb_hash_lookup(ropts, nan_sym))) {
if (null_sym == v) {
copts->dump_opts.nan_dump = NullNan;
} else if (huge_sym == v) {
copts->dump_opts.nan_dump = HugeNan;
} else if (word_sym == v) {
copts->dump_opts.nan_dump = WordNan;
} else if (raise_sym == v) {
copts->dump_opts.nan_dump = RaiseNan;
} else if (auto_sym == v) {
copts->dump_opts.nan_dump = AutoNan;
} else {
rb_raise(rb_eArgError, ":nan must be :null, :huge, :word, :raise, or :auto.");
}
}
copts->dump_opts.use = (0 < copts->dump_opts.indent_size ||
0 < copts->dump_opts.after_size ||
0 < copts->dump_opts.before_size ||
0 < copts->dump_opts.hash_size ||
0 < copts->dump_opts.array_size);
if (Qnil != (v = rb_hash_lookup(ropts, omit_nil_sym))) {
if (Qtrue == v) {
copts->dump_opts.omit_nil = true;
} else if (Qfalse == v) {
copts->dump_opts.omit_nil = false;
} else {
rb_raise(rb_eArgError, ":omit_nil must be true or false.");
}
}
// This is here only for backwards compatibility with the original Oj.
v = rb_hash_lookup(ropts, ascii_only_sym);
if (Qtrue == v) {
copts->escape_mode = ASCIIEsc;
} else if (Qfalse == v) {
copts->escape_mode = JSONEsc;
}
if (Qtrue == rb_funcall(ropts, has_key_id, 1, hash_class_sym)) {
if (Qnil == (v = rb_hash_lookup(ropts, hash_class_sym))) {
copts->hash_class = Qnil;
} else {
rb_check_type(v, T_CLASS);
copts->hash_class = v;
}
}
}
/* Document-method: strict_load
* call-seq: strict_load(json, options) => Hash, Array, String, Fixnum, Float, true, false, or nil
*
* Parses a JSON document String into an Hash, Array, String, Fixnum, Float,
* true, false, or nil. It parses using a mode that is strict in that it maps
* each primitive JSON type to a similar Ruby type. The :create_id is not
* honored in this mode. Note that a Ruby Hash is used to represent the JSON
* Object type. These two are not the same since the JSON Object type can have
* repeating entries with the same key and Ruby Hash can not.
*
* When used with a document that has multiple JSON elements the block, if
* any, will be yielded to. If no block then the last element read will be
* returned.
*
* Raises an exception if the JSON is malformed or the classes specified are not
* valid. If the input is not a valid JSON document (an empty string is not a
* valid JSON document) an exception is raised.
*
* A block can also be provided with a single argument. That argument will be
* the parsed JSON document. This is useful when parsing a string that includes
* multiple JSON documents.
*
* @param [String|IO] json JSON String or an Object that responds to read()
* @param [Hash] options load options (same as default_options)
*/
/* Document-method: compat_load
* call-seq: compat_load(json, options) => Object, Hash, Array, String, Fixnum, Float, true, false, or nil
*
* Parses a JSON document String into an Object, Hash, Array, String, Fixnum,
* Float, true, false, or nil. It parses using a mode that is generally
* compatible with other Ruby JSON parsers in that it will create objects based
* on the :create_id value. It is not compatible in every way to every other
* parser though as each parser has it's own variations.
*
* When used with a document that has multiple JSON elements the block, if
* any, will be yielded to. If no block then the last element read will be
* returned.
*
* Raises an exception if the JSON is malformed or the classes specified are not
* valid. If the input is not a valid JSON document (an empty string is not a
* valid JSON document) an exception is raised.
*
* A block can also be provided with a single argument. That argument will be
* the parsed JSON document. This is useful when parsing a string that includes
* multiple JSON documents.
*
* @param [String|IO] json JSON String or an Object that responds to read()
* @param [Hash] options load options (same as default_options)
*/
/* Document-method: object_load
* call-seq: object_load(json, options) => Object, Hash, Array, String, Fixnum, Float, true, false, or nil
*
* Parses a JSON document String into an Object, Hash, Array, String, Fixnum,
* Float, true, false, or nil. In the :object mode the JSON should have been
* generated by Oj.dump(). The parser will reconstitute the original marshalled
* or dumped Object. The :auto_define and :circular options have meaning with
* this parsing mode.
*
* When used with a document that has multiple JSON elements the block, if
* any, will be yielded to. If no block then the last element read will be
* returned.
*
* Raises an exception if the JSON is malformed or the classes specified are not
* valid. If the input is not a valid JSON document (an empty string is not a
* valid JSON document) an exception is raised.
*
* Note: Oj is not able to automatically deserialize all classes that are a
* subclass of a Ruby Exception. Only exception that take one required string
* argument in the initialize() method are supported. This is an example of how
* to write an Exception subclass that supports both a single string intializer
* and an Exception as an argument. Additional optional arguments can be added
* as well.
*
* The reason for this restriction has to do with a design decision on the part
* of the Ruby developers. Exceptions are special Objects. They do not follow the
* rules of other Objects. Exceptions have 'mesg' and a 'bt' attribute. Note that
* these are not '@mesg' and '@bt'. They can not be set using the normal C or
* Ruby calls. The only way I have found to set the 'mesg' attribute is through
* the initializer. Unfortunately that means any subclass that provides a
* different initializer can not be automatically decoded. A way around this is
* to use a create function but this example shows an alternative.
*
* A block can also be provided with a single argument. That argument will be
* the parsed JSON document. This is useful when parsing a string that includes
* multiple JSON documents.
*
* @param [String|IO] json JSON String or an Object that responds to read()
* @param [Hash] options load options (same as default_options)
*/
/* call-seq: load(json, options) => Object, Hash, Array, String, Fixnum, Float, true, false, or nil
*
* Parses a JSON document String into a Object, Hash, Array, String, Fixnum,
* Float, true, false, or nil according to the default mode or the mode
* specified. Raises an exception if the JSON is malformed or the classes
* specified are not valid. If the string input is not a valid JSON document (an
* empty string is not a valid JSON document) an exception is raised.
*
* When used with a document that has multiple JSON elements the block, if
* any, will be yielded to. If no block then the last element read will be
* returned.
*
* This parser operates on string and will attempt to load files into memory if
* a file object is passed as the first argument. A stream input will be parsed
* using a stream parser but others use the slightly faster string parser.
*
* A block can also be provided with a single argument. That argument will be
* the parsed JSON document. This is useful when parsing a string that includes
* multiple JSON documents.
*
* @param [String|IO] json JSON String or an Object that responds to read()
* @param [Hash] options load options (same as default_options)
*/
static VALUE
load(int argc, VALUE *argv, VALUE self) {
Mode mode = oj_default_options.mode;
if (1 > argc) {
rb_raise(rb_eArgError, "Wrong number of arguments to load().");
}
if (2 <= argc) {
VALUE ropts = argv[1];
VALUE v;
Check_Type(ropts, T_HASH);
if (Qnil != (v = rb_hash_lookup(ropts, mode_sym))) {
if (object_sym == v) {
mode = ObjectMode;
} else if (strict_sym == v) {
mode = StrictMode;
} else if (compat_sym == v) {
mode = CompatMode;
} else if (null_sym == v) {
mode = NullMode;
} else {
rb_raise(rb_eArgError, ":mode must be :object, :strict, :compat, or :null.");
}
}
}
switch (mode) {
case StrictMode:
return oj_strict_parse(argc, argv, self);
case NullMode:
case CompatMode:
return oj_compat_parse(argc, argv, self);
case ObjectMode:
default:
break;
}
return oj_object_parse(argc, argv, self);
}
/* Document-method: load_file
* call-seq: load_file(path, options) => Object, Hash, Array, String, Fixnum, Float, true, false, or nil
*
* Parses a JSON document String into a Object, Hash, Array, String, Fixnum,
* Float, true, false, or nil according to the default mode or the mode
* specified. Raises an exception if the JSON is malformed or the classes
* specified are not valid. If the string input is not a valid JSON document (an
* empty string is not a valid JSON document) an exception is raised.
*
* When used with a document that has multiple JSON elements the block, if
* any, will be yielded to. If no block then the last element read will be
* returned.
*
* If the input file is not a valid JSON document (an empty file is not a valid
* JSON document) an exception is raised.
*
* This is a stream based parser which allows a large or huge file to be loaded
* without pulling the whole file into memory.
*
* A block can also be provided with a single argument. That argument will be
* the parsed JSON document. This is useful when parsing a string that includes
* multiple JSON documents.
*
* @param [String] path path to a file containing a JSON document
* @param [Hash] options load options (same as default_options)
*/
static VALUE
load_file(int argc, VALUE *argv, VALUE self) {
char *path;
int fd;
Mode mode = oj_default_options.mode;
struct _ParseInfo pi;
if (1 > argc) {
rb_raise(rb_eArgError, "Wrong number of arguments to load().");
}
Check_Type(*argv, T_STRING);
pi.options = oj_default_options;
pi.handler = Qnil;
pi.err_class = Qnil;
if (2 <= argc) {
VALUE ropts = argv[1];
VALUE v;
Check_Type(ropts, T_HASH);
if (Qnil != (v = rb_hash_lookup(ropts, mode_sym))) {
if (object_sym == v) {
mode = ObjectMode;
} else if (strict_sym == v) {
mode = StrictMode;
} else if (compat_sym == v) {
mode = CompatMode;
} else if (null_sym == v) {
mode = NullMode;
} else {
rb_raise(rb_eArgError, ":mode must be :object, :strict, :compat, or :null.");
}
}
}
path = StringValuePtr(*argv);
if (0 == (fd = open(path, O_RDONLY))) {
rb_raise(rb_eIOError, "%s", strerror(errno));
}
switch (mode) {
case StrictMode:
oj_set_strict_callbacks(&pi);
return oj_pi_sparse(argc, argv, &pi, fd);
case NullMode:
case CompatMode:
oj_set_compat_callbacks(&pi);
return oj_pi_sparse(argc, argv, &pi, fd);
case ObjectMode:
default:
break;
}
oj_set_object_callbacks(&pi);
return oj_pi_sparse(argc, argv, &pi, fd);
}
/* call-seq: safe_load(doc)
*
* Loads a JSON document in strict mode with :auto_define and :symbol_keys
* turned off. This function should be safe to use with JSON received on an
* unprotected public interface.
*
* @param [String|IO] doc JSON String or IO to load
* @return [Hash|Array|String|Fixnum|Bignum|BigDecimal|nil|True|False]
*/
static VALUE
safe_load(VALUE self, VALUE doc) {
struct _ParseInfo pi;
VALUE args[1];
pi.err_class = Qnil;
pi.options = oj_default_options;
pi.options.auto_define = No;
pi.options.sym_key = No;
pi.options.mode = StrictMode;
oj_set_strict_callbacks(&pi);
*args = doc;
return oj_pi_parse(1, args, &pi, 0, 0, 1);
}
/* call-seq: saj_parse(handler, io)
*
* Parses an IO stream or file containing a JSON document. Raises an exception
* if the JSON is malformed. This is a callback parser that calls the methods in
* the handler if they exist. A sample is the Oj::Saj class which can be used as
* a base class for the handler.
*
* @param [Oj::Saj] handler responds to Oj::Saj methods
* @param [IO|String] io IO Object to read from
*/
/* call-seq: sc_parse(handler, io)
*
* Parses an IO stream or file containing a JSON document. Raises an exception
* if the JSON is malformed. This is a callback parser (Simple Callback Parser)
* that calls the methods in the handler if they exist. A sample is the
* Oj::ScHandler class which can be used as a base class for the handler. This
* callback parser is slightly more efficient than the Saj callback parser and
* requires less argument checking.
*
* @param [Oj::ScHandler] handler responds to Oj::ScHandler methods
* @param [IO|String] io IO Object to read from
*/
/* call-seq: dump(obj, options) => json-string
*
* Dumps an Object (obj) to a string.
* @param [Object] obj Object to serialize as an JSON document String
* @param [Hash] options same as default_options
*/
static VALUE
dump(int argc, VALUE *argv, VALUE self) {
char buf[4096];
struct _Out out;
struct _Options copts = oj_default_options;
VALUE rstr;
if (2 == argc) {
oj_parse_options(argv[1], &copts);
}
out.buf = buf;
out.end = buf + sizeof(buf) - 10;
out.allocated = 0;
out.omit_nil = copts.dump_opts.omit_nil;
oj_dump_obj_to_json(*argv, &copts, &out);
if (0 == out.buf) {
rb_raise(rb_eNoMemError, "Not enough memory.");
}
rstr = rb_str_new2(out.buf);
rstr = oj_encode(rstr);
if (out.allocated) {
xfree(out.buf);
}
return rstr;
}
/* call-seq: to_file(file_path, obj, options)
*
* Dumps an Object to the specified file.
* @param [String] file_path file path to write the JSON document to
* @param [Object] obj Object to serialize as an JSON document String
* @param [Hash] options formating options
* @param [Fixnum] :indent format expected
* @param [true|false] :circular allow circular references, default: false
*/
static VALUE
to_file(int argc, VALUE *argv, VALUE self) {
struct _Options copts = oj_default_options;
if (3 == argc) {
oj_parse_options(argv[2], &copts);
}
Check_Type(*argv, T_STRING);
oj_write_obj_to_file(argv[1], StringValuePtr(*argv), &copts);
return Qnil;
}
/* call-seq: to_stream(io, obj, options)
*
* Dumps an Object to the specified IO stream.
* @param [IO] io IO stream to write the JSON document to
* @param [Object] obj Object to serialize as an JSON document String
* @param [Hash] options formating options
* @param [Fixnum] :indent format expected
* @param [true|false] :circular allow circular references, default: false
*/
static VALUE
to_stream(int argc, VALUE *argv, VALUE self) {
struct _Options copts = oj_default_options;
if (3 == argc) {
oj_parse_options(argv[2], &copts);
}
oj_write_obj_to_stream(argv[1], *argv, &copts);
return Qnil;
}
/* call-seq: register_odd(clas, create_object, create_method, *members)
*
* Registers a class as special. This is useful for working around subclasses of
* primitive types as is done with ActiveSupport classes. The use of this
* function should be limited to just classes that can not be handled in the
* normal way. It is not intended as a hook for changing the output of all
* classes as it is not optimized for large numbers of classes.
*
* @param [Class|Module] clas Class or Module to be made special
* @param [Object] create_object object to call the create method on
* @param [Symbol] create_method method on the clas that will create a new
* instance of the clas when given all the member values in the
* order specified.
* @param [Symbol|String] members methods used to get the member values from
* instances of the clas
*/
static VALUE
register_odd(int argc, VALUE *argv, VALUE self) {
if (3 > argc) {
rb_raise(rb_eArgError, "incorrect number of arguments.");
}
switch (rb_type(*argv)) {
case T_CLASS:
case T_MODULE:
break;
default:
rb_raise(rb_eTypeError, "expected a class or module.");
break;
}
Check_Type(argv[2], T_SYMBOL);
if (MAX_ODD_ARGS < argc - 2) {
rb_raise(rb_eArgError, "too many members.");
}
oj_reg_odd(argv[0], argv[1], argv[2], argc - 3, argv + 3, false);
return Qnil;
}
/* call-seq: register_odd_raw(clas, create_object, create_method, dump_method)
*
* Registers a class as special and expect the output to be a string that can be
* included in the dumped JSON directly. This is useful for working around
* subclasses of primitive types as is done with ActiveSupport classes. The use
* of this function should be limited to just classes that can not be handled in
* the normal way. It is not intended as a hook for changing the output of all
* classes as it is not optimized for large numbers of classes. Be careful with
* this option as the JSON may be incorrect if invalid JSON is returned.
*
* @param [Class|Module] clas Class or Module to be made special
* @param [Object] create_object object to call the create method on
* @param [Symbol] create_method method on the clas that will create a new
* instance of the clas when given all the member values in the
* order specified.
* @param [Symbol|String] dump_method method to call on the object being
* serialized to generate the raw JSON.
*/
static VALUE
register_odd_raw(int argc, VALUE *argv, VALUE self) {
if (3 > argc) {
rb_raise(rb_eArgError, "incorrect number of arguments.");
}
switch (rb_type(*argv)) {
case T_CLASS:
case T_MODULE:
break;
default:
rb_raise(rb_eTypeError, "expected a class or module.");
break;
}
Check_Type(argv[2], T_SYMBOL);
if (MAX_ODD_ARGS < argc - 2) {
rb_raise(rb_eArgError, "too many members.");
}
oj_reg_odd(argv[0], argv[1], argv[2], 1, argv + 3, true);
return Qnil;
}
static void
str_writer_free(void *ptr) {
StrWriter sw;
if (0 == ptr) {
return;
}
sw = (StrWriter)ptr;
xfree(sw->out.buf);
xfree(sw->types);
xfree(ptr);
}
/* Document-class: Oj::StringWriter
*
* Supports building a JSON document one element at a time. Build the document
* by pushing values into the document. Pushing an array or an object will
* create that element in the JSON document and subsequent pushes will add the
* elements to that array or object until a pop() is called. When complete
* calling to_s() will return the JSON document. Note tha calling to_s() before
* construction is complete will return the document in it's current state.
*/
static void
str_writer_init(StrWriter sw) {
sw->opts = oj_default_options;
sw->depth = 0;
sw->types = ALLOC_N(char, 256);
sw->types_end = sw->types + 256;
*sw->types = '\0';
sw->keyWritten = 0;
sw->out.buf = ALLOC_N(char, 4096);
sw->out.end = sw->out.buf + 4086;
sw->out.allocated = 1;
sw->out.cur = sw->out.buf;
*sw->out.cur = '\0';
sw->out.circ_cnt = 0;
sw->out.hash_cnt = 0;
sw->out.opts = &sw->opts;
sw->out.indent = sw->opts.indent;
sw->out.depth = 0;
}
/* call-seq: new(options)
*
* Creates a new StringWriter.
* @param [Hash] options formating options
*/
static VALUE
str_writer_new(int argc, VALUE *argv, VALUE self) {
StrWriter sw = ALLOC(struct _StrWriter);
str_writer_init(sw);
if (1 == argc) {
oj_parse_options(argv[0], &sw->opts);
}
sw->out.indent = sw->opts.indent;
return Data_Wrap_Struct(oj_string_writer_class, 0, str_writer_free, sw);
}
/* call-seq: push_key(key)
*
* Pushes a key onto the JSON document. The key will be used for the next push
* if currently in a JSON object and ignored otherwise. If a key is provided on
* the next push then that new key will be ignored.
* @param [String] key the key pending for the next push
*/
static VALUE
str_writer_push_key(VALUE self, VALUE key) {
StrWriter sw = (StrWriter)DATA_PTR(self);
rb_check_type(key, T_STRING);
oj_str_writer_push_key(sw, StringValuePtr(key));
return Qnil;
}
/* call-seq: push_object(key=nil)
*
* Pushes an object onto the JSON document. Future pushes will be to this object
* until a pop() is called.
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
str_writer_push_object(int argc, VALUE *argv, VALUE self) {
StrWriter sw = (StrWriter)DATA_PTR(self);
switch (argc) {
case 0:
oj_str_writer_push_object(sw, 0);
break;
case 1:
if (Qnil == argv[0]) {
oj_str_writer_push_object(sw, 0);
} else {
rb_check_type(argv[0], T_STRING);
oj_str_writer_push_object(sw, StringValuePtr(argv[0]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
break;
}
if (rb_block_given_p()) {
rb_yield(Qnil);
oj_str_writer_pop(sw);
}
return Qnil;
}
/* call-seq: push_array(key=nil)
*
* Pushes an array onto the JSON document. Future pushes will be to this object
* until a pop() is called.
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
str_writer_push_array(int argc, VALUE *argv, VALUE self) {
StrWriter sw = (StrWriter)DATA_PTR(self);
switch (argc) {
case 0:
oj_str_writer_push_array(sw, 0);
break;
case 1:
if (Qnil == argv[0]) {
oj_str_writer_push_array(sw, 0);
} else {
rb_check_type(argv[0], T_STRING);
oj_str_writer_push_array(sw, StringValuePtr(argv[0]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
break;
}
if (rb_block_given_p()) {
rb_yield(Qnil);
oj_str_writer_pop(sw);
}
return Qnil;
}
/* call-seq: push_value(value, key=nil)
*
* Pushes a value onto the JSON document.
* @param [Object] value value to add to the JSON document
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
str_writer_push_value(int argc, VALUE *argv, VALUE self) {
switch (argc) {
case 1:
oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
break;
case 2:
if (Qnil == argv[1]) {
oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
} else {
rb_check_type(argv[1], T_STRING);
oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_value'.");
break;
}
return Qnil;
}
/* call-seq: push_json(value, key=nil)
*
* Pushes a string onto the JSON document. The String must be a valid JSON
* encoded string. No additional checking is done to verify the validity of the
* string.
* @param [String] value JSON document to add to the JSON document
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
str_writer_push_json(int argc, VALUE *argv, VALUE self) {
rb_check_type(argv[0], T_STRING);
switch (argc) {
case 1:
oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
break;
case 2:
if (Qnil == argv[1]) {
oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
} else {
rb_check_type(argv[1], T_STRING);
oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), StringValuePtr(argv[1]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_json'.");
break;
}
return Qnil;
}
/* call-seq: pop()
*
* Pops up a level in the JSON document closing the array or object that is
* currently open.
*/
static VALUE
str_writer_pop(VALUE self) {
oj_str_writer_pop((StrWriter)DATA_PTR(self));
return Qnil;
}
/* call-seq: pop_all()
*
* Pops all level in the JSON document closing all the array or object that is
* currently open.
*/
static VALUE
str_writer_pop_all(VALUE self) {
oj_str_writer_pop_all((StrWriter)DATA_PTR(self));
return Qnil;
}
/* call-seq: reset()
*
* Reset the writer back to the empty state.
*/
static VALUE
str_writer_reset(VALUE self) {
StrWriter sw = (StrWriter)DATA_PTR(self);
sw->depth = 0;
*sw->types = '\0';
sw->keyWritten = 0;
sw->out.cur = sw->out.buf;
*sw->out.cur = '\0';
return Qnil;
}
/* call-seq: to_s()
*
* Returns the JSON document string in what ever state the construction is at.
*/
static VALUE
str_writer_to_s(VALUE self) {
StrWriter sw = (StrWriter)DATA_PTR(self);
VALUE rstr = rb_str_new(sw->out.buf, sw->out.cur - sw->out.buf);
return oj_encode(rstr);
}
// StreamWriter
/* Document-class: Oj::StreamWriter
*
* Supports building a JSON document one element at a time. Build the IO stream
* document by pushing values into the document. Pushing an array or an object
* will create that element in the JSON document and subsequent pushes will add
* the elements to that array or object until a pop() is called.
*/
static void
stream_writer_free(void *ptr) {
StreamWriter sw;
if (0 == ptr) {
return;
}
sw = (StreamWriter)ptr;
xfree(sw->sw.out.buf);
xfree(sw->sw.types);
xfree(ptr);
}
static void
stream_writer_write(StreamWriter sw) {
ssize_t size = sw->sw.out.cur - sw->sw.out.buf;
switch (sw->type) {
case STRING_IO:
rb_funcall(sw->stream, oj_write_id, 1, rb_str_new(sw->sw.out.buf, size));
break;
case STREAM_IO:
rb_funcall(sw->stream, oj_write_id, 1, rb_str_new(sw->sw.out.buf, size));
break;
case FILE_IO:
if (size != write(sw->fd, sw->sw.out.buf, size)) {
rb_raise(rb_eIOError, "Write failed. [%d:%s]\n", errno, strerror(errno));
}
break;
default:
rb_raise(rb_eArgError, "expected an IO Object.");
}
}
static void
stream_writer_reset_buf(StreamWriter sw) {
sw->sw.out.cur = sw->sw.out.buf;
*sw->sw.out.cur = '\0';
}
/* call-seq: new(io, options)
*
* Creates a new StreamWriter.
* @param [IO] io stream to write to
* @param [Hash] options formating options
*/
static VALUE
stream_writer_new(int argc, VALUE *argv, VALUE self) {
StreamWriterType type = STREAM_IO;
int fd = 0;
VALUE stream = argv[0];
VALUE clas = rb_obj_class(stream);
StreamWriter sw;
#if !IS_WINDOWS
VALUE s;
#endif
if (oj_stringio_class == clas) {
type = STRING_IO;
#if !IS_WINDOWS
} else if (rb_respond_to(stream, oj_fileno_id) &&
Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
0 != (fd = FIX2INT(s))) {
type = FILE_IO;
#endif
} else if (rb_respond_to(stream, oj_write_id)) {
type = STREAM_IO;
} else {
rb_raise(rb_eArgError, "expected an IO Object.");
}
sw = ALLOC(struct _StreamWriter);
str_writer_init(&sw->sw);
if (2 == argc) {
oj_parse_options(argv[1], &sw->sw.opts);
}
sw->sw.out.indent = sw->sw.opts.indent;
sw->stream = stream;
sw->type = type;
sw->fd = fd;
return Data_Wrap_Struct(oj_stream_writer_class, 0, stream_writer_free, sw);
}
/* call-seq: push_key(key)
*
* Pushes a key onto the JSON document. The key will be used for the next push
* if currently in a JSON object and ignored otherwise. If a key is provided on
* the next push then that new key will be ignored.
* @param [String] key the key pending for the next push
*/
static VALUE
stream_writer_push_key(VALUE self, VALUE key) {
StreamWriter sw = (StreamWriter)DATA_PTR(self);
rb_check_type(key, T_STRING);
stream_writer_reset_buf(sw);
oj_str_writer_push_key(&sw->sw, StringValuePtr(key));
stream_writer_write(sw);
return Qnil;
}
/* call-seq: push_object(key=nil)
*
* Pushes an object onto the JSON document. Future pushes will be to this object
* until a pop() is called.
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
stream_writer_push_object(int argc, VALUE *argv, VALUE self) {
StreamWriter sw = (StreamWriter)DATA_PTR(self);
stream_writer_reset_buf(sw);
switch (argc) {
case 0:
oj_str_writer_push_object(&sw->sw, 0);
break;
case 1:
if (Qnil == argv[0]) {
oj_str_writer_push_object(&sw->sw, 0);
} else {
rb_check_type(argv[0], T_STRING);
oj_str_writer_push_object(&sw->sw, StringValuePtr(argv[0]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
break;
}
stream_writer_write(sw);
return Qnil;
}
/* call-seq: push_array(key=nil)
*
* Pushes an array onto the JSON document. Future pushes will be to this object
* until a pop() is called.
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
stream_writer_push_array(int argc, VALUE *argv, VALUE self) {
StreamWriter sw = (StreamWriter)DATA_PTR(self);
stream_writer_reset_buf(sw);
switch (argc) {
case 0:
oj_str_writer_push_array(&sw->sw, 0);
break;
case 1:
if (Qnil == argv[0]) {
oj_str_writer_push_array(&sw->sw, 0);
} else {
rb_check_type(argv[0], T_STRING);
oj_str_writer_push_array(&sw->sw, StringValuePtr(argv[0]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
break;
}
stream_writer_write(sw);
return Qnil;
}
/* call-seq: push_value(value, key=nil)
*
* Pushes a value onto the JSON document.
* @param [Object] value value to add to the JSON document
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
StreamWriter sw = (StreamWriter)DATA_PTR(self);
stream_writer_reset_buf(sw);
switch (argc) {
case 1:
oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
break;
case 2:
if (Qnil == argv[0]) {
oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
} else {
rb_check_type(argv[1], T_STRING);
oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_value'.");
break;
}
stream_writer_write(sw);
return Qnil;
}
/* call-seq: push_json(value, key=nil)
*
* Pushes a string onto the JSON document. The String must be a valid JSON
* encoded string. No additional checking is done to verify the validity of the
* string.
* @param [Object] value value to add to the JSON document
* @param [String] key the key if adding to an object in the JSON document
*/
static VALUE
stream_writer_push_json(int argc, VALUE *argv, VALUE self) {
StreamWriter sw = (StreamWriter)DATA_PTR(self);
rb_check_type(argv[0], T_STRING);
stream_writer_reset_buf(sw);
switch (argc) {
case 1:
oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
break;
case 2:
if (Qnil == argv[0]) {
oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
} else {
rb_check_type(argv[1], T_STRING);
oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), StringValuePtr(argv[1]));
}
break;
default:
rb_raise(rb_eArgError, "Wrong number of argument to 'push_json'.");
break;
}
stream_writer_write(sw);
return Qnil;
}
/* call-seq: pop()
*
* Pops up a level in the JSON document closing the array or object that is
* currently open.
*/
static VALUE
stream_writer_pop(VALUE self) {
StreamWriter sw = (StreamWriter)DATA_PTR(self);
stream_writer_reset_buf(sw);
oj_str_writer_pop(&sw->sw);
stream_writer_write(sw);
return Qnil;
}
/* call-seq: pop_all()
*
* Pops all level in the JSON document closing all the array or object that is
* currently open.
*/
static VALUE
stream_writer_pop_all(VALUE self) {
StreamWriter sw = (StreamWriter)DATA_PTR(self);
stream_writer_reset_buf(sw);
oj_str_writer_pop_all(&sw->sw);
stream_writer_write(sw);
return Qnil;
}
// Mimic JSON section
static VALUE
mimic_dump(int argc, VALUE *argv, VALUE self) {
char buf[4096];
struct _Out out;
struct _Options copts = oj_default_options;
VALUE rstr;
out.buf = buf;
out.end = buf + sizeof(buf) - 10;
out.allocated = 0;
out.omit_nil = copts.dump_opts.omit_nil;
oj_dump_obj_to_json(*argv, &copts, &out);
if (0 == out.buf) {
rb_raise(rb_eNoMemError, "Not enough memory.");
}
rstr = rb_str_new2(out.buf);
rstr = oj_encode(rstr);
if (2 <= argc && Qnil != argv[1]) {
VALUE io = argv[1];
VALUE args[1];
*args = rstr;
rb_funcall2(io, oj_write_id, 1, args);
rstr = io;
}
if (out.allocated) {
xfree(out.buf);
}
return rstr;
}
// This is the signature for the hash_foreach callback also.
static int
mimic_walk(VALUE key, VALUE obj, VALUE proc) {
switch (rb_type(obj)) {
case T_HASH:
rb_hash_foreach(obj, mimic_walk, proc);
break;
case T_ARRAY:
{
size_t cnt = RARRAY_LEN(obj);
size_t i;
for (i = 0; i < cnt; i++) {
mimic_walk(Qnil, rb_ary_entry(obj, i), proc);
}
break;
}
default:
break;
}
if (Qnil == proc) {
if (rb_block_given_p()) {
rb_yield(obj);
}
} else {
#if HAS_PROC_WITH_BLOCK
VALUE args[1];
*args = obj;
rb_proc_call_with_block(proc, 1, args, Qnil);
#else
rb_raise(rb_eNotImpError, "Calling a Proc with a block not supported in this version. Use func() {|x| } syntax instead.");
#endif
}
return ST_CONTINUE;
}
static VALUE
mimic_load(int argc, VALUE *argv, VALUE self) {
struct _ParseInfo pi;
VALUE obj;
VALUE p = Qnil;
pi.err_class = json_parser_error_class;
pi.options = oj_default_options;
oj_set_compat_callbacks(&pi);
obj = oj_pi_parse(argc, argv, &pi, 0, 0, 0);
if (2 <= argc) {
p = argv[1];
}
mimic_walk(Qnil, obj, p);
return obj;
}
static VALUE
mimic_dump_load(int argc, VALUE *argv, VALUE self) {
if (1 > argc) {
rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
} else if (T_STRING == rb_type(*argv)) {
return mimic_load(argc, argv, self);
} else {
return mimic_dump(argc, argv, self);
}
return Qnil;
}
static VALUE
mimic_generate_core(int argc, VALUE *argv, Options copts) {
char buf[4096];
struct _Out out;
VALUE rstr;
out.buf = buf;
out.end = buf + sizeof(buf) - 10;
out.allocated = 0;
out.omit_nil = copts->dump_opts.omit_nil;
if (2 == argc && Qnil != argv[1]) {
VALUE ropts = argv[1];
VALUE v;
size_t len;
if (T_HASH != rb_type(ropts)) {
rb_raise(rb_eArgError, "options must be a hash.");
}
if (Qnil != (v = rb_hash_lookup(ropts, indent_sym))) { // TBD fixnum also ok
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.indent_str) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "indent string is limited to %lu characters.", sizeof(copts->dump_opts.indent_str));
}
strcpy(copts->dump_opts.indent_str, StringValuePtr(v));
copts->dump_opts.indent_size = (uint8_t)len;
copts->dump_opts.use = true;
}
if (Qnil != (v = rb_hash_lookup(ropts, space_sym))) {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.after_sep) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "space string is limited to %lu characters.", sizeof(copts->dump_opts.after_sep));
}
strcpy(copts->dump_opts.after_sep, StringValuePtr(v));
copts->dump_opts.after_size = (uint8_t)len;
copts->dump_opts.use = true;
}
if (Qnil != (v = rb_hash_lookup(ropts, space_before_sym))) {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.before_sep) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "space_before string is limited to %lu characters.", sizeof(copts->dump_opts.before_sep));
}
strcpy(copts->dump_opts.before_sep, StringValuePtr(v));
copts->dump_opts.before_size = (uint8_t)len;
copts->dump_opts.use = true;
}
if (Qnil != (v = rb_hash_lookup(ropts, object_nl_sym))) {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.hash_nl) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "object_nl string is limited to %lu characters.", sizeof(copts->dump_opts.hash_nl));
}
strcpy(copts->dump_opts.hash_nl, StringValuePtr(v));
copts->dump_opts.hash_size = (uint8_t)len;
copts->dump_opts.use = true;
}
if (Qnil != (v = rb_hash_lookup(ropts, array_nl_sym))) {
rb_check_type(v, T_STRING);
if (sizeof(copts->dump_opts.array_nl) <= (len = RSTRING_LEN(v))) {
rb_raise(rb_eArgError, "array_nl string is limited to %lu characters.", sizeof(copts->dump_opts.array_nl));
}
strcpy(copts->dump_opts.array_nl, StringValuePtr(v));
copts->dump_opts.array_size = (uint8_t)len;
copts->dump_opts.use = true;
}
if (Qnil != (v = rb_hash_lookup(ropts, ascii_only_sym))) {
// generate seems to assume anything except nil and false are true.
if (Qfalse == v || Qnil == v) {
copts->escape_mode = JSONEsc;
} else {
copts->escape_mode = ASCIIEsc;
}
}
// :allow_nan is not supported as Oj always allows_nan
// :max_nesting is always set to 100
}
oj_dump_obj_to_json(*argv, copts, &out);
if (0 == out.buf) {
rb_raise(rb_eNoMemError, "Not enough memory.");
}
rstr = rb_str_new2(out.buf);
rstr = oj_encode(rstr);
if (out.allocated) {
xfree(out.buf);
}
return rstr;
}
static VALUE
mimic_generate(int argc, VALUE *argv, VALUE self) {
struct _Options copts = oj_default_options;
return mimic_generate_core(argc, argv, &copts);
}
static VALUE
mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
struct _Options copts = oj_default_options;
strcpy(copts.dump_opts.indent_str, " ");
copts.dump_opts.indent_size = (uint8_t)strlen(copts.dump_opts.indent_str);
strcpy(copts.dump_opts.before_sep, " ");
copts.dump_opts.before_size = (uint8_t)strlen(copts.dump_opts.before_sep);
strcpy(copts.dump_opts.after_sep, " ");
copts.dump_opts.after_size = (uint8_t)strlen(copts.dump_opts.after_sep);
strcpy(copts.dump_opts.hash_nl, "\n");
copts.dump_opts.hash_size = (uint8_t)strlen(copts.dump_opts.hash_nl);
strcpy(copts.dump_opts.array_nl, "\n");
copts.dump_opts.array_size = (uint8_t)strlen(copts.dump_opts.array_nl);
copts.dump_opts.use = true;
return mimic_generate_core(argc, argv, &copts);
}
static VALUE
mimic_parse(int argc, VALUE *argv, VALUE self) {
struct _ParseInfo pi;
VALUE args[1];
if (argc < 1) {
rb_raise(rb_eArgError, "Wrong number of arguments to parse.");
}
oj_set_compat_callbacks(&pi);
pi.err_class = json_parser_error_class;
pi.options = oj_default_options;
pi.options.auto_define = No;
pi.options.quirks_mode = No;
pi.options.allow_invalid = No;
if (2 <= argc) {
VALUE ropts = argv[1];
VALUE v;
if (T_HASH != rb_type(ropts)) {
rb_raise(rb_eArgError, "options must be a hash.");
}
if (Qnil != (v = rb_hash_lookup(ropts, symbolize_names_sym))) {
pi.options.sym_key = (Qtrue == v) ? Yes : No;
}
if (Qnil != (v = rb_hash_lookup(ropts, quirks_mode_sym))) {
pi.options.quirks_mode = (Qtrue == v) ? Yes : No;
}
if (Qnil != (v = rb_hash_lookup(ropts, create_additions_sym))) {
if (Qfalse == v) {
oj_set_strict_callbacks(&pi);
}
}
// :allow_nan is not supported as Oj always allows nan
// :max_nesting is ignored as Oj has not nesting limit
// :object_class is always Hash
// :array_class is always Array
}
*args = *argv;
return oj_pi_parse(1, args, &pi, 0, 0, 0);
}
static VALUE
mimic_recurse_proc(VALUE self, VALUE obj) {
rb_need_block();
mimic_walk(Qnil, obj, Qnil);
return Qnil;
}
static VALUE
no_op1(VALUE self, VALUE obj) {
return Qnil;
}
static VALUE
mimic_set_create_id(VALUE self, VALUE id) {
Check_Type(id, T_STRING);
if (0 != oj_default_options.create_id) {
if (json_class != oj_default_options.create_id) {
xfree((char*)oj_default_options.create_id);
}
oj_default_options.create_id = 0;
oj_default_options.create_id_len = 0;
}
if (Qnil != id) {
size_t len = RSTRING_LEN(id) + 1;
oj_default_options.create_id = ALLOC_N(char, len);
strcpy((char*)oj_default_options.create_id, StringValuePtr(id));
oj_default_options.create_id_len = len - 1;
}
return id;
}
static VALUE
mimic_create_id(VALUE self) {
if (0 != oj_default_options.create_id) {
return oj_encode(rb_str_new_cstr(oj_default_options.create_id));
}
return rb_str_new_cstr(json_class);
}
static struct _Options mimic_object_to_json_options = {
0, // indent
No, // circular
No, // auto_define
No, // sym_key
JSONEsc, // escape_mode
CompatMode, // mode
No, // class_cache
RubyTime, // time_format
No, // bigdec_as_num
FloatDec, // bigdec_load
No, // to_json
Yes, // nilnil
Yes, // allow_gc
Yes, // quirks_mode
No, // allow_invalid
json_class, // create_id
10, // create_id_len
9, // sec_prec
15, // float_prec
"%0.15g", // float_fmt
Qnil, // hash_class
{ // dump_opts
false, //use
"", // indent
"", // before_sep
"", // after_sep
"", // hash_nl
"", // array_nl
0, // indent_size
0, // before_size
0, // after_size
0, // hash_size
0, // array_size
AutoNan,// nan_dump
false, // omit_nil
}
};
static VALUE
mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
char buf[4096];
struct _Out out;
VALUE rstr;
struct _Options copts = oj_default_options;
out.buf = buf;
out.end = buf + sizeof(buf) - 10;
out.allocated = 0;
out.omit_nil = copts.dump_opts.omit_nil;
// Have to turn off to_json to avoid the Active Support recursion problem.
copts.to_json = No;
// To be strict the mimic_object_to_json_options should be used but people
// seem to prefer the option of changing that.
//oj_dump_obj_to_json(self, &mimic_object_to_json_options, &out);
oj_dump_obj_to_json_using_params(self, &copts, &out, argc, argv);
if (0 == out.buf) {
rb_raise(rb_eNoMemError, "Not enough memory.");
}
rstr = rb_str_new2(out.buf);
rstr = oj_encode(rstr);
if (out.allocated) {
xfree(out.buf);
}
return rstr;
}
/* Document-method: mimic_JSON
* call-seq: mimic_JSON() => Module
*
* Creates the JSON module with methods and classes to mimic the JSON gem. After
* this method is invoked calls that expect the JSON module will use Oj instead
* and be faster than the original JSON. Most options that could be passed to
* the JSON methods are supported. The calls to set parser or generator will not
* raise an Exception but will not have any effect. The method can also be
* called after the json gem is loaded. The necessary methods on the json gem
* will be replaced with Oj methods.
*
* Note that this also sets the default options of :mode to :compat and
* :encoding to :ascii.
*/
static VALUE
define_mimic_json(int argc, VALUE *argv, VALUE self) {
VALUE ext;
VALUE dummy;
VALUE verbose;
VALUE json_error;
// Either set the paths to indicate JSON has been loaded or replaces the
// methods if it has been loaded.
if (rb_const_defined_at(rb_cObject, rb_intern("JSON"))) {
mimic = rb_const_get_at(rb_cObject, rb_intern("JSON"));
} else {
mimic = rb_define_module("JSON");
}
verbose = rb_gv_get("$VERBOSE");
rb_gv_set("$VERBOSE", Qfalse);
rb_define_module_function(rb_cObject, "JSON", mimic_dump_load, -1);
if (rb_const_defined_at(mimic, rb_intern("Ext"))) {
ext = rb_const_get_at(mimic, rb_intern("Ext"));
} else {
ext = rb_define_module_under(mimic, "Ext");
}
if (!rb_const_defined_at(ext, rb_intern("Parser"))) {
dummy = rb_define_class_under(ext, "Parser", rb_cObject);
}
if (!rb_const_defined_at(ext, rb_intern("Generator"))) {
dummy = rb_define_class_under(ext, "Generator", rb_cObject);
}
// convince Ruby that the json gem has already been loaded
dummy = rb_gv_get("$LOADED_FEATURES");
if (rb_type(dummy) == T_ARRAY) {
rb_ary_push(dummy, rb_str_new2("json"));
if (0 < argc) {
VALUE mimic_args[1];
*mimic_args = *argv;
rb_funcall2(Oj, rb_intern("mimic_loaded"), 1, mimic_args);
} else {
rb_funcall2(Oj, rb_intern("mimic_loaded"), 0, 0);
}
}
rb_define_module_function(mimic, "parser=", no_op1, 1);
rb_define_module_function(mimic, "generator=", no_op1, 1);
rb_define_module_function(mimic, "create_id=", mimic_set_create_id, 1);
rb_define_module_function(mimic, "create_id", mimic_create_id, 0);
rb_define_module_function(mimic, "dump", mimic_dump, -1);
rb_define_module_function(mimic, "load", mimic_load, -1);
rb_define_module_function(mimic, "restore", mimic_load, -1);
rb_define_module_function(mimic, "recurse_proc", mimic_recurse_proc, 1);
rb_define_module_function(mimic, "[]", mimic_dump_load, -1);
rb_define_module_function(mimic, "generate", mimic_generate, -1);
rb_define_module_function(mimic, "fast_generate", mimic_generate, -1);
rb_define_module_function(mimic, "pretty_generate", mimic_pretty_generate, -1);
/* for older versions of JSON, the deprecated unparse methods */
rb_define_module_function(mimic, "unparse", mimic_generate, -1);
rb_define_module_function(mimic, "fast_unparse", mimic_generate, -1);
rb_define_module_function(mimic, "pretty_unparse", mimic_pretty_generate, -1);
rb_define_module_function(mimic, "parse", mimic_parse, -1);
rb_define_module_function(mimic, "parse!", mimic_parse, -1);
rb_define_method(rb_cObject, "to_json", mimic_object_to_json, -1);
rb_gv_set("$VERBOSE", verbose);
create_additions_sym = ID2SYM(rb_intern("create_additions")); rb_gc_register_address(&create_additions_sym);
symbolize_names_sym = ID2SYM(rb_intern("symbolize_names")); rb_gc_register_address(&symbolize_names_sym);
if (rb_const_defined_at(mimic, rb_intern("JSONError"))) {
rb_funcall(mimic, rb_intern("remove_const"), 1, ID2SYM(rb_intern("JSONError")));
}
json_error = rb_define_class_under(mimic, "JSONError", rb_eStandardError);
if (rb_const_defined_at(mimic, rb_intern("ParserError"))) {
rb_funcall(mimic, rb_intern("remove_const"), 1, ID2SYM(rb_intern("ParserError")));
}
json_parser_error_class = rb_define_class_under(mimic, "ParserError", json_error);
if (!rb_const_defined_at(mimic, rb_intern("State"))) {
rb_define_class_under(mimic, "State", rb_cObject);
}
oj_default_options = mimic_object_to_json_options;
oj_default_options.to_json = Yes;
return mimic;
}
/*
extern void oj_hash_test();
static VALUE
hash_test(VALUE self) {
oj_hash_test();
return Qnil;
}
*/
#if !HAS_ENCODING_SUPPORT
static VALUE
iconv_encoder(VALUE x) {
VALUE iconv;
rb_require("iconv");
iconv = rb_const_get(rb_cObject, rb_intern("Iconv"));
return rb_funcall(iconv, rb_intern("new"), 2, rb_str_new2("ASCII//TRANSLIT"), rb_str_new2("UTF-8"));
}
static VALUE
iconv_rescue(VALUE x) {
return Qnil;
}
#endif
static VALUE
protect_require(VALUE x) {
rb_require("time");
rb_require("bigdecimal");
return Qnil;
}
void Init_oj() {
int err = 0;
Oj = rb_define_module("Oj");
oj_cstack_class = rb_define_class_under(Oj, "CStack", rb_cObject);
oj_string_writer_class = rb_define_class_under(Oj, "StringWriter", rb_cObject);
rb_define_module_function(oj_string_writer_class, "new", str_writer_new, -1);
rb_define_method(oj_string_writer_class, "push_key", str_writer_push_key, 1);
rb_define_method(oj_string_writer_class, "push_object", str_writer_push_object, -1);
rb_define_method(oj_string_writer_class, "push_array", str_writer_push_array, -1);
rb_define_method(oj_string_writer_class, "push_value", str_writer_push_value, -1);
rb_define_method(oj_string_writer_class, "push_json", str_writer_push_json, -1);
rb_define_method(oj_string_writer_class, "pop", str_writer_pop, 0);
rb_define_method(oj_string_writer_class, "pop_all", str_writer_pop_all, 0);
rb_define_method(oj_string_writer_class, "reset", str_writer_reset, 0);
rb_define_method(oj_string_writer_class, "to_s", str_writer_to_s, 0);
oj_stream_writer_class = rb_define_class_under(Oj, "StreamWriter", rb_cObject);
rb_define_module_function(oj_stream_writer_class, "new", stream_writer_new, -1);
rb_define_method(oj_stream_writer_class, "push_key", stream_writer_push_key, 1);
rb_define_method(oj_stream_writer_class, "push_object", stream_writer_push_object, -1);
rb_define_method(oj_stream_writer_class, "push_array", stream_writer_push_array, -1);
rb_define_method(oj_stream_writer_class, "push_value", stream_writer_push_value, -1);
rb_define_method(oj_stream_writer_class, "push_json", stream_writer_push_json, -1);
rb_define_method(oj_stream_writer_class, "pop", stream_writer_pop, 0);
rb_define_method(oj_stream_writer_class, "pop_all", stream_writer_pop_all, 0);
rb_require("time");
rb_require("date");
// On Rubinius the require fails but can be done from a ruby file.
rb_protect(protect_require, Qnil, &err);
#if NEEDS_RATIONAL
rb_require("rational");
#endif
rb_require("stringio");
#if HAS_ENCODING_SUPPORT
oj_utf8_encoding = rb_enc_find("UTF-8");
#else
// need an option to turn this on
oj_utf8_encoding = rb_rescue(iconv_encoder, Qnil, iconv_rescue, Qnil);
oj_utf8_encoding = Qnil;
#endif
//rb_define_module_function(Oj, "hash_test", hash_test, 0);
rb_define_module_function(Oj, "default_options", get_def_opts, 0);
rb_define_module_function(Oj, "default_options=", set_def_opts, 1);
rb_define_module_function(Oj, "mimic_JSON", define_mimic_json, -1);
rb_define_module_function(Oj, "load", load, -1);
rb_define_module_function(Oj, "load_file", load_file, -1);
rb_define_module_function(Oj, "safe_load", safe_load, 1);
rb_define_module_function(Oj, "strict_load", oj_strict_parse, -1);
rb_define_module_function(Oj, "compat_load", oj_compat_parse, -1);
rb_define_module_function(Oj, "object_load", oj_object_parse, -1);
rb_define_module_function(Oj, "dump", dump, -1);
rb_define_module_function(Oj, "to_file", to_file, -1);
rb_define_module_function(Oj, "to_stream", to_stream, -1);
rb_define_module_function(Oj, "register_odd", register_odd, -1);
rb_define_module_function(Oj, "register_odd_raw", register_odd_raw, -1);
rb_define_module_function(Oj, "saj_parse", oj_saj_parse, -1);
rb_define_module_function(Oj, "sc_parse", oj_sc_parse, -1);
oj_add_value_id = rb_intern("add_value");
oj_array_append_id = rb_intern("array_append");
oj_array_end_id = rb_intern("array_end");
oj_array_start_id = rb_intern("array_start");
oj_as_json_id = rb_intern("as_json");
oj_error_id = rb_intern("error");
oj_file_id = rb_intern("file?");
oj_fileno_id = rb_intern("fileno");
oj_ftype_id = rb_intern("ftype");
oj_hash_end_id = rb_intern("hash_end");
oj_hash_key_id = rb_intern("hash_key");
oj_hash_set_id = rb_intern("hash_set");
oj_hash_start_id = rb_intern("hash_start");
oj_iconv_id = rb_intern("iconv");
oj_instance_variables_id = rb_intern("instance_variables");
oj_json_create_id = rb_intern("json_create");
oj_length_id = rb_intern("length");
oj_new_id = rb_intern("new");
oj_parse_id = rb_intern("parse");
oj_pos_id = rb_intern("pos");
oj_read_id = rb_intern("read");
oj_readpartial_id = rb_intern("readpartial");
oj_replace_id = rb_intern("replace");
oj_stat_id = rb_intern("stat");
oj_string_id = rb_intern("string");
oj_to_hash_id = rb_intern("to_hash");
oj_to_json_id = rb_intern("to_json");
oj_to_s_id = rb_intern("to_s");
oj_to_sym_id = rb_intern("to_sym");
oj_to_time_id = rb_intern("to_time");
oj_tv_nsec_id = rb_intern("tv_nsec");
oj_tv_sec_id = rb_intern("tv_sec");
oj_tv_usec_id = rb_intern("tv_usec");
oj_utc_id = rb_intern("utc");
oj_utc_offset_id = rb_intern("utc_offset");
oj_utcq_id = rb_intern("utc?");
oj_write_id = rb_intern("write");
has_key_id = rb_intern("has_key?");
rb_require("oj/bag");
rb_require("oj/error");
rb_require("oj/mimic");
rb_require("oj/saj");
rb_require("oj/schandler");
oj_bag_class = rb_const_get_at(Oj, rb_intern("Bag"));
oj_bigdecimal_class = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
oj_date_class = rb_const_get(rb_cObject, rb_intern("Date"));
oj_datetime_class = rb_const_get(rb_cObject, rb_intern("DateTime"));
oj_parse_error_class = rb_const_get_at(Oj, rb_intern("ParseError"));
oj_stringio_class = rb_const_get(rb_cObject, rb_intern("StringIO"));
oj_struct_class = rb_const_get(rb_cObject, rb_intern("Struct"));
json_parser_error_class = Qnil; // replaced if mimic is called
allow_gc_sym = ID2SYM(rb_intern("allow_gc")); rb_gc_register_address(&allow_gc_sym);
array_nl_sym = ID2SYM(rb_intern("array_nl")); rb_gc_register_address(&array_nl_sym);
ascii_only_sym = ID2SYM(rb_intern("ascii_only")); rb_gc_register_address(&ascii_only_sym);
ascii_sym = ID2SYM(rb_intern("ascii")); rb_gc_register_address(&ascii_sym);
auto_define_sym = ID2SYM(rb_intern("auto_define")); rb_gc_register_address(&auto_define_sym);
auto_sym = ID2SYM(rb_intern("auto")); rb_gc_register_address(&auto_sym);
bigdecimal_as_decimal_sym = ID2SYM(rb_intern("bigdecimal_as_decimal"));rb_gc_register_address(&bigdecimal_as_decimal_sym);
bigdecimal_load_sym = ID2SYM(rb_intern("bigdecimal_load"));rb_gc_register_address(&bigdecimal_load_sym);
bigdecimal_sym = ID2SYM(rb_intern("bigdecimal")); rb_gc_register_address(&bigdecimal_sym);
circular_sym = ID2SYM(rb_intern("circular")); rb_gc_register_address(&circular_sym);
class_cache_sym = ID2SYM(rb_intern("class_cache")); rb_gc_register_address(&class_cache_sym);
compat_sym = ID2SYM(rb_intern("compat")); rb_gc_register_address(&compat_sym);
create_id_sym = ID2SYM(rb_intern("create_id")); rb_gc_register_address(&create_id_sym);
escape_mode_sym = ID2SYM(rb_intern("escape_mode")); rb_gc_register_address(&escape_mode_sym);
float_prec_sym = ID2SYM(rb_intern("float_precision"));rb_gc_register_address(&float_prec_sym);
float_sym = ID2SYM(rb_intern("float")); rb_gc_register_address(&float_sym);
hash_class_sym = ID2SYM(rb_intern("hash_class")); rb_gc_register_address(&hash_class_sym);
huge_sym = ID2SYM(rb_intern("huge")); rb_gc_register_address(&huge_sym);
indent_sym = ID2SYM(rb_intern("indent")); rb_gc_register_address(&indent_sym);
json_sym = ID2SYM(rb_intern("json")); rb_gc_register_address(&json_sym);
mode_sym = ID2SYM(rb_intern("mode")); rb_gc_register_address(&mode_sym);
nan_sym = ID2SYM(rb_intern("nan")); rb_gc_register_address(&nan_sym);
newline_sym = ID2SYM(rb_intern("newline")); rb_gc_register_address(&newline_sym);
nilnil_sym = ID2SYM(rb_intern("nilnil")); rb_gc_register_address(&nilnil_sym);
null_sym = ID2SYM(rb_intern("null")); rb_gc_register_address(&null_sym);
object_nl_sym = ID2SYM(rb_intern("object_nl")); rb_gc_register_address(&object_nl_sym);
object_sym = ID2SYM(rb_intern("object")); rb_gc_register_address(&object_sym);
omit_nil_sym = ID2SYM(rb_intern("omit_nil")); rb_gc_register_address(&omit_nil_sym);
quirks_mode_sym = ID2SYM(rb_intern("quirks_mode")); rb_gc_register_address(&quirks_mode_sym);
allow_invalid_unicode_sym = ID2SYM(rb_intern("allow_invalid_unicode"));rb_gc_register_address(&allow_invalid_unicode_sym);
raise_sym = ID2SYM(rb_intern("raise")); rb_gc_register_address(&raise_sym);
ruby_sym = ID2SYM(rb_intern("ruby")); rb_gc_register_address(&ruby_sym);
sec_prec_sym = ID2SYM(rb_intern("second_precision"));rb_gc_register_address(&sec_prec_sym);
space_before_sym = ID2SYM(rb_intern("space_before"));rb_gc_register_address(&space_before_sym);
space_sym = ID2SYM(rb_intern("space")); rb_gc_register_address(&space_sym);
strict_sym = ID2SYM(rb_intern("strict")); rb_gc_register_address(&strict_sym);
symbol_keys_sym = ID2SYM(rb_intern("symbol_keys")); rb_gc_register_address(&symbol_keys_sym);
time_format_sym = ID2SYM(rb_intern("time_format")); rb_gc_register_address(&time_format_sym);
unix_sym = ID2SYM(rb_intern("unix")); rb_gc_register_address(&unix_sym);
unix_zone_sym = ID2SYM(rb_intern("unix_zone")); rb_gc_register_address(&unix_zone_sym);
use_to_json_sym = ID2SYM(rb_intern("use_to_json")); rb_gc_register_address(&use_to_json_sym);
word_sym = ID2SYM(rb_intern("word")); rb_gc_register_address(&word_sym);
xmlschema_sym = ID2SYM(rb_intern("xmlschema")); rb_gc_register_address(&xmlschema_sym);
xss_safe_sym = ID2SYM(rb_intern("xss_safe")); rb_gc_register_address(&xss_safe_sym);
oj_slash_string = rb_str_new2("/"); rb_gc_register_address(&oj_slash_string);
oj_default_options.mode = ObjectMode;
oj_hash_init();
oj_odd_init();
#if USE_PTHREAD_MUTEX
pthread_mutex_init(&oj_cache_mutex, 0);
#elif USE_RB_MUTEX
oj_cache_mutex = rb_mutex_new();
rb_gc_register_address(&oj_cache_mutex);
#endif
oj_init_doc();
}
// mimic JSON documentation
/* Document-module: JSON
*
* JSON is a JSON parser. This module when defined by the Oj module is a
* faster replacement for the original.
*/
/* Document-module: JSON::Ext
*
* The Ext module is a placeholder in the mimic JSON module used for
* compatibility only.
*/
/* Document-class: JSON::Ext::Parser
*
* The JSON::Ext::Parser is a placeholder in the mimic JSON module used for
* compatibility only.
*/
/* Document-class: JSON::Ext::Generator
*
* The JSON::Ext::Generator is a placeholder in the mimic JSON module used for
* compatibility only.
*/
/* Document-method: create_id=
* call-seq: create_id=(id) -> String
*
* Sets the create_id tag to look for in JSON document. That key triggers the
* creation of a class with the same name.
*
* @param [nil|String] id new create_id
* @return the id
*/
/* Document-method: parser=
* call-seq: parser=(parser) -> nil
*
* Does nothing other than provide compatibiltiy.
* @param [Object] parser ignored
*/
/* Document-method: generator=
* call-seq: generator=(generator) -> nil
*
* Does nothing other than provide compatibiltiy.
* @param [Object] generator ignored
*/
/* Document-method: dump
* call-seq: dump(obj, anIO=nil, limit = nil) -> String
*
* Encodes an object as a JSON String.
*
* @param [Object] obj object to convert to encode as JSON
* @param [IO] anIO an IO that allows writing
* @param [Fixnum] limit ignored
*/
/* Document-method: load
* call-seq: load(source, proc=nil) -> Object
*
* Loads a Ruby Object from a JSON source that can be either a String or an
* IO. If Proc is given or a block is providedit is called with each nested
* element of the loaded Object.
*
* @param [String|IO] source JSON source
* @param [Proc] proc to yield to on each element or nil
*/
/* Document-method: restore
* call-seq: restore(source, proc=nil) -> Object
*
* Loads a Ruby Object from a JSON source that can be either a String or an
* IO. If Proc is given or a block is providedit is called with each nested
* element of the loaded Object.
*
* @param [String|IO] source JSON source
* @param [Proc] proc to yield to on each element or nil
*/
/* Document-method: recurse_proc
* call-seq: recurse_proc(obj, &proc) -> nil
*
* Yields to the proc for every element in the obj recursivly.
*
* @param [Hash|Array] obj object to walk
* @param [Proc] proc to yield to on each element
*/
/* Document-method: []
* call-seq: [](obj, opts={}) -> Object
*
* If the obj argument is a String then it is assumed to be a JSON String and
* parsed otherwise the obj is encoded as a JSON String.
*
* @param [String|Hash|Array] obj object to convert
* @param [Hash] opts same options as either generate or parse
*/
/* Document-method: generate
* call-seq: generate(obj, opts=nil) -> String
*
* Encode obj as a JSON String. The obj argument must be a Hash, Array, or
* respond to to_h or to_json. Options other than those listed such as
* +:allow_nan+ or +:max_nesting+ are ignored.
*
* @param [Object|Hash|Array] obj object to convert to a JSON String
* @param [Hash] opts options
* @param [String] :indent String to use for indentation
* @param [String] :space String placed after a , or : delimiter
* @param [String] :space_before String placed before a : delimiter
* @param [String] :object_nl String placed after a JSON object
* @param [String] :array_nl String placed after a JSON array
* @param [true|false] :ascii_only if not nil or false then use only ascii
* characters in the output. Note JSON.generate does
* support this even if it is not documented.
*/
/* Document-method: fast_generate
* call-seq: fast_generate(obj, opts=nil) -> String
* Same as generate().
* @see generate
*/
/* Document-method: pretty_generate
* call-seq: pretty_generate(obj, opts=nil) -> String
* Same as generate() but with different defaults for the spacing options.
* @see generate
*/
/* Document-method: parse
* call-seq: parse(source, opts=nil) -> Object
*
* Parses a JSON String or IO into a Ruby Object. Options other than those
* listed such as +:allow_nan+ or +:max_nesting+ are ignored. +:object_class+ and
* +:array_object+ are not supported.
*
* @param [String|IO] source source to parse
* @param [Hash] opts options
* @param [true|false] :symbolize_names flag indicating JSON object keys should be Symbols instead of Strings
* @param [true|false] :create_additions flag indicating a key matching +create_id+ in a JSON object should trigger the creation of Ruby Object
* @see create_id=
*/
/* Document-method: parse!
* call-seq: parse!(source, opts=nil) -> Object
* Same as parse().
* @see parse
*/
oj-2.17.4/ext/oj/odd.h 0000644 0000041 0000041 00000005076 12766161567 014425 0 ustar www-data www-data /* odd.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_ODD_H__
#define __OJ_ODD_H__
#include
#include "ruby.h"
#define MAX_ODD_ARGS 10
typedef VALUE (*AttrGetFunc)(VALUE obj);
typedef struct _Odd {
const char *classname;
size_t clen;
VALUE clas; // Ruby class or module
VALUE create_obj;
ID create_op;
int attr_cnt;
bool is_module;
bool raw;
const char *attr_names[MAX_ODD_ARGS]; // 0 terminated attr IDs
ID attrs[MAX_ODD_ARGS]; // 0 terminated attr IDs
AttrGetFunc attrFuncs[MAX_ODD_ARGS];
} *Odd;
typedef struct _OddArgs {
Odd odd;
VALUE args[MAX_ODD_ARGS];
} *OddArgs;
extern void oj_odd_init(void);
extern Odd oj_get_odd(VALUE clas);
extern Odd oj_get_oddc(const char *classname, size_t len);
extern OddArgs oj_odd_alloc_args(Odd odd);
extern void oj_odd_free(OddArgs args);
extern int oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value);
extern void oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members, bool raw);
#endif /* __OJ_ODD_H__ */
oj-2.17.4/ext/oj/encode.h 0000644 0000041 0000041 00000003710 12766161567 015105 0 ustar www-data www-data /* encode.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_ENCODE_H__
#define __OJ_ENCODE_H__
#include "ruby.h"
#if HAS_ENCODING_SUPPORT
#include "ruby/encoding.h"
#endif
static inline VALUE
oj_encode(VALUE rstr) {
#if HAS_ENCODING_SUPPORT
rb_enc_associate(rstr, oj_utf8_encoding);
#else
if (Qnil != oj_utf8_encoding) {
rstr = rb_funcall(oj_utf8_encoding, oj_iconv_id, 1, rstr);
}
#endif
return rstr;
}
#endif /* __OJ_ENCODE_H__ */
oj-2.17.4/ext/oj/parse.c 0000644 0000041 0000041 00000060355 12766161567 014765 0 ustar www-data www-data /* parse.c
* Copyright (c) 2013, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include
#include
#include "oj.h"
#include "parse.h"
#include "buf.h"
#include "val_stack.h"
// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
#define OJ_INFINITY (1.0/0.0)
//#define EXP_MAX 1023
#define EXP_MAX 100000
#define DEC_MAX 15
static void
next_non_white(ParseInfo pi) {
for (; 1; pi->cur++) {
switch(*pi->cur) {
case ' ':
case '\t':
case '\f':
case '\n':
case '\r':
break;
default:
return;
}
}
}
static void
skip_comment(ParseInfo pi) {
if ('*' == *pi->cur) {
pi->cur++;
for (; pi->cur < pi->end; pi->cur++) {
if ('*' == *pi->cur && '/' == *(pi->cur + 1)) {
pi->cur += 2;
return;
} else if (pi->end <= pi->cur) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "comment not terminated");
return;
}
}
} else if ('/' == *pi->cur) {
for (; 1; pi->cur++) {
switch (*pi->cur) {
case '\n':
case '\r':
case '\f':
case '\0':
return;
default:
break;
}
}
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid comment format");
}
}
static void
add_value(ParseInfo pi, VALUE rval) {
Val parent = stack_peek(&pi->stack);
if (0 == parent) { // simple add
pi->add_value(pi, rval);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_value(pi, rval);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_VALUE:
pi->hash_set_value(pi, parent, rval);
if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
xfree((char*)parent->key);
parent->key = 0;
}
parent->next = NEXT_HASH_COMMA;
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
case NEXT_HASH_COMMA:
case NEXT_NONE:
case NEXT_ARRAY_COMMA:
case NEXT_HASH_COLON:
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s", oj_stack_next_string(parent->next));
break;
}
}
}
static void
read_null(ParseInfo pi) {
if ('u' == *pi->cur++ && 'l' == *pi->cur++ && 'l' == *pi->cur++) {
add_value(pi, Qnil);
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected null");
}
}
static void
read_true(ParseInfo pi) {
if ('r' == *pi->cur++ && 'u' == *pi->cur++ && 'e' == *pi->cur++) {
add_value(pi, Qtrue);
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected true");
}
}
static void
read_false(ParseInfo pi) {
if ('a' == *pi->cur++ && 'l' == *pi->cur++ && 's' == *pi->cur++ && 'e' == *pi->cur++) {
add_value(pi, Qfalse);
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected false");
}
}
static uint32_t
read_hex(ParseInfo pi, const char *h) {
uint32_t b = 0;
int i;
for (i = 0; i < 4; i++, h++) {
b = b << 4;
if ('0' <= *h && *h <= '9') {
b += *h - '0';
} else if ('A' <= *h && *h <= 'F') {
b += *h - 'A' + 10;
} else if ('a' <= *h && *h <= 'f') {
b += *h - 'a' + 10;
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hex character");
return 0;
}
}
return b;
}
static void
unicode_to_chars(ParseInfo pi, Buf buf, uint32_t code) {
if (0x0000007F >= code) {
buf_append(buf, (char)code);
} else if (0x000007FF >= code) {
buf_append(buf, 0xC0 | (code >> 6));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x0000FFFF >= code) {
buf_append(buf, 0xE0 | (code >> 12));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x001FFFFF >= code) {
buf_append(buf, 0xF0 | (code >> 18));
buf_append(buf, 0x80 | ((code >> 12) & 0x3F));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x03FFFFFF >= code) {
buf_append(buf, 0xF8 | (code >> 24));
buf_append(buf, 0x80 | ((code >> 18) & 0x3F));
buf_append(buf, 0x80 | ((code >> 12) & 0x3F));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else if (0x7FFFFFFF >= code) {
buf_append(buf, 0xFC | (code >> 30));
buf_append(buf, 0x80 | ((code >> 24) & 0x3F));
buf_append(buf, 0x80 | ((code >> 18) & 0x3F));
buf_append(buf, 0x80 | ((code >> 12) & 0x3F));
buf_append(buf, 0x80 | ((code >> 6) & 0x3F));
buf_append(buf, 0x80 | (0x3F & code));
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid Unicode character");
}
}
// entered at /
static void
read_escaped_str(ParseInfo pi, const char *start) {
struct _Buf buf;
const char *s;
int cnt = (int)(pi->cur - start);
uint32_t code;
Val parent = stack_peek(&pi->stack);
buf_init(&buf);
if (0 < cnt) {
buf_append_string(&buf, start, cnt);
}
for (s = pi->cur; '"' != *s; s++) {
if (s >= pi->end) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
buf_cleanup(&buf);
return;
} else if ('\\' == *s) {
s++;
switch (*s) {
case 'n': buf_append(&buf, '\n'); break;
case 'r': buf_append(&buf, '\r'); break;
case 't': buf_append(&buf, '\t'); break;
case 'f': buf_append(&buf, '\f'); break;
case 'b': buf_append(&buf, '\b'); break;
case '"': buf_append(&buf, '"'); break;
case '/': buf_append(&buf, '/'); break;
case '\\': buf_append(&buf, '\\'); break;
case 'u':
s++;
if (0 == (code = read_hex(pi, s)) && err_has(&pi->err)) {
buf_cleanup(&buf);
return;
}
s += 3;
if (0x0000D800 <= code && code <= 0x0000DFFF) {
uint32_t c1 = (code - 0x0000D800) & 0x000003FF;
uint32_t c2;
s++;
if ('\\' != *s || 'u' != *(s + 1)) {
if (Yes == pi->options.allow_invalid) {
s--;
unicode_to_chars(pi, &buf, code);
break;
}
pi->cur = s;
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
buf_cleanup(&buf);
return;
}
s += 2;
if (0 == (c2 = read_hex(pi, s)) && err_has(&pi->err)) {
buf_cleanup(&buf);
return;
}
s += 3;
c2 = (c2 - 0x0000DC00) & 0x000003FF;
code = ((c1 << 10) | c2) + 0x00010000;
}
unicode_to_chars(pi, &buf, code);
if (err_has(&pi->err)) {
buf_cleanup(&buf);
return;
}
break;
default:
pi->cur = s;
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
buf_cleanup(&buf);
return;
}
} else {
buf_append(&buf, *s);
}
}
if (0 == parent) {
pi->add_cstr(pi, buf.head, buf_len(&buf), start);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_cstr(pi, buf.head, buf_len(&buf), start);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
if (Qundef == (parent->key_val = pi->hash_key(pi, buf.head, buf_len(&buf)))) {
parent->key = strdup(buf.head);
parent->klen = buf_len(&buf);
} else {
parent->key = "";
parent->klen = 0;
}
parent->k1 = *start;
parent->next = NEXT_HASH_COLON;
break;
case NEXT_HASH_VALUE:
pi->hash_set_cstr(pi, parent, buf.head, buf_len(&buf), start);
if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
xfree((char*)parent->key);
parent->key = 0;
}
parent->next = NEXT_HASH_COMMA;
break;
case NEXT_HASH_COMMA:
case NEXT_NONE:
case NEXT_ARRAY_COMMA:
case NEXT_HASH_COLON:
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not a string", oj_stack_next_string(parent->next));
break;
}
}
pi->cur = s + 1;
buf_cleanup(&buf);
}
static void
read_str(ParseInfo pi) {
const char *str = pi->cur;
Val parent = stack_peek(&pi->stack);
for (; '"' != *pi->cur; pi->cur++) {
if (pi->end <= pi->cur) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "quoted string not terminated");
return;
} else if ('\0' == *pi->cur) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "NULL byte in string");
return;
} else if ('\\' == *pi->cur) {
read_escaped_str(pi, str);
return;
}
}
if (0 == parent) { // simple add
pi->add_cstr(pi, str, pi->cur - str, str);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_cstr(pi, str, pi->cur - str, str);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
if (Qundef == (parent->key_val = pi->hash_key(pi, str, pi->cur - str))) {
parent->key = str;
parent->klen = pi->cur - str;
} else {
parent->key = "";
parent->klen = 0;
}
parent->k1 = *str;
parent->next = NEXT_HASH_COLON;
break;
case NEXT_HASH_VALUE:
pi->hash_set_cstr(pi, parent, str, pi->cur - str, str);
if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
xfree((char*)parent->key);
parent->key = 0;
}
parent->next = NEXT_HASH_COMMA;
break;
case NEXT_HASH_COMMA:
case NEXT_NONE:
case NEXT_ARRAY_COMMA:
case NEXT_HASH_COLON:
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not a string", oj_stack_next_string(parent->next));
break;
}
}
pi->cur++; // move past "
}
static void
read_num(ParseInfo pi) {
struct _NumInfo ni;
Val parent = stack_peek(&pi->stack);
ni.str = pi->cur;
ni.i = 0;
ni.num = 0;
ni.div = 1;
ni.di = 0;
ni.len = 0;
ni.exp = 0;
ni.big = 0;
ni.infinity = 0;
ni.nan = 0;
ni.neg = 0;
ni.hasExp = 0;
ni.no_big = (FloatDec == pi->options.bigdec_load);
if ('-' == *pi->cur) {
pi->cur++;
ni.neg = 1;
} else if ('+' == *pi->cur) {
pi->cur++;
}
if ('I' == *pi->cur) {
if (0 != strncmp("Infinity", pi->cur, 8)) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
return;
}
pi->cur += 8;
ni.infinity = 1;
} else if ('N' == *pi->cur || 'n' == *pi->cur) {
if ('a' != pi->cur[1] || ('N' != pi->cur[2] && 'n' != pi->cur[2])) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
return;
}
pi->cur += 3;
ni.nan = 1;
} else {
int dec_cnt = 0;
for (; '0' <= *pi->cur && *pi->cur <= '9'; pi->cur++) {
if (0 < ni.i) {
dec_cnt++;
}
if (!ni.big) {
int d = (*pi->cur - '0');
ni.i = ni.i * 10 + d;
if (INT64_MAX <= ni.i || DEC_MAX < dec_cnt) {
ni.big = 1;
}
}
}
if ('.' == *pi->cur) {
pi->cur++;
for (; '0' <= *pi->cur && *pi->cur <= '9'; pi->cur++) {
int d = (*pi->cur - '0');
if (0 < ni.num || 0 < ni.i) {
dec_cnt++;
}
ni.num = ni.num * 10 + d;
ni.div *= 10;
ni.di++;
if (INT64_MAX <= ni.div || DEC_MAX < dec_cnt) {
ni.big = 1;
}
}
}
if ('e' == *pi->cur || 'E' == *pi->cur) {
int eneg = 0;
ni.hasExp = 1;
pi->cur++;
if ('-' == *pi->cur) {
pi->cur++;
eneg = 1;
} else if ('+' == *pi->cur) {
pi->cur++;
}
for (; '0' <= *pi->cur && *pi->cur <= '9'; pi->cur++) {
ni.exp = ni.exp * 10 + (*pi->cur - '0');
if (EXP_MAX <= ni.exp) {
ni.big = 1;
}
}
if (eneg) {
ni.exp = -ni.exp;
}
}
ni.len = pi->cur - ni.str;
}
// Check for special reserved values for Infinity and NaN.
if (ni.big) {
if (0 == strcasecmp(INF_VAL, ni.str)) {
ni.infinity = 1;
} else if (0 == strcasecmp(NINF_VAL, ni.str)) {
ni.infinity = 1;
ni.neg = 1;
} else if (0 == strcasecmp(NAN_VAL, ni.str)) {
ni.nan = 1;
}
}
if (BigDec == pi->options.bigdec_load) {
ni.big = 1;
}
if (0 == parent) {
pi->add_num(pi, &ni);
} else {
switch (parent->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
pi->array_append_num(pi, &ni);
parent->next = NEXT_ARRAY_COMMA;
break;
case NEXT_HASH_VALUE:
pi->hash_set_num(pi, parent, &ni);
if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
xfree((char*)parent->key);
parent->key = 0;
}
parent->next = NEXT_HASH_COMMA;
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s", oj_stack_next_string(parent->next));
break;
}
}
}
static void
array_start(ParseInfo pi) {
volatile VALUE v = pi->start_array(pi);
stack_push(&pi->stack, v, NEXT_ARRAY_NEW);
}
static void
array_end(ParseInfo pi) {
Val array = stack_pop(&pi->stack);
if (0 == array) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected array close");
} else if (NEXT_ARRAY_COMMA != array->next && NEXT_ARRAY_NEW != array->next) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not an array close", oj_stack_next_string(array->next));
} else {
pi->end_array(pi);
add_value(pi, array->val);
}
}
static void
hash_start(ParseInfo pi) {
volatile VALUE v = pi->start_hash(pi);
stack_push(&pi->stack, v, NEXT_HASH_NEW);
}
static void
hash_end(ParseInfo pi) {
volatile Val hash = stack_peek(&pi->stack);
// leave hash on stack until just before
if (0 == hash) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected hash close");
} else if (NEXT_HASH_COMMA != hash->next && NEXT_HASH_NEW != hash->next) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s, not a hash close", oj_stack_next_string(hash->next));
} else {
pi->end_hash(pi);
stack_pop(&pi->stack);
add_value(pi, hash->val);
}
}
static void
comma(ParseInfo pi) {
Val parent = stack_peek(&pi->stack);
if (0 == parent) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected comma");
} else if (NEXT_ARRAY_COMMA == parent->next) {
parent->next = NEXT_ARRAY_ELEMENT;
} else if (NEXT_HASH_COMMA == parent->next) {
parent->next = NEXT_HASH_KEY;
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected comma");
}
}
static void
colon(ParseInfo pi) {
Val parent = stack_peek(&pi->stack);
if (0 != parent && NEXT_HASH_COLON == parent->next) {
parent->next = NEXT_HASH_VALUE;
} else {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected colon");
}
}
void
oj_parse2(ParseInfo pi) {
int first = 1;
pi->cur = pi->json;
err_init(&pi->err);
while (1) {
next_non_white(pi);
if (!first && '\0' != *pi->cur) {
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected characters after the JSON document");
}
switch (*pi->cur++) {
case '{':
hash_start(pi);
break;
case '}':
hash_end(pi);
break;
case ':':
colon(pi);
break;
case '[':
array_start(pi);
break;
case ']':
array_end(pi);
break;
case ',':
comma(pi);
break;
case '"':
read_str(pi);
break;
case '+':
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'I':
case 'N':
pi->cur--;
read_num(pi);
break;
case 't':
read_true(pi);
break;
case 'f':
read_false(pi);
break;
case 'n':
if ('u' == *pi->cur) {
read_null(pi);
} else {
pi->cur--;
read_num(pi);
}
break;
case '/':
skip_comment(pi);
if (first) {
continue;
}
break;
case '\0':
pi->cur--;
return;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "unexpected character");
return;
}
if (err_has(&pi->err)) {
return;
}
if (stack_empty(&pi->stack)) {
if (Qundef != pi->proc) {
if (Qnil == pi->proc) {
rb_yield(stack_head_val(&pi->stack));
} else {
#if HAS_PROC_WITH_BLOCK
VALUE args[1];
*args = stack_head_val(&pi->stack);
rb_proc_call_with_block(pi->proc, 1, args, Qnil);
#else
rb_raise(rb_eNotImpError,
"Calling a Proc with a block not supported in this version. Use func() {|x| } syntax instead.");
#endif
}
} else {
first = 0;
}
}
}
}
VALUE
oj_num_as_value(NumInfo ni) {
volatile VALUE rnum = Qnil;
if (ni->infinity) {
if (ni->neg) {
rnum = rb_float_new(-OJ_INFINITY);
} else {
rnum = rb_float_new(OJ_INFINITY);
}
} else if (ni->nan) {
rnum = rb_float_new(0.0/0.0);
} else if (1 == ni->div && 0 == ni->exp) { // fixnum
if (ni->big) {
if (256 > ni->len) {
char buf[256];
memcpy(buf, ni->str, ni->len);
buf[ni->len] = '\0';
rnum = rb_cstr_to_inum(buf, 10, 0);
} else {
char *buf = ALLOC_N(char, ni->len + 1);
memcpy(buf, ni->str, ni->len);
buf[ni->len] = '\0';
rnum = rb_cstr_to_inum(buf, 10, 0);
xfree(buf);
}
} else {
if (ni->neg) {
rnum = rb_ll2inum(-ni->i);
} else {
rnum = rb_ll2inum(ni->i);
}
}
} else { // decimal
if (ni->big) {
rnum = rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new(ni->str, ni->len));
if (ni->no_big) {
rnum = rb_funcall(rnum, rb_intern("to_f"), 0);
}
} else {
// All these machinations are to get rounding to work better.
double d = (double)ni->i * (double)ni->div + (double)ni->num;
int x = ni->exp - ni->di;
// Rounding sometimes cuts off the last digit even if there are only
// 15 digits. This attempts to fix those few cases where this
// occurs.
if ((double)INT64_MAX > d && (int64_t)d != (ni->i * ni->div + ni->num)) {
rnum = rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new(ni->str, ni->len));
if (ni->no_big) {
rnum = rb_funcall(rnum, rb_intern("to_f"), 0);
}
} else {
d = round(d);
if (0 < x) {
d *= pow(10.0L, x);
} else if (0 > x) {
d /= pow(10.0L, -x);
}
if (ni->neg) {
d = -d;
}
rnum = rb_float_new(d);
}
}
}
return rnum;
}
void
oj_set_error_at(ParseInfo pi, VALUE err_clas, const char* file, int line, const char *format, ...) {
va_list ap;
char msg[128];
va_start(ap, format);
vsnprintf(msg, sizeof(msg) - 1, format, ap);
va_end(ap);
pi->err.clas = err_clas;
if (0 == pi->json) {
oj_err_set(&pi->err, err_clas, "%s at line %d, column %d [%s:%d]", msg, pi->rd.line, pi->rd.col, file, line);
} else {
_oj_err_set_with_location(&pi->err, err_clas, msg, pi->json, pi->cur - 1, file, line);
}
}
static VALUE
protect_parse(VALUE pip) {
oj_parse2((ParseInfo)pip);
return Qnil;
}
extern int oj_utf8_index;
static void
oj_pi_set_input_str(ParseInfo pi, volatile VALUE *inputp) {
#if HAS_ENCODING_SUPPORT
rb_encoding *enc = rb_to_encoding(rb_obj_encoding(*inputp));
if (rb_utf8_encoding() != enc) {
*inputp = rb_str_conv_enc(*inputp, enc, rb_utf8_encoding());
}
#endif
pi->json = rb_string_value_ptr((VALUE*)inputp);
pi->end = pi->json + RSTRING_LEN(*inputp);
}
VALUE
oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yieldOk) {
char *buf = 0;
volatile VALUE input;
volatile VALUE wrapped_stack;
volatile VALUE result = Qnil;
int line = 0;
int free_json = 0;
if (argc < 1) {
rb_raise(rb_eArgError, "Wrong number of arguments to parse.");
}
input = argv[0];
if (2 == argc) {
oj_parse_options(argv[1], &pi->options);
}
if (yieldOk && rb_block_given_p()) {
pi->proc = Qnil;
} else {
pi->proc = Qundef;
}
if (0 != json) {
pi->json = json;
pi->end = json + len;
free_json = 1;
} else if (T_STRING == rb_type(input)) {
oj_pi_set_input_str(pi, &input);
} else if (Qnil == input && Yes == pi->options.nilnil) {
return Qnil;
} else {
VALUE clas = rb_obj_class(input);
volatile VALUE s;
if (oj_stringio_class == clas) {
s = rb_funcall2(input, oj_string_id, 0, 0);
oj_pi_set_input_str(pi, &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;
size_t len = lseek(fd, 0, SEEK_END);
lseek(fd, 0, SEEK_SET);
buf = ALLOC_N(char, len + 1);
pi->json = buf;
pi->end = buf + len;
if (0 >= (cnt = read(fd, (char*)pi->json, len)) || cnt != (ssize_t)len) {
if (0 != buf) {
xfree(buf);
}
rb_raise(rb_eIOError, "failed to read from IO Object.");
}
((char*)pi->json)[len] = '\0';
/* skip UTF-8 BOM if present */
if (0xEF == (uint8_t)*pi->json && 0xBB == (uint8_t)pi->json[1] && 0xBF == (uint8_t)pi->json[2]) {
pi->json += 3;
}
#endif
} else if (rb_respond_to(input, oj_read_id)) {
// use stream parser instead
return oj_pi_sparse(argc, argv, pi, 0);
} else {
rb_raise(rb_eArgError, "strict_parse() expected a String or IO Object.");
}
}
if (Yes == pi->options.circular) {
pi->circ_array = oj_circ_array_new();
} else {
pi->circ_array = 0;
}
if (No == pi->options.allow_gc) {
rb_gc_disable();
}
// GC can run at any time. When it runs any Object created by C will be
// freed. We protect against this by wrapping the value stack in a ruby
// data object and poviding a mark function for ruby objects on the
// value stack (while it is in scope).
wrapped_stack = oj_stack_init(&pi->stack);
rb_protect(protect_parse, (VALUE)pi, &line);
result = stack_head_val(&pi->stack);
DATA_PTR(wrapped_stack) = 0;
if (No == pi->options.allow_gc) {
rb_gc_enable();
}
if (!err_has(&pi->err)) {
// If the stack is not empty then the JSON terminated early.
Val v;
if (0 != (v = stack_peek(&pi->stack))) {
switch (v->next) {
case NEXT_ARRAY_NEW:
case NEXT_ARRAY_ELEMENT:
case NEXT_ARRAY_COMMA:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Array not terminated");
break;
case NEXT_HASH_NEW:
case NEXT_HASH_KEY:
case NEXT_HASH_COLON:
case NEXT_HASH_VALUE:
case NEXT_HASH_COMMA:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Hash/Object not terminated");
break;
default:
oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not terminated");
}
}
}
// proceed with cleanup
if (0 != pi->circ_array) {
oj_circ_array_free(pi->circ_array);
}
if (0 != buf) {
xfree(buf);
} else if (free_json) {
xfree(json);
}
stack_cleanup(&pi->stack);
if (0 != line) {
rb_jump_tag(line);
}
if (err_has(&pi->err)) {
if (Qnil != pi->err_class) {
pi->err.clas = pi->err_class;
}
oj_err_raise(&pi->err);
}
if (pi->options.quirks_mode == No) {
switch (rb_type(result)) {
case T_NIL:
case T_TRUE:
case T_FALSE:
case T_FIXNUM:
case T_FLOAT:
case T_CLASS:
case T_STRING:
case T_SYMBOL: {
struct _Err err;
if (Qnil == pi->err_class) {
err.clas = oj_parse_error_class;
} else {
err.clas = pi->err_class;
}
snprintf(err.msg, sizeof(err.msg), "unexpected non-document value");
oj_err_raise(&err);
break;
}
default:
// okay
break;
}
}
return result;
}
oj-2.17.4/ext/oj/parse.h 0000644 0000041 0000041 00000007626 12766161567 014774 0 ustar www-data www-data /* parse.h
* Copyright (c) 2011, Peter Ohler
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Peter Ohler nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __OJ_PARSE_H__
#define __OJ_PARSE_H__
#include
#include
#include "ruby.h"
#include "oj.h"
#include "val_stack.h"
#include "circarray.h"
#include "reader.h"
typedef struct _NumInfo {
int64_t i;
int64_t num;
int64_t div;
int64_t di;
const char *str;
size_t len;
long exp;
//int dec_cnt;
int big;
int infinity;
int nan;
int neg;
int hasExp;
int no_big;
} *NumInfo;
typedef struct _ParseInfo {
// used for the string parser
const char *json;
const char *cur;
const char *end;
// used for the stream parser
struct _Reader rd;
struct _Err err;
struct _Options options;
VALUE handler;
struct _ValStack stack;
CircArray circ_array;
int expect_value;
VALUE proc;
VALUE (*start_hash)(struct _ParseInfo *pi);
void (*end_hash)(struct _ParseInfo *pi);
VALUE (*hash_key)(struct _ParseInfo *pi, const char *key, size_t klen);
void (*hash_set_cstr)(struct _ParseInfo *pi, Val kval, const char *str, size_t len, const char *orig);
void (*hash_set_num)(struct _ParseInfo *pi, Val kval, NumInfo ni);
void (*hash_set_value)(struct _ParseInfo *pi, Val kval, VALUE value);
VALUE (*start_array)(struct _ParseInfo *pi);
void (*end_array)(struct _ParseInfo *pi);
void (*array_append_cstr)(struct _ParseInfo *pi, const char *str, size_t len, const char *orig);
void (*array_append_num)(struct _ParseInfo *pi, NumInfo ni);
void (*array_append_value)(struct _ParseInfo *pi, VALUE value);
void (*add_cstr)(struct _ParseInfo *pi, const char *str, size_t len, const char *orig);
void (*add_num)(struct _ParseInfo *pi, NumInfo ni);
void (*add_value)(struct _ParseInfo *pi, VALUE val);
VALUE err_class;
} *ParseInfo;
extern void oj_parse2(ParseInfo pi);
extern void oj_set_error_at(ParseInfo pi, VALUE err_clas, const char* file, int line, const char *format, ...);
extern VALUE oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yieldOk);
extern VALUE oj_num_as_value(NumInfo ni);
extern void oj_set_strict_callbacks(ParseInfo pi);
extern void oj_set_object_callbacks(ParseInfo pi);
extern void oj_set_compat_callbacks(ParseInfo pi);
extern void oj_sparse2(ParseInfo pi);
extern VALUE oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd);
#endif /* __OJ_PARSE_H__ */
oj-2.17.4/README.md 0000644 0000041 0000041 00000024630 12766161567 013552 0 ustar www-data www-data # Oj gem
[](http://travis-ci.org/ohler55/oj)
A fast JSON parser and Object marshaller as a Ruby gem.
## Using
```ruby
require 'oj'
h = { 'one' => 1, 'array' => [ true, false ] }
json = Oj.dump(h)
# json =
# {
# "one":1,
# "array":[
# true,
# false
# ]
# }
h2 = Oj.load(json)
puts "Same? #{h == h2}"
# true
```
By default Oj uses the :object mode which is used to marshal and unmarshal Ruby
objects. Deserialize arbitrary JSON in object mode may lead to unexpected
results. :compat mode is a better choice for rails and :strict mode is a better
choice for general JSON parsing. See the options section below for details.
## Installation
```
gem install oj
```
or in Bundler:
```
gem 'oj'
```
## Advanced
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.
### Options
To change default serialization mode use the following form. Attempting to
modify the Oj.default_options Hash directly will not set the changes on the
actual default options but on a copy of the Hash:
```ruby
Oj.default_options = {:mode => :compat }
```
* `:mode` [Symbol] mode for dumping and loading JSON. **Important format details [here](http://www.ohler.com/dev/oj_misc/encoding_format.html).**
- `:object` mode will dump any `Object` as a JSON `Object` with keys that
match the Ruby `Object`'s variable names without the '@' prefix
character. This mode has the best performance and is the default.
- `:strict` mode will only allow the 7 basic JSON types to be serialized. Any
other `Object` will raise an `Exception`.
- `:null` mode replaces any `Object` that is not one of the JSON types with a JSON `null`.
- `:compat` mode attempts to be compatible with other systems. It will
serialize any `Object`, but will check to see if the `Object` implements an
`to_hash` or `to_json` method. If either exists, that method is used for
serializing the `Object`. Since `as_json` is more flexible and produces
more consistent output, it is preferred over the `to_json` method. If
neither the `to_json` or `to_hash` methods exists, then the Oj internal
`Object` variable encoding is used.
* `:indent` [Fixnum] number of spaces to indent each element in an JSON
document, zero is no newline between JSON elements, negative indicates no
newline between top level JSON elements in a stream
* `:circular` [Boolean] support circular references while dumping.
* `:auto_define` [Boolean] automatically define classes if they do not
exist.
* `:symbol_keys` [Boolean] use symbols instead of strings for hash keys.
* `:escape_mode` [Symbol] determines the characters to escape.
- `:newline` allows unescaped newlines in the output.
- `:json` follows the JSON specification. This is the default mode.
- `:xss_safe` escapes HTML and XML characters such as `&` and `<`.
- `:ascii` escapes all non-ascii or characters with the hi-bit set.
* `:class_cache` [Boolean] cache classes for faster parsing (if
dynamically modifying classes or reloading classes then don't use this)
* `:time_format` [Symbol] time format when dumping in :compat and :object mode
- `:unix` time is output as a decimal number in seconds since epoch including
fractions of a second.
- `:unix_zone` similar to the `:unix` format but with the timezone encoded in
the exponent of the decimal number of seconds since epoch.
- `:xmlschema` time is output as a string that follows the XML schema definition.
- `:ruby` time is output as a string formatted using the Ruby `to_s` conversion.
* `:bigdecimal_as_decimal` [Boolean] dump BigDecimal as a decimal number
or as a String
* `:bigdecimal_load` [Symbol] load decimals as BigDecimal instead of as a
Float.
- `:bigdecimal` convert all decimal numbers to BigDecimal.
- `:float` convert all decimal numbers to Float.
- `:auto` the most precise for the number of digits is used.
* `:create_id` [String] create id for json compatible object encoding,
default is `json_create`.
* `:second_precision` [Fixnum] number of digits after the decimal when dumping
the seconds portion of time
* `:float_precision` [Fixnum] number of digits of precision when dumping
floats, 0 indicates use Ruby
* `:use_to_json` [Boolean] call to_json() methods on dump, default is
false
* `:nilnil` [Boolean] if true a nil input to load will return nil and
not raise an Exception
* `:allow_gc` [Boolean] allow or prohibit GC during parsing, default is
true (allow).
* `:quirks_mode` [Boolean] Allow single JSON values instead of
documents, default is true (allow).
* `:nan` [:null|:huge|:word|:raise|:auto] How to dump Infinity, -Infinity, and
NaN in null, strict, and compat mode. :null places a null, :huge places a huge
number, :word places Infinity or NaN, :raise raises and exception, :auto uses
default for each mode which are :raise for :strict, :null for :null, and :word
for :compat. Default is :auto.
## Releases
**Release 2.17.4**
- Added the ascii_only option to JSON.generate when in mimic_JSON mode so that
it is consistent with the undocumented feature in the json gem.
[Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
## Compatibility
**Ruby**
Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1, 2.2, 2.3 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.
Instead, use the `oj_mimic_json` [gem](https://github.com/ohler55/oj_mimic_json) along with `oj` in your `Gemfile` to have Oj mimic the JSON gem and be used in its place by `ActiveSupport` JSON handling:
```
gem 'oj'
gem 'oj_mimic_json'
```
## Security and Optimization
Two settings in Oj are useful for parsing but do expose a vulnerability if used
from an untrusted source. Symbolized keys can cause memory to be filled with
previous versions of ruby. Ruby 2.1 and below does not garbage collect
Symbols. The same is true for auto defining classes in all versions of ruby;
memory will also be exhausted if too many classes are automatically
defined. Auto defining is a useful feature during development and from trusted
sources but it allows too many classes to be created in the object load mode and
auto defined is used with an untrusted source. The `Oj.strict_load()` method
sets and uses the most strict and safest options. It should be used by
developers who find it difficult to understand the options available in Oj.
The options in Oj are designed to provide flexibility to the developer. This
flexibility allows Objects to be serialized and deserialized. No methods are
ever called on these created Objects but that does not stop the developer from
calling methods on them. As in any system, check your inputs before working with
them. Taking an arbitrary `String` from a user and evaluating it is never a good
idea from an unsecure source. The same is true for `Object` attributes as they
are not more than `String`s. Always check inputs from untrusted sources.
## Links
*Documentation*: http://www.ohler.com/oj, http://rubydoc.info/gems/oj
*GitHub* *repo*: https://github.com/ohler55/oj
*RubyGems* *repo*: https://rubygems.org/gems/oj
Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Oj gem.
#### Performance Comparisons
[Oj Strict Mode Performance](http://www.ohler.com/dev/oj_misc/performance_strict.html) compares Oj strict mode parser performance to other JSON parsers.
[Oj Compat Mode Performance](http://www.ohler.com/dev/oj_misc/performance_compat.html) compares Oj compat mode parser performance to other JSON parsers.
[Oj Object Mode Performance](http://www.ohler.com/dev/oj_misc/performance_object.html) compares Oj object mode parser performance to other marshallers.
[Oj Callback Performance](http://www.ohler.com/dev/oj_misc/performance_callback.html) compares Oj callback parser performance to other JSON parsers.
#### Links of Interest
*Fast XML parser and marshaller on RubyGems*: https://rubygems.org/gems/ox
*Fast XML parser and marshaller on GitHub*: https://github.com/ohler55/ox
[Oj Object Encoding Format](http://www.ohler.com/dev/oj_misc/encoding_format.html) describes the OJ Object JSON encoding format.
[Need for Speed](http://www.ohler.com/dev/need_for_speed/need_for_speed.html) for an overview of how Oj::Doc was designed.
*OjC, a C JSON parser*: https://www.ohler.com/ojc also at https://github.com/ohler55/ojc
*Piper Push Cache, push JSON to browsers*: http://www.piperpushcache.com