usamin 7.7.6 → 7.7.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 578850ff19b39ff8950a5d31f890d78cef055935521637ab28cbcda311d1739d
-  data.tar.gz: 95705ef10f8fc3dcdf3687d9670638a981c081154cbc1dcdd85b3cb7a9821683
+  metadata.gz: 5c1850442411d90d31a98e9d3286b773852a1e855ba32227b1d266ea2ae2581f
+  data.tar.gz: 4382e4499525e5aa163e023feb62f4e839bc98dd3540a11112ee6b3334d632c1
 SHA512:
-  metadata.gz: d95d14dcdfa3578c75699f529e5d324ef47f4e4eba6961efd76136bcaee3b01d50f35cace24c018824de6b48a3cac96e1c0d1ad3c43a72e17f1a882847b6c4c7
-  data.tar.gz: b4f9a8f2cef31b7e7dcfe1e876b59f9164322af8db9a7b970a944559c19d9c83d9490b5dd1c819b34f3f02ec1aa7f83003700c7c243a7af2d2ed96da9947c3cd
+  metadata.gz: 27d1e300cb0242087202b903ef425ff25d81b1249834111f1302d060e7991e9e665f34f2674a8da5f90647bc9448417141925cd6fad06bdd5783f79fc59bea0f
+  data.tar.gz: 0133a944f187fed3deb2f295fd2e18b9386d52a1f87f3873f58ab37b530de591812f29c422558c35e180b65ebb73ff94d4ca9669dc027c6f47716018538e0004

data/.gitignore

@@ -16,3 +16,4 @@ Gemfile.lock
 .DS_Store
 /testdata/
 /vendor/
+/.vscode/

data/README.md

@@ -69,9 +69,10 @@ Usamin.parse(json)
 
 ```ruby
 data = Usamin.load(json)
+#=> => [{...}, {...}]
 ```
 
-Here, `data` is not a Array, but this can be handled like an Array.
+Here, `data` is not an Array, but this can be handled like an Array.
 
 ```ruby
 data.size
@@ -87,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"]
 ```
@@ -104,10 +108,25 @@ 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.
-- A key list of Hash is based on not hash tables but arrays. An index access to hash costs O(n).
+- Hash objects are based on not hash tables but arrays. An index access to an object costs O(n).
 
 ### Generating
 
@@ -207,78 +226,80 @@ Usamin and JSON load the same data from 3 big json data in nativejson-benchmark.
 
 ### Performance
 
-The values show the elapsed time for operating 20 times.
+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.755101   0.004066   0.759167 (  0.762169)
-oj                       1.873840   0.040992   1.914832 (  1.919647)
-usamin                   0.582432   0.011584   0.594016 (  0.596472)
-usamin (fast)            0.271741   0.004775   0.276516 (  0.278315)
-usamin (load)            0.458602   0.009857   0.468459 (  0.471155)
-usamin (load / fast)     0.183260   0.019372   0.202632 (  0.204489)
+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.477735   0.006309   0.484044 (  0.487179)
-oj                       0.374920   0.005170   0.380090 (  0.384444)
-usamin                   0.363176   0.004812   0.367988 (  0.370558)
-usamin (fast)            0.352986   0.004893   0.357879 (  0.360197)
-usamin (load)            0.123704   0.006770   0.130474 (  0.133101)
-usamin (load / fast)     0.106889   0.008363   0.115252 (  0.117514)
+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.227502   0.001665   0.229167 (  0.233347)
-oj                       0.148312   0.000936   0.149248 (  0.151006)
-usamin                   0.178398   0.003571   0.181969 (  0.183786)
-usamin (fast)            0.170842   0.000973   0.171815 (  0.173604)
-usamin (load)            0.064007   0.005254   0.069261 (  0.071036)
-usamin (load / fast)     0.068870   0.006189   0.075059 (  0.077111)
+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.994007   0.026034   2.020041 (  2.025446)
-oj                       2.087961   0.029023   2.116984 (  2.123429)
-usamin                   0.274208   0.022461   0.296669 (  0.298859)
-usamin (load)            0.273885   0.031334   0.305219 (  0.310155)
+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.237936   0.009822   0.247758 (  0.252693)
-oj                       0.073700   0.008512   0.082212 (  0.084021)
-usamin                   0.064633   0.010208   0.074841 (  0.077269)
-usamin (load)            0.041944   0.010903   0.052847 (  0.055097)
+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.165987   0.005908   0.171895 (  0.176533)
-oj                       0.042210   0.005486   0.047696 (  0.049477)
-usamin                   0.039056   0.009091   0.048147 (  0.050299)
-usamin (load)            0.029979   0.009041   0.039020 (  0.041219)
+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.196968   0.067552   2.264520 (  2.270109)
-oj                       1.549510   0.019002   1.568512 (  1.573885)
-usamin                   0.373060   0.071227   0.444287 (  0.446266)
-usamin (load)            0.363781   0.067480   0.431261 (  0.433839)
+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.285428   0.022632   0.308060 (  0.312022)
-oj                       0.064475   0.008716   0.073191 (  0.075125)
-usamin                   0.088890   0.019419   0.108309 (  0.110423)
-usamin (load)            0.058728   0.018471   0.077199 (  0.079330)
+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.170966   0.010184   0.181150 (  0.186188)
-oj                       0.038465   0.007323   0.045788 (  0.047589)
-usamin                   0.046873   0.011960   0.058833 (  0.060903)
-usamin (load)            0.038984   0.010469   0.049453 (  0.049652)
+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,11 +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')
-$CXXFLAGS << ' -std=c++11'
+
+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());
+}