liblouis-rb 0.1.0

data/Rakefile

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/clean"
+require "rbconfig"
+require "shellwords"
+
+ROOT = __dir__
+EXTENSION_DIR = File.join(ROOT, "ext", "liblouis")
+EXTENSION = File.join(EXTENSION_DIR, "liblouis.#{RbConfig::CONFIG.fetch("DLEXT")}")
+
+CLEAN.include(
+  File.join(EXTENSION_DIR, "*.o"),
+  File.join(EXTENSION_DIR, "*.def"),
+  File.join(EXTENSION_DIR, "mkmf.log")
+)
+CLOBBER.include(
+  File.join(EXTENSION_DIR, "Makefile"),
+  File.join(EXTENSION_DIR, "config.h"),
+  File.join(EXTENSION_DIR, "liblouis.h"),
+  EXTENSION
+)
+
+def in_extension_directory
+  Dir.chdir(EXTENSION_DIR) { yield }
+end
+
+def msys_path(path)
+  path.tr("\\", "/").sub(/\A([A-Za-z]):/) { "/#{$1.downcase}" }
+end
+
+desc "Compile the native extension"
+task :compile do
+  ridk = File.join(RbConfig::CONFIG.fetch("bindir"), "ridk.cmd")
+  if Gem.win_platform? && File.file?(ridk)
+    command = [
+      "cd #{Shellwords.escape(msys_path(EXTENSION_DIR))}",
+      "#{Shellwords.escape(msys_path(RbConfig.ruby))} extconf.rb",
+      "make -j4"
+    ].join(" && ")
+    sh ridk, "exec", "bash", "-lc", command
+  else
+    in_extension_directory do
+      ruby "extconf.rb"
+      sh RbConfig::CONFIG.fetch("MAKE", "make")
+    end
+  end
+end
+
+def run_suite(pattern)
+  files = Dir[File.join(ROOT, pattern)].sort
+  ruby "-I#{EXTENSION_DIR}", "-e", files.map { |file| "require #{file.dump}" }.join("; ")
+end
+
+desc "Run Minitest unit tests"
+task test: :compile do
+  run_suite("test/**/test_*.rb")
+end
+
+desc "Run Minitest specs"
+task spec: :compile do
+  run_suite("spec/**/*_spec.rb")
+end
+
+desc "Build the gem in pkg"
+task :gem do
+  spec = Gem::Specification.load(File.join(ROOT, "liblouis-rb.gemspec"))
+  abort "Could not load liblouis-rb.gemspec" unless spec
+  package_dir = File.join(ROOT, "pkg")
+  mkdir_p package_dir
+  ruby "-S", "gem", "build", spec.loaded_from,
+    "--output", File.join(package_dir, spec.file_name)
+end
+
+desc "Test gem installation in paths with spaces and missing submodules"
+task "test:package" do
+  ruby File.join(ROOT, "test/integration/packaging_test.rb")
+end
+
+task default: %i[test spec]

data/ext/liblouis/braille_character.c

@@ -0,0 +1,200 @@
+#include "liblouis_ext.h"
+
+typedef struct {
+    uint8_t mask;
+} ll_character_t;
+
+static const rb_data_type_t ll_character_type = {
+    "LibLouis::BrailleCharacter",
+    {0, RUBY_TYPED_DEFAULT_FREE, 0,},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE
+};
+
+static VALUE
+ll_character_alloc(VALUE klass)
+{
+    ll_character_t *character;
+    VALUE object = TypedData_Make_Struct(
+        klass, ll_character_t, &ll_character_type, character);
+
+    character->mask = 0;
+    return object;
+}
+
+static uint8_t
+ll_mask_from_value(VALUE value)
+{
+    if (RB_INTEGER_TYPE_P(value)) {
+        long mask = NUM2LONG(value);
+        if (mask < 0 || mask > 255)
+            rb_raise(rb_eRangeError, "braille mask must be between 0 and 255");
+        return (uint8_t)mask;
+    }
+
+    if (RB_TYPE_P(value, T_ARRAY)) {
+        uint8_t mask = 0;
+        long index;
+        for (index = 0; index < RARRAY_LEN(value); index++) {
+            int dot = NUM2INT(rb_ary_entry(value, index));
+            if (dot < 1 || dot > 8)
+                rb_raise(rb_eRangeError, "braille dot must be between 1 and 8");
+            mask |= (uint8_t)(1u << (dot - 1));
+        }
+        return mask;
+    }
+
+    if (RB_TYPE_P(value, T_STRING)) {
+        int length;
+        VALUE storage = ll_wide_storage_from_string(value, &length);
+        unsigned int codepoint;
+
+        if (length != 1)
+            rb_raise(rb_eArgError, "expected exactly one Unicode braille character");
+        codepoint = (unsigned int)LL_PTR(widechar, storage)[0];
+        if (codepoint < 0x2800 || codepoint > 0x28ff)
+            rb_raise(rb_eArgError, "expected a character in the Unicode braille block");
+        return (uint8_t)(codepoint - 0x2800);
+    }
+
+    rb_raise(rb_eTypeError, "expected an Integer mask, an Array of dots, or a Unicode braille character");
+    return 0;
+}
+
+static VALUE
+ll_character_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE value = INT2FIX(0);
+    uint8_t mask;
+    ll_character_t *character;
+
+    rb_check_frozen(self);
+    rb_scan_args(argc, argv, "01", &value);
+    TypedData_Get_Struct(self, ll_character_t, &ll_character_type, character);
+    mask = ll_mask_from_value(value);
+    rb_check_frozen(self);
+    character->mask = mask;
+    rb_obj_freeze(self);
+    return self;
+}
+
+static VALUE
+ll_character_initialize_copy(VALUE self, VALUE source)
+{
+    ll_character_t *character;
+
+    if (self == source)
+        return self;
+    rb_obj_init_copy(self, source);
+    rb_check_frozen(self);
+    TypedData_Get_Struct(self, ll_character_t, &ll_character_type, character);
+    character->mask = ll_character_mask(source);
+    return self;
+}
+
+VALUE
+ll_character_new(uint8_t mask)
+{
+    ll_character_t *character;
+    VALUE object = TypedData_Make_Struct(ll_cBrailleCharacter, ll_character_t,
+                                         &ll_character_type, character);
+    character->mask = mask;
+    rb_obj_freeze(object);
+    return object;
+}
+
+uint8_t
+ll_character_mask(VALUE object)
+{
+    ll_character_t *character;
+
+    TypedData_Get_Struct(object, ll_character_t, &ll_character_type, character);
+    return character->mask;
+}
+
+static VALUE
+ll_character_dots(VALUE self)
+{
+    uint8_t mask = ll_character_mask(self);
+    VALUE dots = rb_ary_new_capa(8);
+    int dot;
+
+    for (dot = 1; dot <= 8; dot++)
+        if (mask & (1u << (dot - 1)))
+            rb_ary_push(dots, INT2FIX(dot));
+    return dots;
+}
+
+static VALUE
+ll_character_mask_value(VALUE self)
+{
+    return UINT2NUM(ll_character_mask(self));
+}
+
+static VALUE
+ll_character_unicode(VALUE self)
+{
+    return rb_enc_uint_chr(0x2800u + ll_character_mask(self), rb_utf8_encoding());
+}
+
+static VALUE
+ll_character_equal(VALUE self, VALUE other)
+{
+    if (!rb_typeddata_is_kind_of(other, &ll_character_type))
+        return Qfalse;
+    return ll_character_mask(self) == ll_character_mask(other) ? Qtrue : Qfalse;
+}
+
+static VALUE
+ll_character_hash(VALUE self)
+{
+    return rb_hash(UINT2NUM(ll_character_mask(self)));
+}
+
+static VALUE
+ll_character_inspect(VALUE self)
+{
+    return rb_sprintf("#<LibLouis::BrailleCharacter dots=%+"PRIsVALUE" mask=%u>",
+                      ll_character_dots(self), (unsigned int)ll_character_mask(self));
+}
+
+#define DEFINE_DOT_PREDICATE(number) \
+    static VALUE ll_character_dot##number##_p(VALUE self) \
+    { \
+        return (ll_character_mask(self) & (1u << ((number) - 1))) ? Qtrue : Qfalse; \
+    }
+
+DEFINE_DOT_PREDICATE(1)
+DEFINE_DOT_PREDICATE(2)
+DEFINE_DOT_PREDICATE(3)
+DEFINE_DOT_PREDICATE(4)
+DEFINE_DOT_PREDICATE(5)
+DEFINE_DOT_PREDICATE(6)
+DEFINE_DOT_PREDICATE(7)
+DEFINE_DOT_PREDICATE(8)
+
+void
+ll_init_braille_character(void)
+{
+    ll_cBrailleCharacter = rb_define_class_under(ll_mLibLouis, "BrailleCharacter", rb_cObject);
+    rb_define_alloc_func(ll_cBrailleCharacter, ll_character_alloc);
+    rb_define_method(ll_cBrailleCharacter, "initialize", ll_character_initialize, -1);
+    rb_define_method(ll_cBrailleCharacter, "initialize_copy", ll_character_initialize_copy, 1);
+    rb_define_method(ll_cBrailleCharacter, "dots", ll_character_dots, 0);
+    rb_define_method(ll_cBrailleCharacter, "mask", ll_character_mask_value, 0);
+    rb_define_alias(ll_cBrailleCharacter, "to_i", "mask");
+    rb_define_method(ll_cBrailleCharacter, "unicode_character", ll_character_unicode, 0);
+    rb_define_alias(ll_cBrailleCharacter, "to_s", "unicode_character");
+    rb_define_method(ll_cBrailleCharacter, "==", ll_character_equal, 1);
+    rb_define_method(ll_cBrailleCharacter, "eql?", ll_character_equal, 1);
+    rb_define_method(ll_cBrailleCharacter, "hash", ll_character_hash, 0);
+    rb_define_method(ll_cBrailleCharacter, "inspect", ll_character_inspect, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot1?", ll_character_dot1_p, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot2?", ll_character_dot2_p, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot3?", ll_character_dot3_p, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot4?", ll_character_dot4_p, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot5?", ll_character_dot5_p, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot6?", ll_character_dot6_p, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot7?", ll_character_dot7_p, 0);
+    rb_define_method(ll_cBrailleCharacter, "dot8?", ll_character_dot8_p, 0);
+}

data/ext/liblouis/braille_table.c

@@ -0,0 +1,198 @@
+#include "liblouis_ext.h"
+
+static ID id_file;
+static ID id_display_name_ivar;
+static ID id_display_name;
+
+static VALUE
+ll_table_file(VALUE table)
+{
+    return rb_ivar_get(table, id_file);
+}
+
+const char *
+ll_table_name(VALUE table)
+{
+    VALUE file = ll_table_file(table);
+
+    return StringValueCStr(file);
+}
+
+static VALUE
+ll_table_metadata_value(VALUE file, const char *key)
+{
+    char *metadata = lou_getTableInfo(StringValueCStr(file), key);
+    VALUE result;
+
+    if (!metadata)
+        return Qnil;
+    result = rb_utf8_str_new_cstr(metadata);
+    lou_freeTableInfo(metadata);
+    return result;
+}
+
+static VALUE
+ll_table_display_name(VALUE file, VALUE name)
+{
+    if (NIL_P(name)) {
+        name = strchr(StringValueCStr(file), ',') ? Qnil :
+               ll_table_metadata_value(file, "display-name");
+        if (NIL_P(name))
+            name = rb_funcall(rb_cFile, rb_intern("basename"), 1, file);
+    } else {
+        name = rb_str_dup(StringValue(name));
+        rb_enc_associate(name, rb_utf8_encoding());
+    }
+    return rb_obj_freeze(name);
+}
+
+static VALUE
+ll_table_finish(VALUE table, VALUE file, VALUE display_name)
+{
+    file = ll_table_source_normalize(file);
+    rb_ivar_set(table, id_file, file);
+    rb_ivar_set(table, id_display_name_ivar,
+                ll_table_display_name(file, display_name));
+    return rb_obj_freeze(table);
+}
+
+static VALUE
+ll_table_build(VALUE file)
+{
+    return ll_table_finish(rb_obj_alloc(ll_cBrailleTable), file, Qnil);
+}
+
+static VALUE
+ll_table_initialize(int argc, VALUE *argv, VALUE self)
+{
+    const ID allowed[] = {id_display_name};
+    VALUE file;
+    VALUE keywords = Qnil;
+    VALUE display_name = Qundef;
+
+    rb_scan_args(argc, argv, "1:", &file, &keywords);
+    if (!NIL_P(keywords))
+        rb_get_kwargs(rb_hash_dup(keywords), allowed, 0, 1, &display_name);
+    return ll_table_finish(self, file,
+                           display_name == Qundef ? Qnil : display_name);
+}
+
+static VALUE
+ll_table_inspect(VALUE self)
+{
+    return rb_sprintf(
+        "#<LibLouis::BrailleTable file=%+"PRIsVALUE" display_name=%+"PRIsVALUE">",
+        ll_table_file(self), rb_ivar_get(self, id_display_name_ivar));
+}
+
+static VALUE
+ll_table_metadata(VALUE self, VALUE key)
+{
+    VALUE string = StringValue(key);
+
+    return ll_table_metadata_value(ll_table_file(self), StringValueCStr(string));
+}
+
+static VALUE
+ll_table_valid_p(VALUE self)
+{
+    return lou_checkTable(ll_table_name(self)) ? Qtrue : Qfalse;
+}
+
+static VALUE
+ll_table_compile(VALUE self, VALUE rule)
+{
+    VALUE string = StringValue(rule);
+
+    if (!lou_compileString(ll_table_name(self), StringValueCStr(string)))
+        rb_raise(ll_eError, "could not compile Liblouis rule for table %s",
+                 ll_table_name(self));
+    return self;
+}
+
+static VALUE
+ll_table_emphasis_classes(VALUE self)
+{
+    const char **classes = lou_getEmphClasses(ll_table_name(self));
+    VALUE result = rb_ary_new();
+    int index;
+
+    if (!classes)
+        return result;
+    for (index = 0; classes[index]; index++)
+        rb_ary_push(result, ID2SYM(rb_intern(classes[index])));
+    lou_freeEmphClasses(classes);
+    return result;
+}
+
+static VALUE
+ll_table_list(char **files)
+{
+    VALUE result = rb_ary_new();
+    int index;
+
+    if (!files)
+        return result;
+    for (index = 0; files[index]; index++)
+        rb_ary_push(result, ll_table_build(rb_utf8_str_new_cstr(files[index])));
+    lou_freeTableFiles(files);
+    return result;
+}
+
+static VALUE
+ll_table_all(VALUE owner)
+{
+    (void)owner;
+    return ll_table_list(lou_listTables());
+}
+
+static VALUE
+ll_table_find(VALUE owner, VALUE query)
+{
+    VALUE string = StringValue(query);
+    char *file = lou_findTable(StringValueCStr(string));
+    VALUE result;
+
+    (void)owner;
+    if (!file)
+        return Qnil;
+    result = ll_table_build(rb_utf8_str_new_cstr(file));
+    lou_freeTableFile(file);
+    return result;
+}
+
+static VALUE
+ll_table_find_all(VALUE owner, VALUE query)
+{
+    VALUE string = StringValue(query);
+
+    (void)owner;
+    return ll_table_list(lou_findTables(StringValueCStr(string)));
+}
+
+void
+ll_init_braille_table(void)
+{
+    id_file = rb_intern("@file");
+    id_display_name_ivar = rb_intern("@display_name");
+    id_display_name = rb_intern("display_name");
+
+    ll_cBrailleTable = rb_define_class_under(ll_mLibLouis, "BrailleTable", rb_cObject);
+    rb_define_method(ll_cBrailleTable, "initialize", ll_table_initialize, -1);
+    rb_define_attr(ll_cBrailleTable, "file", 1, 0);
+    rb_define_attr(ll_cBrailleTable, "display_name", 1, 0);
+    rb_define_alias(ll_cBrailleTable, "to_s", "display_name");
+    rb_define_method(ll_cBrailleTable, "inspect", ll_table_inspect, 0);
+    rb_define_method(ll_cBrailleTable, "metadata", ll_table_metadata, 1);
+    rb_define_method(ll_cBrailleTable, "valid?", ll_table_valid_p, 0);
+    rb_define_method(ll_cBrailleTable, "compile", ll_table_compile, 1);
+    rb_define_method(ll_cBrailleTable, "emphasis_classes", ll_table_emphasis_classes, 0);
+    ll_init_translation();
+
+    rb_define_singleton_method(ll_cBrailleTable, "all", ll_table_all, 0);
+    rb_define_singleton_method(ll_cBrailleTable, "find", ll_table_find, 1);
+    rb_define_singleton_method(ll_cBrailleTable, "find_all", ll_table_find_all, 1);
+    rb_define_module_function(ll_mLibLouis, "tables", ll_table_all, 0);
+    rb_define_module_function(ll_mLibLouis, "find_table", ll_table_find, 1);
+    rb_define_module_function(ll_mLibLouis, "find_tables", ll_table_find_all, 1);
+}

data/ext/liblouis/braille_text.c

@@ -0,0 +1,223 @@
+#include "liblouis_ext.h"
+
+static ID id_characters;
+static ID id_input_positions;
+static ID id_output_positions;
+static ID id_cursor_position;
+
+static VALUE
+ll_text_characters(VALUE text)
+{
+    return rb_ivar_get(text, id_characters);
+}
+
+int
+ll_braille_text_p(VALUE value)
+{
+    return rb_obj_is_kind_of(value, ll_cBrailleText);
+}
+
+static VALUE
+ll_text_finish(VALUE text, VALUE characters, VALUE input_positions,
+               VALUE output_positions, VALUE cursor_position)
+{
+    rb_obj_freeze(characters);
+    rb_ivar_set(text, id_characters, characters);
+    rb_ivar_set(text, id_input_positions, input_positions);
+    rb_ivar_set(text, id_output_positions, output_positions);
+    rb_ivar_set(text, id_cursor_position, cursor_position);
+    return rb_obj_freeze(text);
+}
+
+static VALUE
+ll_character_from_input(VALUE input)
+{
+    VALUE argv[] = {input};
+
+    return rb_obj_is_kind_of(input, ll_cBrailleCharacter) ? input :
+           rb_class_new_instance(1, argv, ll_cBrailleCharacter);
+}
+
+static VALUE
+ll_text_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE input = Qnil;
+    VALUE characters = rb_ary_new();
+    long index;
+
+    rb_scan_args(argc, argv, "01", &input);
+    if (RB_TYPE_P(input, T_STRING)) {
+        int length;
+        VALUE storage = ll_wide_storage_from_string(input, &length);
+
+        for (index = 0; index < length; index++) {
+            unsigned int codepoint = LL_PTR(widechar, storage)[index];
+
+            if (codepoint < 0x2800 || codepoint > 0x28ff)
+                rb_raise(rb_eArgError,
+                         "BrailleText strings may contain only Unicode braille characters");
+            rb_ary_push(characters, ll_character_new((uint8_t)(codepoint - 0x2800)));
+        }
+    } else if (!NIL_P(input)) {
+        Check_Type(input, T_ARRAY);
+        for (index = 0; index < RARRAY_LEN(input); index++)
+            rb_ary_push(characters, ll_character_from_input(rb_ary_entry(input, index)));
+    }
+
+    return ll_text_finish(self, characters, Qnil, Qnil, Qnil);
+}
+
+static VALUE
+ll_text_from_dots(VALUE storage, int length, VALUE input_positions,
+                  VALUE output_positions, VALUE cursor_position)
+{
+    VALUE characters = rb_ary_new_capa(length);
+    VALUE text = rb_obj_alloc(ll_cBrailleText);
+    int index;
+
+    for (index = 0; index < length; index++)
+        rb_ary_push(characters,
+                    ll_character_new((uint8_t)(LL_PTR(widechar, storage)[index] & 0xffu)));
+    return ll_text_finish(text, characters, input_positions,
+                          output_positions, cursor_position);
+}
+
+VALUE
+ll_braille_text_from_dot_storage(VALUE storage, int length)
+{
+    return ll_text_from_dots(storage, length, Qnil, Qnil, Qnil);
+}
+
+static VALUE
+ll_position_array(VALUE storage, int length)
+{
+    VALUE positions = rb_ary_new_capa(length);
+    int index;
+
+    for (index = 0; index < length; index++)
+        rb_ary_push(positions, INT2NUM(LL_PTR(int, storage)[index]));
+    return rb_obj_freeze(positions);
+}
+
+VALUE
+ll_braille_text_from_translation(VALUE storage, int length,
+                                 VALUE input_positions_storage,
+                                 VALUE output_positions_storage,
+                                 int input_length, int cursor_given,
+                                 int cursor_position)
+{
+    return ll_text_from_dots(
+        storage, length,
+        ll_position_array(input_positions_storage, length),
+        ll_position_array(output_positions_storage, input_length),
+        cursor_given ? INT2NUM(cursor_position) : Qnil);
+}
+
+VALUE
+ll_braille_text_to_dot_storage(VALUE text, int *length)
+{
+    VALUE characters = ll_text_characters(text);
+    VALUE storage;
+    long index;
+
+    if (RARRAY_LEN(characters) > INT_MAX)
+        rb_raise(rb_eArgError, "BrailleText is too long");
+    *length = (int)RARRAY_LEN(characters);
+    storage = ll_binary_storage((size_t)*length * sizeof(widechar));
+    for (index = 0; index < *length; index++)
+        LL_PTR(widechar, storage)[index] =
+            (widechar)(LOU_DOTS | ll_character_mask(rb_ary_entry(characters, index)));
+    return storage;
+}
+
+static VALUE
+ll_text_unicode(VALUE self)
+{
+    VALUE characters = ll_text_characters(self);
+    VALUE result = rb_enc_str_new(NULL, 0, rb_utf8_encoding());
+    long index;
+
+    for (index = 0; index < RARRAY_LEN(characters); index++)
+        rb_str_buf_append(result, rb_enc_uint_chr(
+            0x2800u + ll_character_mask(rb_ary_entry(characters, index)),
+            rb_utf8_encoding()));
+    return result;
+}
+
+static VALUE
+ll_text_length(VALUE self)
+{
+    return LONG2NUM(RARRAY_LEN(ll_text_characters(self)));
+}
+
+static VALUE
+ll_text_empty_p(VALUE self)
+{
+    return RARRAY_LEN(ll_text_characters(self)) == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE
+ll_text_aref(int argc, VALUE *argv, VALUE self)
+{
+    return rb_ary_aref(argc, argv, ll_text_characters(self));
+}
+
+static VALUE
+ll_text_each(VALUE self)
+{
+    VALUE characters;
+    long index;
+
+    RETURN_ENUMERATOR(self, 0, NULL);
+    characters = ll_text_characters(self);
+    for (index = 0; index < RARRAY_LEN(characters); index++)
+        rb_yield(rb_ary_entry(characters, index));
+    return self;
+}
+
+static VALUE
+ll_text_equal(VALUE self, VALUE other)
+{
+    return ll_braille_text_p(other) &&
+           rb_equal(ll_text_characters(self), ll_text_characters(other)) ? Qtrue : Qfalse;
+}
+
+static VALUE
+ll_text_hash(VALUE self)
+{
+    return rb_hash(ll_text_characters(self));
+}
+
+static VALUE
+ll_text_inspect(VALUE self)
+{
+    return rb_sprintf("#<LibLouis::BrailleText %"PRIsVALUE">", ll_text_unicode(self));
+}
+
+void
+ll_init_braille_text(void)
+{
+    id_characters = rb_intern("@characters");
+    id_input_positions = rb_intern("@input_positions");
+    id_output_positions = rb_intern("@output_positions");
+    id_cursor_position = rb_intern("@cursor_position");
+
+    ll_cBrailleText = rb_define_class_under(ll_mLibLouis, "BrailleText", rb_cObject);
+    rb_include_module(ll_cBrailleText, rb_mEnumerable);
+    rb_define_method(ll_cBrailleText, "initialize", ll_text_initialize, -1);
+    rb_define_attr(ll_cBrailleText, "characters", 1, 0);
+    rb_define_attr(ll_cBrailleText, "input_positions", 1, 0);
+    rb_define_attr(ll_cBrailleText, "output_positions", 1, 0);
+    rb_define_attr(ll_cBrailleText, "cursor_position", 1, 0);
+    rb_define_method(ll_cBrailleText, "unicode_text", ll_text_unicode, 0);
+    rb_define_alias(ll_cBrailleText, "to_s", "unicode_text");
+    rb_define_method(ll_cBrailleText, "length", ll_text_length, 0);
+    rb_define_alias(ll_cBrailleText, "size", "length");
+    rb_define_method(ll_cBrailleText, "empty?", ll_text_empty_p, 0);
+    rb_define_method(ll_cBrailleText, "[]", ll_text_aref, -1);
+    rb_define_method(ll_cBrailleText, "each", ll_text_each, 0);
+    rb_define_method(ll_cBrailleText, "==", ll_text_equal, 1);
+    rb_define_method(ll_cBrailleText, "eql?", ll_text_equal, 1);
+    rb_define_method(ll_cBrailleText, "hash", ll_text_hash, 0);
+    rb_define_method(ll_cBrailleText, "inspect", ll_text_inspect, 0);
+}