json 2.9.0 → 2.10.0

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.0'
+  VERSION = '2.10.0'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: json
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Florian Frank
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-03 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies: []
 description: This is a JSON implementation as a Ruby extension in C.
 email: flori@ping.de
@@ -29,7 +28,6 @@ files:
 - ext/json/ext/generator/generator.c
 - ext/json/ext/parser/extconf.rb
 - ext/json/ext/parser/parser.c
-- ext/json/ext/parser/parser.rl
 - json.gemspec
 - lib/json.rb
 - lib/json/add/bigdecimal.rb
@@ -52,17 +50,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"
 - JSON implementation for Ruby
@@ -81,8 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: JSON Implementation for Ruby
 test_files: []