u 0.5.0 → 1.0.0

data/ext/u/rb_u_string_general_category.c

@@ -0,0 +1,109 @@
+#include "rb_includes.h"
+
+#define CATEGORY2ID(type, symbol) \
+        case U_GENERAL_CATEGORY_##type: { \
+                static ID id_##symbol; \
+                if (id_##symbol == 0) \
+                        id_##symbol = rb_intern(#symbol); \
+                return ID2SYM(id_##symbol); \
+        }
+
+static VALUE
+category_to_symbol(enum u_general_category category)
+{
+        switch (category) {
+        CATEGORY2ID(OTHER_CONTROL, other_control)
+        CATEGORY2ID(OTHER_FORMAT, other_format)
+        CATEGORY2ID(OTHER_NOT_ASSIGNED, other_not_assigned)
+        CATEGORY2ID(OTHER_PRIVATE_USE, other_private_use)
+        CATEGORY2ID(OTHER_SURROGATE, other_surrogate)
+        CATEGORY2ID(LETTER_LOWERCASE, letter_lowercase)
+        CATEGORY2ID(LETTER_MODIFIER, letter_modifier)
+        CATEGORY2ID(LETTER_OTHER, letter_other)
+        CATEGORY2ID(LETTER_TITLECASE, letter_titlecase)
+        CATEGORY2ID(LETTER_UPPERCASE, letter_uppercase)
+        CATEGORY2ID(MARK_SPACING_COMBINING, mark_spacing_combining)
+        CATEGORY2ID(MARK_ENCLOSING, mark_enclosing)
+        CATEGORY2ID(MARK_NON_SPACING, mark_non_spacing)
+        CATEGORY2ID(NUMBER_DECIMAL, number_decimal)
+        CATEGORY2ID(NUMBER_LETTER, number_letter)
+        CATEGORY2ID(NUMBER_OTHER, number_other)
+        CATEGORY2ID(PUNCTUATION_CONNECTOR, punctuation_connector)
+        CATEGORY2ID(PUNCTUATION_DASH, punctuation_dash)
+        CATEGORY2ID(PUNCTUATION_CLOSE, punctuation_close)
+        CATEGORY2ID(PUNCTUATION_FINAL_QUOTE, punctuation_final_quote)
+        CATEGORY2ID(PUNCTUATION_INITIAL_QUOTE, punctuation_initial_quote)
+        CATEGORY2ID(PUNCTUATION_OTHER, punctuation_other)
+        CATEGORY2ID(PUNCTUATION_OPEN, punctuation_open)
+        CATEGORY2ID(SYMBOL_CURRENCY, symbol_currency)
+        CATEGORY2ID(SYMBOL_MODIFIER, symbol_modifier)
+        CATEGORY2ID(SYMBOL_MATH, symbol_math)
+        CATEGORY2ID(SYMBOL_OTHER, symbol_other)
+        CATEGORY2ID(SEPARATOR_LINE, separator_line)
+        CATEGORY2ID(SEPARATOR_PARAGRAPH, separator_paragraph)
+        CATEGORY2ID(SEPARATOR_SPACE, separator_space)
+        default:
+                rb_u_raise(rb_eNotImpError, "unknown general category: %d", category);
+        }
+}
+
+/* Returns the general category of the characters of the receiver.
+ *
+ * The general category identifies what kind of symbol the character is.
+ *
+ * <table>
+ *   <thead>
+ *     <tr>
+ *       <th>Category Major, minor</th>
+ *       <th>Unicode Value</th>
+ *       <th>Ruby Value</th>
+ *     </tr>
+ *   </thead>
+ *   <tbody>
+ *     <tr><td>Other, control</td><td>Cc</td><td>:other_control</td></tr>
+ *     <tr><td>Other, format</td><td>Cf</td><td>:other_format</td></tr>
+ *     <tr><td>Other, not assigned</td><td>Cn</td><td>:other_not_assigned</td></tr>
+ *     <tr><td>Other, private use</td><td>Co</td><td>:other_private_use</td></tr>
+ *     <tr><td>Other, surrogate</td><td>Cs</td><td>:other_surrogate</td></tr>
+ *     <tr><td>Letter, lowercase</td><td>Ll</td><td>:letter_lowercase</td></tr>
+ *     <tr><td>Letter, modifier</td><td>Lm</td><td>:letter_modifier</td></tr>
+ *     <tr><td>Letter, other</td><td>Lo</td><td>:letter_other</td></tr>
+ *     <tr><td>Letter, titlecase</td><td>Lt</td><td>:letter_titlecase</td></tr>
+ *     <tr><td>Letter, uppercase</td><td>Lu</td><td>:letter_uppercase</td></tr>
+ *     <tr><td>Mark, spacing combining</td><td>Mc</td><td>:mark_spacing_combining</td></tr>
+ *     <tr><td>Mark, enclosing</td><td>Me</td><td>:mark_enclosing</td></tr>
+ *     <tr><td>Mark, nonspacing</td><td>Mn</td><td>:mark_non_spacing</td></tr>
+ *     <tr><td>Number, decimal digit</td><td>Nd</td><td>:number_decimal</td></tr>
+ *     <tr><td>Number, letter</td><td>Nl</td><td>:number_letter</td></tr>
+ *     <tr><td>Number, other</td><td>No</td><td>:number_other</td></tr>
+ *     <tr><td>Punctuation, connector</td><td>Pc</td><td>:punctuation_connector</td></tr>
+ *     <tr><td>Punctuation, dash</td><td>Pd</td><td>:punctuation_dash</td></tr>
+ *     <tr><td>Punctuation, close</td><td>Pe</td><td>:punctuation_close</td></tr>
+ *     <tr><td>Punctuation, final quote</td><td>Pf</td><td>:punctuation_final_quote</td></tr>
+ *     <tr><td>Punctuation, initial quote</td><td>Pi</td><td>:punctuation_initial_quote</td></tr>
+ *     <tr><td>Punctuation, other</td><td>Po</td><td>:punctuation_other</td></tr>
+ *     <tr><td>Punctuation, open</td><td>Ps</td><td>:punctuation_open</td></tr>
+ *     <tr><td>Symbol, currency</td><td>Sc</td><td>:symbol_currency</td></tr>
+ *     <tr><td>Symbol, modifier</td><td>Sk</td><td>:symbol_modifier</td></tr>
+ *     <tr><td>Symbol, math</td><td>Sm</td><td>:symbol_math</td></tr>
+ *     <tr><td>Symbol, other</td><td>So</td><td>:symbol_other</td></tr>
+ *     <tr><td>Separator, line</td><td>Zl</td><td>:separator_line</td></tr>
+ *     <tr><td>Separator, paragraph</td><td>Zp</td><td>:separator_paragraph</td></tr>
+ *     <tr><td>Separator, space</td><td>Zs</td><td>:separator_space</td></tr>
+ *   </tbody>
+ * </table>
+ *
+ * @raise [ArgumentError] If the receiver contains two characters belonging to
+ *   different general categories
+ * @raise [ArgumentError] If the receiver contains an incomplete UTF-8 sequence
+ * @raise [ArgumentError] If the receiver contains an invalid UTF-8 sequence
+ * @return [Symbol]
+ * @see http://www.unicode.org/notes/tn36/
+ *   Unicode Technical Note #36: A Categorization of Unicode Characters */
+VALUE
+rb_u_string_general_category(VALUE self)
+{
+        return _rb_u_string_property(self, "general category", U_GENERAL_CATEGORY_OTHER_NOT_ASSIGNED,
+                                     (int (*)(uint32_t))u_char_general_category,
+                                     (VALUE (*)(int))category_to_symbol);
+}

data/ext/u/rb_u_string_getbyte.c

@@ -0,0 +1,21 @@
+#include "rb_includes.h"
+
+/* @overload getbyte(index)
+ *   @param [#to_int] index
+ *   @return [Fixnum, nil] The byte at byte-index _i_, where _i_ = INDEX if
+ *     INDEX ≥ 0, _i_ = {#bytesize} - abs(INDEX) otherwise, or nil if _i_ lays
+ *     outside of [0, {#bytesize}] */
+VALUE
+rb_u_string_getbyte(VALUE self, VALUE rbindex)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        long index = NUM2LONG(rbindex);
+
+        if (index < 0)
+                index += USTRING_LENGTH(string);
+
+        if (index < 0 || USTRING_LENGTH(string) <= index)
+                return Qnil;
+
+        return INT2FIX((unsigned char)USTRING_STR(string)[index]);
+}

data/ext/u/rb_u_string_graph.c

@@ -0,0 +1,21 @@
+#include "rb_includes.h"
+
+/* @overload graph?
+ *
+ *   Returns true if the receiver contains only non-space “printable” characters.
+ *
+ *   Non-space “printable” character are those not in the general categories
+ *   Other or Space, separator (Zs):
+ *
+ *   * Other, control (Cc)
+ *   * Other, format (Cf)
+ *   * Other, not assigned (Cn)
+ *   * Other, surrogate (Cs)
+ *   * Space, separator (Zs)
+ *
+ *   @return [Boolean] */
+VALUE
+rb_u_string_graph(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isgraph);
+}

data/ext/u/rb_u_string_grapheme_break.c

@@ -0,0 +1,61 @@
+#include "rb_includes.h"
+
+#define BREAK2ID(value, symbol) \
+        case U_GRAPHEME_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_grapheme_break value)
+{
+        switch (value) {
+        BREAK2ID(CONTROL, control)
+        BREAK2ID(CR, cr)
+        BREAK2ID(EXTEND, extend)
+        BREAK2ID(L, l)
+        BREAK2ID(LF, lf)
+        BREAK2ID(LV, lv)
+        BREAK2ID(LVT, lvt)
+        BREAK2ID(OTHER, other)
+        BREAK2ID(PREPEND, prepend)
+        BREAK2ID(REGIONAL_INDICATOR, regional_indicator)
+        BREAK2ID(SPACINGMARK, spacingmark)
+        BREAK2ID(T, t)
+        BREAK2ID(V, v)
+        default:
+                rb_u_raise(rb_eNotImpError, "unknown grapheme break: %d", value);
+        }
+}
+
+/* Returns the grapheme break property value of the characters of the receiver.
+ *
+ * The possible break values are
+ *
+ * * :control
+ * * :cr
+ * * :extend
+ * * :l
+ * * :lf
+ * * :lv
+ * * :lvt
+ * * :other
+ * * :prepend
+ * * :regional_indicator
+ * * :spacingmark
+ * * :t
+ * * :v
+ *
+ * @raise [ArgumentError] If the string consists of more than one break type
+ * @return [Symbol]
+ * @see http://www.unicode.org/reports/tr29/
+ *   Unicode Standard Annex #29: Unicode Text Segmentation */
+VALUE
+rb_u_string_grapheme_break(VALUE self)
+{
+        return _rb_u_string_property(self, "grapheme break", U_GRAPHEME_BREAK_OTHER,
+                                     (int (*)(uint32_t))u_char_grapheme_break,
+                                     (VALUE (*)(int))break_to_symbol);
+}

data/ext/u/rb_u_string_gsub.c

@@ -0,0 +1,164 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+/* @overload gsub(pattern, replacement)
+ *
+ *   Returns the receiver with all matches of PATTERN replaced by REPLACEMENT,
+ *   inheriting any taint and untrust from the receiver and from REPLACEMENT.
+ *
+ *   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]
+ *
+ * @overload gsub(pattern, replacements)
+ *
+ *   Returns the receiver with all matches of PATTERN replaced by
+ *   REPLACEMENTS#[_match_], where _match_ is the matched substring, inheriting
+ *   any taint and untrust from the receiver and from the
+ *   REPLACEMENTS#[_match_]es, as well as any taint on REPLACEMENTS.
+ *
+ *   The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …,
+ *   `$`_n_ are updated accordingly.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_hash] replacements
+ *   @raise [RuntimeError] If any replacement is the result being constructed
+ *   @raise [Exception] Any error raised by REPLACEMENTS#default, if it gets
+ *     called
+ *   @return [U::String]
+ *
+ * @overload gsub(pattern){ |match| … }
+ *
+ *   Returns the receiver with all matches 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.
+ *
+ *   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]
+ *
+ * @overload gsub(pattern)
+ *
+ *   Returns an Enumerator over the matches of PATTERN in the receiver.
+ *
+ *   The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …,
+ *   `$`_n_ will be updated accordingly.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @return [Enumerator] */
+VALUE
+rb_u_string_gsub(int argc, VALUE *argv, VALUE self)
+{
+        VALUE pattern, replacement;
+        VALUE replacements = Qnil;
+        bool use_block = false;
+        bool tainted = false;
+
+        if (argc == 1) {
+                RETURN_ENUMERATOR(self, argc, argv);
+                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;
+        }
+
+        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 self;
+
+        const char *base = RSTRING_PTR(str);
+        const char *p = base;
+        const char *end = RSTRING_END(str);
+        VALUE substituted = rb_u_str_buf_new(RSTRING_LEN(str) + 30);
+        do {
+                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,
+                                                               base + registers->beg[0],
+                                                               registers->end[0] - registers->beg[0]);
+                                result = rb_u_string_object_as_string(rb_hash_aref(replacements, ustr));
+                        }
+
+                        if (result == substituted)
+                                rb_u_raise(rb_eRuntimeError,
+                                           "result of block is string being built; please try not to cheat");
+                } 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;
+
+                const struct rb_u_string *value = RVAL2USTRING_ANY(result);
+
+                rb_str_buf_cat(substituted, p, registers->beg[0] - (p - base));
+                rb_str_buf_cat(substituted, USTRING_STR(value), USTRING_LENGTH(value));
+                OBJ_INFECT(substituted, result);
+
+                p = base + registers->end[0];
+                if (registers->beg[0] == registers->end[0])
+                        p = u_next(p);
+                if (p >= end)
+                        break;
+
+                begin = rb_reg_search(pattern, str, registers->end[0], 0);
+        } while (begin >= 0);
+
+        if (p < end)
+                rb_str_buf_cat(substituted, p, end - p);
+
+        rb_reg_search(pattern, str, end - p, 0);
+
+        RBASIC(substituted)->klass = rb_obj_class(str);
+        OBJ_INFECT(substituted, str);
+        if (tainted)
+                OBJ_TAINT(substituted);
+
+        return rb_u_string_new_rb(substituted);
+}

data/ext/u/rb_u_string_hash.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @return [Fixnum] The hash value of the receiver’s content */
+VALUE
+rb_u_string_hash(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        return INT2FIX(rb_memhash(USTRING_STR(string), USTRING_LENGTH(string)));
+}

data/ext/u/rb_u_string_hex.c

@@ -0,0 +1,9 @@
+#include "rb_includes.h"
+#include "rb_u_string_to_inum.h"
+
+/* @return [Integer] The result of {#to_i}(16) */
+VALUE
+rb_u_string_hex(VALUE self)
+{
+        return rb_u_string_to_inum(self, 16, false);
+}

data/ext/u/rb_u_string_include.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload include?(substring)
+ *   @param [#to_str] substring
+ *   @return [Boolean] True if {#index}(SUBSTRING) ≠ nil */
+VALUE
+rb_u_string_include(VALUE self, VALUE substring)
+{
+        return rb_u_string_index(self, substring, 0) != -1 ? Qtrue : Qfalse;
+}

data/ext/u/rb_u_string_index.c

@@ -0,0 +1,110 @@
+#include "rb_includes.h"
+#include "rb_u_re.h"
+
+/* TODO: Return VALUE. */
+long
+rb_u_string_index_regexp(VALUE self, const char *begin, VALUE regex, bool reverse)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        VALUE rbstring = rb_str_to_str(self);
+
+        const char *base = USTRING_STR(string);
+
+        long index = rb_reg_search(regex, rbstring,
+                                   rb_reg_adjust_startpos(regex, rbstring,
+                                                          begin - base,
+                                                          reverse),
+                                   reverse);
+        if (index == -1)
+                return -1;
+
+        return u_pointer_to_offset(base, base + index);
+}
+
+/* TODO: Return VALUE. */
+long
+rb_u_string_index(VALUE self, VALUE rbsubstring, long offset)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *substring = RVAL2USTRING_ANY(rbsubstring);
+
+        const char *begin = rb_u_string_begin_from_offset(string, offset);
+        if (begin == NULL)
+                return -1;
+
+        const char *end = USTRING_END(string);
+
+        long substring_length = USTRING_LENGTH(substring);
+        if (end - begin < substring_length)
+                return -1;
+        if (substring_length == 0)
+                return offset;
+
+        /* TODO: Should we really be using rb_memsearch?  Why not something
+         * more Unicodey? */
+        long index = rb_u_memsearch(USTRING_STR(substring), substring_length,
+                                    begin,
+                                    end - begin);
+        if (index < 0)
+                return -1;
+
+        return offset + u_pointer_to_offset(begin, begin + index);
+}
+
+/* @overload index(pattern, offset = 0)
+ *
+ *   Returns the minimal index of the receiver where PATTERN matches, equal to or
+ *   greater than _i_, where _i_ = OFFSET if OFFSET ≥ 0, _i_ = {#length} -
+ *   abs(OFFSET) otherwise, or nil if there is no match.
+ *
+ *   If PATTERN is a Regexp, the Regexp special variables `$&`, `$'`,
+ *   <code>$\`</code>, `$1`, `$2`, …, `$`_n_ are updated accordingly.
+ *
+ *   If PATTERN responds to #to_str, the matching is performed by byte
+ *   comparison.
+ *
+ *   @param [Regexp, #to_str] pattern
+ *   @param [#to_int] offset
+ *   @return [Integer, nil]
+ *   @see #rindex */
+VALUE
+rb_u_string_index_m(int argc, VALUE *argv, VALUE self)
+{
+        VALUE sub, rboffset;
+        long offset = 0;
+        if (rb_scan_args(argc, argv, "11", &sub, &rboffset) == 2)
+                offset = NUM2LONG(rboffset);
+
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        const char *begin = rb_u_string_begin_from_offset(string, offset);
+        if (begin == NULL) {
+                if (TYPE(sub) == T_REGEXP)
+                        rb_backref_set(Qnil);
+
+                return Qnil;
+        }
+
+        switch (TYPE(sub)) {
+        case T_REGEXP:
+                offset = rb_u_string_index_regexp(self, begin, sub, false);
+                break;
+        default: {
+                VALUE tmp = rb_check_string_type(sub);
+                if (NIL_P(tmp))
+                        rb_u_raise(rb_eTypeError, "type mismatch: %s given",
+                                   rb_obj_classname(sub));
+
+                sub = tmp;
+        }
+                /* fall through */
+        case T_STRING:
+                offset = rb_u_string_index(self, sub, offset);
+                break;
+        }
+
+        if (offset < 0)
+                return Qnil;
+
+        return LONG2NUM(offset);
+}