json 2.7.1-java → 2.7.3-java

data/lib/json/ext/generator/state.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module JSON
+  module Ext
+    module Generator
+      class State
+        # call-seq: new(opts = {})
+        #
+        # Instantiates a new State object, configured by _opts_.
+        #
+        # _opts_ can have the following keys:
+        #
+        # * *indent*: a string used to indent levels (default: ''),
+        # * *space*: a string that is put after, a : or , delimiter (default: ''),
+        # * *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: ''),
+        # * *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.
+        # * *ascii_only*: true if only ASCII characters should be generated. This
+        #   option defaults to false.
+        # * *buffer_initial_length*: sets the initial length of the generator's
+        #   internal buffer.
+        def initialize(opts = nil)
+          if opts && !opts.empty?
+            configure(opts)
+          end
+        end
+
+        # call-seq: configure(opts)
+        #
+        # Configure this State instance with the Hash _opts_, and return
+        # itself.
+        def configure(opts)
+          unless opts.is_a?(Hash)
+            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
+          end
+
+          opts.each do |key, value|
+            case key
+            when :indent
+              self.indent = value
+            when :space
+              self.space = value
+            when :space_before
+              self.space_before = value
+            when :array_nl
+              self.array_nl = value
+            when :object_nl
+              self.object_nl = value
+            when :max_nesting
+              self.max_nesting = value || 0
+            when :depth
+              self.depth = value
+            when :buffer_initial_length
+              self.buffer_initial_length = value
+            when :allow_nan
+              self.allow_nan = value
+            when :ascii_only
+              self.ascii_only = value
+            when :script_safe, :escape_slash
+              self.script_safe = value
+            when :strict
+              self.strict = value
+            end
+          end
+
+          self
+        end
+
+        alias_method :merge, :configure
+
+        # call-seq: to_h
+        #
+        # Returns the configuration instance variables as a hash, that can be
+        # passed to the configure method.
+        def to_h
+          result = {
+            indent: indent,
+            space: space,
+            space_before: space_before,
+            object_nl: object_nl,
+            array_nl: array_nl,
+            allow_nan: allow_nan?,
+            ascii_only: ascii_only?,
+            max_nesting: max_nesting,
+            script_safe: script_safe?,
+            strict: strict?,
+            depth: depth,
+            buffer_initial_length: buffer_initial_length,
+          }
+
+          instance_variables.each do |iv|
+            iv = iv.to_s[1..-1]
+            result[iv.to_sym] = self[iv]
+          end
+
+          result
+        end
+
+        alias_method :to_hash, :to_h
+
+        # call-seq: [](name)
+        #
+        # Returns the value returned by method +name+.
+        def [](name)
+          if respond_to?(name)
+            __send__(name)
+          else
+            instance_variable_get("@#{name}") if
+              instance_variables.include?("@#{name}".to_sym) # avoid warning
+          end
+        end
+
+        # call-seq: []=(name, value)
+        #
+        # Sets the attribute name to value.
+        def []=(name, value)
+          if respond_to?(name_writer = "#{name}=")
+            __send__ name_writer, value
+          else
+            instance_variable_set "@#{name}", value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/ext.rb

@@ -1,14 +1,27 @@
+# frozen_string_literal: true
+
 require 'json/common'
 
 module JSON
   # This module holds all the modules/classes that implement JSON's
   # functionality as C extensions.
   module Ext
-    require 'json/ext/parser'
-    require 'json/ext/generator'
-    $DEBUG and warn "Using Ext extension for JSON."
-    JSON.parser = Parser
-    JSON.generator = Generator
+    if RUBY_ENGINE == 'truffleruby'
+      require 'json/ext/parser'
+      require 'json/pure'
+      $DEBUG and warn "Using Ext extension for JSON parser and Pure library for JSON generator."
+      JSON.parser = Parser
+      JSON.generator = JSON::Pure::Generator
+    else
+      require 'json/ext/parser'
+      require 'json/ext/generator'
+      unless RUBY_ENGINE == 'jruby'
+        require 'json/ext/generator/state'
+      end
+      $DEBUG and warn "Using Ext extension for JSON."
+      JSON.parser = Parser
+      JSON.generator = Generator
+    end
   end
 
   JSON_LOADED = true unless defined?(::JSON::JSON_LOADED)

data/lib/json/generic_object.rb

@@ -1,5 +1,9 @@
-#frozen_string_literal: false
-require 'ostruct'
+# frozen_string_literal: true
+begin
+  require 'ostruct'
+rescue LoadError
+  warn "JSON::GenericObject requires 'ostruct'. Please install it with `gem install ostruct`."
+end
 
 module JSON
   class GenericObject < OpenStruct
@@ -67,5 +71,5 @@ module JSON
     def to_json(*a)
       as_json.to_json(*a)
     end
-  end
+  end if defined?(::OpenStruct)
 end

data/lib/json/pure/generator.rb

@@ -1,4 +1,4 @@
-#frozen_string_literal: false
+# frozen_string_literal: true
 module JSON
   MAP = {
     "\x0" => '\u0000',
@@ -35,7 +35,7 @@ module JSON
     "\x1f" => '\u001f',
     '"'   =>  '\"',
     '\\'  =>  '\\\\',
-  } # :nodoc:
+  }.freeze # :nodoc:
 
   ESCAPE_PATTERN = /[\/"\\\x0-\x1f]/n # :nodoc:
 
@@ -43,15 +43,14 @@ module JSON
     '/'  =>  '\\/',
     "\u2028".b => '\u2028',
     "\u2029".b => '\u2029',
-  )
+  ).freeze
 
   SCRIPT_SAFE_ESCAPE_PATTERN = Regexp.union(ESCAPE_PATTERN, "\u2028".b, "\u2029".b)
 
   # 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, script_safe = false) # :nodoc:
-    string = string.dup
-    string.force_encoding(::Encoding::ASCII_8BIT)
+    string = string.b
     if script_safe
       string.gsub!(SCRIPT_SAFE_ESCAPE_PATTERN) { SCRIPT_SAFE_MAP[$&] || $& }
     else
@@ -62,8 +61,7 @@ module JSON
   end
 
   def utf8_to_json_ascii(string, script_safe = false) # :nodoc:
-    string = string.dup
-    string.force_encoding(::Encoding::ASCII_8BIT)
+    string = string.b
     map = script_safe ? SCRIPT_SAFE_MAP : MAP
     string.gsub!(/[\/"\\\x0-\x1f]/n) { map[$&] || $& }
     string.gsub!(/(
@@ -75,7 +73,7 @@ module JSON
       [\x80-\xc1\xf5-\xff]       # invalid
     )/nx) { |c|
       c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
-      s = JSON.iconv('utf-16be', 'utf-8', c).unpack('H*')[0]
+      s = c.encode(::Encoding::UTF_16BE, ::Encoding::UTF_8).unpack('H*')[0]
       s.force_encoding(::Encoding::ASCII_8BIT)
       s.gsub!(/.{4}/n, '\\\\u\&')
       s.force_encoding(::Encoding::UTF_8)
@@ -219,7 +217,9 @@ module JSON
           @script_safe
         end
 
-        # Returns true, if forward slashes are escaped. Otherwise returns false.
+        # Returns true, if strict mode is enabled. Otherwise returns false.
+        # Strict mode only allow serializing JSON native types: Hash, Array,
+        # String, Integer, Float, true, false and nil.
         def strict?
           @strict
         end
@@ -237,6 +237,8 @@ module JSON
           opts.each do |key, value|
             instance_variable_set "@#{key}", value
           end
+
+          # NOTE: If adding new instance variables here, check whether #generate should check them for #generate_json
           @indent                = opts[:indent] if opts.key?(:indent)
           @space                 = opts[:space] if opts.key?(:space)
           @space_before          = opts[:space_before] if opts.key?(:space_before)
@@ -286,12 +288,71 @@ module JSON
         # created this method raises a
         # GeneratorError exception.
         def generate(obj)
-          result = obj.to_json(self)
+          if @indent.empty? and @space.empty? and @space_before.empty? and @object_nl.empty? and @array_nl.empty? and
+              !@ascii_only and !@script_safe and @max_nesting == 0 and !@strict
+            result = generate_json(obj, ''.dup)
+          else
+            result = obj.to_json(self)
+          end
           JSON.valid_utf8?(result) or raise GeneratorError,
             "source sequence #{result.inspect} is illegal/malformed utf-8"
           result
         end
 
+        # Handles @allow_nan, @buffer_initial_length, other ivars must be the default value (see above)
+        private def generate_json(obj, buf)
+          case obj
+          when Hash
+            buf << '{'
+            first = true
+            obj.each_pair do |k,v|
+              buf << ',' unless first
+              fast_serialize_string(k.to_s, buf)
+              buf << ':'
+              generate_json(v, buf)
+              first = false
+            end
+            buf << '}'
+          when Array
+            buf << '['
+            first = true
+            obj.each do |e|
+              buf << ',' unless first
+              generate_json(e, buf)
+              first = false
+            end
+            buf << ']'
+          when String
+            fast_serialize_string(obj, buf)
+          when Integer
+            buf << obj.to_s
+          else
+            # Note: Float is handled this way since Float#to_s is slow anyway
+            buf << obj.to_json(self)
+          end
+        end
+
+        # Assumes !@ascii_only, !@script_safe
+        if Regexp.method_defined?(:match?)
+          private def fast_serialize_string(string, buf) # :nodoc:
+            buf << '"'
+            string = string.encode(::Encoding::UTF_8) unless string.encoding == ::Encoding::UTF_8
+            raise GeneratorError, "source sequence is illegal/malformed utf-8" unless string.valid_encoding?
+
+            if /["\\\x0-\x1f]/n.match?(string)
+              buf << string.gsub(/["\\\x0-\x1f]/n, MAP)
+            else
+              buf << string
+            end
+            buf << '"'
+          end
+        else
+          # Ruby 2.3 compatibility
+          private def fast_serialize_string(string, buf) # :nodoc:
+            buf << string.to_json(self)
+          end
+        end
+
         # Return the value returned by method +name+.
         def [](name)
           if respond_to?(name)
@@ -316,8 +377,8 @@ module JSON
           # Converts this object to a string (calling #to_s), converts
           # it to a JSON string, and returns the result. This is a fallback, if no
           # special method #to_json was defined for some object.
-          def to_json(generator_state)
-            if generator_state.strict?
+          def to_json(state = nil, *)
+            if state && State.from_state(state).strict?
               raise GeneratorError, "#{self.class} not allowed in JSON"
             else
               to_s.to_json
@@ -346,15 +407,15 @@ module JSON
 
           def json_transform(state)
             delim = ",#{state.object_nl}"
-            result = "{#{state.object_nl}"
+            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 = "#{result}#{key.to_s.to_json(state)}#{state.space_before}:#{state.space}"
-              if state.strict?
+              result = +"#{result}#{key.to_s.to_json(state)}#{state.space_before}:#{state.space}"
+              if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value)
                 raise GeneratorError, "#{value.class} not allowed in JSON"
               elsif value.respond_to?(:to_json)
                 result << value.to_json(state)
@@ -387,17 +448,20 @@ module JSON
           private
 
           def json_transform(state)
-            delim = ','
-            delim << state.array_nl
-            result = '['
-            result << state.array_nl
+            result = '['.dup
+            if state.array_nl.empty?
+              delim = ","
+            else
+              result << state.array_nl
+              delim = ",#{state.array_nl}"
+            end
             depth = state.depth += 1
             first = true
             indent = !state.array_nl.empty?
             each { |value|
               result << delim unless first
               result << state.indent * depth if indent
-              if state.strict?
+              if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value)
                 raise GeneratorError, "#{value.class} not allowed in JSON"
               elsif value.respond_to?(:to_json)
                 result << value.to_json(state)
@@ -448,14 +512,17 @@ module JSON
           def to_json(state = nil, *args)
             state = State.from_state(state)
             if encoding == ::Encoding::UTF_8
+              unless valid_encoding?
+                raise GeneratorError, "source sequence is illegal/malformed utf-8"
+              end
               string = self
             else
               string = encode(::Encoding::UTF_8)
             end
             if state.ascii_only?
-              '"' << JSON.utf8_to_json_ascii(string, state.script_safe) << '"'
+              %("#{JSON.utf8_to_json_ascii(string, state.script_safe)}")
             else
-              '"' << JSON.utf8_to_json(string, state.script_safe) << '"'
+              %("#{JSON.utf8_to_json(string, state.script_safe)}")
             end
           end
 

data/lib/json/pure/parser.rb

@@ -1,4 +1,4 @@
-#frozen_string_literal: false
+#frozen_string_literal: true
 require 'strscan'
 
 module JSON
@@ -39,11 +39,8 @@ module JSON
          //[^\n\r]*[\n\r]| # line comments
          /\*               # c-style comments
          (?:
-          [^*/]|        # normal chars
-          /[^*]|        # slashes that do not start a nested comment
-          \*[^/]|       # asterisks that do not end this comment
-          /(?=\*/)      # single slash before this comment's end
-         )*
+          [\s\S]*?         # any char, repeated lazily
+         )
            \*/               # the End of this comment
            |[ \t\r\n]+       # whitespaces: space, horizontal tab, lf, cr
         )+
@@ -70,12 +67,16 @@ module JSON
       # * *create_additions*: If set to true, the Parser creates
       #   additions when a matching class and create_id are found. This
       #   option defaults to false.
-      # * *object_class*: Defaults to Hash
-      # * *array_class*: Defaults to Array
+      # * *object_class*: Defaults to Hash. If another type is provided, it will be used
+      #   instead of Hash to represent JSON objects. The type must respond to
+      #   +new+ without arguments, and return an object that respond to +[]=+.
+      # * *array_class*: Defaults to Array If another type is provided, it will be used
+      #   instead of Hash to represent JSON arrays. The type must respond to
+      #   +new+ without arguments, and return an object that respond to +<<+.
       # * *decimal_class*: Specifies which class to use instead of the default
       #    (Float) when parsing decimal numbers. This class must accept a single
       #    string argument in its constructor.
-      def initialize(source, opts = {})
+      def initialize(source, opts = nil)
         opts ||= {}
         source = convert_encoding source
         super source
@@ -160,11 +161,6 @@ module JSON
         ?u  => nil,
       })
 
-      EMPTY_8BIT_STRING = ''
-      if ::String.method_defined?(:encode)
-        EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
-      end
-
       STR_UMINUS = ''.respond_to?(:-@)
       def parse_string
         if scan(STRING)
@@ -173,18 +169,16 @@ module JSON
             if u = UNESCAPE_MAP[$&[1]]
               u
             else # \uXXXX
-              bytes = EMPTY_8BIT_STRING.dup
+              bytes = ''.b
               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.iconv('utf-8', 'utf-16be', bytes).force_encoding(::Encoding::ASCII_8BIT)
+              bytes.encode(Encoding::UTF_8, Encoding::UTF_16BE).force_encoding(::Encoding::BINARY)
             end
           end
-          if string.respond_to?(:force_encoding)
-            string.force_encoding(::Encoding::UTF_8)
-          end
+          string.force_encoding(::Encoding::UTF_8)
 
           if @freeze
             if STR_UMINUS

data/lib/json/pure.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'json/common'
 
 module JSON

data/lib/json/version.rb

@@ -1,9 +1,5 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
+
 module JSON
-  # JSON version
-  VERSION         = '2.7.1'
-  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
-  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
-  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
-  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+  VERSION = '2.7.3'
 end

data/lib/json.rb

@@ -1,4 +1,4 @@
-#frozen_string_literal: false
+# frozen_string_literal: true
 require 'json/common'
 
 ##

metadata

@@ -1,22 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: json
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 2.7.3
 platform: java
 authors:
 - Daniel Luz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-05 00:00:00.000000000 Z
+date: 2024-10-24 00:00:00.000000000 Z
 dependencies: []
 description: A JSON implementation as a JRuby extension.
 email: dev+ruby@mernen.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
-- LICENSE
+- BSDL
+- CHANGES.md
+- COPYING
+- LEGAL
+- README.md
+- json.gemspec
 - lib/json.rb
 - lib/json/add/bigdecimal.rb
 - lib/json/add/complex.rb
@@ -34,25 +40,28 @@ 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/ext/generator/state.rb
 - lib/json/generic_object.rb
 - lib/json/pure.rb
 - lib/json/pure/generator.rb
 - lib/json/pure/parser.rb
 - lib/json/version.rb
-homepage: https://flori.github.io/json
+homepage: https://ruby.github.io/json
 licenses:
 - Ruby
 metadata:
-  bug_tracker_uri: https://github.com/flori/json/issues
-  changelog_uri: https://github.com/flori/json/blob/master/CHANGES.md
-  documentation_uri: https://flori.github.io/json/doc/index.html
-  homepage_uri: https://flori.github.io/json
-  source_code_uri: https://github.com/flori/json
-  wiki_uri: https://github.com/flori/json/wiki
+  bug_tracker_uri: https://github.com/ruby/json/issues
+  changelog_uri: https://github.com/ruby/json/blob/master/CHANGES.md
+  documentation_uri: https://ruby.github.io/json/doc/index.html
+  homepage_uri: https://ruby.github.io/json
+  source_code_uri: https://github.com/ruby/json
+  wiki_uri: https://github.com/ruby/json/wiki
 post_install_message:
-rdoc_options: []
+rdoc_options:
+- "--title"
+- JSON implementation for Ruby
+- "--main"
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement