json_pure 1.0.0 → 1.4.6

data/lib/json/pure/generator.rb

@@ -34,30 +34,67 @@ module JSON
     "\x1f" => '\u001f',
     '"'   =>  '\"',
     '\\'  =>  '\\\\',
-    '/'   =>  '\/',
   } # :nodoc:
 
   # 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:
-    string = string.gsub(/["\\\/\x0-\x1f]/) { |c| MAP[c] }
-    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::UTF8toUTF16.iconv(c).unpack('H*')[0]
-      s.gsub!(/.{4}/n, '\\\\u\&')
-    }
-    string
-  rescue Iconv::Failure => e
-    raise GeneratorError, "Caught #{e.class}: #{e}"
+  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)
+      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::UTF8toUTF16.iconv(c).unpack('H*')[0]
+                      s.gsub!(/.{4}/n, '\\\\u\&')
+                    }
+      string.force_encoding(::Encoding::UTF_8)
+      string
+    rescue Iconv::Failure => e
+      raise GeneratorError, "Caught #{e.class}: #{e}"
+    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!(/(
+                      (?:
+                        [\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::UTF8toUTF16.iconv(c).unpack('H*')[0]
+        s.gsub!(/.{4}/n, '\\\\u\&')
+      }
+      string
+    rescue Iconv::Failure => e
+      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
@@ -75,7 +112,7 @@ module JSON
           when Hash
             new(opts)
           else
-            new
+            SAFE_STATE_PROTOTYPE.dup
           end
         end
 
@@ -88,16 +125,21 @@ 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, 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 = {})
-          @indent         = opts[:indent]       || ''
-          @space          = opts[:space]        || ''
-          @space_before   = opts[:space_before] || ''
-          @object_nl      = opts[:object_nl]    || ''
-          @array_nl       = opts[:array_nl]     || ''
-          @check_circular = !!(opts[:check_circular] || false)
-          @seen           = {}
+          @indent         = ''
+          @space          = ''
+          @space_before   = ''
+          @object_nl      = ''
+          @array_nl       = ''
+          @allow_nan      = false
+          @ascii_only     = false
+          configure opts
         end
 
         # This string is used to indent levels in the JSON text.
@@ -117,27 +159,82 @@ module JSON
         # This string is put at the end of a line that holds a JSON array.
         attr_accessor :array_nl
 
-        # Returns true, if circular data structures should be checked,
+        # This integer returns the maximum level of data structure nesting in
+        # the generated JSON, max_nesting = 0 if no maximum is checked.
+        attr_accessor :max_nesting
+
+        # This integer returns the current depth data structure nesting in the
+        # generated JSON.
+        attr_accessor :depth
+
+        def check_max_nesting # :nodoc:
+          return if @max_nesting.zero?
+          current_nesting = depth + 1
+          current_nesting > @max_nesting and
+            raise NestingError, "nesting of #{current_nesting} is too deep"
+        end
+
+        # 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
+        # valid JSON and output.
+        def allow_nan?
+          @allow_nan
         end
 
-        # Returns _true_, if _object_ was already seen during this generating
-        # run. 
-        def seen?(object)
-          @seen.key?(object.__id__)
+        def ascii_only?
+          @ascii_only
         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
+        # Configure this State instance with the Hash _opts_, and return
+        # itself.
+        def configure(opts)
+          @indent         = opts[:indent] if opts.key?(:indent)
+          @space          = opts[:space] if opts.key?(:space)
+          @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)
+          @allow_nan      = !!opts[:allow_nan] if opts.key?(:allow_nan)
+          @ascii_only     = opts[:ascii_only] if opts.key?(:ascii_only)
+          @depth          = opts[:depth] || 0
+          if !opts.key?(:max_nesting) # defaults to 19
+            @max_nesting = 19
+          elsif opts[:max_nesting]
+            @max_nesting = opts[:max_nesting]
+          else
+            @max_nesting = 0
+          end
+          self
         end
 
-        # Forget _object_ for this generating run.
-        def forget(object)
-          @seen.delete object.__id__
+        # Returns the configuration instance variables as a hash, that can be
+        # passed to the configure method.
+        def to_h
+          result = {}
+          for iv in %w[indent space space_before object_nl array_nl allow_nan max_nesting ascii_only depth]
+            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
         end
       end
 
@@ -155,48 +252,40 @@ module JSON
           # _state_ is a JSON::State object, that can also be used to configure the
           # produced JSON string output further.
           # _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)
-              json_check_circular(state) { json_transform(state, depth) }
-            else
-              json_transform(state, depth)
-            end
+          def to_json(state = nil, *)
+            state = State.from_state(state)
+            state.check_max_nesting
+            json_transform(state)
           end
 
           private
 
-          def json_check_circular(state)
-            if state
-              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
+          def json_shift(state)
+            state.object_nl.empty? or return ''
+            state.indent * state.depth
           end
 
-          def json_transform(state, depth)
+          def json_transform(state)
             delim = ','
-            delim << state.object_nl if state
+            delim << state.object_nl
             result = '{'
-            result << state.object_nl if state
-            result << map { |key,value|
-              s = json_shift(state, depth + 1)
-              s << key.to_s.to_json(state, depth + 1)
-              s << state.space_before if state
-              s << ':'
-              s << state.space if state
-              s << value.to_json(state, depth + 1)
-            }.join(delim)
-            result << state.object_nl if state
-            result << json_shift(state, depth)
+            result << state.object_nl
+            depth = state.depth += 1
+            first = true
+            indent = !state.object_nl.empty?
+            each { |key,value|
+              result << delim unless first
+              result << state.indent * depth if indent
+              result << key.to_s.to_json(state)
+              result << state.space_before
+              result << ':'
+              result << state.space
+              result << value.to_json(state)
+              first = false
+            }
+            depth = state.depth -= 1
+            result << state.object_nl
+            result << state.indent * depth if indent if indent
             result << '}'
             result
           end
@@ -207,46 +296,32 @@ module JSON
           # this Array instance.
           # _state_ is a JSON::State object, that can also be used to configure the
           # produced JSON string output further.
-          # _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)
-              json_check_circular(state) { json_transform(state, depth) }
-            else
-              json_transform(state, depth)
-            end
+          def to_json(state = nil, *)
+            state = State.from_state(state)
+            state.check_max_nesting
+            json_transform(state)
           end
 
           private
 
-          def json_check_circular(state)
-            if state
-              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)
+          def json_transform(state)
             delim = ','
-            delim << state.array_nl if state
+            delim << state.array_nl
             result = '['
-            result << state.array_nl if state
-            result << map { |value|
-              json_shift(state, depth + 1) << value.to_json(state, depth + 1)
-            }.join(delim)
-            result << state.array_nl if state
-            result << json_shift(state, depth) 
+            result << state.array_nl
+            depth = state.depth += 1
+            first = true
+            indent = !state.array_nl.empty?
+            each { |value|
+              result << delim unless first
+              result << state.indent * depth if indent
+              result << value.to_json(state)
+              first = false
+            }
+            depth = state.depth -= 1
+            result << state.array_nl
+            result << state.indent * depth if indent
             result << ']'
-            result
           end
         end
 
@@ -257,22 +332,65 @@ module JSON
 
         module Float
           # Returns a JSON string representation for this Float number.
-          def to_json(*) to_s end
+          def to_json(state = nil, *)
+            state = State.from_state(state)
+            case
+            when infinite?
+              if state.allow_nan?
+                to_s
+              else
+                raise GeneratorError, "#{self} not allowed in JSON"
+              end
+            when nan?
+              if state.allow_nan?
+                to_s
+              else
+                raise GeneratorError, "#{self} not allowed in JSON"
+              end
+            else
+              to_s
+            end
+          end
         end
 
         module String
-          # 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) << '"'
+          if defined?(::Encoding)
+            # 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(state = nil, *args)
+              state = State.from_state(state)
+              if encoding == ::Encoding::UTF_8
+                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
+          else
+            # 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(state = nil, *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/pure/parser.rb

@@ -6,9 +6,12 @@ module JSON
     # into a Ruby data structure.
     class Parser < StringScanner
       STRING                = /" ((?:[^\x0-\x1f"\\] |
+                                   # escaped special characters:
                                   \\["\\\/bfnrt] |
-                                  \\u[0-9a-fA-F]{4})*)
-                              "/x
+                                  \\u[0-9a-fA-F]{4} |
+                                   # match all but escaped special characters:
+                                  \\[\x20-\x21\x23-\x2e\x30-\x5b\x5d-\x61\x63-\x65\x67-\x6d\x6f-\x71\x73\x75-\xff])*)
+                              "/nx
       INTEGER               = /(-?0|-?[1-9]\d*)/
       FLOAT                 = /(-?
                                 (?:0|[1-9]\d*)
@@ -18,6 +21,9 @@ module JSON
                                   (?i:e[+-]?\d+)
                                 )
                                 )/x
+      NAN                   = /NaN/
+      INFINITY              = /Infinity/
+      MINUS_INFINITY        = /-Infinity/
       OBJECT_OPEN           = /\{/
       OBJECT_CLOSE          = /\}/
       ARRAY_OPEN            = /\[/
@@ -45,9 +51,75 @@ module JSON
       UNPARSED = Object.new
 
       # Creates a new JSON::Pure::Parser instance for the string _source_.
-      def initialize(source)
-        super
-        @create_id = JSON.create_id
+      #
+      # It will be configured by the _opts_ hash. _opts_ can have the following
+      # 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.
+      # * *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.
+      # * *object_class*: Defaults to Hash
+      # * *array_class*: Defaults to Array
+      def initialize(source, opts = {})
+        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
+        super source
+        if !opts.key?(:max_nesting) # defaults to 19
+          @max_nesting = 19
+        elsif opts[:max_nesting]
+          @max_nesting = opts[:max_nesting]
+        else
+          @max_nesting = 0
+        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
+        @object_class = opts[:object_class] || Hash
+        @array_class = opts[:array_class] || Array
       end
 
       alias source string
@@ -61,9 +133,11 @@ module JSON
           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)
             ;
@@ -77,30 +151,40 @@ module JSON
 
       private
 
+      # Unescape characters in strings.
+      UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+      UNESCAPE_MAP.update({
+        ?"  => '"',
+        ?\\ => '\\',
+        ?/  => '/',
+        ?b  => "\b",
+        ?f  => "\f",
+        ?n  => "\n",
+        ?r  => "\r",
+        ?t  => "\t",
+        ?u  => nil, 
+      })
+
       def parse_string
         if scan(STRING)
           return '' if self[1].empty?
-          self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+))) do
-            case $~[0]
-            when '\\"'  then '"'
-            when '\\\\' then '\\'
-            when '\\/'  then '/'
-            when '\\b'  then "\b"
-            when '\\f'  then "\f"
-            when '\\n'  then "\n"
-            when '\\r'  then "\r"
-            when '\\t'  then "\t"
-            else
+          string = self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+            if u = UNESCAPE_MAP[$&[1]]
+              u
+            else # \uXXXX
               bytes = ''
-              c = $~[0]
               i = 0
-              while c[6 * i] == ?\\ && c[6 * i + 1] == ?u 
+              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)
             end
           end
+          if string.respond_to?(:force_encoding)
+            string.force_encoding(::Encoding::UTF_8)
+          end
+          string
         else
           UNPARSED
         end
@@ -123,16 +207,30 @@ module JSON
         when (string = parse_string) != UNPARSED
           string
         when scan(ARRAY_OPEN)
-          parse_array
+          @current_nesting += 1
+          ary = parse_array
+          @current_nesting -= 1
+          ary
         when scan(OBJECT_OPEN)
-          parse_object
+          @current_nesting += 1
+          obj = parse_object
+          @current_nesting -= 1
+          obj
+        when @allow_nan && scan(NAN)
+          NaN
+        when @allow_nan && scan(INFINITY)
+          Infinity
+        when @allow_nan && scan(MINUS_INFINITY)
+          MinusInfinity
         else
           UNPARSED
         end
       end
 
       def parse_array
-        result = []
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = @array_class.new
         delim = false
         until eos?
           case
@@ -162,7 +260,9 @@ module JSON
       end
 
       def parse_object
-        result = {}
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = @object_class.new
         delim = false
         until eos?
           case
@@ -173,7 +273,7 @@ module JSON
             end
             skip(IGNORE)
             unless (value = parse_value).equal? UNPARSED
-              result[string] = value
+              result[@symbolize_names ? string.to_sym : string] = value
               delim = false
               skip(IGNORE)
               if scan(COLLECTION_DELIMITER)
@@ -190,11 +290,10 @@ module JSON
             if delim
               raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
             end
-            if klassname = result[@create_id]
+            if @create_id and klassname = result[@create_id]
               klass = JSON.deep_const_get klassname
               break unless klass and klass.json_creatable?
               result = klass.json_create(result)
-              result
             end
             break
           when skip(IGNORE)