rapidjson 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17354e68c40c730955b333eacdc5232255f5c0e12605a2e35ea0a90dd84def19
-  data.tar.gz: c3d95c72fb9e4416f33007bf7076ed616e82bd138b2637e0a2e0a57a5b55faed
+  metadata.gz: 5e6a9c6ee55bf39622dca0dec0df0edb42de2f121dfd81b6711e3e730c7beb90
+  data.tar.gz: 2d3f80f79aa7e61cc0340f253891bfb4c6f67d3c80c1bf8a6e23b132d7dd8334
 SHA512:
-  metadata.gz: 5d3dc6b671e1cc4110c457a8551fdf05b62ef03ff355a93531406b32853fd0b9174bc6a9ae3b743f891fd1ff4fe8eb95506b36bff9753ca1ed8f60970e694ed7
-  data.tar.gz: 26195d47a4c2a68b190f0d46da8e09d2df7125b89ad53478758c9db74bf59e65c5a0a6b9fb10f47372da45fe25e269a0c6e48c44b36af10f3f22222739e70497
+  metadata.gz: f0e242022084c035eec3fc8deede180bf390f9275aae83bf923ee7ab2076bb5abc1860eded72bc6c43aa8eb9803d492b7477f1923fa343cc2348d72dff809872
+  data.tar.gz: 34092b2851dade4bf8adcec4dcf8e8fe66a561a41910c9ff99ac721d6aad48d6340bde69f586973d1f004583aa5eb5c5d278117375418edfe0365a91f339a963

data/README.md

@@ -2,6 +2,8 @@
 
 (Maybe) Ruby's fastest JSON library! Built using the [RapidJSON C++ library](https://rapidjson.org/)
 
+No monkey patches, ActiveSupport integration, `json` gem emulation.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -42,6 +44,58 @@ RapidJSON.pretty_encode(json_string)
 # }
 ```
 
+By default the encoder is "strict" and will raise an exception
+
+## ActiveSupport
+
+RapidJSON provides a drop-in replacement ActiveSupport encoder, with very good compatibility.
+Add the following to an initializer to opt-in.
+
+```
+# config/initializers/rapidjson.rb
+
+ActiveSupport::JSON::Encoding.json_encoder = RapidJSON::ActiveSupportEncoder
+```
+
+This makes `model.to_json` ~15x faster, and `nested_hash.to_json` ~27x faster (compred using Rails 7.0)
+
+## JSON gem compatibility
+
+Contrary to some other JSON libraries, `RapidJSON` doesn't provice a monkey patch to entirely replace the stdlib JSON gem.
+
+However it does provide a module that behave like the stdlib JSON gem and that can be used to monkey patch existing code.
+
+```ruby
+module SomeLibrary
+  def do_stuff(payload)
+    JSON.parse(payload)
+  end
+end
+```
+
+```ruby
+SomeLibrary::JSON = RapidJSON::JSONGem
+```
+
+Note that this module only use `RapidJSON` when it's certain it is safe to do so. If the JSON gem is called with
+some options that `RapidJSON` doesn't support, it automatically fallbacks to calling the JSON gem.
+
+## Advanced usage
+
+By default RapidJSON will only encode "JSON-ready" types: `Hash`, `Array`, `Integer`, `Float`, `String`, `Symbol`, `true`, `false`, and `nil`.
+
+RapidJSON::Coder can be initialized with a block which allows the behaviour to be customized. This is how the ActiveSupport encoder and JSON compatibility above are implemented! Just using Ruby :heart:.
+
+```
+RapidJSON::Coder.new do |object, is_key|
+  object.to_s # Convert any unknown object to string
+end
+```
+
+The block is called only for unrecognized types. The return value is expected to be a "JSON ready" type which will then be encoded.
+
+One additional special type is `RapidJSON::Fragment`, which is interpreted as an existing JSON-encoded string. This can be used to efficiently embed an existing JSON document, or to provide compatibility.
+
 ## Performance
 
 Your current JSON parser/encoder is probably fine.
@@ -88,27 +142,6 @@ I spent a week working on YAJL/yajl-ruby, and though I really liked the library,
 
 However, if you're happy with your current Ruby JSON library (including `json`) you should keep using it. They're all very good.
 
-## JSON gem compatibility
-
-Contrary to some other JSON libraries, `RapidJSON` doesn't provice a monkey patch to entirely replace the stdlib JSON gem.
-
-However it does provide a module that behave like the stdlib JSON gem and that can be used to monkey patch existing code.
-
-```ruby
-module SomeLibrary
-  def do_stuff(payload)
-    JSON.parse(payload)
-  end
-end
-```
-
-```ruby
-SomeLibrary::JSON = RapidJSON::JSONGem
-```
-
-Note that this module only use `RapidJSON` when it's certain it is safe to do so. If the JSON gem is called with
-some options that `RapidJSON` doesn't support, it automatically fallbacks to calling the JSON gem.
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/ext/rapidjson/buffer.hh

@@ -12,9 +12,16 @@ class RubyStringBuffer {
             mem = RSTRING_PTR(ruby_string);
         }
 
-        void Reserve(size_t size) {
-            if (capacity - used < size) {
-                resize(capacity * 2);
+        void Reserve(size_t want) {
+            if (capacity - used < want) {
+                size_t new_capacity = capacity;
+                while (new_capacity - used < want) {
+                    if (new_capacity >= SIZE_MAX / 2) {
+                        ruby_malloc_size_overflow(capacity, 2);
+                    }
+                    new_capacity <<= 1;
+                }
+                resize(new_capacity);
             }
         }
 

data/ext/rapidjson/cext.cc

@@ -19,26 +19,44 @@ typedef RubyStringBuffer DefaultBuffer;
 static VALUE
 dump(VALUE _self, VALUE obj, VALUE pretty, VALUE as_json, VALUE allow_nan) {
     // NB: as_json here is not marked by the extension, but is always on the stack
+    VALUE result;
+    int state;
+
     if (RTEST(pretty)) {
         RubyObjectEncoder<DefaultBuffer, PrettyWriter<DefaultBuffer> > encoder(as_json, RTEST(allow_nan));
-        return encoder.encode(obj);
+        encoder.writer.SetIndent(' ', 2);
+        result = encoder.encode_protected(obj, &state);
     } else {
         RubyObjectEncoder<DefaultBuffer, Writer<DefaultBuffer> > encoder(as_json, RTEST(allow_nan));
-        return encoder.encode(obj);
+        result = encoder.encode_protected(obj, &state);
+    }
+
+    if (state) {
+        rb_jump_tag(state);
     }
+    return result;
 }
 
 static VALUE
-load(VALUE _self, VALUE string) {
-    RubyObjectHandler handler;
-    Reader reader;
-    char *cstring = StringValueCStr(string); // fixme?
-    StringStream ss(cstring);
-    ParseResult ok = reader.Parse(ss, handler);
+load(VALUE _self, VALUE string, VALUE allow_nan) {
+    RubyObjectHandler handler(RTEST(allow_nan));
+    ParseResult ok;
+
+    {
+        char *cstring = StringValueCStr(string); // fixme?
+        StringStream ss(cstring);
+        Reader reader;
+        ok = reader.Parse<kParseNanAndInfFlag>(ss, handler);
+    }
 
     if (!ok) {
-        rb_raise(rb_eParseError, "JSON parse error: %s (%lu)",
-                GetParseError_En(ok.Code()), ok.Offset());
+        VALUE err = handler.GetErr();
+        if (RTEST(err)) {
+            rb_exc_raise(err);
+        } else {
+            rb_raise(rb_eParseError, "JSON parse error: %s (%lu)",
+                    GetParseError_En(ok.Code()), ok.Offset());
+        }
     }
 
     return handler.GetRoot();
@@ -68,7 +86,7 @@ Init_rapidjson(void)
     rb_global_variable(&rb_cRapidJSONFragment);
 
     rb_define_private_method(rb_cCoder, "_dump", dump, 4);
-    rb_define_method(rb_cCoder, "load", load, 1);
+    rb_define_method(rb_cCoder, "_load", load, 2);
     rb_define_method(rb_cCoder, "valid_json?", valid_json_p, 1);
 
     VALUE rb_eRapidJSONError = rb_const_get(rb_mRapidJSON, rb_intern("Error"));

data/ext/rapidjson/encoder.hh

@@ -8,7 +8,6 @@ using namespace rapidjson;
 template <typename B = RubyStringBuffer, typename W=Writer<B> >
 class RubyObjectEncoder {
     B buf;
-    W writer;
     VALUE as_json;
     bool allow_nan;
 
@@ -200,10 +199,26 @@ class RubyObjectEncoder {
             allow_nan = allow_nan_;
         };
 
+        W writer;
         int depth;
 
         VALUE encode(VALUE obj) {
             encode_any(obj, true);
             return buf.GetRubyString();
         }
+
+        struct protected_args {
+            RubyObjectEncoder *encoder;
+            VALUE obj;
+        };
+
+        static VALUE encode_protected_cb(VALUE data) {
+            struct protected_args *args = (struct protected_args *)data;
+            return args->encoder->encode(args->obj);
+        }
+
+        VALUE encode_protected(VALUE obj, int *state) {
+            struct protected_args args = { this, obj };
+            return rb_protect(encode_protected_cb, (VALUE)&args, state);
+        }
 };

data/ext/rapidjson/parser.hh

@@ -50,6 +50,10 @@ struct RubyObjectHandler : public BaseReaderHandler<UTF8<>, RubyObjectHandler> {
     }
 
     bool Double(double d) {
+        if (!isfinite(d) && !allow_nan) {
+            err = rb_exc_new_cstr(rb_eParseError, "JSON parse error: Invalid float value");
+            return false;
+        }
         return PutValue(rb_float_new(d));
     }
 
@@ -92,7 +96,7 @@ struct RubyObjectHandler : public BaseReaderHandler<UTF8<>, RubyObjectHandler> {
             depth++;
             return true;
         } else {
-            rb_raise(rb_eParseError, "JSON parse error: input too deep");
+            err = rb_exc_new_cstr(rb_eParseError, "JSON parse error: input too deep");
             return false;
         }
     }
@@ -140,12 +144,18 @@ struct RubyObjectHandler : public BaseReaderHandler<UTF8<>, RubyObjectHandler> {
         return stack[0];
     }
 
-    RubyObjectHandler(): depth(0) {
+    VALUE GetErr() {
+        return err;
+    }
+
+    RubyObjectHandler(bool allow_nan): err(Qfalse), depth(0), allow_nan(allow_nan) {
         stack[0] = Qundef;
     }
 
     static const int MAX_DEPTH = 256;
-    int depth;
     VALUE stack[MAX_DEPTH];
     VALUE last_key[MAX_DEPTH];
+    VALUE err;
+    int depth;
+    bool allow_nan;
 };

data/lib/rapidjson/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RapidJSON
-  VERSION = "0.2.1"
+  VERSION = "0.2.3"
 end

data/lib/rapidjson.rb

@@ -17,6 +17,10 @@ module RapidJSON
     def dump(object)
       _dump(object, @pretty, @to_json_proc, @allow_nan)
     end
+
+    def load(string)
+      _load(string, @allow_nan)
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rapidjson
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-27 00:00:00.000000000 Z
+date: 2023-12-27 00:00:00.000000000 Z
 dependencies: []
 description: Fast JSON encoder/decoder based using RapidJSON
 email:
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Fast JSON encoder/decoder based using RapidJSON