json-jruby 1.2.4-universal-java-1.6 → 1.4.0-universal-java-1.6

data/lib/json/common.rb

@@ -63,6 +63,20 @@ module JSON
       end
       self.state = generator::State
       const_set :State, self.state
+      const_set :SAFE_STATE_PROTOTYPE, State.new.freeze
+      const_set :FAST_STATE_PROTOTYPE, State.new(
+        :indent         => '',
+        :space          => '',
+        :object_nl      => "",
+        :array_nl       => "",
+        :max_nesting    => false
+      ).freeze
+      const_set :PRETTY_STATE_PROTOTYPE, State.new(
+        :indent         => '  ',
+        :space          => ' ',
+        :object_nl      => "\n",
+        :array_nl       => "\n"
+      ).freeze
     end
 
     # Returns the JSON generator modul, that is used by JSON. This might be
@@ -95,15 +109,15 @@ module JSON
   # 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
 
-  # If a circular data structure is encountered while unparsing
-  # this exception is raised.
-  class CircularDatastructure < GeneratorError; end
-
   # 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
@@ -129,7 +143,7 @@ module JSON
   # * *object_class*: Defaults to Hash
   # * *array_class*: Defaults to Array
   def parse(source, opts = {})
-    JSON.parser.new(source, opts).parse
+    Parser.new(source, opts).parse
   end
 
   # Parse the JSON document _source_ into a Ruby data structure and return it.
@@ -149,10 +163,10 @@ module JSON
   #   defaults to true.
   def parse!(source, opts = {})
     opts = {
-      :max_nesting => false,
-      :allow_nan => true
+      :max_nesting  => false,
+      :allow_nan    => true
     }.update(opts)
-    JSON.parser.new(source, opts).parse
+    Parser.new(source, opts).parse
   end
 
   # Generate a JSON document from the Ruby data structure _obj_ and return
@@ -171,8 +185,6 @@ 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: ''),
-  # * *check_circular*: true if checking for circular data structures
-  #   should be done (the default), false otherwise.
   # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
   #   generated, otherwise an exception is thrown, if these values are
   #   encountered. This options defaults to false.
@@ -183,17 +195,21 @@ module JSON
   # See also the fast_generate for the fastest creation method with the least
   # amount of sanity checks, and the pretty_generate method for some
   # defaults for a pretty output.
-  def generate(obj, state = nil)
-    if state
-      state = State.from_state(state)
+  def generate(obj, opts = nil)
+    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 = SAFE_STATE_PROTOTYPE.dup
+      state = state.configure(opts)
     else
-      state = State.new
-    end
-    result = obj.to_json(state)
-    if result !~ /\A\s*(?:\[.*\]|\{.*\})\s*\Z/m
-      raise GeneratorError, "only generation of JSON objects or arrays allowed"
+      state = SAFE_STATE_PROTOTYPE
     end
-    result
+    state.generate(obj)
   end
 
   # :stopdoc:
@@ -208,12 +224,21 @@ module JSON
   #
   # *WARNING*: Be careful not to pass any Ruby data structures with circles as
   # _obj_ argument, because this will cause JSON to go into an infinite loop.
-  def fast_generate(obj)
-    result = obj.to_json(nil)
-    if result !~ /\A(?:\[.*\]|\{.*\})\Z/
-      raise GeneratorError, "only generation of JSON objects or arrays allowed"
+  def fast_generate(obj, opts = nil)
+    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 = FAST_STATE_PROTOTYPE.dup
+      state.configure(opts)
+    else
+      state = FAST_STATE_PROTOTYPE
     end
-    result
+    state.generate(obj)
   end
 
   # :stopdoc:
@@ -229,13 +254,6 @@ module JSON
   # The _opts_ argument can be used to configure the generator, see the
   # generate method for a more detailed explanation.
   def pretty_generate(obj, opts = nil)
-    state = JSON.state.new(
-      :indent     => '  ',
-      :space      => ' ',
-      :object_nl  => "\n",
-      :array_nl   => "\n",
-      :check_circular => true
-    )
     if opts
       if opts.respond_to? :to_hash
         opts = opts.to_hash
@@ -244,13 +262,12 @@ module JSON
       else
         raise TypeError, "can't convert #{opts.class} into Hash"
       end
+      state = PRETTY_STATE_PROTOTYPE.dup
       state.configure(opts)
+    else
+      state = PRETTY_STATE_PROTOTYPE
     end
-    result = obj.to_json(state)
-    if result !~ /\A\s*(?:\[.*\]|\{.*\})\s*\Z/m
-      raise GeneratorError, "only generation of JSON objects or arrays allowed"
-    end
-    result
+    state.generate(obj)
   end
 
   # :stopdoc:

data/lib/json/pure/generator.rb

@@ -40,6 +40,15 @@ module JSON
   # UTF16 big endian characters as \u????, and return it.
   if defined?(::Encoding)
     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
+
+    def utf8_to_json_ascii(string) # :nodoc:
       string = string.dup
       string << '' # XXX workaround: avoid buffer sharing
       string.force_encoding(::Encoding::ASCII_8BIT)
@@ -63,6 +72,10 @@ module JSON
     end
   else
     def utf8_to_json(string) # :nodoc:
+      string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
+    end
+
+    def utf8_to_json_ascii(string) # :nodoc:
       string = string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
       string.gsub!(/(
                       (?:
@@ -81,7 +94,7 @@ module JSON
       raise GeneratorError, "Caught #{e.class}: #{e}"
     end
   end
-  module_function :utf8_to_json
+  module_function :utf8_to_json, :utf8_to_json_ascii
 
   module Pure
     module Generator
@@ -99,7 +112,7 @@ module JSON
           when Hash
             new(opts)
           else
-            new
+            SAFE_STATE_PROTOTYPE
           end
         end
 
@@ -112,22 +125,20 @@ 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: ''),
-        # * *check_circular*: true if checking for circular data structures
-        #   should be done (the default), false otherwise.
-        # * *check_circular*: true if checking for circular data structures
-        #   should be done, false (the default) otherwise.
+        # * *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.
         # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
         #   generated, otherwise an exception is thrown, if these values are
         #   encountered. This options defaults to false.
         def initialize(opts = {})
-          @seen = {}
           @indent         = ''
           @space          = ''
           @space_before   = ''
           @object_nl      = ''
           @array_nl       = ''
-          @check_circular = true
           @allow_nan      = false
+          @ascii_only     = false
           configure opts
         end
 
@@ -159,10 +170,10 @@ module JSON
             raise NestingError, "nesting of #{current_nesting} is too deep"
         end
 
-        # Returns true, if circular data structures should be checked,
+        # Returns true, if circular data structures are checked,
         # otherwise returns false.
         def check_circular?
-          @check_circular
+          !@max_nesting.zero?
         end
 
         # Returns true if NaN, Infinity, and -Infinity should be considered as
@@ -171,21 +182,8 @@ module JSON
           @allow_nan
         end
 
-        # Returns _true_, if _object_ was already seen during this generating
-        # run. 
-        def seen?(object)
-          @seen.key?(object.__id__)
-        end
-
-        # Remember _object_, to find out if it was already encountered (if a
-        # cyclic data structure is if a cyclic data structure is rendered). 
-        def remember(object)
-          @seen[object.__id__] = true
-        end
-
-        # Forget _object_ for this generating run.
-        def forget(object)
-          @seen.delete object.__id__
+        def ascii_only?
+          @ascii_only
         end
 
         # Configure this State instance with the Hash _opts_, and return
@@ -196,8 +194,8 @@ module JSON
           @space_before   = opts[:space_before] if opts.key?(:space_before)
           @object_nl      = opts[:object_nl] if opts.key?(:object_nl)
           @array_nl       = opts[:array_nl] if opts.key?(:array_nl)
-          @check_circular = !!opts[:check_circular] if opts.key?(:check_circular)
           @allow_nan      = !!opts[:allow_nan] if opts.key?(:allow_nan)
+          @ascii_only     = opts[:ascii_only] if opts.key?(:ascii_only)
           if !opts.key?(:max_nesting) # defaults to 19
             @max_nesting = 19
           elsif opts[:max_nesting]
@@ -212,12 +210,23 @@ module JSON
         # passed to the configure method.
         def to_h
           result = {}
-          for iv in %w[indent space space_before object_nl array_nl check_circular allow_nan max_nesting]
+          for iv in %w[indent space space_before object_nl array_nl allow_nan max_nesting]
             result[iv.intern] = instance_variable_get("@#{iv}")
           end
           result
         end
 
+        # Generates a valid JSON document from object +obj+ and returns the
+        # result. If no valid JSON document can be created this method raises a
+        # GeneratorError exception.
+        def generate(obj)
+          result = obj.to_json(self)
+          if result !~ /\A\s*(?:\[.*\]|\{.*\})\s*\Z/m
+            raise GeneratorError, "only generation of JSON objects or arrays allowed"
+          end
+          result
+        end
+
         # Return the value returned by method +name+.
         def [](name)
           __send__ name
@@ -240,27 +249,14 @@ module JSON
           # _depth_ is used to find out nesting depth, to indent accordingly.
           def to_json(state = nil, depth = 0, *)
             if state
-              state = JSON.state.from_state(state)
+              state = State.from_state(state)
               state.check_max_nesting(depth)
-              json_check_circular(state) { json_transform(state, depth) }
-            else
-              json_transform(state, depth)
             end
+            json_transform(state, depth)
           end
 
           private
 
-          def json_check_circular(state)
-            if state and state.check_circular?
-              state.seen?(self) and raise JSON::CircularDatastructure,
-                  "circular data structures not supported!"
-              state.remember self
-            end
-            yield
-          ensure
-            state and state.forget self
-          end
-
           def json_shift(state, depth)
             state and not state.object_nl.empty? or return ''
             state.indent * depth
@@ -272,16 +268,22 @@ module JSON
               delim << state.object_nl
               result = '{'
               result << state.object_nl
-              result << map { |key,value|
-                s = json_shift(state, depth + 1)
-                s << key.to_s.to_json(state, depth + 1)
-                s << state.space_before
-                s << ':'
-                s << state.space
-                s << value.to_json(state, depth + 1)
-              }.join(delim)
+              depth += 1
+              first = true
+              indent = state && !state.object_nl.empty?
+              each { |key,value|
+                result << delim unless first
+                result << state.indent * depth if indent
+                result << key.to_s.to_json(state, depth)
+                result << state.space_before
+                result << ':'
+                result << state.space
+                result << value.to_json(state, depth)
+                first = false
+              }
+              depth -= 1
               result << state.object_nl
-              result << json_shift(state, depth)
+              result << state.indent * depth if indent if indent
               result << '}'
             else
               result = '{'
@@ -302,43 +304,32 @@ module JSON
           # _depth_ is used to find out nesting depth, to indent accordingly.
           def to_json(state = nil, depth = 0, *)
             if state
-              state = JSON.state.from_state(state)
+              state = State.from_state(state)
               state.check_max_nesting(depth)
-              json_check_circular(state) { json_transform(state, depth) }
-            else
-              json_transform(state, depth)
             end
+            json_transform(state, depth)
           end
 
           private
 
-          def json_check_circular(state)
-            if state and state.check_circular?
-              state.seen?(self) and raise JSON::CircularDatastructure,
-                "circular data structures not supported!"
-              state.remember self
-            end
-            yield
-          ensure
-            state and state.forget self
-          end
-
-          def json_shift(state, depth)
-            state and not state.array_nl.empty? or return ''
-            state.indent * depth
-          end
-
           def json_transform(state, depth)
             delim = ','
             if state
               delim << state.array_nl
               result = '['
               result << state.array_nl
-              result << map { |value|
-                json_shift(state, depth + 1) << value.to_json(state, depth + 1)
-              }.join(delim)
+              depth += 1
+              first = true
+              indent = state && !state.array_nl.empty?
+              each { |value|
+                result << delim unless first
+                result << state.indent * depth if indent
+                result << value.to_json(state, depth)
+                first = false
+              }
+              depth -= 1
               result << state.array_nl
-              result << json_shift(state, depth) 
+              result << state.indent * depth if indent
               result << ']'
             else
               '[' << map { |value| value.to_json }.join(delim) << ']'
@@ -378,11 +369,17 @@ module JSON
             # This string should be encoded with UTF-8 A call to this method
             # returns a JSON string encoded with UTF16 big endian characters as
             # \u????.
-            def to_json(*)
+            def to_json(*args)
+              state, = *args
+              state ||= State.from_state(state)
               if encoding == ::Encoding::UTF_8
-                '"' << JSON.utf8_to_json(self) << '"'
+                string = self
               else
                 string = encode(::Encoding::UTF_8)
+              end
+              if state.ascii_only?
+                '"' << JSON.utf8_to_json_ascii(string) << '"'
+              else
                 '"' << JSON.utf8_to_json(string) << '"'
               end
             end
@@ -390,16 +387,23 @@ module JSON
             # This string should be encoded with UTF-8 A call to this method
             # returns a JSON string encoded with UTF16 big endian characters as
             # \u????.
-            def to_json(*)
-              '"' << JSON.utf8_to_json(self) << '"'
+            def to_json(*args)
+              state, = *args
+              state ||= State.from_state(state)
+              if state.ascii_only?
+                '"' << JSON.utf8_to_json_ascii(self) << '"'
+              else
+                '"' << JSON.utf8_to_json(self) << '"'
+              end
             end
           end
 
           # Module that holds the extinding methods if, the String module is
           # included.
           module Extend
-            # Raw Strings are JSON Objects (the raw bytes are stored in an array for the
-            # key "raw"). The Ruby String can be created by this module method.
+            # Raw Strings are JSON Objects (the raw bytes are stored in an
+            # array for the key "raw"). The Ruby String can be created by this
+            # module method.
             def json_create(o)
               o['raw'].pack('C*')
             end

data/lib/json/version.rb

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

data/tests/test_json_encoding.rb

@@ -57,11 +57,12 @@ class TC_JSONEncoding < Test::Unit::TestCase
   end
 
   def test_generate
-    assert_equal @generated, JSON.generate(@parsed)
+    assert_equal @generated, JSON.generate(@parsed, :ascii_only => true)
     if defined?(::Encoding)
-      assert_equal @generated, JSON.generate(@utf_16_data)
+      assert_equal @generated, JSON.generate(@utf_16_data, :ascii_only => true)
     else
-       assert_raises(JSON::GeneratorError) { JSON.generate(@utf_16_data) }
+      # XXX checking of correct utf8 data is not as strict (yet?) without :ascii_only
+      assert_raises(JSON::GeneratorError) { JSON.generate(@utf_16_data, :ascii_only => true) }
     end
   end
 end

data/tests/test_json_generate.rb

@@ -87,19 +87,19 @@ EOT
   def test_states
     json = generate({1=>2}, nil)
     assert_equal('{"1":2}', json)
-    s = JSON.state.new(:check_circular => true)
+    s = JSON.state.new
     assert s.check_circular?
     assert s[:check_circular?]
     h = { 1=>2 }
     h[3] = h
-    assert_raises(JSON::CircularDatastructure) {  generate(h) }
-    assert_raises(JSON::CircularDatastructure) {  generate(h, s) }
-    s = JSON.state.new(:check_circular => true)
-    assert s.check_circular?
-    assert s[:check_circular?]
+    assert_raises(JSON::NestingError) {  generate(h) }
+    assert_raises(JSON::NestingError) {  generate(h, s) }
+    s = JSON.state.new
     a = [ 1, 2 ]
     a << a
-    assert_raises(JSON::CircularDatastructure) {  generate(a, s) }
+    assert_raises(JSON::NestingError) {  generate(a, s) }
+    assert s.check_circular?
+    assert s[:check_circular?]
   end
 
   def test_allow_nan

data/tests/test_json_unicode.rb

@@ -19,22 +19,36 @@ class TC_JSONUnicode < Test::Unit::TestCase
     assert_equal '" "', ' '.to_json
     assert_equal "\"#{0x7f.chr}\"", 0x7f.chr.to_json
     utf8 = [ "© ≠ €! \01" ]
+    json = '["© ≠ €! \u0001"]'
+    assert_equal json, utf8.to_json(:ascii_only => false)
+    assert_equal utf8, parse(json)
     json = '["\u00a9 \u2260 \u20ac! \u0001"]'
-    assert_equal json, utf8.to_json
+    assert_equal json, utf8.to_json(:ascii_only => true)
+    assert_equal utf8, parse(json)
+    utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
+    json = "[\"\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212\"]"
     assert_equal utf8, parse(json)
+    assert_equal json, utf8.to_json(:ascii_only => false)
     utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
+    assert_equal utf8, parse(json)
     json = "[\"\\u3042\\u3044\\u3046\\u3048\\u304a\"]"
-    assert_equal json, utf8.to_json
+    assert_equal json, utf8.to_json(:ascii_only => true)
     assert_equal utf8, parse(json)
     utf8 = ['საქართველო']
+    json = '["საქართველო"]'
+    assert_equal json, utf8.to_json(:ascii_only => false)
     json = "[\"\\u10e1\\u10d0\\u10e5\\u10d0\\u10e0\\u10d7\\u10d5\\u10d4\\u10da\\u10dd\"]"
-    assert_equal json, utf8.to_json
+    assert_equal json, utf8.to_json(:ascii_only => true)
     assert_equal utf8, parse(json)
-    assert_equal '["\\u00c3"]', JSON.generate(["Ã"])
+    assert_equal '["Ã"]', JSON.generate(["Ã"], :ascii_only => false)
+    assert_equal '["\\u00c3"]', JSON.generate(["Ã"], :ascii_only => true)
     assert_equal ["€"], JSON.parse('["\u20ac"]')
     utf8 = ["\xf0\xa0\x80\x81"]
+    json = "[\"\xf0\xa0\x80\x81\"]"
+    assert_equal json, JSON.generate(utf8, :ascii_only => false)
+    assert_equal utf8, JSON.parse(json)
     json = '["\ud840\udc01"]'
-    assert_equal json, JSON.generate(utf8)
+    assert_equal json, JSON.generate(utf8, :ascii_only => true)
     assert_equal utf8, JSON.parse(json)
   end
 
@@ -55,7 +69,7 @@ class TC_JSONUnicode < Test::Unit::TestCase
       end
     end
     assert_raise(JSON::GeneratorError) do
-      JSON.generate(["\x80"])
+      JSON.generate(["\x80"], :ascii_only => true)
     end
     assert_equal "\302\200", JSON.parse('["\u0080"]').first
   end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
     - 1
-    - 2
     - 4
-  version: 1.2.4
+    - 0
+  version: 1.4.0
 platform: universal-java-1.6
 authors: 
   - Daniel Luz
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-08 00:00:00 -03:00
+date: 2010-04-23 00:00:00 -03:00
 default_executable: 
 dependencies: []