usamin 7.7.8 → 7.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71c3b83f7f671964b34398dac52063e4619fcf69352a54a6b6d28c175d3c01ca
-  data.tar.gz: 60599d9808d0504dacb2a0fe96372072cb7e5c779cd84753353dff53ff309337
+  metadata.gz: db59b9c360567cf33fca6506bbd06ad9b31c1382a09b31d13cd1c81c530fbdd0
+  data.tar.gz: c675678f1eec5cd39fae70733f36302664e020981a5d850c12536d755e9c9d7d
 SHA512:
-  metadata.gz: 2e3ceb27b8f0c2f78ecc7c4fb1a4cad9d8d319ab1501e23fc804886a92ef6b6ec1b403bed9c7cbb59e03d1b78753535d8fd2d153622281924fa1ebf0e6c81668
-  data.tar.gz: 022e9d44c3be7e8f1e4f423d35837a0c31ef5ef3a32d801fd965c5d5ff25a76372d5ce41fda0d40576765a1d273fbe4a8fdad41543ee63e4301b5f127475c706
+  metadata.gz: 78f82ae393b94944759de05c6e8dcc01524b9e60041f9fb13c72dbf43319265f6ad3aef8c226f23dcd8e205ee8385d0a773b7a1271a403b81bc6f093fca928ac
+  data.tar.gz: e51369d0d04fb97f9018c0734f3f72df4c404388234baa5f9db61b8c36380f2c197626df512906d3241dbbdc75938946a8d657e086f0263d3b94dc63afa46f03

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
@@ -107,7 +108,7 @@ Usamin.load(json).eval_r
 #### 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
 

data/ext/usamin/usamin.cpp

@@ -39,7 +39,7 @@ typedef rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::MemoryPoolAlloc
 
 rb_encoding *utf8;
 int utf8index;
-ID id_to_s;
+ID id_dig, id_to_s;
 VALUE rb_cUsaminValue, rb_cUsaminHash, rb_cUsaminArray, rb_eUsaminError, rb_eParserError;
 VALUE utf8value, sym_fast, sym_indent, sym_single_line_array;
 
@@ -270,6 +270,110 @@ static inline VALUE eval_array_r(RubynizedValue &value) {
     return ret;
 }
 
+static bool eql_array(RubynizedValue&, RubynizedValue&);
+static bool eql_object(RubynizedValue&, RubynizedValue&);
+
+static bool eql_value(RubynizedValue &self, RubynizedValue &other) {
+    if (self.GetType() != other.GetType())
+        return false;
+    switch (self.GetType()) {
+        case rapidjson::kObjectType:
+            return eql_object(self, other);
+        case rapidjson::kArrayType:
+            return eql_array(self, other);
+        case rapidjson::kStringType:
+            return self == other;
+        case rapidjson::kNumberType:
+            return self == other && self.IsInt() == other.IsInt() &&
+                self.IsUint() == other.IsUint() && self.IsInt64() == other.IsInt64() &&
+                self.IsUint64() == other.IsUint64() && self.IsDouble() == other.IsDouble();
+        default:
+            return true;
+    }
+}
+
+static bool eql_object(RubynizedValue &self, RubynizedValue &other) {
+    if (self.MemberCount() != other.MemberCount())
+        return false;
+    for (auto &m : self.GetObject()) {
+        if (!other.HasMember(m.name))
+            return false;
+        if (!eql_value(m.value, other[m.name]))
+            return false;
+    }
+    return true;
+}
+
+static bool eql_array(RubynizedValue &self, RubynizedValue &other) {
+    if (self.Size() != other.Size())
+        return false;
+    for (rapidjson::SizeType i = 0; i < self.Size(); i++) {
+        if (!eql_value(self[i], other[i]))
+            return false;
+    }
+    return true;
+}
+
+static st_index_t hash_object(RubynizedValue &value);
+static st_index_t hash_array(RubynizedValue &value);
+
+static st_index_t hash_value(RubynizedValue &value) {
+    auto type = value.GetType();
+    st_index_t h = rb_hash_start((st_index_t)type);
+    rb_hash_uint(h, (st_index_t)hash_value);
+    switch (type) {
+        case rapidjson::kNullType:
+            h = rb_hash_uint(h, NUM2LONG(rb_hash(Qnil)));
+            break;
+        case rapidjson::kFalseType:
+            h = rb_hash_uint(h, NUM2LONG(rb_hash(Qfalse)));
+            break;
+        case rapidjson::kTrueType:
+            h = rb_hash_uint(h, NUM2LONG(rb_hash(Qtrue)));
+            break;
+        case rapidjson::kObjectType:
+            h = rb_hash_uint(h, hash_object(value));
+            break;
+        case rapidjson::kArrayType:
+            h = rb_hash_uint(h, hash_array(value));
+            break;
+        case rapidjson::kStringType:
+            h = rb_hash_uint(h, rb_str_hash(eval_str(value)));
+            break;
+        case rapidjson::kNumberType:
+            if (value.IsInt())
+                h = rb_hash_uint(h, 0x770);
+            if (value.IsUint())
+                h = rb_hash_uint(h, 0x771);
+            if (value.IsInt64())
+                h = rb_hash_uint(h, 0x772);
+            if (value.IsUint64())
+                h = rb_hash_uint(h, 0x773);
+            if (value.IsDouble())
+                h = rb_hash_uint(h, 0x774);
+            h = rb_hash_uint(h, NUM2LONG(rb_hash(eval_num(value))));
+    }
+    return rb_hash_end(h);
+}
+
+static st_index_t hash_object(RubynizedValue &value) {
+    st_index_t h = rb_hash_start(value.MemberCount());
+    h = rb_hash_uint(h, (st_index_t)hash_object);
+    for (auto &m : value.GetObject()) {
+        h = rb_hash_uint(h, rb_str_hash(eval_str(m.name)));
+        h = rb_hash_uint(h, hash_value(m.value));
+    }
+    return rb_hash_end(h);
+}
+
+static st_index_t hash_array(RubynizedValue &value) {
+    st_index_t h = rb_hash_start(value.Size());
+    h = rb_hash_uint(h, (st_index_t)hash_array);
+    for (auto &v : value.GetArray())
+        h = rb_hash_uint(h, hash_value(v));
+    return rb_hash_end(h);
+}
+
 
 template <class Writer> static inline void write_str(Writer&, const VALUE);
 template <class Writer> static inline void write_hash(Writer&, const VALUE);
@@ -515,6 +619,32 @@ static VALUE w_parse(const int argc, const VALUE *argv, const VALUE self) {
     return eval_r(doc);
 }
 
+/*
+ * Returns whether the value is equals to the other value.
+ *
+ * @return [Boolean]
+ */
+static VALUE w_value_equal(const VALUE self, const VALUE other) {
+    if (self == other)
+        return Qtrue;
+    UsaminValue *value_self = get_value(self);
+    check_value(value_self);
+    if (rb_obj_is_kind_of(other, rb_cUsaminValue)) {
+        UsaminValue *value_other = get_value(other);
+        check_value(value_other);
+        return value_self->value->operator==(*value_other->value) ? Qtrue : Qfalse;
+    } else if (value_self->value->IsArray() && RB_TYPE_P(other, T_ARRAY)) {
+        if (value_self->value->Size() != RARRAY_LEN(other))
+            return Qfalse;
+        return rb_equal(other, eval_array(*value_self->value, value_self->root_document));
+    } else if (value_self->value->IsObject() && RB_TYPE_P(other, T_HASH)) {
+        if (value_self->value->MemberCount() != RHASH_SIZE(other))
+            return Qfalse;
+        return rb_equal(other, eval_object(*value_self->value, value_self->root_document));
+    }
+    return Qfalse;
+}
+
 /*
  * Returns whether the value is array.
  */
@@ -560,6 +690,21 @@ static VALUE w_value_eval_r(const VALUE self) {
     return eval_r(*(value->value));
 }
 
+/*
+ * @return [Boolean]
+ */
+static VALUE w_value_eql(const VALUE self, const VALUE other) {
+    if (self == other)
+        return Qtrue;
+    if (!rb_obj_is_kind_of(other, rb_cUsaminValue))
+        return Qfalse;
+    UsaminValue *value_self = get_value(self);
+    UsaminValue *value_other = get_value(other);
+    check_value(value_self);
+    check_value(value_other);
+    return eql_value(*value_self->value, *value_other->value) ? Qtrue : Qfalse;
+}
+
 /*
  * Always true.
  */
@@ -567,6 +712,15 @@ static VALUE w_value_isfrozen(const VALUE self) {
     return Qtrue;
 }
 
+/*
+ * @return [Integer]
+ */
+static VALUE w_value_hash(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_value(value);
+    return ST2FIX(hash_value(*value->value));
+}
+
 /*
  * Returns root object.
  *
@@ -657,6 +811,20 @@ static VALUE w_hash_compact(const VALUE self) {
     return hash;
 }
 
+/*
+ * @return [Object | nil]
+ */
+static VALUE w_hash_dig(const int argc, const VALUE *argv, const VALUE self) {
+    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+    VALUE value = w_hash_operator_indexer(self, argv[0]);
+    if (argc == 1)
+        return value;
+    else if (value == Qnil)
+        return Qnil;
+    else
+        return rb_funcall3(value, id_dig, argc - 1, argv + 1);
+}
+
 static VALUE hash_enum_size(const VALUE self, const VALUE args, const VALUE eobj) {
     return UINT2NUM(get_value(self)->value->MemberCount());
 }
@@ -767,6 +935,49 @@ static VALUE w_hash_fetch_values(const int argc, VALUE *argv, const VALUE self)
     return ret;
 }
 
+static void flatten_array(RubynizedValue &value, VALUE array, int level, VALUE root_document);
+
+/*
+ *  @overload flatten(level = 1)
+ *   @return [::Array<Object>]
+ */
+static VALUE w_hash_flatten(const int argc, const VALUE *argv, const VALUE self) {
+    rb_check_arity(argc, 0, 1);
+    UsaminValue *value = get_value(self);
+    check_object(value);
+
+    int level = 1;
+    if (argc == 1 && !NIL_P(argv[0])) {
+        level = NUM2INT(argv[0]);
+        if (level < 0)
+            level = -1;
+    }
+
+    if (level == 0) {
+        VALUE ret = rb_ary_new2(value->value->MemberCount());
+        for (auto &m : value->value->GetObject())
+            rb_ary_push(ret, rb_ary_new3(2, eval_str(m.name), eval(m.value, value->root_document)));
+        return ret;
+    }
+
+    VALUE ret = rb_ary_new2(value->value->MemberCount() * 2);
+    if (level == 1) {
+        for (auto &m : value->value->GetObject()) {
+            rb_ary_push(ret, eval_str(m.name));
+            rb_ary_push(ret, eval(m.value, value->root_document));
+        }
+    } else {
+        for (auto &m : value->value->GetObject()) {
+            rb_ary_push(ret, eval_str(m.name));
+            if (m.value.IsArray())
+                flatten_array(m.value, ret, level > 0 ? level - 2 : level, value->root_document);
+            else
+                rb_ary_push(ret, eval(m.value, value->root_document));
+        }
+    }
+    return ret;
+}
+
 /*
  * @note This method has linear time complexity.
  */
@@ -800,6 +1011,36 @@ static VALUE w_hash_key(const VALUE self, const VALUE val) {
     return Qnil;
 }
 
+/*
+ * @return [String]
+ */
+static VALUE w_hash_inspect(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_object(value);
+    VALUE ret = rb_str_new2("{");
+    bool first = true;
+    for (auto &m : value->value->GetObject()) {
+        if (!first)
+            ret = rb_str_cat2(ret, ", ");
+        ret = rb_str_append(ret, rb_inspect(eval_str(m.name)));
+        ret = rb_str_cat2(ret, "=>");
+        switch (m.value.GetType()) {
+            case rapidjson::kObjectType:
+                ret = rb_str_cat2(ret, "{...}");
+                break;
+            case rapidjson::kArrayType:
+                ret = rb_str_cat2(ret, "[...]");
+                break;
+            default:
+                ret = rb_str_append(ret, rb_inspect(eval(m.value, value->root_document)));
+                break;
+        }
+        first = false;
+    }
+    ret = rb_str_cat2(ret, "}");
+    return ret;
+}
+
 /*
  * @return [::Array<String>]
  */
@@ -1068,6 +1309,20 @@ static VALUE w_array_compact(const VALUE self, const VALUE nth) {
     return ret;
 }
 
+/*
+ * @return [Object | nil]
+ */
+static VALUE w_array_dig(const int argc, const VALUE *argv, const VALUE self) {
+    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+    VALUE value = w_array_at(self, argv[0]);
+    if (argc == 1)
+        return value;
+    else if (value == Qnil)
+        return Qnil;
+    else
+        return rb_funcall3(value, id_dig, argc - 1, argv + 1);
+}
+
 static VALUE array_enum_size(const VALUE self, const VALUE args, const VALUE eobj) {
     return UINT2NUM(get_value(self)->value->Size());
 }
@@ -1173,6 +1428,39 @@ static VALUE w_array_find_index(const int argc, const VALUE *argv, const VALUE s
     return Qnil;
 }
 
+static void flatten_array(RubynizedValue &value, VALUE array, int level, VALUE root_document) {
+    if (level == 0)
+        for (auto &v : value.GetArray())
+            rb_ary_push(array, eval(v, root_document));
+    else
+        for (auto &v : value.GetArray())
+            if (v.IsArray())
+                flatten_array(v, array, level > 0 ? level - 1 : level, root_document);
+            else
+                rb_ary_push(array, eval(v, root_document));
+}
+
+/*
+ *  @overload flatten(lv = nil)
+ *   @return [::Array<Object>]
+ */
+static VALUE w_array_flatten(const int argc, const VALUE *argv, const VALUE self) {
+    rb_check_arity(argc, 0, 1);
+    UsaminValue *value = get_value(self);
+    check_array(value);
+
+    int level = -1;
+    if (argc == 1 && !NIL_P(argv[0])) {
+        level = NUM2INT(argv[0]);
+        if (level <= 0)
+            return eval_array(*value->value, value->root_document);
+    }
+
+    VALUE ret = rb_ary_new2(value->value->Size());
+    flatten_array(*value->value, ret, level, value->root_document);
+    return ret;
+}
+
 /*
  * @overload index(val)
  *   @param [Object] val
@@ -1227,6 +1515,34 @@ static VALUE w_array_include(const VALUE self, const VALUE val) {
     return Qfalse;
 }
 
+/*
+ * @return [String]
+ */
+static VALUE w_array_inspect(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    VALUE ret = rb_str_new2("[");
+    bool first = true;
+    for (auto &v : value->value->GetArray()) {
+        if (!first)
+            ret = rb_str_cat2(ret, ", ");
+        switch (v.GetType()) {
+            case rapidjson::kObjectType:
+                ret = rb_str_cat2(ret, "{...}");
+                break;
+            case rapidjson::kArrayType:
+                ret = rb_str_cat2(ret, "[...]");
+                break;
+            default:
+                ret = rb_str_append(ret, rb_inspect(eval(v, value->root_document)));
+                break;
+        }
+        first = false;
+    }
+    ret = rb_str_cat2(ret, "]");
+    return ret;
+}
+
 /*
  * @overload last
  *   @return [Object | nil]
@@ -1262,6 +1578,86 @@ static VALUE w_array_length(const VALUE self) {
     return UINT2NUM(value->value->Size());
 }
 
+/*
+ * @return [::Array<Object>]
+ */
+static VALUE w_array_reverse(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+
+    VALUE ret = rb_ary_new2(value->value->Size());
+    for (rapidjson::SizeType i = 0, j = value->value->Size() - 1; i < value->value->Size(); i++, j--)
+        rb_ary_push(ret, eval((*value->value)[j], value->root_document));
+    return ret;
+}
+
+/*
+ * @overload rindex(val)
+ *   @param [Object] val
+ *   @return [Integer | nil]
+ *
+ * @overload rindex
+ *   @yield [item]
+ *   @yieldparam item [Object]
+ *   @return [Integer | nil]
+ */
+static VALUE w_array_rindex(const int argc, const 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, j = value->value->Size() - 1; i < value->value->Size(); i++, j--) {
+            if (rb_equal(argv[0], eval_r((*value->value)[j])) == Qtrue)
+                return UINT2NUM(j);
+        }
+        return Qnil;
+    }
+
+    RETURN_SIZED_ENUMERATOR(self, 0, nullptr, array_enum_size);
+    for (rapidjson::SizeType i = 0, j = value->value->Size() - 1; i < value->value->Size(); i++, j--) {
+        if (RTEST(rb_yield(eval((*value->value)[j], value->root_document))))
+            return UINT2NUM(j);
+    }
+    return Qnil;
+}
+
+/*
+ * @overload rotate(cnt = 1)
+ *   @return [::Array<Object>]
+ */
+static VALUE w_array_rotate(const int argc, const VALUE *argv, const VALUE self) {
+    rb_check_arity(argc, 0, 1);
+    UsaminValue *value = get_value(self);
+    check_array(value);
+
+    switch (value->value->Size()) {
+        case 0:
+            return rb_ary_new();
+        case 1:
+            return rb_ary_new3(1, eval(value->value->operator[](0), value->root_document));
+    }
+
+    int cnt = argc == 1 ? NUM2INT(argv[0]) : 1;
+    if (cnt >= 0) {
+        cnt = cnt % value->value->Size();
+    } else {
+        cnt = -cnt % value->value->Size();
+        if (cnt)
+            cnt = value->value->Size() - cnt;
+    }
+    if (cnt == 0)
+        return eval_array(*(value->value), value->root_document);
+
+    rapidjson::SizeType ucnt = cnt;
+    VALUE ret = rb_ary_new2(value->value->Size());
+    for (rapidjson::SizeType i = ucnt; i < value->value->Size(); i++)
+        rb_ary_push(ret, eval((*value->value)[i], value->root_document));
+    for (rapidjson::SizeType i = 0; i < ucnt; i++)
+        rb_ary_push(ret, eval((*value->value)[i], value->root_document));
+    return ret;
+}
+
 /*
  * @overload slice(nth)
  *   @param [Integer] nth
@@ -1371,6 +1767,7 @@ extern "C" void Init_usamin(void) {
     sym_fast = rb_id2sym(rb_intern("fast"));
     sym_indent = rb_id2sym(rb_intern("indent"));
     sym_single_line_array = rb_id2sym(rb_intern("single_line_array"));
+    id_dig = rb_intern("dig");
     id_to_s = rb_intern("to_s");
 
     VALUE rb_mUsamin = rb_define_module("Usamin");
@@ -1382,12 +1779,16 @@ extern "C" void Init_usamin(void) {
     rb_cUsaminValue = rb_define_class_under(rb_mUsamin, "Value", rb_cObject);
     rb_undef_alloc_func(rb_cUsaminValue);
     rb_undef_method(rb_cUsaminValue, "initialize");
+    rb_define_method(rb_cUsaminValue, "==", RUBY_METHOD_FUNC(w_value_equal), 1);
+    rb_define_method(rb_cUsaminValue, "===", RUBY_METHOD_FUNC(w_value_equal), 1);
     rb_define_method(rb_cUsaminValue, "array?", RUBY_METHOD_FUNC(w_value_isarray), 0);
     rb_define_method(rb_cUsaminValue, "hash?", RUBY_METHOD_FUNC(w_value_isobject), 0);
     rb_define_method(rb_cUsaminValue, "object?", RUBY_METHOD_FUNC(w_value_isobject), 0);
     rb_define_method(rb_cUsaminValue, "eval", RUBY_METHOD_FUNC(w_value_eval), 0);
     rb_define_method(rb_cUsaminValue, "eval_r", RUBY_METHOD_FUNC(w_value_eval_r), 0);
+    rb_define_method(rb_cUsaminValue, "eql?", RUBY_METHOD_FUNC(w_value_eql), 1);
     rb_define_method(rb_cUsaminValue, "frozen?", RUBY_METHOD_FUNC(w_value_isfrozen), 0);
+    rb_define_method(rb_cUsaminValue, "hash", RUBY_METHOD_FUNC(w_value_hash), 0);
     rb_define_method(rb_cUsaminValue, "root", RUBY_METHOD_FUNC(w_value_root), 0);
 
     rb_cUsaminHash = rb_define_class_under(rb_mUsamin, "Hash", rb_cUsaminValue);
@@ -1397,6 +1798,7 @@ extern "C" void Init_usamin(void) {
     rb_define_method(rb_cUsaminHash, "[]", RUBY_METHOD_FUNC(w_hash_operator_indexer), 1);
     rb_define_method(rb_cUsaminHash, "assoc", RUBY_METHOD_FUNC(w_hash_assoc), 1);
     rb_define_method(rb_cUsaminHash, "compact", RUBY_METHOD_FUNC(w_hash_compact), 0);
+    rb_define_method(rb_cUsaminHash, "dig", RUBY_METHOD_FUNC(w_hash_dig), -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);
@@ -1404,6 +1806,7 @@ extern "C" void Init_usamin(void) {
     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, "fetch_values", RUBY_METHOD_FUNC(w_hash_fetch_values), -1);
+    rb_define_method(rb_cUsaminHash, "flatten", RUBY_METHOD_FUNC(w_hash_flatten), -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);
@@ -1412,6 +1815,8 @@ extern "C" void Init_usamin(void) {
     rb_define_method(rb_cUsaminHash, "value?", RUBY_METHOD_FUNC(w_hash_hasvalue), 1);
     rb_define_method(rb_cUsaminHash, "key", RUBY_METHOD_FUNC(w_hash_key), 1);
     rb_define_method(rb_cUsaminHash, "index", RUBY_METHOD_FUNC(w_hash_key), 1);
+    rb_define_method(rb_cUsaminHash, "inspect", RUBY_METHOD_FUNC(w_hash_inspect), 0);
+    rb_define_method(rb_cUsaminHash, "to_s", RUBY_METHOD_FUNC(w_hash_inspect), 0);
     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);
@@ -1435,16 +1840,23 @@ extern "C" void Init_usamin(void) {
     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, "compact", RUBY_METHOD_FUNC(w_array_compact), 0);
+    rb_define_method(rb_cUsaminArray, "dig", RUBY_METHOD_FUNC(w_array_dig), -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, "flatten", RUBY_METHOD_FUNC(w_array_flatten), -1);
     rb_define_method(rb_cUsaminArray, "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, "include?", RUBY_METHOD_FUNC(w_array_include), 1);
+    rb_define_method(rb_cUsaminArray, "inspect", RUBY_METHOD_FUNC(w_array_inspect), 0);
+    rb_define_method(rb_cUsaminArray, "to_s", RUBY_METHOD_FUNC(w_array_inspect), 0);
     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, "reverse", RUBY_METHOD_FUNC(w_array_reverse), 0);
+    rb_define_method(rb_cUsaminArray, "rindex", RUBY_METHOD_FUNC(w_array_rindex), -1);
+    rb_define_method(rb_cUsaminArray, "rotate", RUBY_METHOD_FUNC(w_array_rotate), -1);
     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_ary", RUBY_METHOD_FUNC(w_array_eval), 0);

data/lib/usamin/overwrite.rb

@@ -10,15 +10,29 @@ module JSON
     end
 
     def self.parse(source, **options)
-        Usamin.parse(object)
+        Usamin.parse(source)
     end
 
     def self.load(source, proc = nil, **options)
-        ret = Usamin.parse(object)
-        proc.call(ret) if proc
+        ret = Usamin.parse(source)
+        LoadProcCaller.load_call_proc(ret, proc) if proc
         ret
     end
 
+    class LoadProcCaller
+        def self.load_call_proc(object, proc)
+            if object.is_a?(Array)
+                object.each{|e| load_call_proc(e, proc)}
+            elsif object.is_a?(Hash)
+                object.each do |k, v|
+                    proc.call(k)
+                    load_call_proc(v, proc)
+                end
+            end
+            proc.call(object)
+        end
+    end
+
     class << self
         alias fast_generate generate
         alias restore load

data/lib/usamin/version.rb

@@ -1,3 +1,3 @@
 module Usamin
-    VERSION = "7.7.8"
+    VERSION = '7.7.9'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: usamin
 version: !ruby/object:Gem::Version
-  version: 7.7.8
+  version: 7.7.9
 platform: ruby
 authors:
 - Ishotihadus
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-25 00:00:00.000000000 Z
+date: 2019-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A RapidJSON Wrapper for Ruby