u 0.5.0 → 1.0.0

data/ext/u/rb_u_re.c

@@ -0,0 +1,43 @@
+#include <ruby.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "u.h"
+#include "private.h"
+#include "rb_private.h"
+#include "rb_u_re.h"
+
+VALUE
+rb_u_pattern_argument(VALUE pattern, bool quote)
+{
+        VALUE string;
+
+        switch (TYPE(pattern)) {
+        case T_REGEXP:
+                return pattern;
+        case T_STRING:
+                string = pattern;
+                break;
+        default:
+                string = rb_check_string_type(pattern);
+                if (NIL_P(string))
+                        Check_Type(pattern, T_REGEXP);
+        }
+
+        return rb_reg_regcomp(quote ? rb_reg_quote(string) : string);
+}
+
+#ifndef HAVE_RB_REG_BACKREF_NUMBER
+static int
+rb_reg_backref_number(UNUSED(VALUE match), VALUE backref)
+{
+        return NUM2INT(backref);
+}
+#endif
+
+VALUE
+rb_u_pattern_match_reference(VALUE reference)
+{
+        VALUE match = rb_backref_get();
+	return rb_reg_nth_match(rb_reg_backref_number(match, reference), match);
+}

data/ext/u/rb_u_re.h

@@ -0,0 +1,15 @@
+#ifdef HAVE_RUBY_RE_H
+#  include <ruby/re.h>
+#else
+#  include <re.h>
+#endif
+
+
+#ifdef HAVE_BROKEN_RMATCH_REGS
+#  undef RMATCH_REGS
+#  define RMATCH_REGS(obj) ((R_CAST(RMatch)(obj))->regs)
+#endif
+
+
+VALUE rb_u_pattern_argument(VALUE pattern, bool quote);
+VALUE rb_u_pattern_match_reference(VALUE reference);

data/ext/u/rb_u_string.c

@@ -0,0 +1,478 @@
+/* -*- coding: utf-8 -*- */
+
+#include <ruby.h>
+#ifdef HAVE_RUBY_ENCODING_H
+#  include <ruby/encoding.h>
+#endif
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include "u.h"
+#include "private.h"
+#include "rb_private.h"
+#include "rb_u_string.h"
+
+VALUE rb_cUString;
+
+static void
+rb_u_string_mark(const struct rb_u_string *string)
+{
+        rb_gc_mark(string->rb);
+}
+
+static void
+rb_u_string_free(struct rb_u_string *string)
+{
+        free((char *)string->c);
+        free(string);
+}
+
+static VALUE
+rb_u_string_set_rb(VALUE self, VALUE rb)
+{
+        struct rb_u_string *string = RVAL2USTRING(self);
+        if (NIL_P(rb)) {
+                string->rb = rb;
+                return self;
+        }
+#ifdef HAVE_RUBY_ENCODING_H
+        rb = rb_str_encode(rb, rb_enc_from_encoding(rb_utf8_encoding()), 0, Qnil);
+#endif
+        string->rb = rb_str_freeze(rb);
+        OBJ_INFECT(self, string->rb);
+        return self;
+}
+
+static VALUE
+rb_u_string_create(VALUE rb, const char *str, long length)
+{
+        struct rb_u_string *string = ALLOC(struct rb_u_string);
+        string->rb = Qnil;
+        string->c = str;
+        string->length = length;
+        return rb_u_string_set_rb(USTRING2RVAL(string), rb);
+}
+
+static VALUE
+rb_u_string_alloc(UNUSED(VALUE klass))
+{
+        return rb_u_string_create(Qnil, NULL, 0);
+}
+
+VALUE
+rb_u_string_new_uninfected(const char *str, long length)
+{
+        return rb_u_string_new_c(Qnil, str, length);
+}
+
+VALUE
+rb_u_string_new_uninfected_own(const char *str, long length)
+{
+        return rb_u_string_new_c_own(Qnil, str, length);
+}
+
+VALUE
+rb_u_string_new_c(VALUE self, const char *str, long length)
+{
+        char *copy = ALLOC_N(char, length + 1);
+        MEMCPY(copy, str, char, length);
+        copy[length] = '\0';
+        return rb_u_string_new_c_own(self, copy, length);
+}
+
+VALUE
+rb_u_string_new_c_own(VALUE self, const char *str, long length)
+{
+        VALUE result = rb_u_string_create(Qnil, str, length);
+        OBJ_INFECT(result, self);
+        return result;
+}
+
+VALUE
+rb_u_string_new_rb(VALUE str)
+{
+        return rb_u_string_create(str, NULL, 0);
+}
+
+VALUE
+rb_u_string_new_subsequence(VALUE self, long begin, long length)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        return rb_u_string_new_c(self, USTRING_STR(string) + begin, length);
+}
+
+VALUE
+rb_u_string_new_empty(VALUE self)
+{
+        return rb_u_string_new_subsequence(self, 0, 0);
+}
+
+VALUE
+rb_u_string_check_type(VALUE str)
+{
+        if (RTEST(rb_obj_is_kind_of(str, rb_cUString)))
+                return str;
+
+        return rb_check_string_type(str);
+}
+
+VALUE
+rb_u_string_validate_type(VALUE str)
+{
+        VALUE converted = rb_u_string_check_type(str);
+
+        if (NIL_P(converted))
+                rb_u_raise(rb_eTypeError,
+                           "type mismatch: %s given",
+                           rb_obj_classname(str));
+
+        return converted;
+}
+
+VALUE
+rb_u_string_object_as_string(VALUE object)
+{
+        if (TYPE(object) == T_STRING || RTEST(rb_obj_is_kind_of(object, rb_cUString)))
+                return object;
+
+        static ID id_to_s;
+        if (id_to_s == 0)
+                id_to_s = rb_intern("to_s");
+
+        VALUE str = rb_funcall(object, id_to_s, 0);
+        if (TYPE(str) != T_STRING)
+                return rb_any_to_s(object);
+
+        if (OBJ_TAINTED(object))
+                OBJ_TAINT(str);
+
+        return str;
+}
+
+/* @!visibility public
+ * @overload new(string = nil)
+ *
+ *   Sets up a U::String wrapping STRING after encoding it as UTF-8 and
+ *   freezing it.
+ *
+ *   @param [String, nil] string
+ */
+static VALUE
+rb_u_string_initialize(int argc, VALUE *argv, VALUE self)
+{
+        VALUE rb;
+
+        rb_scan_args(argc, argv, "01", &rb);
+        if (!NIL_P(rb)) {
+                StringValue(rb);
+                rb_u_string_set_rb(self, rb);
+        }
+
+        return Qnil;
+}
+
+static VALUE
+rb_u_string_initialize_copy(VALUE self, VALUE rboriginal)
+{
+        struct rb_u_string *string = RVAL2USTRING(self);
+        const struct rb_u_string *original = RVAL2USTRING(rboriginal);
+
+        if (string == original)
+                return self;
+
+        string->rb = original->rb;
+        string->c = original->c;
+        string->length = original->length;
+
+        OBJ_INFECT(self, rboriginal);
+
+        return self;
+}
+
+VALUE
+rb_u_string_dup(VALUE self)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+
+        VALUE result = rb_u_string_create(string->rb, string->c, string->length);
+        OBJ_INFECT(result, self);
+        return result;
+}
+
+#include <errno.h>
+
+static VALUE
+rb_u_string_recode(VALUE self, VALUE codeset)
+{
+        const struct rb_u_string *string = RVAL2USTRING(self);
+        const char *cs = StringValuePtr(codeset);
+        errno = 0;
+        size_t n = u_recode(NULL, 0, USTRING_STR(string), USTRING_LENGTH(string), cs);
+        if (errno != 0)
+                rb_u_raise_errno(errno, "can’t recode");
+        char *recoded = ALLOC_N(char, n + 1);
+        u_recode(recoded, n + 1, USTRING_STR(string), USTRING_LENGTH(string), cs);
+        return rb_str_new(recoded, n);
+}
+
+/* Document-class: U::String
+ *
+ * A U::String is a sequence of zero or more Unicode characters encoded as
+ * UTF-8.  It’s interface is an extension of that of Ruby’s built-in String
+ * class that provides better Unicode support, as it handles things such as
+ * casing, width, collation, and various other Unicode properties that Ruby’s
+ * built-in String class simply doesn’t bother itself with.  It also provides
+ * “backwards compatibility” with Ruby 1.8.7 so that you can use Unicode
+ * without upgrading to Ruby 2.0 (which you probably should do, though).
+ *
+ * It differs from Ruby’s built-in String class in one other very important way
+ * in that it doesn’t provide any way to change an existing object.  That is, a
+ * U::String is a value object.
+ *
+ * A U::String is most easily created from a String by calling {String#u}.
+ * Most U::String methods that return a stringy result will return a U::String,
+ * so you only have to do that once.  You can get back a String by calling
+ * {U::String#to_str}.
+ *
+ * Validation of a U::String’s content isn’t performed until any access to it
+ * is made, at which time an ArgumentError will be raised if it isn’t valid.
+ *
+ * U::String has a lot of methods defined upon it, so let’s break them up into
+ * categories to get a proper overview of what’s possible to do with one.
+ * Let’s begin with the interrogators.  There are three kinds of interrogators,
+ * validity-checking ones, property-checking ones, and content-matching ones.
+ *
+ * The validity-checking interrogator is {#valid_encoding?}, which makes sure
+ * that the UTF-8 sequence itself is valid.
+ *
+ * The property-checking interrogators are {#alnum?}, {#alpha?},
+ * {#ascii_only?}, {#assigned?}, {#case_ignorable?}, {#cased?}, {#cntrl?},
+ * {#defined?}, {#digit?}, {#graph?}, {#newline?}, {#print?}, {#punct?},
+ * {#soft_dotted?}, {#space?}, {#title?}, {#valid?}, {#wide?}, {#wide_cjk?},
+ * {#xdigit?}, and {#zero_width?}.  These interrogators check the corresponding
+ * Unicode property of each characters in the U::String and if all characters
+ * have this property, they’ll return true.
+ *
+ * Very close relatives to the property-checking interrogators are {#folded?},
+ * {#lower?}, and {#upper?}, which check whether a string has been cased in a
+ * given way, and {#normalized?}, which checks whether the receiver has been
+ * normalized, optionally to a specific normalization form.
+ *
+ * The content-matching interrogators are {#==}, {#===}, {#=~}, {#match},
+ * {#empty?}, {#end_with?}, {#eql?}, {#include?}, {#index}, {#rindex}, and
+ * {#start_with?}.  These interrogators check that a substring of the U::String
+ * matches another string or Regexp and either return a Boolean result, and
+ * index into the U::String where the match begins or MatchData for full
+ * matching information.
+ *
+ * Related to the content-matching interrogators are {#<=>}, {#casecmp}, and
+ * {#collation_key}, all of which compare a U::String against another for
+ * ordering.
+ *
+ * Related to the property-checking interrogators are
+ * {#canonical_combining_class}, {#general_category}, {#grapheme_break},
+ * {#line_break}, {#script}, and {#word_break}, which return the value of the
+ * Unicode property in question, the general category being the one often
+ * interrogated.
+ *
+ * There are a couple of other “interrogators” in {#bytesize}, {#length},
+ * {#size}, {#width} that return integer properties of the U::String as a
+ * whole, where #length and #width are probably the most useful.
+ *
+ * Beyond interrogators there are quite a few methods for iterating over the
+ * content of a U::String, each viewing it in its own way: {#each_byte},
+ * {#each_char}, {#each_codepoint}, {#each_grapheme_cluster}, {#each_line}, and
+ * {#each_word}.  They all have respective methods ({#bytes}, {#chars},
+ * {#codepoints}, {#grapheme_clusters}, {#lines}, {#words}) that return an
+ * Array instead of yielding each result.
+ *
+ * Quite a few methods are devoted to extracting a substring of a U::String,
+ * namely {#[]}, {#slice}, {#byteslice}, {#chomp}, {#chop}, {#chr}, {#getbyte},
+ * {#lstrip}, {#ord}, {#rstrip}, {#strip}.
+ *
+ * There are a few methods for case-shifting: {#downcase}, {#foldcase},
+ * {#titlecase}, and {#upcase}.  Then there’s {#mirror}, {#normalize}, and
+ * {#reverse} that alter the string in other ways.
+ *
+ * The methods {#center}, {#ljust}, and {#rjust} pad a U::String to make it a
+ * certain number of cells wide.
+ *
+ * Then there’s a couple of methods that are more related in the arguments they
+ * take than in function: {#count}, {#delete}, {#squeeze}, {#tr}, and {#tr_s}.
+ * These methods all take specifications of character/code point ranges that
+ * should be counted, deleted, squeezed, and translated (plus squeezed).
+ *
+ * Deconstructing a U::String can be done with {#partition} and {#rpartition},
+ * which splits it around a divider, {#scan}, which extracts matches to a
+ * pattern, {#split}, which splits it on a divider.
+ *
+ * Substitution of all matches to a pattern can be made with {#gsub} and of the
+ * first match to a pattern with {#sub}.
+ *
+ * Creating larger U::Strings from smaller ones is done with {#+}, which
+ * concatenates two of them, and {#*}, which concatenates a U::String to itself
+ * a number of times.
+ *
+ * A U::String can also be used as a specification as to how to format a number
+ * of values via {#%} (and its alias {#format}) into a new U::String, much like
+ * snprintf(3) in C.
+ *
+ * The content of a U::String can be {#dump}ed and {#inspect}ed to make it
+ * reader-friendly, but also debugger-friendly.
+ *
+ * Finally, a U::String has a few methods to turn its content into other
+ * values: {#hash}, which turns it into a hash value to be used for hashing,
+ * {#hex}, {#oct}, {#to_i}, which turn it into a Integer, {#to_str}, {#to_s},
+ * {#b}, which turn it into a String, and {#to_sym} (and its alias {#intern}),
+ * which turns it into a Symbol.
+ *
+ * Note that some methods defined on String are missing.  #Capitalize doesn’t
+ * exist, as capitalization isn’t a Unicode concept.  #Sum doesn’t exist, as a
+ * U::String generally doesn’t contain content that you need a checksum of.
+ * \#Crypt doesn’t exist for similar reasons.  #Swapcase isn’t useful on a
+ * String and it certainly isn’t useful in a Unicode context.  As a U::String
+ * doesn’t contain arbitrary data, #unpack is left to String.  #Next/#succ
+ * would perhaps be implementable, but haven’t, as a satisfactory
+ * implementation hasn’t been thought of. */
+void
+Init_u_string(VALUE mU)
+{
+        rb_cUString = rb_define_class_under(mU, "String", rb_cData);
+
+        rb_include_module(rb_cUString, rb_mComparable);
+
+        rb_define_alloc_func(rb_cUString, rb_u_string_alloc);
+        rb_define_private_method(rb_cUString, "initialize", rb_u_string_initialize, -1);
+        rb_define_private_method(rb_cUString, "initialize_copy", rb_u_string_initialize_copy, 1);
+
+        rb_define_method(rb_cUString, "valid_encoding?", rb_u_string_valid_encoding, 0); /* in ext/u/rb_u_string_valid_encoding.c */
+
+        rb_define_method(rb_cUString, "alnum?", rb_u_string_alnum, 0); /* in ext/u/rb_u_string_alnum.c */
+        rb_define_method(rb_cUString, "alpha?", rb_u_string_alpha, 0); /* in ext/u/rb_u_string_alpha.c */
+        rb_define_method(rb_cUString, "ascii_only?", rb_u_string_ascii_only, 0); /* in ext/u/rb_u_string_ascii_only.c */
+        rb_define_method(rb_cUString, "assigned?", rb_u_string_assigned, 0); /* in ext/u/rb_u_string_assigned.c */
+        rb_define_method(rb_cUString, "case_ignorable?", rb_u_string_case_ignorable, 0); /* in ext/u/rb_u_string_case_ignorable.c */
+        rb_define_method(rb_cUString, "cased?", rb_u_string_cased, 0); /* in ext/u/rb_u_string_cased.c */
+        rb_define_method(rb_cUString, "cntrl?", rb_u_string_cntrl, 0); /* in ext/u/rb_u_string_cntrl.c */
+        rb_define_method(rb_cUString, "defined?", rb_u_string_defined, 0); /* in ext/u/rb_u_string_defined.c */
+        rb_define_method(rb_cUString, "digit?", rb_u_string_digit, 0); /* in ext/u/rb_u_string_digit.c */
+        rb_define_method(rb_cUString, "folded?", rb_u_string_folded, -1); /* in ext/u/rb_u_string_folded.c */
+        rb_define_method(rb_cUString, "graph?", rb_u_string_graph, 0); /* in ext/u/rb_u_string_graph.c */
+        rb_define_method(rb_cUString, "lower?", rb_u_string_lower, -1); /* in ext/u/rb_u_string_lower.c */
+        rb_define_method(rb_cUString, "newline?", rb_u_string_newline, 0); /* in ext/u/rb_u_string_newline.c */
+        rb_define_method(rb_cUString, "print?", rb_u_string_print, 0); /* in ext/u/rb_u_string_print.c */
+        rb_define_method(rb_cUString, "punct?", rb_u_string_punct, 0); /* in ext/u/rb_u_string_punct.c */
+        rb_define_method(rb_cUString, "soft_dotted?", rb_u_string_soft_dotted, 0); /* in ext/u/rb_u_string_soft_dotted.c */
+        rb_define_method(rb_cUString, "space?", rb_u_string_space, 0); /* in ext/u/rb_u_string_space.c */
+        rb_define_method(rb_cUString, "title?", rb_u_string_title, 0); /* in ext/u/rb_u_string_title.c */
+        rb_define_method(rb_cUString, "upper?", rb_u_string_upper, -1); /* in ext/u/rb_u_string_upper.c */
+        rb_define_method(rb_cUString, "valid?", rb_u_string_valid, 0); /* in ext/u/rb_u_string_valid.c */
+        rb_define_method(rb_cUString, "wide?", rb_u_string_wide, 0); /* in ext/u/rb_u_string_wide.c */
+        rb_define_method(rb_cUString, "wide_cjk?", rb_u_string_wide_cjk, 0); /* in ext/u/rb_u_string_wide_cjk.c */
+        rb_define_method(rb_cUString, "xdigit?", rb_u_string_xdigit, 0); /* in ext/u/rb_u_string_xdigit.c */
+        rb_define_method(rb_cUString, "zero_width?", rb_u_string_zero_width, 0); /* in ext/u/rb_u_string_zero_width.c */
+
+        rb_define_method(rb_cUString, "normalized?", rb_u_string_normalized, -1); /* in ext/u/rb_u_string_normalized.c */
+
+        rb_define_method(rb_cUString, "==", rb_u_string_equal, 1); /* in ext/u/rb_u_string_equal.c */
+        rb_define_alias(rb_cUString, "===", "==");
+        rb_define_method(rb_cUString, "=~", rb_u_string_match, 1); /* in ext/u/rb_u_string_match.c */
+        rb_define_method(rb_cUString, "match", rb_u_string_match_m, -1); /* in ext/u/rb_u_string_match.c */
+        rb_define_method(rb_cUString, "empty?", rb_u_string_empty, 0); /* in ext/u/rb_u_string_empty.c */
+        rb_define_method(rb_cUString, "end_with?", rb_u_string_end_with, -1); /* in ext/u/rb_u_string_end_with.c */
+        rb_define_method(rb_cUString, "eql?", rb_u_string_eql, 1); /* in ext/u/rb_u_string_eql.c */
+        rb_define_method(rb_cUString, "include?", rb_u_string_include, 1); /* in ext/u/rb_u_string_include.c */
+        rb_define_method(rb_cUString, "index", rb_u_string_index_m, -1); /* in ext/u/rb_u_string_index.c */
+        rb_define_method(rb_cUString, "rindex", rb_u_string_rindex_m, -1); /* in ext/u/rb_u_string_rindex.c */
+        rb_define_method(rb_cUString, "start_with?", rb_u_string_start_with, -1); /* in ext/u/rb_u_string_start_with.c */
+
+        rb_define_method(rb_cUString, "<=>", rb_u_string_collate, -1); /* in ext/u/rb_u_string_collate.c */
+        rb_define_method(rb_cUString, "casecmp", rb_u_string_casecmp, -1); /* in ext/u/rb_u_string_casecmp.c */
+        rb_define_method(rb_cUString, "collation_key", rb_u_string_collation_key, -1); /* in ext/u/rb_u_string_collation_key.c */
+
+        rb_define_method(rb_cUString, "canonical_combining_class", rb_u_string_canonical_combining_class, 0); /* in ext/u/rb_u_string_canonical_combining_class.c */
+        rb_define_method(rb_cUString, "general_category", rb_u_string_general_category, 0); /* in ext/u/rb_u_string_general_category.c */
+        rb_define_method(rb_cUString, "grapheme_break", rb_u_string_grapheme_break, 0); /* in ext/u/rb_u_string_grapheme_break.c */
+        rb_define_method(rb_cUString, "line_break", rb_u_string_line_break, 0); /* in ext/u/rb_u_string_line_break.c */
+        rb_define_method(rb_cUString, "script", rb_u_string_script, 0); /* in ext/u/rb_u_string_script.c */
+        rb_define_method(rb_cUString, "word_break", rb_u_string_word_break, 0); /* in ext/u/rb_u_string_word_break.c */
+
+        rb_define_method(rb_cUString, "bytesize", rb_u_string_bytesize, 0); /* in ext/u/rb_u_string_bytesize.c */
+        rb_define_method(rb_cUString, "length", rb_u_string_length, 0); /* in ext/u/rb_u_string_length.c */
+        rb_define_alias(rb_cUString, "size", "length");
+        rb_define_method(rb_cUString, "width", rb_u_string_width, 0); /* in ext/u/rb_u_string_width.c */
+
+        rb_define_method(rb_cUString, "each_byte", rb_u_string_each_byte, 0); /* in ext/u/rb_u_string_each_byte.c */
+        rb_define_method(rb_cUString, "bytes", rb_u_string_bytes, 0); /* in ext/u/rb_u_string_each_byte.c */
+        rb_define_method(rb_cUString, "each_char", rb_u_string_each_char, 0); /* in ext/u/rb_u_string_each_char.c */
+        rb_define_method(rb_cUString, "chars", rb_u_string_chars, 0); /* in ext/u/rb_u_string_each_char.c */
+        rb_define_method(rb_cUString, "each_codepoint", rb_u_string_each_codepoint, 0); /* in ext/u/rb_u_string_each_codepoint.c */
+        rb_define_method(rb_cUString, "codepoints", rb_u_string_codepoints, 0); /* in ext/u/rb_u_string_each_codepoint.c */
+        rb_define_method(rb_cUString, "each_grapheme_cluster", rb_u_string_each_grapheme_cluster, 0); /* in ext/u/rb_u_string_each_grapheme_cluster.c */
+        rb_define_alias(rb_cUString, "grapheme_clusters", "each_grapheme_cluster");
+        rb_define_method(rb_cUString, "each_line", rb_u_string_each_line, -1); /* in ext/u/rb_u_string_each_line.c */
+        rb_define_method(rb_cUString, "lines", rb_u_string_lines, -1); /* in ext/u/rb_u_string_each_line.c */
+        rb_define_method(rb_cUString, "each_word", rb_u_string_each_word, 0); /* in ext/u/rb_u_string_each_word.c */
+        rb_define_alias(rb_cUString, "words", "each_word");
+
+        rb_define_method(rb_cUString, "[]", rb_u_string_aref_m, -1); /* in ext/u/rb_u_string_aref.c */
+        rb_define_alias(rb_cUString, "slice", "[]");
+        rb_define_method(rb_cUString, "byteslice", rb_u_string_byteslice_m, -1); /* in ext/u/rb_u_string_byteslice.c */
+        rb_define_method(rb_cUString, "chomp", rb_u_string_chomp, -1); /* in ext/u/rb_u_string_chomp.c */
+        rb_define_method(rb_cUString, "chop", rb_u_string_chop, 0); /* in ext/u/rb_u_string_chop.c */
+        rb_define_method(rb_cUString, "chr", rb_u_string_chr, 0); /* in ext/u/rb_u_string_chr.c */
+        rb_define_method(rb_cUString, "getbyte", rb_u_string_getbyte, 1); /* in ext/u/rb_u_string_getbyte.c */
+        rb_define_method(rb_cUString, "lstrip", rb_u_string_lstrip, 0); /* in ext/u/rb_u_string_lstrip.c */
+        rb_define_method(rb_cUString, "ord", rb_u_string_ord, 0); /* in ext/u/rb_u_string_ord.c */
+        rb_define_method(rb_cUString, "rstrip", rb_u_string_rstrip, 0); /* in ext/u/rb_u_string_rstrip.c */
+        rb_define_method(rb_cUString, "strip", rb_u_string_strip, 0); /* in ext/u/rb_u_string_strip.c */
+
+        rb_define_method(rb_cUString, "downcase", rb_u_string_downcase, -1); /* in ext/u/rb_u_string_downcase.c */
+        rb_define_method(rb_cUString, "foldcase", rb_u_string_foldcase, -1); /* in ext/u/rb_u_string_foldcase.c */
+        rb_define_method(rb_cUString, "titlecase", rb_u_string_titlecase, -1); /* in ext/u/rb_u_string_titlecase.c */
+        rb_define_method(rb_cUString, "upcase", rb_u_string_upcase, -1); /* in ext/u/rb_u_string_upcase.c */
+
+        rb_define_method(rb_cUString, "mirror", rb_u_string_mirror, 0); /* in ext/u/rb_u_string_mirror.c */
+        rb_define_method(rb_cUString, "normalize", rb_u_string_normalize, -1); /* in ext/u/rb_u_string_normalize.c */
+        rb_define_method(rb_cUString, "reverse", rb_u_string_reverse, 0); /* in ext/u/rb_u_string_reverse.c */
+
+        rb_define_method(rb_cUString, "center", rb_u_string_center, -1); /* in ext/u/rb_u_string_justify.c */
+        rb_define_method(rb_cUString, "ljust", rb_u_string_ljust, -1); /* in ext/u/rb_u_string_justify.c */
+        rb_define_method(rb_cUString, "rjust", rb_u_string_rjust, -1); /* in ext/u/rb_u_string_justify.c */
+
+        rb_define_method(rb_cUString, "count", rb_u_string_count, -1); /* in ext/u/rb_u_string_count.c */
+        rb_define_method(rb_cUString, "delete", rb_u_string_delete, -1); /* in ext/u/rb_u_string_delete.c */
+        rb_define_method(rb_cUString, "squeeze", rb_u_string_squeeze, -1); /* in ext/u/rb_u_string_squeeze.c */
+        rb_define_method(rb_cUString, "tr", rb_u_string_tr, 2); /* in ext/u/rb_u_string_tr.c */
+        rb_define_method(rb_cUString, "tr_s", rb_u_string_tr_s, 2); /* in ext/u/rb_u_string_tr.c */
+
+        rb_define_method(rb_cUString, "partition", rb_u_string_partition, 1); /* in ext/u/rb_u_string_partition.c */
+        rb_define_method(rb_cUString, "rpartition", rb_u_string_rpartition, 1); /* in ext/u/rb_u_string_rpartition.c */
+        rb_define_method(rb_cUString, "scan", rb_u_string_scan, 1); /* in ext/u/rb_u_string_scan.c */
+        rb_define_method(rb_cUString, "split", rb_u_string_split_m, -1); /* in ext/u/rb_u_string_split.c */
+
+        rb_define_method(rb_cUString, "gsub", rb_u_string_gsub, -1); /* in ext/u/rb_u_string_gsub.c */
+        rb_define_method(rb_cUString, "sub", rb_u_string_sub, -1); /* in ext/u/rb_u_string_sub.c */
+
+        rb_define_method(rb_cUString, "+", rb_u_string_plus, 1); /* in ext/u/rb_u_string_plus.c */
+        rb_define_method(rb_cUString, "*", rb_u_string_times, 1); /* in ext/u/rb_u_string_times.c */
+
+        rb_define_method(rb_cUString, "%", rb_u_string_format_m, 1); /* in ext/u/rb_u_string_format.c */
+        rb_define_alias(rb_cUString, "format", "%");
+
+        rb_define_method(rb_cUString, "dump", rb_u_string_dump, 0); /* in ext/u/rb_u_string_dump.c */
+        rb_define_method(rb_cUString, "inspect", rb_u_string_inspect, 0); /* in ext/u/rb_u_string_inspect.c */
+
+        rb_define_method(rb_cUString, "hash", rb_u_string_hash, 0); /* in ext/u/rb_u_string_hash.c */
+        rb_define_method(rb_cUString, "hex", rb_u_string_hex, 0); /* in ext/u/rb_u_string_hex.c */
+        rb_define_method(rb_cUString, "oct", rb_u_string_oct, 0); /* in ext/u/rb_u_string_oct.c */
+        rb_define_method(rb_cUString, "to_i", rb_u_string_to_i, -1); /* in ext/u/rb_u_string_to_i.c */
+        rb_define_method(rb_cUString, "to_str", rb_u_string_to_str, 0); /* in ext/u/rb_u_string_to_str.c */
+        rb_define_alias(rb_cUString, "to_s", "to_str");
+        rb_define_method(rb_cUString, "b", rb_u_string_b, 0); /* in ext/u/rb_u_string_b.c */
+        rb_define_method(rb_cUString, "to_sym", rb_u_string_to_sym, 0); /* in ext/u/rb_u_string_to_sym.c */
+        rb_define_alias(rb_cUString, "intern", "to_sym");
+
+        rb_define_method(rb_cUString, "recode", rb_u_string_recode, 1);
+}