usamin 7.7.9 → 7.7.10

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,100 @@
+#include "default_parse_flags.hpp"
+#include "parser.hpp"
+#include <rapidjson/reader.h>
+#include <rapidjson/error/en.h>
+#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

data/ext/usamin/parser_helper.hpp

@@ -0,0 +1,131 @@
+#include <ruby.h>
+#include "rb_common.hpp"
+#include "rb_usamin_value.hpp"
+#include "rubynized_rapidjson.hpp"
+#include "usamin_value.hpp"
+
+static inline int test_option(VALUE options, VALUE sym) {
+    return !NIL_P(options) && RTEST(rb_hash_lookup(options, sym));
+}
+
+static inline VALUE make_hash(UsaminValue *value, bool is_root = false) {
+    extern VALUE rb_cUsaminHash;
+    VALUE ret = rb_obj_alloc(rb_cUsaminHash);
+    set_value(ret, value);
+    if (is_root)
+        value->root_document = ret;
+    return ret;
+}
+
+static inline VALUE make_array(UsaminValue *value, bool is_root = false) {
+    extern VALUE rb_cUsaminArray;
+    VALUE ret = rb_obj_alloc(rb_cUsaminArray);
+    set_value(ret, value);
+    if (is_root)
+        value->root_document = ret;
+    return ret;
+}
+
+static inline VALUE eval_num(RubynizedValue &);
+static inline VALUE eval_str(RubynizedValue &);
+static inline VALUE eval_object_r(RubynizedValue &, int);
+static inline VALUE eval_array_r(RubynizedValue &, int);
+
+static VALUE eval(RubynizedValue &value, VALUE root_document) {
+    extern VALUE rb_eUsaminError;
+    switch (value.GetType()) {
+    case rapidjson::kObjectType:
+        return make_hash(new UsaminValue(&value, false, root_document));
+    case rapidjson::kArrayType:
+        return make_array(new UsaminValue(&value, false, root_document));
+    case rapidjson::kNullType:
+        return Qnil;
+    case rapidjson::kFalseType:
+        return Qfalse;
+    case rapidjson::kTrueType:
+        return Qtrue;
+    case rapidjson::kNumberType:
+        return eval_num(value);
+    case rapidjson::kStringType:
+        return eval_str(value);
+    default:
+        rb_raise(rb_eUsaminError, "unknown value type: %d", value.GetType());
+        return Qnil;
+    }
+}
+
+static VALUE eval_r(RubynizedValue &value, int symbolize) {
+    extern VALUE rb_eUsaminError;
+    switch (value.GetType()) {
+    case rapidjson::kObjectType:
+        return eval_object_r(value, symbolize);
+    case rapidjson::kArrayType:
+        return eval_array_r(value, symbolize);
+    case rapidjson::kNullType:
+        return Qnil;
+    case rapidjson::kFalseType:
+        return Qfalse;
+    case rapidjson::kTrueType:
+        return Qtrue;
+    case rapidjson::kNumberType:
+        return eval_num(value);
+    case rapidjson::kStringType:
+        return eval_str(value);
+    default:
+        rb_raise(rb_eUsaminError, "unknown value type: %d", value.GetType());
+        return Qnil;
+    }
+}
+
+static inline VALUE eval_num(RubynizedValue &value) {
+    if (value.IsInt())
+        return INT2FIX(value.GetInt());
+    else if (value.IsUint())
+        return UINT2NUM(value.GetUint());
+    else if (value.IsInt64())
+        return LL2NUM(value.GetInt64());
+    else if (value.IsUint64())
+        return ULL2NUM(value.GetUint64());
+    else
+        return DBL2NUM(value.GetDouble());
+}
+
+static inline VALUE eval_str(RubynizedValue &value) {
+    return new_utf8_str(value.GetString(), value.GetStringLength());
+}
+
+static inline VALUE eval_object(RubynizedValue &value, const VALUE root_document, int symbolize) {
+    VALUE ret = rb_hash_new();
+    if (symbolize)
+        for (auto &m : value.GetObject())
+            rb_hash_aset(ret, rb_to_symbol(eval_str(m.name)), eval(m.value, root_document));
+    else
+        for (auto &m : value.GetObject())
+            rb_hash_aset(ret, eval_str(m.name), eval(m.value, root_document));
+    return ret;
+}
+
+static inline VALUE eval_object_r(RubynizedValue &value, int symbolize) {
+    VALUE ret = rb_hash_new();
+    if (symbolize)
+        for (auto &m : value.GetObject())
+            rb_hash_aset(ret, rb_to_symbol(eval_str(m.name)), eval_r(m.value, symbolize));
+    else
+        for (auto &m : value.GetObject())
+            rb_hash_aset(ret, eval_str(m.name), eval_r(m.value, symbolize));
+    return ret;
+}
+
+static inline VALUE eval_array(RubynizedValue &value, const VALUE root_document) {
+    VALUE ret = rb_ary_new2(value.Size());
+    for (auto &v : value.GetArray())
+        rb_ary_push(ret, eval(v, root_document));
+    return ret;
+}
+
+static inline VALUE eval_array_r(RubynizedValue &value, int symbolize) {
+    VALUE ret = rb_ary_new2(value.Size());
+    for (auto &v : value.GetArray())
+        rb_ary_push(ret, eval_r(v, symbolize));
+    return ret;
+}

data/ext/usamin/rb_common.cpp

@@ -0,0 +1,60 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include "rubynized_rapidjson.hpp"
+#include "usamin_value.hpp"
+
+VALUE get_utf8_str(VALUE str) {
+    extern int utf8index;
+    extern VALUE utf8value;
+    extern rb_encoding *utf8;
+
+    Check_Type(str, T_STRING);
+    int encoding = rb_enc_get_index(str);
+    if (encoding == utf8index || rb_enc_compatible(str, utf8value) == utf8)
+        return str;
+    else
+        return rb_str_conv_enc(str, rb_enc_from_index(encoding), utf8);
+}
+
+VALUE new_utf8_str(const char *cstr, const long len) {
+    extern int utf8index;
+    VALUE ret = rb_str_new(cstr, len);
+    rb_enc_set_index(ret, utf8index);
+    return ret;
+}
+
+static inline bool str_compare(const char *str1, const long len1, const char *str2, const long len2) {
+    if (len1 != len2 || len1 < 0)
+        return false;
+    return memcmp(str1, str2, len1) == 0;
+}
+
+bool str_compare_xx(VALUE str1, const RubynizedValue &str2) {
+    if (RB_TYPE_P(str1, T_STRING))
+        str1 = get_utf8_str(str1);
+    else if (SYMBOL_P(str1))
+        str1 = get_utf8_str(rb_sym_to_s(str1));
+    else
+        str1 = get_utf8_str(StringValue(str1));
+    return str_compare(RSTRING_PTR(str1), RSTRING_LEN(str1), str2.GetString(), str2.GetStringLength());
+}
+
+void check_value(UsaminValue *ptr) {
+    extern VALUE rb_eUsaminError;
+    if (!ptr || !ptr->value)
+        rb_raise(rb_eUsaminError, "null reference");
+}
+
+void check_object(UsaminValue *ptr) {
+    extern VALUE rb_eUsaminError;
+    check_value(ptr);
+    if (!ptr->value->IsObject())
+        rb_raise(rb_eUsaminError, "unexpected type of value (expected: object)");
+}
+
+void check_array(UsaminValue *ptr) {
+    extern VALUE rb_eUsaminError;
+    check_value(ptr);
+    if (!ptr->value->IsArray())
+        rb_raise(rb_eUsaminError, "unexpected type of value (expected: array)");
+}

data/ext/usamin/rb_common.hpp

@@ -0,0 +1,15 @@
+#ifndef USAMIN_RB_COMMON_HPP
+#define USAMIN_RB_COMMON_HPP
+
+#include <ruby.h>
+#include "rubynized_rapidjson.hpp"
+#include "usamin_value.hpp"
+
+VALUE get_utf8_str(VALUE str);
+VALUE new_utf8_str(const char *cstr, const long len);
+bool str_compare_xx(VALUE str1, const RubynizedValue &str2);
+void check_value(UsaminValue *ptr);
+void check_object(UsaminValue *ptr);
+void check_array(UsaminValue *ptr);
+
+#endif

data/ext/usamin/rb_usamin_array.cpp

@@ -0,0 +1,453 @@
+#include <rapidjson/document.h>
+#include <ruby.h>
+#include "usamin_value.hpp"
+#include "parser_helper.hpp"
+
+/*
+ * @overload [](nth)
+ *   @param [Integer] nth
+ *   @return [Object | nil]
+ *
+ * @overload [](start, length)
+ *   @param [Integer] start
+ *   @param [Integer] length
+ *   @return [::Array<Object> | nil]
+ *
+ * @overload [](range)
+ *   @param [Range] range
+ *   @return [::Array<Object> | nil]
+ */
+VALUE w_array_operator_indexer(const int argc, const 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();
+    if (argc == 2) {
+        int beg = FIX2INT(argv[0]);
+        int len = FIX2INT(argv[1]);
+        if (len < 0)
+            return Qnil;
+        if (beg < 0)
+            beg += sz;
+        if (beg < 0 || static_cast<rapidjson::SizeType>(beg) > sz)
+            return Qnil;
+        rapidjson::SizeType end = beg + len;
+        if (end > sz)
+            end = sz;
+        VALUE ret = rb_ary_new2(end - beg);
+        for (rapidjson::SizeType i = beg; i < end; i++)
+            rb_ary_push(ret, eval((*value->value)[i], value->root_document));
+        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, sz, 0) == Qtrue) {
+            VALUE ret = rb_ary_new2(len);
+            unsigned int beg_i = rb_long2int(beg);
+            unsigned int len_i = rb_long2int(len);
+            for (rapidjson::SizeType i = beg_i; i < beg_i + len_i; i++)
+                rb_ary_push(ret, eval((*value->value)[i], value->root_document));
+            return ret;
+        }
+    } else {
+        int l = FIX2INT(argv[0]);
+        if (l < 0)
+            l += sz;
+        if (0 <= l && static_cast<rapidjson::SizeType>(l) < sz)
+            return eval((*value->value)[l], value->root_document);
+    }
+    return Qnil;
+}
+
+/*
+ * @param [Integer] nth
+ * @return [Object]
+ */
+VALUE w_array_at(const VALUE self, const VALUE nth) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    int l = FIX2INT(nth);
+    rapidjson::SizeType sz = value->value->Size();
+    if (l < 0)
+        l += sz;
+    if (0 <= l && static_cast<rapidjson::SizeType>(l) < sz)
+        return eval((*value->value)[l], value->root_document);
+    return Qnil;
+}
+
+/*
+ * @return [::Array]
+ */
+VALUE w_array_compact(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    VALUE ret = rb_ary_new2(value->value->Size());
+    for (auto &v : value->value->GetArray())
+        if (!v.IsNull())
+            rb_ary_push(ret, eval(v, value->root_document));
+    return ret;
+}
+
+/*
+ * @return [Object | nil]
+ */
+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;
+    extern ID id_dig;
+    return rb_funcall3(value, id_dig, argc - 1, argv + 1);
+}
+
+static VALUE array_enum_size(const VALUE self, const VALUE, const VALUE) {
+    return UINT2NUM(get_value(self)->value->Size());
+}
+
+/*
+ * @yield [value]
+ * @return [Enumerator | self]
+ */
+VALUE w_array_each(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    RETURN_SIZED_ENUMERATOR(self, 0, nullptr, array_enum_size);
+    for (auto &v : value->value->GetArray())
+        rb_yield(eval(v, value->root_document));
+    return self;
+}
+
+/*
+ * @yield [index]
+ * @yieldparam index [Integer]
+ * @return [Enumerator | self]
+ */
+VALUE w_array_each_index(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    RETURN_SIZED_ENUMERATOR(self, 0, nullptr, array_enum_size);
+    for (rapidjson::SizeType i = 0; i < value->value->Size(); i++)
+        rb_yield(UINT2NUM(i));
+    return self;
+}
+
+VALUE w_array_isempty(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    return value->value->Size() == 0 ? Qtrue : Qfalse;
+}
+
+/*
+ * @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]
+ */
+VALUE w_array_fetch(const int argc, const 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();
+
+    if (argc == 2 && rb_block_given_p())
+        rb_warn("block supersedes default value argument");
+
+    int l = FIX2INT(argv[0]);
+    if (l < 0)
+        l += sz;
+    if (0 <= l && static_cast<rapidjson::SizeType>(l) < sz)
+        return eval((*value->value)[l], value->root_document);
+
+    if (rb_block_given_p())
+        return rb_yield(argv[0]);
+    else if (argc == 2)
+        return argv[1];
+    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]
+ */
+VALUE w_array_find_index(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) {
+        if (rb_block_given_p())
+            rb_warn("given block not used");
+        for (rapidjson::SizeType i = 0; i < value->value->Size(); i++) {
+            if (rb_equal(argv[0], eval_r((*value->value)[i], 0)) == Qtrue)
+                return UINT2NUM(i);
+        }
+        return Qnil;
+    }
+
+    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], value->root_document))))
+            return UINT2NUM(i);
+    }
+    return Qnil;
+}
+
+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 - 1, root_document);
+            else
+                rb_ary_push(array, eval(v, root_document));
+}
+
+/*
+ *  @overload flatten(lv = nil)
+ *   @return [::Array<Object>]
+ */
+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]);
+    VALUE ret = rb_ary_new2(value->value->Size());
+    flatten_array(*value->value, ret, level, value->root_document);
+    return ret;
+}
+
+/*
+ * @overload first
+ *   @return [Object | nil]
+ *
+ * @overload first(n)
+ *   @return [::Array<Object>]
+ */
+VALUE w_array_first(const int argc, const 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 (sz == 0)
+            return Qnil;
+        return eval(*value->value->Begin(), value->root_document);
+    } 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, value->root_document));
+        return ret;
+    }
+}
+
+/*
+ * @return [Boolean]
+ */
+VALUE w_array_include(const VALUE self, const VALUE val) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    for (auto &v : value->value->GetArray())
+        if (rb_equal(val, eval_r(v, 0)))
+            return Qtrue;
+    return Qfalse;
+}
+
+/*
+ * @return [String]
+ */
+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]
+ *
+ * @overload last(n)
+ *   @return [::Array<Object>]
+ */
+VALUE w_array_last(const int argc, const 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) {
+        return sz > 0 ? eval(*(value->value->End() - 1), value->root_document) : 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, value->root_document));
+        return ret;
+    }
+}
+
+/*
+ * @return [Integer]
+ */
+VALUE w_array_length(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    return UINT2NUM(value->value->Size());
+}
+
+/*
+ * @return [::Array<Object>]
+ */
+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]
+ */
+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], 0)) == 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>]
+ */
+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
+ *   @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]
+ */
+VALUE w_array_slice(const int argc, const VALUE *argv, const VALUE self) {
+    return w_array_operator_indexer(argc, argv, self);
+}
+
+/*
+ * Convert to Ruby data structures. Same as {Value#eval}.
+ *
+ * @return [::Array<Object>]
+ */
+VALUE w_array_eval(const VALUE self) {
+    UsaminValue *value = get_value(self);
+    check_array(value);
+    return eval_array(*(value->value), value->root_document);
+}