u 0.5.0 → 1.0.0

data/ext/u/rb_u_string.h

@@ -0,0 +1,173 @@
+/* TODO: Move this to rb_u_string.c and turn USTRING_STR() into
+ * rb_u_string_c_str() and USTRING_LENGTH() into rb_u_string_c_length() */
+struct rb_u_string {
+        VALUE rb;
+        const char *c;
+        long length;
+};
+
+
+#define RVAL2USTRING(object) \
+        (Check_Type(object, T_DATA), (struct rb_u_string *)DATA_PTR(object))
+
+#define RVAL2USTRING_ANY(value) \
+        (rb_obj_is_kind_of((value), rb_cUString) ? \
+         RVAL2USTRING(value) : \
+         USTRING_LOCAL(StringValue(value), NULL, 0))
+
+#define USTRING2RVAL(string) \
+        Data_Wrap_Struct(rb_cUString, rb_u_string_mark, rb_u_string_free, string)
+
+#define USTRING_LOCAL(arb, ac, alength) \
+        (&(struct rb_u_string){ .rb = (arb), .c = (ac), .length = (alength) })
+
+/* TODO: Call this USTRING_BEGIN() instead */
+#define USTRING_STR(string) \
+        (NIL_P((string)->rb) ? (string)->c : RSTRING_PTR(string->rb))
+
+#define USTRING_LENGTH(string) \
+        (NIL_P((string)->rb) ? (string)->length : RSTRING_LEN(string->rb))
+
+#define USTRING_END(string) \
+        (NIL_P((string)->rb) ? (string)->c + (string)->length : RSTRING_END(string->rb))
+
+static inline const char *
+rb_u_string_begin_from_offset(const struct rb_u_string *string, long offset)
+{
+        return u_offset_to_pointer_n(offset >= 0 ?
+                                        USTRING_STR(string) :
+                                        USTRING_END(string),
+                                     offset,
+                                     USTRING_LENGTH(string));
+}
+
+
+extern VALUE rb_cUString;
+
+
+VALUE rb_u_string_new_uninfected(const char *str, long length);
+VALUE rb_u_string_new_uninfected_own(const char *str, long length);
+VALUE rb_u_string_new_c(VALUE self, const char *str, long length);
+VALUE rb_u_string_new_c_own(VALUE self, const char *str, long length);
+VALUE rb_u_string_new_rb(VALUE str);
+VALUE rb_u_string_new_subsequence(VALUE self, long begin, long length);
+VALUE rb_u_string_new_empty(VALUE self);
+
+VALUE rb_u_string_check_type(VALUE str);
+VALUE rb_u_string_validate_type(VALUE str);
+VALUE rb_u_string_object_as_string(VALUE object);
+
+const char *rb_u_string_begin_from_offset(const struct rb_u_string *string, long offset);
+
+/* TODO: Move to rb_private.h. */
+long rb_u_string_index(VALUE self, VALUE sub, long offset);
+long rb_u_string_rindex(VALUE self, VALUE rbsubstring, long offset);
+
+VALUE rb_u_string_alnum(VALUE self);
+VALUE rb_u_string_alpha(VALUE self);
+VALUE rb_u_string_assigned(VALUE self);
+VALUE rb_u_string_aref_m(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_ascii_only(VALUE self);
+VALUE rb_u_string_b(VALUE self);
+VALUE rb_u_string_bytes(VALUE self);
+VALUE rb_u_string_bytesize(VALUE self);
+VALUE rb_u_string_byteslice_m(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_center(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_casecmp(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_cased(VALUE self);
+VALUE rb_u_string_case_ignorable(VALUE self);
+VALUE rb_u_string_chars(VALUE self);
+VALUE rb_u_string_chomp(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_chop(VALUE self);
+VALUE rb_u_string_chr(VALUE self);
+VALUE rb_u_string_cntrl(VALUE self);
+VALUE rb_u_string_codepoints(VALUE self);
+VALUE rb_u_string_collate(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_collation_key(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_canonical_combining_class(VALUE self);
+VALUE rb_u_string_count(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_defined(VALUE self);
+VALUE rb_u_string_delete(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_digit(VALUE self);
+VALUE rb_u_string_downcase(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_dump(VALUE self);
+VALUE rb_u_string_dup(VALUE self);
+VALUE rb_u_string_each_byte(VALUE self);
+VALUE rb_u_string_each_char(VALUE self);
+VALUE rb_u_string_each_codepoint(VALUE self);
+VALUE rb_u_string_each_grapheme_cluster(VALUE self);
+VALUE rb_u_string_each_line(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_each_word(VALUE self);
+VALUE rb_u_string_empty(VALUE self);
+VALUE rb_u_string_end_with(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_equal(VALUE self, VALUE other);
+VALUE rb_u_string_eql(VALUE self, VALUE other);
+VALUE rb_u_string_foldcase(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_folded(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_format(int argc, const VALUE *argv, VALUE self);
+VALUE rb_u_string_format_m(VALUE self, VALUE argument);
+VALUE rb_u_string_general_category(VALUE self);
+VALUE rb_u_string_getbyte(VALUE self, VALUE rbindex);
+VALUE rb_u_string_graph(VALUE self);
+VALUE rb_u_string_grapheme_break(VALUE self);
+VALUE rb_u_string_gsub(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_hash(VALUE self);
+VALUE rb_u_string_hex(VALUE self);
+VALUE rb_u_string_index_m(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_include(VALUE self, VALUE other);
+VALUE rb_u_string_inspect(VALUE self);
+VALUE rb_u_string_length(VALUE self);
+VALUE rb_u_string_line_break(VALUE self);
+VALUE rb_u_string_lines(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_ljust(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_lower(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_lstrip(VALUE self);
+VALUE rb_u_string_match(VALUE self, VALUE other);
+VALUE rb_u_string_match_m(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_mirror(VALUE self);
+VALUE rb_u_string_normalize(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_normalized(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_newline(VALUE self);
+VALUE rb_u_string_oct(VALUE self);
+VALUE rb_u_string_ord(VALUE self);
+VALUE rb_u_string_partition(VALUE self, VALUE separator);
+VALUE rb_u_string_plus(VALUE self, VALUE rbother);
+VALUE rb_u_string_print(VALUE self);
+VALUE rb_u_string_punct(VALUE self);
+VALUE rb_u_string_reverse(VALUE self);
+VALUE rb_u_string_rindex_m(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_rjust(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_rpartition(VALUE self, VALUE separator);
+VALUE rb_u_string_rstrip(VALUE self);
+VALUE rb_u_string_scan(VALUE self, VALUE pattern);
+VALUE rb_u_string_script(VALUE self);
+VALUE rb_u_string_soft_dotted(VALUE self);
+VALUE rb_u_string_space(VALUE self);
+VALUE rb_u_string_split(VALUE self, const char *separator, long length);
+VALUE rb_u_string_split_m(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_squeeze(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_start_with(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_strip(VALUE self);
+VALUE rb_u_string_sub(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_substr(VALUE self, long offset, long len);
+VALUE rb_u_string_times(VALUE self, VALUE rbtimes);
+VALUE rb_u_string_title(VALUE self);
+VALUE rb_u_string_titlecase(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_to_i(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_to_str(VALUE self);
+VALUE rb_u_string_to_sym(VALUE self);
+VALUE rb_u_string_tr(VALUE self, VALUE from, VALUE to);
+VALUE rb_u_string_tr_s(VALUE self, VALUE from, VALUE to);
+VALUE rb_u_string_upcase(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_upper(int argc, VALUE *argv, VALUE self);
+VALUE rb_u_string_valid(VALUE self);
+VALUE rb_u_string_valid_encoding(VALUE self);
+VALUE rb_u_string_wide(VALUE self);
+VALUE rb_u_string_wide_cjk(VALUE self);
+VALUE rb_u_string_width(VALUE self);
+VALUE rb_u_string_word_break(VALUE self);
+VALUE rb_u_string_xdigit(VALUE self);
+VALUE rb_u_string_zero_width(VALUE self);
+
+
+void Init_u_string(VALUE mU);

data/ext/u/rb_u_string_alnum.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload alnum?
+ *   @return [Boolean] True if the receiver contains only characters in the
+ *     general categories Letter and Number */
+VALUE
+rb_u_string_alnum(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isalnum);
+}

data/ext/u/rb_u_string_alpha.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload alpha?
+ *   @return [Boolean] True if the receiver contains only characters in the
+ *     general category Alpha */
+VALUE
+rb_u_string_alpha(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isalpha);
+}

data/ext/u/rb_u_string_aref.c

@@ -0,0 +1,142 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+static VALUE
+rb_u_string_substr_impl(VALUE self, long offset, long len, bool nil_on_empty)
+{
+        if (len < 0)
+                return Qnil;
+
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        const char *begin = rb_u_string_begin_from_offset(string, offset);
+        if (begin == NULL)
+                return Qnil;
+
+        const char *end = u_offset_to_pointer_n(begin, len, USTRING_END(string) - begin);
+        if (end == NULL)
+                end = USTRING_END(string);
+
+        if (nil_on_empty && begin == end)
+                return Qnil;
+
+        if (begin == USTRING_STR(string) && end == USTRING_END(string))
+                return self;
+
+        return rb_u_string_new_c(self, begin, end - begin);
+}
+
+VALUE
+rb_u_string_substr(VALUE self, long offset, long len)
+{
+        return rb_u_string_substr_impl(self, offset, len, false);
+}
+
+static VALUE
+rb_u_string_subpat(VALUE self, VALUE re, VALUE reference)
+{
+        if (rb_reg_search(re, StringValue(self), 0, 0) < 0)
+                return Qnil;
+
+        volatile VALUE match = rb_u_pattern_match_reference(reference);
+
+        return NIL_P(match) ? Qnil : rb_u_string_new_rb(match);
+}
+
+static VALUE
+rb_u_string_aref_num(VALUE self, long offset)
+{
+        return rb_u_string_substr_impl(self, offset, 1, true);
+}
+
+static VALUE
+rb_u_string_aref_default(VALUE self, VALUE index)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        long n_chars = u_n_chars_n(USTRING_STR(string), USTRING_LENGTH(string));
+
+        long begin, length;
+        switch (rb_range_beg_len(index, &begin, &length, n_chars, 0)) {
+        case Qfalse:
+                return rb_u_string_aref_num(self, NUM2LONG(index));
+        case Qnil:
+                return Qnil;
+        default:
+                return rb_u_string_substr(self, begin, length);
+        }
+}
+
+static VALUE
+rb_u_string_aref(VALUE self, VALUE index)
+{
+        if (TYPE(index) == T_STRING || RTEST(rb_obj_is_kind_of(index, rb_cUString))) {
+                if (rb_u_string_index(self, index, 0) == -1)
+                        return Qnil;
+
+                return TYPE(index) == T_STRING ?
+                        rb_u_string_new_c(index, RSTRING_PTR(index), RSTRING_LEN(index)) :
+                        index;
+        }
+
+        switch (TYPE(index)) {
+        case T_FIXNUM:
+                return rb_u_string_aref_num(self, FIX2LONG(index));
+        case T_REGEXP:
+                return rb_u_string_subpat(self, index, INT2FIX(0));
+        default:
+                return rb_u_string_aref_default(self, index);
+        }
+}
+
+/* @overload [](index)
+ *   @param [#to_int] index
+ *   @return [U::String, nil] The substring [max(_i_, 0), min({#length}, _i_ +
+ *     1)], where _i_ = INDEX if INDEX ≥ 0, _i_ = {#length} - abs(INDEX)
+ *     otherwise, inheriting any taint and untrust, or nil if this substring is
+ *     empty
+ *
+ * @overload [](index, length)
+ *   @param [#to_int] index
+ *   @param [#to_int] length
+ *   @return [U::String, nil] The substring [max(_i_, 0), min({#length}, _i_ +
+ *     LENGTH)], where _i_ = INDEX if INDEX ≥ 0, _i_ = {#length} - abs(INDEX)
+ *     otherwise, inheriting any taint or untrust, or nil if LENGTH < 0
+ *
+ * @overload [](range)
+ *   @param [Range] range
+ *   @return [U::String, nil] The result of `#[i, j - k]`, where _i_ =
+ *     RANGE#begin if RANGE#begin ≥ 0, _i_ = {#length} - abs(RANGE#begin)
+ *     otherwise, _j_ = RANGE#end if RANGE#end ≥ 0, _j_ = {#length} -
+ *     abs(RANGE#end) otherwise, and _k_ = 1 if RANGE#exclude_end?, _k_ = 0
+ *     otherwise, or nil if _j_ - _k_ < 0
+ *
+ * @overload [](regexp, reference = 0)
+ *   @param [Regexp] regexp
+ *   @param [#to_int, #to_str, Symbol] reference
+ *   @raise [IndexError] If REFERENCE doesn’t refer to a submatch
+ *   @return [U::String, nil] The submatch REFERENCE from the first match of
+ *     REGEXP in the receiver, inheriting any taint and untrust from both
+ *     the receiver and from REGEXP, or nil if there is no match or if the
+ *     submatch isn’t part of the overall match
+ *
+ * @overload [](string)
+ *   @param [U::String, ::String] string
+ *   @return [U::String, nil] The substring STRING, inheriting any taint and
+ *     untrust from STRING, if STRING is a substring of the receiver
+ *
+ * @overload [](object)
+ *   @param [Object] object
+ *   @return [nil] Nil for any object that doesn’t satisfy the other cases */
+VALUE
+rb_u_string_aref_m(int argc, VALUE *argv, VALUE self)
+{
+        need_m_to_n_arguments(argc, 1, 2);
+
+        if (argc == 1)
+                return rb_u_string_aref(self, argv[0]);
+
+        if (TYPE(argv[0]) == T_REGEXP)
+                return rb_u_string_subpat(self, argv[0], argv[1]);
+
+        return rb_u_string_substr(self, NUM2LONG(argv[0]), NUM2LONG(argv[1]));
+}

data/ext/u/rb_u_string_ascii_only.c

@@ -0,0 +1,13 @@
+#include "rb_includes.h"
+
+/* @overload ascii_only?
+ *   @return [Boolean] True if the receiver contains only characters in the ASCII region, that
+ *     is, U+0000 through U+007F */
+VALUE
+rb_u_string_ascii_only(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        return u_is_ascii_only_n(USTRING_STR(string), USTRING_LENGTH(string)) ?
+                Qtrue : Qfalse;
+}

data/ext/u/rb_u_string_assigned.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload assigned?
+ *   @return [Boolean] True if the receiver contains only code points that have
+ *     been assigned a code value */
+VALUE
+rb_u_string_assigned(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isassigned);
+}

data/ext/u/rb_u_string_b.c

@@ -0,0 +1,18 @@
+#include "rb_includes.h"
+#ifdef HAVE_RUBY_ENCODING_H
+#  include <ruby/encoding.h>
+#endif
+
+/* @return [String] The String representation of the receiver, inheriting any
+ *   taint and untrust, encoded as ASCII-8BIT. */
+VALUE
+rb_u_string_b(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        VALUE result = rb_str_new(USTRING_STR(string), USTRING_LENGTH(string));
+#ifdef HAVE_RUBY_ENCODING_H
+        rb_enc_associate(result, rb_ascii8bit_encoding());
+#endif
+        OBJ_INFECT(result, self);
+        return result;
+}

data/ext/u/rb_u_string_bytesize.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @return [Integer] The number of bytes required to represent the receiver */
+VALUE
+rb_u_string_bytesize(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        return LONG2NUM(USTRING_LENGTH(string));
+}

data/ext/u/rb_u_string_byteslice.c

@@ -0,0 +1,103 @@
+#include "rb_includes.h"
+
+static VALUE
+rb_u_string_byte_substr(VALUE self, long offset, long length)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        long n = USTRING_LENGTH(string);
+
+        if (offset > n || length < 0)
+                return Qnil;
+
+        if (offset < 0) {
+                offset += n;
+                if (offset < 0)
+                        return Qnil;
+        }
+
+        if (offset + length > n)
+                length = n - offset;
+
+        if (length <= 0)
+                return rb_u_string_new_empty(self);
+
+        return rb_u_string_new_subsequence(self, offset, length);
+}
+
+static VALUE
+rb_u_string_byteslice_num(VALUE self, long offset)
+{
+        VALUE result = rb_u_string_byte_substr(self, offset, 1);
+
+        if (NIL_P(result) || USTRING_LENGTH(RVAL2USTRING(result)) == 0)
+                return Qnil;
+
+        return result;
+}
+
+static VALUE
+rb_u_string_byteslice_default(VALUE self, VALUE index)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        long n_bytes = USTRING_LENGTH(string);
+
+        long begin, length;
+        switch (rb_range_beg_len(index, &begin, &length, n_bytes, 0)) {
+        case Qfalse:
+                return rb_u_string_byteslice_num(self, NUM2LONG(index));
+        case Qnil:
+                return Qnil;
+        default:
+                return rb_u_string_byte_substr(self, begin, length);
+        }
+}
+
+static VALUE
+rb_u_string_byteslice(VALUE self, VALUE index)
+{
+        switch (TYPE(index)) {
+        case T_FIXNUM:
+                return rb_u_string_byteslice_num(self, FIX2LONG(index));
+        default:
+                return rb_u_string_byteslice_default(self, index);
+        }
+}
+
+/* @overload byteslice(index)
+ *   @param [#to_int] index
+ *   @return [U::String, nil] The byte-index-based substring [max(_i_, 0),
+ *     min({#bytesize}, _i_ + 1)], where _i_ = INDEX if INDEX ≥ 0, _i_ =
+ *     {#bytesize} - abs(INDEX) otherwise, inheriting any taint and untrust, or
+ *     nil if this substring is empty
+ *
+ * @overload byteslice(index, length)
+ *   @param [#to_int] index
+ *   @param [#to_int] length
+ *   @return [U::String, nil] The byte-index-based substring [max(_i_, 0),
+ *     min({#bytesize}, _i_ + LENGTH)], where _i_ = INDEX if INDEX ≥ 0, _i_ =
+ *     {#bytesize} - abs(INDEX) otherwise, inheriting any taint and untrust, or
+ *     nil if LENGTH < 0
+ *
+ * @overload byteslice(range)
+ *   @param [Range] range
+ *   @return [U::String, nil] The result of `#[i, j - k]`, where _i_ =
+ *     RANGE#begin if RANGE#begin ≥ 0, _i_ = {#bytesize} - abs(RANGE#begin)
+ *     otherwise, _j_ = RANGE#end if RANGE#end ≥ 0, _j_ = {#bytesize} -
+ *     abs(RANGE#end) otherwise, and _k_ = 1 if RANGE#exclude_end?, _k_ = 0
+ *     otherwise, or nil if _j_ - _k_ < 0
+ *
+ * @overload byteslice(object)
+ *   @param [Object] object
+ *   @return [nil] Nil for any object that doesn’t satisfy the other cases */
+VALUE
+rb_u_string_byteslice_m(int argc, VALUE *argv, VALUE self)
+{
+        need_m_to_n_arguments(argc, 1, 2);
+
+        if (argc == 1)
+                return rb_u_string_byteslice(self, argv[0]);
+
+        return rb_u_string_byte_substr(self,
+                                       NUM2LONG(argv[0]),
+                                       NUM2LONG(argv[1]));
+}