rapidjson 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 722ff2bcb2ebfc8ab861d5066e53e938933bd03d2e7f4bca7662233fa0a8a314
-  data.tar.gz: 59d25e68af12d81bc3b5517a88de320a76a72c6b5d7cc9d26758084bd604b9fe
+  metadata.gz: f6e0fb853f22254885b3a5e40c0b615992bbe77c7cde00d6cf5c3f9bdd8fa3c7
+  data.tar.gz: 0e94b7913c864277937c7b1024fd2e6d99a3730598112eba16e86ff5fc286b6d
 SHA512:
-  metadata.gz: 4eea208e695986e0e312c3794ba44852057f86a8159c4d862518482d263f2d13ef94fff481c38e2d7a79f881a13cef08e65eff4d49ded5c85378891bc79dab85
-  data.tar.gz: cafbbb2e33c4adecdfac50d1fc0bb34e3c1b019828af29714b0005a8a24955c3914c79e7a9690161589597b3df12928d6adddad8887014fd48fb36b58525f25d
+  metadata.gz: 524f57ff6a71f07de04c173f84ed7465d8b5f97450afda4a5e0f6c21ba29e44d41a8aa0958d675b38b6daa2bca7fd0017c99eabda4c77c72cd63ebbc21309e38
+  data.tar.gz: f9d5f408ffaeb533e2e8c0d3eb156bd2493f2928dc2aa4dee07e9e1ca0053ec4f6df5a5c7f57ed2b335fa9fc2f14f24efc2265d4700cc76614c53bf66917c555

data/README.md

@@ -2,7 +2,7 @@
 
 (Maybe) Ruby's fastest JSON library! Built using the [RapidJSON C++ library](https://rapidjson.org/)
 
-No monkey patches, ActiveSupport integration, `json` gem emulation.
+ActiveSupport integration, `json` gem emulation, and no monkey patches.
 
 ## Installation
 
@@ -44,24 +44,24 @@ RapidJSON.pretty_encode(json_string)
 # }
 ```
 
-By default the encoder is "strict" and will raise an exception
+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.
 
-```
+```ruby
 # 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)
+This makes `model.to_json` ~15x faster, and `nested_hash.to_json` ~27x faster (compared 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.
+Contrary to some other JSON libraries, `RapidJSON` doesn't provide 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.
 
@@ -86,7 +86,7 @@ By default RapidJSON will only encode "JSON-ready" types: `Hash`, `Array`, `Inte
 
 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:.
 
-```
+```ruby
 RapidJSON::Coder.new do |object, is_key|
   object.to_s # Convert any unknown object to string
 end
@@ -105,11 +105,11 @@ Unless there's good reason, it's probably best sticking with the standard `json`
 However this library has a few performance advantages:
 
 * JSON parsing
-  * Performance is achieved mostly through using RapidJSON one of the fastest open source JSON parsing libraries. It supports SIMD (SSE2, SSE4.2, NEON), avoids allocated memory, and has been honed to be if not the fastest library (that honour likely going to simdjson) the library to beat for JSON performance.
+  * Performance is achieved mostly through using RapidJSON one of the fastest open source JSON parsing libraries. It supports SIMD (SSE2, SSE4.2, NEON), avoids allocated memory, and has been honed to be if not the fastest library (that honour likely going to simdjson), the library to beat for JSON performance.
 * Object allocation
   * Wherever possible we avoid allocating objects. When generating JSON, RapidJSON will write the emitted JSON directly into the buffer of a Ruby string. (This is an optimization most Ruby JSON libraries will have)
   * When parsing JSON we parse directly form the source string with a single copy
-  * When building a Hash for a JSON object, we use an fstrings (dedup'd and frozen strings) as the key
+  * When building a Hash for a JSON object, we use `fstrings` (dedup'd and frozen strings) as the key
   * Whenever possible we build Ruby objects from C types (int, char \*, double) rather than constructing intermediate Ruby string objects.
 
 Many of these optimization can be found in all popular Ruby JSON libraries
@@ -158,4 +158,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Rapidjson project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jhawthorn/rapidjson/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the RapidJSON project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/jhawthorn/rapidjson/blob/main/CODE_OF_CONDUCT.md).

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();
@@ -59,6 +77,57 @@ valid_json_p(VALUE _self, VALUE string) {
     return Qtrue;
 }
 
+static bool is_json_ready(VALUE obj);
+
+static int is_json_ready_hash_i(VALUE key, VALUE val, VALUE arg) {
+    bool *result = (bool *)arg;
+
+    if (!RB_TYPE_P(key, T_STRING) && !RB_TYPE_P(key, T_SYMBOL)) {
+        *result = false;
+        return ST_STOP;
+    }
+    if (!is_json_ready(val)) {
+        *result = false;
+        return ST_STOP;
+    }
+    return ST_CONTINUE;
+}
+
+static bool
+is_json_ready(VALUE obj) {
+    switch(rb_type(obj)) {
+        case T_NIL:
+        case T_FALSE:
+        case T_TRUE:
+        case T_FIXNUM:
+        case T_BIGNUM:
+        case T_FLOAT:
+        case T_SYMBOL:
+        case T_STRING:
+            return true;
+        case T_HASH:
+            {
+                bool result = true;
+                rb_hash_foreach(obj, is_json_ready_hash_i, (VALUE)&result);
+                return result;
+            }
+        case T_ARRAY:
+            for (int i = 0; i < RARRAY_LEN(obj); i++) {
+                if (!is_json_ready(RARRAY_AREF(obj, i))) {
+                    return false;
+                }
+            }
+            return true;
+        default:
+            return false;
+    }
+}
+
+static VALUE
+json_ready_p(VALUE _self, VALUE obj) {
+    return is_json_ready(obj) ? Qtrue : Qfalse;
+}
+
 extern "C" void
 Init_rapidjson(void)
 {
@@ -68,7 +137,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"));
@@ -76,4 +145,5 @@ Init_rapidjson(void)
     rb_eEncodeError = rb_define_class_under(rb_mRapidJSON, "EncodeError", rb_eRapidJSONError);
 
     rb_define_singleton_method(rb_mRapidJSON, "json_escape", escape_json, 1);
+    rb_define_singleton_method(rb_mRapidJSON, "json_ready?", json_ready_p, 1);
 }

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/active_support_encoder.rb

@@ -14,7 +14,9 @@ module RapidJSON
     # Encode the given object into a JSON string
     def encode(value)
       if @options && !@options.empty?
-        value = value.as_json(@options.dup)
+        if !RapidJSON.json_ready?(value) || @options.key?(:only) || @options.key?(:except)
+          value = value.as_json(@options.dup)
+        end
       end
       json = @coder.dump(value)
       if ActiveSupport::JSON::Encoding.escape_html_entities_in_json

data/lib/rapidjson/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RapidJSON
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 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.2
+  version: 0.3.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-27 00:00:00.000000000 Z
+date: 2024-08-06 00:00:00.000000000 Z
 dependencies: []
 description: Fast JSON encoder/decoder based using RapidJSON
 email:
@@ -71,13 +71,13 @@ files:
 - lib/rapidjson/active_support_encoder.rb
 - lib/rapidjson/json_gem.rb
 - lib/rapidjson/version.rb
-homepage: https://github.com/jhawthorn/rapidjson
+homepage: https://github.com/jhawthorn/rapidjson-ruby
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/jhawthorn/rapidjson
-  source_code_uri: https://github.com/jhawthorn/rapidjson
-  changelog_uri: https://github.com/jhawthorn/rapidjson
+  homepage_uri: https://github.com/jhawthorn/rapidjson-ruby
+  source_code_uri: https://github.com/jhawthorn/rapidjson-ruby
+  changelog_uri: https://github.com/jhawthorn/rapidjson-ruby
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Fast JSON encoder/decoder based using RapidJSON