rapidjson 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4824f0636d8f801de840ebf32bd639258ce1e21a063228beaabd2b4ad6e1760a
-  data.tar.gz: 04bdbf36fdfd8b2ef289d8ba6e68b9d34c731cd1ffae61c154dd276ed56dc35e
+  metadata.gz: 722ff2bcb2ebfc8ab861d5066e53e938933bd03d2e7f4bca7662233fa0a8a314
+  data.tar.gz: 59d25e68af12d81bc3b5517a88de320a76a72c6b5d7cc9d26758084bd604b9fe
 SHA512:
-  metadata.gz: 74f3d0a620d505b0aa55601830f294794e8a938ee087d9fcc228fc6a83452c2b255b1ddf9c0b3aea1d086808259e6f75744fcd6fb9528361090d2bea9d35a612
-  data.tar.gz: cff30c2bafab60f467ee59cf8a63691f93dd2de1fb5f07573e54a1303f3f279f9100ec9e1c6991cf5c9e874c25df3f6dd52b3e549aef3e510d0d068ce50f9877
+  metadata.gz: 4eea208e695986e0e312c3794ba44852057f86a8159c4d862518482d263f2d13ef94fff481c38e2d7a79f881a13cef08e65eff4d49ded5c85378891bc79dab85
+  data.tar.gz: cafbbb2e33c4adecdfac50d1fc0bb34e3c1b019828af29714b0005a8a24955c3914c79e7a9690161589597b3df12928d6adddad8887014fd48fb36b58525f25d

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/json_escape.h

@@ -0,0 +1,90 @@
+#include "ruby.h"
+#include "ruby/encoding.h"
+
+/* strlen("\\u2029") == 6 */
+#define ESCAPE_JSON_MAX_LEN 6
+
+static inline long
+json_escaped_length(VALUE str)
+{
+    const long len = RSTRING_LEN(str);
+    if (len >= LONG_MAX / ESCAPE_JSON_MAX_LEN) {
+        ruby_malloc_size_overflow(len, ESCAPE_JSON_MAX_LEN);
+    }
+    return len * ESCAPE_JSON_MAX_LEN;
+}
+
+static VALUE
+escape_json(VALUE self, VALUE str)
+{
+    if (!RB_TYPE_P(str, T_STRING)) {
+        str = rb_convert_type(str, T_STRING, "String", "to_s");
+    }
+
+    rb_encoding *enc = rb_enc_get(str);
+    if (enc != rb_utf8_encoding() && enc != rb_usascii_encoding()) {
+        rb_raise(rb_eEncCompatError, "input string must be UTF-8 or ASCII");
+    }
+
+    const char *cstr = RSTRING_PTR(str);
+    const unsigned long str_len = RSTRING_LEN(str);
+    const char *end = cstr + RSTRING_LEN(str);
+
+    size_t initial_match = strcspn(cstr, "&<>\xe2");
+    if (initial_match == str_len) {
+        return str;
+    }
+
+    VALUE escaped = rb_str_buf_new(json_escaped_length(str));
+    rb_str_resize(escaped, json_escaped_length(str));
+    char *buf = RSTRING_PTR(escaped);
+    char *dest = buf;
+
+    memcpy(dest, cstr, initial_match);
+    cstr += initial_match;
+    dest += initial_match;
+
+    while (cstr < end) {
+        const char c = *cstr++;
+
+#define JSON_ESCAPE_CONCAT(s) do { \
+    memcpy(dest, ("\\u" s), strlen(s) + 2); \
+    dest += strlen(s) + 2; \
+} while (0)
+
+        if (0) {
+        }
+        else if (c == '&') {
+            JSON_ESCAPE_CONCAT("0026");
+        }
+        else if (c == '>') {
+            JSON_ESCAPE_CONCAT("003e");
+        }
+        else if (c == '<') {
+            JSON_ESCAPE_CONCAT("003c");
+        }
+        else if (c == '\xe2' && cstr[0] == '\x80' && cstr[1] == '\xa8') {
+            JSON_ESCAPE_CONCAT("2028");
+            cstr += 2;
+        }
+        else if (c == '\xe2' && cstr[0] == '\x80' && cstr[1] == '\xa9') {
+            JSON_ESCAPE_CONCAT("2029");
+            cstr += 2;
+        }
+        else {
+            *dest++ = c;
+        }
+
+        initial_match = strcspn(cstr, "&<>\xe2");
+        memcpy(dest, cstr, initial_match);
+        cstr += initial_match;
+        dest += initial_match;
+
+#undef JSON_ESCAPE_CONCAT
+    }
+
+    rb_str_resize(escaped, dest - buf);
+    rb_enc_associate(escaped, rb_enc_get(str));
+
+    return escaped;
+}

data/lib/rapidjson/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rapidjson
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - John Hawthorn
@@ -27,6 +27,7 @@ files:
 - ext/rapidjson/cext.hh
 - ext/rapidjson/encoder.hh
 - ext/rapidjson/extconf.rb
+- ext/rapidjson/json_escape.h
 - ext/rapidjson/parser.hh
 - ext/rapidjson/rapidjson/include/rapidjson/allocators.h
 - ext/rapidjson/rapidjson/include/rapidjson/cursorstreamwrapper.h