json 2.3.1-java → 2.4.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dab6c5a90b48e148a0987ce6cf13284c517b672bf9eedc6672b9b0cfb7123af5
-  data.tar.gz: 2668c1bbb2ece7579896373029a947671894b8882072cc5cc56908210a5973cb
+  metadata.gz: 4b0ed6ed8147c1e99dd585403ea77d2ddfe044b2039ebdeea1226fdbf39459fa
+  data.tar.gz: f3c2584779ff507b86dd9df78dcc2ae9fe4b1904952db719985327609896108e
 SHA512:
-  metadata.gz: '0715338d655adec7af365f721ac56a2737436f8771a002cb303f86b7b800717378e84e9401a09a5ab7de1a4116d3891ad15ad8aa598747296004d55adb2ff2bd'
-  data.tar.gz: c1b6446ef0b012974aed4595de272179109a28ce890e6459f39e991b2ed10b5e0997cb37c03a32bf84ba634b6347d80e8144afa7e2771b60e458f36beac8ee53
+  metadata.gz: bf55f870a11035a308017c8d8555335f410ba7780c419926e0a334ef3ed475027ea2eb12408cf1eceab347e77960127516667f8aa50c9549032e593da6de0a5e
+  data.tar.gz: a25e1338acfc66cec81e6e27f130f85c178b5962bc7a9b153c479001ec72cc23fb6ae5ac80299bbefad30cec89b90b73906e758253cdf91dca1041a135b1d5e1

data/LICENSE

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/lib/json.rb

@@ -107,6 +107,89 @@ require 'json/common'
 #   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,
@@ -169,6 +252,94 @@ require 'json/common'
 #   JSON.generate(Complex(0, 0)) # => '"0+0i"'
 #   JSON.generate(Dir.new('.')) # => '"#<Dir>"'
 #
+# ==== Generating Options
+#
+# ====== Input Options
+#
+# Option +allow_nan+ (boolean) specifies whether
+# +NaN+, +Infinity+, and <tt>-Infinity</tt> may be generated;
+# defaults to +false+.
+#
+# With the default, +false+:
+#   # Raises JSON::GeneratorError (920: NaN not allowed in JSON):
+#   JSON.generate(JSON::NaN)
+#   # Raises JSON::GeneratorError (917: Infinity not allowed in JSON):
+#   JSON.generate(JSON::Infinity)
+#   # Raises JSON::GeneratorError (917: -Infinity not allowed in JSON):
+#   JSON.generate(JSON::MinusInfinity)
+#
+# Allow:
+#   ruby = [Float::NaN, Float::Infinity, Float::MinusInfinity]
+#   JSON.generate(ruby, allow_nan: true) # => '[NaN,Infinity,-Infinity]'
+#
+# ---
+#
+# Option +max_nesting+ (\Integer) specifies the maximum nesting depth
+# in +obj+; defaults to +100+.
+#
+# With the default, +100+:
+#   obj = [[[[[[0]]]]]]
+#   JSON.generate(obj) # => '[[[[[[0]]]]]]'
+#
+# Too deep:
+#   # Raises JSON::NestingError (nesting of 2 is too deep):
+#   JSON.generate(obj, max_nesting: 2)
+#
+# ====== Output Options
+#
+# The default formatting options generate the most compact
+# \JSON data, all on one line and with no whitespace.
+#
+# You can use these formatting options to generate
+# \JSON data in a more open format, using whitespace.
+# See also JSON.pretty_generate.
+#
+# - Option +array_nl+ (\String) specifies a string (usually a newline)
+#   to be inserted after each \JSON array; defaults to the empty \String, <tt>''</tt>.
+# - Option +object_nl+ (\String) specifies a string (usually a newline)
+#   to be inserted after each \JSON object; defaults to the empty \String, <tt>''</tt>.
+# - Option +indent+ (\String) specifies the string (usually spaces) to be
+#   used for indentation; defaults to the empty \String, <tt>''</tt>;
+#   defaults to the empty \String, <tt>''</tt>;
+#   has no effect unless options +array_nl+ or +object_nl+ specify newlines.
+# - Option +space+ (\String) specifies a string (usually a space) to be
+#   inserted after the colon in each \JSON object's pair;
+#   defaults to the empty \String, <tt>''</tt>.
+# - Option +space_before+ (\String) specifies a string (usually a space) to be
+#   inserted before the colon in each \JSON object's pair;
+#   defaults to the empty \String, <tt>''</tt>.
+#
+# In this example, +obj+ is used first to generate the shortest
+# \JSON data (no whitespace), then again with all formatting options
+# specified:
+#
+#   obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}}
+#   json = JSON.generate(obj)
+#   puts 'Compact:', json
+#   opts = {
+#     array_nl: "\n",
+#     object_nl: "\n",
+#     indent: '  ',
+#     space_before: ' ',
+#     space: ' '
+#   }
+#   puts 'Open:', JSON.generate(obj, opts)
+#
+# Output:
+#   Compact:
+#   {"foo":["bar","baz"],"bat":{"bam":0,"bad":1}}
+#   Open:
+#   {
+#     "foo" : [
+#       "bar",
+#       "baz"
+#   ],
+#     "bat" : {
+#       "bam" : 0,
+#       "bad" : 1
+#     }
+#   }
+#
 # == \JSON Additions
 #
 # When you "round trip" a non-\String object from Ruby to \JSON and back,

data/lib/json/add/complex.rb

@@ -2,7 +2,6 @@
 unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
   require 'json'
 end
-defined?(::Complex) or require 'complex'
 
 class Complex
 

data/lib/json/add/rational.rb

@@ -2,7 +2,6 @@
 unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
   require 'json'
 end
-defined?(::Rational) or require 'rational'
 
 class Rational
   # Deserializes JSON string by converting numerator value <tt>n</tt>,

data/lib/json/common.rb

@@ -4,13 +4,15 @@ require 'json/generic_object'
 
 module JSON
   class << self
-    # If +object+ is a
-    # {String-convertible object}[doc/implicit_conversion_rdoc.html#label-String-Convertible+Objects]
-    # (implementing +to_str+), calls JSON.parse with +object+ and +opts+:
+    # :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+:
+    # Otherwise, calls JSON.generate with +object+ and +opts+ (see method #generate):
     #   ruby = [0, 1, nil]
     #   JSON[ruby] # => '[0,1,null]'
     def [](object, opts = {})
@@ -144,15 +146,12 @@ module JSON
   # :call-seq:
   #   JSON.parse(source, opts) -> object
   #
-  # Argument +source+ contains the \String to be parsed. It must be a
-  # {String-convertible object}[doc/implicit_conversion_rdoc.html#label-String-Convertible+Objects]
-  # (implementing +to_str+), and must contain valid \JSON data.
+  # Returns the Ruby objects created by parsing the given +source+.
   #
-  # Argument +opts+, if given, contains options for the parsing, and must be a
-  # {Hash-convertible object}[doc/implicit_conversion_rdoc.html#label-Hash-Convertible+Objects]
-  # (implementing +to_hash+).
+  # Argument +source+ contains the \String to be parsed.
   #
-  # Returns the Ruby objects created by parsing the given +source+.
+  # Argument +opts+, if given, contains a \Hash of options for the parsing.
+  # See {Parsing Options}[#module-JSON-label-Parsing+Options].
   #
   # ---
   #
@@ -171,91 +170,24 @@ module JSON
   # For examples of parsing for all \JSON data types, see
   # {Parsing \JSON}[#module-JSON-label-Parsing+JSON].
   #
-  # ====== 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]'
+  # Parses nested JSON objects:
+  #   source = <<-EOT
+  #   {
+  #   "name": "Dave",
+  #     "age" :40,
+  #     "hats": [
+  #       "Cattleman's",
+  #       "Panama",
+  #       "Tophat"
+  #     ]
+  #   }
+  #   EOT
   #   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}>
+  #   ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]}
   #
   # ---
   #
-  # Option +create_additions+ (boolean) specifies whether to use \JSON additions in parsing.
-  # See {\JSON Additions}[#module-JSON-label-JSON+Additions].
-  #
-  # ====== Exceptions
-  #
   # Raises an exception if +source+ is not valid JSON:
-  #
   #   # Raises JSON::ParserError (783: unexpected token at ''):
   #   JSON.parse('')
   #
@@ -283,30 +215,47 @@ module JSON
   end
 
   # :call-seq:
-  #   JSON.generate(obj, opts = nil) -> new_string
+  #   JSON.load_file(path, opts={}) -> object
   #
-  # Argument +obj+ is the Ruby object to be converted to \JSON.
+  # Calls:
+  #   parse(File.read(path), opts)
   #
-  # Argument +opts+, if given, contains options for the generation, and must be a
-  # {Hash-convertible object}[doc/implicit_conversion_rdoc.html#label-Hash-Convertible+Objects]
-  # (implementing +to_hash+).
+  # 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-convertible object}[doc/implicit_conversion_rdoc.html#label-Array-Convertible+Objects]
-  # (implementing +to_ary+), returns a \String containing a \JSON array:
+  # 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-convertible object}[doc/implicit_conversion_rdoc.html#label-Hash-Convertible+Objects],
-  # return a \String containing a \JSON object:
+  # 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"}'
@@ -314,98 +263,10 @@ module JSON
   # For examples of generating from other Ruby objects, see
   # {Generating \JSON from Other Objects}[#module-JSON-label-Generating+JSON+from+Other+Objects].
   #
-  # ====== Input Options
-  #
-  # Option +allow_nan+ (boolean) specifies whether
-  # +NaN+, +Infinity+, and <tt>-Infinity</tt> may be generated;
-  # defaults to +false+.
-  #
-  # With the default, +false+:
-  #   # Raises JSON::GeneratorError (920: NaN not allowed in JSON):
-  #   JSON.generate(JSON::NaN)
-  #   # Raises JSON::GeneratorError (917: Infinity not allowed in JSON):
-  #   JSON.generate(JSON::Infinity)
-  #   # Raises JSON::GeneratorError (917: -Infinity not allowed in JSON):
-  #   JSON.generate(JSON::MinusInfinity)
-  #
-  # Allow:
-  #   ruby = [Float::NaN, Float::Infinity, Float::MinusInfinity]
-  #   JSON.generate(ruby, allow_nan: true) # => '[NaN,Infinity,-Infinity]'
-  #
-  # ---
-  #
-  # Option +max_nesting+ (\Integer) specifies the maximum nesting depth
-  # in +obj+; defaults to +100+.
-  #
-  # With the default, +100+:
-  #   obj = [[[[[[0]]]]]]
-  #   JSON.generate(obj) # => '[[[[[[0]]]]]]'
-  #
-  # Too deep:
-  #   # Raises JSON::NestingError (nesting of 2 is too deep):
-  #   JSON.generate(obj, max_nesting: 2)
-  #
-  # ====== Output Options
-  #
-  # The default formatting options generate the most compact
-  # \JSON data, all on one line and with no whitespace.
-  #
-  # You can use these formatting options to generate
-  # \JSON data in a more open format, using whitespace.
-  # See also JSON.pretty_generate.
-  #
-  # - Option +array_nl+ (\String) specifies a string (usually a newline)
-  #   to be inserted after each \JSON array; defaults to the empty \String, <tt>''</tt>.
-  # - Option +object_nl+ (\String) specifies a string (usually a newline)
-  #   to be inserted after each \JSON object; defaults to the empty \String, <tt>''</tt>.
-  # - Option +indent+ (\String) specifies the string (usually spaces) to be
-  #   used for indentation; defaults to the empty \String, <tt>''</tt>;
-  #   defaults to the empty \String, <tt>''</tt>;
-  #   has no effect unless options +array_nl+ or +object_nl+ specify newlines.
-  # - Option +space+ (\String) specifies a string (usually a space) to be
-  #   inserted after the colon in each \JSON object's pair;
-  #   defaults to the empty \String, <tt>''</tt>.
-  # - Option +space_before+ (\String) specifies a string (usually a space) to be
-  #   inserted before the colon in each \JSON object's pair;
-  #   defaults to the empty \String, <tt>''</tt>.
-  #
-  # In this example, +obj+ is used first to generate the shortest
-  # \JSON data (no whitespace), then again with all formatting options
-  # specified:
-  #
-  #   obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}}
-  #   json = JSON.generate(obj)
-  #   puts 'Compact:', json
-  #   opts = {
-  #     array_nl: "\n",
-  #     object_nl: "\n",
-  #     indent+: '  ',
-  #     space_before: ' ',
-  #     space: ' '
-  #   }
-  #   puts 'Open:', JSON.generate(obj, opts)
-  #
-  # Output:
-  #   Compact:
-  #   {"foo":["bar","baz"],"bat":{"bam":0,"bad":1}}
-  #   Open:
-  #   {
-  #     "foo" : [
-  #       "bar",
-  #       "baz"
-  #   ],
-  #     "bat" : {
-  #       "bam" : 0,
-  #       "bad" : 1
-  #     }
-  #   }
-  #
   # ---
   #
   # Raises an exception if any formatting option is not a \String.
   #
-  # ====== Exceptions
-  #
   # 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):
@@ -437,6 +298,9 @@ module JSON
   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.
   #
@@ -541,20 +405,134 @@ module JSON
     :create_additions => true,
   }
 
-  # 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.
+  # :call-seq:
+  #   JSON.load(source, proc = nil, options = {}) -> object
   #
-  # 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.
+  # 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+,
+  #     <tt>source.to_str</tt> becomes the source.
+  #   - If +source+ responds to instance method +to_io+,
+  #     <tt>source.to_io.read</tt> becomes the source.
+  #   - If +source+ responds to instance method +read+,
+  #     <tt>source.read</tt> becomes the source.
+  #   - If both of the following are true, source becomes the \String <tt>'null'</tt>:
+  #     - Option +allow_blank+ specifies a truthy value.
+  #     - The source, as defined above, is +nil+ or the empty \String <tt>''</tt>.
+  #   - Otherwise, +source+ remains the source.
+  # - Argument +proc+, if given, must be a \Proc that accepts one argument.
+  #   It will be called recursively with each result (depth-first order).
+  #   See details below.
+  #   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
+  # <tt>parse(source, opts)</tt>;  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 <tt>parse(source, opts)</tt>.
+  # - Recursively calls <tt>proc(result)</tt>.
+  # - Returns the final result.
+  #
+  # Example:
+  #   require 'json'
+  #
+  #   # Some classes for the example.
+  #   class Base
+  #     def initialize(attributes)
+  #       @attributes = attributes
+  #     end
+  #   end
+  #   class User    < Base; end
+  #   class Account < Base; end
+  #   class Admin   < Base; end
+  #   # The JSON source.
+  #   json = <<-EOF
+  #   {
+  #     "users": [
+  #         {"type": "User", "username": "jane", "email": "jane@example.com"},
+  #         {"type": "User", "username": "john", "email": "john@example.com"}
+  #     ],
+  #     "accounts": [
+  #         {"account": {"type": "Account", "paid": true, "account_id": "1234"}},
+  #         {"account": {"type": "Account", "paid": false, "account_id": "1235"}}
+  #     ],
+  #     "admins": {"type": "Admin", "password": "0wn3d"}
+  #   }
+  #   EOF
+  #   # Deserializer method.
+  #   def deserialize_obj(obj, safe_types = %w(User Account Admin))
+  #     type = obj.is_a?(Hash) && obj["type"]
+  #     safe_types.include?(type) ? Object.const_get(type).new(obj) : obj
+  #   end
+  #   # Call to JSON.load
+  #   ruby = JSON.load(json, proc {|obj|
+  #     case obj
+  #     when Hash
+  #       obj.each {|k, v| obj[k] = deserialize_obj v }
+  #     when Array
+  #       obj.map! {|v| deserialize_obj v }
+  #     end
+  #   })
+  #   pp ruby
+  # Output:
+  #   {"users"=>
+  #      [#<User:0x00000000064c4c98
+  #        @attributes=
+  #          {"type"=>"User", "username"=>"jane", "email"=>"jane@example.com"}>,
+  #        #<User:0x00000000064c4bd0
+  #        @attributes=
+  #          {"type"=>"User", "username"=>"john", "email"=>"john@example.com"}>],
+  #    "accounts"=>
+  #      [{"account"=>
+  #          #<Account:0x00000000064c4928
+  #          @attributes={"type"=>"Account", "paid"=>true, "account_id"=>"1234"}>},
+  #       {"account"=>
+  #          #<Account:0x00000000064c4680
+  #          @attributes={"type"=>"Account", "paid"=>false, "account_id"=>"1235"}>}],
+  #    "admins"=>
+  #      #<Admin:0x00000000064c41f8
+  #      @attributes={"type"=>"Admin", "password"=>"0wn3d"}>}
   #
-  # This method is part of the implementation of the load/dump interface of
-  # Marshal and YAML.
   def load(source, proc = nil, options = {})
     opts = load_default_options.merge options
     if source.respond_to? :to_str
@@ -573,7 +551,7 @@ module JSON
   end
 
   # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_
-  def recurse_proc(result, &proc)
+  def recurse_proc(result, &proc) # :nodoc:
     case result
     when Array
       result.each { |x| recurse_proc x, &proc }
@@ -593,29 +571,42 @@ module JSON
     # Sets or returns the default options for the JSON.dump method.
     # Initially:
     #   opts = JSON.dump_default_options
-    #   opts # => {:max_nesting=>false, :allow_nan=>true}
+    #   opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false}
     attr_accessor :dump_default_options
   end
   self.dump_default_options = {
     :max_nesting => false,
     :allow_nan   => true,
+    :escape_slash => false,
   }
 
-  # Dumps _obj_ as a JSON string, i.e. calls generate on the object and returns
-  # the result.
+  # :call-seq:
+  #   JSON.dump(obj, io = nil, limit = nil)
   #
-  # If anIO (an IO-like object or an object that responds to the write method)
-  # was given, the resulting JSON is written to it.
+  # Dumps +obj+ as a \JSON string, i.e. calls generate on the object and returns the result.
   #
-  # 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.
+  # The default options can be changed via method JSON.dump_default_options.
   #
-  # The default options for the generator can be changed via the
-  # dump_default_options method.
+  # - 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+.
   #
-  # 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 dump(obj, anIO = nil, limit = nil)
     if anIO and limit.nil?
       anIO = anIO.to_io if anIO.respond_to?(:to_io)

data/lib/json/pure/generator.rb

@@ -37,20 +37,26 @@ module JSON
     '\\'  =>  '\\\\',
   } # :nodoc:
 
+  ESCAPE_SLASH_MAP = MAP.merge(
+    '/'  =>  '\\/',
+  )
+
   # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
   # UTF16 big endian characters as \u????, and return it.
-  def utf8_to_json(string) # :nodoc:
+  def utf8_to_json(string, escape_slash = false) # :nodoc:
     string = string.dup
     string.force_encoding(::Encoding::ASCII_8BIT)
-    string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
+    map = escape_slash ? ESCAPE_SLASH_MAP : MAP
+    string.gsub!(/[\/"\\\x0-\x1f]/) { map[$&] || $& }
     string.force_encoding(::Encoding::UTF_8)
     string
   end
 
-  def utf8_to_json_ascii(string) # :nodoc:
+  def utf8_to_json_ascii(string, escape_slash = false) # :nodoc:
     string = string.dup
     string.force_encoding(::Encoding::ASCII_8BIT)
-    string.gsub!(/["\\\x0-\x1f]/n) { MAP[$&] }
+    map = escape_slash ? ESCAPE_SLASH_MAP : MAP
+    string.gsub!(/[\/"\\\x0-\x1f]/n) { map[$&] || $& }
     string.gsub!(/(
       (?:
        [\xc2-\xdf][\x80-\xbf]    |
@@ -109,6 +115,7 @@ module JSON
         # * *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: ''),
+        # * *escape_slash*: true if forward slash (/) should be escaped (default: false)
         # * *check_circular*: is deprecated now, use the :max_nesting option instead,
         # * *max_nesting*: sets the maximum level of data structure nesting in
         #   the generated JSON, max_nesting = 0 if no maximum should be checked.
@@ -123,6 +130,7 @@ module JSON
           @array_nl              = ''
           @allow_nan             = false
           @ascii_only            = false
+          @escape_slash          = false
           @buffer_initial_length = 1024
           configure opts
         end
@@ -148,6 +156,10 @@ module JSON
         # the generated JSON, max_nesting = 0 if no maximum is checked.
         attr_accessor :max_nesting
 
+        # If this attribute is set to true, forward slashes will be escaped in
+        # all json strings.
+        attr_accessor :escape_slash
+
         # :stopdoc:
         attr_reader :buffer_initial_length
 
@@ -187,6 +199,11 @@ module JSON
           @ascii_only
         end
 
+        # Returns true, if forward slashes are escaped. Otherwise returns false.
+        def escape_slash?
+          @escape_slash
+        end
+
         # Configure this State instance with the Hash _opts_, and return
         # itself.
         def configure(opts)
@@ -209,6 +226,7 @@ module JSON
           @ascii_only            = opts[:ascii_only] if opts.key?(:ascii_only)
           @depth                 = opts[:depth] || 0
           @buffer_initial_length ||= opts[:buffer_initial_length]
+          @escape_slash          = !!opts[:escape_slash] if opts.key?(:escape_slash)
 
           if !opts.key?(:max_nesting) # defaults to 100
             @max_nesting = 100
@@ -314,8 +332,10 @@ module JSON
               first = false
             }
             depth = state.depth -= 1
-            result << state.object_nl
-            result << state.indent * depth if indent
+            unless first
+              result << state.object_nl
+              result << state.indent * depth if indent
+            end
             result << '}'
             result
           end
@@ -399,9 +419,9 @@ module JSON
               string = encode(::Encoding::UTF_8)
             end
             if state.ascii_only?
-              '"' << JSON.utf8_to_json_ascii(string) << '"'
+              '"' << JSON.utf8_to_json_ascii(string, state.escape_slash) << '"'
             else
-              '"' << JSON.utf8_to_json(string) << '"'
+              '"' << JSON.utf8_to_json(string, state.escape_slash) << '"'
             end
           end
 

data/lib/json/pure/parser.rb

@@ -61,6 +61,8 @@ module JSON
       # * *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.
+      # * *freeze*: If set to true, all parsed objects will be frozen. Parsed
+      #   string will be deduplicated if possible.
       # * *symbolize_names*: If set to true, returns symbols for the names
       #   (keys) in a JSON object. Otherwise strings are returned, which is
       #   also the default. It's not possible to use this option in
@@ -86,6 +88,7 @@ module JSON
         end
         @allow_nan = !!opts[:allow_nan]
         @symbolize_names = !!opts[:symbolize_names]
+        @freeze = !!opts[:freeze]
         if opts.key?(:create_additions)
           @create_additions = !!opts[:create_additions]
         else
@@ -120,6 +123,7 @@ module JSON
           obj = parse_value
           UNPARSED.equal?(obj) and raise ParserError,
             "source is not valid JSON!"
+          obj.freeze if @freeze
         end
         while !eos? && skip(IGNORE) do end
         eos? or raise ParserError, "source is not valid JSON!"
@@ -161,6 +165,7 @@ module JSON
         EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
       end
 
+      STR_UMINUS = ''.respond_to?(:-@)
       def parse_string
         if scan(STRING)
           return '' if self[1].empty?
@@ -180,6 +185,15 @@ module JSON
           if string.respond_to?(:force_encoding)
             string.force_encoding(::Encoding::UTF_8)
           end
+
+          if @freeze
+            if STR_UMINUS
+              string = -string
+            else
+              string.freeze
+            end
+          end
+
           if @create_additions and @match_string
             for (regexp, klass) in @match_string
               klass.json_creatable? or next
@@ -242,8 +256,10 @@ module JSON
           @max_nesting.nonzero? && @current_nesting > @max_nesting
         result = @array_class.new
         delim = false
-        until eos?
+        loop do
           case
+          when eos?
+            raise ParserError, "unexpected end of string while parsing array"
           when !UNPARSED.equal?(value = parse_value)
             delim = false
             result << value
@@ -274,8 +290,10 @@ module JSON
           @max_nesting.nonzero? && @current_nesting > @max_nesting
         result = @object_class.new
         delim = false
-        until eos?
+        loop do
           case
+          when eos?
+            raise ParserError, "unexpected end of string while parsing object"
           when !UNPARSED.equal?(string = parse_string)
             skip(IGNORE)
             unless scan(PAIR_DELIMITER)

data/tests/fixtures/fail29.json

@@ -0,0 +1 @@
+{

data/tests/fixtures/fail30.json

@@ -0,0 +1 @@
+[

data/tests/fixtures/fail31.json

@@ -0,0 +1 @@
+[1, 2, 3,

data/tests/fixtures/fail32.json

@@ -0,0 +1 @@
+{"foo": "bar"

data/tests/json_addition_test.rb

@@ -195,9 +195,5 @@ class JSONAdditionTest < Test::Unit::TestCase
   def test_set
     s = Set.new([:a, :b, :c, :a])
     assert_equal s, JSON.parse(JSON(s), :create_additions => true)
-    ss = SortedSet.new([:d, :b, :a, :c])
-    ss_again = JSON.parse(JSON(ss), :create_additions => true)
-    assert_kind_of ss.class, ss_again
-    assert_equal ss, ss_again
   end
 end

data/tests/json_common_interface_test.rb

@@ -123,4 +123,47 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
     assert_equal @json, JSON(@hash)
     assert_equal @hash, JSON(@json)
   end
+
+  def test_load_file
+    test_load_shared(:load_file)
+  end
+
+  def test_load_file!
+    test_load_shared(:load_file!)
+  end
+
+  def test_load_file_with_option
+    test_load_file_with_option_shared(:load_file)
+  end
+
+  def test_load_file_with_option!
+    test_load_file_with_option_shared(:load_file!)
+  end
+
+  private
+
+  def test_load_shared(method_name)
+    temp_file_containing(@json) do |filespec|
+      assert_equal JSON.public_send(method_name, filespec), @hash
+    end
+  end
+
+  def test_load_file_with_option_shared(method_name)
+    temp_file_containing(@json) do |filespec|
+      parsed_object = JSON.public_send(method_name, filespec, symbolize_names: true)
+      key_classes = parsed_object.keys.map(&:class)
+      assert_include(key_classes, Symbol)
+      assert_not_include(key_classes, String)
+    end
+  end
+
+  def temp_file_containing(text, file_prefix = '')
+    raise "This method must be called with a code block." unless block_given?
+
+    Tempfile.create(file_prefix) do |file|
+      file << text
+      file.close
+      yield file.path
+    end
+  end
 end

data/tests/json_fixtures_test.rb

@@ -10,6 +10,7 @@ class JSONFixturesTest < Test::Unit::TestCase
   end
 
   def test_passing
+    verbose_bak, $VERBOSE = $VERBOSE, nil
     for name, source in @passed
       begin
         assert JSON.parse(source),
@@ -19,6 +20,8 @@ class JSONFixturesTest < Test::Unit::TestCase
         raise e
       end
     end
+  ensure
+    $VERBOSE = verbose_bak
   end
 
   def test_failing

data/tests/json_generator_test.rb

@@ -49,7 +49,6 @@ EOT
   end
 
   def test_remove_const_segv
-    return if RUBY_ENGINE == 'jruby'
     stress = GC.stress
     const = JSON::SAFE_STATE_PROTOTYPE.dup
 
@@ -76,7 +75,7 @@ EOT
     silence do
       JSON.const_set :SAFE_STATE_PROTOTYPE, const
     end
-  end if JSON.const_defined?("Ext")
+  end if JSON.const_defined?("Ext") && RUBY_ENGINE != 'jruby'
 
   def test_generate
     json = generate(@hash)
@@ -93,6 +92,11 @@ EOT
   end
 
   def test_generate_pretty
+    json = pretty_generate({})
+    assert_equal(<<'EOT'.chomp, json)
+{
+}
+EOT
     json = pretty_generate(@hash)
     # hashes aren't (insertion) ordered on every ruby implementation
     # assert_equal(@json3, json)
@@ -174,6 +178,7 @@ EOT
       :ascii_only            => false,
       :buffer_initial_length => 1024,
       :depth                 => 0,
+      :escape_slash          => false,
       :indent                => "  ",
       :max_nesting           => 100,
       :object_nl             => "\n",
@@ -190,6 +195,7 @@ EOT
       :ascii_only            => false,
       :buffer_initial_length => 1024,
       :depth                 => 0,
+      :escape_slash          => false,
       :indent                => "",
       :max_nesting           => 100,
       :object_nl             => "",
@@ -206,6 +212,7 @@ EOT
       :ascii_only            => false,
       :buffer_initial_length => 1024,
       :depth                 => 0,
+      :escape_slash          => false,
       :indent                => "",
       :max_nesting           => 0,
       :object_nl             => "",
@@ -394,6 +401,10 @@ EOT
     json = '["/"]'
     assert_equal json, generate(data)
     #
+    data = [ '/' ]
+    json = '["\/"]'
+    assert_equal json, generate(data, :escape_slash => true)
+    #
     data = ['"']
     json = '["\""]'
     assert_equal json, generate(data)

data/tests/json_parser_test.rb

@@ -218,6 +218,17 @@ class JSONParserTest < Test::Unit::TestCase
     end
   end
 
+  def test_freeze
+    assert_predicate parse('{}', :freeze => true), :frozen?
+    assert_predicate parse('[]', :freeze => true), :frozen?
+    assert_predicate parse('"foo"', :freeze => true), :frozen?
+
+    if string_deduplication_available?
+      assert_same(-'foo', parse('"foo"', :freeze => true))
+      assert_same(-'foo', parse('{"foo": 1}', :freeze => true).keys.first)
+    end
+  end
+
   def test_parse_comments
     json = <<EOT
 {
@@ -293,6 +304,10 @@ EOT
     json = '["\\\'"]'
     data = ["'"]
     assert_equal data, parse(json)
+
+    json = '["\/"]'
+    data = [ '/' ]
+    assert_equal data, parse(json)
   end
 
   class SubArray < Array
@@ -464,6 +479,16 @@ EOT
 
   private
 
+  def string_deduplication_available?
+    r1 = rand.to_s
+    r2 = r1.dup
+    begin
+      (-r1).equal?(-r2)
+    rescue NoMethodError
+      false # No String#-@
+    end
+  end
+
   def assert_equal_float(expected, actual, delta = 1e-2)
     Array === expected and expected = expected.first
     Array === actual and actual = actual.first

data/tests/test_helper.rb

@@ -1,12 +1,12 @@
 case ENV['JSON']
 when 'pure'
-  $:.unshift 'lib'
+  $:.unshift File.join(__dir__, '../lib')
   require 'json/pure'
 when 'ext'
-  $:.unshift 'ext', 'lib'
+  $:.unshift File.join(__dir__, '../ext'), File.join(__dir__, '../lib')
   require 'json/ext'
 else
-  $:.unshift 'ext', 'lib'
+  $:.unshift File.join(__dir__, '../ext'), File.join(__dir__, '../lib')
   require 'json'
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: java
 authors:
 - Daniel Luz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-30 00:00:00.000000000 Z
+date: 2020-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -50,6 +50,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - lib/json.rb
 - lib/json/add/bigdecimal.rb
 - lib/json/add/complex.rb
@@ -67,6 +68,8 @@ files:
 - lib/json/add/time.rb
 - lib/json/common.rb
 - lib/json/ext.rb
+- lib/json/ext/generator.jar
+- lib/json/ext/parser.jar
 - lib/json/generic_object.rb
 - lib/json/pure.rb
 - lib/json/pure/generator.rb
@@ -88,7 +91,11 @@ files:
 - tests/fixtures/fail25.json
 - tests/fixtures/fail27.json
 - tests/fixtures/fail28.json
+- tests/fixtures/fail29.json
 - tests/fixtures/fail3.json
+- tests/fixtures/fail30.json
+- tests/fixtures/fail31.json
+- tests/fixtures/fail32.json
 - tests/fixtures/fail4.json
 - tests/fixtures/fail5.json
 - tests/fixtures/fail6.json
@@ -116,7 +123,13 @@ files:
 homepage: http://flori.github.com/json
 licenses:
 - Ruby
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/flori/json/issues
+  changelog_uri: https://github.com/flori/json/blob/master/CHANGES.md
+  documentation_uri: http://flori.github.io/json/doc/index.html
+  homepage_uri: http://flori.github.io/json/
+  source_code_uri: https://github.com/flori/json
+  wiki_uri: https://github.com/flori/json/wiki
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -125,7 +138,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -135,5 +148,6 @@ requirements: []
 rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
-summary: JSON implementation for JRuby
-test_files: []
+summary: JSON Implementation for Ruby
+test_files:
+- tests/test_helper.rb