u 0.5.0 → 1.0.0

data/ext/u/rb_u_string_digit.c

@@ -0,0 +1,10 @@
+#include "rb_includes.h"
+
+/* @overload digit?
+ *   @return [Boolean] True if the receiver contains only characters in the
+ *     general category Number, decimal digit (Nd) */
+VALUE
+rb_u_string_digit(VALUE self)
+{
+        return _rb_u_character_test(self, u_char_isdigit);
+}

data/ext/u/rb_u_string_downcase.c

@@ -0,0 +1,13 @@
+#include "rb_includes.h"
+
+/* @overload downcase(locale = ENV['LC_CTYPE'])
+ *   @param [#to_str] locale
+ *   @return [U::String] The downcasing of the receiver according to the rules
+ *     of the language of LOCALE, which may be empty to specifically use the
+ *     default, language-independent, rules, inheriting any taint and
+ *     untrust */
+VALUE
+rb_u_string_downcase(int argc, VALUE *argv, VALUE self)
+{
+        return _rb_u_string_convert_locale(argc, argv, self, u_downcase, NULL);
+}

data/ext/u/rb_u_string_dump.c

@@ -0,0 +1,153 @@
+#include <ctype.h>
+
+#include "rb_includes.h"
+#include "rb_u_buffer.h"
+
+static inline bool
+rb_u_string_dump_escape(VALUE buffer, unsigned char c)
+{
+        const char *escape = NULL;
+
+        switch (c) {
+        case '"':       escape = "\\\""; break;
+        case '\\':      escape = "\\\\"; break;
+        case '\n':      escape = "\\n";  break;
+        case '\r':      escape = "\\r";  break;
+        case '\t':      escape = "\\t";  break;
+        case '\f':      escape = "\\f";  break;
+        case '\013':    escape = "\\v";  break;
+        case '\010':    escape = "\\b";  break;
+        case '\007':    escape = "\\a";  break;
+        case '\033':    escape = "\\e";  break;
+        default:
+                        return false;
+        }
+
+        rb_u_buffer_append(buffer, escape, 2);
+
+        return true;
+}
+
+#define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{'))
+
+static inline bool
+rb_u_string_dump_hash(VALUE buffer, unsigned char c, const char *p, const char *end)
+{
+        if (c != '#' || !IS_EVSTR(p + 1, end))
+                return false;
+
+        rb_u_buffer_append(buffer, "\\#", 2);
+
+        return true;
+}
+
+static inline bool
+rb_u_string_dump_ascii_printable(VALUE buffer, unsigned char c)
+{
+        if (c > 0x7f || !u_char_isprint(c))
+                return false;
+
+        rb_u_buffer_append_char(buffer, c);
+
+        return true;
+}
+
+#define REPLACEMENT_CHARACTER ((uint32_t)0xfffd)
+
+static inline void
+rb_u_string_dump_hex(VALUE buffer, unsigned char c)
+{
+        char escaped[4 + 1];
+        int length = snprintf(escaped, sizeof(escaped), "\\x%02X", c);
+        rb_u_buffer_append(buffer, escaped, length);
+}
+
+static inline bool
+rb_u_string_dump_codepoint(VALUE buffer, const char **p, const char *end)
+{
+        const char *q;
+        uint32_t c = u_decode(&q, *p, end);
+        if (c == REPLACEMENT_CHARACTER && !u_valid(*p, q - *p, NULL)) {
+                for (const char *r = *p; r < q; r++)
+                        rb_u_string_dump_hex(buffer, (unsigned char)*r);
+                /* -1, since we increase p inside the loop. */
+                *p = q - 1;
+                return true;
+        }
+        /* -1, since we increase p inside the loop. */
+        *p = q - 1;
+        char escaped[3 + sizeof(c) * CHAR_BIT + 2 + 1];
+        int length = snprintf(escaped, sizeof(escaped), "\\u{%x}", c);
+        rb_u_buffer_append(buffer, escaped, length);
+        return true;
+}
+
+/* Returns the receiver in a reader-friendly format, inheriting any taint and
+ * untrust.
+ *
+ * The reader-friendly format looks like “`"…".u`”.  Inside the “…”, any
+ * {#print?} characters in the ASCII range are output as-is, the following
+ * special characters are escaped according to the following table:
+ *
+ * <table>
+ *   <thead><tr><th>Character</th><th>Dumped Sequence</th></tr></thead>
+ *   <tbody>
+ *     <tr><td>U+0022 QUOTATION MARK</td><td><code>\"</code></td></tr>
+ *     <tr><td>U+005C REVERSE SOLIDUS</td><td><code>\\</code></td></tr>
+ *     <tr><td>U+000A LINE FEED (LF)</td><td><code>\n</code></td></tr>
+ *     <tr><td>U+000D CARRIAGE RETURN (CR)</td><td><code>\r</code></td></tr>
+ *     <tr><td>U+0009 CHARACTER TABULATION</td><td><code>\t</code></td></tr>
+ *     <tr><td>U+000C FORM FEED (FF)</td><td><code>\f</code></td></tr>
+ *     <tr><td>U+000B LINE TABULATION</td><td><code>\v</code></td></tr>
+ *     <tr><td>U+0008 BACKSPACE</td><td><code>\b</code></td></tr>
+ *     <tr><td>U+0007 BELL</td><td><code>\a</code></td></tr>
+ *     <tr><td>U+001B ESCAPE</td><td><code>\e</code></td></tr>
+ *   </tbody>
+ * </table>
+ *
+ * the following special sequences are also escaped:
+ *
+ * <table>
+ *   <thead><tr><th>Character</th><th>Dumped Sequence</th></tr></thead>
+ *   <tbody>
+ *     <tr><td><code>#$</code></td><td><code>\#$</code></td></tr>
+ *     <tr><td><code>#@</code></td><td><code>\#@</code></td></tr>
+ *     <tr><td><code>#{</code></td><td><code>\#{</code></td></tr>
+ *   </tbody>
+ * </table>
+ *
+ * any valid UTF-8 byte sequences are output as “`\u{`_n_`}`”, where _n_ is the
+ * lowercase hexadecimal representation of the code point encoded by the UTF-8
+ * sequence, and any other byte is output as “`\x`_n_”, where _n_ is the
+ * two-digit uppercase hexadecimal representation of the byte’s value.
+ *
+ * @return [U::String] */
+VALUE
+rb_u_string_dump(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *p = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+
+        VALUE buffer = rb_u_buffer_new_sized(7);
+
+        rb_u_buffer_append(buffer, "\"", 1);
+        while (p < end) {
+                unsigned char c = *p;
+
+                if (!rb_u_string_dump_escape(buffer, c) &&
+                    !rb_u_string_dump_hash(buffer, c, p, end) &&
+                    !rb_u_string_dump_ascii_printable(buffer, c) &&
+                    !rb_u_string_dump_codepoint(buffer, &p, end))
+                        rb_u_string_dump_hex(buffer, c);
+
+                p++;
+        }
+        rb_u_buffer_append(buffer, "\".u", 3);
+
+        VALUE result = rb_u_buffer_to_u_bang(buffer);
+
+        OBJ_INFECT(result, self);
+
+        return result;
+}

data/ext/u/rb_u_string_each_byte.c

@@ -0,0 +1,46 @@
+#include "rb_includes.h"
+#include "yield.h"
+
+static void
+each(VALUE self, struct yield *yield)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *end = USTRING_END(string);
+        for (const char *p = USTRING_STR(string); p < end; p++)
+                yield_call(yield, INT2FIX(*p & 0xff));
+}
+
+UNUSED(static VALUE
+       size(VALUE self, UNUSED(VALUE args)))
+{
+        return LONG2NUM(USTRING_LENGTH(RVAL2USTRING(self)));
+}
+
+/* @overload each_byte{ |byte| … }
+ *
+ *   Enumerates the bytes in the receiver.
+ *
+ *   @yieldparam [Fixnum] byte
+ *   @return [self]
+ *
+ * @overload each_byte
+ *
+ *   @return [Enumerator] An Enumerator over the bytes in the receiver
+ */
+VALUE
+rb_u_string_each_byte(VALUE self)
+{
+        RETURN_SIZED_ENUMERATOR(self, 0, NULL, size);
+        struct yield y = YIELD_INIT;
+        each(self, &y);
+        return self;
+}
+
+/* @return [Array<Fixnum>] The bytes of the receiver. */
+VALUE
+rb_u_string_bytes(VALUE self)
+{
+        struct yield_array y = YIELD_ARRAY_INIT;
+        each(self, &y.yield);
+        return y.array;
+}

data/ext/u/rb_u_string_each_char.c

@@ -0,0 +1,49 @@
+#include "rb_includes.h"
+#include "yield.h"
+
+static void
+each(VALUE self, struct yield *yield)
+{
+        const struct rb_u_string *s = RVAL2USTRING(self);
+        for (const char *p = USTRING_STR(s), *q, *end = USTRING_END(s); p < end; p = q) {
+                u_decode(&q, p, end);
+                yield_call(yield, rb_u_string_new_c(self, p, q - p));
+        }
+}
+
+UNUSED(static VALUE
+       size(VALUE self, UNUSED(VALUE args)))
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        return UINT2NUM(u_n_chars_n(USTRING_STR(string), USTRING_LENGTH(string)));
+}
+
+/* @overload each_char{ |char| … }
+ *
+ *   Enumerates the characters in the receiver, each inheriting any taint and
+ *   untrust.
+ *
+ *   @yieldparam [U::String] char
+ *   @return [self]
+ *
+ * @overload each_char
+ *
+ *   @return [Enumerator] An Enumerator over the characters in the receiver */
+VALUE
+rb_u_string_each_char(VALUE self)
+{
+        RETURN_SIZED_ENUMERATOR(self, 0, NULL, size);
+        struct yield y = YIELD_INIT;
+        each(self, &y);
+        return self;
+}
+
+/* @return [Array<U::String>] The characters of the receiver, each inheriting
+ *   any taint and untrust. */
+VALUE
+rb_u_string_chars(VALUE self)
+{
+        struct yield_array y = YIELD_ARRAY_INIT;
+        each(self, &y.yield);
+        return y.array;
+}

data/ext/u/rb_u_string_each_codepoint.c

@@ -0,0 +1,45 @@
+#include "rb_includes.h"
+#include "yield.h"
+
+static void
+each(VALUE self, struct yield *yield)
+{
+        const struct rb_u_string *s = RVAL2USTRING(self);
+        for (const char *p = USTRING_STR(s), *end = USTRING_END(s); p < end; )
+                yield_call(yield, UINT2NUM(u_decode(&p, p, end)));
+}
+
+UNUSED(static VALUE
+       size(VALUE self, UNUSED(VALUE args)))
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        return UINT2NUM(u_n_chars_n(USTRING_STR(string), USTRING_LENGTH(string)));
+}
+
+/* @overload each_codepoint{ |codepoint| … }
+ *
+ *   Enumerates the code points of the receiver.
+ *
+ *   @yieldparam [Integer] codepoint
+ *   @return [self]
+ *
+ * @overload each_codepoint
+ *   @return [Enumerator] An Enumerator over the code points of the receiver
+ */
+VALUE
+rb_u_string_each_codepoint(VALUE self)
+{
+        RETURN_SIZED_ENUMERATOR(self, 0, NULL, size);
+        struct yield y = YIELD_INIT;
+        each(self, &y);
+        return self;
+}
+
+/* @return [Array<Integer>] The code points of the receiver. */
+VALUE
+rb_u_string_codepoints(VALUE self)
+{
+        struct yield_array y = YIELD_ARRAY_INIT;
+        each(self, &y.yield);
+        return y.array;
+}

data/ext/u/rb_u_string_each_grapheme_cluster.c

@@ -0,0 +1,36 @@
+#include "rb_includes.h"
+
+static void
+each(const char *p, size_t n, VALUE *self)
+{
+        rb_yield(rb_u_string_new_c(*self, p, n));
+}
+
+/* @overload each_grapheme_cluster{ |cluster| … }
+ *
+ *   Enumerates the grapheme clusters in the receiver, each inheriting any
+ *   taint and untrust.
+ *
+ *   @yieldparam [U::String] cluster
+ *   @return [self]
+ *   @see http://www.unicode.org/reports/tr29/
+ *     Unicode Standard Annex #29: Unicode Text Segmentation
+ *
+ * @overload each_grapheme_cluster
+ *
+ *   @return [Enumerator] An Enumerator over the grapheme clusters in the
+ *     receiver
+ *   @see http://www.unicode.org/reports/tr29/
+ *     Unicode Standard Annex #29: Unicode Text Segmentation */
+VALUE
+rb_u_string_each_grapheme_cluster(VALUE self)
+{
+        RETURN_ENUMERATOR(self, 0, NULL);
+
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *p = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+        size_t length = end - p;
+        u_grapheme_clusters(p, length, (u_substring_fn)each, &self);
+        return self;
+}

data/ext/u/rb_u_string_each_line.c

@@ -0,0 +1,142 @@
+#include "rb_includes.h"
+#include "yield.h"
+
+static void
+rb_u_string_each_line_default(VALUE self, struct yield *yield)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        const char *begin = USTRING_STR(string);
+        const char *base = begin;
+        const char *p = begin;
+        const char *end = USTRING_END(string);
+
+        while (p < end) {
+                p = memchr(p, '\n', end - p);
+                if (p == NULL)
+                        break;
+                p++;
+
+                yield_call(yield, rb_u_string_new_c(self, base, p - base));
+
+                base = p;
+        }
+
+        if (base != end)
+                yield_call(yield, rb_u_string_new_c(self, base, end - base));
+}
+
+static void
+rb_u_string_each_line_separator(VALUE self, const struct rb_u_string *separator,
+                                struct yield *yield)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        long separator_length = USTRING_LENGTH(separator);
+        const char *q;
+        uint32_t first = separator_length == 0 ?
+                '\n' :
+                u_decode(&q, USTRING_STR(separator), USTRING_END(separator));
+
+        const char *begin = USTRING_STR(string);
+        const char *base = begin;
+        const char *p = begin;
+        const char *end = USTRING_END(string);
+
+        while (p < end) {
+                uint32_t c = u_decode(&q, p, end);
+again:
+                if (separator_length == 0 && c == first) {
+                        p = q;
+                        if (p < end) {
+                                c = u_decode(&q, p, end);
+                                if (c != first)
+                                        goto again;
+                        }
+                        while (p < end) {
+                                if (u_decode(&q, p, end) != first)
+                                        break;
+                                p = q;
+                        }
+                }
+
+                if (c == first &&
+                    (separator_length < 2 ||
+                     (end - p >= separator_length &&
+                      memcmp(USTRING_STR(separator), p, separator_length) == 0))) {
+                        p += separator_length;
+                        yield_call(yield, rb_u_string_new_c(self, base, p - base));
+                        base = p;
+                } else
+                        p = q;
+        }
+
+        if (base != end)
+                yield_call(yield, rb_u_string_new_c(self, base, end - base));
+}
+
+static void
+each(int argc, VALUE *argv, VALUE self, struct yield *yield)
+{
+        VALUE rs;
+        if (argc == 0)
+                rs = rb_rs;
+        else
+                rb_scan_args(argc, argv, "01", &rs);
+        if (NIL_P(rs)) {
+                yield_call(yield, self);
+                return;
+        }
+        const struct rb_u_string *separator = RVAL2USTRING_ANY(rs);
+        if (rs == rb_default_rs)
+                rb_u_string_each_line_default(self, yield);
+        else
+                rb_u_string_each_line_separator(self, separator, yield);
+}
+
+/* @overload each_line(separator = $/){ |lp| … }
+ *
+ *   Enumerates the lines of the receiver, inheriting any taint and untrust.
+ *
+ *   If SEPARATOR is nil, yields self.  If SEPARATOR is {#empty?}, separates
+ *   each line (paragraph) by two or more U+000A LINE FEED characters.
+ *
+ *   @param [U::String, #to_str] separator
+ *   @yieldparam [U::String, self] lp
+ *   @return [self]
+ *
+ * @overload each_line(separator = $/)
+ *
+ *   Returns an Enumerator over the lines of the receiver.
+ *
+ *   If SEPARATOR is nil, self will be yielded.  If SEPARATOR is {#empty?},
+ *   separates each line (paragraph) by two or more U+000A LINE FEED
+ *   characters.
+ *
+ *   @param [U::String, #to_str] separator
+ *   @return [Enumerator] */
+VALUE
+rb_u_string_each_line(int argc, VALUE *argv, VALUE self)
+{
+        RETURN_ENUMERATOR(self, argc, argv);
+        struct yield y = YIELD_INIT;
+        each(argc, argv, self, &y);
+        return self;
+}
+
+/* @overload lines(separator = $/)
+ *
+ *   Returns the lines of the receiver, inheriting any taint and untrust.
+ *
+ *   If SEPARATOR is nil, yields self.  If SEPARATOR is {#empty?}, separates
+ *   each line (paragraph) by two or more U+000A LINE FEED characters.
+ *
+ *   @param [U::String, #to_str] separator
+ *   @return [Array<U::String>] */
+VALUE
+rb_u_string_lines(int argc, VALUE *argv, VALUE self)
+{
+        struct yield_array y = YIELD_ARRAY_INIT;
+        each(argc, argv, self, &y.yield);
+        return y.array;
+}