json 3.0.1 → 3.1.0

data/ext/json/ext/parser/parser.c

@@ -20,9 +20,9 @@ static int utf8_encindex;
 #ifndef HAVE_RB_HASH_BULK_INSERT
 // For TruffleRuby
 static void
-rb_hash_bulk_insert(long count, const VALUE *pairs, VALUE hash)
+rb_hash_bulk_insert(rb_len_t count, const VALUE *pairs, VALUE hash)
 {
-    long index = 0;
+    rb_len_t index = 0;
     while (index < count) {
         VALUE name = pairs[index++];
         VALUE value = pairs[index++];
@@ -79,7 +79,7 @@ static rb_encoding *enc_utf8;
 
 #define JSON_RVALUE_CACHE_MAX_ENTRY_LENGTH 55
 
-static inline VALUE build_interned_string(const char *str, const long length)
+static inline VALUE build_interned_string(const char *str, const rb_len_t length)
 {
 # ifdef HAVE_RB_ENC_INTERNED_STR
     return rb_enc_interned_str(str, length, enc_utf8);
@@ -89,7 +89,7 @@ static inline VALUE build_interned_string(const char *str, const long length)
 # endif
 }
 
-static inline VALUE build_symbol(const char *str, const long length)
+static inline VALUE build_symbol(const char *str, const rb_len_t length)
 {
     return rb_str_intern(build_interned_string(str, length));
 }
@@ -138,7 +138,7 @@ ALWAYS_INLINE(static) int rstring_cache_memcmp(const char *str, const char *rptr
 ALWAYS_INLINE(static) int rstring_cache_cmp(const char *str, const long length, VALUE rstring)
 {
     const char *rstring_ptr;
-    long rstring_length;
+    rb_len_t rstring_length;
 
     RSTRING_GETMEM(rstring, rstring_ptr, rstring_length);
 
@@ -323,14 +323,17 @@ static const rb_data_type_t JSON_Parser_rvalue_stack_type = {
 static rvalue_stack *rvalue_stack_spill(rvalue_stack *old_stack, VALUE *handle, rvalue_stack **stack_ref)
 {
     rvalue_stack *stack;
-    *handle = TypedData_Make_Struct(0, rvalue_stack, &JSON_Parser_rvalue_stack_type, stack);
-    *stack_ref = stack;
+    VALUE stack_handle = TypedData_Make_Struct(0, rvalue_stack, &JSON_Parser_rvalue_stack_type, stack);
     MEMCPY(stack, old_stack, rvalue_stack, 1);
 
     stack->capa = old_stack->capa << 1;
     stack->ptr = ALLOC_N(VALUE, stack->capa);
     stack->type = RVALUE_STACK_HEAP_ALLOCATED;
     MEMCPY(stack->ptr, old_stack->ptr, VALUE, old_stack->head);
+
+    *handle = stack_handle;
+    *stack_ref = stack;
+
     return stack;
 }
 
@@ -580,7 +583,7 @@ static inline char peek(JSON_ParserState *state)
     return *state->cursor;
 }
 
-static void cursor_position(JSON_ParserState *state, long *line_out, long *column_out)
+static void cursor_position(JSON_ParserState *state, long *line_out, rb_len_t *column_out)
 {
     JSON_ASSERT(!state->parser);
     JSON_ASSERT(state->cursor);
@@ -592,19 +595,15 @@ static void cursor_position(JSON_ParserState *state, long *line_out, long *colum
     }
 
     const char *cursor = state->cursor;
-    long column = 0;
     long line = 1;
 
-    while (cursor >= state->start) {
-        if (*cursor-- == '\n') {
-            line++;
-            break;
-        }
-        column++;
+    while (cursor > state->start && cursor[-1] != '\n') {
+        cursor--;
     }
+    rb_len_t column = rb_enc_strlen(cursor, state->cursor, enc_utf8) + 1;
 
-    while (cursor >= state->start) {
-        if (*cursor-- == '\n') {
+    while (cursor > state->start) {
+        if (*--cursor == '\n') {
             line++;
         }
     }
@@ -631,17 +630,15 @@ static VALUE build_parse_error_message(const char *format, JSON_ParserState *sta
         }
 
         if (len) {
-            buffer[0] = '\'';
-            MEMCPY(buffer + 1, ptr, char, len);
-
-            while (buffer[len] >= 0x80 && buffer[len] < 0xC0) { // Is continuation byte
-                len--;
-            }
-
-            if (buffer[len] >= 0xC0) { // multibyte character start
-                len--;
+            if (len == PARSE_ERROR_FRAGMENT_LEN) {
+                // Only trim when the byte limit splits a multibyte character.
+                while (len && (unsigned char)ptr[len] >= 0x80 && (unsigned char)ptr[len] < 0xC0) {
+                    len--;
+                }
             }
 
+            buffer[0] = '\'';
+            MEMCPY(buffer + 1, ptr, char, len);
             buffer[len + 1] = '\'';
             buffer[len + 2] = '\0';
             ptr = (const char *)buffer;
@@ -681,11 +678,11 @@ static VALUE json_path_new(JSON_ParserState *state, VALUE duplicate_key)
     return path;
 }
 
-static VALUE parse_error_new(JSON_ParserState *state, VALUE message, long line, long column, bool eos)
+static VALUE parse_error_new(JSON_ParserState *state, VALUE message, long line, rb_len_t column, bool eos)
 {
     VALUE exc = rb_exc_new_str(eParserError, message);
     rb_ivar_set(exc, i_at_line, LONG2NUM(line));
-    rb_ivar_set(exc, i_at_column, LONG2NUM(column));
+    rb_ivar_set(exc, i_at_column, LEN2NUM(column));
     rb_ivar_set(exc, i_at_json_path, json_path_new(state, Qundef));
     return exc;
 }
@@ -703,9 +700,10 @@ NORETURN(static) void raise_parse_error(const char *format, JSON_ParserState *st
         }
     } else {
         VALUE message = build_parse_error_message(format, state);
-        long line, column;
+        long line;
+        rb_len_t column;
         cursor_position(state, &line, &column);
-        rb_str_catf(message, " at line %ld column %ld", line, column);
+        rb_str_catf(message, " at line %ld column %"PRIdLEN, line, column);
         rb_exc_raise(parse_error_new(state, message, line, column, eos));
     }
 }
@@ -758,7 +756,7 @@ static const signed char digit_values[256] = {
 static uint32_t unescape_unicode(JSON_ParserState *state, const char *sp, const char *spe)
 {
     if (RB_UNLIKELY(sp > spe - 4)) {
-        raise_eos_error_at("incomplete unicode character escape sequence at %s", state, sp - 2);
+        raise_syntax_error_at("incomplete unicode character escape sequence at %s", state, sp - 2);
     }
 
     const unsigned char *p = (const unsigned char *)sp;
@@ -895,12 +893,12 @@ static inline VALUE build_string(const char *start, const char *end, bool intern
     VALUE result;
 # ifdef HAVE_RB_ENC_INTERNED_STR
     if (intern) {
-      result = rb_enc_interned_str(start, (long)(end - start), enc_utf8);
+      result = rb_enc_interned_str(start, (rb_len_t)(end - start), enc_utf8);
     } else {
-      result = rb_utf8_str_new(start, (long)(end - start));
+      result = rb_utf8_str_new(start, (rb_len_t)(end - start));
     }
 # else
-    result = rb_utf8_str_new(start, (long)(end - start));
+    result = rb_utf8_str_new(start, (rb_len_t)(end - start));
     if (intern) {
         result = rb_funcall(rb_str_freeze(result), i_uminus, 0);
     }
@@ -1051,13 +1049,13 @@ NOINLINE(static) VALUE json_string_unescape(JSON_ParserState *state, JSON_Parser
                 p = ++pe;
                 break;
             }
-            case 0:
-              return Qundef;
             default:
                 if ((unsigned char)*pe < 0x20) {
                     if (!config->allow_control_characters) {
                         if (*pe == '\n') {
                             raise_syntax_error_at("Invalid unescaped newline character (\\n) in string: %s", state, pe - 1);
+                        } else if (*pe == '\0') {
+                            raise_syntax_error_at("Invalid unescaped NULL character (\\0) in string: %s", state, pe - 1);
                         }
                         raise_syntax_error_at("invalid ASCII control character in string: %s", state, pe - 1);
                     }
@@ -1094,7 +1092,7 @@ NOINLINE(static) VALUE json_string_unescape(JSON_ParserState *state, JSON_Parser
 
 typedef VALUE (*json_number_decode_func_t)(const char *ptr);
 
-static inline VALUE json_decode_large_number(const char *start, long len, json_number_decode_func_t func)
+static inline VALUE json_decode_large_number(const char *start, rb_len_t len, json_number_decode_func_t func)
 {
     if (RB_LIKELY(len < MAX_NUMBER_STACK_BUFFER)) {
         char buffer[MAX_NUMBER_STACK_BUFFER];
@@ -1117,7 +1115,7 @@ static VALUE json_decode_inum(const char *buffer)
     return rb_cstr2inum(buffer, 10);
 }
 
-NOINLINE(static) VALUE json_decode_large_integer(const char *start, long len)
+NOINLINE(static) VALUE json_decode_large_integer(const char *start, rb_len_t len)
 {
     return json_decode_large_number(start, len, json_decode_inum);
 }
@@ -1158,7 +1156,7 @@ static VALUE json_decode_dnum(const char *buffer)
     return DBL2NUM(rb_cstr_to_dbl(buffer, 1));
 }
 
-NOINLINE(static) VALUE json_decode_large_float(const char *start, long len)
+NOINLINE(static) VALUE json_decode_large_float(const char *start, rb_len_t len)
 {
     return json_decode_large_number(start, len, json_decode_dnum);
 }
@@ -1174,11 +1172,11 @@ static inline VALUE json_decode_float(JSON_ParserConfig *config, uint64_t mantis
         return rb_funcallv(config->decimal_class, config->decimal_method_id, 1, &text);
     }
 
-    if (RB_UNLIKELY(exponent > INT32_MAX)) {
+    if (RB_UNLIKELY(exponent >= (int64_t)INT32_MAX)) {
         return negative ? CMinusInfinity : CInfinity;
     }
 
-    if (RB_UNLIKELY(exponent < INT32_MIN)) {
+    if (RB_UNLIKELY(exponent <= INT32_MIN)) {
         return rb_float_new(negative ? -0.0 : 0.0);
     }
 
@@ -1237,9 +1235,10 @@ NORETURN(static) void raise_duplicate_key_error(JSON_ParserState *state, VALUE d
     if (state->parser) { // line and columns can't be accurate in resumable
         exc = parse_error_new(state, message, 0, 0, false);
     } else {
-        long line, column;
+        long line;
+        rb_len_t column;
         cursor_position(state, &line, &column);
-        rb_str_catf(message, " at line %ld column %ld", line, column);
+        rb_str_catf(message, " at line %ld column %"PRIdLEN, line, column);
         exc = parse_error_new(state, message, line, column, false);
     }
     rb_ivar_set(exc, i_at_json_path, json_path_new(state, duplicate_key));
@@ -1518,7 +1517,7 @@ static inline VALUE json_parse_number(JSON_ParserState *state, JSON_ParserConfig
         }
 
         if (RB_UNLIKELY(exponent_digits >= 20 || abs_exponent > (uint64_t)INT64_MAX)) {
-            exponent = negative_exponent ? INT64_MIN : INT64_MAX;
+            exponent = negative_exponent ? INT32_MIN : INT32_MAX;
         } else {
             exponent = negative_exponent ? -(int64_t)abs_exponent : (int64_t)abs_exponent;
         }
@@ -1815,7 +1814,7 @@ ALWAYS_INLINE(static) bool json_parse_any(JSON_ParserState *state, JSON_ParserCo
         if (RB_LIKELY(peek(state) == '"')) {
             VALUE string = json_parse_string(state, config, true);
             if (UNDEF_P(string)) {
-                if (resumable) {
+                if (resumable && eos(state)) {
                     state->cursor = start;
                     return false;
                 } else {
@@ -2021,7 +2020,15 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
     else if (key == sym_allow_invalid_escape)       { config->allow_invalid_escape = RTEST(val); }
     else if (key == sym_symbolize_names)            { config->symbolize_names = RTEST(val); }
     else if (key == sym_freeze)                     { config->freeze = RTEST(val); }
-    else if (key == sym_on_load)                    { parser_config_wb_write(self, &config->on_load_proc, RTEST(val) ? val : Qfalse); }
+    else if (key == sym_on_load)                    {
+        if (RTEST(val) && !rb_obj_is_proc(val)) {
+            val = rb_check_funcall(val, rb_intern("to_proc"), 0, NULL);
+            if (val == Qundef || !rb_obj_is_proc(val)) {
+                rb_raise(rb_eTypeError, "on_load must be a Proc");
+            }
+        }
+        parser_config_wb_write(self, &config->on_load_proc, RTEST(val) ? val : Qfalse);
+    }
     else if (key == sym_allow_duplicate_key)        { config->allow_duplicate_key = RTEST(val); }
     else if (key == sym_decimal_class)              {
         if (RTEST(val)) {
@@ -2041,8 +2048,8 @@ static int parser_config_init_i(VALUE key, VALUE val, VALUE data)
                     parser_config_wb_write(self, &config->decimal_class, rb_path_to_class(mod_path));
 
                     const char *method_name_beg = last_colon + 1;
-                    long before_len = method_name_beg - name_cstr;
-                    long len = RSTRING_LEN(name) - before_len;
+                    rb_len_t before_len = method_name_beg - name_cstr;
+                    rb_len_t len = RSTRING_LEN(name) - before_len;
                     VALUE method_name = rb_str_substr(name, before_len, len);
                     config->decimal_method_id = SYM2ID(rb_str_intern(method_name));
                 } else {
@@ -2109,9 +2116,7 @@ static VALUE cParser_parse(JSON_ParserConfig *config, VALUE src)
     // Ensure the string isn't mutated under us.
     // The classic API to use is `rb_str_locktmp`, but then we'd
     // need to use `rb_protect` to make sure we always unlock.
-    if (Vsource == src) {
-        Vsource = rb_str_new_frozen(Vsource);
-    }
+    Vsource = rb_str_new_frozen(Vsource);
 
     VALUE rvalue_stack_buffer[RVALUE_STACK_INITIAL_CAPA];
     rvalue_stack value_stack = {
@@ -2135,7 +2140,7 @@ static VALUE cParser_parse(JSON_ParserConfig *config, VALUE src)
         .head = 1,
     };
 
-    long len;
+    rb_len_t len;
     const char *start;
 
     RSTRING_GETMEM(Vsource, start, len);
@@ -2454,7 +2459,7 @@ static VALUE cResumableParser_feed(VALUE self, VALUE str)
         rb_str_append(parser->buffer, str);
     }
 
-    long len;
+    rb_len_t len;
     const char *start;
     RSTRING_GETMEM(parser->buffer, start, len);
     parser->state.start = start;
@@ -2760,7 +2765,7 @@ static VALUE cResumableParser_rest(VALUE self)
 
     size_t offset = parser->state.cursor - parser->state.start;
     const char *ptr;
-    long len;
+    rb_len_t len;
     RSTRING_GETMEM(parser->buffer, ptr, len);
     return rb_utf8_str_new(ptr + offset, len - offset);
 }

data/lib/json/common.rb

@@ -80,14 +80,6 @@ module JSON
     def generator=(generator) # :nodoc:
       old, $VERBOSE = $VERBOSE, nil
 
-      # The default proc used when the +sort_keys+ generation option is +true+.
-      # It returns a new hash with the entries sorted by their keys.
-      sort_keys_proc = ->(hash) { hash.sort.to_h }
-      if defined?(::Ractor) && Ractor.respond_to?(:shareable_lambda)
-        sort_keys_proc = Ractor.shareable_lambda(&sort_keys_proc)
-      end
-      generator::State.default_sort_keys_proc = sort_keys_proc
-
       @generator = generator
       if generator.const_defined?(:GeneratorMethods)
         generator_methods = generator::GeneratorMethods
@@ -143,11 +135,11 @@ module JSON
   # This exception is raised if a parser error occurs.
   class ParserError < JSONError
     # Line number where the parser encountered an error.
-    # Is <tt>nil</tt> when raised by JSON::ResumableParser.
+    # Is +nil+ when raised by JSON::ResumableParser.
     attr_reader :line
 
-    # Column number where the parser encountered an error.
-    # Is <tt>nil</tt> when raised by JSON::ResumableParser.
+    # One-based column number where the parser encountered an error, counted in Unicode codepoints.
+    # Is +nil+ when raised by JSON::ResumableParser.
     attr_reader :column
 
     # Returns a best effort JSONPath string representing where in the document
@@ -179,7 +171,10 @@ module JSON
         when Integer
           "[#{segment}]"
         when String, Symbol
-          if segment.match?(/\A[a-zA-Z\$\_][a-zA-Z\$\_0-9]*\z/)
+          if !segment.valid_encoding?
+            segment = segment.b.gsub(/["\\]/n, { '"' => '\\"', '\\' => '\\\\' }).force_encoding(Encoding::UTF_8)
+            %{["#{segment}"]}
+          elsif segment.match?(/\A[a-zA-Z\$\_][a-zA-Z\$\_0-9]*\z/)
             ".#{segment}"
           else
             segment = segment.to_s.gsub(/["\\]/, { '"' => '\\"', '\\' => '\\\\' })
@@ -232,7 +227,7 @@ module 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"
+        raise TypeError, "no implicit conversion of #{json.class} into String"
       end
 
       super(string)
@@ -290,7 +285,7 @@ module JSON
   # ---
   #
   # Raises an exception if +source+ is not valid JSON:
-  #   # Raises JSON::ParserError unexpected character: 'invalid' at line 1 column 1 :
+  #   # Raises JSON::ParserError (unexpected character: 'invalid' at line 1 column 1):
   #   JSON.parse('invalid')
   #
   def parse(source, on_load: nil, object_class: nil, array_class: nil, **options)
@@ -324,8 +319,8 @@ module JSON
   #   parse(File.read(path), **)
   #
   # See method #parse.
-  def load_file(filespec, ...)
-    parse(File.read(filespec, encoding: Encoding::UTF_8), ...)
+  def load_file(filespec, **options)
+    parse(File.read(filespec, encoding: Encoding::UTF_8), **options)
   end
 
   # :call-seq:
@@ -335,8 +330,8 @@ module JSON
   #   JSON.parse!(File.read(path), **)
   #
   # See method #parse!
-  def load_file!(filespec, ...)
-    parse!(File.read(filespec, encoding: Encoding::UTF_8), ...)
+  def load_file!(filespec, **options)
+    parse!(File.read(filespec, encoding: Encoding::UTF_8), **options)
   end
 
   # :call-seq:
@@ -372,7 +367,7 @@ module JSON
   #
   # Raises an exception if +obj+ contains circular references:
   #   a = []; b = []; a.push(b); b.push(a)
-  #   # Raises JSON::NestingError (nesting of 100 is too deep):
+  #   # Raises JSON::NestingError (nesting of 100 is too deep. Did you try to serialize objects with circular references?):
   #   JSON.generate(a)
   #
   def generate(obj, opts = nil)
@@ -707,10 +702,10 @@ module JSON
     unless source.is_a?(String)
       if source.respond_to? :to_str
         source = source.to_str
+      elsif source.respond_to? :read
+        source = source.read
       elsif source.respond_to? :to_io
         source = source.to_io.read
-      elsif source.respond_to?(:read)
-        source = source.read
       end
     end
 
@@ -771,7 +766,7 @@ module JSON
     end
 
     opts = {
-      allow_nan: true,
+      allow_nan: !(kwargs && kwargs[:rfc8785]),
     }
     opts[:max_nesting] = _deprecated_limit if _deprecated_limit
     opts.merge!(kwargs) if kwargs
@@ -812,9 +807,9 @@ module JSON
     private_constant :EXCLUDED_GENERATOR_OPTIONS
 
     # :call-seq:
-    #   JSON.new(options = nil, &block)
+    #   JSON::Coder.new(**options, &block)
     #
-    # Argument +options+, if given, contains a \Hash of options for both parsing and generating.
+    # Keyword arguments +options+, if given, are options for both parsing and generating.
     # See {Parsing Options}[rdoc-ref:JSON@Parsing+Options],
     # and {Generating Options}[rdoc-ref:JSON@Generating+Options].
     #
@@ -835,7 +830,12 @@ module JSON
     #
     #  puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z"
     #
-    def initialize(object_class: nil, array_class: nil, on_load: nil, **options, &as_json)
+    # The conversion callback can also be passed as +as_json:+. If both are given, the block takes precedence.
+    # Passing +false+ or +nil+ for +strict:+ raises ArgumentError.
+    #
+    def initialize(object_class: nil, array_class: nil, on_load: nil, strict: true, **options, &as_json)
+      raise ArgumentError, "JSON::Coder requires strict mode" unless strict
+
       if object_class || array_class
         on_load = ParserOptions.on_load(on_load, object_class, array_class)
       end
@@ -847,7 +847,7 @@ module JSON
       @state = State.new(
         **generator_options,
         strict: true,
-        as_json: as_json,
+        as_json: as_json || generator_options[:as_json],
       ).freeze
     end
 

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

@@ -54,7 +54,8 @@ module JSON
             strict: strict?,
             depth: depth,
             buffer_initial_length: buffer_initial_length,
-            sort_keys: sort_keys
+            sort_keys: sort_keys,
+            rfc8785: rfc8785?,
           }
 
           allow_duplicate_key = allow_duplicate_key?
@@ -62,11 +63,6 @@ module JSON
             result[:allow_duplicate_key] = allow_duplicate_key
           end
 
-          instance_variables.each do |iv|
-            iv = iv.to_s[1..-1]
-            result[iv.to_sym] = self[iv]
-          end
-
           result
         end
 

data/lib/json/ext.rb

@@ -28,17 +28,143 @@ module JSON
       end
     end
 
+    class << self
+      if defined?(::Ractor) && Ractor.respond_to?(:shareable_lambda)
+        def shareable_lambda(block) # :nodoc:
+          Ractor.shareable_lambda(&block)
+        end
+      else
+        def shareable_lambda(block) # :nodoc:
+          block
+        end
+      end
+
+      def valid_encoding?(str) # :nodoc:
+        str.ascii_only? || (str.encoding == Encoding::UTF_8 && str.valid_encoding?)
+      end
+
+      def coerce_key(key, as_json) # :nodoc:
+        as_json_called = false
+
+        unless String === key || Symbol === key
+          key = as_json.call(key, true)
+          as_json_called = true
+        end
+
+        if Symbol === key
+          key = key.to_s
+        end
+
+        unless String === key
+          raise GeneratorError.new("#{key.class} not allowed as object key in JSON", key)
+        end
+
+        unless valid_encoding?(key)
+          if as_json_called
+            raise GeneratorError.new("source sequence is illegal/malformed utf-8", key)
+          end
+
+          key = as_json.call(key, true)
+          unless String === key
+            raise GeneratorError.new("#{key.class} not allowed as object key in JSON", key)
+          end
+
+          unless Ext.valid_encoding?(key)
+            raise GeneratorError.new("source sequence is illegal/malformed utf-8", key)
+          end
+        end
+
+        key
+      end
+
+      def on_duplicate_key(hash, as_json)
+        set = {}
+        hash.each_key do |key|
+          key = coerce_key(key, as_json)
+          if set[key]
+            raise GeneratorError.new("detected duplicate key #{key.inspect}", key)
+          else
+            set[key] = true
+          end
+        end
+      end
+    end
+
     require 'json/ext/parser'
     Ext::Parser::Config = Ext::ParserConfig
     JSON.parser = Ext::Parser
 
-    if RUBY_ENGINE == 'truffleruby'
+    generator = if RUBY_ENGINE == 'truffleruby'
       require 'json/truffle_ruby/generator'
-      JSON.generator = JSON::TruffleRuby::Generator
+      JSON::TruffleRuby::Generator
     else
       require 'json/ext/generator'
-      JSON.generator = Generator
+      Generator
     end
+
+    # The default proc used when the +sort_keys+ generation option is +true+.
+    # It returns a new hash with the entries sorted by their keys.
+    generator::State.default_sort_keys_proc = shareable_lambda(->(hash) {
+      hash.sort.to_h
+    })
+
+    # Directly lifted from Gregg Kellogg's json-canonicalization
+    generator::State.rfc8785_number_formatter_proc = shareable_lambda(->(num) {
+      if Integer === num
+        if num > Float::MAX || num < -Float::MAX
+          raise GeneratorError.new("Integer out of range for RFC 8785", num)
+        end
+        num = num.to_f
+      end
+      if num.zero?
+        "0"
+      else
+        if num < 0
+          num, sign = -num, '-'
+        end
+        native_rep = num.to_s
+        decimal, exponential = native_rep.split('e')
+        exp_val = exponential.to_i
+        exponential = exp_val > 0 ? ('+' + exp_val.to_s) : exp_val.to_s
+
+        integral, fractional = decimal.split('.')
+        fractional = fractional.sub(/0+$/, '')  # Remove trailing zeros
+
+        if exp_val > 0 && exp_val < 21
+          while exp_val > 0
+            integral += fractional.to_s[0] || '0'
+            fractional = fractional.to_s[1..-1]
+            exp_val -= 1
+          end
+          exponential = nil
+        elsif exp_val == 0
+          exponential = nil
+        elsif exp_val < 0 && exp_val > -7
+          # Small numbers are shown as 0.etc with e-6 as lower limit
+          fractional, integral, exponential = integral + fractional.to_s, '0', nil
+          fractional = ("0" * (-exp_val - 1)) + fractional
+        end
+
+        fractional = nil if fractional.to_s.empty?
+        sign.to_s + integral + (fractional ? ".#{fractional}" : '') + (exponential ? "e#{exponential}" : '')
+      end
+    })
+
+    generator::State.rfc8785_sort_keys_proc = shareable_lambda(->(hash, as_json) {
+      converted = if as_json
+        hash.transform_keys { |k| Ext.coerce_key(k, as_json) }
+      else
+        hash.transform_keys(&:to_s)
+      end
+
+      if converted.size < hash.size
+        Ext.on_duplicate_key(hash, as_json)
+      end
+
+      converted.sort_by { |k,| k.encode(Encoding::UTF_16) }.to_h
+    })
+
+    JSON.generator = generator
   end
 
   if defined?(ResumableParser) # Not yet available on JRuby