u 0.5.0 → 1.0.0

data/ext/u/rb_u_string_length.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @return [Integer] The number of characters in the receiver */
+VALUE
+rb_u_string_length(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        return UINT2NUM(u_n_chars_n(USTRING_STR(string), USTRING_LENGTH(string)));
+}

data/ext/u/rb_u_string_line_break.c

@@ -0,0 +1,115 @@
+#include "rb_includes.h"
+
+#define BREAK2ID(value, symbol) \
+        case U_LINE_BREAK_##value: { \
+                static ID id_##symbol; \
+                if (id_##symbol == 0) \
+                        id_##symbol = rb_intern(#symbol); \
+                return ID2SYM(id_##symbol); \
+        }
+
+static VALUE
+break_to_symbol(enum u_line_break value)
+{
+        switch (value) {
+        BREAK2ID(MANDATORY, mandatory)
+        BREAK2ID(CARRIAGE_RETURN, carriage_return)
+        BREAK2ID(LINE_FEED, line_feed)
+        BREAK2ID(COMBINING_MARK, combining_mark)
+        BREAK2ID(NEXT_LINE, next_line)
+        BREAK2ID(SURROGATE, surrogate)
+        BREAK2ID(WORD_JOINER, word_joiner)
+        BREAK2ID(ZERO_WIDTH_SPACE, zero_width_space)
+        BREAK2ID(NON_BREAKING_GLUE, non_breaking_glue)
+        BREAK2ID(SPACE, space)
+        BREAK2ID(BREAK_OPPORTUNITY_BEFORE_AND_AFTER, break_opportunity_before_and_after)
+        BREAK2ID(BREAK_AFTER, break_after)
+        BREAK2ID(BREAK_BEFORE, break_before)
+        BREAK2ID(HYPHEN, hyphen)
+        BREAK2ID(CONTINGENT_BREAK_OPPORTUNITY, contingent_break_opportunity)
+        BREAK2ID(CLOSE_PUNCTUATION, close_punctuation)
+        BREAK2ID(CLOSE_PARENTHESIS, close_parenthesis)
+        BREAK2ID(EXCLAMATION_INTERROGATION, exclamation_interrogation)
+        BREAK2ID(INSEPARABLE, inseparable)
+        BREAK2ID(NONSTARTER, nonstarter)
+        BREAK2ID(OPEN_PUNCTUATION, open_punctuation)
+        BREAK2ID(QUOTATION, quotation)
+        BREAK2ID(INFIX_NUMERIC_SEPARATOR, infix_numeric_separator)
+        BREAK2ID(NUMERIC, numeric)
+        BREAK2ID(POSTFIX_NUMERIC, postfix_numeric)
+        BREAK2ID(PREFIX_NUMERIC, prefix_numeric)
+        BREAK2ID(SYMBOLS_ALLOWING_BREAK_AFTER, symbols_allowing_break_after)
+        BREAK2ID(AMBIGUOUS, ambiguous)
+        BREAK2ID(ALPHABETIC, alphabetic)
+        BREAK2ID(CONDITIONAL_JAPANESE_STARTER, conditional_japanese_starter)
+        BREAK2ID(HANGUL_LV_SYLLABLE, hangul_lv_syllable)
+        BREAK2ID(HANGUL_LVT_SYLLABLE, hangul_lvt_syllable)
+        BREAK2ID(HEBREW_LETTER, hebrew_letter)
+        BREAK2ID(IDEOGRAPHIC, ideographic)
+        BREAK2ID(HANGUL_L_JAMO, hangul_l_jamo)
+        BREAK2ID(HANGUL_V_JAMO, hangul_v_jamo)
+        BREAK2ID(HANGUL_T_JAMO, hangul_t_jamo)
+        BREAK2ID(REGIONAL_INDICATOR, regional_indicator)
+        BREAK2ID(COMPLEX_CONTEXT_DEPENDENT, complex_context_dependent)
+        BREAK2ID(UNKNOWN, unknown)
+        default:
+                rb_u_raise(rb_eNotImpError, "unknown line break: %d", value);
+        }
+}
+
+/* Returns the line break property value of the characters of the receiver.
+ *
+ * The possible break values are
+ *
+ * * :after
+ * * :alphabetic
+ * * :ambiguous
+ * * :before
+ * * :before_and_after
+ * * :carriage_return
+ * * :close_parenthesis
+ * * :close_punctuation
+ * * :combining_mark
+ * * :complex_context
+ * * :conditional_japanese_starter
+ * * :contingent
+ * * :exclamation
+ * * :hangul_l_jamo
+ * * :hangul_lv_syllable
+ * * :hangul_lvt_syllable
+ * * :hangul_t_jamo
+ * * :hangul_v_jamo
+ * * :hebrew_letter
+ * * :hyphen
+ * * :ideographic
+ * * :infix_separator
+ * * :inseparable
+ * * :line_feed
+ * * :mandatory
+ * * :next_line
+ * * :non_breaking_glue
+ * * :non_starter
+ * * :numeric
+ * * :open_punctuation
+ * * :postfix
+ * * :prefix
+ * * :quotation
+ * * :regional_indicator
+ * * :space
+ * * :surrogate
+ * * :symbol
+ * * :unknown
+ * * :word_joiner
+ * * :zero_width_space
+ *
+ * @raise [ArgumentError] If the string consists of more than one break type
+ * @return [Symbol]
+ * @see http://unicode.org/reports/tr14/
+ *   Unicode Standard Annex #14: Unicode Line Breaking Algorithm */
+VALUE
+rb_u_string_line_break(VALUE self)
+{
+        return _rb_u_string_property(self, "line break", U_LINE_BREAK_UNKNOWN,
+                                     (int (*)(uint32_t))u_char_line_break,
+                                     (VALUE (*)(int))break_to_symbol);
+}

data/ext/u/rb_u_string_lower.c

@@ -0,0 +1,13 @@
+#include "rb_includes.h"
+
+/* @overload lower?(locale = ENV[LC_CTYPE])
+ *   @param [#to_str] locale
+ *   @return [Boolean] True if the receiver has been downcased according to the
+ *     rules of the language of LOCALE, which may be empty to specifically use
+ *     the default, language-independent, rules, that is, if _a_ =
+ *     _a_{#downcase}(LOCALE), where _a_ = {#normalize}(`:nfd`) */
+VALUE
+rb_u_string_lower(int argc, VALUE *argv, VALUE self)
+{
+        return _rb_u_string_test_locale(argc, argv, self, u_downcase);
+}

data/ext/u/rb_u_string_lstrip.c

@@ -0,0 +1,24 @@
+#include "rb_includes.h"
+
+/* @return [U::String] The receiver with its maximum {#space?} prefix removed,
+ *   inheriting any taint and untrust
+ * @see #rstrip
+ * @see #strip */
+VALUE
+rb_u_string_lstrip(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        const char *begin = USTRING_STR(string);
+        if (begin == NULL)
+                return self;
+
+        const char *p = begin, *end = USTRING_END(string);
+        for (const char *q; p < end; p = q)
+                if (!u_char_isspace(u_decode(&q, p, end)))
+                        break;
+        if (p == begin)
+                return self;
+
+        return rb_u_string_new_c(self, p, end - p);
+}

data/ext/u/rb_u_string_match.c

@@ -0,0 +1,65 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+/* @overload =~(other)
+ *   @param [Regexp, #=~] other
+ *   @raise [TypeError] If OTHER is a {U::String} or String
+ *   @return [Numeric, nil] The result of OTHER`#=~`(self), that is, the index
+ *     of the first character of the match of OTHER in the receiver, if one
+ *     exists */
+VALUE
+rb_u_string_match(VALUE self, VALUE other)
+{
+        if (RTEST(rb_obj_is_kind_of(other, rb_cUString)))
+                rb_u_raise(rb_eTypeError, "type mismatch: U::String given");
+
+        switch (TYPE(other)) {
+        case T_STRING:
+                rb_u_raise(rb_eTypeError, "type mismatch: String given");
+                break;
+        case T_REGEXP: {
+                const struct rb_u_string *string = RVAL2USTRING(self);
+
+                long index = rb_reg_search(other, rb_str_to_str(self), 0, 0);
+                if (index < 0)
+                        return Qnil;
+
+                return LONG2NUM(u_pointer_to_offset(USTRING_STR(string),
+                                                    USTRING_STR(string) + index));
+        }
+        default:
+                return rb_funcall(other, rb_intern("=~"), 1, self);
+        }
+}
+
+/* @overload match(pattern, index = 0)
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_int] index
+ *   @return [MatchData, nil] The result of _r_#match(self, index), that is,
+ *     the match data of the first match of _r_ in the receiver, inheriting any
+ *     taint and untrust from both the receiver and from PATTERN, if one
+ *     exists, where _r_ = PATTERN, if PATTERN is a Regexp, _r_ =
+ *     Regexp.new(PATTERN) otherwise
+ * @overload match(pattern, index = 0){ |matchdata| … }
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_int] index
+ *   @yieldparam [MatchData] matchdata
+ *   @return [Object, nil] The result of calling the given block with the
+ *     result of _r_#match(self, index), that is, the match data of the first
+ *     match of _r_ in the receiver, inheriting any taint and untrust from both
+ *     the recevier and from PATTERN, if one exists, where _r_ = PATTERN, if
+ *     PATTERN is a Regexp, _r_ = Regexp.new(PATTERN) otherwise */
+VALUE
+rb_u_string_match_m(int argc, VALUE *argv, VALUE self)
+{
+        VALUE re;
+        if (argc < 0)
+                need_m_to_n_arguments(argc, 1, 2);
+        re = argv[0];
+        argv[0] = self;
+        VALUE result = rb_funcall2(rb_u_pattern_argument(re, false),
+                                   rb_intern("match"), argc, argv);
+        if (!NIL_P(result) && rb_block_given_p())
+                return rb_yield(result);
+        return result;
+}

data/ext/u/rb_u_string_mirror.c

@@ -0,0 +1,16 @@
+#include "rb_includes.h"
+
+/* Returns the mirroring of the receiver, inheriting any taint and untrust.
+ *
+ * Mirroring is done by replacing characters in the string with their
+ * horizontal mirror image, if any, in text that is laid out from right to
+ * left.  For example, ‘(’ becomes ‘)’ and ‘)’ becomes ‘(’.
+ *
+ * @return [U::String]
+ * @see http://www.unicode.org/reports/tr9/
+ *   Unicode Standard Annex #9: Unicode Bidirectional Algorithm */
+VALUE
+rb_u_string_mirror(VALUE self)
+{
+        return _rb_u_string_convert(self, u_mirror);
+}

data/ext/u/rb_u_string_newline.c

@@ -0,0 +1,21 @@
+#include "rb_includes.h"
+
+/* @overload newline?
+ *
+ *   Returns true if the receiver contains only “newline” characters.  A
+ *   character is a “newline” character if it is any of the following
+ *   characters:
+ *
+ *   * U+000A (LINE FEED (LF))
+ *   * U+000C (FORM FEED (FF))
+ *   * U+000D (CARRIAGE RETURN (CR))
+ *   * U+0085 (NEXT LINE)
+ *   * U+2028 (LINE SEPARATOR)
+ *   * U+2029 (PARAGRAPH SEPARATOR)
+ *
+ *   @return [Boolean] */
+VALUE
+rb_u_string_newline(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isnewline);
+}

data/ext/u/rb_u_string_normalize.c

@@ -0,0 +1,70 @@
+#include "rb_includes.h"
+
+/* @overload normalize(form = :nfd)
+ *
+ *   Returns the receiver normalized into FORM, inheriting any taint and
+ *   untrust.
+ *
+ *   Normalization is the process of converting characters and sequences of
+ *   characters in string into a canonical form.  This process includes dealing
+ *   with whether characters are represented by a composed character or a base
+ *   character and combining marks, such as accents.
+ *
+ *   The possible normalization forms are
+ *
+ *   <table>
+ *     <thead>
+ *       <tr><th>Form</th><th>Description</th></tr>
+ *     </thead>
+ *     <tbody>
+ *       <tr>
+ *         <td><code>:nfd</code></td>
+ *         <td>Normalizes characters to their maximally decomposed form,
+ *         ordering accents and so on according to their combining class</td>
+ *       </tr>
+ *       <tr>
+ *         <td><code>:nfc</code></td>
+ *         <td>Normalizes according to <code>:nfd</code>, then composes any
+ *         decomposed characters</td>
+ *       </tr>
+ *       <tr>
+ *         <td><code>:nfkd</code></td>
+ *         <td>Normalizes according to <code>:nfd</code> and also normalizes
+ *         “compatibility” characters, such as replacing U+00B3 SUPERSCRIPT
+ *         THREE with U+0033 DIGIT THREE</td>
+ *       </tr>
+ *       <tr>
+ *         <td><code>:nfkc</code></td>
+ *         <td>Normalizes according to <code>:nfkd</code>, then composes any
+ *         decomposed characters</td>
+ *       </tr>
+ *     </tbody>
+ *   </table>
+ *
+ *   @param [#to_sym] form
+ *   @return [U::String]
+ *   @see http://unicode.org/reports/tr15/
+ *     Unicode Standard Annex #15: Unicode Normalization Forms */
+VALUE
+rb_u_string_normalize(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        VALUE rbform;
+        enum u_normalization_form form = U_NORMALIZATION_FORM_D;
+        if (rb_scan_args(argc, argv, "01", &rbform) == 1)
+                form = _rb_u_symbol_to_normalization_form(rbform);
+
+        size_t n = u_normalize(NULL, 0,
+                               USTRING_STR(string), USTRING_LENGTH(string),
+                               form);
+        char *normalized = ALLOC_N(char, n + 1);
+        n = u_normalize(normalized, n + 1,
+                        USTRING_STR(string), USTRING_LENGTH(string),
+                        form);
+        char *t = REALLOC_N(normalized, char, n + 1);
+        if (t != NULL)
+                normalized = t;
+
+        return rb_u_string_new_c_own(self, normalized, n);
+}

data/ext/u/rb_u_string_normalized.c

@@ -0,0 +1,28 @@
+#include "rb_includes.h"
+
+/* @overload normalize?(mode = :default)
+ *
+ *   Returns true if it can be determined that the receiver is normalized
+ *   according to MODE.
+ *
+ *   See {#normalize} for a discussion on normalization and a list of the
+ *   possible normalization modes.
+ *
+ *   @param [#to_sym] mode
+ *   @return [Boolean]
+ *   @see http://unicode.org/reports/tr15/
+ *     Unicode Standard Annex #15: Unicode Normalization Forms */
+VALUE
+rb_u_string_normalized(int argc, VALUE *argv, VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        VALUE rbform;
+        enum u_normalization_form form = U_NORMALIZATION_FORM_D;
+        if (rb_scan_args(argc, argv, "01", &rbform) == 1)
+                form = _rb_u_symbol_to_normalization_form(rbform);
+
+        return u_normalized(USTRING_STR(string),
+                            USTRING_LENGTH(string),
+                            form) == U_NORMALIZED_YES ? Qtrue : Qfalse;
+}

data/ext/u/rb_u_string_oct.c

@@ -0,0 +1,11 @@
+#include "rb_includes.h"
+#include "rb_u_string_to_inum.h"
+
+/* @return [Integer] The result of {#to_i}(8), but with the added provision
+ *   that any leading base specification in the receiver will override the
+ *   suggested octal (8) base, that is, `'0b11'.u`{#oct} = 3, not 9. */
+VALUE
+rb_u_string_oct(VALUE self)
+{
+        return rb_u_string_to_inum(self, -8, false);
+}

data/ext/u/rb_u_string_ord.c

@@ -0,0 +1,14 @@
+#include "rb_includes.h"
+
+/* @return [Integer] The code point of the first character of the receiver */
+VALUE
+rb_u_string_ord(VALUE self)
+{
+        const struct rb_u_string *s = RVAL2USTRING(self);
+        const char *p = USTRING_STR(s);
+        const char *end = USTRING_END(s);
+        if (p == end)
+                rb_u_raise(rb_eArgError, "empty string");
+        const char *q;
+        return UINT2NUM(u_decode(&q, p, end));
+}

data/ext/u/rb_u_string_partition.c

@@ -0,0 +1,80 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+static VALUE
+rb_u_string_partition_failure(VALUE self)
+{
+        return rb_ary_new3(3,
+                           self,
+                           rb_u_string_new_empty(self),
+                           rb_u_string_new_empty(self));
+}
+
+static VALUE
+rb_u_string_partition_success(VALUE self, VALUE rbseparator, long offset)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *separator = RVAL2USTRING_ANY(rbseparator);
+
+        long after = offset + USTRING_LENGTH(separator);
+
+        return rb_ary_new3(3,
+                           rb_u_string_new_subsequence(self, 0, offset),
+                           TYPE(rbseparator) == T_STRING ?
+                                rb_u_string_new_rb(rbseparator) :
+                                rbseparator,
+                           rb_u_string_new_subsequence(self,
+                                                       after,
+                                                       USTRING_LENGTH(string) - after));
+}
+
+static VALUE
+rb_u_string_partition_regex(VALUE self, VALUE regex)
+{
+        VALUE str = rb_str_to_str(self);
+
+        long offset = rb_reg_search(regex, str, 0, 0);
+        if (offset < 0)
+                return rb_u_string_partition_failure(self);
+
+        VALUE separator = rb_u_pattern_match_reference(INT2FIX(0));
+
+        if (offset == 0 && RSTRING_LEN(separator) == 0)
+                return rb_u_string_partition_failure(self);
+
+        return rb_u_string_partition_success(self, separator, offset);
+}
+
+static VALUE
+rb_u_string_partition_string(VALUE self, VALUE rbseparator)
+{
+        VALUE validated = rb_u_string_validate_type(rbseparator);
+
+        long offset = rb_u_string_index(self, validated, 0);
+        if (offset < 0)
+                return rb_u_string_partition_failure(self);
+
+        const char *begin = USTRING_STR(RVAL2USTRING(self));
+        long byte_offset = u_offset_to_pointer(begin, offset) - begin;
+
+        return rb_u_string_partition_success(self, validated, byte_offset);
+}
+
+/* @overload partition(separator)
+ *   @param [Regexp, #to_str] separator
+ *   @return [Array<U::String>] The receiver split into _s₁_ = {#slice}(0,
+ *     _i_), _s₂_ = {#slice}(_i_, _n_), _s₃_ = {#slice}(_i_+_n_, -1), where _i_
+ *     = _j_ if _j_ ≠ nil, _i_ = {#length} otherwise, _j_ =
+ *     {#index}(SEPARATOR), _n_ = SEPARATOR{#length}, where _s₁_ and _s₃_
+ *     inherit any taint and untrust from the receiver and _s₂_ inherits any
+ *     taint and untrust from SEPARATOR and also from the receiver if SEPARATOR
+ *     is a Regexp
+ *   @see #rpartition */
+VALUE
+rb_u_string_partition(VALUE self, VALUE separator)
+{
+        if (TYPE(separator) == T_REGEXP)
+                return rb_u_string_partition_regex(self, separator);
+
+        return rb_u_string_partition_string(self, separator);
+}