Module: JSON

Defined in:

lib/json.rb,
lib/json/ext.rb,
lib/json/pure.rb,
lib/json/common.rb,
lib/json/version.rb,
lib/json/pure/parser.rb,
lib/json/pure/generator.rb,
ext/json/ext/parser/parser.c,
ext/json/ext/generator/generator.c

Defined Under Namespace

Modules: Ext, Pure Classes: CircularDatastructure, GeneratorError, JSONError, MissingUnicodeSupport, NestingError, ParserError

Constant Summary

JSON_LOADED =

true

NaN =

0.0/0

Infinity =

1.0/0

MinusInfinity =

-Infinity

UnparserError =

For backwards compatibility

GeneratorError

VERSION =

JSON version

'1.6.6'

VERSION_ARRAY =

:nodoc:

VERSION.split(/\./).map { |x| x.to_i }

VERSION_MAJOR =

VERSION_ARRAY[0]

VERSION_MINOR =

VERSION_ARRAY[1]

VERSION_BUILD =

:nodoc: :nodoc: :nodoc:

VERSION_ARRAY[2]

MAP =

{
  "\x0" => '\u0000',
  "\x1" => '\u0001',
  "\x2" => '\u0002',
  "\x3" => '\u0003',
  "\x4" => '\u0004',
  "\x5" => '\u0005',
  "\x6" => '\u0006',
  "\x7" => '\u0007',
  "\b"  =>  '\b',
  "\t"  =>  '\t',
  "\n"  =>  '\n',
  "\xb" => '\u000b',
  "\f"  =>  '\f',
  "\r"  =>  '\r',
  "\xe" => '\u000e',
  "\xf" => '\u000f',
  "\x10" => '\u0010',
  "\x11" => '\u0011',
  "\x12" => '\u0012',
  "\x13" => '\u0013',
  "\x14" => '\u0014',
  "\x15" => '\u0015',
  "\x16" => '\u0016',
  "\x17" => '\u0017',
  "\x18" => '\u0018',
  "\x19" => '\u0019',
  "\x1a" => '\u001a',
  "\x1b" => '\u001b',
  "\x1c" => '\u001c',
  "\x1d" => '\u001d',
  "\x1e" => '\u001e',
  "\x1f" => '\u001f',
  '"'   =>  '\"',
  '\\'  =>  '\\\\',
}

Class Attribute Summary (collapse)

• + (Object) create_id

  This is create identifier, which is used to decide if the json_create hook of a class should be called.

• + (Object) dump_default_options

  The global default options for the JSON.dump method:.

• + (Object) generator

  Returns the JSON generator module that is used by JSON.

• + (Object) load_default_options

  The global default options for the JSON.load method:.

• + (Object) parser

  Returns the JSON parser class that is used by JSON.

• + (Object) state

  Returns the JSON generator state class that is used by JSON.

Class Method Summary (collapse)

• + (Object) [](object, opts = {})

  If object is string-like, parse the string and return the parsed result as a Ruby data structure.

• + (Boolean) const_defined_in?(modul, constant)
• + (Object) deep_const_get(path)

  Return the constant located at path.

• + (Object) iconv(to, from, string)

  Encodes string using iconv library.

• + (Object) swap!(string)

  Swap consecutive bytes of string in place.

Instance Method Summary (collapse)

• - (Object) dump(obj, anIO = nil, limit = nil)

  Dumps obj as a JSON string, i.e.

• - (Object) fast_generate(obj, opts = nil) (also: #fast_unparse)

  Generate a JSON document from the Ruby data structure obj and return it.

• - (Object) generate(obj, opts = nil) (also: #unparse)

  Generate a JSON document from the Ruby data structure obj and return it.

• - (Object) load(source, proc = nil) (also: #restore)

  Load a ruby data structure from a JSON source and return it.

• - (Object) parse(source, opts = {})

  Parse the JSON document source into a Ruby data structure and return it.

• - (Object) parse!(source, opts = {})

  Parse the JSON document source into a Ruby data structure and return it.

• - (Object) pretty_generate(obj, opts = nil) (also: #pretty_unparse)

  Generate a JSON document from the Ruby data structure obj and return it.

• - (Object) recurse_proc(result, &proc)

  Recursively calls passed Proc if the parsed data structure is an Array or Hash.

• - (Object) utf8_to_json(string)

  :nodoc:.

• - (Object) utf8_to_json_ascii(string)

  :nodoc:.

94
95
96

# File 'lib/json/common.rb', line 94

def create_id
  @create_id
end

:max_nesting: false
:allow_nan:   true
:quirks_mode: true

347
348
349

# File 'lib/json/common.rb', line 347

def dump_default_options
  @dump_default_options
end

86
87
88

# File 'lib/json/common.rb', line 86

def generator
  @generator
end

:max_nesting: false
:allow_nan:   true
:quirks_mode: true

292
293
294

# File 'lib/json/common.rb', line 292

def load_default_options
  @load_default_options
end

21
22
23

# File 'lib/json/common.rb', line 21

def parser
  @parser
end

90
91
92

# File 'lib/json/common.rb', line 90

def state
  @state
end

11
12
13
14
15
16
17

# File 'lib/json/common.rb', line 11

def [](object, opts = {})
  if object.respond_to? :to_str
    JSON.parse(object.to_str, opts)
  else
    JSON.generate(object, opts)
  end
end

415
416
417

# File 'lib/json/common.rb', line 415

def self.const_defined_in?(modul, constant)
  modul.const_defined?(constant, false)
end

34
35
36
37
38
39
40
41
42
43
44
45
46
47

# File 'lib/json/common.rb', line 34

def deep_const_get(path) # :nodoc:
  path.to_s.split(/::/).inject(Object) do |p, c|
    case
    when c.empty?                     then p
    when JSON.const_defined_in?(p, c) 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

403
404
405

# File 'lib/json/common.rb', line 403

def self.iconv(to, from, string)
  Iconv.conv(to, from, string)
end

392
393
394
395
396
397
398

# File 'lib/json/common.rb', line 392

def self.swap!(string) # :nodoc:
  0.upto(string.size / 2) do |i|
    break unless string[2 * i + 1]
    string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
  end
  string
end

370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389

# File 'lib/json/common.rb', line 370

def dump(obj, anIO = nil, limit = nil)
  if anIO and limit.nil?
    anIO = anIO.to_io if anIO.respond_to?(:to_io)
    unless anIO.respond_to?(:write)
      limit = anIO
      anIO = nil
    end
  end
  opts = JSON.dump_default_options
  limit and opts.update(:max_nesting => limit)
  result = generate(obj, opts)
  if anIO
    anIO.write result
    anIO
  else
    result
  end
rescue JSON::NestingError
  raise ArgumentError, "exceed depth limit"
end

231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248

# File 'lib/json/common.rb', line 231

def fast_generate(obj, opts = nil)
  if State === opts
    state, opts = opts, nil
  else
    state = FAST_STATE_PROTOTYPE.dup
  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

200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

# File 'lib/json/common.rb', line 200

def generate(obj, opts = nil)
  if State === opts
    state, opts = opts, nil
  else
    state = SAFE_STATE_PROTOTYPE.dup
  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 = state.configure(opts)
  end
  state.generate(obj)
end

308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323

# File 'lib/json/common.rb', line 308

def load(source, proc = nil)
  opts = load_default_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[:quirks_mode] && (source.nil? || source.empty?)
    source = 'null'
  end
  result = parse(source, opts)
  recurse_proc(result, &proc) if proc
  result
end

147
148
149

# File 'lib/json/common.rb', line 147

def parse(source, opts = {})
  Parser.new(source, opts).parse
end

166
167
168
169
170
171
172

# File 'lib/json/common.rb', line 166

def parse!(source, opts = {})
  opts = {
    :max_nesting  => false,
    :allow_nan    => true
  }.update(opts)
  Parser.new(source, opts).parse
end

262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279

# File 'lib/json/common.rb', line 262

def pretty_generate(obj, opts = nil)
  if State === opts
    state, opts = opts, nil
  else
    state = PRETTY_STATE_PROTOTYPE.dup
  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

326
327
328
329
330
331
332
333
334
335
336
337

# File 'lib/json/common.rb', line 326

def recurse_proc(result, &proc)
  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

42
43
44
45
46
47
48
49

# File 'lib/json/pure/generator.rb', line 42

def utf8_to_json(string) # :nodoc:
  string = string.dup
  string << '' # XXX workaround: avoid buffer sharing
  string.force_encoding(::Encoding::ASCII_8BIT)
  string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
  string.force_encoding(::Encoding::UTF_8)
  string
end

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

# File 'lib/json/pure/generator.rb', line 51

def utf8_to_json_ascii(string) # :nodoc:
  string = string.dup
  string << '' # XXX workaround: avoid buffer sharing
  string.force_encoding(::Encoding::ASCII_8BIT)
  string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
  string.gsub!(/(
                  (?:
                    [\xc2-\xdf][\x80-\xbf]    |
                    [\xe0-\xef][\x80-\xbf]{2} |
                    [\xf0-\xf4][\x80-\xbf]{3}
                  )+ |
                  [\x80-\xc1\xf5-\xff]       # invalid
                )/nx) { |c|
                  c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
                  s = JSON.iconv('utf-16be', 'utf-8', c).unpack('H*')[0]
                  s.gsub!(/.{4}/n, '\\\\u\&')
                }
  string.force_encoding(::Encoding::UTF_8)
  string
rescue => e
  raise GeneratorError, "Caught #{e.class}: #{e}"
end