json 2.7.3 → 2.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1500b32611dd205778d21f8175a6e587c85d8090e9861c6ab5c2bbdc8cc7b107
-  data.tar.gz: 7bccf2b0c350f282b152f0e85addedb62d596c83a5347afa4205bb025f1dd24f
+  metadata.gz: fc08bd5e3c83c4e731d37e18b5a32f9bf0049d896c483f1beb96af96f2daad18
+  data.tar.gz: ff215943fdccc5a5ed3f7390719aa5c43a18664e19f86d94226ff14c154cc354
 SHA512:
-  metadata.gz: cf52a3ae9060dcebbc0febfde70aba86d718dd0545eb55da4f25e7fffa3bacbaff82e56656c189f6d7ffd25093c9a5967085864ce1db921dcb0e9cc92c9b299f
-  data.tar.gz: 55d5e7da5ff1dee20b3a48e08d7a8e389fe8cd4a1f6569ca84d0a59f0e84085fb5af3e2a6721f76ea7dfd860bdbdc8844e7464572191be0c816bf0522036edd0
+  metadata.gz: e3bc85653be385e76842fa3f69671fccdc4235a32806f554cf8ec4a9ad697996be97d3aef52823b3c1f8839e1cd9a7893ab87360ca76d59b4ff704c75fcb655e
+  data.tar.gz: f2f09188afd38972e15e1c80c2c8c4efd14aee954d18ff83d4a6a993bd0f9d9c84362232c17abbc9bf3ffdfce062c79c75a6fccf124bdbd3345a202b76d50a26

data/CHANGES.md

@@ -1,5 +1,66 @@
 # Changes
 
+### 2025-02-10 (2.10.1)
+
+* Fix a compatibility issue with `MultiJson.dump(obj, pretty: true)`: `no implicit conversion of false into Proc (TypeError)`.
+
+### 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.
+* Introduced `JSON::Fragment` to allow assembling cached fragments in a safe way.
+* The Java implementation of the generator received many optimizations.
+
+### 2024-12-18 (2.9.1)
+
+* Fix support for Solaris 10.
+
+### 2024-12-03 (2.9.0)
+
+* Fix C implementation of `script_safe` escaping to not confuse some other 3 wide characters with `\u2028` and `\u2029`.
+  e.g. `JSON.generate(["倩", "瀨"], script_safe: true)` would generate the wrong JSON.
+* `JSON.dump(object, some_io)` now write into the IO in chunks while previously it would buffer the entire JSON before writing.
+* `JSON::GeneratorError` now has a `#invalid_object` attribute, making it easier to understand why an object tree cannot be serialized.
+* Numerous improvements to the JRuby extension.
+
+### 2024-11-14 (2.8.2)
+
+* `JSON.load_file` explictly read the file as UTF-8.
+
+### 2024-11-06 (2.8.1)
+
+* Fix the java packages to include the extension.
+
+### 2024-11-06 (2.8.0)
+
+* Emit a deprecation warning when `JSON.load` create custom types without the `create_additions` option being explictly enabled.
+  * Prefer to use `JSON.unsafe_load(string)` or `JSON.load(string, create_additions: true)`.
+* Emit a deprecation warning when serializing valid UTF-8 strings encoded in `ASCII_8BIT` aka `BINARY`.
+* Bump required Ruby version to 2.7.
+* Add support for optionally parsing trailing commas, via `allow_trailing_comma: true`, which in cunjunction with the
+  pre-existing support for comments, make it suitable to parse `jsonc` documents.
+* Many performance improvements to `JSON.parse` and `JSON.load`, up to `1.7x` faster on real world documents.
+* Some minor performance improvements to `JSON.dump` and `JSON.generate`.
+* `JSON.pretty_generate` no longer include newline inside empty object and arrays. 
+
+### 2024-11-04 (2.7.6)
+
+* Fix a regression in JSON.generate when dealing with Hash keys that are string subclasses, call `to_json` on them.
+
+### 2024-10-25 (2.7.5)
+
+* Fix a memory leak when `#to_json` methods raise an exception.
+* Gracefully handle formatting configs being set to `nil` instead of `""`.
+* Workaround another issue caused by conflicting versions of both `json_pure` and `json` being loaded.
+
+### 2024-10-25 (2.7.4)
+
+* Workaround a bug in 3.4.8 and older https://github.com/rubygems/rubygems/pull/6490.
+  This bug would cause some gems with native extension to fail during compilation.
+* Workaround different versions of `json` and `json_pure` being loaded (not officially supported).
+* Make `json_pure` Ractor compatible. 
+
 ### 2024-10-24 (2.7.3)
 
 * Numerous performance optimizations in `JSON.generate` and `JSON.dump` (up to 2 times faster).

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

@@ -5,16 +5,10 @@
 ## Description
 
 This is an implementation of the JSON specification according to RFC 7159
-http://www.ietf.org/rfc/rfc7159.txt . There is two variants available:
+http://www.ietf.org/rfc/rfc7159.txt .
 
-* A pure ruby variant, that relies on the `strscan` extensions, which is
-  part of the ruby standard library.
-* The quite a bit faster native extension variant, which is in parts
-  implemented in C or Java and comes with a parser generated by the [Ragel]
-  state machine compiler.
-
-Both variants of the JSON generator generate UTF-8 character sequences by
-default. If an :ascii\_only option with a true value is given, they escape all
+The JSON generator generate UTF-8 character sequences by default.
+If an :ascii\_only option with a true value is given, they escape all
 non-ASCII and control characters with \uXXXX escape sequences, and support
 UTF-16 surrogate pairs in order to be able to generate the whole range of
 unicode code points.
@@ -27,10 +21,6 @@ endpoint.
 
 ## Installation
 
-It's recommended to use the extension variant of JSON, because it's faster than
-the pure ruby variant. If you cannot build it on your system, you can settle
-for the latter.
-
 Install the gem and add to the application's Gemfile by executing:
 
     $ bundle add json
@@ -39,13 +29,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install json
 
-
-There is also a pure ruby json only variant of the gem, that can be installed
-with:
-
-    $ gem install json_pure
-
-## Usage
+## Basic Usage
 
 To use JSON you can
 
@@ -53,20 +37,6 @@ To use JSON you can
 require 'json'
 ```
 
-to load the installed variant (either the extension `'json'` or the pure
-variant `'json_pure'`). If you have installed the extension variant, you can
-pick either the extension variant or the pure variant by typing
-
-```ruby
-require 'json/ext'
-```
-
-or
-
-```ruby
-require 'json/pure'
-```
-
 Now you can parse a JSON document into a ruby data structure by calling
 
 ```ruby
@@ -82,50 +52,84 @@ 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).
 
-There are also the JSON and JSON[] methods which use parse on a String or
-generate a JSON document from an array or hash:
+## 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
-document = JSON 'test'  => 23 # => "{\"test\":23}"
-document = JSON['test' => 23] # => "{\"test\":23}"
+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}]
 ```
 
-and
+If a `#to_json` method isn't defined on the object, `JSON.generate` will fallback to call `#to_s`:
 
 ```ruby
-data = JSON '{"test":23}'  # => {"test"=>23}
-data = JSON['{"test":23}'] # => {"test"=>23}
+JSON.generate(Object.new) # => "#<Object:0x000000011e768b98>"
 ```
 
-You can choose to load a set of common additions to ruby core's objects if
-you
+Both of these behavior can be disabled using the `strict: true` option:
 
 ```ruby
-require 'json/add/core'
+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)
 ```
 
-After requiring this you can, e. g., serialise/deserialise Ruby ranges:
+## 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
-JSON JSON(1..10) # => 1..10
-```
+module MyApp
+  API_JSON_CODER = JSON::Coder.new do |object|
+    case object
+    when Time
+      object.iso8601(3)
+    else
+      object
+    end
+  end
+end
 
-To find out how to add JSON support to other or your own classes, read the
-section "More Examples" below.
+puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z"
+```
 
-## Serializing exceptions
+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.
 
-The JSON module doesn't extend `Exception` by default. If you convert an `Exception`
-object to JSON, it will by default only include the exception message.
+## Combining JSON fragments
 
-To include the full details, you must either load the `json/add/core` mentioned
-above, or specifically load the exception addition:
+To combine JSON fragments into a bigger JSON document, you can use `JSON::Fragment`:
 
 ```ruby
-require 'json/add/exception'
+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 })
 ```
 
-## More Examples
+## Round-tripping arbitrary types
+
+> [!CAUTION]
+> You should never use `JSON.unsafe_load` nor `JSON.parse(str, create_additions: true)` to parse untrusted user input,
+> as it can lead to remote code execution vulnerabilities.
 
 To create a JSON document from a ruby data structure, you can call
 `JSON.generate` like that:
@@ -191,7 +195,7 @@ JSON.parse json
 # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
 json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
 # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
-JSON.parse json, :create_additions => true
+JSON.unsafe_load json
 # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
 ```
 

data/ext/json/ext/fbuffer/fbuffer.h

@@ -4,78 +4,141 @@
 #include "ruby.h"
 #include "ruby/encoding.h"
 
+/* shims */
+/* This is the fallback definition from Ruby 3.4 */
+
+#ifndef RBIMPL_STDBOOL_H
+#if defined(__cplusplus)
+# if defined(HAVE_STDBOOL_H) && (__cplusplus >= 201103L)
+#  include <cstdbool>
+# endif
+#elif defined(HAVE_STDBOOL_H)
+# include <stdbool.h>
+#elif !defined(HAVE__BOOL)
+typedef unsigned char _Bool;
+# define bool  _Bool
+# define true  ((_Bool)+1)
+# define false ((_Bool)+0)
+# define __bool_true_false_are_defined
+#endif
+#endif
+
+#ifndef RB_UNLIKELY
+#define RB_UNLIKELY(expr) expr
+#endif
+
+#ifndef RB_LIKELY
+#define RB_LIKELY(expr) expr
+#endif
+
+#ifndef MAYBE_UNUSED
+# define MAYBE_UNUSED(x) x
+#endif
+
+enum fbuffer_type {
+    FBUFFER_HEAP_ALLOCATED = 0,
+    FBUFFER_STACK_ALLOCATED = 1,
+};
+
 typedef struct FBufferStruct {
+    enum fbuffer_type type;
     unsigned long initial_length;
-    char *ptr;
     unsigned long len;
     unsigned long capa;
+    char *ptr;
+    VALUE io;
 } FBuffer;
 
+#define FBUFFER_STACK_SIZE 512
+#define FBUFFER_IO_BUFFER_SIZE (16384 - 1)
 #define FBUFFER_INITIAL_LENGTH_DEFAULT 1024
 
-#define FBUFFER_PTR(fb) (fb->ptr)
-#define FBUFFER_LEN(fb) (fb->len)
-#define FBUFFER_CAPA(fb) (fb->capa)
+#define FBUFFER_PTR(fb) ((fb)->ptr)
+#define FBUFFER_LEN(fb) ((fb)->len)
+#define FBUFFER_CAPA(fb) ((fb)->capa)
 #define FBUFFER_PAIR(fb) FBUFFER_PTR(fb), FBUFFER_LEN(fb)
 
-static FBuffer *fbuffer_alloc(unsigned long initial_length);
 static void fbuffer_free(FBuffer *fb);
-#ifndef JSON_GENERATOR
 static void fbuffer_clear(FBuffer *fb);
-#endif
 static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len);
-#ifdef JSON_GENERATOR
 static void fbuffer_append_long(FBuffer *fb, long number);
-#endif
-static void fbuffer_append_char(FBuffer *fb, char newchr);
-#ifdef JSON_GENERATOR
-static VALUE fbuffer_to_s(FBuffer *fb);
-#endif
-
-#ifndef RB_UNLIKELY
-#define RB_UNLIKELY(expr) expr
-#endif
+static inline void fbuffer_append_char(FBuffer *fb, char newchr);
+static VALUE fbuffer_finalize(FBuffer *fb);
 
-static FBuffer *fbuffer_alloc(unsigned long initial_length)
+static void fbuffer_stack_init(FBuffer *fb, unsigned long initial_length, char *stack_buffer, long stack_buffer_size)
 {
-    FBuffer *fb;
-    if (initial_length <= 0) initial_length = FBUFFER_INITIAL_LENGTH_DEFAULT;
-    fb = ALLOC(FBuffer);
-    memset((void *) fb, 0, sizeof(FBuffer));
-    fb->initial_length = initial_length;
-    return fb;
+    fb->initial_length = (initial_length > 0) ? initial_length : FBUFFER_INITIAL_LENGTH_DEFAULT;
+    if (stack_buffer) {
+        fb->type = FBUFFER_STACK_ALLOCATED;
+        fb->ptr = stack_buffer;
+        fb->capa = stack_buffer_size;
+    }
 }
 
 static void fbuffer_free(FBuffer *fb)
 {
-    if (fb->ptr) ruby_xfree(fb->ptr);
-    ruby_xfree(fb);
+    if (fb->ptr && fb->type == FBUFFER_HEAP_ALLOCATED) {
+        ruby_xfree(fb->ptr);
+    }
 }
 
-#ifndef JSON_GENERATOR
 static void fbuffer_clear(FBuffer *fb)
 {
     fb->len = 0;
 }
-#endif
 
-static inline void fbuffer_inc_capa(FBuffer *fb, unsigned long requested)
+static void fbuffer_flush(FBuffer *fb)
 {
-    if (RB_UNLIKELY(requested > fb->capa - fb->len)) {
-        unsigned long required;
+    rb_io_write(fb->io, rb_utf8_str_new(fb->ptr, fb->len));
+    fbuffer_clear(fb);
+}
 
-        if (RB_UNLIKELY(!fb->ptr)) {
-            fb->ptr = ALLOC_N(char, fb->initial_length);
-            fb->capa = fb->initial_length;
+static void fbuffer_realloc(FBuffer *fb, unsigned long required)
+{
+    if (required > fb->capa) {
+        if (fb->type == FBUFFER_STACK_ALLOCATED) {
+            const char *old_buffer = fb->ptr;
+            fb->ptr = ALLOC_N(char, required);
+            fb->type = FBUFFER_HEAP_ALLOCATED;
+            MEMCPY(fb->ptr, old_buffer, char, fb->len);
+        } else {
+            REALLOC_N(fb->ptr, char, required);
         }
+        fb->capa = required;
+    }
+}
 
-        for (required = fb->capa; requested > required - fb->len; required <<= 1);
+static void fbuffer_do_inc_capa(FBuffer *fb, unsigned long requested)
+{
+    if (RB_UNLIKELY(fb->io)) {
+        if (fb->capa < FBUFFER_IO_BUFFER_SIZE) {
+            fbuffer_realloc(fb, FBUFFER_IO_BUFFER_SIZE);
+        } else {
+            fbuffer_flush(fb);
+        }
 
-        if (required > fb->capa) {
-            REALLOC_N(fb->ptr, char, required);
-            fb->capa = required;
+        if (RB_LIKELY(requested < fb->capa)) {
+            return;
         }
     }
+
+    unsigned long required;
+
+    if (RB_UNLIKELY(!fb->ptr)) {
+        fb->ptr = ALLOC_N(char, fb->initial_length);
+        fb->capa = fb->initial_length;
+    }
+
+    for (required = fb->capa; requested > required - fb->len; required <<= 1);
+
+    fbuffer_realloc(fb, required);
+}
+
+static inline void fbuffer_inc_capa(FBuffer *fb, unsigned long requested)
+{
+    if (RB_UNLIKELY(requested > fb->capa - fb->len)) {
+        fbuffer_do_inc_capa(fb, requested);
+    }
 }
 
 static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
@@ -87,7 +150,6 @@ static void fbuffer_append(FBuffer *fb, const char *newstr, unsigned long len)
     }
 }
 
-#ifdef JSON_GENERATOR
 static void fbuffer_append_str(FBuffer *fb, VALUE str)
 {
     const char *newstr = StringValuePtr(str);
@@ -97,50 +159,47 @@ static void fbuffer_append_str(FBuffer *fb, VALUE str)
 
     fbuffer_append(fb, newstr, len);
 }
-#endif
 
-static void fbuffer_append_char(FBuffer *fb, char newchr)
+static inline void fbuffer_append_char(FBuffer *fb, char newchr)
 {
     fbuffer_inc_capa(fb, 1);
     *(fb->ptr + fb->len) = newchr;
     fb->len++;
 }
 
-#ifdef JSON_GENERATOR
-static void freverse(char *start, char *end)
-{
-    char c;
-
-    while (end > start) {
-        c = *end, *end-- = *start, *start++ = c;
-    }
-}
-
 static long fltoa(long number, char *buf)
 {
-    static char digits[] = "0123456789";
+    static const char digits[] = "0123456789";
     long sign = number;
     char* tmp = buf;
 
     if (sign < 0) number = -number;
-    do *tmp++ = digits[number % 10]; while (number /= 10);
-    if (sign < 0) *tmp++ = '-';
-    freverse(buf, tmp - 1);
-    return tmp - buf;
+    do *tmp-- = digits[number % 10]; while (number /= 10);
+    if (sign < 0) *tmp-- = '-';
+    return buf - tmp;
 }
 
+#define LONG_BUFFER_SIZE 20
 static void fbuffer_append_long(FBuffer *fb, long number)
 {
-    char buf[20];
-    unsigned long len = fltoa(number, buf);
-    fbuffer_append(fb, buf, len);
+    char buf[LONG_BUFFER_SIZE];
+    char *buffer_end = buf + LONG_BUFFER_SIZE;
+    long len = fltoa(number, buffer_end - 1);
+    fbuffer_append(fb, buffer_end - len, len);
 }
 
-static VALUE fbuffer_to_s(FBuffer *fb)
+static VALUE fbuffer_finalize(FBuffer *fb)
 {
-    VALUE result = rb_utf8_str_new(FBUFFER_PTR(fb), FBUFFER_LEN(fb));
-    fbuffer_free(fb);
-    return result;
+    if (fb->io) {
+        fbuffer_flush(fb);
+        fbuffer_free(fb);
+        rb_io_flush(fb->io);
+        return fb->io;
+    } else {
+        VALUE result = rb_utf8_str_new(FBUFFER_PTR(fb), FBUFFER_LEN(fb));
+        fbuffer_free(fb);
+        return result;
+    }
 }
-#endif
+
 #endif