scout 5.6.7 → 5.6.8.pre

data/vendor/json_pure/lib/json/pure/parser.rb

@@ -41,7 +41,7 @@ module JSON
           [^*/]|        # normal chars
           /[^*]|        # slashes that do not start a nested comment
           \*[^/]|       # asterisks that do not end this comment
-          /(?=\*/)      # single slash before this comment's end 
+          /(?=\*/)      # single slash before this comment's end
          )*
            \*/               # the End of this comment
            |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
@@ -56,56 +56,28 @@ module JSON
       # keys:
       # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
       #   structures. Disable depth checking with :max_nesting => false|nil|0,
-      #   it defaults to 19.
+      #   it defaults to 100.
       # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
       #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
       #   to false.
       # * *symbolize_names*: If set to true, returns symbols for the names
       #   (keys) in a JSON object. Otherwise strings are returned, which is also
       #   the default.
-      # * *create_additions*: If set to false, the Parser doesn't create
-      #   additions even if a matchin class and create_id was found. This option
-      #   defaults to true.
+      # * *create_additions*: If set to true, the Parser creates
+      #   additions when if a matching class and create_id was found. This
+      #   option defaults to false.
       # * *object_class*: Defaults to Hash
       # * *array_class*: Defaults to Array
+      # * *quirks_mode*: Enables quirks_mode for parser, that is for example
+      #   parsing single JSON values instead of documents is possible.
       def initialize(source, opts = {})
-          if defined?(::Encoding)
-            if source.encoding == Encoding::ASCII_8BIT
-              b = source[0, 4].bytes.to_a
-              source = case
-                       when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
-                         source.dup.force_encoding(Encoding::UTF_32BE).encode!(Encoding::UTF_8)
-                       when b.size >= 4 && b[0] == 0 && b[2] == 0
-                         source.dup.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8)
-                       when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
-                         source.dup.force_encoding(Encoding::UTF_32LE).encode!(Encoding::UTF_8)
-                       when b.size >= 4 && b[1] == 0 && b[3] == 0
-                         source.dup.force_encoding(Encoding::UTF_16LE).encode!(Encoding::UTF_8)
-                       else
-                         source.dup
-                       end
-            else
-              source = source.encode(Encoding::UTF_8)
-            end
-            source.force_encoding(Encoding::ASCII_8BIT)
-          else
-            b = source
-            source = case
-                     when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
-                       JSON.iconv('utf-8', 'utf-32be', b)
-                     when b.size >= 4 && b[0] == 0 && b[2] == 0
-                       JSON.iconv('utf-8', 'utf-16be', b)
-                     when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
-                       JSON.iconv('utf-8', 'utf-32le', b)
-                     when b.size >= 4 && b[1] == 0 && b[3] == 0
-                       JSON.iconv('utf-8', 'utf-16le', b)
-                     else
-                       b
-                     end
-          end
+        opts ||= {}
+        unless @quirks_mode = opts[:quirks_mode]
+          source = convert_encoding source
+        end
         super source
-        if !opts.key?(:max_nesting) # defaults to 19
-          @max_nesting = 19
+        if !opts.key?(:max_nesting) # defaults to 100
+          @max_nesting = 100
         elsif opts[:max_nesting]
           @max_nesting = opts[:max_nesting]
         else
@@ -113,42 +85,111 @@ module JSON
         end
         @allow_nan = !!opts[:allow_nan]
         @symbolize_names = !!opts[:symbolize_names]
-        ca = true
-        ca = opts[:create_additions] if opts.key?(:create_additions)
-        @create_id = ca ? JSON.create_id : nil
+        if opts.key?(:create_additions)
+          @create_additions = !!opts[:create_additions]
+        else
+          @create_additions = false
+        end
+        @create_id = @create_additions ? JSON.create_id : nil
         @object_class = opts[:object_class] || Hash
-        @array_class = opts[:array_class] || Array
+        @array_class  = opts[:array_class] || Array
+        @match_string = opts[:match_string]
       end
 
       alias source string
 
+      def quirks_mode?
+        !!@quirks_mode
+      end
+
+      def reset
+        super
+        @current_nesting = 0
+      end
+
       # Parses the current JSON string _source_ and returns the complete data
       # structure as a result.
       def parse
         reset
         obj = nil
-        until eos?
-          case
-          when scan(OBJECT_OPEN)
-            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
-            @current_nesting = 1
-            obj = parse_object
-          when scan(ARRAY_OPEN)
-            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
-            @current_nesting = 1
-            obj = parse_array
-          when skip(IGNORE)
-            ;
+        if @quirks_mode
+          while !eos? && skip(IGNORE)
+          end
+          if eos?
+            raise ParserError, "source did not contain any JSON!"
           else
-            raise ParserError, "source '#{peek(20)}' not in JSON!"
+            obj = parse_value
+            obj == UNPARSED and raise ParserError, "source did not contain any JSON!"
           end
+        else
+          until eos?
+            case
+            when scan(OBJECT_OPEN)
+              obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+              @current_nesting = 1
+              obj = parse_object
+            when scan(ARRAY_OPEN)
+              obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+              @current_nesting = 1
+              obj = parse_array
+            when skip(IGNORE)
+              ;
+            else
+              raise ParserError, "source '#{peek(20)}' not in JSON!"
+            end
+          end
+          obj or raise ParserError, "source did not contain any JSON!"
         end
-        obj or raise ParserError, "source did not contain any JSON!"
         obj
       end
 
       private
 
+      def convert_encoding(source)
+        if source.respond_to?(:to_str)
+          source = source.to_str
+        else
+          raise TypeError, "#{source.inspect} is not like a string"
+        end
+        if defined?(::Encoding)
+          if source.encoding == ::Encoding::ASCII_8BIT
+            b = source[0, 4].bytes.to_a
+            source =
+              case
+              when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
+                source.dup.force_encoding(::Encoding::UTF_32BE).encode!(::Encoding::UTF_8)
+              when b.size >= 4 && b[0] == 0 && b[2] == 0
+                source.dup.force_encoding(::Encoding::UTF_16BE).encode!(::Encoding::UTF_8)
+              when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
+                source.dup.force_encoding(::Encoding::UTF_32LE).encode!(::Encoding::UTF_8)
+              when b.size >= 4 && b[1] == 0 && b[3] == 0
+                source.dup.force_encoding(::Encoding::UTF_16LE).encode!(::Encoding::UTF_8)
+              else
+                source.dup
+              end
+          else
+            source = source.encode(::Encoding::UTF_8)
+          end
+          source.force_encoding(::Encoding::ASCII_8BIT)
+        else
+          b = source
+          source =
+            case
+            when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
+              JSON.iconv('utf-8', 'utf-32be', b)
+            when b.size >= 4 && b[0] == 0 && b[2] == 0
+              JSON.iconv('utf-8', 'utf-16be', b)
+            when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
+              JSON.iconv('utf-8', 'utf-32le', b)
+            when b.size >= 4 && b[1] == 0 && b[3] == 0
+              JSON.iconv('utf-8', 'utf-16le', b)
+            else
+              b
+            end
+        end
+        source
+      end
+
       # Unescape characters in strings.
       UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
       UNESCAPE_MAP.update({
@@ -160,9 +201,14 @@ module JSON
         ?n  => "\n",
         ?r  => "\r",
         ?t  => "\t",
-        ?u  => nil, 
+        ?u  => nil,
       })
 
+      EMPTY_8BIT_STRING = ''
+      if ::String.method_defined?(:encode)
+        EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
+      end
+
       def parse_string
         if scan(STRING)
           return '' if self[1].empty?
@@ -170,24 +216,30 @@ module JSON
             if u = UNESCAPE_MAP[$&[1]]
               u
             else # \uXXXX
-              bytes = ''
+              bytes = EMPTY_8BIT_STRING.dup
               i = 0
               while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
                 bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
                 i += 1
               end
-              JSON::UTF16toUTF8.iconv(bytes)
+              JSON.iconv('utf-8', 'utf-16be', bytes)
             end
           end
           if string.respond_to?(:force_encoding)
-            string.force_encoding(Encoding::UTF_8)
+            string.force_encoding(::Encoding::UTF_8)
+          end
+          if @create_additions and @match_string
+            for (regexp, klass) in @match_string
+              klass.json_creatable? or next
+              string =~ regexp and return klass.json_create(string)
+            end
           end
           string
         else
           UNPARSED
         end
-      rescue Iconv::Failure => e
-        raise GeneratorError, "Caught #{e.class}: #{e}"
+      rescue => e
+        raise ParserError, "Caught #{e.class} at '#{peek(20)}': #{e}"
       end
 
       def parse_value
@@ -288,7 +340,7 @@ module JSON
             if delim
               raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
             end
-            if @create_id and klassname = result[@create_id]
+            if @create_additions and klassname = result[@create_id]
               klass = JSON.deep_const_get klassname
               break unless klass and klass.json_creatable?
               result = klass.json_create(result)

data/vendor/json_pure/lib/json/version.rb

@@ -1,6 +1,6 @@
 module JSON
   # JSON version
-  VERSION         = '1.4.2'
+  VERSION         = '1.8.0'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/vendor/json_pure/tests/fixtures/fail18.json

@@ -1 +1 @@
-[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

data/vendor/json_pure/tests/setup_variant.rb

@@ -0,0 +1,11 @@
+case ENV['JSON']
+when 'pure'
+  $:.unshift 'lib'
+  require 'json/pure'
+when 'ext'
+  $:.unshift 'ext', 'lib'
+  require 'json/ext'
+else
+  $:.unshift 'ext', 'lib'
+  require 'json'
+end

data/vendor/json_pure/tests/test_json.rb

@@ -1,13 +1,11 @@
 #!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
 require 'test/unit'
-case ENV['JSON']
-when 'pure' then require 'json/pure'
-when 'ext'  then require 'json/ext'
-else             require 'json'
-end
+require File.join(File.dirname(__FILE__), 'setup_variant')
 require 'stringio'
+require 'tempfile'
+require 'ostruct'
 
 unless Array.method_defined?(:permutation)
   begin
@@ -23,7 +21,7 @@ unless Array.method_defined?(:permutation)
   end
 end
 
-class TC_JSON < Test::Unit::TestCase
+class TestJSON < Test::Unit::TestCase
   include JSON
 
   def setup
@@ -108,6 +106,46 @@ class TC_JSON < Test::Unit::TestCase
     assert_equal({ "a" => 0.23 }, parse('  {  "a"  :  0.23  }  '))
   end
 
+  def test_parse_json_primitive_values
+    assert_raise(JSON::ParserError) { JSON.parse('') }
+    assert_raise(JSON::ParserError) { JSON.parse('', :quirks_mode => true) }
+    assert_raise(TypeError) { JSON::Parser.new(nil).parse }
+    assert_raise(TypeError) { JSON::Parser.new(nil, :quirks_mode => true).parse }
+    assert_raise(TypeError) { JSON.parse(nil) }
+    assert_raise(TypeError) { JSON.parse(nil, :quirks_mode => true) }
+    assert_raise(JSON::ParserError) { JSON.parse('  /* foo */ ') }
+    assert_raise(JSON::ParserError) { JSON.parse('  /* foo */ ', :quirks_mode => true) }
+    parser = JSON::Parser.new('null')
+    assert_equal false, parser.quirks_mode?
+    assert_raise(JSON::ParserError) { parser.parse }
+    assert_raise(JSON::ParserError) { JSON.parse('null') }
+    assert_equal nil, JSON.parse('null', :quirks_mode => true)
+    parser = JSON::Parser.new('null', :quirks_mode => true)
+    assert_equal true, parser.quirks_mode?
+    assert_equal nil, parser.parse
+    assert_raise(JSON::ParserError) { JSON.parse('false') }
+    assert_equal false, JSON.parse('false', :quirks_mode => true)
+    assert_raise(JSON::ParserError) { JSON.parse('true') }
+    assert_equal true, JSON.parse('true', :quirks_mode => true)
+    assert_raise(JSON::ParserError) { JSON.parse('23') }
+    assert_equal 23, JSON.parse('23', :quirks_mode => true)
+    assert_raise(JSON::ParserError) { JSON.parse('1') }
+    assert_equal 1, JSON.parse('1', :quirks_mode => true)
+    assert_raise(JSON::ParserError) { JSON.parse('3.141') }
+    assert_in_delta 3.141, JSON.parse('3.141', :quirks_mode => true), 1E-3
+    assert_raise(JSON::ParserError) { JSON.parse('18446744073709551616') }
+    assert_equal 2 ** 64, JSON.parse('18446744073709551616', :quirks_mode => true)
+    assert_raise(JSON::ParserError) { JSON.parse('"foo"') }
+    assert_equal 'foo', JSON.parse('"foo"', :quirks_mode => true)
+    assert_raise(JSON::ParserError) { JSON.parse('NaN', :allow_nan => true) }
+    assert JSON.parse('NaN', :quirks_mode => true, :allow_nan => true).nan?
+    assert_raise(JSON::ParserError) { JSON.parse('Infinity', :allow_nan => true) }
+    assert JSON.parse('Infinity', :quirks_mode => true, :allow_nan => true).infinite?
+    assert_raise(JSON::ParserError) { JSON.parse('-Infinity', :allow_nan => true) }
+    assert JSON.parse('-Infinity', :quirks_mode => true, :allow_nan => true).infinite?
+    assert_raise(JSON::ParserError) { JSON.parse('[ 1, ]', :quirks_mode => true) }
+  end
+
   if Array.method_defined?(:permutation)
     def test_parse_more_complex_arrays
       a = [ nil, false, true, "foßbar", [ "n€st€d", true ], { "nested" => true, "n€ßt€ð2" => {} }]
@@ -154,16 +192,68 @@ class TC_JSON < Test::Unit::TestCase
     assert_equal(@ary,
       parse('[[1],["foo"],[3.14],[47.11e+2],[2718.0E-3],[null],[[1,-2,3]]'\
       ',[false],[true]]'))
-    assert_equal(@ary, parse(%Q{   [   [1] , ["foo"]  ,  [3.14] \t ,  [47.11e+2] 
+    assert_equal(@ary, parse(%Q{   [   [1] , ["foo"]  ,  [3.14] \t ,  [47.11e+2]\s
       , [2718.0E-3 ],\r[ null] , [[1, -2, 3 ]], [false ],[ true]\n ]  }))
   end
 
-  class SubArray < Array; end
+  class SubArray < Array
+    def <<(v)
+      @shifted = true
+      super
+    end
+
+    def shifted?
+      @shifted
+    end
+  end
+
+  class SubArray2 < Array
+    def to_json(*a)
+      {
+        JSON.create_id => self.class.name,
+        'ary'          => to_a,
+      }.to_json(*a)
+    end
+
+    def self.json_create(o)
+      o.delete JSON.create_id
+      o['ary']
+    end
+  end
+
+  class SubArrayWrapper
+    def initialize
+      @data = []
+    end
+
+    attr_reader :data
 
-  def test_parse_array_custom_class
-    res = parse('[]', :array_class => SubArray)
-    assert_equal([], res)
+    def [](index)
+      @data[index]
+    end
+
+    def <<(value)
+      @data << value
+      @shifted = true
+    end
+
+    def shifted?
+      @shifted
+    end
+  end
+
+  def test_parse_array_custom_array_derived_class
+    res = parse('[1,2]', :array_class => SubArray)
+    assert_equal([1,2], res)
     assert_equal(SubArray, res.class)
+    assert res.shifted?
+  end
+
+  def test_parse_array_custom_non_array_derived_class
+    res = parse('[1,2]', :array_class => SubArrayWrapper)
+    assert_equal([1,2], res.data)
+    assert_equal(SubArrayWrapper, res.class)
+    assert res.shifted?
   end
 
   def test_parse_object
@@ -173,12 +263,93 @@ class TC_JSON < Test::Unit::TestCase
     assert_equal({'foo'=>'bar'}, parse('    { "foo"  :   "bar"   }   '))
   end
 
-  class SubHash < Hash; end
+  class SubHash < Hash
+    def []=(k, v)
+      @item_set = true
+      super
+    end
+
+    def item_set?
+      @item_set
+    end
+  end
+
+  class SubHash2 < Hash
+    def to_json(*a)
+      {
+        JSON.create_id => self.class.name,
+      }.merge(self).to_json(*a)
+    end
+
+    def self.json_create(o)
+      o.delete JSON.create_id
+      self[o]
+    end
+  end
+
+  class SubOpenStruct < OpenStruct
+    def [](k)
+      __send__(k)
+    end
+
+    def []=(k, v)
+      @item_set = true
+      __send__("#{k}=", v)
+    end
 
-  def test_parse_object_custom_class
-    res = parse('{}', :object_class => SubHash)
-    assert_equal({}, res)
+    def item_set?
+      @item_set
+    end
+  end
+
+  def test_parse_object_custom_hash_derived_class
+    res = parse('{"foo":"bar"}', :object_class => SubHash)
+    assert_equal({"foo" => "bar"}, res)
     assert_equal(SubHash, res.class)
+    assert res.item_set?
+  end
+
+  def test_parse_object_custom_non_hash_derived_class
+    res = parse('{"foo":"bar"}', :object_class => SubOpenStruct)
+    assert_equal "bar", res.foo
+    assert_equal(SubOpenStruct, res.class)
+    assert res.item_set?
+  end
+
+  def test_parse_generic_object
+    res = parse('{"foo":"bar", "baz":{}}', :object_class => JSON::GenericObject)
+    assert_equal(JSON::GenericObject, res.class)
+    assert_equal "bar", res.foo
+    assert_equal "bar", res["foo"]
+    assert_equal "bar", res[:foo]
+    assert_equal "bar", res.to_hash[:foo]
+    assert_equal(JSON::GenericObject, res.baz.class)
+  end
+
+  def test_generate_core_subclasses_with_new_to_json
+    obj = SubHash2["foo" => SubHash2["bar" => true]]
+    obj_json = JSON(obj)
+    obj_again = JSON.parse(obj_json, :create_additions => true)
+    assert_kind_of SubHash2, obj_again
+    assert_kind_of SubHash2, obj_again['foo']
+    assert obj_again['foo']['bar']
+    assert_equal obj, obj_again
+    assert_equal ["foo"], JSON(JSON(SubArray2["foo"]), :create_additions => true)
+  end
+
+  def test_generate_core_subclasses_with_default_to_json
+    assert_equal '{"foo":"bar"}', JSON(SubHash["foo" => "bar"])
+    assert_equal '["foo"]', JSON(SubArray["foo"])
+  end
+
+  def test_generate_of_core_subclasses
+    obj = SubHash["foo" => SubHash["bar" => true]]
+    obj_json = JSON(obj)
+    obj_again = JSON(obj_json)
+    assert_kind_of Hash, obj_again
+    assert_kind_of Hash, obj_again['foo']
+    assert obj_again['foo']['bar']
+    assert_equal obj, obj_again
   end
 
   def test_parser_reset
@@ -275,12 +446,12 @@ EOT
     assert_raises(JSON::NestingError) { JSON.parse '[[]]', :max_nesting => 1 }
     assert_raises(JSON::NestingError) { JSON.parser.new('[[]]', :max_nesting => 1).parse }
     assert_equal [[]], JSON.parse('[[]]', :max_nesting => 2)
-    too_deep = '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]'
+    too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
     too_deep_ary = eval too_deep
     assert_raises(JSON::NestingError) { JSON.parse too_deep }
     assert_raises(JSON::NestingError) { JSON.parser.new(too_deep).parse }
-    assert_raises(JSON::NestingError) { JSON.parse too_deep, :max_nesting => 19 }
-    ok = JSON.parse too_deep, :max_nesting => 20
+    assert_raises(JSON::NestingError) { JSON.parse too_deep, :max_nesting => 100 }
+    ok = JSON.parse too_deep, :max_nesting => 101
     assert_equal too_deep_ary, ok
     ok = JSON.parse too_deep, :max_nesting => nil
     assert_equal too_deep_ary, ok
@@ -291,8 +462,8 @@ EOT
     assert_raises(JSON::NestingError) { JSON.generate [[]], :max_nesting => 1 }
     assert_equal '[[]]', JSON.generate([[]], :max_nesting => 2)
     assert_raises(JSON::NestingError) { JSON.generate too_deep_ary }
-    assert_raises(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 19 }
-    ok = JSON.generate too_deep_ary, :max_nesting => 20
+    assert_raises(JSON::NestingError) { JSON.generate too_deep_ary, :max_nesting => 100 }
+    ok = JSON.generate too_deep_ary, :max_nesting => 101
     assert_equal too_deep, ok
     ok = JSON.generate too_deep_ary, :max_nesting => nil
     assert_equal too_deep, ok
@@ -309,19 +480,38 @@ EOT
       JSON.parse('{"foo":"bar", "baz":"quux"}', :symbolize_names => true))
   end
 
-  def test_load_dump
-    too_deep = '[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]'
+  def test_load
+    assert_equal @hash, JSON.load(@json)
+    tempfile = Tempfile.open('json')
+    tempfile.write @json
+    tempfile.rewind
+    assert_equal @hash, JSON.load(tempfile)
+    stringio = StringIO.new(@json)
+    stringio.rewind
+    assert_equal @hash, JSON.load(stringio)
+    assert_equal nil, JSON.load(nil)
+    assert_equal nil, JSON.load('')
+  end
+
+  def test_load_with_options
+    small_hash  = JSON("foo" => 'bar')
+    symbol_hash = { :foo => 'bar' }
+    assert_equal symbol_hash, JSON.load(small_hash, nil, :symbolize_names => true)
+  end
+
+  def test_dump
+    too_deep = '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]'
     assert_equal too_deep, JSON.dump(eval(too_deep))
     assert_kind_of String, Marshal.dump(eval(too_deep))
-    assert_raises(ArgumentError) { JSON.dump(eval(too_deep), 19) }
-    assert_raises(ArgumentError) { Marshal.dump(eval(too_deep), 19) }
-    assert_equal too_deep, JSON.dump(eval(too_deep), 20)
-    assert_kind_of String, Marshal.dump(eval(too_deep), 20)
+    assert_raises(ArgumentError) { JSON.dump(eval(too_deep), 100) }
+    assert_raises(ArgumentError) { Marshal.dump(eval(too_deep), 100) }
+    assert_equal too_deep, JSON.dump(eval(too_deep), 101)
+    assert_kind_of String, Marshal.dump(eval(too_deep), 101)
     output = StringIO.new
     JSON.dump(eval(too_deep), output)
     assert_equal too_deep, output.string
     output = StringIO.new
-    JSON.dump(eval(too_deep), output, 20)
+    JSON.dump(eval(too_deep), output, 101)
     assert_equal too_deep, output.string
   end
 
@@ -337,4 +527,19 @@ EOT
     json5 = JSON([orig = 1 << 64])
     assert_equal orig, JSON[json5][0]
   end
+
+  if defined?(JSON::Ext::Parser)
+    def test_allocate
+      parser = JSON::Ext::Parser.new("{}")
+      assert_raise(TypeError, '[ruby-core:35079]') {parser.__send__(:initialize, "{}")}
+      parser = JSON::Ext::Parser.allocate
+      assert_raise(TypeError, '[ruby-core:35079]') {parser.source}
+    end
+  end
+
+  def test_argument_encoding
+    source = "{}".force_encoding("ascii-8bit")
+    JSON::Parser.new(source)
+    assert_equal Encoding::ASCII_8BIT, source.encoding
+  end if defined?(Encoding::ASCII_8BIT)
 end