liblouis-rb 0.1.0

data/ext/liblouis/translation.c

@@ -0,0 +1,443 @@
+#include "liblouis_ext.h"
+
+#include <stddef.h>
+
+#define LL_ARRAY_LENGTH(array) (sizeof(array) / sizeof((array)[0]))
+
+static ID id_mode;
+static ID id_cursor_position;
+static ID id_typeform;
+static ID id_translated;
+
+typedef struct {
+    const char *name;
+    int value;
+} ll_named_value_t;
+
+static void
+ll_get_keywords(VALUE keywords, const ID *allowed, int count, VALUE *values)
+{
+    int index;
+
+    for (index = 0; index < count; index++)
+        values[index] = Qundef;
+    if (!NIL_P(keywords))
+        rb_get_kwargs(rb_hash_dup(keywords), allowed, 0, count, values);
+}
+
+static int
+ll_named_symbol(VALUE symbol, const ll_named_value_t *named, size_t count,
+                const char *kind, const char **name, int *value)
+{
+    size_t index;
+
+    if (!SYMBOL_P(symbol))
+        rb_raise(rb_eTypeError, "%s entries must be symbols", kind);
+    *name = rb_id2name(SYM2ID(symbol));
+    for (index = 0; index < count; index++) {
+        if (strcmp(*name, named[index].name) != 0)
+            continue;
+        *value = named[index].value;
+        return 1;
+    }
+    return 0;
+}
+
+static formtype
+ll_typeform_symbol(VALUE table, VALUE symbol)
+{
+    static const ll_named_value_t named[] = {
+        {"plain_text", plain_text},
+        {"computer_braille", computer_braille},
+        {"no_translate", no_translate},
+        {"no_contract", no_contract}
+    };
+    const char *name;
+    int value;
+    formtype typeform;
+
+    if (ll_named_symbol(symbol, named, LL_ARRAY_LENGTH(named),
+                        "typeform", &name, &value))
+        return (formtype)value;
+    typeform = lou_getTypeformForEmphClass(ll_table_name(table), name);
+    if (typeform == plain_text)
+        rb_raise(rb_eArgError, "unknown typeform symbol: :%s", name);
+    return typeform;
+}
+
+static formtype
+ll_typeform_value(VALUE table, VALUE value)
+{
+    formtype typeform = plain_text;
+    long index;
+
+    if (SYMBOL_P(value))
+        return ll_typeform_symbol(table, value);
+    if (!RB_TYPE_P(value, T_ARRAY))
+        rb_raise(rb_eTypeError,
+                 "typeform entries must be symbols or arrays of symbols");
+
+    for (index = 0; index < RARRAY_LEN(value); index++)
+        typeform |= ll_typeform_symbol(table, rb_ary_entry(value, index));
+    return typeform;
+}
+
+static VALUE
+ll_typeform_storage(VALUE table, VALUE typeforms, int input_length,
+                    int output_capacity)
+{
+    VALUE storage;
+    long index;
+
+    if (typeforms == Qundef || NIL_P(typeforms))
+        return Qnil;
+    Check_Type(typeforms, T_ARRAY);
+    if (RARRAY_LEN(typeforms) != input_length)
+        rb_raise(rb_eArgError, "typeform length (%ld) must equal input length (%d)",
+                 RARRAY_LEN(typeforms), input_length);
+
+    /* Liblouis writes output-cell markers back into this input buffer. */
+    storage = ll_binary_storage((size_t)output_capacity * sizeof(formtype));
+    for (index = 0; index < input_length; index++)
+        LL_PTR(formtype, storage)[index] =
+            ll_typeform_value(table, rb_ary_entry(typeforms, index));
+    return storage;
+}
+
+static int
+ll_mode_symbol(VALUE symbol, int allowed, const char *direction)
+{
+    static const ll_named_value_t named[] = {
+        {"no_contractions", noContractions},
+        {"computer_braille_at_cursor", compbrlAtCursor},
+        {"computer_braille_before_cursor", compbrlLeftCursor},
+        {"suppress_undefined", noUndefined},
+        {"partial_translation", partialTrans}
+    };
+    const char *name;
+    int mode;
+
+    if (!ll_named_symbol(symbol, named, LL_ARRAY_LENGTH(named),
+                         "mode", &name, &mode))
+        rb_raise(rb_eArgError, "unknown translation mode: :%s", name);
+    if ((mode & allowed) == 0)
+        rb_raise(rb_eArgError, "mode :%s is not available for %s translation",
+                 name, direction);
+    return mode;
+}
+
+static int
+ll_translation_mode(VALUE value, int allowed, const char *direction)
+{
+    int mode = 0;
+    long index;
+
+    if (value == Qundef || NIL_P(value))
+        return 0;
+    if (SYMBOL_P(value))
+        return ll_mode_symbol(value, allowed, direction);
+    if (!RB_TYPE_P(value, T_ARRAY))
+        rb_raise(rb_eTypeError, "mode must be a symbol or an array of symbols");
+    for (index = 0; index < RARRAY_LEN(value); index++)
+        mode |= ll_mode_symbol(rb_ary_entry(value, index), allowed, direction);
+    return mode;
+}
+
+static int
+ll_max_output_capacity(void)
+{
+    size_t maximum = (size_t)LONG_MAX / sizeof(widechar) - 1;
+
+    if (maximum > (size_t)INT_MAX - 1)
+        maximum = (size_t)INT_MAX - 1;
+    return (int)maximum;
+}
+
+static int
+ll_output_capacity(int input_length)
+{
+    if (input_length > (ll_max_output_capacity() - 16) / 12)
+        rb_raise(rb_eArgError, "input is too long");
+    return input_length * 12 + 16;
+}
+
+static int
+ll_larger_output_capacity(int capacity)
+{
+    int maximum = ll_max_output_capacity();
+
+    if (capacity >= maximum)
+        rb_raise(ll_eTranslationError, "translation output is too long");
+    return capacity > maximum / 2 ? maximum : capacity * 2;
+}
+
+static void
+ll_check_translation_input(VALUE storage, int length)
+{
+    int index;
+
+    /* Liblouis treats NUL as the end of input, even with an explicit length. */
+    for (index = 0; index < length; index++)
+        if (LL_PTR(widechar, storage)[index] == 0)
+            rb_raise(rb_eArgError, "translation input must not contain NUL characters");
+}
+
+static int
+ll_unicode_braille_to_dots(VALUE storage, int length)
+{
+    int index;
+
+    if (length == 0)
+        return 0;
+    for (index = 0; index < length; index++) {
+        unsigned int codepoint = LL_PTR(widechar, storage)[index];
+
+        if (codepoint < 0x2800 || codepoint > 0x28ff)
+            return 0;
+    }
+    for (index = 0; index < length; index++)
+        LL_PTR(widechar, storage)[index] =
+            (widechar)(LOU_DOTS | (LL_PTR(widechar, storage)[index] - 0x2800u));
+    return 1;
+}
+
+static VALUE
+ll_back_input_storage(VALUE input, int *length, int *dots_io)
+{
+    VALUE storage;
+
+    if (ll_braille_text_p(input)) {
+        if (dots_io)
+            *dots_io = 1;
+        return ll_braille_text_to_dot_storage(input, length);
+    }
+    if (rb_obj_is_kind_of(input, ll_cBrailleCharacter)) {
+        storage = ll_binary_storage(sizeof(widechar));
+        LL_PTR(widechar, storage)[0] =
+            (widechar)(LOU_DOTS | ll_character_mask(input));
+        *length = 1;
+        if (dots_io)
+            *dots_io = 1;
+        return storage;
+    }
+
+    storage = ll_wide_storage_from_string(input, length);
+    if (dots_io)
+        *dots_io = ll_unicode_braille_to_dots(storage, *length);
+    else
+        ll_unicode_braille_to_dots(storage, *length);
+    return storage;
+}
+
+static VALUE
+ll_table_translate(int argc, VALUE *argv, VALUE self)
+{
+    const ID allowed[] = {id_mode, id_cursor_position, id_typeform};
+    const int allowed_modes = noContractions | compbrlAtCursor |
+                              compbrlLeftCursor | noUndefined;
+    VALUE input;
+    VALUE keywords = Qnil;
+    VALUE values[3];
+    VALUE input_storage;
+    VALUE output_storage;
+    VALUE typeform_storage;
+    VALUE input_positions_storage;
+    VALUE output_positions_storage;
+    VALUE dots_storage;
+    int input_length;
+    int translated_input_length;
+    int output_length;
+    int output_capacity;
+    int cursor_given;
+    int cursor_position = 0;
+    int input_cursor_position;
+    int mode;
+
+    rb_scan_args(argc, argv, "1:", &input, &keywords);
+    input_storage = ll_wide_storage_from_string(input, &input_length);
+    ll_check_translation_input(input_storage, input_length);
+    ll_get_keywords(keywords, allowed, 3, values);
+    mode = ll_translation_mode(values[0], allowed_modes, "forward");
+
+    cursor_given = values[1] != Qundef && !NIL_P(values[1]);
+    if (cursor_given) {
+        cursor_position = NUM2INT(values[1]);
+        if (cursor_position < 0 || cursor_position > input_length)
+            rb_raise(rb_eRangeError,
+                     "cursor_position must be between 0 and the input length");
+    }
+    if ((mode & (compbrlAtCursor | compbrlLeftCursor)) && !cursor_given)
+        rb_raise(rb_eArgError,
+                 "computer-braille cursor modes require cursor_position");
+
+    input_cursor_position = cursor_position;
+    output_capacity = ll_output_capacity(input_length);
+    for (;;) {
+        /* Liblouis changes lengths, cursor and typeforms on every attempt. */
+        typeform_storage = ll_typeform_storage(self, values[2], input_length,
+                                               output_capacity);
+        output_storage = ll_binary_storage((size_t)output_capacity * sizeof(widechar));
+        input_positions_storage = ll_binary_storage(
+            (size_t)output_capacity * sizeof(int));
+        output_positions_storage = ll_binary_storage(
+            (size_t)(input_length + 1) * sizeof(int));
+
+        translated_input_length = input_length;
+        output_length = output_capacity;
+        cursor_position = input_cursor_position;
+        if (!lou_translate(
+                ll_table_name(self), LL_PTR(widechar, input_storage),
+                &translated_input_length, LL_PTR(widechar, output_storage), &output_length,
+                NIL_P(typeform_storage) ? NULL : LL_PTR(formtype, typeform_storage),
+                NULL, LL_PTR(int, output_positions_storage),
+                LL_PTR(int, input_positions_storage),
+                cursor_given ? &cursor_position : NULL, mode))
+            rb_raise(ll_eTranslationError, "forward translation failed for table %s",
+                     ll_table_name(self));
+        if (translated_input_length == input_length)
+            break;
+        output_capacity = ll_larger_output_capacity(output_capacity);
+    }
+
+    dots_storage = ll_binary_storage((size_t)output_length * sizeof(widechar));
+    if (output_length > 0 &&
+            !lou_charToDots(ll_table_name(self), LL_PTR(widechar, output_storage),
+                            LL_PTR(widechar, dots_storage), output_length, mode))
+        rb_raise(ll_eTranslationError,
+                 "could not convert translated cells to dots for table %s",
+                 ll_table_name(self));
+
+    return ll_braille_text_from_translation(
+        dots_storage, output_length, input_positions_storage,
+        output_positions_storage, translated_input_length,
+        cursor_given, cursor_position);
+}
+
+static VALUE
+ll_table_back_translate(int argc, VALUE *argv, VALUE self)
+{
+    const ID allowed[] = {id_mode};
+    VALUE input;
+    VALUE keywords = Qnil;
+    VALUE values[1];
+    VALUE input_storage;
+    VALUE output_storage;
+    int input_length;
+    int translated_input_length;
+    int output_length;
+    int dots_io = 0;
+    int output_capacity;
+    int mode;
+
+    rb_scan_args(argc, argv, "1:", &input, &keywords);
+    input_storage = ll_back_input_storage(input, &input_length, &dots_io);
+    ll_check_translation_input(input_storage, input_length);
+    ll_get_keywords(keywords, allowed, 1, values);
+    mode = ll_translation_mode(values[0], noUndefined | partialTrans, "back");
+    if (dots_io)
+        mode |= dotsIO;
+
+    output_capacity = ll_output_capacity(input_length);
+    for (;;) {
+        translated_input_length = input_length;
+        output_length = output_capacity;
+        output_storage = ll_binary_storage((size_t)output_capacity * sizeof(widechar));
+        if (!lou_backTranslate(
+                ll_table_name(self), LL_PTR(widechar, input_storage),
+                &translated_input_length, LL_PTR(widechar, output_storage), &output_length,
+                NULL, NULL, NULL, NULL, NULL, mode))
+            rb_raise(ll_eTranslationError, "back translation failed for table %s",
+                     ll_table_name(self));
+        if (translated_input_length == input_length)
+            break;
+        output_capacity = ll_larger_output_capacity(output_capacity);
+    }
+    return ll_string_from_wide_storage(output_storage, output_length);
+}
+
+static VALUE
+ll_table_hyphenate(int argc, VALUE *argv, VALUE self)
+{
+    const ID allowed[] = {id_translated};
+    VALUE input;
+    VALUE keywords = Qnil;
+    VALUE values[1];
+    VALUE input_storage;
+    VALUE hyphens;
+    int input_length;
+    int mode;
+
+    rb_scan_args(argc, argv, "1:", &input, &keywords);
+    ll_get_keywords(keywords, allowed, 1, values);
+    if (values[0] == Qundef || NIL_P(values[0]) || values[0] == Qfalse)
+        mode = 0;
+    else if (values[0] == Qtrue)
+        mode = 1;
+    else
+        rb_raise(rb_eTypeError, "translated must be true or false");
+
+    input_storage = ll_wide_storage_from_string(input, &input_length);
+    hyphens = ll_binary_storage((size_t)input_length + 1);
+    if (!lou_hyphenate(ll_table_name(self), LL_PTR(widechar, input_storage),
+                       input_length, RSTRING_PTR(hyphens), mode))
+        rb_raise(ll_eTranslationError, "hyphenation failed for table %s",
+                 ll_table_name(self));
+    rb_str_resize(hyphens, input_length);
+    rb_enc_associate(hyphens, rb_usascii_encoding());
+    return hyphens;
+}
+
+static VALUE
+ll_table_characters_to_dots(VALUE self, VALUE input)
+{
+    VALUE input_storage;
+    VALUE output_storage;
+    int length;
+
+    input_storage = ll_wide_storage_from_string(input, &length);
+    output_storage = ll_binary_storage((size_t)length * sizeof(widechar));
+    if (length > 0 &&
+            !lou_charToDots(ll_table_name(self), LL_PTR(widechar, input_storage),
+                            LL_PTR(widechar, output_storage), length, 0))
+        rb_raise(ll_eTranslationError,
+                 "character-to-dots conversion failed for table %s",
+                 ll_table_name(self));
+    return ll_braille_text_from_dot_storage(output_storage, length);
+}
+
+static VALUE
+ll_table_dots_to_characters(VALUE self, VALUE input)
+{
+    VALUE input_storage;
+    VALUE output_storage;
+    int length;
+
+    input_storage = ll_back_input_storage(input, &length, NULL);
+    output_storage = ll_binary_storage((size_t)length * sizeof(widechar));
+    if (length > 0 &&
+            !lou_dotsToChar(ll_table_name(self), LL_PTR(widechar, input_storage),
+                            LL_PTR(widechar, output_storage), length, 0))
+        rb_raise(ll_eTranslationError,
+                 "dots-to-character conversion failed for table %s",
+                 ll_table_name(self));
+    return ll_string_from_wide_storage(output_storage, length);
+}
+
+void
+ll_init_translation(void)
+{
+    id_mode = rb_intern("mode");
+    id_cursor_position = rb_intern("cursor_position");
+    id_typeform = rb_intern("typeform");
+    id_translated = rb_intern("translated");
+
+    rb_define_method(ll_cBrailleTable, "translate", ll_table_translate, -1);
+    rb_define_alias(ll_cBrailleTable, "get_braille", "translate");
+    rb_define_method(ll_cBrailleTable, "back_translate", ll_table_back_translate, -1);
+    rb_define_alias(ll_cBrailleTable, "get_text", "back_translate");
+    rb_define_method(ll_cBrailleTable, "hyphenate", ll_table_hyphenate, -1);
+    rb_define_method(ll_cBrailleTable, "characters_to_dots",
+                     ll_table_characters_to_dots, 1);
+    rb_define_method(ll_cBrailleTable, "dots_to_characters",
+                     ll_table_dots_to_characters, 1);
+}

data/liblouis-rb.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+vendor_root = File.expand_path("vendor/liblouis", __dir__)
+unless File.file?(File.join(vendor_root, "liblouis/liblouis.h.in")) &&
+       File.file?(File.join(vendor_root, "configure.ac")) &&
+       Dir.exist?(File.join(vendor_root, "tables"))
+  raise "Liblouis sources are missing. Run: git submodule update --init --recursive"
+end
+
+Gem::Specification.new do |spec|
+  spec.name = "liblouis-rb"
+  spec.version = "0.1.0"
+  spec.authors = ["Dawid Pieper", "liblouis contributors"]
+  spec.summary = "Native Ruby bindings for Liblouis"
+  spec.description = <<~DESCRIPTION.strip
+    A single native Ruby extension that embeds Liblouis library, allowing translations from and to Braille notation.
+  DESCRIPTION
+  spec.licenses = ["LGPL-2.1-or-later"]
+  spec.required_ruby_version = ">= 3.1"
+  spec.email = ["dawidpieper@o2.pl"]
+  spec.homepage = "https://github.com/dawidpieper/liblouis-rb"
+
+  extension_files = %w[
+    ext/liblouis/extconf.rb
+    ext/liblouis/liblouis_ext.h
+    ext/liblouis/liblouis.c
+    ext/liblouis/braille_character.c
+    ext/liblouis/braille_text.c
+    ext/liblouis/braille_table.c
+    ext/liblouis/translation.c
+    ext/liblouis/table_source.c
+  ]
+  vendor_files = Dir[
+    "vendor/liblouis/liblouis/*.{c,h,h.in}",
+    "vendor/liblouis/tables/**/*",
+    "vendor/liblouis/configure.ac",
+    "vendor/liblouis/COPYING*"
+  ].select { |file| File.file?(file) }
+  test_files = Dir["test/**/*.rb", "spec/**/*.rb"]
+
+  spec.files = extension_files + vendor_files + test_files + %w[
+    README.md
+    LICENSE
+    liblouis-rb.gemspec
+    Rakefile
+  ]
+  spec.extensions = ["ext/liblouis/extconf.rb"]
+  spec.require_paths = ["lib"]
+end

data/spec/liblouis_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+
+$LOAD_PATH.unshift(File.expand_path("../ext/liblouis", __dir__))
+require "liblouis"
+require_relative "../test/translation_cases"
+require_relative "../test/table_source_cases"
+require "stringio"
+
+describe LibLouis do
+  it "translates the requested regression corpus" do
+    TranslationCases::CASES.each do |test_case|
+      table = LibLouis::BrailleTable.new(test_case[:table])
+      braille = table.translate(test_case[:source])
+
+      _(braille).must_be_instance_of LibLouis::BrailleText
+      _(braille.to_s).must_equal test_case[:braille]
+    end
+  end
+
+  it "round-trips the bidirectional requested tables" do
+    TranslationCases::CASES.each do |test_case|
+      next unless test_case.key?(:back_translation)
+
+      table = LibLouis::BrailleTable.new(test_case[:table])
+      braille = table.translate(test_case[:source])
+
+      _(table.back_translate(braille)).must_equal test_case[:back_translation]
+    end
+  end
+
+  it "exposes eight-dot cells without a Ruby implementation layer" do
+    cell = LibLouis::BrailleCharacter.new(255)
+
+    _(cell.dots).must_equal((1..8).to_a)
+    _(cell.unicode_character).must_equal "⣿"
+  end
+
+  it "accepts IO sources inside a table list" do
+    source = StringIO.new(TableSourceCases::CUSTOM_TABLE)
+    table = LibLouis::BrailleTable.new([source])
+
+    _(table).must_be :valid?
+    _(table.translate("a").to_s).must_equal "⠿"
+  end
+
+  it "uses semantic symbols for typeforms" do
+    table = LibLouis::BrailleTable.new("en-GB-g2.ctb")
+    text = "Test"
+
+    _(table.emphasis_classes).must_include :italic
+    _(table.translate(text, typeform: Array.new(text.length, :plain_text)))
+      .must_be_instance_of LibLouis::BrailleText
+  end
+
+  it "uses semantic symbols for translation modes" do
+    table = LibLouis::BrailleTable.new("en-GB-g2.ctb")
+
+    _(table.translate("the", mode: :no_contractions).to_s).must_equal "⠞⠓⠑"
+  end
+end

data/test/integration/packaging_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "fileutils"
+require "open3"
+require "rbconfig"
+require "rubygems/package"
+require "tmpdir"
+
+class PackagingTest < Minitest::Test
+  ROOT = File.expand_path("../..", __dir__)
+  PACKAGE_ROOT = File.join(ROOT, "pkg")
+
+  def test_gem_installs_in_a_path_with_spaces_without_submodule_metadata
+    with_package_directory do |directory|
+      gem_path = File.join(directory, "liblouis-rb.gem")
+      run_ruby("-S", "gem", "build", "liblouis-rb.gemspec", "--output", gem_path)
+      package = Gem::Package.new(gem_path)
+      package.verify
+      %w[configure.ac COPYING COPYING.LESSER liblouis/liblouis.h.in tables/en-gb-comp8.ctb].each do |file|
+        assert_includes package.spec.files, "vendor/liblouis/#{file}"
+      end
+      refute package.spec.files.any? { |file| file.split("/").include?(".git") || file.end_with?(".gitmodules") }
+
+      install_dir = File.join(directory, "gem home")
+      run_ruby("-S", "gem", "install", gem_path, "--local", "--no-document",
+               "--ignore-dependencies", "--no-user-install",
+               "--install-dir", install_dir, "--bindir", File.join(directory, "bin"))
+      smoke_test = <<~'CODE'
+        Gem.use_paths(ARGV.fetch(0), [ARGV.fetch(0)])
+        require "liblouis"
+        installed = Gem.loaded_specs.fetch("liblouis-rb").full_gem_path
+        abort "Git metadata was packaged" if File.exist?(File.join(installed, ".git"))
+        table = LibLouis::BrailleTable.new("en-gb-comp8.ctb")
+        abort "Bundled tables failed" unless table.back_translate(table.translate("hello")) == "hello"
+        abort "Copy lost its mask" unless LibLouis::BrailleCharacter.new(137).dup.mask == 137
+        puts LibLouis.version
+      CODE
+      expected_version = File.read(File.join(ROOT, "vendor/liblouis/configure.ac"))[
+        /AC_INIT\(\[Liblouis\],\s*\[([0-9.]+)\]/, 1
+      ]
+      assert_equal expected_version, run_ruby("-e", smoke_test, install_dir, chdir: directory).strip
+    end
+  end
+
+  def test_missing_submodule_stops_packaging_and_compilation_with_instructions
+    with_package_directory do |directory|
+      FileUtils.cp(File.join(ROOT, "liblouis-rb.gemspec"), directory)
+      extension_dir = File.join(directory, "ext/liblouis")
+      FileUtils.mkdir_p(extension_dir)
+      FileUtils.cp(File.join(ROOT, "ext/liblouis/extconf.rb"), extension_dir)
+      commands = [
+        [directory, ["-S", "gem", "build", "liblouis-rb.gemspec"]],
+        [extension_dir, ["extconf.rb"]]
+      ]
+      commands.each do |working_dir, arguments|
+        output, status = Open3.capture2e(RbConfig.ruby, *arguments, chdir: working_dir)
+        refute status.success?, output
+        assert_includes output, "git submodule update --init --recursive"
+      end
+      assert_empty Dir[File.join(directory, "*.gem")]
+    end
+  end
+
+  private
+
+  def run_ruby(*arguments, chdir: ROOT)
+    output, status = Open3.capture2e(RbConfig.ruby, *arguments, chdir: chdir)
+    assert status.success?, output
+    output
+  end
+
+  def with_package_directory
+    FileUtils.mkdir_p(PACKAGE_ROOT)
+    Dir.mktmpdir("package-test ", PACKAGE_ROOT) do |directory|
+      unless File.realpath(directory).start_with?(File.realpath(PACKAGE_ROOT) + "/")
+        raise "Unexpected package test directory"
+      end
+      yield directory
+    end
+  end
+end

data/test/table_source_cases.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module TableSourceCases
+  CUSTOM_TABLE = <<~'TABLE'.freeze
+    #-display-name: Custom table source
+    space \s 0
+    lowercase a 123456
+  TABLE
+end