usamin 7.7.9 → 7.7.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db59b9c360567cf33fca6506bbd06ad9b31c1382a09b31d13cd1c81c530fbdd0
-  data.tar.gz: c675678f1eec5cd39fae70733f36302664e020981a5d850c12536d755e9c9d7d
+  metadata.gz: f1416f23892e15634eafdbb8536499e785802ac5ca3ff9ac7bc8a9b6f47add00
+  data.tar.gz: cfdb20662dce9920a52a48f0e7c17d82943d94d7212d8ad19897b150291058cb
 SHA512:
-  metadata.gz: 78f82ae393b94944759de05c6e8dcc01524b9e60041f9fb13c72dbf43319265f6ad3aef8c226f23dcd8e205ee8385d0a773b7a1271a403b81bc6f093fca928ac
-  data.tar.gz: e51369d0d04fb97f9018c0734f3f72df4c404388234baa5f9db61b8c36380f2c197626df512906d3241dbbdc75938946a8d657e086f0263d3b94dc63afa46f03
+  metadata.gz: e7ef1f8f1eba35b68a94b28f18865c0bec6b0be3e4c145ab8fd86806fc7deace8d7ca1515c89c51bb35bec7a296db122963226583d1f0351dea38e3ec96ef9c7
+  data.tar.gz: 3a456c76021b846a04573bfda63c2dc2ab0935e01571ed61e4dbf05c233bb58a2bbf5af1ffb04a3328ad1696bb353e081065e745bc0f6bb2564445f4935171b7

data/README.md

@@ -88,6 +88,9 @@ Objects also can be handled like Hash objects.
 data.first['name']
 #=> "miku maekawa"
 
+data.first[:name]
+#=> "miku maekawa"
+
 data.first.keys
 #=> ["name", "age", "height", "weight", "body_size", "birthday", "cv"]
 ```
@@ -105,6 +108,21 @@ data.first.eval_r
 Usamin.load(json).eval_r
 ```
 
+Usamin supports pattern matching, which is introduced in Ruby 2.7.0.
+
+Note that all keys are treated as symbols in pattern matching.
+
+```ruby
+data = Usamin.load('{"maekawa": "miku", "osaki": ["tenka", "amana"], "hisakawa": { "hayate": "haa", "nagi": "naa" }}')
+#=> {"maekawa"=>"miku", "osaki"=>[...], "hisakawa"=>{...}}
+
+case data
+in maekawa:, hisakawa: {**sisters}
+    sisters
+end
+#=> {:hayate=>"haa", :nagi=>"naa"}
+```
+
 #### Notes about lazy loading data
 
 - Frozen. Modification is not allowed.
@@ -210,76 +228,78 @@ Usamin and JSON load the same data from 3 big json data in nativejson-benchmark.
 
 The values show the elapsed time for operating 20 times. SSE4.2 was enabled in these tests.
 
+Ruby 2.7.0-rc2. json 2.3.0, oj 3.10.0, usamin 7.7.10 (rapidjson 1.1.0).
+
 #### Parsing
 
 ```
 nativejson-benchmark/data/canada.json
-json                     0.743695   0.005426   0.749121 (  0.751004)
-oj                       1.779671   0.039642   1.819313 (  1.824576)
-usamin                   0.510856   0.013166   0.524022 (  0.525174)
-usamin (fast)            0.258916   0.007298   0.266214 (  0.267910)
-usamin (load)            0.403337   0.010124   0.413461 (  0.414023)
-usamin (load / fast)     0.164099   0.020126   0.184225 (  0.184817)
+json                     0.734855   0.005684   0.740539 (  0.743125)
+oj                       1.906612   0.022766   1.929378 (  1.938912)
+usamin                   0.546606   0.016939   0.563545 (  0.565339)
+usamin (fast)            0.221778   0.013511   0.235289 (  0.235782)
+usamin (load)            0.467457   0.018688   0.486145 (  0.487849)
+usamin (load / fast)     0.166556   0.025738   0.192294 (  0.192736)
 
 nativejson-benchmark/data/citm_catalog.json
-json                     0.481490   0.006217   0.487707 (  0.490407)
-oj                       0.337618   0.002676   0.340294 (  0.340697)
-usamin                   0.363082   0.005774   0.368856 (  0.370124)
-usamin (fast)            0.348798   0.005620   0.354418 (  0.355544)
-usamin (load)            0.114139   0.004866   0.119005 (  0.119659)
-usamin (load / fast)     0.101378   0.004685   0.106063 (  0.106161)
+json                     0.339319   0.004765   0.344084 (  0.345174)
+oj                       0.224548   0.000997   0.225545 (  0.225837)
+usamin                   0.278662   0.003313   0.281975 (  0.285040)
+usamin (fast)            0.232262   0.001691   0.233953 (  0.234662)
+usamin (load)            0.111687   0.006829   0.118516 (  0.118821)
+usamin (load / fast)     0.072404   0.007138   0.079542 (  0.079620)
 
 nativejson-benchmark/data/twitter.json
-json                     0.242091   0.004512   0.246603 (  0.246985)
-oj                       0.165441   0.000833   0.166274 (  0.166517)
-usamin                   0.179744   0.000353   0.180097 (  0.180320)
-usamin (fast)            0.181126   0.000577   0.181703 (  0.182080)
-usamin (load)            0.061376   0.000944   0.062320 (  0.062647)
-usamin (load / fast)     0.064891   0.001240   0.066131 (  0.067542)
+json                     0.208798   0.004463   0.213261 (  0.213952)
+oj                       0.134336   0.000970   0.135306 (  0.135999)
+usamin                   0.174997   0.000755   0.175752 (  0.176467)
+usamin (fast)            0.176687   0.001193   0.177880 (  0.179466)
+usamin (load)            0.062983   0.004450   0.067433 (  0.067547)
+usamin (load / fast)     0.063495   0.006539   0.070034 (  0.071615)
 ```
 
 #### Generating
 
 ```
 nativejson-benchmark/data/canada.json
-json                     1.964397   0.024287   1.988684 (  1.993397)
-oj                       2.070033   0.028986   2.099019 (  2.107441)
-usamin                   0.247659   0.018489   0.266148 (  0.266663)
-usamin (load)            0.246872   0.027028   0.273900 (  0.274989)
+json                     2.039965   0.015920   2.055885 (  2.065514)
+oj                       2.008353   0.004610   2.012963 (  2.016850)
+usamin                   0.276563   0.015915   0.292478 (  0.294615)
+usamin (load)            0.256360   0.010180   0.266540 (  0.268350)
 
 nativejson-benchmark/data/citm_catalog.json
-json                     0.244533   0.009066   0.253599 (  0.255088)
-oj                       0.069532   0.008088   0.077620 (  0.077661)
-usamin                   0.058047   0.009538   0.067585 (  0.067694)
-usamin (load)            0.038105   0.009722   0.047827 (  0.047993)
+json                     0.068053   0.004018   0.072071 (  0.072138)
+oj                       0.060933   0.003070   0.064003 (  0.064161)
+usamin                   0.056743   0.008311   0.065054 (  0.065449)
+usamin (load)            0.037438   0.003680   0.041118 (  0.041461)
 
 nativejson-benchmark/data/twitter.json
-json                     0.160310   0.006469   0.166779 (  0.167137)
-oj                       0.042114   0.004044   0.046158 (  0.046254)
-usamin                   0.038971   0.004943   0.043914 (  0.044313)
-usamin (load)            0.029375   0.004385   0.033760 (  0.033882)
+json                     0.040689   0.003881   0.044570 (  0.044641)
+oj                       0.038957   0.003410   0.042367 (  0.042525)
+usamin                   0.037130   0.005539   0.042669 (  0.042951)
+usamin (load)            0.031568   0.003316   0.034884 (  0.035690)
 ```
 
 #### Pretty Generating
 
 ```
 nativejson-benchmark/data/canada.json
-json                     2.224924   0.089327   2.314251 (  2.320405)
-oj                       1.624790   0.022204   1.646994 (  1.650566)
-usamin                   0.356511   0.084944   0.441455 (  0.442372)
-usamin (load)            0.334884   0.076830   0.411714 (  0.412275)
+json                     2.247403   0.056727   2.304130 (  2.312832)
+oj                       1.560007   0.005153   1.565160 (  1.569151)
+usamin                   0.353357   0.063384   0.416741 (  0.418236)
+usamin (load)            0.341948   0.055289   0.397237 (  0.399525)
 
 nativejson-benchmark/data/citm_catalog.json
-json                     0.302005   0.017108   0.319113 (  0.322104)
-oj                       0.071386   0.008597   0.079983 (  0.080194)
-usamin                   0.099413   0.021275   0.120688 (  0.121417)
-usamin (load)            0.060486   0.021065   0.081551 (  0.081808)
+json                     0.128840   0.008824   0.137664 (  0.139104)
+oj                       0.061869   0.004010   0.065879 (  0.067000)
+usamin                   0.071300   0.005988   0.077288 (  0.077439)
+usamin (load)            0.048758   0.004353   0.053111 (  0.053186)
 
 nativejson-benchmark/data/twitter.json
-json                     0.170121   0.011923   0.182044 (  0.182585)
-oj                       0.035700   0.006364   0.042064 (  0.042099)
-usamin                   0.040141   0.006321   0.046462 (  0.046556)
-usamin (load)            0.036990   0.005729   0.042719 (  0.042816)
+json                     0.060095   0.004639   0.064734 (  0.065314)
+oj                       0.037025   0.004194   0.041219 (  0.041495)
+usamin                   0.053145   0.011938   0.065083 (  0.065184)
+usamin (load)            0.034704   0.002547   0.037251 (  0.037505)
 ```
 
 ## Contributing

data/Rakefile

@@ -1,18 +1,20 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
 end
 
-require "rake/extensiontask"
+require 'rake/extensiontask'
 
-task :build => :compile
+task build: :compile
 
-Rake::ExtensionTask.new("usamin") do |ext|
-  ext.lib_dir = "lib/usamin"
+Rake::ExtensionTask.new('usamin') do |ext|
+  ext.lib_dir = 'lib/usamin'
 end
 
-task :default => [:clobber, :compile, :test]
+task default: %i[clobber compile test]

data/ext/usamin/default_parse_flags.hpp

@@ -0,0 +1,6 @@
+#define RAPIDJSON_PARSE_DEFAULT_FLAGS                                                                      \
+    (rapidjson::kParseIterativeFlag | rapidjson::kParseFullPrecisionFlag | rapidjson::kParseCommentsFlag | \
+     rapidjson::kParseTrailingCommasFlag | rapidjson::kParseNanAndInfFlag)
+#define RAPIDJSON_PARSE_FAST_FLAGS (RAPIDJSON_PARSE_DEFAULT_FLAGS & ~rapidjson::kParseFullPrecisionFlag)
+#define RAPIDJSON_PARSE_FLAGS_FOR_MARSHAL \
+    (rapidjson::kParseIterativeFlag | rapidjson::kParseFullPrecisionFlag | rapidjson::kParseNanAndInfFlag)

data/ext/usamin/extconf.rb

@@ -1,18 +1,27 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 
 RbConfig::MAKEFILE_CONFIG['CXX'] = ENV['CXX'] if ENV['CXX']
 have_library('stdc++')
+have_library('m')
 dir_config('rapidjson')
 append_cppflags('-O3')
 append_cppflags('-Wall')
+append_cppflags('-Wextra')
+append_cppflags('-Wno-missing-field-initializers')
+append_cppflags('-Wvla')
 
-if checking_for("whether -march=native is accepted as CPPFLAGS"){try_cppflags('-march=native')}
-    if checking_for("whether -msse4.2 is accepted as CPPFLAGS"){try_cppflags('-msse4.2')}
-        $CPPFLAGS << ' -msse4.2 -march=native'
-    elsif checking_for("whether -msse2 is accepted as CPPFLAGS"){try_cppflags('-msse2')}
-        $CPPFLAGS << ' -msse2 -march=native'
-    end
+if checking_for('whether -march=native is accepted as CPPFLAGS'){try_cppflags('-march=native')}
+  if checking_for('whether -msse4.2 is accepted as CPPFLAGS'){try_cppflags('-msse4.2')}
+    $CPPFLAGS << ' -msse4.2 -march=native'
+  elsif checking_for('whether -msse2 is accepted as CPPFLAGS'){try_cppflags('-msse2')}
+    $CPPFLAGS << ' -msse2 -march=native'
+  end
 end
 
 $CPPFLAGS << ' -std=c++11'
+
+$CPPFLAGS << ' -DRAPIDJSON_IS_HEAD' if arg_config('--rapidjson-is-head')
+
 create_makefile('usamin/usamin')

data/ext/usamin/generator.cpp

@@ -0,0 +1,226 @@
+#include "rb270_fix.hpp"
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/writer.h>
+#include <ruby.h>
+#include <ruby/version.h>
+#include "rb_common.hpp"
+#include "rb_usamin_value.hpp"
+#include "rubynized_rapidjson.hpp"
+
+#define WRITER_CONFIGS rapidjson::UTF8<>, rapidjson::UTF8<>, RubyCrtAllocator, rapidjson::kWriteNanAndInfFlag
+
+template <class Writer>
+static inline void write_hash(Writer &, const VALUE);
+template <class Writer>
+static inline void write_array(Writer &, const VALUE);
+template <class Writer>
+static inline void write_struct(Writer &, const VALUE);
+template <class Writer>
+static inline void write_usamin(Writer &, const VALUE);
+
+template <class Writer>
+static inline void write_str(Writer &writer, const VALUE value) {
+    VALUE v = get_utf8_str(value);
+    writer.String(RSTRING_PTR(v), RSTRING_LENINT(v));
+}
+
+template <class Writer>
+static inline void write_to_s(Writer &writer, const VALUE value) {
+    extern ID id_to_s;
+    write_str(writer, rb_funcall(value, id_to_s, 0));
+}
+
+template <class Writer>
+static void write(Writer &writer, const VALUE value) {
+    extern VALUE rb_cUsaminValue;
+    switch (TYPE(value)) {
+    case RUBY_T_NONE:
+    case RUBY_T_NIL:
+    case RUBY_T_UNDEF:
+        writer.Null();
+        break;
+    case RUBY_T_TRUE:
+        writer.Bool(true);
+        break;
+    case RUBY_T_FALSE:
+        writer.Bool(false);
+        break;
+    case RUBY_T_FIXNUM:
+        writer.Int64(FIX2LONG(value));
+        break;
+    case RUBY_T_FLOAT:
+    case RUBY_T_RATIONAL:
+        writer.Double(NUM2DBL(value));
+        break;
+    case RUBY_T_STRING:
+        write_str(writer, value);
+        break;
+    case RUBY_T_ARRAY:
+        write_array(writer, value);
+        break;
+    case RUBY_T_HASH:
+        write_hash(writer, value);
+        break;
+    case RUBY_T_STRUCT:
+        write_struct(writer, value);
+        break;
+    case RUBY_T_BIGNUM: {
+        VALUE v = rb_big2str(value, 10);
+        writer.RawValue(RSTRING_PTR(v), RSTRING_LEN(v), rapidjson::kNumberType);
+    } break;
+    default:
+        if (rb_obj_is_kind_of(value, rb_cUsaminValue))
+            write_usamin(writer, value);
+        else
+            write_to_s(writer, value);
+        break;
+    }
+}
+
+template <class Writer>
+static inline void write_key_str(Writer &writer, const VALUE value) {
+    VALUE v = get_utf8_str(value);
+    writer.Key(RSTRING_PTR(v), RSTRING_LENINT(v));
+}
+
+template <class Writer>
+static inline void write_key_to_s(Writer &writer, const VALUE value) {
+    extern ID id_to_s;
+    write_key_str(writer, rb_funcall(value, id_to_s, 0));
+}
+
+template <class Writer>
+static inline int write_hash_each(const VALUE key, const VALUE value, VALUE writer_v) {
+    Writer *writer = reinterpret_cast<Writer *>(writer_v);
+    if (RB_TYPE_P(key, T_STRING))
+        write_key_str(*writer, key);
+    else if (RB_TYPE_P(key, T_SYMBOL))
+        write_key_str(*writer, rb_sym_to_s(key));
+    else
+        write_key_to_s(*writer, key);
+    write(*writer, value);
+    return ST_CONTINUE;
+}
+
+template <class Writer>
+static inline void write_hash(Writer &writer, const VALUE hash) {
+    writer.StartObject();
+#if RUBY_API_VERSION_CODE < 20700
+    rb_hash_foreach(hash, (int (*)(ANYARGS))write_hash_each<Writer>, reinterpret_cast<VALUE>(&writer));
+#else
+    rb_hash_foreach(hash, write_hash_each<Writer>, reinterpret_cast<VALUE>(&writer));
+#endif
+    writer.EndObject();
+}
+
+template <class Writer>
+static inline void write_array(Writer &writer, const VALUE value) {
+    writer.StartArray();
+    const VALUE *ptr = rb_array_const_ptr(value);
+    for (long i = 0; i < rb_array_len(value); i++, ptr++)
+        write(writer, *ptr);
+    writer.EndArray();
+}
+
+template <class Writer>
+static inline void write_struct(Writer &writer, const VALUE value) {
+    writer.StartObject();
+    VALUE members = rb_struct_members(value);
+    const VALUE *ptr = rb_array_const_ptr(members);
+    for (long i = 0; i < rb_array_len(members); i++, ptr++) {
+        if (RB_TYPE_P(*ptr, T_SYMBOL))
+            write_key_str(writer, rb_sym_to_s(*ptr));
+        else if (RB_TYPE_P(*ptr, T_STRING))
+            write_key_str(writer, *ptr);
+        else
+            write_key_to_s(writer, *ptr);
+        write(writer, rb_struct_aref(value, *ptr));
+    }
+    writer.EndObject();
+}
+
+template <class Writer>
+static inline void write_usamin(Writer &writer, const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_value(value);
+    value->value->Accept(writer);
+}
+
+/*
+ * Generate the JSON string from Ruby data structures.
+ *
+ * @overload generate(obj)
+ *   @param [Object] obj an object to serialize
+ *   @return [String]
+ */
+VALUE w_generate(const VALUE, const VALUE value) {
+    rapidjson::StringBuffer buf;
+    rapidjson::Writer<rapidjson::StringBuffer, WRITER_CONFIGS> writer(buf);
+    write(writer, value);
+    return new_utf8_str(buf.GetString(), buf.GetSize());
+}
+
+/*
+ * Generate the prettified JSON string from Ruby data structures.
+ *
+ * @overload pretty_generate(obj, opts = {})
+ *   @param [Object] obj an object to serialize
+ *   @param [::Hash] opts options
+ *   @option opts [String] :indent ('  ') a string used to indent
+ *   @option opts [Boolean] :single_line_array (false)
+ *   @return [String]
+ */
+VALUE w_pretty_generate(const int argc, const VALUE *argv, const VALUE) {
+    extern VALUE rb_eUsaminError;
+    extern VALUE sym_indent, sym_single_line_array;
+
+    VALUE value, options;
+    rb_scan_args(argc, argv, "1:", &value, &options);
+    rapidjson::StringBuffer buf;
+#if RAPIDJSON_VERSION_CODE(RAPIDJSON_MAJOR_VERSION, RAPIDJSON_MINOR_VERSION, RAPIDJSON_PATCH_VERSION) > RAPIDJSON_VERSION_CODE(1, 1, 0) || defined(RAPIDJSON_IS_HEAD)
+    rapidjson::PrettyWriter<rapidjson::StringBuffer, WRITER_CONFIGS> writer(buf);
+#else
+    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buf);
+#endif
+
+    char indent_char = ' ';
+    unsigned int indent_count = 2;
+    if (!NIL_P(options)) {
+        VALUE v_indent = rb_hash_lookup(options, sym_indent);
+        if (RTEST(v_indent)) {
+            if (RB_FIXNUM_P(v_indent)) {
+                int l = FIX2INT(v_indent);
+                indent_count = l > 0 ? l : 0;
+            } else {
+                int vlen = RSTRING_LENINT(v_indent);
+                if (vlen == 0) {
+                    indent_count = 0;
+                } else {
+                    const char *indent_str = RSTRING_PTR(v_indent);
+                    switch (indent_str[0]) {
+                    case ' ':
+                    case '\t':
+                    case '\r':
+                    case '\n':
+                        indent_char = indent_str[0];
+                        break;
+                    default:
+                        rb_raise(rb_eUsaminError,
+                                 ":indent must be a repetation of \" \", \"\\t\", \"\\r\" or \"\\n\".");
+                    }
+                    for (long i = 1; i < vlen; i++)
+                        if (indent_str[0] != indent_str[i])
+                            rb_raise(rb_eUsaminError,
+                                     ":indent must be a repetation of \" \", \"\\t\", \"\\r\" or \"\\n\".");
+                    indent_count = vlen;
+                }
+            }
+        }
+        if (RTEST(rb_hash_lookup(options, sym_single_line_array)))
+            writer.SetFormatOptions(rapidjson::kFormatSingleLineArray);
+    }
+    writer.SetIndent(indent_char, indent_count);
+
+    write(writer, value);
+    return new_utf8_str(buf.GetString(), buf.GetSize());
+}

data/ext/usamin/generator.hpp

@@ -0,0 +1,11 @@
+#ifndef USAMIN_GENERATOR_HPP
+#define USAMIN_GENERATOR_HPP
+
+#include <rapidjson/writer.h>
+#include <ruby.h>
+#include "rubynized_rapidjson.hpp"
+
+VALUE w_generate(const VALUE self, const VALUE value);
+VALUE w_pretty_generate(const int argc, const VALUE *argv, const VALUE self);
+
+#endif

data/ext/usamin/parser.cpp

@@ -0,0 +1,101 @@
+#include "rb270_fix.hpp"
+#include "default_parse_flags.hpp"
+#include <rapidjson/reader.h>
+#include <rapidjson/error/en.h>
+#include "parser.hpp"
+#include <ruby.h>
+#include "rb_common.hpp"
+#include "rubynized_rapidjson.hpp"
+#include "usamin_value.hpp"
+#include "parser_helper.hpp"
+
+static inline rapidjson::ParseResult parse(RubynizedDocument &doc, const VALUE str, bool fast = false,
+                                           bool recursive = false) {
+    volatile VALUE v = get_utf8_str(str);
+#define PARSE_WITH_FLAGS(flags) return doc.Parse<flags>(RSTRING_PTR(v), RSTRING_LEN(v))
+    if (recursive)
+        if (fast)
+            PARSE_WITH_FLAGS(RAPIDJSON_PARSE_FAST_FLAGS & ~rapidjson::kParseIterativeFlag);
+        else
+            PARSE_WITH_FLAGS(RAPIDJSON_PARSE_DEFAULT_FLAGS & ~rapidjson::kParseIterativeFlag);
+    else if (fast)
+        PARSE_WITH_FLAGS(RAPIDJSON_PARSE_FAST_FLAGS);
+    else
+        PARSE_WITH_FLAGS(RAPIDJSON_PARSE_DEFAULT_FLAGS);
+#undef PARSE_WITH_FLAGS
+}
+
+/*
+ * Parse the JSON string into UsaminValue.
+ * If the document root is not an object or an array, the same value as {#parse} will be returned.
+ *
+ * @overload load(source, opts = {})
+ *   @param [String] source JSON string to parse
+ *   @param [::Hash] opts options
+ *   @option opts :fast fast mode (but not precise)
+ *   @option opts :recursive non-iterative (recursive) mode (fast but not safe, can cause SystemStackError and illegal hardware instruction)
+ *   @return [Object]
+ */
+VALUE w_load(const int argc, const VALUE *argv, const VALUE) {
+    extern VALUE rb_eUsaminError, rb_eParserError, sym_fast, sym_recursive;
+
+    VALUE source, options;
+    rb_scan_args(argc, argv, "1:", &source, &options);
+    RubynizedDocument *doc = new RubynizedDocument;
+    auto result = parse(*doc, source, test_option(options, sym_fast), test_option(options, sym_recursive));
+    if (!result) {
+        delete doc;
+        rb_raise(rb_eParserError, "%s Offset: %lu", GetParseError_En(result.Code()), result.Offset());
+    }
+
+    VALUE ret;
+    switch (doc->GetType()) {
+    case rapidjson::kNullType:
+        delete doc;
+        return Qnil;
+    case rapidjson::kFalseType:
+        delete doc;
+        return Qfalse;
+    case rapidjson::kTrueType:
+        delete doc;
+        return Qtrue;
+    case rapidjson::kObjectType:
+        return make_hash(new UsaminValue(doc, true), true);
+    case rapidjson::kArrayType:
+        return make_array(new UsaminValue(doc, true), true);
+    case rapidjson::kStringType:
+        ret = eval_str(*doc);
+        delete doc;
+        return ret;
+    case rapidjson::kNumberType:
+        ret = eval_num(*doc);
+        delete doc;
+        return ret;
+    default:
+        rb_raise(rb_eUsaminError, "unknown value type: %d", doc->GetType());
+        return Qnil;
+    }
+}
+
+/*
+ * Parse the JSON string into Ruby data structures.
+ *
+ * @overload parse(source, opts = {})
+ *   @param [String] source a JSON string to parse
+ *   @param [::Hash] opts options
+ *   @option opts :fast fast mode (but not precise)
+ *   @option opts :recursive non-iterative (recursive) mode (fast but not safe, can cause SystemStackError and illegal hardware instruction)
+ *   @option opts :symbolize_names symbolize keys of all Hash objects
+ *   @return [Object]
+ */
+VALUE w_parse(const int argc, const VALUE *argv, const VALUE) {
+    extern VALUE rb_eParserError, sym_fast, sym_recursive, sym_symbolize_names;
+
+    VALUE source, options;
+    rb_scan_args(argc, argv, "1:", &source, &options);
+    RubynizedDocument doc;
+    auto result = parse(doc, source, test_option(options, sym_fast), test_option(options, sym_recursive));
+    if (!result)
+        rb_raise(rb_eParserError, "%s Offset: %lu", GetParseError_En(result.Code()), result.Offset());
+    return eval_r(doc, test_option(options, sym_symbolize_names));
+}

data/ext/usamin/parser.hpp

@@ -0,0 +1,9 @@
+#ifndef USAMIN_PARSER_HPP
+#define USAMIN_PARSER_HPP
+
+#include <ruby.h>
+
+VALUE w_load(const int argc, const VALUE *argv, const VALUE self);
+VALUE w_parse(const int argc, const VALUE *argv, const VALUE self);
+
+#endif