usamin 7.7.0 → 7.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38c48b49c05c5a95289abb777b32db4b47252fd31c5553acf09b11f3c076b500
-  data.tar.gz: 023641ec4fb9fc7277044ae4c6a1dcca134ace8ed4aaddf2b64c80a4fb7ef89e
+  metadata.gz: d053f43fdfdf7a7698d45fa5707245c7ea47946c906f3c504f27aabc543f38b1
+  data.tar.gz: 0d2b48bf5962478bd7ce35c1a4cfca68589881b59b62ccff5fadd6addd59be8b
 SHA512:
-  metadata.gz: 493e984049b444963a1be108cc624bc6a426edbf3c951c860f4662f4f3121e309e1768be11a919a16353c36fc96fb90124daf68bb68ec8f5756a82850c4a7618
-  data.tar.gz: 74cfe2c5148808a6be7f43a6bddf5ec1306ee3692a7833ea775392b61948fee537fc83befe55d0961d5ff3771e43a91d208294d2a8b4c41c8df20c738976cb5a
+  metadata.gz: baf083e37d53f5ebfd4ca36e39ec239d62f5f0e198c2a9d79c0efcc77060d5483962d1e1de1268a143ff566713f413f8853a29a68cacc9bc9722d5169abb6cde
+  data.tar.gz: 540f79a2a0015a39b119435b064d683687f248c6405855170dc8fa7469dfcffb4f393df2f33041f4ff1fcd6816f9d2f9808a2249f0ee68f78e685486c6d0c707

data/.gitignore

@@ -14,3 +14,4 @@ mkmf.log
 
 .DS_Store
 /testdata/
+/vendor/

data/README.md

@@ -6,7 +6,7 @@ The name of "Usamin" is derived from [Nana Abe](https://www.project-imas.com/wik
 
 ## Installation
 
-Install RapidJSON beforehand.
+Install RapidJSON beforehand. Only header files are necessary, and no need to build.
 
 Next, add this line to your application's Gemfile:
 
@@ -37,24 +37,28 @@ require 'usamin'
 ### Parsing
 
 ```ruby
-json = '{
-    "miku maekawa": {
+json = <<JSON
+[
+    {
+        "name": "miku maekawa",
         "age": 15,
         "height": 152,
         "weight": 45,
         "body_size": [85, 55, 81],
-        "birthday": [2, 22],
+        "birthday": "2/22",
         "cv": "natsumi takamori"
     },
-    "nana abe": {
+    {
+        "name": "nana abe",
         "age": 17,
         "height": 146,
         "weight": 40,
         "body_size": [84, 57, 84],
-        "birthday": [5, 15],
+        "birthday": "5/15",
         "cv": "marie miyake"
     }
-}'
+]
+JSON
 
 Usamin.parse(json)
 ```
@@ -65,37 +69,37 @@ Usamin.parse(json)
 data = Usamin.load(json)
 ```
 
-Here, `data` is not a Hash, but this can be handled like a Hash.
+Here, `data` is not a Array, but this can be handled like an Array.
 
 ```ruby
-data.keys
-#=> ["miku maekawa", "nana abe"]
+data.size
+#=> 2
 
-data.map{|k, v| [k, v['age']]}.to_h
-#=> {"miku maekawa"=>15, "nana abe"=>17}
+data.map{|e| e['name']}
+#=> ["miku maekawa", "nana abe"]
 ```
 
-Array data also can be handled like an Array object.
+Objects also can be handled like Hash objects.
 
 ```ruby
-data['nana abe']['body_size'].size
-#=> 3
+data.first['name']
+#=> "miku maekawa"
 
-data['nana abe']['body_size'].inject(:+)
-#=> 225
+data.first.keys
+#=> ["name", "age", "height", "weight", "body_size", "birthday", "cv"]
 ```
 
-The `eval` and `eval_r` converts these data structures into the Ruby data structures. `_r` means recursiveness.
+The methods `eval` and `eval_r` convert these data structures into Ruby data structures. `_r` means recursiveness.
 
 ```ruby
 data.eval
-#=> {"miku maekawa"=>#<Usamin::Hash>, "nana abe"=>#<Usamin::Hash>}
+#=> [#<Usamin::Hash>, #<Usamin::Hash>]
 
-data['miku maekawa'].eval_r
-#=> {"age"=>15, "height"=>152, "weight"=>45, "body_size"=>[85, 55, 81], "birthday"=>[2, 22], "cv"=>"natsumi takamori"}
+data.first.eval_r
+#=> {"name"=>"miku maekawa", "age"=>15, "height"=>152, "weight"=>45, "body_size"=>[85, 55, 81], "birthday"=>"2/22", "cv"=>"natsumi takamori"}
 
-data.eval_r
-#=> same as Usamin.parse(json)
+# same as Usamin.parse(json)
+Usamin.load(json).eval_r
 ```
 
 #### Notes about lazy loading data
@@ -106,21 +110,14 @@ data.eval_r
 ### Generating
 
 ```ruby
-data = {
-    "miku maekawa" => {
-        "age"=>15,
-        "height"=>152,
-        "weight"=>45,
-        "body_size"=>[85, 55, 81],
-        "birthday"=>[2, 22],
-        "cv"=>"natsumi takamori"},
-    "nana abe"=> {
-        "age"=>17,
-        "height"=>146,
-        "weight"=>40,
-        "body_size"=>[84, 57, 84],
-        "birthday"=>[5, 15],
-        "cv"=>"marie miyake"}}
+data = [{"name" => "miku maekawa", "age" => 15,
+    "height" => 152, "weight" => 45,
+    "body_size" => [85, 55, 81], "birthday" => "2/22",
+    "cv" => "natsumi takamori"}, {
+    "name" => "nana abe", "age" => 17,
+    "height" => 146, "weight" => 40,
+    "body_size" => [84, 57, 84], "birthday" => "5/15",
+    "cv" => "marie miyake"}]
 
 Usamin.generate(data)
 
@@ -132,8 +129,7 @@ Of course, UsaminValue also can be serialized.
 
 ```ruby
 data = Usamin.load(json)
-
-Usamin.generate(data['nana abe'])
+Usamin.generate(data[1])
 ```
 
 ### Fast parsing
@@ -160,6 +156,37 @@ Usamin.parse(str)
 # Usamin::ParserError: Missing a colon after a name of object member. Offset: 22
 ```
 
+### Overwrite JSON module
+
+You can overwrite JSON module methods by loading `usamin/overwrite`.
+
+```ruby
+require 'usamin/overwrite'
+
+# These methods are based on Usamin
+JSON.parse(json)
+JSON.generate(data)
+JSON.pretty_generate(data)
+```
+
+The overwritten methods are as follows:
+
+- JSON.parse -> Usamin.parse
+- JSON.load / JSON.restore -> Usamin.parse
+- JSON.generate -> Usamin.generate / Usamin.pretty_generate
+- JSON.pretty_generate -> Usamin.pretty_generate
+
+You can automatically switch packages by following technique.
+
+```ruby
+begin
+    require 'usamin'
+    require 'usamin/overwrite'
+rescue LoadError
+    require 'json'
+end
+```
+
 ### Documentation
 
 See: http://www.rubydoc.info/gems/usamin/
@@ -184,66 +211,72 @@ The values show the elapsed time for operating 20 times.
 
 ```
 nativejson-benchmark/data/canada.json
-json                     0.785524   0.007927   0.793451 (  0.805269)
-oj                       1.833580   0.043648   1.877228 (  1.895704)
-usamin                   0.595523   0.012299   0.607822 (  0.612215)
-usamin (fast)            0.286458   0.008710   0.295168 (  0.297998)
-usamin (load)            0.484056   0.011770   0.495826 (  0.498110)
-usamin (load / fast)     0.187712   0.020202   0.207914 (  0.210711)
+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)
 
 nativejson-benchmark/data/citm_catalog.json
-json                     0.469471   0.005208   0.474679 (  0.478920)
-oj                       0.327143   0.002947   0.330090 (  0.331882)
-usamin                   0.362764   0.005633   0.368397 (  0.370940)
-usamin (fast)            0.359859   0.005884   0.365743 (  0.371016)
-usamin (load)            0.117140   0.007003   0.124143 (  0.126548)
-usamin (load / fast)     0.115237   0.010061   0.125298 (  0.128470)
+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)
 
 nativejson-benchmark/data/twitter.json
-json                     0.238582   0.002561   0.241143 (  0.243726)
-oj                       0.162212   0.001031   0.163243 (  0.165047)
-usamin                   0.194476   0.001523   0.195999 (  0.197920)
-usamin (fast)            0.192985   0.001339   0.194324 (  0.197404)
-usamin (load)            0.070360   0.005012   0.075372 (  0.078090)
-usamin (load / fast)     0.067618   0.006416   0.074034 (  0.076244)
+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)
 ```
 
 #### Generating
 
 ```
 nativejson-benchmark/data/canada.json
-json                     1.988155   0.029728   2.017883 (  2.023475)
-oj                       2.092999   0.033136   2.126135 (  2.135765)
-usamin                   0.296385   0.031412   0.327797 (  0.330314)
+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)
 
 nativejson-benchmark/data/citm_catalog.json
-json                     0.243795   0.007463   0.251258 (  0.256621)
-oj                       0.076474   0.009617   0.086091 (  0.087966)
-usamin                   0.059434   0.009616   0.069050 (  0.071158)
+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)
 
 nativejson-benchmark/data/twitter.json
-json                     0.159030   0.006730   0.165760 (  0.170796)
-oj                       0.052856   0.009164   0.062020 (  0.064344)
-usamin                   0.047707   0.010265   0.057972 (  0.061729)
+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)
 ```
 
 #### Pretty Generating
 
 ```
 nativejson-benchmark/data/canada.json
-json                     2.188493   0.066003   2.254496 (  2.260332)
-oj                       1.583613   0.029798   1.613411 (  1.619652)
-usamin                   0.399066   0.081314   0.480380 (  0.482841)
+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)
 
 nativejson-benchmark/data/citm_catalog.json
-json                     0.300601   0.029596   0.330197 (  0.335351)
-oj                       0.065151   0.009553   0.074704 (  0.077010)
-usamin                   0.089872   0.022203   0.112075 (  0.116063)
+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)
 
 nativejson-benchmark/data/twitter.json
-json                     0.189439   0.010086   0.199525 (  0.204491)
-oj                       0.040982   0.008203   0.049185 (  0.049352)
-usamin                   0.044296   0.010095   0.054391 (  0.056245)
+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)
 ```
 
 ## Contributing

data/ext/usamin/usamin.cpp

@@ -211,6 +211,170 @@ static inline VALUE eval_array_r(rapidjson::Value &value) {
 }
 
 
+template <class Writer> static inline void write_str(Writer&, const VALUE);
+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_bignum(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_to_s(Writer&, const VALUE);
+
+template <class Writer> static void write(Writer &writer, const VALUE value) {
+    if (value == Qnil) {
+        writer.Null();
+    } else if (value == Qfalse) {
+        writer.Bool(false);
+    } else if (value == Qtrue) {
+        writer.Bool(true);
+    } else if (RB_FIXNUM_P(value)) {
+        writer.Int64(FIX2LONG(value));
+    } else if (RB_FLOAT_TYPE_P(value)) {
+        writer.Double(NUM2DBL(value));
+    } else if (RB_STATIC_SYM_P(value)) {
+        write_str(writer, rb_sym_to_s(value));
+    } else {
+        switch (RB_BUILTIN_TYPE(value)) {
+            case T_STRING:
+                write_str(writer, value);
+                break;
+            case T_HASH:
+                write_hash(writer, value);
+                break;
+            case T_ARRAY:
+                write_array(writer, value);
+                break;
+            case T_BIGNUM:
+                write_bignum(writer, value);
+                break;
+            case T_STRUCT:
+                write_struct(writer, value);
+                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_str(Writer &writer, const VALUE value) {
+    VALUE v = get_utf8_str(value);
+    writer.String(RSTRING_PTR(v), static_cast<unsigned int>(RSTRING_LEN(v)));
+}
+
+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), static_cast<unsigned int>(RSTRING_LEN(v)));
+}
+
+template <class Writer> static inline void write_key_to_s(Writer &writer, const VALUE value) {
+    write_key_str(writer, rb_funcall(value, id_to_s, 0));
+}
+
+template <class Writer> static inline int write_hash_each(VALUE key, VALUE value, Writer *writer) {
+    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();
+    rb_hash_foreach(hash, (int (*)(ANYARGS))write_hash_each<Writer>, reinterpret_cast<VALUE>((&writer)));
+    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_bignum(Writer &writer, const VALUE value) {
+    VALUE v = rb_big2str(value, 10);
+    writer.RawValue(RSTRING_PTR(v), static_cast<unsigned int>(RSTRING_LEN(v)), rapidjson::kNumberType);
+}
+
+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 void write_value(Writer &writer, rapidjson::Value &value) {
+    switch (value.GetType()) {
+        case rapidjson::kObjectType:
+            writer.StartObject();
+            for (auto &m : value.GetObject()) {
+                writer.Key(m.name.GetString(), m.name.GetStringLength());
+                write_value(writer, m.value);
+            }
+            writer.EndObject();
+            break;
+        case rapidjson::kArrayType:
+            writer.StartArray();
+            for (auto &v : value.GetArray())
+                write_value(writer, v);
+            writer.EndArray();
+            break;
+        case rapidjson::kNullType:
+            writer.Null();
+            break;
+        case rapidjson::kFalseType:
+            writer.Bool(false);
+            break;
+        case rapidjson::kTrueType:
+            writer.Bool(true);
+            break;
+        case rapidjson::kNumberType:
+            if (value.IsInt())
+                writer.Int(value.GetInt());
+            else if (value.IsUint())
+                writer.Uint(value.GetUint());
+            else if (value.IsInt64())
+                writer.Int64(value.GetInt64());
+            else if (value.IsUint64())
+                writer.Uint64(value.GetUint64());
+            else
+                writer.Double(value.GetDouble());
+            break;
+        case rapidjson::kStringType:
+            writer.String(value.GetString(), value.GetStringLength());
+            break;
+        default:
+            rb_raise(rb_eUsaminError, "Unknown Value Type: %d", value.GetType());
+    }
+}
+
+template <class Writer> static inline void write_usamin(Writer &writer, const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_value(value);
+    write_value(writer, *(value->value));
+}
+
+template <class Writer> static inline void write_to_s(Writer &writer, const VALUE value) {
+    write_str(writer, rb_funcall(value, id_to_s, 0));
+}
+
+
 UsaminValue::UsaminValue(rapidjson::Value *value, bool free_flag) {
     this->value = value;
     this->free_flag = free_flag;
@@ -319,7 +483,8 @@ static VALUE w_value_eval(const VALUE self) {
         return eval_object(*(value->value));
     else if (value->value->IsArray())
         return eval_array(*(value->value));
-    return Qnil;
+    else
+        return Qnil;
 }
 
 /*
@@ -340,8 +505,6 @@ static VALUE w_value_isfrozen(const VALUE self) {
     return Qtrue;
 }
 
-template <class Writer> static void write_value(Writer&, rapidjson::Value&);
-
 /*
  * Dumps data in JSON.
  *
@@ -352,7 +515,7 @@ static VALUE w_value_marshal_dump(const VALUE self) {
     check_value(value);
     rapidjson::StringBuffer buf;
     rapidjson::Writer<rapidjson::StringBuffer> writer(buf);
-    write_value(writer, *(value->value));
+    write_value(writer, *value->value);
     return rb_str_new(buf.GetString(), buf.GetSize());
 }
 
@@ -381,8 +544,7 @@ static VALUE w_value_marshal_load(const VALUE self, VALUE source) {
 
 
 /*
- * @overload [](name)
- *   @return [Object | nil]
+ * @return [Object | nil]
  *
  * @note This method has linear time complexity.
  */
@@ -397,14 +559,13 @@ static VALUE w_hash_operator_indexer(const VALUE self, VALUE key) {
 }
 
 static VALUE hash_enum_size(const VALUE self, VALUE args, VALUE eobj) {
-    UsaminValue *value = get_value(self);
-    check_object(value);
-    return UINT2NUM(value->value->MemberCount());
+    return UINT2NUM(get_value(self)->value->MemberCount());
 }
 
 /*
  * @yield [key, value]
  * @yieldparam key [String]
+ * @yieldparam value [Object]
  * @return [Enumerator | self]
  */
 static VALUE w_hash_each(const VALUE self) {
@@ -456,6 +617,28 @@ static VALUE w_hash_isempty(const VALUE self) {
     return value->value->MemberCount() == 0 ? Qtrue : Qfalse;
 }
 
+/*
+ * @overload fetch(key, default = nil)
+ *   @param [String] key
+ *   @param [Object] default
+ *   @return [Object]
+ *
+ * @overload fetch(key)
+ *   @param [String] key
+ *   @yield [key]
+ *   @return [Object]
+ */
+static VALUE w_hash_fetch(const int argc, VALUE* argv, const VALUE self) {
+    rb_check_arity(argc, 1, 2);
+    UsaminValue *value = get_value(self);
+    check_object(value);
+    VALUE kvalue = get_utf8_str(argv[0]);
+    for (auto &m : value->value->GetObject())
+        if (str_compare(RSTRING_PTR(kvalue), RSTRING_LEN(kvalue), m.name.GetString(), m.name.GetStringLength()))
+            return eval(m.value);
+    return argc == 2 ? argv[1] : rb_block_given_p() ? rb_yield(argv[0]) : Qnil;
+}
+
 /*
  * @note This method has linear time complexity.
  */
@@ -490,6 +673,34 @@ static VALUE w_hash_length(const VALUE self) {
     return UINT2NUM(value->value->MemberCount());
 }
 
+/*
+ * @yield [key, value]
+ * @yieldparam key [String]
+ * @yieldparam value [Object]
+ * @return [Enumerator | ::Hash]
+ */
+static VALUE w_hash_select(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_object(value);
+    RETURN_SIZED_ENUMERATOR(self, 0, nullptr, hash_enum_size);
+    VALUE hash = rb_hash_new();
+    if (rb_proc_arity(rb_block_proc()) > 1) {
+        for (auto &m : value->value->GetObject()) {
+            VALUE args[] = { eval_str(m.name), eval(m.value) };
+            if (RTEST(rb_yield_values2(2, args)))
+                rb_hash_aset(hash, args[0], args[1]);
+        }
+    } else {
+        for (auto &m : value->value->GetObject()) {
+            VALUE key = eval_str(m.name);
+            VALUE val = eval(m.value);
+            if (RTEST(rb_yield(rb_assoc_new(key, val))))
+                rb_hash_aset(hash, key, val);
+        }
+    }
+    return hash;
+}
+
 /*
  * Convert to Ruby Hash. Same as {Value#eval}.
  *
@@ -532,45 +743,57 @@ static VALUE w_array_operator_indexer(const int argc, VALUE* argv, const VALUE s
     rb_check_arity(argc, 1, 2);
     UsaminValue *value = get_value(self);
     check_array(value);
+    rapidjson::SizeType sz = value->value->Size();
     if (argc == 2) {
-        long beg = NUM2LONG(argv[0]);
-        long len = NUM2LONG(argv[1]);
+        long beg = FIX2LONG(argv[0]);
+        long len = FIX2LONG(argv[1]);
         if (beg < 0)
-            beg = beg + value->value->Size();
+            beg += sz;
         if (beg >= 0 && len >= 0) {
-            long end = beg + len;
-            if (end > value->value->Size())
-                end = value->value->Size();
+            rapidjson::SizeType end = static_cast<rapidjson::SizeType>(beg + len);
+            if (end > sz)
+                end = sz;
             VALUE ret = rb_ary_new2(end - beg);
-            for (long i = beg; i < end; i++)
-                rb_ary_push(ret, eval((*(value->value))[static_cast<unsigned int>(i)]));
+            for (rapidjson::SizeType i = static_cast<rapidjson::SizeType>(beg); i < end; i++)
+                rb_ary_push(ret, eval((*value->value)[i]));
             return ret;
         }
     } else if (rb_obj_is_kind_of(argv[0], rb_cRange)) {
         long beg, len;
-        if (rb_range_beg_len(argv[0], &beg, &len, value->value->Size(), 0) == Qtrue) {
+        if (rb_range_beg_len(argv[0], &beg, &len, sz, 0) == Qtrue) {
             VALUE ret = rb_ary_new2(len);
-            for (long i = beg; i < beg + len; i++)
-                rb_ary_push(ret, eval((*(value->value))[static_cast<unsigned int>(i)]));
+            for (rapidjson::SizeType i = static_cast<rapidjson::SizeType>(beg); i < beg + len; i++)
+                rb_ary_push(ret, eval((*value->value)[i]));
             return ret;
         }
     } else {
-        long l = NUM2LONG(argv[0]);
+        long l = FIX2LONG(argv[0]);
         if (l < 0)
-            l = l + value->value->Size();
-        if (l >= 0) {
-            unsigned int i = static_cast<unsigned int>(l);
-            if (i < value->value->Size())
-                return eval((*(value->value))[i]);
-        }
+            l += sz;
+        if (0 <= l && l < sz)
+            return eval((*value->value)[static_cast<rapidjson::SizeType>(l)]);
     }
     return Qnil;
 }
 
-static VALUE array_enum_size(const VALUE self, VALUE args, VALUE eobj) {
+/*
+ * @param [Integer] nth
+ * @return [Object]
+ */
+static VALUE w_array_at(const VALUE self, VALUE nth) {
     UsaminValue *value = get_value(self);
     check_array(value);
-    return UINT2NUM(value->value->Size());
+    long l = FIX2LONG(nth);
+    rapidjson::SizeType sz = value->value->Size();
+    if (l < 0)
+        l += sz;
+    if (0 <= l && l < sz)
+        return eval((*value->value)[static_cast<rapidjson::SizeType>(l)]);
+    return Qnil;
+}
+
+static VALUE array_enum_size(const VALUE self, VALUE args, VALUE eobj) {
+    return UINT2NUM(get_value(self)->value->Size());
 }
 
 /*
@@ -607,17 +830,60 @@ static VALUE w_array_isempty(const VALUE self) {
 }
 
 /*
- * @yield [value]
- * @return [Integer]
+ * @overload fetch(nth)
+ *   @param [Integer] nth
+ *   @return [Object]
+ *   @raise [IndexError] if nth is out of array bounds
+ *
+ * @overload fetch(nth, ifnone)
+ *   @param [Integer] nth
+ *   @param [Object] ifnone
+ *   @return [Object]
+ *
+ * @overload fetch(nth)
+ *   @param [Integer] nth
+ *   @yield [nth]
+ *   @return [Object]
  */
-static VALUE w_array_index(int argc, VALUE* argv, const VALUE self) {
+static VALUE w_array_fetch(const int argc, VALUE* argv, const VALUE self) {
+    rb_check_arity(argc, 1, 2);
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    rapidjson::SizeType sz = value->value->Size();
+
+    long l = FIX2LONG(argv[0]);
+    if (l < 0)
+        l += sz;
+    if (0 <= l && l < sz)
+        return eval((*value->value)[static_cast<rapidjson::SizeType>(l)]);
+
+    if (argc == 2)
+        return argv[1];
+    else if (rb_block_given_p())
+        return rb_yield(argv[0]);
+    else
+        rb_raise(rb_eIndexError, "index %ld outside of array bounds: %ld...%u", FIX2LONG(argv[0]), -static_cast<long>(sz), sz);
+    return Qnil;
+}
+
+/*
+ * @overload find_index(val)
+ *   @param [Object] val
+ *   @return [Integer | nil]
+ *
+ * @overload find_index
+ *   @yield [item]
+ *   @yieldparam item [Object]
+ *   @return [Integer | nil]
+ */
+static VALUE w_array_find_index(int argc, VALUE* argv, const VALUE self) {
     rb_check_arity(argc, 0, 1);
     UsaminValue *value = get_value(self);
     check_array(value);
 
     if (argc == 1) {
         for (rapidjson::SizeType i = 0; i < value->value->Size(); i++) {
-            if (rb_equal(argv[0], eval((*(value->value))[i])) == Qtrue)
+            if (rb_equal(argv[0], eval((*value->value)[i])) == Qtrue)
                 return UINT2NUM(i);
         }
         return Qnil;
@@ -625,12 +891,26 @@ static VALUE w_array_index(int argc, VALUE* argv, const VALUE self) {
 
     RETURN_SIZED_ENUMERATOR(self, 0, nullptr, array_enum_size);
     for (rapidjson::SizeType i = 0; i < value->value->Size(); i++) {
-        if (RTEST(rb_yield(eval((*(value->value))[i]))))
+        if (RTEST(rb_yield(eval((*value->value)[i]))))
             return UINT2NUM(i);
     }
     return Qnil;
 }
 
+/*
+ * @overload index(val)
+ *   @param [Object] val
+ *   @return [Integer | nil]
+ *
+ * @overload index
+ *   @yield [item]
+ *   @yieldparam item [Object]
+ *   @return [Integer | nil]
+ */
+static VALUE w_array_index(int argc, VALUE* argv, const VALUE self) {
+    return w_array_find_index(argc, argv, self);
+}
+
 /*
  * @overload first
  *   @return [Object | nil]
@@ -642,24 +922,47 @@ static VALUE w_array_first(const int argc, VALUE* argv, const VALUE self) {
     rb_check_arity(argc, 0, 1);
     UsaminValue *value = get_value(self);
     check_array(value);
+    rapidjson::SizeType sz = value->value->Size();
 
     if (argc == 0) {
-        if (value->value->Size() == 0)
+        if (sz == 0)
             return Qnil;
-        return eval((*(value->value))[0]);
+        return eval(*value->value->Begin());
+    } else {
+        long l = FIX2LONG(argv[0]);
+        if (l > sz)
+            l = sz;
+        VALUE ret = rb_ary_new2(l);
+        for (auto v = value->value->Begin(); v < value->value->Begin() + l; v++)
+            rb_ary_push(ret, eval(*v));
+        return ret;
     }
+}
 
-    long l = NUM2LONG(argv[0]);
-    if (l < 0)
-        l = 0;
-    else if (l > value->value->Size())
-        l = value->value->Size();
-    unsigned int li = static_cast<unsigned int>(l);
-    VALUE ret = rb_ary_new2(li);
-    for (unsigned int i = 0; i < li; i++)
-        rb_ary_push(ret, eval((*(value->value))[i]));
+/*
+ * @overload last
+ *   @return [Object | nil]
+ *
+ * @overload last(n)
+ *   @return [::Array<Object>]
+ */
+static VALUE w_array_last(const int argc, VALUE* argv, const VALUE self) {
+    rb_check_arity(argc, 0, 1);
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    rapidjson::SizeType sz = value->value->Size();
 
-    return ret;
+    if (argc == 0) {
+        return sz > 0 ? eval(*(value->value->End() - 1)) : Qnil;
+    } else {
+        long l = FIX2LONG(argv[0]);
+        if (l > sz)
+            l = sz;
+        VALUE ret = rb_ary_new2(l);
+        for (auto v = value->value->End() - l; v < value->value->End(); v++)
+            rb_ary_push(ret, eval(*v));
+        return ret;
+    }
 }
 
 /*
@@ -671,6 +974,24 @@ static VALUE w_array_length(const VALUE self) {
     return UINT2NUM(value->value->Size());
 }
 
+/*
+ * @overload slice(nth)
+ *   @param [Integer] nth
+ *   @return [Object | nil]
+ *
+ * @overload slice(start, length)
+ *   @param [Integer] start
+ *   @param [Integer] length
+ *   @return [::Array<Object> | nil]
+ *
+ * @overload slice(range)
+ *   @param [Range] range
+ *   @return [::Array<Object> | nil]
+ */
+static VALUE w_array_slice(const int argc, VALUE* argv, const VALUE self) {
+    return w_array_operator_indexer(argc, argv, self);
+}
+
 /*
  * Convert to Ruby data structures. Same as {Value#eval}.
  *
@@ -683,163 +1004,6 @@ static VALUE w_array_eval(const VALUE self) {
 }
 
 
-template <class Writer> static void write(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), static_cast<unsigned int>(RSTRING_LEN(v)));
-}
-
-template <class Writer> static inline void write_to_s(Writer &writer, const VALUE value) {
-    write_str(writer, rb_funcall(value, id_to_s, 0));
-}
-
-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), static_cast<unsigned int>(RSTRING_LEN(v)));
-}
-
-template <class Writer> static inline void write_key_to_s(Writer &writer, const VALUE value) {
-    write_key_str(writer, rb_funcall(value, id_to_s, 0));
-}
-
-template <class Writer> static inline void write_bignum(Writer &writer, const VALUE value) {
-    VALUE v = rb_big2str(value, 10);
-    writer.RawValue(RSTRING_PTR(v), static_cast<unsigned int>(RSTRING_LEN(v)), rapidjson::kNumberType);
-}
-
-template <class Writer> static inline int write_hash_each(VALUE key, VALUE value, Writer *writer) {
-    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();
-    rb_hash_foreach(hash, (int (*)(ANYARGS))write_hash_each<Writer>, reinterpret_cast<VALUE>((&writer)));
-    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 void write_value(Writer &writer, rapidjson::Value &value) {
-    switch (value.GetType()) {
-        case rapidjson::kObjectType:
-            writer.StartObject();
-            for (auto &m : value.GetObject()) {
-                writer.Key(m.name.GetString(), m.name.GetStringLength());
-                write_value(writer, m.value);
-            }
-            writer.EndObject();
-            break;
-        case rapidjson::kArrayType:
-            writer.StartArray();
-            for (auto &v : value.GetArray())
-                write_value(writer, v);
-            writer.EndArray();
-            break;
-        case rapidjson::kNullType:
-            writer.Null();
-            break;
-        case rapidjson::kFalseType:
-            writer.Bool(false);
-            break;
-        case rapidjson::kTrueType:
-            writer.Bool(true);
-            break;
-        case rapidjson::kNumberType:
-            if (value.IsInt())
-                writer.Int(value.GetInt());
-            else if (value.IsUint())
-                writer.Uint(value.GetUint());
-            else if (value.IsInt64())
-                writer.Int64(value.GetInt64());
-            else if (value.IsUint64())
-                writer.Uint64(value.GetUint64());
-            else
-                writer.Double(value.GetDouble());
-            break;
-        case rapidjson::kStringType:
-            writer.String(value.GetString(), value.GetStringLength());
-            break;
-        default:
-            rb_raise(rb_eUsaminError, "Unknown Value Type: %d", value.GetType());
-    }
-}
-
-template <class Writer> static inline void write_usamin(Writer &writer, const VALUE self) {
-    UsaminValue *value = get_value(self);
-    check_value(value);
-    write_value(writer, *(value->value));
-}
-
-template <class Writer> static void write(Writer &writer, const VALUE value) {
-    if (value == Qnil) {
-        writer.Null();
-    } else if (value == Qfalse) {
-        writer.Bool(false);
-    } else if (value == Qtrue) {
-        writer.Bool(true);
-    } else if (RB_FIXNUM_P(value)) {
-        writer.Int64(FIX2LONG(value));
-    } else if (RB_FLOAT_TYPE_P(value)) {
-        writer.Double(NUM2DBL(value));
-    } else if (RB_STATIC_SYM_P(value)) {
-        write_str(writer, rb_sym_to_s(value));
-    } else {
-        switch (RB_BUILTIN_TYPE(value)) {
-            case T_STRING:
-                write_str(writer, value);
-                break;
-            case T_HASH:
-                write_hash(writer, value);
-                break;
-            case T_ARRAY:
-                write_array(writer, value);
-                break;
-            case T_BIGNUM:
-                write_bignum(writer, value);
-                break;
-            case T_STRUCT:
-                write_struct(writer, value);
-                break;
-            default:
-                if (rb_obj_is_kind_of(value, rb_cUsaminValue))
-                    write_usamin(writer, value);
-                else
-                    write_to_s(writer, value);
-                break;
-        }
-    }
-}
-
 /*
  * Generate the JSON string from Ruby data structures.
  *
@@ -857,10 +1021,11 @@ static VALUE w_generate(const VALUE self, VALUE value) {
 /*
  * Generate the prettified JSON string from Ruby data structures.
  *
- * @overload generate(obj, opts = {})
+ * @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]
  */
 static VALUE w_pretty_generate(const int argc, VALUE *argv, const VALUE self) {
@@ -873,8 +1038,6 @@ static VALUE w_pretty_generate(const int argc, VALUE *argv, const VALUE self) {
     unsigned int indent_count = 2;
     if (argc > 1) {
         VALUE v_indent = rb_hash_lookup(options, sym_indent);
-        VALUE v_single_line_array = rb_hash_lookup(options, sym_single_line_array);
-
         if (RTEST(v_indent)) {
             if (RB_FIXNUM_P(v_indent)) {
                 long l = FIX2LONG(v_indent);
@@ -887,9 +1050,6 @@ static VALUE w_pretty_generate(const int argc, VALUE *argv, const VALUE self) {
                 } else {
                     const char *indent_str = RSTRING_PTR(v);
                     switch (indent_str[0]) {
-                        case '\0':
-                            indent_count = 0;
-                            break;
                         case ' ':
                         case '\t':
                         case '\r':
@@ -899,7 +1059,6 @@ static VALUE w_pretty_generate(const int argc, VALUE *argv, const VALUE self) {
                         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\".");
@@ -908,7 +1067,7 @@ static VALUE w_pretty_generate(const int argc, VALUE *argv, const VALUE self) {
             }
         }
 
-        if (RTEST(v_single_line_array))
+        if (RTEST(rb_hash_lookup(options, sym_single_line_array)))
             writer.SetFormatOptions(rapidjson::kFormatSingleLineArray);
     }
     writer.SetIndent(indent_char, indent_count);
@@ -950,11 +1109,13 @@ extern "C" void Init_usamin(void) {
     rb_define_alloc_func(rb_cUsaminHash, usamin_alloc);
     rb_undef_method(rb_cUsaminHash, "initialize");
     rb_define_method(rb_cUsaminHash, "[]", RUBY_METHOD_FUNC(w_hash_operator_indexer), 1);
+    rb_define_method(rb_cUsaminHash, "assoc", RUBY_METHOD_FUNC(w_hash_operator_indexer), 1);
     rb_define_method(rb_cUsaminHash, "each", RUBY_METHOD_FUNC(w_hash_each), 0);
     rb_define_method(rb_cUsaminHash, "each_pair", RUBY_METHOD_FUNC(w_hash_each), 0);
     rb_define_method(rb_cUsaminHash, "each_key", RUBY_METHOD_FUNC(w_hash_each_key), 0);
     rb_define_method(rb_cUsaminHash, "each_value", RUBY_METHOD_FUNC(w_hash_each_value), 0);
     rb_define_method(rb_cUsaminHash, "empty?", RUBY_METHOD_FUNC(w_hash_isempty), 0);
+    rb_define_method(rb_cUsaminHash, "fetch", RUBY_METHOD_FUNC(w_hash_fetch), -1);
     rb_define_method(rb_cUsaminHash, "has_key?", RUBY_METHOD_FUNC(w_hash_haskey), 1);
     rb_define_method(rb_cUsaminHash, "include?", RUBY_METHOD_FUNC(w_hash_haskey), 1);
     rb_define_method(rb_cUsaminHash, "key?", RUBY_METHOD_FUNC(w_hash_haskey), 1);
@@ -962,6 +1123,7 @@ extern "C" void Init_usamin(void) {
     rb_define_method(rb_cUsaminHash, "keys", RUBY_METHOD_FUNC(w_hash_keys), 0);
     rb_define_method(rb_cUsaminHash, "length", RUBY_METHOD_FUNC(w_hash_length), 0);
     rb_define_method(rb_cUsaminHash, "size", RUBY_METHOD_FUNC(w_hash_length), 0);
+    rb_define_method(rb_cUsaminHash, "select", RUBY_METHOD_FUNC(w_hash_select), 0);
     rb_define_method(rb_cUsaminHash, "to_h", RUBY_METHOD_FUNC(w_hash_eval), 0);
     rb_define_method(rb_cUsaminHash, "to_hash", RUBY_METHOD_FUNC(w_hash_eval), 0);
     rb_define_method(rb_cUsaminHash, "values", RUBY_METHOD_FUNC(w_hash_values), 0);
@@ -971,14 +1133,18 @@ extern "C" void Init_usamin(void) {
     rb_define_alloc_func(rb_cUsaminArray, usamin_alloc);
     rb_undef_method(rb_cUsaminArray, "initialize");
     rb_define_method(rb_cUsaminArray, "[]", RUBY_METHOD_FUNC(w_array_operator_indexer), -1);
+    rb_define_method(rb_cUsaminArray, "at", RUBY_METHOD_FUNC(w_array_at), 1);
     rb_define_method(rb_cUsaminArray, "each", RUBY_METHOD_FUNC(w_array_each), 0);
     rb_define_method(rb_cUsaminArray, "each_index", RUBY_METHOD_FUNC(w_array_each_index), 0);
     rb_define_method(rb_cUsaminArray, "empty?", RUBY_METHOD_FUNC(w_array_isempty), 0);
+    rb_define_method(rb_cUsaminArray, "fetch", RUBY_METHOD_FUNC(w_array_fetch), -1);
+    rb_define_method(rb_cUsaminArray, "find_index", RUBY_METHOD_FUNC(w_array_find_index), -1);
     rb_define_method(rb_cUsaminArray, "index", RUBY_METHOD_FUNC(w_array_index), -1);
-    rb_define_method(rb_cUsaminArray, "find_index", RUBY_METHOD_FUNC(w_array_index), -1);
     rb_define_method(rb_cUsaminArray, "first", RUBY_METHOD_FUNC(w_array_first), -1);
+    rb_define_method(rb_cUsaminArray, "last", RUBY_METHOD_FUNC(w_array_last), -1);
     rb_define_method(rb_cUsaminArray, "length", RUBY_METHOD_FUNC(w_array_length), 0);
     rb_define_method(rb_cUsaminArray, "size", RUBY_METHOD_FUNC(w_array_length), 0);
+    rb_define_method(rb_cUsaminArray, "slice", RUBY_METHOD_FUNC(w_array_slice), -1);
     rb_define_method(rb_cUsaminArray, "to_a", RUBY_METHOD_FUNC(w_array_eval), 0);
     rb_define_method(rb_cUsaminArray, "to_ary", RUBY_METHOD_FUNC(w_array_eval), 0);
 

data/lib/usamin.rb

@@ -1,2 +1,8 @@
 require 'usamin/version'
 require 'usamin/usamin'
+
+# When I was a child, I loved fairy tales.
+# I wished for wonderland every time my mother read the tales to me.
+# And now, I feel like I'm in the dream.
+module Usamin
+end

data/lib/usamin/overwrite.rb

@@ -0,0 +1,26 @@
+require 'usamin'
+
+module JSON
+    def self.generate(object, **options)
+        options[:indent] ? Usamin.pretty_generate(object, indent: options[:indent]) : Usamin.generate(object)
+    end
+
+    def self.pretty_generate(object, **options)
+        options[:indent] ? Usamin.pretty_generate(object, indent: options[:indent]) : Usamin.pretty_generate(object)
+    end
+
+    def self.parse(source, **options)
+        Usamin.parse(object)
+    end
+
+    def self.load(source, proc = nil, **options)
+        ret = Usamin.parse(object)
+        proc.call(ret) if proc
+        ret
+    end
+
+    class << self
+        alias fast_generate generate
+        alias restore load
+    end
+end

data/lib/usamin/version.rb

@@ -1,3 +1,3 @@
 module Usamin
-  VERSION = "7.7.0"
+    VERSION = "7.7.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: usamin
 version: !ruby/object:Gem::Version
-  version: 7.7.0
+  version: 7.7.2
 platform: ruby
 authors:
 - Ishotihadus
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-24 00:00:00.000000000 Z
+date: 2018-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,6 +86,7 @@ files:
 - ext/usamin/extconf.rb
 - ext/usamin/usamin.cpp
 - lib/usamin.rb
+- lib/usamin/overwrite.rb
 - lib/usamin/version.rb
 - usamin.gemspec
 homepage: https://github.com/Ishotihadus/usamin