u 0.5.0 → 1.0.0

data/ext/u/rb_u_string_inspect.c

@@ -0,0 +1,189 @@
+#include "rb_includes.h"
+
+static void
+rb_u_string_inspect_bad_input(const char *p, const char *q, VALUE result)
+{
+        while (p < q) {
+                char hex[5];
+                snprintf(hex, lengthof(hex), "\\x%02X", *p & 0xff);
+                rb_str_buf_cat2(result, hex);
+                p++;
+        }
+}
+
+static void
+rb_u_string_inspect_special_char(uint32_t c, VALUE result)
+{
+        char str[U_CHAR_MAX_BYTE_LENGTH];
+
+        rb_str_buf_cat2(result, "\\");
+        rb_str_buf_cat(result, str, u_char_to_u(c, str));
+}
+
+static void
+rb_u_string_inspect_escaped_char(uint32_t c, VALUE result)
+{
+        char str[4 + 8 + 1];
+
+        if (c < 0x10000)
+                snprintf(str, lengthof(str), "\\u%04X", c);
+        else
+                snprintf(str, lengthof(str), "\\u{%X}", c & 0xffffffff);
+
+        rb_str_buf_cat2(result, str);
+}
+
+static void
+rb_u_string_inspect_default(uint32_t c, VALUE result)
+{
+        if (!u_char_isprint(c)) {
+                rb_u_string_inspect_escaped_char(c, result);
+                return;
+        }
+
+        char str[U_CHAR_MAX_BYTE_LENGTH];
+        rb_str_buf_cat(result, str, u_char_to_u(c, str));
+}
+
+#define REPLACEMENT_CHARACTER ((uint32_t)0xfffd)
+
+static const char *
+rb_u_string_inspect_hash_char(const char *q, const char *end,
+                              VALUE result)
+{
+        if (q == end) {
+                rb_str_buf_cat2(result, "#");
+                return q;
+        }
+
+        const char *p = q;
+        uint32_t c = u_decode(&q, p, end);
+        switch (c) {
+        case REPLACEMENT_CHARACTER:
+                rb_str_buf_cat2(result, "#");
+                if (!u_valid(p, q - p, NULL))
+                        rb_u_string_inspect_bad_input(p, q, result);
+                else
+                        rb_u_string_inspect_default(c, result);
+                return q;
+        case '$':
+        case '@':
+        case '{':
+                rb_str_buf_cat2(result, "\\#");
+                rb_u_string_inspect_default(c, result);
+                return q;
+        default:
+                rb_str_buf_cat2(result, "#");
+                return p;
+        }
+}
+
+/* Returns the receiver in a reader-friendly inspectable format, inheriting
+ * any taint and untrust, encoded using UTF-8.
+ *
+ * The reader-friendly inspectable format looks like “`"…".u`”.  Inside the
+ * “…”, any {#print?} characters 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>
+ *
+ * Valid UTF-8 byte sequences representing code points < 0x10000 are output as
+ * `\u`_n_, where _n_ is the four-digit uppercase hexadecimal representation
+ * of the code point.
+ *
+ * Valid UTF-8 byte sequences representing code points ≥ 0x10000 are output as
+ * `\u{`_n_`}`, where _n_ is the uppercase hexadecimal representation of the
+ * code point.
+ *
+ * Any other byte is output as `\x`_n_, where _n_ is the two-digit uppercase
+ * hexadecimal representation of the byte’s value.
+ *
+ * @return [String] */
+VALUE
+rb_u_string_inspect(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        VALUE result = rb_u_str_buf_new(0);
+        rb_str_buf_cat2(result, "\"");
+        const char *p = USTRING_STR(string);
+        const char *end = USTRING_END(string);
+        while (p < end) {
+                const char *q;
+                uint32_t c = u_decode(&q, p, end);
+                switch (c) {
+                case '"':
+                case '\\':
+                        rb_u_string_inspect_special_char(c, result);
+                        break;
+                case '#':
+                        p = rb_u_string_inspect_hash_char(q, end, result);
+                        continue;
+                case '\n':
+                        rb_str_buf_cat2(result, "\\n");
+                        break;
+                case '\r':
+                        rb_str_buf_cat2(result, "\\r");
+                        break;
+                case '\t':
+                        rb_str_buf_cat2(result, "\\t");
+                        break;
+                case '\f':
+                        rb_str_buf_cat2(result, "\\f");
+                        break;
+                case '\013':
+                        rb_str_buf_cat2(result, "\\v");
+                        break;
+                case '\010':
+                        rb_str_buf_cat2(result, "\\b");
+                        break;
+                case '\007':
+                        rb_str_buf_cat2(result, "\\a");
+                        break;
+                case '\033':
+                        rb_str_buf_cat2(result, "\\e");
+                        break;
+                case REPLACEMENT_CHARACTER:
+                        if (!u_valid(p, q - p, NULL)) {
+                                rb_u_string_inspect_bad_input(p, q, result);
+                                break;
+                        }
+                        /* fall through */
+                default:
+                        rb_u_string_inspect_default(c, result);
+                        break;
+                }
+                p = q;
+        }
+
+        rb_str_buf_cat2(result, "\".u");
+
+        OBJ_INFECT(result, self);
+
+        return result;
+}

data/ext/u/rb_u_string_internal_tr.c

@@ -0,0 +1,148 @@
+#include "rb_includes.h"
+#include "rb_u_string_internal_tr.h"
+
+void
+tr_init(struct tr *tr, const char *p, const char *end)
+{
+        tr->p = p;
+        tr->end = end;
+        tr->inside_range = false;
+}
+
+bool
+tr_should_exclude(struct tr *tr)
+{
+        if (tr->p + 1 < tr->end && *tr->p == '^') {
+                tr->p++;
+                return true;
+        }
+
+        return false;
+}
+
+static enum tr_state
+tr_next_char(struct tr *t)
+{
+        if (t->p == t->end)
+                return TR_FINISHED;
+
+        t->now = u_decode(&t->p, t->p, t->end);
+        if (t->p == t->end)
+                return TR_FOUND;
+        if (t->now == '\\') {
+                t->now = u_decode(&t->p, t->p, t->end);
+                if (t->p == t->end)
+                        return TR_FOUND;
+        }
+
+        const char *next;
+        if (u_decode(&next, t->p, t->end) == '-') {
+                /* TODO: Make this simpler.  Perhaps we don’t need
+                 * TR_READ_ANOTHER, as we advance it here ourselves.  I got to
+                 * check the offsets here.  Perhaps TR_READ_ANOTHER should also
+                 * have advanced t->p one more step. */
+                if (next < t->end) {
+                        uint32_t max = u_decode(&t->p, next, t->end);
+                        if (max < t->now) {
+                                t->p = next;
+                                return TR_READ_ANOTHER;
+                        }
+                        t->inside_range = true;
+                        t->max = max;
+                }
+        }
+
+        return TR_FOUND;
+}
+
+enum tr_state
+tr_next(struct tr *t)
+{
+        while (true) {
+                if (!t->inside_range) {
+                        enum tr_state state;
+
+                        if ((state = tr_next_char(t)) == TR_READ_ANOTHER)
+                                continue;
+
+                        return state;
+                } else if (++t->now < t->max) {
+                        return TR_FOUND;
+                } else {
+                        t->inside_range = false;
+                        return TR_FOUND;
+                }
+        }
+}
+
+static void
+tr_table_set(struct tr_table *table, bool *buffer, uint32_t c, bool value)
+{
+        if (c < lengthof(table->continuous)) {
+                buffer[c] = value;
+                return;
+        }
+
+        if (NIL_P(table->sparse))
+                table->sparse = rb_hash_new();
+
+        rb_hash_aset(table->sparse, UINT2NUM(c), value ? Qtrue : Qfalse);
+}
+
+static void
+tr_table_add(struct tr_table *table, const struct rb_u_string *string)
+{
+        struct tr tr;
+        tr_init(&tr, USTRING_STR(string), USTRING_END(string));
+
+        bool exclude = tr_should_exclude(&tr);
+
+        bool buffer[lengthof(table->continuous)];
+
+        for (size_t i = 0; i < lengthof(buffer); i++)
+                buffer[i] = exclude;
+
+        while (tr_next(&tr) != TR_FINISHED)
+                tr_table_set(table, buffer, tr.now, !exclude);
+
+        for (size_t i = 0; i < lengthof(table->continuous); i++)
+                table->continuous[i] = table->continuous[i] && buffer[i];
+}
+
+void
+tr_table_initialize(struct tr_table *table, VALUE rbstring)
+{
+        const struct rb_u_string *string = RVAL2USTRING_ANY(rbstring);
+
+        struct tr tr;
+        tr_init(&tr, USTRING_STR(string), USTRING_END(string));
+
+        table->exclude = tr_should_exclude(&tr);
+
+        for (size_t i = 0; i < lengthof(table->continuous); i++)
+                table->continuous[i] = true;
+
+        table->sparse = Qnil;
+
+        tr_table_add(table, string);
+}
+
+void
+tr_table_initialize_from_strings(struct tr_table *table, int argc, VALUE *argv)
+{
+    tr_table_initialize(table, argv[0]);
+    for (int i = 1; i < argc; i++)
+            tr_table_add(table, RVAL2USTRING_ANY(argv[i]));
+}
+
+bool
+tr_table_lookup(struct tr_table *table, uint32_t c)
+{
+        if (c < lengthof(table->continuous))
+                return table->continuous[c];
+
+        VALUE value = NIL_P(table->sparse) ?
+                Qnil : rb_hash_lookup(table->sparse, UINT2NUM(c));
+
+        return NIL_P(value) ? table->exclude : RTEST(value);
+}

data/ext/u/rb_u_string_internal_tr.h

@@ -0,0 +1,29 @@
+struct tr {
+        bool inside_range;
+        uint32_t now;
+        uint32_t max;
+        const char *p;
+        const char *end;
+};
+
+enum tr_state
+{
+        TR_FOUND,
+        TR_READ_ANOTHER,
+        TR_FINISHED
+};
+
+struct tr_table {
+        bool exclude;
+        bool continuous[256];
+        VALUE sparse;
+};
+
+void tr_init(struct tr *tr, const char *p, const char *end);
+bool tr_should_exclude(struct tr *tr);
+enum tr_state tr_next(struct tr *t);
+void tr_table_initialize(struct tr_table *table, VALUE rbstring);
+void tr_table_initialize_from_strings(struct tr_table *table,
+                                             int argc,
+                                             VALUE *argv);
+bool tr_table_lookup(struct tr_table *table, uint32_t c);

data/ext/u/rb_u_string_justify.c

@@ -0,0 +1,169 @@
+#include "rb_includes.h"
+
+static char *
+rb_u_string_justify_one_side(char *p, const struct rb_u_string *padding, long padding_width, long n)
+{
+        const char *padding_str = USTRING_STR(padding);
+        long padding_size = USTRING_LENGTH(padding);
+
+        long i = 0;
+
+        for ( ; i + padding_width < n; i += padding_width, p += padding_size)
+                memcpy(p, padding_str, padding_size);
+
+        const char *q = padding_str;
+        const char *end = padding_str + padding_size;
+        while (i < n)
+                i += u_char_width(u_decode(&q, q, end));
+        memcpy(p, padding_str, q - padding_str);
+        p += q - padding_str;
+
+        return p;
+}
+
+static long
+rounding_size(const struct rb_u_string *padding, long padding_width, long n)
+{
+        const char *padding_str = USTRING_STR(padding);
+        const char *q = padding_str, *end = padding_str + USTRING_LENGTH(padding);
+        long r = n % padding_width;
+        long i = 0;
+        while (i < r && q < end)
+                i += u_char_width(u_decode(&q, q, end));
+        // NOTE I think i ≮ r is guaranteed, but I can’t seem to prove it, so
+        // leave this in for safety.
+        if (i < r)
+                rb_u_raise(rb_eArgError,
+                           "padding isn’t wide enough to complete rounding (%ld < %ld)",
+                           i, r);
+        if (i > r)
+                rb_u_raise(rb_eArgError,
+                           "padding is too wide to complete rounding (%ld > %ld)",
+                           i, r);
+        return q - padding_str;
+}
+
+static long
+rb_u_string_justified_size(long string_size,
+                           const struct rb_u_string *padding, long padding_width,
+                           long left_n, long right_n)
+{
+        long size;
+
+        long left_n_2 = rounding_size(padding, padding_width, left_n);
+        long right_n_2 = rounding_size(padding, padding_width, right_n);
+        if ((size = left_n / padding_width + right_n / padding_width) >= LONG_MAX / USTRING_LENGTH(padding) ||
+            (size *= USTRING_LENGTH(padding)) >= LONG_MAX - left_n_2 - right_n_2 ||
+            (size += left_n_2 + right_n_2) >= LONG_MAX - string_size)
+                rb_u_raise(rb_eArgError, "argument too big");
+        size += string_size;
+
+        return size;
+}
+
+static VALUE
+rb_u_string_justify_impl(VALUE self,
+                         const struct rb_u_string *string, long string_width,
+                         const struct rb_u_string *padding, long padding_width,
+                         long width, char jflag)
+{
+        long n = width - string_width;
+        long left_n = (jflag == 'l') ? 0 : ((jflag == 'r') ? n : n / 2);
+        long right_n = n - left_n;
+
+        long string_size = USTRING_LENGTH(string);
+        long justified_size = rb_u_string_justified_size(string_size,
+                                                         padding, padding_width,
+                                                         left_n, right_n);
+        char *justified = ALLOC_N(char, justified_size + 1);
+
+        char *p = rb_u_string_justify_one_side(justified, padding, padding_width, left_n);
+        memcpy(p, USTRING_STR(string), string_size);
+        p += string_size;
+        p = rb_u_string_justify_one_side(p, padding, padding_width, right_n);
+        justified[justified_size] = '\0';
+
+        return rb_u_string_new_c_own(self, justified, justified_size);
+}
+
+static VALUE
+rb_u_string_justify(int argc, VALUE *argv, VALUE self, char jflag)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        VALUE rbwidth, rbpadding;
+        const struct rb_u_string *padding = USTRING_LOCAL(Qnil, " ", 1);
+        long padding_width = 1;
+        if (rb_scan_args(argc, argv, "11", &rbwidth, &rbpadding) == 2) {
+                padding = RVAL2USTRING_ANY(rbpadding);
+                padding_width = u_width_n(USTRING_STR(padding), USTRING_LENGTH(padding));
+                if (padding_width == 0)
+                        rb_u_raise(rb_eArgError, "zero-width padding");
+        }
+
+        long string_width = u_width_n(USTRING_STR(string), USTRING_LENGTH(string));
+
+        long width = NUM2LONG(rbwidth);
+        if (width < 0 || string_width >= width)
+                return self;
+
+        VALUE result = rb_u_string_justify_impl(self,
+                                                string, string_width,
+                                                padding, padding_width,
+                                                width, jflag);
+        if (!NIL_P(rbpadding))
+                OBJ_INFECT(result, rbpadding);
+        return result;
+}
+
+/* @overload center(width, padding = ' ')
+ *   @param [#to_int] width
+ *   @param [U::String, #to_str] padding
+ *   @raise [ArgumentError] If PADDING{#width} = 0
+ *   @raise [ArgumentError] If characters inside PADDING that should be used
+ *     for round-off padding are too wide
+ *   @return [U::String] The receiver padded as evenly as possible on both
+ *     sides with PADDING to make it max({#length}, WIDTH) wide, inheriting any
+ *     taint and untrust from the receiver and also from PADDING if PADDING is
+ *     used
+ *   @see #ljust
+ *   @see #rjust */
+VALUE
+rb_u_string_center(int argc, VALUE *argv, VALUE self)
+{
+        return rb_u_string_justify(argc, argv, self, 'c');
+}
+
+/* @overload ljust(width, padding = ' ')
+ *   @param [#to_int] width
+ *   @param [U::String, #to_str] padding
+ *   @raise [ArgumentError] If PADDING{#width} = 0
+ *   @raise [ArgumentError] If characters inside PADDING that should be used
+ *     for round-off padding are too wide
+ *   @return [U::String] The receiver padded on the right with PADDING to make
+ *     it max({#length}, WIDTH) wide, inheriting any taint and untrust from
+ *     the receiver and also from PADDING if PADDING is used
+ *   @see #center
+ *   @see #rjust */
+VALUE
+rb_u_string_ljust(int argc, VALUE *argv, VALUE self)
+{
+        return rb_u_string_justify(argc, argv, self, 'l');
+}
+
+/* @overload rjust(width, padding = ' ')
+ *   @param [#to_int] width
+ *   @param [U::String, #to_str] padding
+ *   @raise [ArgumentError] If PADDING{#width} = 0
+ *   @raise [ArgumentError] If characters inside PADDING that should be used
+ *     for round-off padding are too wide
+ *   @return [U::String] The receiver padded on the left with PADDING to make
+ *     it max({#length}, WIDTH) wide, inheriting any taint and untrust from the
+ *     receiver and also from PADDING if PADDING is used
+ *   @see #center
+ *   @see #ljust */
+VALUE
+rb_u_string_rjust(int argc, VALUE *argv, VALUE self)
+{
+        return rb_u_string_justify(argc, argv, self, 'r');
+}