u 0.5.0 → 1.0.0

data/ext/u/rb_u_string_canonical_combining_class.c

@@ -0,0 +1,33 @@
+#include "rb_includes.h"
+
+/* Returns the canonical combining class of the characters of the receiver.
+ *
+ * The canonical combining class of a character is a number in the range [0,
+ * 254].  The canonical combining class is used when generating a canonical
+ * ordering of the characters in a string.
+ *
+ * The empty string has a canonical combining class of 0.
+ *
+ * @raise [ArgumentError] If the receiver contains two characters belonging to
+ *   different combining classes
+ * @raise [ArgumentError] If the receiver contains an incomplete UTF-8 sequence
+ * @raise [ArgumentError] If the receiver contains an invalid UTF-8 sequence
+ * @return [Fixnum] */
+VALUE
+rb_u_string_canonical_combining_class(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *p = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+        if (p == end)
+                return 0;
+        int first = u_char_canonical_combining_class(u_decode(&p, p, end));
+        while (p < end) {
+                int value = u_char_canonical_combining_class(u_decode(&p, p, end));
+                if (value != first)
+                        rb_u_raise(rb_eArgError,
+                                   "string consists of characters with different canonical combining class values: %d+, %d",
+                                   first, value);
+        }
+        return INT2FIX(first);
+}

data/ext/u/rb_u_string_case_ignorable.c

@@ -0,0 +1,25 @@
+#include "rb_includes.h"
+
+/* @overload case_ignorable?
+ *
+ *   @return [Boolean] True if the receiver contains only “case ignorable”
+ *     characters, that is, characters in the general categories
+ *
+ *     * Other, format (Cf)
+ *     * Letter, modifier (Lm)
+ *     * Mark, enclosing (Me)
+ *     * Mark, nonspacing (Mn)
+ *     * Symbol, modifier (Sk)
+ *
+ *     and the characters
+ *
+ *     * U+0027 APOSTROPHE
+ *     * U+00AD SOFT HYPHEN
+ *     * U+2019 RIGHT SINGLE QUOTATION MARK
+ *   @see http://unicode.org/reports/tr21/tr21-5.html
+ *     Unicode Standard Annex #21: Case Mappings */
+VALUE
+rb_u_string_case_ignorable(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_iscaseignorable);
+}

data/ext/u/rb_u_string_casecmp.c

@@ -0,0 +1,61 @@
+#include <errno.h>
+#include "rb_includes.h"
+
+static size_t
+foldcase(char **result, const struct rb_u_string *string, const char *locale,
+         char *previous)
+{
+        size_t n = u_foldcase(NULL, 0,
+                              USTRING_STR(string), USTRING_LENGTH(string),
+                              locale);
+        *result = _rb_u_guarded_alloc(n + 1, previous, NULL);
+        return u_foldcase(*result, n + 1,
+                          USTRING_STR(string), USTRING_LENGTH(string),
+                          locale);
+}
+
+/* @overload casecmp(other, locale = ENV['LC_COLLATE'])
+ *
+ *   Returns the comparison of {#foldcase} to _other_{#foldcase} using the
+ *   linguistically correct rules of LOCALE.  This is, however, only an
+ *   approximation of a case-insensitive comparison.  The LOCALE must be given
+ *   as a language, region, and encoding, for example, “en_US.UTF-8”.
+ *
+ *   This operation is known as “collation” and you can find more information
+ *   about the collation algorithm employed in the
+ *   Unicode Technical Standard #10, see http://unicode.org/reports/tr10/.
+ *
+ *   @param [U::String, #to_str] other
+ *   @param [#to_str] locale
+ *   @return [Fixnum] */
+VALUE
+rb_u_string_casecmp(int argc, VALUE *argv, VALUE self)
+{
+        const char *locale = NULL;
+
+        VALUE rbother, rblocale;
+        if (rb_scan_args(argc, argv, "11", &rbother, &rblocale) == 2)
+                locale = StringValuePtr(rblocale);
+
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *other = RVAL2USTRING_ANY(rbother);
+
+        char *folded;
+        size_t folded_n = foldcase(&folded, string, locale, NULL);
+
+        char *folded_other;
+        size_t folded_other_n = foldcase(&folded_other, other, locale, folded);
+
+        errno = 0;
+        int r = u_collate(folded, folded_n,
+                          folded_other, folded_other_n,
+                          locale);
+
+        free(folded_other);
+        free(folded);
+
+        if (errno != 0)
+                rb_u_raise_errno(errno, "can’t collate strings");
+
+        return INT2FIX(r);
+}

data/ext/u/rb_u_string_cased.c

@@ -0,0 +1,17 @@
+#include "rb_includes.h"
+
+/* @overload cased?
+ *
+ *   @return [Boolean] True if the receiver only contains characters in the
+ *     general categories
+ *
+ *     * Letter, uppercase (Lu)
+ *     * Letter, lowercase (Ll)
+ *     * Letter, titlecase (Lt)
+ *
+ *     or has the derived properties Other_Uppercase or Other_Lowercase */
+VALUE
+rb_u_string_cased(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_iscased);
+}

data/ext/u/rb_u_string_chomp.c

@@ -0,0 +1,107 @@
+#include "rb_includes.h"
+
+static VALUE
+rb_u_string_chomp_default(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        const char *begin = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+
+        const char *last;
+        uint32_t c = u_decode_r(&last, begin, end);
+        if (c == '\n') {
+                if (*(last - 1) == '\r')
+                        last--;
+        } else if (!u_char_isnewline(c))
+                return self;
+
+        return rb_u_string_new_c(self, begin, last - begin);
+}
+
+static VALUE
+rb_u_string_chomp_newlines(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *begin = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+
+        const char *last = end;
+        const char *last_but_one;
+        while (last > begin &&
+               u_char_isnewline(u_decode_r(&last_but_one, begin, last)))
+                last = last_but_one;
+
+        if (last == end)
+                return self;
+
+        return rb_u_string_new_c(self, begin, last - begin);
+}
+
+/* @overload chomp(separator = $/)
+ *
+ *   Returns the receiver, minus any SEPARATOR suffix, inheriting any taint and
+ *   untrust, unless {#length} = 0, in which case nil is returned.  If
+ *   SEPARATOR is nil or invalidly encoded, the receiver is returned.
+ *
+ *   If SEPARATOR is `$/` and `$/` has its default value or if SEPARATOR is
+ *   U+000A LINE FEED, the longest suffix consisting of any of
+ *
+ *   * U+000A LINE FEED
+ *   * U+000D CARRIAGE RETURN
+ *   * U+000D CARRIAGE RETURN, U+000D LINE FEED
+ *
+ *   will be removed. If no such suffix exists and the last character is a
+ *   {#newline?}, it will be removed instead.
+ *
+ *   If SEPARATOR is {#empty?}, remove the longest {#newline?} suffix.
+ *
+ *   @param [U::String, #to_str, nil] separator
+ *   @return [U::String, self, nil]
+ *   @see #chop
+ *   @see #lstrip
+ *   @see #rstrip
+ *   @see #strip */
+VALUE
+rb_u_string_chomp(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        long length = USTRING_LENGTH(string);
+        if (length == 0)
+                return Qnil;
+
+        VALUE rs;
+        if (argc == 0) {
+                rs = rb_rs;
+                if (rs == rb_default_rs)
+                        return rb_u_string_chomp_default(self);
+        } else {
+                rb_scan_args(argc, argv, "01", &rs);
+        }
+        if (NIL_P(rs))
+                return self;
+
+        const struct rb_u_string *separator = RVAL2USTRING_ANY(rs);
+
+        long separator_length = USTRING_LENGTH(separator);
+        if (separator_length == 0)
+                return rb_u_string_chomp_newlines(self);
+
+        if (separator_length > length)
+                return self;
+
+        char last_char = USTRING_STR(separator)[separator_length - 1];
+        if (separator_length == 1 && last_char == '\n')
+                return rb_u_string_chomp_default(self);
+
+        if (!u_valid(USTRING_STR(separator), separator_length, NULL) ||
+            USTRING_STR(string)[length - 1] != last_char ||
+            (separator_length > 1 &&
+             rb_memcmp(USTRING_STR(separator),
+                       USTRING_END(string) - separator_length,
+                       separator_length) != 0))
+                return self;
+
+        return rb_u_string_new_c(self, USTRING_STR(string), length - separator_length);
+}

data/ext/u/rb_u_string_chop.c

@@ -0,0 +1,33 @@
+#include "rb_includes.h"
+
+/* Returns the receiver, minus its last character, inheriting any taint and
+ * untrust, unless the receiver is {#empty?} or if the last character is
+ * invalidly encoded, in which case the receiver is returned.
+ *
+ * If the last character is U+000A LINE FEED and the second-to-last character
+ * is U+000D CARRIAGE RETURN, both characters are removed.
+ *
+ * @return [U::String]
+ * @see #chomp
+ * @see #lstrip
+ * @see #rstrip
+ * @see #strip */
+VALUE
+rb_u_string_chop(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        if (USTRING_LENGTH(string) == 0)
+                return self;
+
+        const char *begin = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+
+        const char *last;
+        uint32_t c = u_decode_r(&last, begin, end);
+        if (c == '\n')
+                if (*(last - 1) == '\r')
+                        last--;
+
+        return rb_u_string_new_c(self, begin, last - begin);
+}

data/ext/u/rb_u_string_chr.c

@@ -0,0 +1,9 @@
+#include "rb_includes.h"
+
+/* @return [U::String] The substring [0, min({#length}, 1)], inheriting any
+ *   taint and untrust */
+VALUE
+rb_u_string_chr(VALUE self)
+{
+        return rb_u_string_substr(self, 0, 1);
+}

data/ext/u/rb_u_string_cntrl.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload cntrl?
+ *   @return [Boolean] True if the receiver contains only characters in the
+ *     general category Other, control (Cc) */
+VALUE
+rb_u_string_cntrl(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_iscntrl);
+}

data/ext/u/rb_u_string_collate.c

@@ -0,0 +1,46 @@
+#include "rb_includes.h"
+#include <errno.h>
+
+/* @overload <=>(other, locale = ENV['LC_COLLATE'])
+ *
+ *   Returns the comparison of the receiver and OTHER using the linguistically
+ *   correct rules of LOCALE.  The LOCALE must be given as a language, region,
+ *   and encoding, for example, “en_US.UTF-8”.
+ *
+ *   This operation is known as “collation” and you can find more information
+ *   about the collation algorithm employed in the
+ *   Unicode Technical Standard #10, see http://unicode.org/reports/tr10/.
+ *
+ *   @param [U::String, #to_str] other
+ *   @param [#to_str] locale
+ *   @raise [Errno::EILSEQ] If a character in the receiver can’t be converted
+ *     into the encoding of the locale
+ *   @return [Fixnum]
+ *   @see #==
+ *   @see #eql? */
+VALUE
+rb_u_string_collate(int argc, VALUE *argv, VALUE self)
+{
+        const char *locale = NULL;
+
+        VALUE rbother, rblocale;
+        if (rb_scan_args(argc, argv, "11", &rbother, &rblocale) == 2)
+                locale = StringValuePtr(rblocale);
+        else {
+                const char * const env[] = { "LC_ALL", "LC_COLLATE", "LANG", NULL };
+                for (const char * const *p = env; *p != NULL; p++)
+                        if ((locale = getenv(*p)) != NULL)
+                                break;
+        }
+
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *other = RVAL2USTRING_ANY(rbother);
+
+        errno = 0;
+        int r = u_collate(USTRING_STR(string), USTRING_LENGTH(string),
+                          USTRING_STR(other), USTRING_LENGTH(other),
+                          locale);
+        if (errno != 0)
+                rb_u_raise_errno(errno, "can’t collate strings");
+        return INT2FIX(r);
+}

data/ext/u/rb_u_string_collation_key.c

@@ -0,0 +1,18 @@
+#include "rb_includes.h"
+
+/* @overload collation_key(locale = ENV['LC_COLLATE'])
+ *
+ *   @raise [Errno::EILSEQ] If a character in the receiver can’t be converted
+ *     into the encoding of the locale
+ *   @return [U::String] The locale-dependent collation key of the receiver in
+ *     LOCALE, inheriting any taint and untrust
+ *   @note Use the collation key when comparing U::Strings to each other
+ *     repeatedly, as occurs when, for example, sorting a list of
+ *     U::Strings.
+ *   @note The LOCALE must be given as a language, region, and encoding, for
+ *     example, “en_US.UTF-8”. */
+VALUE
+rb_u_string_collation_key(int argc, VALUE *argv, VALUE self)
+{
+        return _rb_u_string_convert_locale(argc, argv, self, u_collation_key, "LC_COLLATE");
+}

data/ext/u/rb_u_string_count.c

@@ -0,0 +1,38 @@
+#include "rb_includes.h"
+#include "rb_u_string_internal_tr.h"
+
+/* @overload count(set, *sets)
+ *
+ * Returns the number of characters in the receiver that are included in the
+ * intersection of SET and any additional SETS of characters.
+ *
+ * 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 [U::String, #to_str] set
+ * @param [Array<U::String, #to_str>] sets
+ * @return [Integer] */
+VALUE
+rb_u_string_count(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        need_at_least_n_arguments(argc, 1);
+
+        if (USTRING_LENGTH(string) == 0)
+                return INT2FIX(0);
+
+        struct tr_table table;
+        tr_table_initialize_from_strings(&table, argc, argv);
+
+        long count = 0;
+        for (const char *p = USTRING_STR(string), *end = USTRING_END(string); p < end; )
+                if (tr_table_lookup(&table, u_decode(&p, p, end)))
+                        count++;
+
+        return LONG2NUM(count);
+}

data/ext/u/rb_u_string_defined.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload defined?
+ *   @return [Boolean] True if the receiver contains only characters not in the
+ *     general categories Other, not assigned (Cn) and Other, surrogate (Cs) */
+VALUE
+rb_u_string_defined(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isdefined);
+}

data/ext/u/rb_u_string_delete.c

@@ -0,0 +1,62 @@
+#include "rb_includes.h"
+#include "rb_u_string_internal_tr.h"
+
+static long
+rb_u_string_delete_loop(const struct rb_u_string *string, struct tr_table *table,
+                        char *result)
+{
+        long count = 0;
+
+        char *base = result;
+        for (const char *p = USTRING_STR(string), *q, *end = USTRING_END(string); p < end; p = q)
+                if (!tr_table_lookup(table, u_decode(&q, p, end))) {
+                        long run = q - p;
+                        if (base != NULL) {
+                                memcpy(base, p, run);
+                                base += run;
+                        }
+                        count += run;
+                }
+
+        return count;
+}
+
+/* @overload delete(set, *sets)
+ *
+ *   Returns the receiver, minus any characters that are included in the
+ *   intersection of SET and any additional SETS of characters, inheriting any
+ *   taint and untrust.
+ *
+ *   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 [U::String, #to_str] set
+ *   @param [Array<U::String, #to_str>] sets
+ *   @return [U::String] */
+VALUE
+rb_u_string_delete(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        need_at_least_n_arguments(argc, 1);
+
+        if (USTRING_LENGTH(string) == 0)
+                return self;
+
+        struct tr_table table;
+        tr_table_initialize_from_strings(&table, argc, argv);
+
+        long count = rb_u_string_delete_loop(string, &table, NULL);
+        if (count == 0)
+                return self;
+
+        char *remaining = ALLOC_N(char, count + 1);
+        rb_u_string_delete_loop(string, &table, remaining);
+        remaining[count] = '\0';
+
+        return rb_u_string_new_c_own(self, remaining, count);
+}