json 2.9.1-java → 2.10.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fbe500aeaaee4ca7ecdd33333c6867ecaa7f4dabbfb7ee0dd951009650494ec
-  data.tar.gz: 6faa1e8eb9a2cc5f98c01bfc26d2b0b84e814455e7f6829bfd3b617181078650
+  metadata.gz: 7c1c1f77de7b4d11ae341c57e478018a4e4099df04a747de675a96d04c9b34a8
+  data.tar.gz: 3371f68faaf2fc0e463f8832dfec85a159abff5006b339d2012c5cb901cdbeda
 SHA512:
-  metadata.gz: 95285612fa42036d37652f18239c85ed51550d6fd87bd5eccc78a13cccd68f687d1ed915d30d46bff3b5b5fd9bf3f9fee5fe6cfd498a1fdbc89f8d657b62966a
-  data.tar.gz: f08899fdf14ef2d8e5e8693176394763becce85f2d735f7961c0ed37862315bc67f421439c978a8785609dcb0790112122021af10f25efc428a2bba1637970bd
+  metadata.gz: ac182ab8e520d417bfc69535d640f928aebae3c9c3481c650074445b5f41b721a753e9aa34b32099e2d67e219cb9b5c979dd34873ce77902d776e8929472069f
+  data.tar.gz: 26c1acf79a62ad24214dffbd47804b42a4a6e4952b26aab27247607c23fe09d20cfb43e53b909d709fd89288bf70e8797f2a53db35b87691d44c2adbdea5dbd2

data/CHANGES.md

@@ -1,5 +1,12 @@
 # Changes
 
+### 2025-02-10 (2.10.0)
+
+* `strict: true` now accept symbols as values. Previously they'd only be accepted as hash keys.
+* The C extension Parser has been entirely reimplemented from scratch.
+* Introduced `JSON::Coder` as a new API allowing to customize how non native types are serialized in a non-global way.
+* The Java implementation of the generator received many optimizations.
+
 ### 2024-12-18 (2.9.1)
 
 * Fix support for Solaris 10.

data/LEGAL

@@ -6,55 +6,3 @@
 All the files in this distribution are covered under either the Ruby's
 license (see the file COPYING) or public-domain except some files
 mentioned below.
-
-== MIT License
->>>
-      Permission is hereby granted, free of charge, to any person obtaining
-      a copy of this software and associated documentation files (the
-      "Software"), to deal in the Software without restriction, including
-      without limitation the rights to use, copy, modify, merge, publish,
-      distribute, sublicense, and/or sell copies of the Software, and to
-      permit persons to whom the Software is furnished to do so, subject to
-      the following conditions:
-
-      The above copyright notice and this permission notice shall be
-      included in all copies or substantial portions of the Software.
-
-      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-      EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-      NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-      LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-      OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-      WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-== Old-style BSD license
->>>
-      Redistribution and use in source and binary forms, with or without
-      modification, are permitted provided that the following conditions
-      are met:
-      1. Redistributions of source code must retain the above copyright
-         notice, this list of conditions and the following disclaimer.
-      2. Redistributions in binary form must reproduce the above copyright
-         notice, this list of conditions and the following disclaimer in the
-         documentation and/or other materials provided with the distribution.
-      3. Neither the name of the University nor the names of its contributors
-         may be used to endorse or promote products derived from this software
-         without specific prior written permission.
-
-      THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
-      ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-      IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-      ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
-      FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-      DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-      OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-      OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-      SUCH DAMAGE.
-
-      IMPORTANT NOTE::
-
-      From ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change
-      paragraph 3 above is now null and void.

data/README.md

@@ -29,7 +29,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install json
 
-## Usage
+## Basic Usage
 
 To use JSON you can
 
@@ -52,7 +52,80 @@ You can also use the `pretty_generate` method (which formats the output more
 verbosely and nicely) or `fast_generate` (which doesn't do any of the security
 checks generate performs, e. g. nesting deepness checks).
 
-## Handling arbitrary types
+## Casting non native types
+
+JSON documents can only support Hashes, Arrays, Strings, Integers and Floats.
+
+By default if you attempt to serialize something else, `JSON.generate` will
+search for a `#to_json` method on that object:
+
+```ruby
+Position = Struct.new(:latitude, :longitude) do
+  def to_json(state = nil, *)
+    JSON::State.from_state(state).generate({
+      latitude: latitude,
+      longitude: longitude,
+    })
+  end
+end
+
+JSON.generate([
+  Position.new(12323.234, 435345.233),
+  Position.new(23434.676, 159435.324),
+]) # => [{"latitude":12323.234,"longitude":435345.233},{"latitude":23434.676,"longitude":159435.324}]
+```
+
+If a `#to_json` method isn't defined on the object, `JSON.generate` will fallback to call `#to_s`:
+
+```ruby
+JSON.generate(Object.new) # => "#<Object:0x000000011e768b98>"
+```
+
+Both of these behavior can be disabled using the `strict: true` option:
+
+```ruby
+JSON.generate(Object.new, strict: true) # => Object not allowed in JSON (JSON::GeneratorError)
+JSON.generate(Position.new(1, 2)) # => Position not allowed in JSON (JSON::GeneratorError)
+```
+
+## JSON::Coder
+
+Since `#to_json` methods are global, it can sometimes be problematic if you need a given type to be
+serialized in different ways in different locations.
+
+Instead it is recommended to use the newer `JSON::Coder` API:
+
+```ruby
+module MyApp
+  API_JSON_CODER = JSON::Coder.new do |object|
+    case object
+    when Time
+      object.iso8601(3)
+    else
+      object
+    end
+  end
+end
+
+puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z"
+```
+
+The provided block is called for all objects that don't have a native JSON equivalent, and
+must return a Ruby object that has a native JSON equivalent.
+
+## Combining JSON fragments
+
+To combine JSON fragments into a bigger JSON document, you can use `JSON::Fragment`:
+
+```ruby
+posts_json = cache.fetch_multi(post_ids) do |post_id|
+  JSON.generate(Post.find(post_id))
+end
+posts_json.map! { |post_json| JSON::Fragment.new(post_json) }
+JSON.generate({ posts: posts_json, count: posts_json.count })
+```
+
+## Round-tripping arbitrary types
 
 > [!CAUTION]
 > You should never use `JSON.unsafe_load` nor `JSON.parse(str, create_additions: true)` to parse untrusted user input,

data/json.gemspec

@@ -11,14 +11,13 @@ spec = Gem::Specification.new do |s|
   s.version = version
 
   s.summary = "JSON Implementation for Ruby"
-  s.homepage = "https://ruby.github.io/json"
+  s.homepage = "https://github.com/ruby/json"
   s.metadata = {
     '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',
+    'documentation_uri' => 'https://docs.ruby-lang.org/en/master/JSON.html',
     'homepage_uri'      => s.homepage,
     'source_code_uri'   => 'https://github.com/ruby/json',
-    'wiki_uri'          => 'https://github.com/ruby/json/wiki'
   }
 
   s.required_ruby_version = Gem::Requirement.new(">= 2.7")
@@ -53,7 +52,7 @@ spec = Gem::Specification.new do |s|
     s.files += Dir["lib/json/ext/**/*.jar"]
   else
     s.extensions = Dir["ext/json/**/extconf.rb"]
-    s.files += Dir["ext/json/**/*.{c,h,rl}"]
+    s.files += Dir["ext/json/**/*.{c,h}"]
   end
 end
 

data/lib/json/add/symbol.rb

@@ -36,8 +36,13 @@ class Symbol
   #
   #   # {"json_class":"Symbol","s":"foo"}
   #
-  def to_json(*a)
-    as_json.to_json(*a)
+  def to_json(state = nil, *a)
+    state = ::JSON::State.from_state(state)
+    if state.strict?
+      super
+    else
+      as_json.to_json(state, *a)
+    end
   end
 
   # See #as_json.

data/lib/json/common.rb

@@ -167,6 +167,30 @@ module JSON
   # system. Usually this means that the iconv library is not installed.
   class MissingUnicodeSupport < JSONError; end
 
+  # Fragment of JSON document that is to be included as is:
+  #   fragment = JSON::Fragment.new("[1, 2, 3]")
+  #   JSON.generate({ count: 3, items: fragments })
+  #
+  # This allows to easily assemble multiple JSON fragments that have
+  # been persisted somewhere without having to parse them nor resorting
+  # to string interpolation.
+  #
+  # Note: no validation is performed on the provided string. It is the
+  # responsability of the caller to ensure the string contains valid JSON.
+  Fragment = Struct.new(:json) do
+    def initialize(json)
+      unless string = String.try_convert(json)
+        raise TypeError, " no implicit conversion of #{json.class} into String"
+      end
+
+      super(string)
+    end
+
+    def to_json(state = nil, *)
+      json
+    end
+  end
+
   module_function
 
   # :call-seq:
@@ -232,12 +256,13 @@ module JSON
   # - Option +max_nesting+, if not provided, defaults to +false+,
   #   which disables checking for nesting depth.
   # - Option +allow_nan+, if not provided, defaults to +true+.
-  def parse!(source, opts = {})
-    opts = {
+  def parse!(source, opts = nil)
+    options = {
       :max_nesting  => false,
       :allow_nan    => true
-    }.merge(opts)
-    Parser.new(source, **(opts||{})).parse
+    }
+    options.merge!(opts) if opts
+    Parser.new(source, options).parse
   end
 
   # :call-seq:
@@ -258,7 +283,7 @@ module JSON
   #   JSON.parse!(File.read(path, opts))
   #
   # See method #parse!
-  def load_file!(filespec, opts = {})
+  def load_file!(filespec, opts = nil)
     parse!(File.read(filespec, encoding: Encoding::UTF_8), opts)
   end
 
@@ -818,11 +843,7 @@ module JSON
     opts = merge_dump_options(opts, **kwargs) if kwargs
 
     begin
-      if State === opts
-        opts.generate(obj, anIO)
-      else
-        State.generate(obj, opts, anIO)
-      end
+      State.generate(obj, opts, anIO)
     rescue JSON::NestingError
       raise ArgumentError, "exceed depth limit"
     end
@@ -841,6 +862,82 @@ module JSON
   class << self
     private :merge_dump_options
   end
+
+  # JSON::Coder holds a parser and generator configuration.
+  #
+  #   module MyApp
+  #     JSONC_CODER = JSON::Coder.new(
+  #       allow_trailing_comma: true
+  #     )
+  #   end
+  #
+  #   MyApp::JSONC_CODER.load(document)
+  #
+  class Coder
+    # :call-seq:
+    #   JSON.new(options = nil, &block)
+    #
+    # Argument +options+, if given, contains a \Hash of options for both parsing and generating.
+    # See {Parsing Options}[#module-JSON-label-Parsing+Options], and {Generating Options}[#module-JSON-label-Generating+Options].
+    #
+    # For generation, the <tt>strict: true</tt> option is always set. When a Ruby object with no native \JSON counterpart is
+    # encoutered, the block provided to the initialize method is invoked, and must return a Ruby object that has a native
+    # \JSON counterpart:
+    #
+    #  module MyApp
+    #    API_JSON_CODER = JSON::Coder.new do |object|
+    #      case object
+    #      when Time
+    #        object.iso8601(3)
+    #      else
+    #        object # Unknown type, will raise
+    #      end
+    #    end
+    #  end
+    #
+    #  puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z"
+    #
+    def initialize(options = nil, &as_json)
+      if options.nil?
+        options = { strict: true }
+      else
+        options = options.dup
+        options[:strict] = true
+      end
+      options[:as_json] = as_json if as_json
+      options[:create_additions] = false unless options.key?(:create_additions)
+
+      @state = State.new(options).freeze
+      @parser_config = Ext::Parser::Config.new(options)
+    end
+
+    # call-seq:
+    #   dump(object) -> String
+    #   dump(object, io) -> io
+    #
+    # Serialize the given object into a \JSON document.
+    def dump(object, io = nil)
+      @state.generate_new(object, io)
+    end
+    alias_method :generate, :dump
+
+    # call-seq:
+    #   load(string) -> Object
+    #
+    # Parse the given \JSON document and return an equivalent Ruby object.
+    def load(source)
+      @parser_config.parse(source)
+    end
+    alias_method :parse, :load
+
+    # call-seq:
+    #   load(path) -> Object
+    #
+    # Parse the given \JSON document and return an equivalent Ruby object.
+    def load_file(path)
+      load(File.read(path, encoding: Encoding::UTF_8))
+    end
+  end
 end
 
 module ::Kernel

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

@@ -47,17 +47,6 @@ module JSON
 
         alias_method :merge, :configure
 
-        # call-seq:
-        #   generate(obj) -> String
-        #   generate(obj, anIO) -> anIO
-        #
-        # 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, io = nil)
-          _generate(obj, io)
-        end
-
         # call-seq: to_h
         #
         # Returns the configuration instance variables as a hash, that can be
@@ -69,6 +58,7 @@ module JSON
             space_before: space_before,
             object_nl: object_nl,
             array_nl: array_nl,
+            as_json: as_json,
             allow_nan: allow_nan?,
             ascii_only: ascii_only?,
             max_nesting: max_nesting,

data/lib/json/ext.rb

@@ -6,15 +6,37 @@ module JSON
   # This module holds all the modules/classes that implement JSON's
   # functionality as C extensions.
   module Ext
+    class Parser
+      class << self
+        def parse(...)
+          new(...).parse
+        end
+        alias_method :parse, :parse # Allow redefinition by extensions
+      end
+
+      def initialize(source, opts = nil)
+        @source = source
+        @config = Config.new(opts)
+      end
+
+      def source
+        @source.dup
+      end
+
+      def parse
+        @config.parse(@source)
+      end
+    end
+
+    require 'json/ext/parser'
+    Ext::Parser::Config = Ext::ParserConfig
+    JSON.parser = Ext::Parser
+
     if RUBY_ENGINE == 'truffleruby'
-      require 'json/ext/parser'
       require 'json/truffle_ruby/generator'
-      JSON.parser = Parser
       JSON.generator = ::JSON::TruffleRuby::Generator
     else
-      require 'json/ext/parser'
       require 'json/ext/generator'
-      JSON.parser = Parser
       JSON.generator = Generator
     end
   end

data/lib/json/truffle_ruby/generator.rb

@@ -39,30 +39,33 @@ module JSON
         '\\'  =>  '\\\\',
       }.freeze # :nodoc:
 
-      ESCAPE_PATTERN = /[\/"\\\x0-\x1f]/n # :nodoc:
-
       SCRIPT_SAFE_MAP = MAP.merge(
         '/'  =>  '\\/',
-        "\u2028".b => '\u2028',
-        "\u2029".b => '\u2029',
+        "\u2028" => '\u2028',
+        "\u2029" => '\u2029',
       ).freeze
 
-      SCRIPT_SAFE_ESCAPE_PATTERN = Regexp.union(ESCAPE_PATTERN, "\u2028".b, "\u2029".b)
+      SCRIPT_SAFE_ESCAPE_PATTERN = /[\/"\\\x0-\x1f\u2028-\u2029]/
 
       # 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.b
+      def self.utf8_to_json(string, script_safe = false) # :nodoc:
         if script_safe
-          string.gsub!(SCRIPT_SAFE_ESCAPE_PATTERN) { SCRIPT_SAFE_MAP[$&] || $& }
+          if SCRIPT_SAFE_ESCAPE_PATTERN.match?(string)
+            string.gsub(SCRIPT_SAFE_ESCAPE_PATTERN, SCRIPT_SAFE_MAP)
+          else
+            string
+          end
         else
-          string.gsub!(ESCAPE_PATTERN) { MAP[$&] || $& }
+          if /["\\\x0-\x1f]/.match?(string)
+            string.gsub(/["\\\x0-\x1f]/, MAP)
+          else
+            string
+          end
         end
-        string.force_encoding(::Encoding::UTF_8)
-        string
       end
 
-      def utf8_to_json_ascii(original_string, script_safe = false) # :nodoc:
+      def self.utf8_to_json_ascii(original_string, script_safe = false) # :nodoc:
         string = original_string.b
         map = script_safe ? SCRIPT_SAFE_MAP : MAP
         string.gsub!(/[\/"\\\x0-\x1f]/n) { map[$&] || $& }
@@ -86,24 +89,17 @@ module JSON
         raise GeneratorError.new(e.message, original_string)
       end
 
-      def valid_utf8?(string)
+      def self.valid_utf8?(string)
         encoding = string.encoding
         (encoding == Encoding::UTF_8 || encoding == Encoding::ASCII) &&
           string.valid_encoding?
       end
-      module_function :utf8_to_json, :utf8_to_json_ascii, :valid_utf8?
 
       # This class is used to create State instances, that are use to hold data
       # while generating a JSON text from a Ruby data structure.
       class State
         def self.generate(obj, opts = nil, io = nil)
-          string = new(opts).generate(obj)
-          if io
-            io.write(string)
-            io
-          else
-            string
-          end
+          new(opts).generate(obj, io)
         end
 
         # Creates a State object from _opts_, which ought to be Hash to create
@@ -111,16 +107,17 @@ module JSON
         # an unconfigured instance. If _opts_ is a State object, it is just
         # returned.
         def self.from_state(opts)
-          case
-          when self === opts
-            opts
-          when opts.respond_to?(:to_hash)
-            new(opts.to_hash)
-          when opts.respond_to?(:to_h)
-            new(opts.to_h)
-          else
-            SAFE_STATE_PROTOTYPE.dup
+          if opts
+            case
+            when self === opts
+              return opts
+            when opts.respond_to?(:to_hash)
+              return new(opts.to_hash)
+            when opts.respond_to?(:to_h)
+              return new(opts.to_h)
+            end
           end
+          SAFE_STATE_PROTOTYPE.dup
         end
 
         # Instantiates a new State object, configured by _opts_.
@@ -148,6 +145,7 @@ module JSON
           @array_nl              = ''
           @allow_nan             = false
           @ascii_only            = false
+          @as_json               = false
           @depth                 = 0
           @buffer_initial_length = 1024
           @script_safe           = false
@@ -173,6 +171,9 @@ module JSON
         # This string is put at the end of a line that holds a JSON array.
         attr_accessor :array_nl
 
+        # This proc converts unsupported types into native JSON types.
+        attr_accessor :as_json
+
         # 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
@@ -257,6 +258,7 @@ module JSON
           @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)
+          @as_json               = opts[:as_json].to_proc     if opts.key?(:as_json)
           @ascii_only            = opts[:ascii_only]          if opts.key?(:ascii_only)
           @depth                 = opts[:depth] || 0
           @buffer_initial_length ||= opts[:buffer_initial_length]
@@ -299,9 +301,9 @@ module JSON
         # returns the result. If no valid JSON document can be
         # created this method raises a
         # GeneratorError exception.
-        def generate(obj)
+        def generate(obj, anIO = nil)
           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
+              !@ascii_only and !@script_safe and @max_nesting == 0 and (!@strict || Symbol === obj)
             result = generate_json(obj, ''.dup)
           else
             result = obj.to_json(self)
@@ -310,7 +312,16 @@ module JSON
             "source sequence #{result.inspect} is illegal/malformed utf-8",
             obj
           )
-          result
+          if anIO
+            anIO.write(result)
+            anIO
+          else
+            result
+          end
+        end
+
+        def generate_new(obj, anIO = nil) # :nodoc:
+          dup.generate(obj, anIO)
         end
 
         # Handles @allow_nan, @buffer_initial_length, other ivars must be the default value (see above)
@@ -353,6 +364,12 @@ module JSON
             end
           when Integer
             buf << obj.to_s
+          when Symbol
+            if @strict
+              fast_serialize_string(obj.name, buf)
+            else
+              buf << obj.to_json(self)
+            end
           else
             # Note: Float is handled this way since Float#to_s is slow anyway
             buf << obj.to_json(self)
@@ -371,8 +388,8 @@ module JSON
           end
           raise GeneratorError.new("source sequence is illegal/malformed utf-8", string) unless string.valid_encoding?
 
-          if /["\\\x0-\x1f]/n.match?(string)
-            buf << string.gsub(/["\\\x0-\x1f]/n, MAP)
+          if /["\\\x0-\x1f]/.match?(string)
+            buf << string.gsub(/["\\\x0-\x1f]/, MAP)
           else
             buf << string
           end
@@ -404,8 +421,20 @@ module JSON
           # 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(state = nil, *)
-            if state && State.from_state(state).strict?
-              raise GeneratorError.new("#{self.class} not allowed in JSON", self)
+            state = State.from_state(state) if state
+            if state&.strict?
+              value = self
+              if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value)
+                if state.as_json
+                  value = state.as_json.call(value)
+                  unless false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value
+                    raise GeneratorError.new("#{value.class} returned by #{state.as_json} not allowed in JSON", value)
+                  end
+                  value.to_json(state)
+                else
+                  raise GeneratorError.new("#{value.class} not allowed in JSON", value)
+                end
+              end
             else
               to_s.to_json
             end
@@ -455,8 +484,16 @@ module JSON
               end
 
               result = +"#{result}#{key_json}#{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.new("#{value.class} not allowed in JSON", value)
+              if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value)
+                if state.as_json
+                  value = state.as_json.call(value)
+                  unless false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value
+                    raise GeneratorError.new("#{value.class} returned by #{state.as_json} not allowed in JSON", value)
+                  end
+                  result << value.to_json(state)
+                else
+                  raise GeneratorError.new("#{value.class} not allowed in JSON", value)
+                end
               elsif value.respond_to?(:to_json)
                 result << value.to_json(state)
               else
@@ -508,8 +545,16 @@ module JSON
             each { |value|
               result << delim unless first
               result << state.indent * depth if indent
-              if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value)
-                raise GeneratorError.new("#{value.class} not allowed in JSON", value)
+              if state.strict? && !(false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value || Symbol == value)
+                if state.as_json
+                  value = state.as_json.call(value)
+                  unless false == value || true == value || nil == value || String === value || Array === value || Hash === value || Integer === value || Float === value || Fragment === value || Symbol === value
+                    raise GeneratorError.new("#{value.class} returned by #{state.as_json} not allowed in JSON", value)
+                  end
+                  result << value.to_json(state)
+                else
+                  raise GeneratorError.new("#{value.class} not allowed in JSON", value)
+                end
               elsif value.respond_to?(:to_json)
                 result << value.to_json(state)
               else
@@ -531,18 +576,23 @@ module JSON
 
         module Float
           # Returns a JSON string representation for this Float number.
-          def to_json(state = nil, *)
+          def to_json(state = nil, *args)
             state = State.from_state(state)
-            case
-            when infinite?
-              if state.allow_nan?
-                to_s
-              else
-                raise GeneratorError.new("#{self} not allowed in JSON", self)
-              end
-            when nan?
+            if infinite? || nan?
               if state.allow_nan?
                 to_s
+              elsif state.strict? && state.as_json
+                casted_value = state.as_json.call(self)
+
+                if casted_value.equal?(self)
+                  raise GeneratorError.new("#{self} not allowed in JSON", self)
+                end
+
+                state.check_max_nesting
+                state.depth += 1
+                result = casted_value.to_json(state, *args)
+                state.depth -= 1
+                result
               else
                 raise GeneratorError.new("#{self} not allowed in JSON", self)
               end
@@ -552,6 +602,17 @@ module JSON
           end
         end
 
+        module Symbol
+          def to_json(state = nil, *args)
+            state = State.from_state(state)
+            if state.strict?
+              name.to_json(state, *args)
+            else
+              super
+            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

data/lib/json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSON
-  VERSION = '2.9.1'
+  VERSION = '2.10.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json
 version: !ruby/object:Gem::Version
-  version: 2.9.1
+  version: 2.10.0
 platform: java
 authors:
 - Daniel Luz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-18 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies: []
 description: A JSON implementation as a JRuby extension.
 email: dev+ruby@mernen.com
@@ -46,16 +46,15 @@ files:
 - lib/json/generic_object.rb
 - lib/json/truffle_ruby/generator.rb
 - lib/json/version.rb
-homepage: https://ruby.github.io/json
+homepage: https://github.com/ruby/json
 licenses:
 - Ruby
 metadata:
   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
+  documentation_uri: https://docs.ruby-lang.org/en/master/JSON.html
+  homepage_uri: https://github.com/ruby/json
   source_code_uri: https://github.com/ruby/json
-  wiki_uri: https://github.com/ruby/json/wiki
 post_install_message:
 rdoc_options:
 - "--title"