Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! =yN yN lib/json.rbnu [ #frozen_string_literal: false
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: "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]
#
# - \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:
# - JSON.parse(source, opts)
# - JSON.parse!(source, opts)
#
# 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 # => #
#
# ---
#
# 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 # => #
#
# ---
#
# 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('.')) # => '"#"'
#
# ==== 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)
#
# ====== Escaping Options
#
# Options +script_safe+ (boolean) specifies wether '\u2028', '\u2029'
# and '/' 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, ''.
# - 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 = <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') # #
# json = JSON.generate(ruby0) # {"json_class":"OpenStruct","t":{"name":"Matz","language":"Ruby"}}
# ruby1 = JSON.parse(json, create_additions: true) # #
# 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]) # #
# json = JSON.generate(ruby0) # {"json_class":"Set","a":[0,1,2]}
# ruby1 = JSON.parse(json, create_additions: true) # #
# ruby1.class # Set
#
# \Struct:
# require 'json/add/struct'
# Customer = Struct.new(:name, :address) # Customer
# ruby0 = Customer.new("Dave", "123 Main") # #
# json = JSON.generate(ruby0) # {"json_class":"Customer","v":["Dave","123 Main"]}
# ruby1 = JSON.parse(json, create_additions: true) # #
# 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 = <" (String)
# With custom addition: {"json_class":"Foo","a":[0,1]} (String)
# Parsed JSON:
# Without custom addition: "#" (String)
# With custom addition: # (Foo)
#
module JSON
require 'json/version'
begin
require 'json/ext'
rescue LoadError
require 'json/pure'
end
end
PK ! 3n:. . lib/json/version.rbnu [ # frozen_string_literal: false
module JSON
# JSON version
VERSION = '2.7.2'
VERSION_ARRAY = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
VERSION_MAJOR = VERSION_ARRAY[0] # :nodoc:
VERSION_MINOR = VERSION_ARRAY[1] # :nodoc:
VERSION_BUILD = VERSION_ARRAY[2] # :nodoc:
end
PK ! 1z lib/json/ext.rbnu [ require 'json/common'
module JSON
# This module holds all the modules/classes that implement JSON's
# functionality as C extensions.
module Ext
require 'json/ext/parser'
require 'json/ext/generator'
$DEBUG and warn "Using Ext extension for JSON."
JSON.parser = Parser
JSON.generator = Generator
end
JSON_LOADED = true unless defined?(::JSON::JSON_LOADED)
end
PK ! * * lib/json/generic_object.rbnu [ #frozen_string_literal: false
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
PK ! ES S lib/json/common.rbnu [ #frozen_string_literal: false
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.respond_to? :to_str
JSON.parse(object.to_str, opts)
else
JSON.generate(object, opts)
end
end
# Returns the JSON parser class that is used by JSON. This is either
# JSON::Ext::Parser or JSON::Pure::Parser:
# JSON.parser # => JSON::Ext::Parser
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:
path.to_s.split(/::/).inject(Object) do |p, c|
case
when c.empty? then p
when p.const_defined?(c, true) then p.const_get(c)
else
begin
p.const_missing(c)
rescue NameError => e
raise ArgumentError, "can't get const #{path}: #{e}"
end
end
end
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 = deep_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. This is
# either JSON::Ext::Generator or JSON::Pure::Generator:
# JSON.generator # => JSON::Ext::Generator
attr_reader :generator
# 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
attr_accessor :state
end
DEFAULT_CREATE_ID = 'json_class'.freeze
private_constant :DEFAULT_CREATE_ID
CREATE_ID_TLS_KEY = "JSON.create_id".freeze
private_constant :CREATE_ID_TLS_KEY
# 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[CREATE_ID_TLS_KEY] = new_value.dup.freeze
end
# Returns the current create identifier.
# See also JSON.create_id=.
def self.create_id
Thread.current[CREATE_ID_TLS_KEY] || DEFAULT_CREATE_ID
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; 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
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 = <<-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 parse(source, opts = {})
Parser.new(source, **(opts||{})).parse
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 = {})
opts = {
:max_nesting => false,
:allow_nan => true
}.merge(opts)
Parser.new(source, **(opts||{})).parse
end
# :call-seq:
# JSON.load_file(path, opts={}) -> object
#
# Calls:
# parse(File.read(path), opts)
#
# See method #parse.
def load_file(filespec, opts = {})
parse(File.read(filespec), opts)
end
# :call-seq:
# JSON.load_file!(path, opts = {})
#
# Calls:
# JSON.parse!(File.read(path, opts))
#
# See method #parse!
def load_file!(filespec, opts = {})
parse!(File.read(filespec), 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
state = opts
else
state = State.new(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 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.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 = {
:max_nesting => false,
:allow_nan => true,
:allow_blank => true,
:create_additions => true,
}
# :call-seq:
# JSON.load(source, proc = nil, options = {}) -> object
#
# Returns the Ruby objects created by parsing the given +source+.
#
# - 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 ''.
# - 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", "username"=>"jane", "email"=>"jane@example.com"}>,
# #"User", "username"=>"john", "email"=>"john@example.com"}>],
# "accounts"=>
# [{"account"=>
# #"Account", "paid"=>true, "account_id"=>"1234"}>},
# {"account"=>
# #"Account", "paid"=>false, "account_id"=>"1235"}>}],
# "admins"=>
# #"Admin", "password"=>"0wn3d"}>}
#
def load(source, proc = nil, options = {})
opts = load_default_options.merge options
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
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, :script_safe=>false}
attr_accessor :dump_default_options
end
self.dump_default_options = {
:max_nesting => false,
:allow_nan => true,
:script_safe => false,
}
# :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 # => #
# puts File.read(path)
# Output:
# {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}
def dump(obj, anIO = nil, limit = nil, kwargs = nil)
io_limit_opt = [anIO, limit, kwargs].compact
kwargs = io_limit_opt.pop if io_limit_opt.last.is_a?(Hash)
anIO, limit = io_limit_opt
if anIO.respond_to?(:to_io)
anIO = anIO.to_io
elsif limit.nil? && !anIO.respond_to?(:write)
anIO, limit = nil, anIO
end
opts = JSON.dump_default_options
opts = opts.merge(:max_nesting => limit) if limit
opts = merge_dump_options(opts, **kwargs) if kwargs
result = generate(obj, opts)
if anIO
anIO.write result
anIO
else
result
end
rescue JSON::NestingError
raise ArgumentError, "exceed depth limit"
end
# Encodes string using String.encode.
def self.iconv(to, from, string)
string.encode(to, from)
end
def merge_dump_options(opts, strict: NOT_SET)
opts = opts.merge(strict: strict) if NOT_SET != strict
opts
end
class << self
private :merge_dump_options
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.respond_to? :to_str
JSON.parse(object.to_str, args.first)
else
JSON.generate(object, args.first)
end
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
PK ! W lib/json/add/rational.rbnu [ #frozen_string_literal: false
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 Rational#as_json and +Rational.json_create+ may be used
# to serialize and deserialize a \Rational object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Rational#as_json 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
PK ! l lib/json/add/exception.rbnu [ #frozen_string_literal: false
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 Exception#as_json and +Exception.json_create+ may be used
# to serialize and deserialize a \Exception object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Exception#as_json 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) # => #
#
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
PK ! n˧X X lib/json/add/set.rbnu [ 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 Set#as_json and +Set.json_create+ may be used
# to serialize and deserialize a \Set object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Set#as_json 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) # => #
#
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
PK ! Q lib/json/add/symbol.rbnu [
#frozen_string_literal: false
unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
require 'json'
end
class Symbol
# Methods Symbol#as_json and +Symbol.json_create+ may be used
# to serialize and deserialize a \Symbol object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Symbol#as_json 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(*a)
as_json.to_json(*a)
end
# See #as_json.
def self.json_create(o)
o['s'].to_sym
end
end
PK ! AW2 2 lib/json/add/complex.rbnu [ #frozen_string_literal: false
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 Complex#as_json and +Complex.json_create+ may be used
# to serialize and deserialize a \Complex object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Complex#as_json 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
PK ! 2
lib/json/add/date.rbnu [ #frozen_string_literal: false
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 Date#as_json and +Date.json_create+ may be used
# to serialize and deserialize a \Date object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Date#as_json 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)
# # => #
#
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
PK ! ]դ lib/json/add/time.rbnu [ #frozen_string_literal: false
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
if method_defined?(:tv_nsec)
at(object['s'], Rational(object['n'], 1000))
else
at(object['s'], object['n'] / 1000)
end
end
# Methods Time#as_json and +Time.json_create+ may be used
# to serialize and deserialize a \Time object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Time#as_json 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(*)
nanoseconds = [ tv_usec * 1000 ]
respond_to?(:tv_nsec) and nanoseconds << tv_nsec
nanoseconds = nanoseconds.max
{
JSON.create_id => self.class.name,
's' => tv_sec,
'n' => nanoseconds,
}
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
PK ! GY Y lib/json/add/regexp.rbnu [ #frozen_string_literal: false
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 Regexp#as_json and +Regexp.json_create+ may be used
# to serialize and deserialize a \Regexp object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Regexp#as_json 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
PK ! = lib/json/add/bigdecimal.rbnu [ #frozen_string_literal: false
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 BigDecimal#as_json and +BigDecimal.json_create+ may be used
# to serialize and deserialize a \BigDecimal object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method BigDecimal#as_json 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,
}
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)
PK ! fC C lib/json/add/date_time.rbnu [ #frozen_string_literal: false
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 DateTime#as_json and +DateTime.json_create+ may be used
# to serialize and deserialize a \DateTime object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method DateTime#as_json 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
PK ! {# lib/json/add/struct.rbnu [ #frozen_string_literal: false
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 Struct#as_json and +Struct.json_create+ may be used
# to serialize and deserialize a \Struct object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Struct#as_json 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)
# # => #
#
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
PK ! *4< lib/json/add/range.rbnu [ #frozen_string_literal: false
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 Range#as_json and +Range.json_create+ may be used
# to serialize and deserialize a \Range object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method Range#as_json 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
PK ! &a\ \ lib/json/add/core.rbnu [ #frozen_string_literal: false
# 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'
PK ! .`톡 lib/json/add/ostruct.rbnu [ #frozen_string_literal: false
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 OpenStruct#as_json and +OpenStruct.json_create+ may be used
# to serialize and deserialize a \OpenStruct object;
# see Marshal[rdoc-ref:Marshal].
#
# \Method OpenStruct#as_json 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)
# # => #
#
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)
PK ! =yN yN lib/json.rbnu [ PK ! 3n:. . N lib/json/version.rbnu [ PK ! 1z %P lib/json/ext.rbnu [ PK ! * * Q lib/json/generic_object.rbnu [ PK ! ES S _X lib/json/common.rbnu [ PK ! W lib/json/add/rational.rbnu [ PK ! l lib/json/add/exception.rbnu [ PK ! n˧X X lib/json/add/set.rbnu [ PK ! Q < lib/json/add/symbol.rbnu [ PK ! AW2 2 lib/json/add/complex.rbnu [ PK ! 2
lib/json/add/date.rbnu [ PK ! ]դ X lib/json/add/time.rbnu [ PK ! GY Y z lib/json/add/regexp.rbnu [ PK ! = lib/json/add/bigdecimal.rbnu [ PK ! fC C lib/json/add/date_time.rbnu [ PK ! {# w lib/json/add/struct.rbnu [ PK ! *4< K lib/json/add/range.rbnu [ PK ! &a\ \ K lib/json/add/core.rbnu [ PK ! .`톡 lib/json/add/ostruct.rbnu [ PK Q