rapidjson 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9399c5d53ffb32742313e2ad6016a63329dd28a8095aa07946997c500c5ea073
-  data.tar.gz: 36af0427268da02dc2d58c6ba2f18d68e559992f7793e1761cf448f3094bd96c
+  metadata.gz: 4824f0636d8f801de840ebf32bd639258ce1e21a063228beaabd2b4ad6e1760a
+  data.tar.gz: 04bdbf36fdfd8b2ef289d8ba6e68b9d34c731cd1ffae61c154dd276ed56dc35e
 SHA512:
-  metadata.gz: 231d6b2853f377ce7771e6602a1f1eb320dced2330f149b3b0b3ee0d42000ecf7511e7262aea67a02f0e4f2ecfa59f1e3a7009c79f1327816744fe59e6da1a73
-  data.tar.gz: b8e2c77b789a41ce104e29c830bc4281e492e1d05113f8e4cb3497a8c89f2a7dbd6e1d2f95ebdb145c5f7f30a625bf7963e97c27cc3032613a2bbfda45807ee7
+  metadata.gz: 74f3d0a620d505b0aa55601830f294794e8a938ee087d9fcc228fc6a83452c2b255b1ddf9c0b3aea1d086808259e6f75744fcd6fb9528361090d2bea9d35a612
+  data.tar.gz: cff30c2bafab60f467ee59cf8a63691f93dd2de1fb5f07573e54a1303f3f279f9100ec9e1c6991cf5c9e874c25df3f6dd52b3e549aef3e510d0d068ce50f9877

data/README.md

@@ -73,13 +73,10 @@ Many of these optimization can be found in all popular Ruby JSON libraries
                 yajl     35.510  (± 2.8%) i/s -    180.000  in   5.070803s
                 json     22.105  (± 0.0%) i/s -    112.000  in   5.067063s
                   oj     15.163  (± 6.6%) i/s -     76.000  in   5.042864s
-     fast_jsonparser     10.791  (± 0.0%) i/s -     54.000  in   5.004290s
            rapidjson    148.263  (± 2.0%) i/s -    742.000  in   5.006370s
 ```
 Notes: oj seems unusually bad at this test, and is usually faster than yajl and
 json, and comparable to rapidjson.
-`fast_jsonparser` has been slow since Ruby 3.0, likely a bug, if fixed I'd
-expect it to be the fasest JSON parser.
 
 Other libraries may include modes to avoid constructing all objects. Currently
 RapidJSON only focuses on the patterns and APIs users are likely to actually
@@ -91,6 +88,27 @@ 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

@@ -8,6 +8,7 @@ class RubyStringBuffer {
 
         RubyStringBuffer() : used(0), capacity(INITIAL_SIZE) {
             ruby_string = rb_str_buf_new(INITIAL_SIZE);
+            rb_enc_associate(ruby_string, rb_utf8_encoding());
             mem = RSTRING_PTR(ruby_string);
         }
 

data/ext/rapidjson/cext.cc

@@ -4,31 +4,32 @@
 #include "rapidjson/prettywriter.h"
 #include "rapidjson/error/en.h"
 
-static VALUE rb_mRapidjson;
 static VALUE rb_eParseError;
 static VALUE rb_eEncodeError;
-
-static ID id_to_json;
-static ID id_to_s;
+static VALUE rb_cRapidJSONFragment;
 
 #include "encoder.hh"
 #include "parser.hh"
+#include "json_escape.h"
 
 using namespace rapidjson;
 
 typedef RubyStringBuffer DefaultBuffer;
 
-VALUE encode(VALUE _self, VALUE obj) {
-    RubyObjectEncoder<DefaultBuffer, Writer<DefaultBuffer> > encoder;
-    return encoder.encode(obj);
-}
-
-VALUE pretty_encode(VALUE _self, VALUE obj) {
-    RubyObjectEncoder<DefaultBuffer, PrettyWriter<DefaultBuffer> > encoder;
-    return encoder.encode(obj);
+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
+    if (RTEST(pretty)) {
+        RubyObjectEncoder<DefaultBuffer, PrettyWriter<DefaultBuffer> > encoder(as_json, RTEST(allow_nan));
+        return encoder.encode(obj);
+    } else {
+        RubyObjectEncoder<DefaultBuffer, Writer<DefaultBuffer> > encoder(as_json, RTEST(allow_nan));
+        return encoder.encode(obj);
+    }
 }
 
-VALUE parse(VALUE _self, VALUE string) {
+static VALUE
+load(VALUE _self, VALUE string) {
     RubyObjectHandler handler;
     Reader reader;
     char *cstring = StringValueCStr(string); // fixme?
@@ -43,7 +44,8 @@ VALUE parse(VALUE _self, VALUE string) {
     return handler.GetRoot();
 }
 
-VALUE valid_json_p(VALUE _self, VALUE string) {
+static VALUE
+valid_json_p(VALUE _self, VALUE string) {
     NullHandler handler;
     Reader reader;
     char *cstring = StringValueCStr(string); // fixme?
@@ -60,18 +62,18 @@ VALUE valid_json_p(VALUE _self, VALUE string) {
 extern "C" void
 Init_rapidjson(void)
 {
-    id_to_s = rb_intern("to_s");
-    id_to_json = rb_intern("to_json");
+    VALUE rb_mRapidJSON = rb_const_get(rb_cObject, rb_intern("RapidJSON"));
+    VALUE rb_cCoder = rb_const_get(rb_mRapidJSON, rb_intern("Coder"));
+    rb_cRapidJSONFragment = rb_const_get(rb_mRapidJSON, rb_intern("Fragment"));;
+    rb_global_variable(&rb_cRapidJSONFragment);
 
-    rb_mRapidjson = rb_define_module("RapidJSON");
-    rb_define_module_function(rb_mRapidjson, "encode", encode, 1);
-    rb_define_module_function(rb_mRapidjson, "pretty_encode", pretty_encode, 1);
-    rb_define_module_function(rb_mRapidjson, "dump", encode, 1);
+    rb_define_private_method(rb_cCoder, "_dump", dump, 4);
+    rb_define_method(rb_cCoder, "load", load, 1);
+    rb_define_method(rb_cCoder, "valid_json?", valid_json_p, 1);
 
-    rb_define_module_function(rb_mRapidjson, "parse", parse, 1);
-    rb_define_module_function(rb_mRapidjson, "load", parse, 1);
-    rb_define_module_function(rb_mRapidjson, "valid_json?", valid_json_p, 1);
+    VALUE rb_eRapidJSONError = rb_const_get(rb_mRapidJSON, rb_intern("Error"));
+    rb_eParseError = rb_define_class_under(rb_mRapidJSON, "ParseError", rb_eRapidJSONError);
+    rb_eEncodeError = rb_define_class_under(rb_mRapidJSON, "EncodeError", rb_eRapidJSONError);
 
-    rb_eParseError = rb_define_class_under(rb_mRapidjson, "ParseError", rb_eStandardError);
-    rb_eEncodeError = rb_define_class_under(rb_mRapidjson, "EncodeError", rb_eStandardError);
+    rb_define_singleton_method(rb_mRapidJSON, "json_escape", escape_json, 1);
 }

data/ext/rapidjson/encoder.hh

@@ -9,33 +9,60 @@ template <typename B = RubyStringBuffer, typename W=Writer<B> >
 class RubyObjectEncoder {
     B buf;
     W writer;
+    VALUE as_json;
+    bool allow_nan;
 
     void encode_array(VALUE ary) {
         writer.StartArray();
         int length = RARRAY_LEN(ary);
         RARRAY_PTR_USE(ary, ptr, {
                 for (int i = 0; i < length; i++) {
-                encode_any(ptr[i]);
+                encode_any(ptr[i], true);
                 }
                 });
         writer.EndArray();
     }
 
+    static VALUE string_to_utf8_compatible(VALUE str) {
+        rb_encoding *enc = rb_enc_get(str);
+        if (enc == rb_utf8_encoding() || enc == rb_usascii_encoding()) {
+            return str;
+        } else {
+            return rb_str_export_to_enc(str, rb_utf8_encoding());
+        }
+    }
+
     void encode_key(VALUE key) {
         switch(rb_type(key)) {
+            case T_STRING:
+                break;
             case T_SYMBOL:
                 key = rb_sym2str(key);
-                /* FALLTHRU */
-            case T_STRING:
-                writer.Key(RSTRING_PTR(key), RSTRING_LEN(key), false);
-                return;
+                break;
+            case T_FIXNUM:
+            case T_BIGNUM:
+                key = rb_String(key);
+                break;
             default:
-                {
-                    VALUE str = rb_funcall(key, id_to_s, 0);
+                if (NIL_P(as_json)) {
+                    rb_raise(rb_eTypeError, "Invalid object key type: %" PRIsVALUE, rb_obj_class(key));
+                    UNREACHABLE_RETURN();
+                }
+
+                VALUE args[2] = { key, Qtrue };
+                key = rb_proc_call_with_block(as_json, 2, args, Qnil);
+                if (rb_obj_class(key) == rb_cRapidJSONFragment) {
+                    VALUE str = rb_struct_aref(key, INT2FIX(0));
                     Check_Type(str, T_STRING);
-                    encode_string(str);
+                    return encode_raw_json_str(str);
                 }
+
+                break;
         }
+
+        Check_Type(key, T_STRING);
+        key = string_to_utf8_compatible(key);
+        writer.Key(RSTRING_PTR(key), RSTRING_LEN(key), false);
     }
 
     static int encode_hash_i_cb(VALUE key, VALUE val, VALUE ctx) {
@@ -46,7 +73,7 @@ class RubyObjectEncoder {
 
     void encode_hash_i(VALUE key, VALUE val) {
         encode_key(key);
-        encode_any(val);
+        encode_any(val, true);
     }
 
     void encode_hash(VALUE hash) {
@@ -60,27 +87,48 @@ class RubyObjectEncoder {
     }
 
     void encode_bignum(VALUE b) {
-        b = rb_big_norm(b);
-        if (FIXNUM_P(b)) {
-            return encode_fixnum(b);
-        }
-
-        bool negative = rb_big_cmp(b, INT2FIX(0)) == INT2FIX(-1);
-        if (negative) {
-            long long ll = rb_big2ll(b);
-            writer.Int64(ll);
-        } else {
-            unsigned long long ull = rb_big2ull(b);
-            writer.Uint64(ull);
-        }
+        // Some T_BIGNUM might be small enough to fit in long long or unsigned long long
+        // but this being the slow path, it's not really worth it.
+        VALUE str = rb_String(b);
+        Check_Type(str, T_STRING);
+
+        // We should be able to use RawNumber here, but it's buggy
+        // https://github.com/Tencent/rapidjson/issues/852
+        writer.RawValue(RSTRING_PTR(str), RSTRING_LEN(str), kNumberType);
     }
 
-    void encode_float(VALUE v) {
+    void encode_float(VALUE v, bool generic) {
         double f = rb_float_value(v);
-        writer.Double(f);
+        if (!isfinite(f)) {
+            if (!allow_nan && !NIL_P(as_json) && generic) {
+                return encode_generic(v);
+            }
+            if (f == (-1.0 / 0.0)) {
+                if (allow_nan) {
+                    writer.RawValue("-Infinity", 9, kObjectType);
+                } else {
+                    rb_raise(rb_eEncodeError, "-Float::INFINITY is not allowed in JSON");
+                }
+            } else if (isinf(f)) {
+                if (allow_nan) {
+                    writer.RawValue("Infinity", 8, kObjectType);
+                } else {
+                    rb_raise(rb_eEncodeError, "Float::INFINITY is not allowed in JSON");
+                }
+            } else if (isnan(f)) {
+                if (allow_nan) {
+                    writer.RawValue("NaN", 3, kObjectType);
+                } else {
+                    rb_raise(rb_eEncodeError, "Float::NAN is not allowed in JSON");
+                }
+            }
+        } else {
+            writer.Double(f);
+        }
     }
 
     void encode_string(VALUE v) {
+        v = string_to_utf8_compatible(v);
         writer.String(RSTRING_PTR(v), RSTRING_LEN(v), false);
     }
 
@@ -92,22 +140,20 @@ class RubyObjectEncoder {
         const char *cstr = RSTRING_PTR(s);
         size_t len = RSTRING_LEN(s);
 
-	writer.RawValue(cstr, len, kObjectType);
+        writer.RawValue(cstr, len, kObjectType);
     }
 
     void encode_generic(VALUE obj) {
-        if (rb_respond_to(obj, id_to_json)) {
-            VALUE str = rb_funcall(obj, id_to_json, 0);
-            Check_Type(str, T_STRING);
-            encode_raw_json_str(str);
-        } else {
-            VALUE str = rb_funcall(obj, id_to_s, 0);
-            Check_Type(str, T_STRING);
-            encode_string(str);
+        if (NIL_P(as_json)) {
+            rb_raise(rb_eTypeError, "Don't know how to serialize %" PRIsVALUE " to JSON", rb_obj_class(obj));
+            UNREACHABLE_RETURN();
         }
+
+        VALUE args[2] = { obj, Qfalse };
+        encode_any(rb_proc_call_with_block(as_json, 2, args, Qnil), false);
     }
 
-    void encode_any(VALUE v) {
+    void encode_any(VALUE v, bool generic) {
         switch(rb_type(v)) {
             case T_NIL:
                 writer.Null();
@@ -123,7 +169,7 @@ class RubyObjectEncoder {
             case T_BIGNUM:
                 return encode_bignum(v);
             case T_FLOAT:
-                return encode_float(v);
+                return encode_float(v, generic);
             case T_HASH:
                 return encode_hash(v);
             case T_ARRAY:
@@ -132,19 +178,32 @@ class RubyObjectEncoder {
                 return encode_string(v);
             case T_SYMBOL:
                 return encode_symbol(v);
+            case T_STRUCT:
+                if (rb_obj_class(v) == rb_cRapidJSONFragment) {
+                    VALUE str = rb_struct_aref(v, INT2FIX(0));
+                    Check_Type(str, T_STRING);
+                    return encode_raw_json_str(str);
+                }
+                // fall through
             default:
-                encode_generic(v);
+                if (generic) {
+                    encode_generic(v);
+                } else {
+                    rb_raise(rb_eTypeError, "Don't know how to serialize %" PRIsVALUE " to JSON", rb_obj_class(v));
+                }
         }
     }
 
     public:
-        RubyObjectEncoder(): buf(), writer(buf), depth(0) {
+        RubyObjectEncoder(VALUE as_json_proc, bool allow_nan_): buf(), writer(buf), depth(0) {
+            as_json = as_json_proc;
+            allow_nan = allow_nan_;
         };
 
         int depth;
 
         VALUE encode(VALUE obj) {
-            encode_any(obj);
+            encode_any(obj, true);
             return buf.GetRubyString();
         }
 };

data/ext/rapidjson/extconf.rb

@@ -14,6 +14,6 @@ $CXXFLAGS += " -fsanitize=address"
 $LDFLAGS += " -fsanitize=address"
 end
 
-have_func("rb_interned_str", "ruby.h")
+have_func("rb_enc_interned_str", "ruby.h")
 
 create_makefile("rapidjson/rapidjson")

data/ext/rapidjson/parser.hh

@@ -63,10 +63,10 @@ struct RubyObjectHandler : public BaseReaderHandler<UTF8<>, RubyObjectHandler> {
     }
 
     bool Key(const char* str, SizeType length, bool copy) {
-#ifdef HAVE_RB_INTERNED_STR
+#ifdef HAVE_RB_ENC_INTERNED_STR
         VALUE val = rb_enc_interned_str(str, length, rb_utf8_encoding());
 #else
-        VALUE val = rb_str_new(str, length);
+        VALUE val = rb_enc_str_new(str, length, rb_utf8_encoding());
 #endif
         return PutKey(val);
     }

data/lib/rapidjson/active_support_encoder.rb

@@ -0,0 +1,26 @@
+module RapidJSON
+  class ActiveSupportEncoder
+    def initialize(options = nil)
+      @options = options
+      @coder = RapidJSON::Coder.new do |value, is_key|
+        if is_key
+          value.to_s
+        else
+          value.as_json
+        end
+      end
+    end
+
+    # Encode the given object into a JSON string
+    def encode(value)
+      if @options && !@options.empty?
+        value = value.as_json(@options.dup)
+      end
+      json = @coder.dump(value)
+      if ActiveSupport::JSON::Encoding.escape_html_entities_in_json
+        json = RapidJSON.json_escape(json)
+      end
+      json
+    end
+  end
+end

data/lib/rapidjson/json_gem.rb

@@ -1,36 +1,87 @@
-module ::Kernel
-  def JSON(object, opts = {})
-    if object.respond_to? :to_s
-      JSON.parse(object.to_s)
-    else
-      JSON.generate(object, opts)
+require "json"
+
+module RapidJSON
+  module JSONGem
+    GeneratorError = RapidJSON::EncodeError
+
+    GEM = ::JSON
+    private_constant :GEM
+
+    STATE = ::JSON::State.new
+    private_constant :STATE
+
+    TO_JSON_PROC = lambda do |object, is_key|
+      if !is_key && object.respond_to?(:to_json)
+        if Float === object
+          # Avoid calling .to_json on NaN/Infinity/-Infinity
+          # Prefers our exception to one raised by ::JSON
+          object
+        else
+          Fragment.new(object.to_json(STATE))
+        end
+      elsif object.respond_to?(:to_s)
+        object.to_s
+      else
+        raise TypeError, "Can't serialize #{object.class} to JSON"
+      end
     end
-  end
-end
+    private_constant :TO_JSON_PROC
 
-module JSON
-  def self.generate(obj, opts=nil)
-    RapidJSON.encode(obj)
-  end
+    GENERATE_CODER = Coder.new(&TO_JSON_PROC)
+    private_constant :GENERATE_CODER
 
-  def self.pretty_generate(obj, opts=nil)
-    RapidJSON.pretty_encode(obj)
-  end
+    DUMP_CODER = Coder.new(allow_nan: true, &TO_JSON_PROC)
+    private_constant :DUMP_CODER
 
-  def self.dump(obj)
-    RapidJSON.encode(obj)
-  end
-end
+    PRETTY_CODER = Coder.new(pretty: true, &TO_JSON_PROC)
+    private_constant :PRETTY_CODER
 
-# to_json
-module RapidJSON
-  module JSONGemCompact
-    def to_json(opts=nil)
-      RapidJSON.encode(self)
+    # Note, we very explictly fallback to the JSON gem when we receive unknown options.
+    # Unknown options may be required for security reasons (e.g. escape_slash: true)
+    # so ignoring them could lead to security vulnerabilities.
+    class << self
+      def load(string, proc = nil, options = nil)
+        if proc.nil? && options.nil?
+          DEFAULT_CODER.load(string)
+        else
+          GEM.load(string, proc, options)
+        end
+      end
+
+      def parse(string, opts = nil)
+        if opts.nil?
+          DEFAULT_CODER.load(string)
+        else
+          GEM.load(string, options)
+        end
+      end
+
+      def dump(object, anIO = nil, limit = nil)
+        if anIO.nil? && limit.nil?
+          DUMP_CODER.dump(object)
+        else
+          GEM.dump(object, anIO, limit)
+        end
+      end
+
+      def generate(object, opts = nil)
+        if opts.nil?
+          GENERATE_CODER.dump(object)
+        else
+          GEM.generate(object, opts)
+        end
+      end
+
+      private
+
+      def method_missing(name, *args)
+        GEM.public_send(name, *args)
+      end
+      ruby2_keywords :method_missing
+
+      def respond_to_missing?(name, include_private = false)
+        GEM.respond_to?(name, include_private)
+      end
     end
   end
 end
-
-[Hash, Array, String, Integer, Float, TrueClass, FalseClass, NilClass].each do |klass|
-  klass.include RapidJSON::JSONGemCompact
-end

data/lib/rapidjson/version.rb

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

data/lib/rapidjson.rb

@@ -1,9 +1,54 @@
 # frozen_string_literal: true
 
 require_relative "rapidjson/version"
-require_relative "rapidjson/rapidjson"
 
-module Rapidjson
+module RapidJSON
   class Error < StandardError; end
-  # Your code goes here...
+
+  Fragment = Struct.new(:to_json)
+
+  class Coder
+    def initialize(pretty: false, allow_nan: false, &to_json)
+      @pretty = pretty
+      @to_json_proc = to_json
+      @allow_nan = allow_nan
+    end
+
+    def dump(object)
+      _dump(object, @pretty, @to_json_proc, @allow_nan)
+    end
+  end
+end
+
+require_relative "rapidjson/rapidjson"
+
+module RapidJSON
+  class << self
+    def load(string)
+      DEFAULT_CODER.load(string)
+    end
+    alias_method :parse, :load
+
+    def dump(object)
+      DEFAULT_CODER.dump(object)
+    end
+    alias_method :encode, :dump
+
+    def pretty_encode(object)
+      PRETTY_CODER.dump(object)
+    end
+
+    def valid_json?(string)
+      DEFAULT_CODER.valid_json?(string)
+    end
+  end
+
+  DEFAULT_CODER = Coder.new
+  private_constant :DEFAULT_CODER
+
+  PRETTY_CODER = Coder.new(pretty: true)
+  private_constant :PRETTY_CODER
 end
+
+require "rapidjson/json_gem"
+require "rapidjson/active_support_encoder"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rapidjson
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-05 00:00:00.000000000 Z
+date: 2023-06-27 00:00:00.000000000 Z
 dependencies: []
 description: Fast JSON encoder/decoder based using RapidJSON
 email:
@@ -67,6 +67,7 @@ files:
 - ext/rapidjson/rapidjson/include/rapidjson/uri.h
 - ext/rapidjson/rapidjson/include/rapidjson/writer.h
 - lib/rapidjson.rb
+- lib/rapidjson/active_support_encoder.rb
 - lib/rapidjson/json_gem.rb
 - lib/rapidjson/version.rb
 homepage: https://github.com/jhawthorn/rapidjson
@@ -91,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Fast JSON encoder/decoder based using RapidJSON