This commit is contained in:
@@ -0,0 +1,587 @@
|
||||
# frozen_string_literal: true
|
||||
require 'json/common'
|
||||
|
||||
##
|
||||
# = JavaScript \Object Notation (\JSON)
|
||||
#
|
||||
# \JSON is a lightweight data-interchange format.
|
||||
#
|
||||
# A \JSON value is one of the following:
|
||||
# - Double-quoted text: <tt>"foo"</tt>.
|
||||
# - Number: +1+, +1.0+, +2.0e2+.
|
||||
# - Boolean: +true+, +false+.
|
||||
# - Null: +null+.
|
||||
# - \Array: an ordered list of values, enclosed by square brackets:
|
||||
# ["foo", 1, 1.0, 2.0e2, true, false, null]
|
||||
#
|
||||
# - \Object: a collection of name/value pairs, enclosed by curly braces;
|
||||
# each name is double-quoted text;
|
||||
# the values may be any \JSON values:
|
||||
# {"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null}
|
||||
#
|
||||
# A \JSON array or object may contain nested arrays, objects, and scalars
|
||||
# to any depth:
|
||||
# {"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]}
|
||||
# [{"foo": 0, "bar": 1}, ["baz", 2]]
|
||||
#
|
||||
# == Using \Module \JSON
|
||||
#
|
||||
# To make module \JSON available in your code, begin with:
|
||||
# require 'json'
|
||||
#
|
||||
# All examples here assume that this has been done.
|
||||
#
|
||||
# === Parsing \JSON
|
||||
#
|
||||
# You can parse a \String containing \JSON data using
|
||||
# either of two methods:
|
||||
# - <tt>JSON.parse(source, opts)</tt>
|
||||
# - <tt>JSON.parse!(source, opts)</tt>
|
||||
#
|
||||
# where
|
||||
# - +source+ is a Ruby object.
|
||||
# - +opts+ is a \Hash object containing options
|
||||
# that control both input allowed and output formatting.
|
||||
#
|
||||
# The difference between the two methods
|
||||
# is that JSON.parse! omits some checks
|
||||
# and may not be safe for some +source+ data;
|
||||
# use it only for data from trusted sources.
|
||||
# Use the safer method JSON.parse for less trusted sources.
|
||||
#
|
||||
# ==== Parsing \JSON Arrays
|
||||
#
|
||||
# When +source+ is a \JSON array, JSON.parse by default returns a Ruby \Array:
|
||||
# json = '["foo", 1, 1.0, 2.0e2, true, false, null]'
|
||||
# ruby = JSON.parse(json)
|
||||
# ruby # => ["foo", 1, 1.0, 200.0, true, false, nil]
|
||||
# ruby.class # => Array
|
||||
#
|
||||
# The \JSON array may contain nested arrays, objects, and scalars
|
||||
# to any depth:
|
||||
# json = '[{"foo": 0, "bar": 1}, ["baz", 2]]'
|
||||
# JSON.parse(json) # => [{"foo"=>0, "bar"=>1}, ["baz", 2]]
|
||||
#
|
||||
# ==== Parsing \JSON \Objects
|
||||
#
|
||||
# When the source is a \JSON object, JSON.parse by default returns a Ruby \Hash:
|
||||
# json = '{"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null}'
|
||||
# ruby = JSON.parse(json)
|
||||
# ruby # => {"a"=>"foo", "b"=>1, "c"=>1.0, "d"=>200.0, "e"=>true, "f"=>false, "g"=>nil}
|
||||
# ruby.class # => Hash
|
||||
#
|
||||
# The \JSON object may contain nested arrays, objects, and scalars
|
||||
# to any depth:
|
||||
# json = '{"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]}'
|
||||
# JSON.parse(json) # => {"foo"=>{"bar"=>1, "baz"=>2}, "bat"=>[0, 1, 2]}
|
||||
#
|
||||
# ==== Parsing \JSON Scalars
|
||||
#
|
||||
# When the source is a \JSON scalar (not an array or object),
|
||||
# JSON.parse returns a Ruby scalar.
|
||||
#
|
||||
# \String:
|
||||
# ruby = JSON.parse('"foo"')
|
||||
# ruby # => 'foo'
|
||||
# ruby.class # => String
|
||||
# \Integer:
|
||||
# ruby = JSON.parse('1')
|
||||
# ruby # => 1
|
||||
# ruby.class # => Integer
|
||||
# \Float:
|
||||
# ruby = JSON.parse('1.0')
|
||||
# ruby # => 1.0
|
||||
# ruby.class # => Float
|
||||
# ruby = JSON.parse('2.0e2')
|
||||
# ruby # => 200
|
||||
# ruby.class # => Float
|
||||
# Boolean:
|
||||
# ruby = JSON.parse('true')
|
||||
# ruby # => true
|
||||
# ruby.class # => TrueClass
|
||||
# ruby = JSON.parse('false')
|
||||
# ruby # => false
|
||||
# ruby.class # => FalseClass
|
||||
# Null:
|
||||
# ruby = JSON.parse('null')
|
||||
# ruby # => nil
|
||||
# ruby.class # => NilClass
|
||||
#
|
||||
# ==== Parsing Options
|
||||
#
|
||||
# ====== Input Options
|
||||
#
|
||||
# Option +max_nesting+ (\Integer) specifies the maximum nesting depth allowed;
|
||||
# defaults to +100+; specify +false+ to disable depth checking.
|
||||
#
|
||||
# With the default, +false+:
|
||||
# source = '[0, [1, [2, [3]]]]'
|
||||
# ruby = JSON.parse(source)
|
||||
# ruby # => [0, [1, [2, [3]]]]
|
||||
# Too deep:
|
||||
# # Raises JSON::NestingError (nesting of 2 is too deep):
|
||||
# JSON.parse(source, {max_nesting: 1})
|
||||
# Bad value:
|
||||
# # Raises TypeError (wrong argument type Symbol (expected Fixnum)):
|
||||
# JSON.parse(source, {max_nesting: :foo})
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# Option +allow_nan+ (boolean) specifies whether to allow
|
||||
# NaN, Infinity, and MinusInfinity in +source+;
|
||||
# defaults to +false+.
|
||||
#
|
||||
# With the default, +false+:
|
||||
# # Raises JSON::ParserError (225: unexpected token at '[NaN]'):
|
||||
# JSON.parse('[NaN]')
|
||||
# # Raises JSON::ParserError (232: unexpected token at '[Infinity]'):
|
||||
# JSON.parse('[Infinity]')
|
||||
# # Raises JSON::ParserError (248: unexpected token at '[-Infinity]'):
|
||||
# JSON.parse('[-Infinity]')
|
||||
# Allow:
|
||||
# source = '[NaN, Infinity, -Infinity]'
|
||||
# ruby = JSON.parse(source, {allow_nan: true})
|
||||
# ruby # => [NaN, Infinity, -Infinity]
|
||||
#
|
||||
# ====== Output Options
|
||||
#
|
||||
# Option +symbolize_names+ (boolean) specifies whether returned \Hash keys
|
||||
# should be Symbols;
|
||||
# defaults to +false+ (use Strings).
|
||||
#
|
||||
# With the default, +false+:
|
||||
# source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}'
|
||||
# ruby = JSON.parse(source)
|
||||
# ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil}
|
||||
# Use Symbols:
|
||||
# ruby = JSON.parse(source, {symbolize_names: true})
|
||||
# ruby # => {:a=>"foo", :b=>1.0, :c=>true, :d=>false, :e=>nil}
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# Option +object_class+ (\Class) specifies the Ruby class to be used
|
||||
# for each \JSON object;
|
||||
# defaults to \Hash.
|
||||
#
|
||||
# With the default, \Hash:
|
||||
# source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}'
|
||||
# ruby = JSON.parse(source)
|
||||
# ruby.class # => Hash
|
||||
# Use class \OpenStruct:
|
||||
# ruby = JSON.parse(source, {object_class: OpenStruct})
|
||||
# ruby # => #<OpenStruct a="foo", b=1.0, c=true, d=false, e=nil>
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# Option +array_class+ (\Class) specifies the Ruby class to be used
|
||||
# for each \JSON array;
|
||||
# defaults to \Array.
|
||||
#
|
||||
# With the default, \Array:
|
||||
# source = '["foo", 1.0, true, false, null]'
|
||||
# ruby = JSON.parse(source)
|
||||
# ruby.class # => Array
|
||||
# Use class \Set:
|
||||
# ruby = JSON.parse(source, {array_class: Set})
|
||||
# ruby # => #<Set: {"foo", 1.0, true, false, nil}>
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# Option +create_additions+ (boolean) specifies whether to use \JSON additions in parsing.
|
||||
# See {\JSON Additions}[#module-JSON-label-JSON+Additions].
|
||||
#
|
||||
# === Generating \JSON
|
||||
#
|
||||
# To generate a Ruby \String containing \JSON data,
|
||||
# use method <tt>JSON.generate(source, opts)</tt>, where
|
||||
# - +source+ is a Ruby object.
|
||||
# - +opts+ is a \Hash object containing options
|
||||
# that control both input allowed and output formatting.
|
||||
#
|
||||
# ==== Generating \JSON from Arrays
|
||||
#
|
||||
# When the source is a Ruby \Array, JSON.generate returns
|
||||
# a \String containing a \JSON array:
|
||||
# ruby = [0, 's', :foo]
|
||||
# json = JSON.generate(ruby)
|
||||
# json # => '[0,"s","foo"]'
|
||||
#
|
||||
# The Ruby \Array array may contain nested arrays, hashes, and scalars
|
||||
# to any depth:
|
||||
# ruby = [0, [1, 2], {foo: 3, bar: 4}]
|
||||
# json = JSON.generate(ruby)
|
||||
# json # => '[0,[1,2],{"foo":3,"bar":4}]'
|
||||
#
|
||||
# ==== Generating \JSON from Hashes
|
||||
#
|
||||
# When the source is a Ruby \Hash, JSON.generate returns
|
||||
# a \String containing a \JSON object:
|
||||
# ruby = {foo: 0, bar: 's', baz: :bat}
|
||||
# json = JSON.generate(ruby)
|
||||
# json # => '{"foo":0,"bar":"s","baz":"bat"}'
|
||||
#
|
||||
# The Ruby \Hash array may contain nested arrays, hashes, and scalars
|
||||
# to any depth:
|
||||
# ruby = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad}
|
||||
# json = JSON.generate(ruby)
|
||||
# json # => '{"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}'
|
||||
#
|
||||
# ==== Generating \JSON from Other Objects
|
||||
#
|
||||
# When the source is neither an \Array nor a \Hash,
|
||||
# the generated \JSON data depends on the class of the source.
|
||||
#
|
||||
# When the source is a Ruby \Integer or \Float, JSON.generate returns
|
||||
# a \String containing a \JSON number:
|
||||
# JSON.generate(42) # => '42'
|
||||
# JSON.generate(0.42) # => '0.42'
|
||||
#
|
||||
# When the source is a Ruby \String, JSON.generate returns
|
||||
# a \String containing a \JSON string (with double-quotes):
|
||||
# JSON.generate('A string') # => '"A string"'
|
||||
#
|
||||
# When the source is +true+, +false+ or +nil+, JSON.generate returns
|
||||
# a \String containing the corresponding \JSON token:
|
||||
# JSON.generate(true) # => 'true'
|
||||
# JSON.generate(false) # => 'false'
|
||||
# JSON.generate(nil) # => 'null'
|
||||
#
|
||||
# When the source is none of the above, JSON.generate returns
|
||||
# a \String containing a \JSON string representation of the source:
|
||||
# JSON.generate(:foo) # => '"foo"'
|
||||
# JSON.generate(Complex(0, 0)) # => '"0+0i"'
|
||||
# JSON.generate(Dir.new('.')) # => '"#<Dir>"'
|
||||
#
|
||||
# ==== Generating Options
|
||||
#
|
||||
# ====== Input Options
|
||||
#
|
||||
# Option +allow_nan+ (boolean) specifies whether
|
||||
# +NaN+, +Infinity+, and <tt>-Infinity</tt> may be generated;
|
||||
# defaults to +false+.
|
||||
#
|
||||
# With the default, +false+:
|
||||
# # Raises JSON::GeneratorError (920: NaN not allowed in JSON):
|
||||
# JSON.generate(JSON::NaN)
|
||||
# # Raises JSON::GeneratorError (917: Infinity not allowed in JSON):
|
||||
# JSON.generate(JSON::Infinity)
|
||||
# # Raises JSON::GeneratorError (917: -Infinity not allowed in JSON):
|
||||
# JSON.generate(JSON::MinusInfinity)
|
||||
#
|
||||
# Allow:
|
||||
# ruby = [Float::NaN, Float::Infinity, Float::MinusInfinity]
|
||||
# JSON.generate(ruby, allow_nan: true) # => '[NaN,Infinity,-Infinity]'
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# Option +max_nesting+ (\Integer) specifies the maximum nesting depth
|
||||
# in +obj+; defaults to +100+.
|
||||
#
|
||||
# With the default, +100+:
|
||||
# obj = [[[[[[0]]]]]]
|
||||
# JSON.generate(obj) # => '[[[[[[0]]]]]]'
|
||||
#
|
||||
# Too deep:
|
||||
# # Raises JSON::NestingError (nesting of 2 is too deep):
|
||||
# JSON.generate(obj, max_nesting: 2)
|
||||
#
|
||||
# ====== Escaping Options
|
||||
#
|
||||
# Options +script_safe+ (boolean) specifies wether <tt>'\u2028'</tt>, <tt>'\u2029'</tt>
|
||||
# and <tt>'/'</tt> should be escaped as to make the JSON object safe to interpolate in script
|
||||
# tags.
|
||||
#
|
||||
# Options +ascii_only+ (boolean) specifies wether all characters outside the ASCII range
|
||||
# should be escaped.
|
||||
#
|
||||
# ====== Output Options
|
||||
#
|
||||
# The default formatting options generate the most compact
|
||||
# \JSON data, all on one line and with no whitespace.
|
||||
#
|
||||
# You can use these formatting options to generate
|
||||
# \JSON data in a more open format, using whitespace.
|
||||
# See also JSON.pretty_generate.
|
||||
#
|
||||
# - Option +array_nl+ (\String) specifies a string (usually a newline)
|
||||
# to be inserted after each \JSON array; defaults to the empty \String, <tt>''</tt>.
|
||||
# - Option +object_nl+ (\String) specifies a string (usually a newline)
|
||||
# to be inserted after each \JSON object; defaults to the empty \String, <tt>''</tt>.
|
||||
# - Option +indent+ (\String) specifies the string (usually spaces) to be
|
||||
# used for indentation; defaults to the empty \String, <tt>''</tt>;
|
||||
# defaults to the empty \String, <tt>''</tt>;
|
||||
# has no effect unless options +array_nl+ or +object_nl+ specify newlines.
|
||||
# - Option +space+ (\String) specifies a string (usually a space) to be
|
||||
# inserted after the colon in each \JSON object's pair;
|
||||
# defaults to the empty \String, <tt>''</tt>.
|
||||
# - Option +space_before+ (\String) specifies a string (usually a space) to be
|
||||
# inserted before the colon in each \JSON object's pair;
|
||||
# defaults to the empty \String, <tt>''</tt>.
|
||||
#
|
||||
# In this example, +obj+ is used first to generate the shortest
|
||||
# \JSON data (no whitespace), then again with all formatting options
|
||||
# specified:
|
||||
#
|
||||
# obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}}
|
||||
# json = JSON.generate(obj)
|
||||
# puts 'Compact:', json
|
||||
# opts = {
|
||||
# array_nl: "\n",
|
||||
# object_nl: "\n",
|
||||
# indent: ' ',
|
||||
# space_before: ' ',
|
||||
# space: ' '
|
||||
# }
|
||||
# puts 'Open:', JSON.generate(obj, opts)
|
||||
#
|
||||
# Output:
|
||||
# Compact:
|
||||
# {"foo":["bar","baz"],"bat":{"bam":0,"bad":1}}
|
||||
# Open:
|
||||
# {
|
||||
# "foo" : [
|
||||
# "bar",
|
||||
# "baz"
|
||||
# ],
|
||||
# "bat" : {
|
||||
# "bam" : 0,
|
||||
# "bad" : 1
|
||||
# }
|
||||
# }
|
||||
#
|
||||
# == \JSON Additions
|
||||
#
|
||||
# When you "round trip" a non-\String object from Ruby to \JSON and back,
|
||||
# you have a new \String, instead of the object you began with:
|
||||
# ruby0 = Range.new(0, 2)
|
||||
# json = JSON.generate(ruby0)
|
||||
# json # => '0..2"'
|
||||
# ruby1 = JSON.parse(json)
|
||||
# ruby1 # => '0..2'
|
||||
# ruby1.class # => String
|
||||
#
|
||||
# You can use \JSON _additions_ to preserve the original object.
|
||||
# The addition is an extension of a ruby class, so that:
|
||||
# - \JSON.generate stores more information in the \JSON string.
|
||||
# - \JSON.parse, called with option +create_additions+,
|
||||
# uses that information to create a proper Ruby object.
|
||||
#
|
||||
# This example shows a \Range being generated into \JSON
|
||||
# and parsed back into Ruby, both without and with
|
||||
# the addition for \Range:
|
||||
# ruby = Range.new(0, 2)
|
||||
# # This passage does not use the addition for Range.
|
||||
# json0 = JSON.generate(ruby)
|
||||
# ruby0 = JSON.parse(json0)
|
||||
# # This passage uses the addition for Range.
|
||||
# require 'json/add/range'
|
||||
# json1 = JSON.generate(ruby)
|
||||
# ruby1 = JSON.parse(json1, create_additions: true)
|
||||
# # Make a nice display.
|
||||
# display = <<~EOT
|
||||
# Generated JSON:
|
||||
# Without addition: #{json0} (#{json0.class})
|
||||
# With addition: #{json1} (#{json1.class})
|
||||
# Parsed JSON:
|
||||
# Without addition: #{ruby0.inspect} (#{ruby0.class})
|
||||
# With addition: #{ruby1.inspect} (#{ruby1.class})
|
||||
# EOT
|
||||
# puts display
|
||||
#
|
||||
# This output shows the different results:
|
||||
# Generated JSON:
|
||||
# Without addition: "0..2" (String)
|
||||
# With addition: {"json_class":"Range","a":[0,2,false]} (String)
|
||||
# Parsed JSON:
|
||||
# Without addition: "0..2" (String)
|
||||
# With addition: 0..2 (Range)
|
||||
#
|
||||
# The \JSON module includes additions for certain classes.
|
||||
# You can also craft custom additions.
|
||||
# See {Custom \JSON Additions}[#module-JSON-label-Custom+JSON+Additions].
|
||||
#
|
||||
# === Built-in Additions
|
||||
#
|
||||
# The \JSON module includes additions for certain classes.
|
||||
# To use an addition, +require+ its source:
|
||||
# - BigDecimal: <tt>require 'json/add/bigdecimal'</tt>
|
||||
# - Complex: <tt>require 'json/add/complex'</tt>
|
||||
# - Date: <tt>require 'json/add/date'</tt>
|
||||
# - DateTime: <tt>require 'json/add/date_time'</tt>
|
||||
# - Exception: <tt>require 'json/add/exception'</tt>
|
||||
# - OpenStruct: <tt>require 'json/add/ostruct'</tt>
|
||||
# - Range: <tt>require 'json/add/range'</tt>
|
||||
# - Rational: <tt>require 'json/add/rational'</tt>
|
||||
# - Regexp: <tt>require 'json/add/regexp'</tt>
|
||||
# - Set: <tt>require 'json/add/set'</tt>
|
||||
# - Struct: <tt>require 'json/add/struct'</tt>
|
||||
# - Symbol: <tt>require 'json/add/symbol'</tt>
|
||||
# - Time: <tt>require 'json/add/time'</tt>
|
||||
#
|
||||
# To reduce punctuation clutter, the examples below
|
||||
# show the generated \JSON via +puts+, rather than the usual +inspect+,
|
||||
#
|
||||
# \BigDecimal:
|
||||
# require 'json/add/bigdecimal'
|
||||
# ruby0 = BigDecimal(0) # 0.0
|
||||
# json = JSON.generate(ruby0) # {"json_class":"BigDecimal","b":"27:0.0"}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # 0.0
|
||||
# ruby1.class # => BigDecimal
|
||||
#
|
||||
# \Complex:
|
||||
# require 'json/add/complex'
|
||||
# ruby0 = Complex(1+0i) # 1+0i
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Complex","r":1,"i":0}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # 1+0i
|
||||
# ruby1.class # Complex
|
||||
#
|
||||
# \Date:
|
||||
# require 'json/add/date'
|
||||
# ruby0 = Date.today # 2020-05-02
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Date","y":2020,"m":5,"d":2,"sg":2299161.0}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02
|
||||
# ruby1.class # Date
|
||||
#
|
||||
# \DateTime:
|
||||
# require 'json/add/date_time'
|
||||
# ruby0 = DateTime.now # 2020-05-02T10:38:13-05:00
|
||||
# json = JSON.generate(ruby0) # {"json_class":"DateTime","y":2020,"m":5,"d":2,"H":10,"M":38,"S":13,"of":"-5/24","sg":2299161.0}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02T10:38:13-05:00
|
||||
# ruby1.class # DateTime
|
||||
#
|
||||
# \Exception (and its subclasses including \RuntimeError):
|
||||
# require 'json/add/exception'
|
||||
# ruby0 = Exception.new('A message') # A message
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Exception","m":"A message","b":null}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # A message
|
||||
# ruby1.class # Exception
|
||||
# ruby0 = RuntimeError.new('Another message') # Another message
|
||||
# json = JSON.generate(ruby0) # {"json_class":"RuntimeError","m":"Another message","b":null}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # Another message
|
||||
# ruby1.class # RuntimeError
|
||||
#
|
||||
# \OpenStruct:
|
||||
# require 'json/add/ostruct'
|
||||
# ruby0 = OpenStruct.new(name: 'Matz', language: 'Ruby') # #<OpenStruct name="Matz", language="Ruby">
|
||||
# json = JSON.generate(ruby0) # {"json_class":"OpenStruct","t":{"name":"Matz","language":"Ruby"}}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # #<OpenStruct name="Matz", language="Ruby">
|
||||
# ruby1.class # OpenStruct
|
||||
#
|
||||
# \Range:
|
||||
# require 'json/add/range'
|
||||
# ruby0 = Range.new(0, 2) # 0..2
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Range","a":[0,2,false]}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # 0..2
|
||||
# ruby1.class # Range
|
||||
#
|
||||
# \Rational:
|
||||
# require 'json/add/rational'
|
||||
# ruby0 = Rational(1, 3) # 1/3
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Rational","n":1,"d":3}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # 1/3
|
||||
# ruby1.class # Rational
|
||||
#
|
||||
# \Regexp:
|
||||
# require 'json/add/regexp'
|
||||
# ruby0 = Regexp.new('foo') # (?-mix:foo)
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Regexp","o":0,"s":"foo"}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # (?-mix:foo)
|
||||
# ruby1.class # Regexp
|
||||
#
|
||||
# \Set:
|
||||
# require 'json/add/set'
|
||||
# ruby0 = Set.new([0, 1, 2]) # #<Set: {0, 1, 2}>
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Set","a":[0,1,2]}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # #<Set: {0, 1, 2}>
|
||||
# ruby1.class # Set
|
||||
#
|
||||
# \Struct:
|
||||
# require 'json/add/struct'
|
||||
# Customer = Struct.new(:name, :address) # Customer
|
||||
# ruby0 = Customer.new("Dave", "123 Main") # #<struct Customer name="Dave", address="123 Main">
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Customer","v":["Dave","123 Main"]}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # #<struct Customer name="Dave", address="123 Main">
|
||||
# ruby1.class # Customer
|
||||
#
|
||||
# \Symbol:
|
||||
# require 'json/add/symbol'
|
||||
# ruby0 = :foo # foo
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Symbol","s":"foo"}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # foo
|
||||
# ruby1.class # Symbol
|
||||
#
|
||||
# \Time:
|
||||
# require 'json/add/time'
|
||||
# ruby0 = Time.now # 2020-05-02 11:28:26 -0500
|
||||
# json = JSON.generate(ruby0) # {"json_class":"Time","s":1588436906,"n":840560000}
|
||||
# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02 11:28:26 -0500
|
||||
# ruby1.class # Time
|
||||
#
|
||||
#
|
||||
# === Custom \JSON Additions
|
||||
#
|
||||
# In addition to the \JSON additions provided,
|
||||
# you can craft \JSON additions of your own,
|
||||
# either for Ruby built-in classes or for user-defined classes.
|
||||
#
|
||||
# Here's a user-defined class +Foo+:
|
||||
# class Foo
|
||||
# attr_accessor :bar, :baz
|
||||
# def initialize(bar, baz)
|
||||
# self.bar = bar
|
||||
# self.baz = baz
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# Here's the \JSON addition for it:
|
||||
# # Extend class Foo with JSON addition.
|
||||
# class Foo
|
||||
# # Serialize Foo object with its class name and arguments
|
||||
# def to_json(*args)
|
||||
# {
|
||||
# JSON.create_id => self.class.name,
|
||||
# 'a' => [ bar, baz ]
|
||||
# }.to_json(*args)
|
||||
# end
|
||||
# # Deserialize JSON string by constructing new Foo object with arguments.
|
||||
# def self.json_create(object)
|
||||
# new(*object['a'])
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# Demonstration:
|
||||
# require 'json'
|
||||
# # This Foo object has no custom addition.
|
||||
# foo0 = Foo.new(0, 1)
|
||||
# json0 = JSON.generate(foo0)
|
||||
# obj0 = JSON.parse(json0)
|
||||
# # Lood the custom addition.
|
||||
# require_relative 'foo_addition'
|
||||
# # This foo has the custom addition.
|
||||
# foo1 = Foo.new(0, 1)
|
||||
# json1 = JSON.generate(foo1)
|
||||
# obj1 = JSON.parse(json1, create_additions: true)
|
||||
# # Make a nice display.
|
||||
# display = <<~EOT
|
||||
# Generated JSON:
|
||||
# Without custom addition: #{json0} (#{json0.class})
|
||||
# With custom addition: #{json1} (#{json1.class})
|
||||
# Parsed JSON:
|
||||
# Without custom addition: #{obj0.inspect} (#{obj0.class})
|
||||
# With custom addition: #{obj1.inspect} (#{obj1.class})
|
||||
# EOT
|
||||
# puts display
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# Generated JSON:
|
||||
# Without custom addition: "#<Foo:0x0000000006534e80>" (String)
|
||||
# With custom addition: {"json_class":"Foo","a":[0,1]} (String)
|
||||
# Parsed JSON:
|
||||
# Without custom addition: "#<Foo:0x0000000006534e80>" (String)
|
||||
# With custom addition: #<Foo:0x0000000006473bb8 @bar=0, @baz=1> (Foo)
|
||||
#
|
||||
module JSON
|
||||
require 'json/version'
|
||||
require 'json/ext'
|
||||
end
|
||||
@@ -0,0 +1,58 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
begin
|
||||
require 'bigdecimal'
|
||||
rescue LoadError
|
||||
end
|
||||
|
||||
class BigDecimal
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
BigDecimal._load object['b']
|
||||
end
|
||||
|
||||
# Methods <tt>BigDecimal#as_json</tt> and +BigDecimal.json_create+ may be used
|
||||
# to serialize and deserialize a \BigDecimal object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>BigDecimal#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/bigdecimal'
|
||||
# x = BigDecimal(2).as_json # => {"json_class"=>"BigDecimal", "b"=>"27:0.2e1"}
|
||||
# y = BigDecimal(2.0, 4).as_json # => {"json_class"=>"BigDecimal", "b"=>"36:0.2e1"}
|
||||
# z = BigDecimal(Complex(2, 0)).as_json # => {"json_class"=>"BigDecimal", "b"=>"27:0.2e1"}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \BigDecimal object:
|
||||
#
|
||||
# BigDecimal.json_create(x) # => 0.2e1
|
||||
# BigDecimal.json_create(y) # => 0.2e1
|
||||
# BigDecimal.json_create(z) # => 0.2e1
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'b' => _dump.force_encoding(Encoding::UTF_8),
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/bigdecimal'
|
||||
# puts BigDecimal(2).to_json
|
||||
# puts BigDecimal(2.0, 4).to_json
|
||||
# puts BigDecimal(Complex(2, 0)).to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"BigDecimal","b":"27:0.2e1"}
|
||||
# {"json_class":"BigDecimal","b":"36:0.2e1"}
|
||||
# {"json_class":"BigDecimal","b":"27:0.2e1"}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end if defined?(::BigDecimal)
|
||||
@@ -0,0 +1,51 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Complex
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
Complex(object['r'], object['i'])
|
||||
end
|
||||
|
||||
# Methods <tt>Complex#as_json</tt> and +Complex.json_create+ may be used
|
||||
# to serialize and deserialize a \Complex object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Complex#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/complex'
|
||||
# x = Complex(2).as_json # => {"json_class"=>"Complex", "r"=>2, "i"=>0}
|
||||
# y = Complex(2.0, 4).as_json # => {"json_class"=>"Complex", "r"=>2.0, "i"=>4}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Complex object:
|
||||
#
|
||||
# Complex.json_create(x) # => (2+0i)
|
||||
# Complex.json_create(y) # => (2.0+4i)
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'r' => real,
|
||||
'i' => imag,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/complex'
|
||||
# puts Complex(2).to_json
|
||||
# puts Complex(2.0, 4).to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Complex","r":2,"i":0}
|
||||
# {"json_class":"Complex","r":2.0,"i":4}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,12 @@
|
||||
# frozen_string_literal: true
|
||||
# This file requires the implementations of ruby core's custom objects for
|
||||
# serialisation/deserialisation.
|
||||
|
||||
require 'json/add/date'
|
||||
require 'json/add/date_time'
|
||||
require 'json/add/exception'
|
||||
require 'json/add/range'
|
||||
require 'json/add/regexp'
|
||||
require 'json/add/struct'
|
||||
require 'json/add/symbol'
|
||||
require 'json/add/time'
|
||||
@@ -0,0 +1,54 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
require 'date'
|
||||
|
||||
class Date
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
civil(*object.values_at('y', 'm', 'd', 'sg'))
|
||||
end
|
||||
|
||||
alias start sg unless method_defined?(:start)
|
||||
|
||||
# Methods <tt>Date#as_json</tt> and +Date.json_create+ may be used
|
||||
# to serialize and deserialize a \Date object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Date#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/date'
|
||||
# x = Date.today.as_json
|
||||
# # => {"json_class"=>"Date", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Date object:
|
||||
#
|
||||
# Date.json_create(x)
|
||||
# # => #<Date: 2023-11-21 ((2460270j,0s,0n),+0s,2299161j)>
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'y' => year,
|
||||
'm' => month,
|
||||
'd' => day,
|
||||
'sg' => start,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/date'
|
||||
# puts Date.today.to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Date","y":2023,"m":11,"d":21,"sg":2299161.0}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,67 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
require 'date'
|
||||
|
||||
class DateTime
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
args = object.values_at('y', 'm', 'd', 'H', 'M', 'S')
|
||||
of_a, of_b = object['of'].split('/')
|
||||
if of_b and of_b != '0'
|
||||
args << Rational(of_a.to_i, of_b.to_i)
|
||||
else
|
||||
args << of_a
|
||||
end
|
||||
args << object['sg']
|
||||
civil(*args)
|
||||
end
|
||||
|
||||
alias start sg unless method_defined?(:start)
|
||||
|
||||
# Methods <tt>DateTime#as_json</tt> and +DateTime.json_create+ may be used
|
||||
# to serialize and deserialize a \DateTime object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>DateTime#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/datetime'
|
||||
# x = DateTime.now.as_json
|
||||
# # => {"json_class"=>"DateTime", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \DateTime object:
|
||||
#
|
||||
# DateTime.json_create(x) # BUG? Raises Date::Error "invalid date"
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'y' => year,
|
||||
'm' => month,
|
||||
'd' => day,
|
||||
'H' => hour,
|
||||
'M' => min,
|
||||
'S' => sec,
|
||||
'of' => offset.to_s,
|
||||
'sg' => start,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/datetime'
|
||||
# puts DateTime.now.to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"DateTime","y":2023,"m":11,"d":21,"sg":2299161.0}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Exception
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
result = new(object['m'])
|
||||
result.set_backtrace object['b']
|
||||
result
|
||||
end
|
||||
|
||||
# Methods <tt>Exception#as_json</tt> and +Exception.json_create+ may be used
|
||||
# to serialize and deserialize a \Exception object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Exception#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/exception'
|
||||
# x = Exception.new('Foo').as_json # => {"json_class"=>"Exception", "m"=>"Foo", "b"=>nil}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Exception object:
|
||||
#
|
||||
# Exception.json_create(x) # => #<Exception: Foo>
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'm' => message,
|
||||
'b' => backtrace,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/exception'
|
||||
# puts Exception.new('Foo').to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Exception","m":"Foo","b":null}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,54 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
begin
|
||||
require 'ostruct'
|
||||
rescue LoadError
|
||||
end
|
||||
|
||||
class OpenStruct
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
new(object['t'] || object[:t])
|
||||
end
|
||||
|
||||
# Methods <tt>OpenStruct#as_json</tt> and +OpenStruct.json_create+ may be used
|
||||
# to serialize and deserialize a \OpenStruct object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>OpenStruct#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/ostruct'
|
||||
# x = OpenStruct.new('name' => 'Rowdy', :age => nil).as_json
|
||||
# # => {"json_class"=>"OpenStruct", "t"=>{:name=>'Rowdy', :age=>nil}}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \OpenStruct object:
|
||||
#
|
||||
# OpenStruct.json_create(x)
|
||||
# # => #<OpenStruct name='Rowdy', age=nil>
|
||||
#
|
||||
def as_json(*)
|
||||
klass = self.class.name
|
||||
klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
|
||||
{
|
||||
JSON.create_id => klass,
|
||||
't' => table,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/ostruct'
|
||||
# puts OpenStruct.new('name' => 'Rowdy', :age => nil).to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"OpenStruct","t":{'name':'Rowdy',"age":null}}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end if defined?(::OpenStruct)
|
||||
@@ -0,0 +1,54 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Range
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
new(*object['a'])
|
||||
end
|
||||
|
||||
# Methods <tt>Range#as_json</tt> and +Range.json_create+ may be used
|
||||
# to serialize and deserialize a \Range object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Range#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/range'
|
||||
# x = (1..4).as_json # => {"json_class"=>"Range", "a"=>[1, 4, false]}
|
||||
# y = (1...4).as_json # => {"json_class"=>"Range", "a"=>[1, 4, true]}
|
||||
# z = ('a'..'d').as_json # => {"json_class"=>"Range", "a"=>["a", "d", false]}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Range object:
|
||||
#
|
||||
# Range.json_create(x) # => 1..4
|
||||
# Range.json_create(y) # => 1...4
|
||||
# Range.json_create(z) # => "a".."d"
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'a' => [ first, last, exclude_end? ]
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/range'
|
||||
# puts (1..4).to_json
|
||||
# puts (1...4).to_json
|
||||
# puts ('a'..'d').to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Range","a":[1,4,false]}
|
||||
# {"json_class":"Range","a":[1,4,true]}
|
||||
# {"json_class":"Range","a":["a","d",false]}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,49 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Rational
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
Rational(object['n'], object['d'])
|
||||
end
|
||||
|
||||
# Methods <tt>Rational#as_json</tt> and +Rational.json_create+ may be used
|
||||
# to serialize and deserialize a \Rational object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Rational#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/rational'
|
||||
# x = Rational(2, 3).as_json
|
||||
# # => {"json_class"=>"Rational", "n"=>2, "d"=>3}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Rational object:
|
||||
#
|
||||
# Rational.json_create(x)
|
||||
# # => (2/3)
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'n' => numerator,
|
||||
'd' => denominator,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/rational'
|
||||
# puts Rational(2, 3).to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Rational","n":2,"d":3}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,48 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Regexp
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
new(object['s'], object['o'])
|
||||
end
|
||||
|
||||
# Methods <tt>Regexp#as_json</tt> and +Regexp.json_create+ may be used
|
||||
# to serialize and deserialize a \Regexp object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Regexp#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/regexp'
|
||||
# x = /foo/.as_json
|
||||
# # => {"json_class"=>"Regexp", "o"=>0, "s"=>"foo"}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Regexp object:
|
||||
#
|
||||
# Regexp.json_create(x) # => /foo/
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'o' => options,
|
||||
's' => source,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/regexp'
|
||||
# puts /foo/.to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Regexp","o":0,"s":"foo"}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,48 @@
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
defined?(::Set) or require 'set'
|
||||
|
||||
class Set
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
new object['a']
|
||||
end
|
||||
|
||||
# Methods <tt>Set#as_json</tt> and +Set.json_create+ may be used
|
||||
# to serialize and deserialize a \Set object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Set#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/set'
|
||||
# x = Set.new(%w/foo bar baz/).as_json
|
||||
# # => {"json_class"=>"Set", "a"=>["foo", "bar", "baz"]}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Set object:
|
||||
#
|
||||
# Set.json_create(x) # => #<Set: {"foo", "bar", "baz"}>
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'a' => to_a,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/set'
|
||||
# puts Set.new(%w/foo bar baz/).to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Set","a":["foo","bar","baz"]}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Struct
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
new(*object['v'])
|
||||
end
|
||||
|
||||
# Methods <tt>Struct#as_json</tt> and +Struct.json_create+ may be used
|
||||
# to serialize and deserialize a \Struct object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Struct#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/struct'
|
||||
# Customer = Struct.new('Customer', :name, :address, :zip)
|
||||
# x = Struct::Customer.new.as_json
|
||||
# # => {"json_class"=>"Struct::Customer", "v"=>[nil, nil, nil]}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Struct object:
|
||||
#
|
||||
# Struct::Customer.json_create(x)
|
||||
# # => #<struct Struct::Customer name=nil, address=nil, zip=nil>
|
||||
#
|
||||
def as_json(*)
|
||||
klass = self.class.name
|
||||
klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
|
||||
{
|
||||
JSON.create_id => klass,
|
||||
'v' => values,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/struct'
|
||||
# Customer = Struct.new('Customer', :name, :address, :zip)
|
||||
# puts Struct::Customer.new.to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Struct","t":{'name':'Rowdy',"age":null}}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,52 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Symbol
|
||||
|
||||
# Methods <tt>Symbol#as_json</tt> and +Symbol.json_create+ may be used
|
||||
# to serialize and deserialize a \Symbol object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Symbol#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/symbol'
|
||||
# x = :foo.as_json
|
||||
# # => {"json_class"=>"Symbol", "s"=>"foo"}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Symbol object:
|
||||
#
|
||||
# Symbol.json_create(x) # => :foo
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
's' => to_s,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/symbol'
|
||||
# puts :foo.to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# # {"json_class":"Symbol","s":"foo"}
|
||||
#
|
||||
def to_json(state = nil, *a)
|
||||
state = ::JSON::State.from_state(state)
|
||||
if state.strict?
|
||||
super
|
||||
else
|
||||
as_json.to_json(state, *a)
|
||||
end
|
||||
end
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(o)
|
||||
o['s'].to_sym
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,52 @@
|
||||
# frozen_string_literal: true
|
||||
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
|
||||
require 'json'
|
||||
end
|
||||
|
||||
class Time
|
||||
|
||||
# See #as_json.
|
||||
def self.json_create(object)
|
||||
if usec = object.delete('u') # used to be tv_usec -> tv_nsec
|
||||
object['n'] = usec * 1000
|
||||
end
|
||||
at(object['s'], Rational(object['n'], 1000))
|
||||
end
|
||||
|
||||
# Methods <tt>Time#as_json</tt> and +Time.json_create+ may be used
|
||||
# to serialize and deserialize a \Time object;
|
||||
# see Marshal[https://docs.ruby-lang.org/en/master/Marshal.html].
|
||||
#
|
||||
# \Method <tt>Time#as_json</tt> serializes +self+,
|
||||
# returning a 2-element hash representing +self+:
|
||||
#
|
||||
# require 'json/add/time'
|
||||
# x = Time.now.as_json
|
||||
# # => {"json_class"=>"Time", "s"=>1700931656, "n"=>472846644}
|
||||
#
|
||||
# \Method +JSON.create+ deserializes such a hash, returning a \Time object:
|
||||
#
|
||||
# Time.json_create(x)
|
||||
# # => 2023-11-25 11:00:56.472846644 -0600
|
||||
#
|
||||
def as_json(*)
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
's' => tv_sec,
|
||||
'n' => tv_nsec,
|
||||
}
|
||||
end
|
||||
|
||||
# Returns a JSON string representing +self+:
|
||||
#
|
||||
# require 'json/add/time'
|
||||
# puts Time.now.to_json
|
||||
#
|
||||
# Output:
|
||||
#
|
||||
# {"json_class":"Time","s":1700931678,"n":980650786}
|
||||
#
|
||||
def to_json(*args)
|
||||
as_json.to_json(*args)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,987 @@
|
||||
# frozen_string_literal: true
|
||||
|
||||
require 'json/version'
|
||||
|
||||
module JSON
|
||||
autoload :GenericObject, 'json/generic_object'
|
||||
|
||||
NOT_SET = Object.new.freeze
|
||||
private_constant :NOT_SET
|
||||
|
||||
class << self
|
||||
# :call-seq:
|
||||
# JSON[object] -> new_array or new_string
|
||||
#
|
||||
# If +object+ is a \String,
|
||||
# calls JSON.parse with +object+ and +opts+ (see method #parse):
|
||||
# json = '[0, 1, null]'
|
||||
# JSON[json]# => [0, 1, nil]
|
||||
#
|
||||
# Otherwise, calls JSON.generate with +object+ and +opts+ (see method #generate):
|
||||
# ruby = [0, 1, nil]
|
||||
# JSON[ruby] # => '[0,1,null]'
|
||||
def [](object, opts = {})
|
||||
if object.is_a?(String)
|
||||
return JSON.parse(object, opts)
|
||||
elsif object.respond_to?(:to_str)
|
||||
str = object.to_str
|
||||
if str.is_a?(String)
|
||||
return JSON.parse(str, opts)
|
||||
end
|
||||
end
|
||||
|
||||
JSON.generate(object, opts)
|
||||
end
|
||||
|
||||
# Returns the JSON parser class that is used by JSON.
|
||||
attr_reader :parser
|
||||
|
||||
# Set the JSON parser class _parser_ to be used by JSON.
|
||||
def parser=(parser) # :nodoc:
|
||||
@parser = parser
|
||||
remove_const :Parser if const_defined?(:Parser, false)
|
||||
const_set :Parser, parser
|
||||
end
|
||||
|
||||
# Return the constant located at _path_. The format of _path_ has to be
|
||||
# either ::A::B::C or A::B::C. In any case, A has to be located at the top
|
||||
# level (absolute namespace path?). If there doesn't exist a constant at
|
||||
# the given path, an ArgumentError is raised.
|
||||
def deep_const_get(path) # :nodoc:
|
||||
Object.const_get(path)
|
||||
rescue NameError => e
|
||||
raise ArgumentError, "can't get const #{path}: #{e}"
|
||||
end
|
||||
|
||||
# Set the module _generator_ to be used by JSON.
|
||||
def generator=(generator) # :nodoc:
|
||||
old, $VERBOSE = $VERBOSE, nil
|
||||
@generator = generator
|
||||
generator_methods = generator::GeneratorMethods
|
||||
for const in generator_methods.constants
|
||||
klass = const_get(const)
|
||||
modul = generator_methods.const_get(const)
|
||||
klass.class_eval do
|
||||
instance_methods(false).each do |m|
|
||||
m.to_s == 'to_json' and remove_method m
|
||||
end
|
||||
include modul
|
||||
end
|
||||
end
|
||||
self.state = generator::State
|
||||
const_set :State, self.state
|
||||
const_set :SAFE_STATE_PROTOTYPE, State.new # for JRuby
|
||||
const_set :FAST_STATE_PROTOTYPE, create_fast_state
|
||||
const_set :PRETTY_STATE_PROTOTYPE, create_pretty_state
|
||||
ensure
|
||||
$VERBOSE = old
|
||||
end
|
||||
|
||||
def create_fast_state
|
||||
State.new(
|
||||
:indent => '',
|
||||
:space => '',
|
||||
:object_nl => "",
|
||||
:array_nl => "",
|
||||
:max_nesting => false
|
||||
)
|
||||
end
|
||||
|
||||
def create_pretty_state
|
||||
State.new(
|
||||
:indent => ' ',
|
||||
:space => ' ',
|
||||
:object_nl => "\n",
|
||||
:array_nl => "\n"
|
||||
)
|
||||
end
|
||||
|
||||
# Returns the JSON generator module that is used by JSON.
|
||||
attr_reader :generator
|
||||
|
||||
# Sets or Returns the JSON generator state class that is used by JSON.
|
||||
attr_accessor :state
|
||||
end
|
||||
|
||||
# Sets create identifier, which is used to decide if the _json_create_
|
||||
# hook of a class should be called; initial value is +json_class+:
|
||||
# JSON.create_id # => 'json_class'
|
||||
def self.create_id=(new_value)
|
||||
Thread.current[:"JSON.create_id"] = new_value.dup.freeze
|
||||
end
|
||||
|
||||
# Returns the current create identifier.
|
||||
# See also JSON.create_id=.
|
||||
def self.create_id
|
||||
Thread.current[:"JSON.create_id"] || 'json_class'
|
||||
end
|
||||
|
||||
NaN = 0.0/0
|
||||
|
||||
Infinity = 1.0/0
|
||||
|
||||
MinusInfinity = -Infinity
|
||||
|
||||
# The base exception for JSON errors.
|
||||
class JSONError < StandardError
|
||||
def self.wrap(exception)
|
||||
obj = new("Wrapped(#{exception.class}): #{exception.message.inspect}")
|
||||
obj.set_backtrace exception.backtrace
|
||||
obj
|
||||
end
|
||||
end
|
||||
|
||||
# This exception is raised if a parser error occurs.
|
||||
class ParserError < JSONError; end
|
||||
|
||||
# This exception is raised if the nesting of parsed data structures is too
|
||||
# deep.
|
||||
class NestingError < ParserError; end
|
||||
|
||||
# :stopdoc:
|
||||
class CircularDatastructure < NestingError; end
|
||||
# :startdoc:
|
||||
|
||||
# This exception is raised if a generator or unparser error occurs.
|
||||
class GeneratorError < JSONError
|
||||
attr_reader :invalid_object
|
||||
|
||||
def initialize(message, invalid_object = nil)
|
||||
super(message)
|
||||
@invalid_object = invalid_object
|
||||
end
|
||||
|
||||
def detailed_message(...)
|
||||
# Exception#detailed_message doesn't exist until Ruby 3.2
|
||||
super_message = defined?(super) ? super : message
|
||||
|
||||
if @invalid_object.nil?
|
||||
super_message
|
||||
else
|
||||
"#{super_message}\nInvalid object: #{@invalid_object.inspect}"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# For backwards compatibility
|
||||
UnparserError = GeneratorError # :nodoc:
|
||||
|
||||
# This exception is raised if the required unicode support is missing on the
|
||||
# system. Usually this means that the iconv library is not installed.
|
||||
class MissingUnicodeSupport < JSONError; end
|
||||
|
||||
# Fragment of JSON document that is to be included as is:
|
||||
# fragment = JSON::Fragment.new("[1, 2, 3]")
|
||||
# JSON.generate({ count: 3, items: fragments })
|
||||
#
|
||||
# This allows to easily assemble multiple JSON fragments that have
|
||||
# been persisted somewhere without having to parse them nor resorting
|
||||
# to string interpolation.
|
||||
#
|
||||
# Note: no validation is performed on the provided string. It is the
|
||||
# responsability of the caller to ensure the string contains valid JSON.
|
||||
Fragment = Struct.new(:json) do
|
||||
def initialize(json)
|
||||
unless string = String.try_convert(json)
|
||||
raise TypeError, " no implicit conversion of #{json.class} into String"
|
||||
end
|
||||
|
||||
super(string)
|
||||
end
|
||||
|
||||
def to_json(state = nil, *)
|
||||
json
|
||||
end
|
||||
end
|
||||
|
||||
module_function
|
||||
|
||||
# :call-seq:
|
||||
# JSON.parse(source, opts) -> object
|
||||
#
|
||||
# Returns the Ruby objects created by parsing the given +source+.
|
||||
#
|
||||
# Argument +source+ contains the \String to be parsed.
|
||||
#
|
||||
# Argument +opts+, if given, contains a \Hash of options for the parsing.
|
||||
# See {Parsing Options}[#module-JSON-label-Parsing+Options].
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# When +source+ is a \JSON array, returns a Ruby \Array:
|
||||
# source = '["foo", 1.0, true, false, null]'
|
||||
# ruby = JSON.parse(source)
|
||||
# ruby # => ["foo", 1.0, true, false, nil]
|
||||
# ruby.class # => Array
|
||||
#
|
||||
# When +source+ is a \JSON object, returns a Ruby \Hash:
|
||||
# source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}'
|
||||
# ruby = JSON.parse(source)
|
||||
# ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil}
|
||||
# ruby.class # => Hash
|
||||
#
|
||||
# For examples of parsing for all \JSON data types, see
|
||||
# {Parsing \JSON}[#module-JSON-label-Parsing+JSON].
|
||||
#
|
||||
# Parses nested JSON objects:
|
||||
# source = <<~JSON
|
||||
# {
|
||||
# "name": "Dave",
|
||||
# "age" :40,
|
||||
# "hats": [
|
||||
# "Cattleman's",
|
||||
# "Panama",
|
||||
# "Tophat"
|
||||
# ]
|
||||
# }
|
||||
# JSON
|
||||
# ruby = JSON.parse(source)
|
||||
# ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# Raises an exception if +source+ is not valid JSON:
|
||||
# # Raises JSON::ParserError (783: unexpected token at ''):
|
||||
# JSON.parse('')
|
||||
#
|
||||
def parse(source, opts = nil)
|
||||
Parser.parse(source, opts)
|
||||
end
|
||||
|
||||
# :call-seq:
|
||||
# JSON.parse!(source, opts) -> object
|
||||
#
|
||||
# Calls
|
||||
# parse(source, opts)
|
||||
# with +source+ and possibly modified +opts+.
|
||||
#
|
||||
# Differences from JSON.parse:
|
||||
# - Option +max_nesting+, if not provided, defaults to +false+,
|
||||
# which disables checking for nesting depth.
|
||||
# - Option +allow_nan+, if not provided, defaults to +true+.
|
||||
def parse!(source, opts = nil)
|
||||
options = {
|
||||
:max_nesting => false,
|
||||
:allow_nan => true
|
||||
}
|
||||
options.merge!(opts) if opts
|
||||
Parser.new(source, options).parse
|
||||
end
|
||||
|
||||
# :call-seq:
|
||||
# JSON.load_file(path, opts={}) -> object
|
||||
#
|
||||
# Calls:
|
||||
# parse(File.read(path), opts)
|
||||
#
|
||||
# See method #parse.
|
||||
def load_file(filespec, opts = nil)
|
||||
parse(File.read(filespec, encoding: Encoding::UTF_8), opts)
|
||||
end
|
||||
|
||||
# :call-seq:
|
||||
# JSON.load_file!(path, opts = {})
|
||||
#
|
||||
# Calls:
|
||||
# JSON.parse!(File.read(path, opts))
|
||||
#
|
||||
# See method #parse!
|
||||
def load_file!(filespec, opts = nil)
|
||||
parse!(File.read(filespec, encoding: Encoding::UTF_8), opts)
|
||||
end
|
||||
|
||||
# :call-seq:
|
||||
# JSON.generate(obj, opts = nil) -> new_string
|
||||
#
|
||||
# Returns a \String containing the generated \JSON data.
|
||||
#
|
||||
# See also JSON.fast_generate, JSON.pretty_generate.
|
||||
#
|
||||
# Argument +obj+ is the Ruby object to be converted to \JSON.
|
||||
#
|
||||
# Argument +opts+, if given, contains a \Hash of options for the generation.
|
||||
# See {Generating Options}[#module-JSON-label-Generating+Options].
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# When +obj+ is an \Array, returns a \String containing a \JSON array:
|
||||
# obj = ["foo", 1.0, true, false, nil]
|
||||
# json = JSON.generate(obj)
|
||||
# json # => '["foo",1.0,true,false,null]'
|
||||
#
|
||||
# When +obj+ is a \Hash, returns a \String containing a \JSON object:
|
||||
# obj = {foo: 0, bar: 's', baz: :bat}
|
||||
# json = JSON.generate(obj)
|
||||
# json # => '{"foo":0,"bar":"s","baz":"bat"}'
|
||||
#
|
||||
# For examples of generating from other Ruby objects, see
|
||||
# {Generating \JSON from Other Objects}[#module-JSON-label-Generating+JSON+from+Other+Objects].
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# Raises an exception if any formatting option is not a \String.
|
||||
#
|
||||
# Raises an exception if +obj+ contains circular references:
|
||||
# a = []; b = []; a.push(b); b.push(a)
|
||||
# # Raises JSON::NestingError (nesting of 100 is too deep):
|
||||
# JSON.generate(a)
|
||||
#
|
||||
def generate(obj, opts = nil)
|
||||
if State === opts
|
||||
opts.generate(obj)
|
||||
else
|
||||
State.generate(obj, opts, nil)
|
||||
end
|
||||
end
|
||||
|
||||
# :stopdoc:
|
||||
# I want to deprecate these later, so I'll first be silent about them, and
|
||||
# later delete them.
|
||||
alias unparse generate
|
||||
module_function :unparse
|
||||
# :startdoc:
|
||||
|
||||
# :call-seq:
|
||||
# JSON.fast_generate(obj, opts) -> new_string
|
||||
#
|
||||
# Arguments +obj+ and +opts+ here are the same as
|
||||
# arguments +obj+ and +opts+ in JSON.generate.
|
||||
#
|
||||
# By default, generates \JSON data without checking
|
||||
# for circular references in +obj+ (option +max_nesting+ set to +false+, disabled).
|
||||
#
|
||||
# Raises an exception if +obj+ contains circular references:
|
||||
# a = []; b = []; a.push(b); b.push(a)
|
||||
# # Raises SystemStackError (stack level too deep):
|
||||
# JSON.fast_generate(a)
|
||||
def fast_generate(obj, opts = nil)
|
||||
if State === opts
|
||||
state = opts
|
||||
else
|
||||
state = JSON.create_fast_state.configure(opts)
|
||||
end
|
||||
state.generate(obj)
|
||||
end
|
||||
|
||||
# :stopdoc:
|
||||
# I want to deprecate these later, so I'll first be silent about them, and later delete them.
|
||||
alias fast_unparse fast_generate
|
||||
module_function :fast_unparse
|
||||
# :startdoc:
|
||||
|
||||
# :call-seq:
|
||||
# JSON.pretty_generate(obj, opts = nil) -> new_string
|
||||
#
|
||||
# Arguments +obj+ and +opts+ here are the same as
|
||||
# arguments +obj+ and +opts+ in JSON.generate.
|
||||
#
|
||||
# Default options are:
|
||||
# {
|
||||
# indent: ' ', # Two spaces
|
||||
# space: ' ', # One space
|
||||
# array_nl: "\n", # Newline
|
||||
# object_nl: "\n" # Newline
|
||||
# }
|
||||
#
|
||||
# Example:
|
||||
# obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}}
|
||||
# json = JSON.pretty_generate(obj)
|
||||
# puts json
|
||||
# Output:
|
||||
# {
|
||||
# "foo": [
|
||||
# "bar",
|
||||
# "baz"
|
||||
# ],
|
||||
# "bat": {
|
||||
# "bam": 0,
|
||||
# "bad": 1
|
||||
# }
|
||||
# }
|
||||
#
|
||||
def pretty_generate(obj, opts = nil)
|
||||
if State === opts
|
||||
state, opts = opts, nil
|
||||
else
|
||||
state = JSON.create_pretty_state
|
||||
end
|
||||
if opts
|
||||
if opts.respond_to? :to_hash
|
||||
opts = opts.to_hash
|
||||
elsif opts.respond_to? :to_h
|
||||
opts = opts.to_h
|
||||
else
|
||||
raise TypeError, "can't convert #{opts.class} into Hash"
|
||||
end
|
||||
state.configure(opts)
|
||||
end
|
||||
state.generate(obj)
|
||||
end
|
||||
|
||||
# :stopdoc:
|
||||
# I want to deprecate these later, so I'll first be silent about them, and later delete them.
|
||||
alias pretty_unparse pretty_generate
|
||||
module_function :pretty_unparse
|
||||
# :startdoc:
|
||||
|
||||
class << self
|
||||
# Sets or returns default options for the JSON.unsafe_load method.
|
||||
# Initially:
|
||||
# opts = JSON.load_default_options
|
||||
# opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true}
|
||||
attr_accessor :unsafe_load_default_options
|
||||
end
|
||||
self.unsafe_load_default_options = {
|
||||
:max_nesting => false,
|
||||
:allow_nan => true,
|
||||
:allow_blank => true,
|
||||
:create_additions => true,
|
||||
}
|
||||
|
||||
class << self
|
||||
# Sets or returns default options for the JSON.load method.
|
||||
# Initially:
|
||||
# opts = JSON.load_default_options
|
||||
# opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true}
|
||||
attr_accessor :load_default_options
|
||||
end
|
||||
self.load_default_options = {
|
||||
:allow_nan => true,
|
||||
:allow_blank => true,
|
||||
:create_additions => nil,
|
||||
}
|
||||
# :call-seq:
|
||||
# JSON.unsafe_load(source, proc = nil, options = {}) -> object
|
||||
#
|
||||
# Returns the Ruby objects created by parsing the given +source+.
|
||||
#
|
||||
# BEWARE: This method is meant to serialise data from trusted user input,
|
||||
# like from your own database server or clients under your control, it could
|
||||
# be dangerous to allow untrusted users to pass JSON sources into it.
|
||||
#
|
||||
# - Argument +source+ must be, or be convertible to, a \String:
|
||||
# - If +source+ responds to instance method +to_str+,
|
||||
# <tt>source.to_str</tt> becomes the source.
|
||||
# - If +source+ responds to instance method +to_io+,
|
||||
# <tt>source.to_io.read</tt> becomes the source.
|
||||
# - If +source+ responds to instance method +read+,
|
||||
# <tt>source.read</tt> becomes the source.
|
||||
# - If both of the following are true, source becomes the \String <tt>'null'</tt>:
|
||||
# - Option +allow_blank+ specifies a truthy value.
|
||||
# - The source, as defined above, is +nil+ or the empty \String <tt>''</tt>.
|
||||
# - Otherwise, +source+ remains the source.
|
||||
# - Argument +proc+, if given, must be a \Proc that accepts one argument.
|
||||
# It will be called recursively with each result (depth-first order).
|
||||
# See details below.
|
||||
# - Argument +opts+, if given, contains a \Hash of options for the parsing.
|
||||
# See {Parsing Options}[#module-JSON-label-Parsing+Options].
|
||||
# The default options can be changed via method JSON.unsafe_load_default_options=.
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# When no +proc+ is given, modifies +source+ as above and returns the result of
|
||||
# <tt>parse(source, opts)</tt>; see #parse.
|
||||
#
|
||||
# Source for following examples:
|
||||
# source = <<~JSON
|
||||
# {
|
||||
# "name": "Dave",
|
||||
# "age" :40,
|
||||
# "hats": [
|
||||
# "Cattleman's",
|
||||
# "Panama",
|
||||
# "Tophat"
|
||||
# ]
|
||||
# }
|
||||
# JSON
|
||||
#
|
||||
# Load a \String:
|
||||
# ruby = JSON.unsafe_load(source)
|
||||
# ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
|
||||
#
|
||||
# Load an \IO object:
|
||||
# require 'stringio'
|
||||
# object = JSON.unsafe_load(StringIO.new(source))
|
||||
# object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
|
||||
#
|
||||
# Load a \File object:
|
||||
# path = 't.json'
|
||||
# File.write(path, source)
|
||||
# File.open(path) do |file|
|
||||
# JSON.unsafe_load(file)
|
||||
# end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# When +proc+ is given:
|
||||
# - Modifies +source+ as above.
|
||||
# - Gets the +result+ from calling <tt>parse(source, opts)</tt>.
|
||||
# - Recursively calls <tt>proc(result)</tt>.
|
||||
# - Returns the final result.
|
||||
#
|
||||
# Example:
|
||||
# require 'json'
|
||||
#
|
||||
# # Some classes for the example.
|
||||
# class Base
|
||||
# def initialize(attributes)
|
||||
# @attributes = attributes
|
||||
# end
|
||||
# end
|
||||
# class User < Base; end
|
||||
# class Account < Base; end
|
||||
# class Admin < Base; end
|
||||
# # The JSON source.
|
||||
# json = <<-EOF
|
||||
# {
|
||||
# "users": [
|
||||
# {"type": "User", "username": "jane", "email": "jane@example.com"},
|
||||
# {"type": "User", "username": "john", "email": "john@example.com"}
|
||||
# ],
|
||||
# "accounts": [
|
||||
# {"account": {"type": "Account", "paid": true, "account_id": "1234"}},
|
||||
# {"account": {"type": "Account", "paid": false, "account_id": "1235"}}
|
||||
# ],
|
||||
# "admins": {"type": "Admin", "password": "0wn3d"}
|
||||
# }
|
||||
# EOF
|
||||
# # Deserializer method.
|
||||
# def deserialize_obj(obj, safe_types = %w(User Account Admin))
|
||||
# type = obj.is_a?(Hash) && obj["type"]
|
||||
# safe_types.include?(type) ? Object.const_get(type).new(obj) : obj
|
||||
# end
|
||||
# # Call to JSON.unsafe_load
|
||||
# ruby = JSON.unsafe_load(json, proc {|obj|
|
||||
# case obj
|
||||
# when Hash
|
||||
# obj.each {|k, v| obj[k] = deserialize_obj v }
|
||||
# when Array
|
||||
# obj.map! {|v| deserialize_obj v }
|
||||
# end
|
||||
# })
|
||||
# pp ruby
|
||||
# Output:
|
||||
# {"users"=>
|
||||
# [#<User:0x00000000064c4c98
|
||||
# @attributes=
|
||||
# {"type"=>"User", "username"=>"jane", "email"=>"jane@example.com"}>,
|
||||
# #<User:0x00000000064c4bd0
|
||||
# @attributes=
|
||||
# {"type"=>"User", "username"=>"john", "email"=>"john@example.com"}>],
|
||||
# "accounts"=>
|
||||
# [{"account"=>
|
||||
# #<Account:0x00000000064c4928
|
||||
# @attributes={"type"=>"Account", "paid"=>true, "account_id"=>"1234"}>},
|
||||
# {"account"=>
|
||||
# #<Account:0x00000000064c4680
|
||||
# @attributes={"type"=>"Account", "paid"=>false, "account_id"=>"1235"}>}],
|
||||
# "admins"=>
|
||||
# #<Admin:0x00000000064c41f8
|
||||
# @attributes={"type"=>"Admin", "password"=>"0wn3d"}>}
|
||||
#
|
||||
def unsafe_load(source, proc = nil, options = nil)
|
||||
opts = if options.nil?
|
||||
unsafe_load_default_options
|
||||
else
|
||||
unsafe_load_default_options.merge(options)
|
||||
end
|
||||
|
||||
unless source.is_a?(String)
|
||||
if source.respond_to? :to_str
|
||||
source = source.to_str
|
||||
elsif source.respond_to? :to_io
|
||||
source = source.to_io.read
|
||||
elsif source.respond_to?(:read)
|
||||
source = source.read
|
||||
end
|
||||
end
|
||||
|
||||
if opts[:allow_blank] && (source.nil? || source.empty?)
|
||||
source = 'null'
|
||||
end
|
||||
result = parse(source, opts)
|
||||
recurse_proc(result, &proc) if proc
|
||||
result
|
||||
end
|
||||
|
||||
# :call-seq:
|
||||
# JSON.load(source, proc = nil, options = {}) -> object
|
||||
#
|
||||
# Returns the Ruby objects created by parsing the given +source+.
|
||||
#
|
||||
# BEWARE: This method is meant to serialise data from trusted user input,
|
||||
# like from your own database server or clients under your control, it could
|
||||
# be dangerous to allow untrusted users to pass JSON sources into it.
|
||||
# If you must use it, use JSON.unsafe_load instead to make it clear.
|
||||
#
|
||||
# Since JSON version 2.8.0, `load` emits a deprecation warning when a
|
||||
# non native type is deserialized, without `create_additions` being explicitly
|
||||
# enabled, and in JSON version 3.0, `load` will have `create_additions` disabled
|
||||
# by default.
|
||||
#
|
||||
# - Argument +source+ must be, or be convertible to, a \String:
|
||||
# - If +source+ responds to instance method +to_str+,
|
||||
# <tt>source.to_str</tt> becomes the source.
|
||||
# - If +source+ responds to instance method +to_io+,
|
||||
# <tt>source.to_io.read</tt> becomes the source.
|
||||
# - If +source+ responds to instance method +read+,
|
||||
# <tt>source.read</tt> becomes the source.
|
||||
# - If both of the following are true, source becomes the \String <tt>'null'</tt>:
|
||||
# - Option +allow_blank+ specifies a truthy value.
|
||||
# - The source, as defined above, is +nil+ or the empty \String <tt>''</tt>.
|
||||
# - Otherwise, +source+ remains the source.
|
||||
# - Argument +proc+, if given, must be a \Proc that accepts one argument.
|
||||
# It will be called recursively with each result (depth-first order).
|
||||
# See details below.
|
||||
# - Argument +opts+, if given, contains a \Hash of options for the parsing.
|
||||
# See {Parsing Options}[#module-JSON-label-Parsing+Options].
|
||||
# The default options can be changed via method JSON.load_default_options=.
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# When no +proc+ is given, modifies +source+ as above and returns the result of
|
||||
# <tt>parse(source, opts)</tt>; see #parse.
|
||||
#
|
||||
# Source for following examples:
|
||||
# source = <<~JSON
|
||||
# {
|
||||
# "name": "Dave",
|
||||
# "age" :40,
|
||||
# "hats": [
|
||||
# "Cattleman's",
|
||||
# "Panama",
|
||||
# "Tophat"
|
||||
# ]
|
||||
# }
|
||||
# JSON
|
||||
#
|
||||
# Load a \String:
|
||||
# ruby = JSON.load(source)
|
||||
# ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
|
||||
#
|
||||
# Load an \IO object:
|
||||
# require 'stringio'
|
||||
# object = JSON.load(StringIO.new(source))
|
||||
# object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
|
||||
#
|
||||
# Load a \File object:
|
||||
# path = 't.json'
|
||||
# File.write(path, source)
|
||||
# File.open(path) do |file|
|
||||
# JSON.load(file)
|
||||
# end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# When +proc+ is given:
|
||||
# - Modifies +source+ as above.
|
||||
# - Gets the +result+ from calling <tt>parse(source, opts)</tt>.
|
||||
# - Recursively calls <tt>proc(result)</tt>.
|
||||
# - Returns the final result.
|
||||
#
|
||||
# Example:
|
||||
# require 'json'
|
||||
#
|
||||
# # Some classes for the example.
|
||||
# class Base
|
||||
# def initialize(attributes)
|
||||
# @attributes = attributes
|
||||
# end
|
||||
# end
|
||||
# class User < Base; end
|
||||
# class Account < Base; end
|
||||
# class Admin < Base; end
|
||||
# # The JSON source.
|
||||
# json = <<-EOF
|
||||
# {
|
||||
# "users": [
|
||||
# {"type": "User", "username": "jane", "email": "jane@example.com"},
|
||||
# {"type": "User", "username": "john", "email": "john@example.com"}
|
||||
# ],
|
||||
# "accounts": [
|
||||
# {"account": {"type": "Account", "paid": true, "account_id": "1234"}},
|
||||
# {"account": {"type": "Account", "paid": false, "account_id": "1235"}}
|
||||
# ],
|
||||
# "admins": {"type": "Admin", "password": "0wn3d"}
|
||||
# }
|
||||
# EOF
|
||||
# # Deserializer method.
|
||||
# def deserialize_obj(obj, safe_types = %w(User Account Admin))
|
||||
# type = obj.is_a?(Hash) && obj["type"]
|
||||
# safe_types.include?(type) ? Object.const_get(type).new(obj) : obj
|
||||
# end
|
||||
# # Call to JSON.load
|
||||
# ruby = JSON.load(json, proc {|obj|
|
||||
# case obj
|
||||
# when Hash
|
||||
# obj.each {|k, v| obj[k] = deserialize_obj v }
|
||||
# when Array
|
||||
# obj.map! {|v| deserialize_obj v }
|
||||
# end
|
||||
# })
|
||||
# pp ruby
|
||||
# Output:
|
||||
# {"users"=>
|
||||
# [#<User:0x00000000064c4c98
|
||||
# @attributes=
|
||||
# {"type"=>"User", "username"=>"jane", "email"=>"jane@example.com"}>,
|
||||
# #<User:0x00000000064c4bd0
|
||||
# @attributes=
|
||||
# {"type"=>"User", "username"=>"john", "email"=>"john@example.com"}>],
|
||||
# "accounts"=>
|
||||
# [{"account"=>
|
||||
# #<Account:0x00000000064c4928
|
||||
# @attributes={"type"=>"Account", "paid"=>true, "account_id"=>"1234"}>},
|
||||
# {"account"=>
|
||||
# #<Account:0x00000000064c4680
|
||||
# @attributes={"type"=>"Account", "paid"=>false, "account_id"=>"1235"}>}],
|
||||
# "admins"=>
|
||||
# #<Admin:0x00000000064c41f8
|
||||
# @attributes={"type"=>"Admin", "password"=>"0wn3d"}>}
|
||||
#
|
||||
def load(source, proc = nil, options = nil)
|
||||
opts = if options.nil?
|
||||
load_default_options
|
||||
else
|
||||
load_default_options.merge(options)
|
||||
end
|
||||
|
||||
unless source.is_a?(String)
|
||||
if source.respond_to? :to_str
|
||||
source = source.to_str
|
||||
elsif source.respond_to? :to_io
|
||||
source = source.to_io.read
|
||||
elsif source.respond_to?(:read)
|
||||
source = source.read
|
||||
end
|
||||
end
|
||||
|
||||
if opts[:allow_blank] && (source.nil? || source.empty?)
|
||||
source = 'null'
|
||||
end
|
||||
result = parse(source, opts)
|
||||
recurse_proc(result, &proc) if proc
|
||||
result
|
||||
end
|
||||
|
||||
# Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_
|
||||
def recurse_proc(result, &proc) # :nodoc:
|
||||
case result
|
||||
when Array
|
||||
result.each { |x| recurse_proc x, &proc }
|
||||
proc.call result
|
||||
when Hash
|
||||
result.each { |x, y| recurse_proc x, &proc; recurse_proc y, &proc }
|
||||
proc.call result
|
||||
else
|
||||
proc.call result
|
||||
end
|
||||
end
|
||||
|
||||
alias restore load
|
||||
module_function :restore
|
||||
|
||||
class << self
|
||||
# Sets or returns the default options for the JSON.dump method.
|
||||
# Initially:
|
||||
# opts = JSON.dump_default_options
|
||||
# opts # => {:max_nesting=>false, :allow_nan=>true}
|
||||
attr_accessor :dump_default_options
|
||||
end
|
||||
self.dump_default_options = {
|
||||
:max_nesting => false,
|
||||
:allow_nan => true,
|
||||
}
|
||||
|
||||
# :call-seq:
|
||||
# JSON.dump(obj, io = nil, limit = nil)
|
||||
#
|
||||
# Dumps +obj+ as a \JSON string, i.e. calls generate on the object and returns the result.
|
||||
#
|
||||
# The default options can be changed via method JSON.dump_default_options.
|
||||
#
|
||||
# - Argument +io+, if given, should respond to method +write+;
|
||||
# the \JSON \String is written to +io+, and +io+ is returned.
|
||||
# If +io+ is not given, the \JSON \String is returned.
|
||||
# - Argument +limit+, if given, is passed to JSON.generate as option +max_nesting+.
|
||||
#
|
||||
# ---
|
||||
#
|
||||
# When argument +io+ is not given, returns the \JSON \String generated from +obj+:
|
||||
# obj = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad}
|
||||
# json = JSON.dump(obj)
|
||||
# json # => "{\"foo\":[0,1],\"bar\":{\"baz\":2,\"bat\":3},\"bam\":\"bad\"}"
|
||||
#
|
||||
# When argument +io+ is given, writes the \JSON \String to +io+ and returns +io+:
|
||||
# path = 't.json'
|
||||
# File.open(path, 'w') do |file|
|
||||
# JSON.dump(obj, file)
|
||||
# end # => #<File:t.json (closed)>
|
||||
# puts File.read(path)
|
||||
# Output:
|
||||
# {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}
|
||||
def dump(obj, anIO = nil, limit = nil, kwargs = nil)
|
||||
if kwargs.nil?
|
||||
if limit.nil?
|
||||
if anIO.is_a?(Hash)
|
||||
kwargs = anIO
|
||||
anIO = nil
|
||||
end
|
||||
elsif limit.is_a?(Hash)
|
||||
kwargs = limit
|
||||
limit = nil
|
||||
end
|
||||
end
|
||||
|
||||
unless anIO.nil?
|
||||
if anIO.respond_to?(:to_io)
|
||||
anIO = anIO.to_io
|
||||
elsif limit.nil? && !anIO.respond_to?(:write)
|
||||
anIO, limit = nil, anIO
|
||||
end
|
||||
end
|
||||
|
||||
opts = JSON.dump_default_options
|
||||
opts = opts.merge(:max_nesting => limit) if limit
|
||||
opts = opts.merge(kwargs) if kwargs
|
||||
|
||||
begin
|
||||
State.generate(obj, opts, anIO)
|
||||
rescue JSON::NestingError
|
||||
raise ArgumentError, "exceed depth limit"
|
||||
end
|
||||
end
|
||||
|
||||
# Encodes string using String.encode.
|
||||
def self.iconv(to, from, string)
|
||||
string.encode(to, from)
|
||||
end
|
||||
|
||||
# JSON::Coder holds a parser and generator configuration.
|
||||
#
|
||||
# module MyApp
|
||||
# JSONC_CODER = JSON::Coder.new(
|
||||
# allow_trailing_comma: true
|
||||
# )
|
||||
# end
|
||||
#
|
||||
# MyApp::JSONC_CODER.load(document)
|
||||
#
|
||||
class Coder
|
||||
# :call-seq:
|
||||
# JSON.new(options = nil, &block)
|
||||
#
|
||||
# Argument +options+, if given, contains a \Hash of options for both parsing and generating.
|
||||
# See {Parsing Options}[#module-JSON-label-Parsing+Options], and {Generating Options}[#module-JSON-label-Generating+Options].
|
||||
#
|
||||
# For generation, the <tt>strict: true</tt> option is always set. When a Ruby object with no native \JSON counterpart is
|
||||
# encoutered, the block provided to the initialize method is invoked, and must return a Ruby object that has a native
|
||||
# \JSON counterpart:
|
||||
#
|
||||
# module MyApp
|
||||
# API_JSON_CODER = JSON::Coder.new do |object|
|
||||
# case object
|
||||
# when Time
|
||||
# object.iso8601(3)
|
||||
# else
|
||||
# object # Unknown type, will raise
|
||||
# end
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z"
|
||||
#
|
||||
def initialize(options = nil, &as_json)
|
||||
if options.nil?
|
||||
options = { strict: true }
|
||||
else
|
||||
options = options.dup
|
||||
options[:strict] = true
|
||||
end
|
||||
options[:as_json] = as_json if as_json
|
||||
options[:create_additions] = false unless options.key?(:create_additions)
|
||||
|
||||
@state = State.new(options).freeze
|
||||
@parser_config = Ext::Parser::Config.new(options)
|
||||
end
|
||||
|
||||
# call-seq:
|
||||
# dump(object) -> String
|
||||
# dump(object, io) -> io
|
||||
#
|
||||
# Serialize the given object into a \JSON document.
|
||||
def dump(object, io = nil)
|
||||
@state.generate_new(object, io)
|
||||
end
|
||||
alias_method :generate, :dump
|
||||
|
||||
# call-seq:
|
||||
# load(string) -> Object
|
||||
#
|
||||
# Parse the given \JSON document and return an equivalent Ruby object.
|
||||
def load(source)
|
||||
@parser_config.parse(source)
|
||||
end
|
||||
alias_method :parse, :load
|
||||
|
||||
# call-seq:
|
||||
# load(path) -> Object
|
||||
#
|
||||
# Parse the given \JSON document and return an equivalent Ruby object.
|
||||
def load_file(path)
|
||||
load(File.read(path, encoding: Encoding::UTF_8))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module ::Kernel
|
||||
private
|
||||
|
||||
# Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
|
||||
# one line.
|
||||
def j(*objs)
|
||||
objs.each do |obj|
|
||||
puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
|
||||
end
|
||||
nil
|
||||
end
|
||||
|
||||
# Outputs _objs_ to STDOUT as JSON strings in a pretty format, with
|
||||
# indentation and over many lines.
|
||||
def jj(*objs)
|
||||
objs.each do |obj|
|
||||
puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
|
||||
end
|
||||
nil
|
||||
end
|
||||
|
||||
# If _object_ is string-like, parse the string and return the parsed result as
|
||||
# a Ruby data structure. Otherwise, generate a JSON text from the Ruby data
|
||||
# structure object and return it.
|
||||
#
|
||||
# The _opts_ argument is passed through to generate/parse respectively. See
|
||||
# generate and parse for their documentation.
|
||||
def JSON(object, *args)
|
||||
if object.is_a?(String)
|
||||
return JSON.parse(object, args.first)
|
||||
elsif object.respond_to?(:to_str)
|
||||
str = object.to_str
|
||||
if str.is_a?(String)
|
||||
return JSON.parse(object.to_str, args.first)
|
||||
end
|
||||
end
|
||||
|
||||
JSON.generate(object, args.first)
|
||||
end
|
||||
end
|
||||
|
||||
# Extends any Class to include _json_creatable?_ method.
|
||||
class ::Class
|
||||
# Returns true if this class can be used to create an instance
|
||||
# from a serialised JSON string. The class has to implement a class
|
||||
# method _json_create_ that expects a hash as first parameter. The hash
|
||||
# should include the required data.
|
||||
def json_creatable?
|
||||
respond_to?(:json_create)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,45 @@
|
||||
# frozen_string_literal: true
|
||||
|
||||
require 'json/common'
|
||||
|
||||
module JSON
|
||||
# This module holds all the modules/classes that implement JSON's
|
||||
# functionality as C extensions.
|
||||
module Ext
|
||||
class Parser
|
||||
class << self
|
||||
def parse(...)
|
||||
new(...).parse
|
||||
end
|
||||
alias_method :parse, :parse # Allow redefinition by extensions
|
||||
end
|
||||
|
||||
def initialize(source, opts = nil)
|
||||
@source = source
|
||||
@config = Config.new(opts)
|
||||
end
|
||||
|
||||
def source
|
||||
@source.dup
|
||||
end
|
||||
|
||||
def parse
|
||||
@config.parse(@source)
|
||||
end
|
||||
end
|
||||
|
||||
require 'json/ext/parser'
|
||||
Ext::Parser::Config = Ext::ParserConfig
|
||||
JSON.parser = Ext::Parser
|
||||
|
||||
if RUBY_ENGINE == 'truffleruby'
|
||||
require 'json/truffle_ruby/generator'
|
||||
JSON.generator = ::JSON::TruffleRuby::Generator
|
||||
else
|
||||
require 'json/ext/generator'
|
||||
JSON.generator = Generator
|
||||
end
|
||||
end
|
||||
|
||||
JSON_LOADED = true unless defined?(::JSON::JSON_LOADED)
|
||||
end
|
||||
BIN
Binary file not shown.
@@ -0,0 +1,106 @@
|
||||
# frozen_string_literal: true
|
||||
|
||||
module JSON
|
||||
module Ext
|
||||
module Generator
|
||||
class State
|
||||
# call-seq: new(opts = {})
|
||||
#
|
||||
# Instantiates a new State object, configured by _opts_.
|
||||
#
|
||||
# _opts_ can have the following keys:
|
||||
#
|
||||
# * *indent*: a string used to indent levels (default: ''),
|
||||
# * *space*: a string that is put after, a : or , delimiter (default: ''),
|
||||
# * *space_before*: a string that is put before a : pair delimiter (default: ''),
|
||||
# * *object_nl*: a string that is put at the end of a JSON object (default: ''),
|
||||
# * *array_nl*: a string that is put at the end of a JSON array (default: ''),
|
||||
# * *allow_nan*: true if NaN, Infinity, and -Infinity should be
|
||||
# generated, otherwise an exception is thrown, if these values are
|
||||
# encountered. This options defaults to false.
|
||||
# * *ascii_only*: true if only ASCII characters should be generated. This
|
||||
# option defaults to false.
|
||||
# * *buffer_initial_length*: sets the initial length of the generator's
|
||||
# internal buffer.
|
||||
def initialize(opts = nil)
|
||||
if opts && !opts.empty?
|
||||
configure(opts)
|
||||
end
|
||||
end
|
||||
|
||||
# call-seq: configure(opts)
|
||||
#
|
||||
# Configure this State instance with the Hash _opts_, and return
|
||||
# itself.
|
||||
def configure(opts)
|
||||
unless opts.is_a?(Hash)
|
||||
if opts.respond_to?(:to_hash)
|
||||
opts = opts.to_hash
|
||||
elsif opts.respond_to?(:to_h)
|
||||
opts = opts.to_h
|
||||
else
|
||||
raise TypeError, "can't convert #{opts.class} into Hash"
|
||||
end
|
||||
end
|
||||
_configure(opts)
|
||||
end
|
||||
|
||||
alias_method :merge, :configure
|
||||
|
||||
# call-seq: to_h
|
||||
#
|
||||
# Returns the configuration instance variables as a hash, that can be
|
||||
# passed to the configure method.
|
||||
def to_h
|
||||
result = {
|
||||
indent: indent,
|
||||
space: space,
|
||||
space_before: space_before,
|
||||
object_nl: object_nl,
|
||||
array_nl: array_nl,
|
||||
as_json: as_json,
|
||||
allow_nan: allow_nan?,
|
||||
ascii_only: ascii_only?,
|
||||
max_nesting: max_nesting,
|
||||
script_safe: script_safe?,
|
||||
strict: strict?,
|
||||
depth: depth,
|
||||
buffer_initial_length: buffer_initial_length,
|
||||
}
|
||||
|
||||
instance_variables.each do |iv|
|
||||
iv = iv.to_s[1..-1]
|
||||
result[iv.to_sym] = self[iv]
|
||||
end
|
||||
|
||||
result
|
||||
end
|
||||
|
||||
alias_method :to_hash, :to_h
|
||||
|
||||
# call-seq: [](name)
|
||||
#
|
||||
# Returns the value returned by method +name+.
|
||||
def [](name)
|
||||
if respond_to?(name)
|
||||
__send__(name)
|
||||
else
|
||||
instance_variable_get("@#{name}") if
|
||||
instance_variables.include?("@#{name}".to_sym) # avoid warning
|
||||
end
|
||||
end
|
||||
|
||||
# call-seq: []=(name, value)
|
||||
#
|
||||
# Sets the attribute name to value.
|
||||
def []=(name, value)
|
||||
if respond_to?(name_writer = "#{name}=")
|
||||
__send__ name_writer, value
|
||||
else
|
||||
instance_variable_set "@#{name}", value
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
Executable
BIN
Binary file not shown.
@@ -0,0 +1,75 @@
|
||||
# frozen_string_literal: true
|
||||
begin
|
||||
require 'ostruct'
|
||||
rescue LoadError
|
||||
warn "JSON::GenericObject requires 'ostruct'. Please install it with `gem install ostruct`."
|
||||
end
|
||||
|
||||
module JSON
|
||||
class GenericObject < OpenStruct
|
||||
class << self
|
||||
alias [] new
|
||||
|
||||
def json_creatable?
|
||||
@json_creatable
|
||||
end
|
||||
|
||||
attr_writer :json_creatable
|
||||
|
||||
def json_create(data)
|
||||
data = data.dup
|
||||
data.delete JSON.create_id
|
||||
self[data]
|
||||
end
|
||||
|
||||
def from_hash(object)
|
||||
case
|
||||
when object.respond_to?(:to_hash)
|
||||
result = new
|
||||
object.to_hash.each do |key, value|
|
||||
result[key] = from_hash(value)
|
||||
end
|
||||
result
|
||||
when object.respond_to?(:to_ary)
|
||||
object.to_ary.map { |a| from_hash(a) }
|
||||
else
|
||||
object
|
||||
end
|
||||
end
|
||||
|
||||
def load(source, proc = nil, opts = {})
|
||||
result = ::JSON.load(source, proc, opts.merge(:object_class => self))
|
||||
result.nil? ? new : result
|
||||
end
|
||||
|
||||
def dump(obj, *args)
|
||||
::JSON.dump(obj, *args)
|
||||
end
|
||||
end
|
||||
self.json_creatable = false
|
||||
|
||||
def to_hash
|
||||
table
|
||||
end
|
||||
|
||||
def [](name)
|
||||
__send__(name)
|
||||
end unless method_defined?(:[])
|
||||
|
||||
def []=(name, value)
|
||||
__send__("#{name}=", value)
|
||||
end unless method_defined?(:[]=)
|
||||
|
||||
def |(other)
|
||||
self.class[other.to_hash.merge(to_hash)]
|
||||
end
|
||||
|
||||
def as_json(*)
|
||||
{ JSON.create_id => self.class.name }.merge to_hash
|
||||
end
|
||||
|
||||
def to_json(*a)
|
||||
as_json.to_json(*a)
|
||||
end
|
||||
end if defined?(::OpenStruct)
|
||||
end
|
||||
@@ -0,0 +1,690 @@
|
||||
# frozen_string_literal: true
|
||||
module JSON
|
||||
module TruffleRuby
|
||||
module Generator
|
||||
MAP = {
|
||||
"\x0" => '\u0000',
|
||||
"\x1" => '\u0001',
|
||||
"\x2" => '\u0002',
|
||||
"\x3" => '\u0003',
|
||||
"\x4" => '\u0004',
|
||||
"\x5" => '\u0005',
|
||||
"\x6" => '\u0006',
|
||||
"\x7" => '\u0007',
|
||||
"\b" => '\b',
|
||||
"\t" => '\t',
|
||||
"\n" => '\n',
|
||||
"\xb" => '\u000b',
|
||||
"\f" => '\f',
|
||||
"\r" => '\r',
|
||||
"\xe" => '\u000e',
|
||||
"\xf" => '\u000f',
|
||||
"\x10" => '\u0010',
|
||||
"\x11" => '\u0011',
|
||||
"\x12" => '\u0012',
|
||||
"\x13" => '\u0013',
|
||||
"\x14" => '\u0014',
|
||||
"\x15" => '\u0015',
|
||||
"\x16" => '\u0016',
|
||||
"\x17" => '\u0017',
|
||||
"\x18" => '\u0018',
|
||||
"\x19" => '\u0019',
|
||||
"\x1a" => '\u001a',
|
||||
"\x1b" => '\u001b',
|
||||
"\x1c" => '\u001c',
|
||||
"\x1d" => '\u001d',
|
||||
"\x1e" => '\u001e',
|
||||
"\x1f" => '\u001f',
|
||||
'"' => '\"',
|
||||
'\\' => '\\\\',
|
||||
}.freeze # :nodoc:
|
||||
|
||||
SCRIPT_SAFE_MAP = MAP.merge(
|
||||
'/' => '\\/',
|
||||
"\u2028" => '\u2028',
|
||||
"\u2029" => '\u2029',
|
||||
).freeze
|
||||
|
||||
SCRIPT_SAFE_ESCAPE_PATTERN = /[\/"\\\x0-\x1f\u2028-\u2029]/
|
||||
|
||||
# Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
|
||||
# UTF16 big endian characters as \u????, and return it.
|
||||
def self.utf8_to_json(string, script_safe = false) # :nodoc:
|
||||
if script_safe
|
||||
if SCRIPT_SAFE_ESCAPE_PATTERN.match?(string)
|
||||
string.gsub(SCRIPT_SAFE_ESCAPE_PATTERN, SCRIPT_SAFE_MAP)
|
||||
else
|
||||
string
|
||||
end
|
||||
else
|
||||
if /["\\\x0-\x1f]/.match?(string)
|
||||
string.gsub(/["\\\x0-\x1f]/, MAP)
|
||||
else
|
||||
string
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def self.utf8_to_json_ascii(original_string, script_safe = false) # :nodoc:
|
||||
string = original_string.b
|
||||
map = script_safe ? SCRIPT_SAFE_MAP : MAP
|
||||
string.gsub!(/[\/"\\\x0-\x1f]/n) { map[$&] || $& }
|
||||
string.gsub!(/(
|
||||
(?:
|
||||
[\xc2-\xdf][\x80-\xbf] |
|
||||
[\xe0-\xef][\x80-\xbf]{2} |
|
||||
[\xf0-\xf4][\x80-\xbf]{3}
|
||||
)+ |
|
||||
[\x80-\xc1\xf5-\xff] # invalid
|
||||
)/nx) { |c|
|
||||
c.size == 1 and raise GeneratorError.new("invalid utf8 byte: '#{c}'", original_string)
|
||||
s = c.encode(::Encoding::UTF_16BE, ::Encoding::UTF_8).unpack('H*')[0]
|
||||
s.force_encoding(::Encoding::BINARY)
|
||||
s.gsub!(/.{4}/n, '\\\\u\&')
|
||||
s.force_encoding(::Encoding::UTF_8)
|
||||
}
|
||||
string.force_encoding(::Encoding::UTF_8)
|
||||
string
|
||||
rescue => e
|
||||
raise GeneratorError.new(e.message, original_string)
|
||||
end
|
||||
|
||||
def self.valid_utf8?(string)
|
||||
encoding = string.encoding
|
||||
(encoding == Encoding::UTF_8 || encoding == Encoding::ASCII) &&
|
||||
string.valid_encoding?
|
||||
end
|
||||
|
||||
# This class is used to create State instances, that are use to hold data
|
||||
# while generating a JSON text from a Ruby data structure.
|
||||
class State
|
||||
def self.generate(obj, opts = nil, io = nil)
|
||||
new(opts).generate(obj, io)
|
||||
end
|
||||
|
||||
# Creates a State object from _opts_, which ought to be Hash to create
|
||||
# a new State instance configured by _opts_, something else to create
|
||||
# an unconfigured instance. If _opts_ is a State object, it is just
|
||||
# returned.
|
||||
def self.from_state(opts)
|
||||
if opts
|
||||
case
|
||||
when self === opts
|
||||
return opts
|
||||
when opts.respond_to?(:to_hash)
|
||||
return new(opts.to_hash)
|
||||
when opts.respond_to?(:to_h)
|
||||
return new(opts.to_h)
|
||||
end
|
||||
end
|
||||
SAFE_STATE_PROTOTYPE.dup
|
||||
end
|
||||
|
||||
# Instantiates a new State object, configured by _opts_.
|
||||
#
|
||||
# _opts_ can have the following keys:
|
||||
#
|
||||
# * *indent*: a string used to indent levels (default: ''),
|
||||
# * *space*: a string that is put after, a : or , delimiter (default: ''),
|
||||
# * *space_before*: a string that is put before a : pair delimiter (default: ''),
|
||||
# * *object_nl*: a string that is put at the end of a JSON object (default: ''),
|
||||
# * *array_nl*: a string that is put at the end of a JSON array (default: ''),
|
||||
# * *script_safe*: true if U+2028, U+2029 and forward slash (/) should be escaped
|
||||
# as to make the JSON object safe to interpolate in a script tag (default: false).
|
||||
# * *check_circular*: is deprecated now, use the :max_nesting option instead,
|
||||
# * *max_nesting*: sets the maximum level of data structure nesting in
|
||||
# the generated JSON, max_nesting = 0 if no maximum should be checked.
|
||||
# * *allow_nan*: true if NaN, Infinity, and -Infinity should be
|
||||
# generated, otherwise an exception is thrown, if these values are
|
||||
# encountered. This options defaults to false.
|
||||
def initialize(opts = nil)
|
||||
@indent = ''
|
||||
@space = ''
|
||||
@space_before = ''
|
||||
@object_nl = ''
|
||||
@array_nl = ''
|
||||
@allow_nan = false
|
||||
@ascii_only = false
|
||||
@as_json = false
|
||||
@depth = 0
|
||||
@buffer_initial_length = 1024
|
||||
@script_safe = false
|
||||
@strict = false
|
||||
@max_nesting = 100
|
||||
configure(opts) if opts
|
||||
end
|
||||
|
||||
# This string is used to indent levels in the JSON text.
|
||||
attr_accessor :indent
|
||||
|
||||
# This string is used to insert a space between the tokens in a JSON
|
||||
# string.
|
||||
attr_accessor :space
|
||||
|
||||
# This string is used to insert a space before the ':' in JSON objects.
|
||||
attr_accessor :space_before
|
||||
|
||||
# This string is put at the end of a line that holds a JSON object (or
|
||||
# Hash).
|
||||
attr_accessor :object_nl
|
||||
|
||||
# This string is put at the end of a line that holds a JSON array.
|
||||
attr_accessor :array_nl
|
||||
|
||||
# This proc converts unsupported types into native JSON types.
|
||||
attr_accessor :as_json
|
||||
|
||||
# This integer returns the maximum level of data structure nesting in
|
||||
# the generated JSON, max_nesting = 0 if no maximum is checked.
|
||||
attr_accessor :max_nesting
|
||||
|
||||
# If this attribute is set to true, forward slashes will be escaped in
|
||||
# all json strings.
|
||||
attr_accessor :script_safe
|
||||
|
||||
# If this attribute is set to true, attempting to serialize types not
|
||||
# supported by the JSON spec will raise a JSON::GeneratorError
|
||||
attr_accessor :strict
|
||||
|
||||
# :stopdoc:
|
||||
attr_reader :buffer_initial_length
|
||||
|
||||
def buffer_initial_length=(length)
|
||||
if length > 0
|
||||
@buffer_initial_length = length
|
||||
end
|
||||
end
|
||||
# :startdoc:
|
||||
|
||||
# This integer returns the current depth data structure nesting in the
|
||||
# generated JSON.
|
||||
attr_accessor :depth
|
||||
|
||||
def check_max_nesting # :nodoc:
|
||||
return if @max_nesting.zero?
|
||||
current_nesting = depth + 1
|
||||
current_nesting > @max_nesting and
|
||||
raise NestingError, "nesting of #{current_nesting} is too deep"
|
||||
end
|
||||
|
||||
# Returns true, if circular data structures are checked,
|
||||
# otherwise returns false.
|
||||
def check_circular?
|
||||
!@max_nesting.zero?
|
||||
end
|
||||
|
||||
# Returns true if NaN, Infinity, and -Infinity should be considered as
|
||||
# valid JSON and output.
|
||||
def allow_nan?
|
||||
@allow_nan
|
||||
end
|
||||
|
||||
# Returns true, if only ASCII characters should be generated. Otherwise
|
||||
# returns false.
|
||||
def ascii_only?
|
||||
@ascii_only
|
||||
end
|
||||
|
||||
# Returns true, if forward slashes are escaped. Otherwise returns false.
|
||||
def script_safe?
|
||||
@script_safe
|
||||
end
|
||||
|
||||
# Returns true, if strict mode is enabled. Otherwise returns false.
|
||||
# Strict mode only allow serializing JSON native types: Hash, Array,
|
||||
# String, Integer, Float, true, false and nil.
|
||||
def strict?
|
||||
@strict
|
||||
end
|
||||
|
||||
# Configure this State instance with the Hash _opts_, and return
|
||||
# itself.
|
||||
def configure(opts)
|
||||
if opts.respond_to?(:to_hash)
|
||||
opts = opts.to_hash
|
||||
elsif opts.respond_to?(:to_h)
|
||||
opts = opts.to_h
|
||||
else
|
||||
raise TypeError, "can't convert #{opts.class} into Hash"
|
||||
end
|
||||
opts.each do |key, value|
|
||||
instance_variable_set "@#{key}", value
|
||||
end
|
||||
|
||||
# NOTE: If adding new instance variables here, check whether #generate should check them for #generate_json
|
||||
@indent = opts[:indent] || '' if opts.key?(:indent)
|
||||
@space = opts[:space] || '' if opts.key?(:space)
|
||||
@space_before = opts[:space_before] || '' if opts.key?(:space_before)
|
||||
@object_nl = opts[:object_nl] || '' if opts.key?(:object_nl)
|
||||
@array_nl = opts[:array_nl] || '' if opts.key?(:array_nl)
|
||||
@allow_nan = !!opts[:allow_nan] if opts.key?(:allow_nan)
|
||||
@as_json = opts[:as_json].to_proc if opts[:as_json]
|
||||
@ascii_only = opts[:ascii_only] if opts.key?(:ascii_only)
|
||||
@depth = opts[:depth] || 0
|
||||
@buffer_initial_length ||= opts[:buffer_initial_length]
|
||||
|
||||
@script_safe = if opts.key?(:script_safe)
|
||||
!!opts[:script_safe]
|
||||
elsif opts.key?(:escape_slash)
|
||||
!!opts[:escape_slash]
|
||||
else
|
||||
false
|
||||
end
|
||||
|
||||
@strict = !!opts[:strict] if opts.key?(:strict)
|
||||
|
||||
if !opts.key?(:max_nesting) # defaults to 100
|
||||
@max_nesting = 100
|
||||
elsif opts[:max_nesting]
|
||||
@max_nesting = opts[:max_nesting]
|
||||
else
|
||||
@max_nesting = 0
|
||||
end
|
||||
self
|
||||
end
|
||||
alias merge configure
|
||||
|
||||
# Returns the configuration instance variables as a hash, that can be
|
||||
# passed to the configure method.
|
||||
def to_h
|
||||
result = {}
|
||||
instance_variables.each do |iv|
|
||||
iv = iv.to_s[1..-1]
|
||||
result[iv.to_sym] = self[iv]
|
||||
end
|
||||
result
|
||||
end
|
||||
|
||||
alias to_hash to_h
|
||||
|
||||
# Generates a valid JSON document from object +obj+ and
|
||||
# returns the result. If no valid JSON document can be
|
||||
# created this method raises a
|
||||
# GeneratorError exception.
|
||||
def generate(obj, anIO = nil)
|
||||
if @indent.empty? and @space.empty? and @space_before.empty? and @object_nl.empty? and @array_nl.empty? and
|
||||
!@ascii_only and !@script_safe and @max_nesting == 0 and (!@strict || Symbol === obj)
|
||||
result = generate_json(obj, ''.dup)
|
||||
else
|
||||
result = obj.to_json(self)
|
||||
end
|
||||
JSON::TruffleRuby::Generator.valid_utf8?(result) or raise GeneratorError.new(
|
||||
"source sequence #{result.inspect} is illegal/malformed utf-8",
|
||||
obj
|
||||
)
|
||||
if anIO
|
||||
anIO.write(result)
|
||||
anIO
|
||||
else
|
||||
result
|
||||
end
|
||||
end
|
||||
|
||||
def generate_new(obj, anIO = nil) # :nodoc:
|
||||
dup.generate(obj, anIO)
|
||||
end
|
||||
|
||||
# Handles @allow_nan, @buffer_initial_length, other ivars must be the default value (see above)
|
||||
private def generate_json(obj, buf)
|
||||
case obj
|
||||
when Hash
|
||||
buf << '{'
|
||||
first = true
|
||||
obj.each_pair do |k,v|
|
||||
buf << ',' unless first
|
||||
|
||||
key_str = k.to_s
|
||||
if key_str.class == String
|
||||
fast_serialize_string(key_str, buf)
|
||||
elsif key_str.is_a?(String)
|
||||
generate_json(key_str, buf)
|
||||
else
|
||||
raise TypeError, "#{k.class}#to_s returns an instance of #{key_str.class}, expected a String"
|
||||
end
|
||||
|
||||
buf << ':'
|
||||
generate_json(v, buf)
|
||||
first = false
|
||||
end
|
||||
buf << '}'
|
||||
when Array
|
||||
buf << '['
|
||||
first = true
|
||||
obj.each do |e|
|
||||
buf << ',' unless first
|
||||
generate_json(e, buf)
|
||||
first = false
|
||||
end
|
||||
buf << ']'
|
||||
when String
|
||||
if obj.class == String
|
||||
fast_serialize_string(obj, buf)
|
||||
else
|
||||
buf << obj.to_json(self)
|
||||
end
|
||||
when Integer
|
||||
buf << obj.to_s
|
||||
when Symbol
|
||||
if @strict
|
||||
fast_serialize_string(obj.name, buf)
|
||||
else
|
||||
buf << obj.to_json(self)
|
||||
end
|
||||
else
|
||||
# Note: Float is handled this way since Float#to_s is slow anyway
|
||||
buf << obj.to_json(self)
|
||||
end
|
||||
end
|
||||
|
||||
# Assumes !@ascii_only, !@script_safe
|
||||
private def fast_serialize_string(string, buf) # :nodoc:
|
||||
buf << '"'
|
||||
unless string.encoding == ::Encoding::UTF_8
|
||||
begin
|
||||
string = string.encode(::Encoding::UTF_8)
|
||||
rescue Encoding::UndefinedConversionError => error
|
||||
raise GeneratorError.new(error.message, string)
|
||||
end
|
||||
end
|
||||
raise GeneratorError.new("source sequence is illegal/malformed utf-8", string) unless string.valid_encoding?
|
||||
|
||||
if /["\\\x0-\x1f]/.match?(string)
|
||||
buf << string.gsub(/["\\\x0-\x1f]/, MAP)
|
||||
else
|
||||
buf << string
|
||||
end
|
||||
buf << '"'
|
||||
end
|
||||
|
||||
# Return the value returned by method +name+.
|
||||
def [](name)
|
||||
if respond_to?(name)
|
||||
__send__(name)
|
||||
else
|
||||
instance_variable_get("@#{name}") if
|
||||
instance_variables.include?("@#{name}".to_sym) # avoid warning
|
||||
end
|
||||
end
|
||||
|
||||
def []=(name, value)
|
||||
if respond_to?(name_writer = "#{name}=")
|
||||
__send__ name_writer, value
|
||||
else
|
||||
instance_variable_set "@#{name}", value
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module GeneratorMethods
|
||||
module Object
|
||||
# Converts this object to a string (calling #to_s), converts
|
||||
# it to a JSON string, and returns the result. This is a fallback, if no
|
||||
# special method #to_json was defined for some object.
|
||||
def to_json(state = nil, *)
|
||||
state = State.from_state(state) if state
|
||||
if state&.strict?
|
||||
value = self
|
||||
if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value)
|
||||
if state.as_json
|
||||
value = state.as_json.call(value)
|
||||
unless false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value
|
||||
raise GeneratorError.new("#{value.class} returned by #{state.as_json} not allowed in JSON", value)
|
||||
end
|
||||
value.to_json(state)
|
||||
else
|
||||
raise GeneratorError.new("#{value.class} not allowed in JSON", value)
|
||||
end
|
||||
end
|
||||
else
|
||||
to_s.to_json
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module Hash
|
||||
# Returns a JSON string containing a JSON object, that is unparsed from
|
||||
# this Hash instance.
|
||||
# _state_ is a JSON::State object, that can also be used to configure the
|
||||
# produced JSON string output further.
|
||||
# _depth_ is used to find out nesting depth, to indent accordingly.
|
||||
def to_json(state = nil, *)
|
||||
state = State.from_state(state)
|
||||
state.check_max_nesting
|
||||
json_transform(state)
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def json_shift(state)
|
||||
state.object_nl.empty? or return ''
|
||||
state.indent * state.depth
|
||||
end
|
||||
|
||||
def json_transform(state)
|
||||
depth = state.depth += 1
|
||||
|
||||
if empty?
|
||||
state.depth -= 1
|
||||
return '{}'
|
||||
end
|
||||
|
||||
delim = ",#{state.object_nl}"
|
||||
result = +"{#{state.object_nl}"
|
||||
first = true
|
||||
indent = !state.object_nl.empty?
|
||||
each { |key, value|
|
||||
result << delim unless first
|
||||
result << state.indent * depth if indent
|
||||
|
||||
key_str = key.to_s
|
||||
if key_str.is_a?(String)
|
||||
key_json = key_str.to_json(state)
|
||||
else
|
||||
raise TypeError, "#{key.class}#to_s returns an instance of #{key_str.class}, expected a String"
|
||||
end
|
||||
|
||||
result = +"#{result}#{key_json}#{state.space_before}:#{state.space}"
|
||||
if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value)
|
||||
if state.as_json
|
||||
value = state.as_json.call(value)
|
||||
unless false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value
|
||||
raise GeneratorError.new("#{value.class} returned by #{state.as_json} not allowed in JSON", value)
|
||||
end
|
||||
result << value.to_json(state)
|
||||
else
|
||||
raise GeneratorError.new("#{value.class} not allowed in JSON", value)
|
||||
end
|
||||
elsif value.respond_to?(:to_json)
|
||||
result << value.to_json(state)
|
||||
else
|
||||
result << %{"#{String(value)}"}
|
||||
end
|
||||
first = false
|
||||
}
|
||||
depth = state.depth -= 1
|
||||
unless first
|
||||
result << state.object_nl
|
||||
result << state.indent * depth if indent
|
||||
end
|
||||
result << '}'
|
||||
result
|
||||
end
|
||||
end
|
||||
|
||||
module Array
|
||||
# Returns a JSON string containing a JSON array, that is unparsed from
|
||||
# this Array instance.
|
||||
# _state_ is a JSON::State object, that can also be used to configure the
|
||||
# produced JSON string output further.
|
||||
def to_json(state = nil, *)
|
||||
state = State.from_state(state)
|
||||
state.check_max_nesting
|
||||
json_transform(state)
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def json_transform(state)
|
||||
depth = state.depth += 1
|
||||
|
||||
if empty?
|
||||
state.depth -= 1
|
||||
return '[]'
|
||||
end
|
||||
|
||||
result = '['.dup
|
||||
if state.array_nl.empty?
|
||||
delim = ","
|
||||
else
|
||||
result << state.array_nl
|
||||
delim = ",#{state.array_nl}"
|
||||
end
|
||||
|
||||
first = true
|
||||
indent = !state.array_nl.empty?
|
||||
each { |value|
|
||||
result << delim unless first
|
||||
result << state.indent * depth if indent
|
||||
if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value || Symbol == value)
|
||||
if state.as_json
|
||||
value = state.as_json.call(value)
|
||||
unless false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value || Symbol === value
|
||||
raise GeneratorError.new("#{value.class} returned by #{state.as_json} not allowed in JSON", value)
|
||||
end
|
||||
result << value.to_json(state)
|
||||
else
|
||||
raise GeneratorError.new("#{value.class} not allowed in JSON", value)
|
||||
end
|
||||
elsif value.respond_to?(:to_json)
|
||||
result << value.to_json(state)
|
||||
else
|
||||
result << %{"#{String(value)}"}
|
||||
end
|
||||
first = false
|
||||
}
|
||||
depth = state.depth -= 1
|
||||
result << state.array_nl
|
||||
result << state.indent * depth if indent
|
||||
result << ']'
|
||||
end
|
||||
end
|
||||
|
||||
module Integer
|
||||
# Returns a JSON string representation for this Integer number.
|
||||
def to_json(*) to_s end
|
||||
end
|
||||
|
||||
module Float
|
||||
# Returns a JSON string representation for this Float number.
|
||||
def to_json(state = nil, *args)
|
||||
state = State.from_state(state)
|
||||
if infinite? || nan?
|
||||
if state.allow_nan?
|
||||
to_s
|
||||
elsif state.strict? && state.as_json
|
||||
casted_value = state.as_json.call(self)
|
||||
|
||||
if casted_value.equal?(self)
|
||||
raise GeneratorError.new("#{self} not allowed in JSON", self)
|
||||
end
|
||||
|
||||
state.check_max_nesting
|
||||
state.depth += 1
|
||||
result = casted_value.to_json(state, *args)
|
||||
state.depth -= 1
|
||||
result
|
||||
else
|
||||
raise GeneratorError.new("#{self} not allowed in JSON", self)
|
||||
end
|
||||
else
|
||||
to_s
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module Symbol
|
||||
def to_json(state = nil, *args)
|
||||
state = State.from_state(state)
|
||||
if state.strict?
|
||||
name.to_json(state, *args)
|
||||
else
|
||||
super
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module String
|
||||
# This string should be encoded with UTF-8 A call to this method
|
||||
# returns a JSON string encoded with UTF16 big endian characters as
|
||||
# \u????.
|
||||
def to_json(state = nil, *args)
|
||||
state = State.from_state(state)
|
||||
if encoding == ::Encoding::UTF_8
|
||||
unless valid_encoding?
|
||||
raise GeneratorError.new("source sequence is illegal/malformed utf-8", self)
|
||||
end
|
||||
string = self
|
||||
else
|
||||
string = encode(::Encoding::UTF_8)
|
||||
end
|
||||
if state.ascii_only?
|
||||
%("#{JSON::TruffleRuby::Generator.utf8_to_json_ascii(string, state.script_safe)}")
|
||||
else
|
||||
%("#{JSON::TruffleRuby::Generator.utf8_to_json(string, state.script_safe)}")
|
||||
end
|
||||
rescue Encoding::UndefinedConversionError => error
|
||||
raise ::JSON::GeneratorError.new(error.message, self)
|
||||
end
|
||||
|
||||
# Module that holds the extending methods if, the String module is
|
||||
# included.
|
||||
module Extend
|
||||
# Raw Strings are JSON Objects (the raw bytes are stored in an
|
||||
# array for the key "raw"). The Ruby String can be created by this
|
||||
# module method.
|
||||
def json_create(o)
|
||||
o['raw'].pack('C*')
|
||||
end
|
||||
end
|
||||
|
||||
# Extends _modul_ with the String::Extend module.
|
||||
def self.included(modul)
|
||||
modul.extend Extend
|
||||
end
|
||||
|
||||
# This method creates a raw object hash, that can be nested into
|
||||
# other data structures and will be unparsed as a raw string. This
|
||||
# method should be used, if you want to convert raw strings to JSON
|
||||
# instead of UTF-8 strings, e. g. binary data.
|
||||
def to_json_raw_object
|
||||
{
|
||||
JSON.create_id => self.class.name,
|
||||
'raw' => self.unpack('C*'),
|
||||
}
|
||||
end
|
||||
|
||||
# This method creates a JSON text from the result of
|
||||
# a call to to_json_raw_object of this String.
|
||||
def to_json_raw(*args)
|
||||
to_json_raw_object.to_json(*args)
|
||||
end
|
||||
end
|
||||
|
||||
module TrueClass
|
||||
# Returns a JSON string for true: 'true'.
|
||||
def to_json(*) 'true' end
|
||||
end
|
||||
|
||||
module FalseClass
|
||||
# Returns a JSON string for false: 'false'.
|
||||
def to_json(*) 'false' end
|
||||
end
|
||||
|
||||
module NilClass
|
||||
# Returns a JSON string for nil: 'null'.
|
||||
def to_json(*) 'null' end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,5 @@
|
||||
# frozen_string_literal: true
|
||||
|
||||
module JSON
|
||||
VERSION = '2.10.2'
|
||||
end
|
||||
Reference in New Issue
Block a user