stdlib/json/0/json.rbs in rbs-2.0.0 vs stdlib/json/0/json.rbs in rbs-2.1.0

- old
+ new

@@ -18,19 +18,48 @@ def read: () -> string end type json_options = Hash[Symbol, untyped] +# <!-- rdoc-file=ext/json/lib/json/common.rb --> +# The base exception for JSON errors. +# +class JSON::JSONError < StandardError +end + +# <!-- rdoc-file=ext/json/lib/json/common.rb --> +# This exception is raised if a generator or unparser error occurs. +# +class JSON::GeneratorError < JSON::JSONError +end + +class JSON::UnparserError < JSON::GeneratorError +end + +# <!-- rdoc-file=ext/json/lib/json/common.rb --> +# This exception is raised if a parser error occurs. +# +class JSON::ParserError < JSON::JSONError +end + +# <!-- rdoc-file=ext/json/lib/json/common.rb --> +# This exception is raised if the nesting of parsed data structures is too deep. +# +class JSON::NestingError < JSON::ParserError +end + class JSON::State end +# <!-- rdoc-file=ext/json/lib/json/ext.rb --> # This module holds all the modules/classes that implement JSON's functionality # as C extensions. # module JSON::Ext end +# <!-- rdoc-file=ext/json/generator/generator.c --> # This is the JSON generator implemented as a C extension. It can be configured # to be used by setting # # JSON.generator = JSON::Ext::Generator # @@ -40,10 +69,18 @@ end class JSON::Ext::Generator::State end +# <!-- rdoc-file=ext/json/parser/parser.c --> +# This is the JSON parser implemented as a C extension. It can be configured to +# be used by setting +# +# JSON.parser = JSON::Ext::Parser +# +# with the method parser= in JSON. +# class JSON::Ext::Parser end module JSON::Pure end @@ -59,260 +96,1046 @@ type json_generator = singleton(::JSON::Ext::Generator) | singleton(::JSON::Pure::Generator) type json_parser = singleton(::JSON::Ext::Parser) | singleton(::JSON::Pure::Parser) type json_state = singleton(JSON::Ext::Generator::State) | singleton(JSON::Pure::Generator::State) +# <!-- rdoc-file=ext/json/lib/json.rb --> # # JavaScript Object Notation (JSON) # -# JSON is a lightweight data-interchange format. It is easy for us humans to -# read and write. Plus, equally simple for machines to generate or parse. JSON -# is completely language agnostic, making it the ideal interchange format. +# JSON is a lightweight data-interchange format. # -# Built on two universally available structures: -# 1. A collection of name/value pairs. Often referred to as an _object_, hash table, record, struct, keyed list, or associative array. -# 2. An ordered list of values. More commonly called an _array_, vector, sequence or list. +# A JSON value is one of the following: +# * Double-quoted text: `"foo"`. +# * 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] # -# To read more about JSON visit: http://json.org +# * 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} # -# ## Parsing JSON # -# To parse a JSON string received by another application or generated within -# your existing application: +# 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' # -# my_hash = JSON.parse('{"hello": "goodbye"}') -# puts my_hash["hello"] => "goodbye" +# All examples here assume that this has been done. # -# Notice the extra quotes `''` around the hash notation. Ruby expects the -# argument to be a string and can't convert objects like a hash or array. +# ### Parsing JSON # -# Ruby converts your string into a hash +# You can parse a String containing JSON data using either of two methods: +# * `JSON.parse(source, opts)` +# * `JSON.parse!(source, opts)` # -# ## Generating JSON # -# Creating a JSON string for communication or serialization is just as simple. +# where +# * `source` is a Ruby object. +# * `opts` is a Hash object containing options that control both input allowed +# and output formatting. # -# require 'json' # -# my_hash = {:hello => "goodbye"} -# puts JSON.generate(my_hash) => "{\"hello\":\"goodbye\"}" +# 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. # -# Or an alternative way: +# #### Parsing JSON Arrays # -# require 'json' -# puts {:hello => "goodbye"}.to_json => "{\"hello\":\"goodbye\"}" +# 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 # -# `JSON.generate` only allows objects or arrays to be converted to JSON syntax. -# `to_json`, however, accepts many Ruby classes even though it acts only as a -# method for serialization: +# 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 +# `JSON.generate(source, opts)`, 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 +# `-Infinity` 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) +# +# ###### 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, `''`. +# * Option `object_nl` (String) specifies a string (usually a newline) to be +# inserted after each JSON object; defaults to the empty String, `''`. +# * Option `indent` (String) specifies the string (usually spaces) to be used +# for indentation; defaults to the empty String, `''`; defaults to the empty +# String, `''`; 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, `''`. +# * 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, `''`. +# +# +# 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: `require 'json/add/bigdecimal'` +# * Complex: `require 'json/add/complex'` +# * Date: `require 'json/add/date'` +# * DateTime: `require 'json/add/date_time'` +# * Exception: `require 'json/add/exception'` +# * OpenStruct: `require 'json/add/ostruct'` +# * Range: `require 'json/add/range'` +# * Rational: `require 'json/add/rational'` +# * Regexp: `require 'json/add/regexp'` +# * Set: `require 'json/add/set'` +# * Struct: `require 'json/add/struct'` +# * Symbol: `require 'json/add/symbol'` +# * Time: `require 'json/add/time'` +# +# +# 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 # -# 1.to_json => "1" +# 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 - # 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. + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - 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] # - # The *opts* argument is passed through to generate/parse respectively. See - # generate and parse for their documentation. + # Otherwise, calls JSON.generate with `object` and `opts` (see method + # #generate): + # ruby = [0, 1, nil] + # JSON[ruby] # => '[0,1,null]' # def self.[]: (untyped object, ?json_options opts) -> untyped - # This is create identifier, which is used to decide if the *json_create* hook - # of a class should be called. It defaults to 'json_class'. + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - create_id() + # --> + # Returns the current create identifier. See also JSON.create_id=. # def self.create_id: () -> _ToS + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - create_id=(new_value) + # --> + # 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=: (_ToS create_id) -> _ToS def self.deep_const_get: (_ToS path) -> untyped - # Dumps *obj* as a JSON string, i.e. calls generate on the object and returns + + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - JSON.dump(obj, io = nil, limit = nil) + # --> + # Dumps `obj` as a JSON string, i.e. calls generate on the object and returns # the result. # - # If anIO (an IO-like object or an object that responds to the write method) was - # given, the resulting JSON is written to it. + # The default options can be changed via method JSON.dump_default_options. # - # If the number of nested arrays or objects exceeds *limit*, an ArgumentError - # exception is raised. This argument is similar (but not exactly the same!) to - # the *limit* argument in Marshal.dump. + # * 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`. # - # The default options for the generator can be changed via the - # dump_default_options method. # - # This method is part of the implementation of the load/dump interface of - # Marshal and YAML. + # --- # + # 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 self?.dump: (_ToJson obj, ?Integer limit) -> String | (_ToJson obj, _JsonToWritableIO anIO) -> _JsonWrite | (_ToJson obj, _JsonWrite anIO, ?Integer limit) -> _JsonWrite - # The global default options for the JSON.dump method: - # :max_nesting: false - # :allow_nan: true - # :allow_blank: true + # <!-- rdoc-file=ext/json/lib/json/common.rb --> + # Sets or returns the default options for the JSON.dump method. Initially: + # opts = JSON.dump_default_options + # opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false} # def self.dump_default_options: () -> json_options + # <!-- rdoc-file=ext/json/lib/json/common.rb --> + # Sets or returns the default options for the JSON.dump method. Initially: + # opts = JSON.dump_default_options + # opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false} + # def self.dump_default_options=: (json_options) -> json_options - # Generate a JSON document from the Ruby data structure *obj* and return it. - # This method disables the checks for circles in Ruby objects. + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - JSON.fast_generate(obj, opts) -> new_string + # --> + # Arguments `obj` and `opts` here are the same as arguments `obj` and `opts` in + # JSON.generate. # - # **WARNING**: Be careful not to pass any Ruby data structures with circles as - # *obj* argument because this will cause JSON to go into an infinite loop. + # 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 self?.fast_generate: (_ToJson obj, ?json_options opts) -> String alias self.fast_unparse self.fast_generate + alias fast_unparse fast_generate - # Generate a JSON document from the Ruby data structure *obj* and return it. - # *state* is * a JSON::State object, - # * or a Hash like object (responding to to_hash), - # * an object convertible into a hash by a to_h method, + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - JSON.generate(obj, opts = nil) -> new_string + # --> + # Returns a String containing the generated JSON data. # - # that is used as or to configure a State object. + # See also JSON.fast_generate, JSON.pretty_generate. # - # It defaults to a state object, that creates the shortest possible JSON text in - # one line, checks for circular data structures and doesn't allow NaN, Infinity, - # and -Infinity. + # Argument `obj` is the Ruby object to be converted to JSON. # - # A *state* hash 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. - # * **max_nesting**: The maximum depth of nesting allowed in the data - # structures from which JSON is to be generated. Disable depth checking with - # :max_nesting => false, it defaults to 100. + # Argument `opts`, if given, contains a Hash of options for the generation. See + # [Generating Options](#module-JSON-label-Generating+Options). # + # --- # - # See also the fast_generate for the fastest creation method with the least - # amount of sanity checks, and the pretty_generate method for some defaults for - # pretty output. + # 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 self?.generate: (_ToJson obj, ?json_options opts) -> String + # <!-- rdoc-file=ext/json/lib/json/common.rb --> # Returns the JSON generator module that is used by JSON. This is either - # JSON::Ext::Generator or JSON::Pure::Generator. + # JSON::Ext::Generator or JSON::Pure::Generator: + # JSON.generator # => JSON::Ext::Generator # def self.generator: () -> json_generator def self.generator=: (json_generator generator) -> void - # Encodes string using Ruby's *String.encode* + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - iconv(to, from, string) + # --> + # Encodes string using String.encode. # def self.iconv: (encoding to, encoding from, String string) -> String - # Load a ruby data structure from a JSON *source* and return it. A source can - # either be a string-like object, an IO-like object, or an object responding to - # the read method. If *proc* was given, it will be called with any nested Ruby - # object as an argument recursively in depth first order. To modify the default - # options pass in the optional *options* argument as well. + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - 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. The default - # options for the parser can be changed via the load_default_options method. + # * Argument `source` must be, or be convertible to, a String: + # * If `source` responds to instance method `to_str`, `source.to_str` + # becomes the source. + # * If `source` responds to instance method `to_io`, `source.to_io.read` + # becomes the source. + # * If `source` responds to instance method `read`, `source.read` becomes + # the source. + # * If both of the following are true, source becomes the String `'null'`: + # * Option `allow_blank` specifies a truthy value. + # * The source, as defined above, is `nil` or the empty String `''`. # - # This method is part of the implementation of the load/dump interface of - # Marshal and YAML. + # * 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. 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 `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 + # `parse(source, opts)`; see #parse. + # + # Source for following examples: + # source = <<-EOT + # { + # "name": "Dave", + # "age" :40, + # "hats": [ + # "Cattleman's", + # "Panama", + # "Tophat" + # ] + # } + # EOT + # + # 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 `parse(source, opts)`. + # * Recursively calls `proc(result)`. + # * 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 self?.load: (string | _JsonReadableIO | _JsonRead source, ?Proc proc, ?json_options options) -> untyped - # The global default options for the JSON.load method: - # :max_nesting: false - # :allow_nan: true - # :allow_blank: true + # <!-- rdoc-file=ext/json/lib/json/common.rb --> + # 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} # def self.load_default_options: () -> json_options + # <!-- rdoc-file=ext/json/lib/json/common.rb --> + # 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} + # def self.load_default_options=: (json_options) -> json_options - # Parse the JSON document *source* into a Ruby data structure and return it. + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - JSON.parse(source, opts) -> object + # --> + # Returns the Ruby objects created by parsing the given `source`. # - # *opts* can have the following keys: - # * **max_nesting**: The maximum depth of nesting allowed in the parsed data - # structures. Disable depth checking with :max_nesting => false. It defaults - # to 100. - # * **allow_nan**: If set to true, allow NaN, Infinity and -Infinity in - # defiance of RFC 7159 to be parsed by the Parser. This option defaults to - # false. - # * **symbolize_names**: If set to true, returns symbols for the names (keys) - # in a JSON object. Otherwise strings are returned. Strings are the default. - # * **create_additions**: If set to false, the Parser doesn't create additions - # even if a matching class and create_id was found. This option defaults to - # false. - # * **object_class**: Defaults to Hash - # * **array_class**: Defaults to Array + # 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 = <<-EOT + # { + # "name": "Dave", + # "age" :40, + # "hats": [ + # "Cattleman's", + # "Panama", + # "Tophat" + # ] + # } + # EOT + # 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 self?.parse: (string source, ?json_options opts) -> untyped - # Parse the JSON document *source* into a Ruby data structure and return it. The - # bang version of the parse method defaults to the more dangerous values for the - # *opts* hash, so be sure only to parse trusted *source* documents. + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - JSON.parse!(source, opts) -> object + # --> + # Calls + # parse(source, opts) # - # *opts* can have the following keys: - # * **max_nesting**: The maximum depth of nesting allowed in the parsed data - # structures. Enable depth checking with :max_nesting => anInteger. The - # parse! methods defaults to not doing max depth checking: This can be - # dangerous if someone wants to fill up your stack. - # * **allow_nan**: If set to true, allow NaN, Infinity, and -Infinity in - # defiance of RFC 7159 to be parsed by the Parser. This option defaults to - # true. - # * **create_additions**: If set to false, the Parser doesn't create additions - # even if a matching class and create_id was found. This option defaults to - # false. + # 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 self?.parse!: (string source, ?json_options opts) -> untyped + # <!-- rdoc-file=ext/json/lib/json/common.rb --> # Returns the JSON parser class that is used by JSON. This is either - # JSON::Ext::Parser or JSON::Pure::Parser. + # JSON::Ext::Parser or JSON::Pure::Parser: + # JSON.parser # => JSON::Ext::Parser # def self.parser: () -> json_parser def self.parser=: (json_parser parser) -> void - # Generate a JSON document from the Ruby data structure *obj* and return it. The - # returned document is a prettier form of the document returned by #unparse. + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - JSON.pretty_generate(obj, opts = nil) -> new_string + # --> + # Arguments `obj` and `opts` here are the same as arguments `obj` and `opts` in + # JSON.generate. # - # The *opts* argument can be used to configure the generator. See the generate - # method for a more detailed explanation. + # 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 self?.pretty_generate: (_ToJson obj, ?json_options opts) -> untyped alias self.pretty_unparse self.pretty_generate + alias pretty_unparse pretty_generate # Recursively calls passed *Proc* if the parsed data structure is an *Array* or # *Hash* # def self?.recurse_proc: (untyped result) { (*untyped) -> void } -> void + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - restore(source, proc = nil, options = {}) + # --> + # alias self.restore self.load + + # <!-- + # rdoc-file=ext/json/lib/json/common.rb + # - restore(source, proc = nil, options = {}) + # --> + # alias restore load - # Returns the JSON generator state class that is used by JSON. This is either - # JSON::Ext::Generator::State or JSON::Pure::Generator::State. + # <!-- rdoc-file=ext/json/lib/json/common.rb --> + # Sets or Returns the JSON generator state class that is used by JSON. This is + # either JSON::Ext::Generator::State or JSON::Pure::Generator::State: + # JSON.state # => JSON::Ext::Generator::State # def self.state: () -> json_state + # <!-- rdoc-file=ext/json/lib/json/common.rb --> + # Sets or Returns the JSON generator state class that is used by JSON. This is + # either JSON::Ext::Generator::State or JSON::Pure::Generator::State: + # JSON.state # => JSON::Ext::Generator::State + # def self.state=: (json_state) -> json_state alias self.unparse self.generate + alias unparse generate end JSON::FAST_STATE_PROTOTYPE: json_state @@ -326,10 +1149,11 @@ JSON::PRETTY_STATE_PROTOTYPE: json_state JSON::SAFE_STATE_PROTOTYPE: json_state +# <!-- rdoc-file=ext/json/lib/json/version.rb --> # JSON version # JSON::VERSION: String JSON::VERSION_ARRAY: Array[Integer] @@ -338,291 +1162,469 @@ JSON::VERSION_MAJOR: Integer JSON::VERSION_MINOR: Integer +%a{annotate:rdoc:skip} class 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: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class NilClass # Returns a JSON string for nil: 'null'. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class TrueClass # Returns a JSON string for true: 'true'. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class FalseClass # Returns a JSON string for false: 'false'. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class 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: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Integer # Returns a JSON string representation for this Integer number. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Float # Returns a JSON string representation for this Float number. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Hash[unchecked out K, unchecked out V] # Returns a JSON string containing a JSON object, that is generated from # this Hash instance. # _state_ is a JSON::State object, that can also be used to configure the # produced JSON string output further. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Array[unchecked out Elem] # Returns a JSON string containing a JSON array, that is generated 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: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class BigDecimal + # <!-- + # rdoc-file=ext/json/lib/json/add/bigdecimal.rb + # - json_create(object) + # --> # Import a JSON Marshalled object. # # method used for JSON marshalling support. # def self.json_create: (Hash[String, String] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/bigdecimal.rb + # - as_json(*) + # --> # Marshal the object to JSON. # # method used for JSON marshalling support. # def as_json: (*untyped) -> Hash[String, String] + # <!-- + # rdoc-file=ext/json/lib/json/add/bigdecimal.rb + # - to_json(*args) + # --> # return the JSON value # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Complex + # <!-- + # rdoc-file=ext/json/lib/json/add/complex.rb + # - json_create(object) + # --> # Deserializes JSON string by converting Real value `r`, imaginary value `i`, to # a Complex object. # def self.json_create: (Hash[String, String | Numeric] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/complex.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Numeric] + # <!-- + # rdoc-file=ext/json/lib/json/add/complex.rb + # - to_json(*args) + # --> # Stores class name (Complex) along with real value `r` and imaginary value `i` # as JSON string # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Date + # <!-- + # rdoc-file=ext/json/lib/json/add/date.rb + # - json_create(object) + # --> # Deserializes JSON string by converting Julian year `y`, month `m`, day `d` and # Day of Calendar Reform `sg` to Date. # def self.json_create: (Hash[String, String | Integer | Float] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/date.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Integer | Float] + # <!-- + # rdoc-file=ext/json/lib/json/add/date.rb + # - to_json(*args) + # --> # Stores class name (Date) with Julian year `y`, month `m`, day `d` and Day of # Calendar Reform `sg` as JSON string # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class DateTime + # <!-- + # rdoc-file=ext/json/lib/json/add/date_time.rb + # - json_create(object) + # --> # Deserializes JSON string by converting year `y`, month `m`, day `d`, hour `H`, # minute `M`, second `S`, offset `of` and Day of Calendar Reform `sg` to # DateTime. # def self.json_create: (Hash[String, String | Integer | Float] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/date_time.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Integer | Float] + # <!-- + # rdoc-file=ext/json/lib/json/add/date_time.rb + # - to_json(*args) + # --> # Stores class name (DateTime) with Julian year `y`, month `m`, day `d`, hour # `H`, minute `M`, second `S`, offset `of` and Day of Calendar Reform `sg` as # JSON string # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Exception + # <!-- + # rdoc-file=ext/json/lib/json/add/exception.rb + # - json_create(object) + # --> # Deserializes JSON string by constructing new Exception object with message `m` # and backtrace `b` serialized with `to_json` # def self.json_create: (Hash[String, String | Array[String] | nil] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/exception.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Array[String] | nil] + # <!-- + # rdoc-file=ext/json/lib/json/add/exception.rb + # - to_json(*args) + # --> # Stores class name (Exception) with message `m` and backtrace array `b` as JSON # string # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class OpenStruct + # <!-- + # rdoc-file=ext/json/lib/json/add/ostruct.rb + # - json_create(object) + # --> # Deserializes JSON string by constructing new Struct object with values `t` # serialized by `to_json`. # def self.json_create: (Hash[String, String | Hash[Symbol, untyped]] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/ostruct.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Hash[Symbol, untyped]] + # <!-- + # rdoc-file=ext/json/lib/json/add/ostruct.rb + # - to_json(*args) + # --> # Stores class name (OpenStruct) with this struct's values `t` as a JSON string. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Range[out Elem] + # <!-- + # rdoc-file=ext/json/lib/json/add/range.rb + # - json_create(object) + # --> # Deserializes JSON string by constructing new Range object with arguments `a` # serialized by `to_json`. # - def self.json_create: [A] (Hash[String, String | [A, A, bool]] object) -> Range[A] + def self.json_create: [A] (Hash[String, String | [ A, A, bool ]] object) -> Range[A] + # <!-- + # rdoc-file=ext/json/lib/json/add/range.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # - def as_json: (*untyped) -> Hash[String, String | [Elem, Elem, bool]] + def as_json: (*untyped) -> Hash[String, String | [ Elem, Elem, bool ]] + # <!-- + # rdoc-file=ext/json/lib/json/add/range.rb + # - to_json(*args) + # --> # Stores class name (Range) with JSON array of arguments `a` which include # `first` (integer), `last` (integer), and `exclude_end?` (boolean) as JSON # string. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Rational + # <!-- + # rdoc-file=ext/json/lib/json/add/rational.rb + # - json_create(object) + # --> # Deserializes JSON string by converting numerator value `n`, denominator value # `d`, to a Rational object. # def self.json_create: (Hash[String, String | Integer] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/rational.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Integer] + # <!-- + # rdoc-file=ext/json/lib/json/add/rational.rb + # - to_json(*args) + # --> # Stores class name (Rational) along with numerator value `n` and denominator # value `d` as JSON string # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Regexp + # <!-- + # rdoc-file=ext/json/lib/json/add/regexp.rb + # - json_create(object) + # --> # Deserializes JSON string by constructing new Regexp object with source `s` # (Regexp or String) and options `o` serialized by `to_json` # def self.json_create: (Hash[String, String | Integer] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/regexp.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Integer] + # <!-- + # rdoc-file=ext/json/lib/json/add/regexp.rb + # - to_json(*args) + # --> # Stores class name (Regexp) with options `o` and source `s` (Regexp or String) # as JSON string # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Set[A] + # <!-- + # rdoc-file=ext/json/lib/json/add/set.rb + # - json_create(object) + # --> # Import a JSON Marshalled object. # # method used for JSON marshalling support. # def self.json_create: [A] (Hash[String, String | Array[A]] object) -> Set[A] + # <!-- + # rdoc-file=ext/json/lib/json/add/set.rb + # - as_json(*) + # --> # Marshal the object to JSON. # # method used for JSON marshalling support. # def as_json: (*untyped) -> Hash[String, String | Array[A]] + # <!-- + # rdoc-file=ext/json/lib/json/add/set.rb + # - to_json(*args) + # --> # return the JSON value # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Struct[Elem] + # <!-- + # rdoc-file=ext/json/lib/json/add/struct.rb + # - json_create(object) + # --> # Deserializes JSON string by constructing new Struct object with values `v` # serialized by `to_json`. # def self.json_create: [Elem] (Hash[String, String | Array[Elem]] object) -> Struct[Elem] + # <!-- + # rdoc-file=ext/json/lib/json/add/struct.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Array[Elem]] + # <!-- + # rdoc-file=ext/json/lib/json/add/struct.rb + # - to_json(*args) + # --> # Stores class name (Struct) with Struct values `v` as a JSON string. Only named # structs are supported. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Symbol + # <!-- + # rdoc-file=ext/json/lib/json/add/symbol.rb + # - json_create(o) + # --> # Deserializes JSON string by converting the `string` value stored in the object # to a Symbol # def self.json_create: (Hash[String, String] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/symbol.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String] + # <!-- + # rdoc-file=ext/json/lib/json/add/symbol.rb + # - to_json(*a) + # --> # Stores class name (Symbol) with String representation of Symbol as a JSON # string. # def to_json: (?JSON::State state) -> String end +%a{annotate:rdoc:skip} class Time + # <!-- + # rdoc-file=ext/json/lib/json/add/time.rb + # - json_create(object) + # --> # Deserializes JSON string by converting time since epoch to Time # def self.json_create: (Hash[String, String | Integer] object) -> instance + # <!-- + # rdoc-file=ext/json/lib/json/add/time.rb + # - as_json(*) + # --> # Returns a hash, that will be turned into a JSON object and represent this # object. # def as_json: (*untyped) -> Hash[String, String | Integer] + # <!-- + # rdoc-file=ext/json/lib/json/add/time.rb + # - to_json(*args) + # --> # Stores class name (Time) with number of seconds since epoch and number of # microseconds for Time as JSON string # def to_json: (?JSON::State state) -> String end