u 0.5.0 → 1.0.0

data/ext/u/rb_u_string_soft_dotted.c

@@ -0,0 +1,13 @@
+#include "rb_includes.h"
+
+/* @overload soft_dotted?
+ *   @return [Boolean] True if this {U::String} only contains soft-dotted
+ *     characters
+ *   @note Soft-dotted characters have the soft-dotted property and thus lose
+ *     their dot if an accent is applied to them, for example, ‘i’ and ‘j’.
+ *   @see http://unicode.org/review/pr-11.html Unicode Public Review Issue #11 */
+VALUE
+rb_u_string_soft_dotted(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_issoftdotted);
+}

data/ext/u/rb_u_string_space.c

@@ -0,0 +1,24 @@
+#include "rb_includes.h"
+
+/* @overload space?
+ *
+ *   Returns true if the receiver contains only “space” characters.  Space
+ *   characters are those in the general category Separator:
+ *
+ *   * Separator, space (Zs)
+ *   * Separator, line (Zl)
+ *   * Separator, paragraph (Zp)
+ *
+ *   such as ‘ ’, or a control character acting as such, namely
+ *
+ *   * U+0009 CHARACTER TABULATION (HT)
+ *   * U+000A LINE FEED (LF)
+ *   * U+000C FORM FEED (FF)
+ *   * U+000D CARRIAGE RETURN (CR)
+ *
+ *   @return [Boolean] */
+VALUE
+rb_u_string_space(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isspace);
+}

data/ext/u/rb_u_string_split.c

@@ -0,0 +1,245 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+static VALUE
+rb_u_string_split_trim(VALUE result, bool limit_given, int limit)
+{
+        if (limit_given || limit != 0)
+                return result;
+
+        long length;
+        while ((length = RARRAY_LEN(result)) > 0 &&
+               USTRING_LENGTH(RVAL2USTRING(RARRAY_PTR(result)[length - 1])) == 0)
+                rb_ary_pop(result);
+
+        return result;
+}
+
+static VALUE
+rb_u_string_split_rest(VALUE self, long offset, bool limit_given, int limit, VALUE result)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        long length = USTRING_LENGTH(string);
+
+        if (length > 0 && (limit_given || length > offset || limit < 0))
+                rb_ary_push(result,
+                            length == offset ?
+                                rb_u_string_new_empty(self) :
+                                rb_u_string_new_subsequence(self,
+                                                            offset,
+                                                            length - offset));
+
+        return rb_u_string_split_trim(result, limit_given, limit);
+}
+
+static VALUE
+rb_u_string_split_awk(VALUE self, bool limit_given, int limit)
+{
+        VALUE result = rb_ary_new();
+
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *begin = USTRING_STR(string);
+        const char *p = begin;
+        const char *end = USTRING_END(string);
+        int i = 1;
+        while (p < end) {
+                const char *q;
+                while (p < end && u_char_isspace(u_decode(&q, p, end)))
+                        p = q;
+
+                if (p == end || (limit_given && i >= limit))
+                        break;
+                i++;
+
+                q = p;
+                const char *r;
+                while (q < end && !u_char_isspace(u_decode(&r, q, end)))
+                        q = r;
+
+                rb_ary_push(result,
+                            rb_u_string_new_subsequence(self,
+                                                        p - begin,
+                                                        q - p));
+                p = q;
+        }
+
+        return rb_u_string_split_rest(self, p - begin, limit_given, limit, result);
+}
+
+static VALUE
+rb_u_string_split_string(VALUE self, VALUE rbseparator, bool limit_given, int limit)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *separator = RVAL2USTRING_ANY(rbseparator);
+
+        const char *begin = USTRING_STR(string);
+        const char *p = begin;
+        const char *end = USTRING_END(string);
+
+        const char *s_p = USTRING_STR(separator);
+        long s_len = USTRING_LENGTH(separator);
+
+        rb_u_validate(p, USTRING_LENGTH(string));
+        rb_u_validate(s_p, s_len);
+
+        VALUE result = rb_ary_new();
+
+        /* TODO: Better variable name. */
+        long offset;
+        for (int i = 1; (!limit_given || i < limit) && p < end; i++) {
+                if ((offset = rb_u_memsearch(s_p, s_len, p, end - p)) < 0)
+                        break;
+                rb_ary_push(result, rb_u_string_new_subsequence(self, p - begin, offset));
+                p += offset + s_len;
+        }
+
+        return rb_u_string_split_rest(self, p - begin, limit_given, limit, result);
+}
+
+static void
+rb_u_string_split_pattern_push_registers(VALUE self,
+                                         struct re_registers *registers,
+                                         VALUE result)
+{
+        for (int i = 1; i < registers->num_regs; i++) {
+                if (registers->beg[i] == -1)
+                        continue;
+                rb_ary_push(result,
+                            registers->beg[i] == registers->end[i] ?
+                                rb_u_string_new_empty(self) :
+                                rb_u_string_new_subsequence(self,
+                                                            registers->beg[i],
+                                                            registers->end[i] - registers->beg[i]));
+        }
+}
+
+static VALUE
+rb_u_string_split_pattern(VALUE self, VALUE pattern, bool limit_given, int limit)
+{
+        VALUE str = rb_str_to_str(self);
+
+        const char *begin = RSTRING_PTR(str);
+        const char *p = begin;
+        const char *end = RSTRING_END(str);
+
+        VALUE result = rb_ary_new();
+
+        bool last_was_empty = false;
+
+        long start = 0;
+        /* TODO: Better variable name. */
+        long offset;
+        int i = 1;
+        while ((offset = rb_reg_search(pattern, str, start, 0)) >= 0) {
+                struct re_registers *registers = RMATCH_REGS(rb_backref_get());
+                if (start == offset && registers->beg[0] == registers->end[0]) {
+                        if (begin == NULL) {
+                                rb_ary_push(result, rb_u_string_new_empty(self));
+                                break;
+                        } else if (last_was_empty) {
+                                const char *q;
+                                u_decode(&q, p, end);
+                                rb_ary_push(result,
+                                            rb_u_string_new_subsequence(self,
+                                                                        p - begin,
+                                                                        q - p));
+                        } else {
+                                if (begin + start == end)
+                                        start++;
+                                else {
+                                        const char *q;
+                                        u_decode(&q, p, end);
+                                        start += q - p;
+                                }
+                                last_was_empty = true;
+                                continue;
+                        }
+                } else {
+                        rb_ary_push(result,
+                                    rb_u_string_new_subsequence(self,
+                                                                p - begin,
+                                                                offset - (p - begin)));
+                        start = registers->end[0];
+                }
+                last_was_empty = false;
+                p = begin + start;
+
+                rb_u_string_split_pattern_push_registers(self, registers, result);
+
+                i++;
+                if (limit_given && i == limit)
+                        break;
+        }
+
+        return rb_u_string_split_rest(self, p - begin, limit_given, limit, result);
+}
+
+/* @overload split(pattern = $;, limit = 0)
+ *
+ *   Returns the receiver split into LIMIT substrings separated by PATTERN,
+ *   each inheriting any taint and untrust.
+ *
+ *   If PATTERN = `$;` = nil or PATTERN = `' '`, splits according to AWK rules,
+ *   that is, any {#space?} prefix is skipped, then substrings are separated by
+ *   non-empty {#space?} substrings.
+ *
+ *   If LIMIT < 0, then no limit is imposed and trailing {#empty?} substrings
+ *   aren’t removed.
+ *
+ *   If LIMIT = 0, then no limit is imposed and trailing {#empty?} substrings
+ *   are removed.
+ *
+ *   If LIMIT = 1, then, if {#length} = 0, the result will be empty, otherwise
+ *   it will consist of the receiver only.
+ *
+ *   If LIMIT > 1, then the receiver is split into at most LIMIT substrings.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_int] limit
+ *   @return [Array<U::String>] */
+VALUE
+rb_u_string_split_m(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rbpattern, rblimit;
+        int limit = 0;
+        bool limit_given;
+
+        if (rb_scan_args(argc, argv, "02", &rbpattern, &rblimit) == 2)
+                limit = NUM2INT(rblimit);
+
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        if (limit == 1) {
+                if (USTRING_LENGTH(string) == 0)
+                        return rb_ary_new2(0);
+
+                return rb_ary_new3(1, self);
+        }
+
+        limit_given = !NIL_P(rblimit) && limit >= 0;
+
+        if (NIL_P(rbpattern) && NIL_P(rb_fs))
+                return rb_u_string_split_awk(self, limit_given, limit);
+        else if (NIL_P(rbpattern))
+                rbpattern = rb_fs;
+
+        if (TYPE(rbpattern) != T_STRING && !RTEST(rb_obj_is_kind_of(rbpattern, rb_cUString)))
+                return rb_u_string_split_pattern(self,
+                                                 rb_u_pattern_argument(rbpattern, true),
+                                                 limit_given,
+                                                 limit);
+
+        const struct rb_u_string *pattern = RVAL2USTRING_ANY(rbpattern);
+        const char *p = USTRING_STR(pattern);
+        long length = USTRING_LENGTH(pattern);
+
+        if (length == 0)
+                return rb_u_string_split_pattern(self,
+                                                 rb_reg_regcomp(rb_str_to_str(rbpattern)),
+                                                 limit_given,
+                                                 limit);
+        else if (length == 1 && *p == ' ')
+                return rb_u_string_split_awk(self, limit_given, limit);
+        else
+                return rb_u_string_split_string(self, rbpattern, limit_given, limit);
+}

data/ext/u/rb_u_string_squeeze.c

@@ -0,0 +1,75 @@
+#include "rb_includes.h"
+#include "rb_u_string_internal_tr.h"
+
+static long
+rb_u_string_squeeze_loop(const struct rb_u_string *string, struct tr_table *table,
+                         char *result)
+{
+        long count = 0;
+
+        const char *p = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+
+        uint32_t previous = U_N_CODEPOINTS;
+        char *base = result;
+        while (p < end) {
+                const char *q;
+                uint32_t c = u_decode(&q, p, end);
+                if (c != previous ||
+                    (table != NULL && !tr_table_lookup(table, c))) {
+                        long run = q - p;
+                        if (base != NULL) {
+                                memcpy(base, p, run);
+                                base += run;
+                        }
+                        count += run;
+                        previous = c;
+                }
+                p = q;
+        }
+
+        return count;
+}
+
+/* @overload squeeze(*sets)
+ *
+ *   Returns the receiver, replacing any substrings of {#length} > 1 consisting
+ *   of the same character _c_ with _c_, where _c_ is a member of the
+ *   intersection of the character sets in SETS, inheriting any taint and
+ *   untrust.
+ *
+ *   If SETS is empty, then the set of all Unicode characters is used.
+ *
+ *   The complement of all Unicode characters and a given set of characters may
+ *   be specified by prefixing a non-empty set with ‘`^`’ (U+005E CIRCUMFLEX
+ *   ACCENT).
+ *
+ *   Any sequence of characters _a_-_b_ inside a set will expand to also
+ *   include all characters whose code points lay between those of _a_ and _b_.
+ *
+ *   @param [Array<U::String, #to_str>] sets
+ *   @return [U::String] */
+VALUE
+rb_u_string_squeeze(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        if (USTRING_LENGTH(string) == 0)
+                return Qnil;
+
+        struct tr_table table;
+        if (argc > 0)
+                tr_table_initialize_from_strings(&table, argc, argv);
+
+        struct tr_table *table_pointer = (argc > 0) ? &table : NULL;
+
+        long count = rb_u_string_squeeze_loop(string, table_pointer, NULL);
+        if (count == 0)
+                return self;
+
+        char *remaining = ALLOC_N(char, count + 1);
+        rb_u_string_squeeze_loop(string, table_pointer, remaining);
+        remaining[count] = '\0';
+
+        return rb_u_string_new_c_own(self, remaining, count);
+}

data/ext/u/rb_u_string_start_with.c

@@ -0,0 +1,31 @@
+#include "rb_includes.h"
+
+/* @overload start_with?(*prefixes)
+ *   @param [Array] prefixes
+ *   @return [Boolean] True if any element of PREFIXES that responds to #to_str
+ *     is a byte-level prefix of the receiver */
+VALUE
+rb_u_string_start_with(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *p = USTRING_STR(string);
+        long p_length = USTRING_LENGTH(string);
+
+        for (int i = 0; i < argc; i++) {
+                VALUE tmp = rb_u_string_check_type(argv[i]);
+                if (NIL_P(tmp))
+                        continue;
+
+                const struct rb_u_string *other = RVAL2USTRING_ANY(tmp);
+                const char *q = USTRING_STR(other);
+                long q_length = USTRING_LENGTH(other);
+
+                if (p_length < q_length)
+                        continue;
+
+                if (memcmp(p, q, q_length) == 0)
+                        return Qtrue;
+        }
+
+        return Qfalse;
+}

data/ext/u/rb_u_string_strip.c

@@ -0,0 +1,36 @@
+#include "rb_includes.h"
+
+/* @return [U::String] The receiver with its maximum {#space?} prefix and
+ *   suffix removed, inheriting any taint and untrust
+ * @see #lstrip
+ * @see #rstrip */
+VALUE
+rb_u_string_strip(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        const char *begin = USTRING_STR(string);
+        if (begin == NULL)
+                return self;
+
+        const char *end = USTRING_END(string);
+        const char *s = begin;
+        uint32_t c;
+        const char *t;
+        while (s < end && u_char_isspace(u_decode(&t, s, end)))
+                s = t;
+
+        t = end;
+        while (begin < t) {
+                const char *p;
+                c = u_decode_r(&p, begin, t);
+                if (c != '\0' && !u_char_isspace(c))
+                        break;
+                t = p;
+        }
+
+        if (s == begin && t == end)
+                return self;
+
+        return rb_u_string_new_c(self, s, t - s);
+}

data/ext/u/rb_u_string_sub.c

@@ -0,0 +1,147 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+/* @overload sub(pattern, replacement)
+ *
+ *   Returns the receiver with the first match of PATTERN replaced by
+ *   REPLACEMENT, inheriting any taint and untrust from the receiver and from
+ *   REPLACEMENT, or nil if there’s no match.
+ *
+ *   The REPLACEMENT is used as a specification for what to replace matches
+ *   with:
+ *
+ *   <table>
+ *     <thead>
+ *       <tr><th>Specification</th><th>Replacement</th></tr>
+ *     </thead>
+ *     <tbody>
+ *       <tr>
+ *         <td><code>\1</code>, <code>\2</code>, …, <code>\</code><em>n</em></td>
+ *         <td>Numbered sub-match <em>n</em></td>
+ *       </tr>
+ *       <tr>
+ *         <td><code>\k&lt;</code><em>name</em><code>></code></td>
+ *         <td>Named sub-match <em>name</em></td>
+ *       </tr>
+ *     </tbody>
+ *   </table>
+ *
+ *   The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …,
+ *   `$`_n_ are updated accordingly.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_str] replacement
+ *   @return [U::String, nil]
+ *
+ * @overload sub(pattern, replacements)
+ *
+ *   Returns the receiver with the first match of PATTERN replaced by
+ *   REPLACEMENTS#[_match_], where _match_ is the matched substring, inheriting
+ *   any taint and untrust from the receiver, REPLACEMENTS, and
+ *   REPLACEMENTS#[_match_], or nil if there’s no match.
+ *
+ *   The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …,
+ *   `$`_n_ are updated accordingly.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_hash] replacements
+ *   @raise [Exception] Any error raised by REPLACEMENTS#default, if it gets
+ *     called
+ *   @return [U::String, nil]
+ *
+ * @overload sub(pattern){ |match| … }
+ *
+ *   Returns the receiver with all instances of PATTERN replaced by the results
+ *   of the given block, inheriting any taint and untrust from the receiver and
+ *   from the results of the given block, or nil if there’s no match.
+ *
+ *   The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …,
+ *   `$`_n_ are updated accordingly.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @yieldparam [U::String] match
+ *   @yieldreturn [#to_str]
+ *   @return [U::String, nil] */
+VALUE
+rb_u_string_sub(int argc, VALUE *argv, VALUE self)
+{
+        VALUE pattern, replacement;
+        VALUE replacements = Qnil;
+        bool use_block = false;
+        bool tainted = false;
+        bool untrusted = false;
+
+        if (argc == 1)
+                use_block = true;
+
+        if (rb_scan_args(argc, argv, "11", &pattern, &replacement) == 2) {
+                replacements = rb_check_convert_type(replacement, T_HASH,
+                                                     "Hash", "to_hash");
+                if (NIL_P(replacements))
+                        StringValue(replacement);
+                if (OBJ_TAINTED(replacement))
+                        tainted = true;
+                if (OBJ_UNTRUSTED(replacement))
+                        untrusted = true;
+        }
+
+        pattern = rb_u_pattern_argument(pattern, true);
+
+        VALUE str = rb_str_to_str(self);
+        long begin = rb_reg_search(pattern, str, 0, 0);
+        if (begin < 0)
+                return Qnil;
+
+        VALUE match = rb_backref_get();
+        struct re_registers *registers = RMATCH_REGS(match);
+        VALUE result;
+        if (use_block || !NIL_P(replacements)) {
+                if (use_block) {
+                        VALUE ustr = rb_u_string_new_rb(rb_reg_nth_match(0, match));
+                        result = rb_u_string_object_as_string(rb_yield(ustr));
+                } else {
+                        VALUE ustr = rb_u_string_new_c(self,
+                                                       RSTRING_PTR(str) + registers->beg[0],
+                                                       registers->end[0] - registers->beg[0]);
+                        result = rb_u_string_object_as_string(rb_hash_aref(replacements, ustr));
+                }
+        } else
+                result =
+#ifdef HAVE_RB_REG_REGSUB4
+                        rb_reg_regsub(replacement, str, registers, pattern);
+#else
+                        rb_reg_regsub(replacement, str, registers);
+#endif
+
+        if (OBJ_TAINTED(result))
+                tainted = true;
+        if (OBJ_UNTRUSTED(result))
+                untrusted = true;
+
+        const struct rb_u_string *value = RVAL2USTRING_ANY(result);
+
+        size_t length = registers->beg[0] +
+                USTRING_LENGTH(value) +
+                (RSTRING_LEN(str) - registers->end[0]);
+        char *base = ALLOC_N(char, length + 1);
+        MEMCPY(base,
+               RSTRING_PTR(str),
+               char,
+               registers->beg[0]);
+        MEMCPY(base + registers->beg[0],
+               USTRING_STR(value),
+               char,
+               USTRING_LENGTH(value));
+        MEMCPY(base + registers->beg[0] + USTRING_LENGTH(value),
+               RSTRING_PTR(str) + registers->end[0],
+               char,
+               RSTRING_LEN(str) - registers->end[0]);
+        base[length] = '\0';
+
+        VALUE substituted = rb_u_string_new_c_own(self, base, length);
+        if (tainted)
+                OBJ_TAINT(substituted);
+        if (untrusted)
+                OBJ_UNTRUST(substituted);
+        return substituted;
+}