rb-readline-r7 0.5.2.0

data/test/support/filesystem_completion_helper.rb

@@ -0,0 +1,53 @@
+require "fileutils"
+
+module FilesystemCompletionHelper
+  SEP = File::SEPARATOR
+  COMP_TEST_DIR = "comp_test#{SEP}"
+  SUB_DIR = "#{COMP_TEST_DIR}a_sub_dir#{SEP}"
+  SUB_SUB_DIR = "#{SUB_DIR}another_sub_dir#{SEP}"
+  DIR_WITH_SPACES = "#{COMP_TEST_DIR}dir with spaces#{SEP}"
+  SUB_DIR_WITH_SPACES = "#{DIR_WITH_SPACES}sub dir with spaces#{SEP}"
+
+  # This creates:
+  #
+  #   comp_test/
+  #     abc
+  #     aaa
+  #     a_sub_dir/
+  #       abc
+  #       aaa
+  #       another_sub_dir/
+  #         aaa
+  #     dir with spaces/
+  #       filename with spaces
+  #       sub dir with spaces/
+  #         another filename with spaces
+  def setup_filesystem_for_completion
+    FileUtils.mkdir_p("#{SUB_SUB_DIR}")
+    FileUtils.mkdir_p("#{SUB_DIR_WITH_SPACES}")
+    @comp_test_dir = Dir.new COMP_TEST_DIR
+    @sub_dir = Dir.new SUB_DIR
+    @sub_sub_dir = Dir.new SUB_SUB_DIR
+    @dir_with_spaces = Dir.new DIR_WITH_SPACES
+    @sub_dir_with_spaces = Dir.new SUB_DIR_WITH_SPACES
+
+    FileUtils.touch("#{@comp_test_dir.path}abc")
+    FileUtils.touch("#{@comp_test_dir.path}aaa")
+    FileUtils.touch("#{@sub_dir.path}abc")
+    FileUtils.touch("#{@sub_dir.path}aaa")
+    FileUtils.touch("#{@sub_sub_dir.path}aaa")
+    FileUtils.touch("#{@dir_with_spaces.path}filename with spaces")
+    FileUtils.touch("#{@sub_dir_with_spaces.path}another filename with spaces")
+
+    # The previous Dir.new calls seem to cache the dir entries on Windows.
+    @comp_test_dir = Dir.new COMP_TEST_DIR
+    @sub_dir = Dir.new SUB_DIR
+    @sub_sub_dir = Dir.new SUB_SUB_DIR
+    @sub_dir_with_spaces = Dir.new SUB_DIR_WITH_SPACES
+    @dir_with_spaces = Dir.new DIR_WITH_SPACES
+  end
+
+  def teardown_filesystem_after_completion
+    FileUtils.rm_r(COMP_TEST_DIR)
+  end
+end

data/test/test_completion.rb

@@ -0,0 +1,100 @@
+require "minitest/autorun"
+require "readline"
+
+require 'timeout'
+require "support/filesystem_completion_helper"
+
+class TestCompletion < Minitest::Test
+  include RbReadline
+  include FilesystemCompletionHelper
+
+  def filename_quoting_function(filename, mtype, quote_char)
+    quoted_filename = filename.dup
+    @rl_filename_quote_characters.split("").each do |c|
+      quoted_filename.gsub!(c, "\\#{c}")
+    end
+    quoted_filename
+  end
+
+  def filename_dequoting_function(filename, quote_char = "\\")
+    filename.delete quote_char
+  end
+
+  def setup
+    @rl_completion_word_break_hook, @rl_char_is_quoted_p = nil
+    @rl_basic_quote_characters, @rl_special_prefixes = nil
+    @rl_completer_word_break_characters = Readline.basic_word_break_characters
+    @rl_completer_quote_characters = "\\"
+    @rl_completion_quote_character = "\\"
+    @rl_filename_quote_characters = " "
+    @rl_byte_oriented = true
+    @rl_filename_quoting_desired = true
+    @rl_filename_completion_desired = true
+    @rl_complete_with_tilde_expansion = true
+    @_rl_match_hidden_files = false
+    @rl_completion_found_quote = false
+    @_rl_completion_case_fold = false
+    @directory = nil
+
+    @rl_filename_quoting_function = :filename_quoting_function
+    @rl_filename_dequoting_function = :filename_dequoting_function
+    @rl_directory_completion_hook = nil
+
+    setup_filesystem_for_completion
+  end
+
+  def teardown
+    teardown_filesystem_after_completion
+  end
+
+  def set_line_buffer(text)
+    @rl_line_buffer = text
+    @rl_point = @rl_line_buffer.size
+    @rl_line_buffer << 0.chr
+  end
+
+  def test__find_completion_word_doesnt_hang_on_completer_quote_character
+    set_line_buffer "#{@dir_with_spaces.path}filename\\ w"
+
+    Timeout::timeout(3) do
+      assert_equal([ "\000", true, "\000" ], _rl_find_completion_word)
+    end
+  end
+
+  def test__find_completion_word_without_quote_characters
+    set_line_buffer "#{@comp_test_dir.path}a"
+    assert_equal([ "\000", false, "\000" ], _rl_find_completion_word)
+  end
+
+  def test_make_quoted_replacement_calls_filename_quoting_function
+    assert_equal "dir/with\\ space", make_quoted_replacement("dir/with space", RbReadline::SINGLE_MATCH, 0.chr)
+  end
+
+  def test_rl_filname_completion_function_calls_dequoting_function
+    @rl_completion_found_quote = true
+    dir = filename_quoting_function(@dir_with_spaces.path, nil, 0.chr)
+
+    # rl_filename_completion_function is called with an increasing state in
+    # order to iterate through directory entries.
+
+    entries = [ "#{@dir_with_spaces.path}sub dir with spaces", "#{@dir_with_spaces.path}filename with spaces" ]
+
+    assert entries.include?(rl_filename_completion_function(dir, 0))
+    assert entries.include?(rl_filename_completion_function(dir, 1))
+    assert_nil rl_filename_completion_function(dir, 2)
+  ensure
+    @rl_completion_found_quote = false
+  end
+
+  def test_completing_path_starting_dot_slash
+    assert_equal "./#{COMP_TEST_DIR.chop}", rl_filename_completion_function("./#{COMP_TEST_DIR.chop}", 0)
+  end
+
+  def test_completing_non_existant_directory
+    assert_nil rl_filename_completion_function("/this/dir/does/not/exist", 0)
+  end
+
+  def test_completing_a_file_as_a_directory
+    assert_nil rl_filename_completion_function("#{File.expand_path(__FILE__)}/", 0)
+  end
+end

data/test/test_filename_completion_proc.rb

@@ -0,0 +1,88 @@
+require 'minitest/autorun'
+require 'readline'
+
+require 'fileutils'
+require "rbconfig"
+require "support/filesystem_completion_helper"
+
+class TestFilenameCompletionProc < Minitest::Test
+  include FilesystemCompletionHelper
+
+  def setup
+    FileUtils.mkdir_p("#{SUB_SUB_DIR}")
+    FileUtils.mkdir_p("#{SUB_DIR_WITH_SPACES}")
+    @comp_test_dir = Dir.new COMP_TEST_DIR
+    @sub_dir = Dir.new SUB_DIR
+    @sub_sub_dir = Dir.new SUB_SUB_DIR
+    @dir_with_spaces = Dir.new DIR_WITH_SPACES
+    @sub_dir_with_spaces = Dir.new SUB_DIR_WITH_SPACES
+
+    FileUtils.touch("#{@comp_test_dir.path}abc")
+    FileUtils.touch("#{@comp_test_dir.path}aaa")
+    FileUtils.touch("#{@sub_dir.path}abc")
+    FileUtils.touch("#{@sub_dir.path}aaa")
+    FileUtils.touch("#{@sub_sub_dir.path}aaa")
+    FileUtils.touch("#{@dir_with_spaces.path}filename with spaces")
+    FileUtils.touch("#{@sub_dir_with_spaces.path}another filename with spaces")
+
+    # The previous Dir.new calls seem to cache the dir entries on Windows.
+    @comp_test_dir = Dir.new COMP_TEST_DIR
+    @sub_dir = Dir.new SUB_DIR
+    @sub_sub_dir = Dir.new SUB_SUB_DIR
+    @dir_with_spaces = Dir.new DIR_WITH_SPACES
+    @sub_dir_with_spaces = Dir.new SUB_DIR_WITH_SPACES
+    setup_filesystem_for_completion
+  end
+
+  def teardown
+    teardown_filesystem_after_completion
+  end
+
+  def test_listing_files_in_cwd
+    Dir.chdir(COMP_TEST_DIR) do
+      entries = Dir.entries(".").select { |e| e[0,1] == "a" }
+      assert_equal entries, Readline::FILENAME_COMPLETION_PROC.call("a")
+    end
+  end
+
+  def test_list_files_in_sub_directories
+    entries = @sub_dir.entries.select { |e| e[0,1] == "a" }
+    entries.map! { |e| "#{@sub_dir.path}#{e}" }
+    assert_equal entries, Readline::FILENAME_COMPLETION_PROC.call("#{@sub_dir.path}a")
+
+    entries = @sub_sub_dir.entries - %w( . .. )
+    entries.map! { |e| "#{@sub_sub_dir.path}#{e}" }
+    assert_equal entries, Readline::FILENAME_COMPLETION_PROC.call("#{@sub_sub_dir.path}")
+  end
+
+  def test_list_files_and_directories_with_spaces
+    entries = @comp_test_dir.entries.select { |e| e[0,1] == "d" }
+    entries.map! { |e| @comp_test_dir.path + e }
+    assert_equal entries, Readline::FILENAME_COMPLETION_PROC.call("#{@comp_test_dir.path}d")
+
+    entries = @dir_with_spaces.entries - %w( . .. )
+    entries.map! { |e| @dir_with_spaces.path + e }
+    assert_equal entries, Readline::FILENAME_COMPLETION_PROC.call("#{@dir_with_spaces.path}")
+  end
+
+  def test_list_files_in_current_directory
+    assert_equal((Dir.entries(".") - %w( . .. )).sort, Readline::FILENAME_COMPLETION_PROC.call("").sort)
+  end
+
+  def test_listing_files_with_no_read_access
+    FileUtils.mkdir("test_no_access")
+    FileUtils.touch("test_no_access/123")
+
+    skip "chmod is noop in Windows" if windows?
+
+    FileUtils.chmod(0333, "test_no_access")
+    assert_nil Readline::FILENAME_COMPLETION_PROC.call("test_no_access/")
+  ensure
+    FileUtils.chmod(0775, "test_no_access")
+    FileUtils.rm_r("test_no_access")
+  end
+
+  def windows?
+    RbConfig::CONFIG["host_os"] =~ /mingw|mswin/
+  end
+end

data/test/test_history.rb

@@ -0,0 +1,29 @@
+require "minitest/autorun"
+require "readline"
+
+class TestHistory < Minitest::Test
+
+  # RbReadline::HISTORY_WORD_DELIMITERS.inspect
+  # => " \t\n;&()|<>"
+  # RbReadline::HISTORY_QUOTE_CHARACTERS   = "\"'`"
+  # => "\"'`"
+  def test_history_arg_extract
+    assert_raises(RuntimeError) { RbReadline.history_arg_extract("!", "$", "one two three") }
+    assert_raises(RuntimeError) { RbReadline.history_arg_extract("$", "!", "one two three") }
+
+    assert_equal "one", RbReadline.history_arg_extract("$", "$", "one")
+    assert_equal "three", RbReadline.history_arg_extract("$", "$", "one two three")
+    assert_equal "two\\ three", RbReadline.history_arg_extract("$", "$", "one two\\ three")
+    assert_equal "three", RbReadline.history_arg_extract("$", "$", "one two;three")
+    assert_equal "two\\;three", RbReadline.history_arg_extract("$", "$", "one two\\;three")
+
+    assert_equal "'two three'", RbReadline.history_arg_extract("$", "$", "one 'two three'")
+    assert_equal "`two three`", RbReadline.history_arg_extract("$", "$", "one `two three`")
+    assert_equal "three\\'", RbReadline.history_arg_extract("$", "$", "one \\'two three\\'")
+    assert_equal "`one`", RbReadline.history_arg_extract("$", "$", "`one`")
+
+    assert_equal "three'", RbReadline.history_arg_extract("$", "$", "one two three'")
+    assert_equal "three", RbReadline.history_arg_extract("$", "$", "one two' three")
+    assert_equal "'two three '", RbReadline.history_arg_extract("$", "$", "one 'two three '")
+  end
+end

data/test/test_rbreadline.rb

@@ -0,0 +1,23 @@
+require 'minitest/autorun'
+require 'rbreadline'
+
+class TestRbReadline < Minitest::Test
+  def test_versions
+    assert_equal('5.2', RbReadline::RL_LIBRARY_VERSION)
+    assert_equal(0x0502, RbReadline::RL_READLINE_VERSION)
+  end
+
+  def test_rl_adjust_point
+    encoding_name = RbReadline.instance_variable_get(:@encoding_name)
+    RbReadline.instance_variable_set(:@encoding_name, Encoding.find('UTF-8'))
+
+    assert_equal(0, RbReadline._rl_adjust_point("a".force_encoding('ASCII-8BIT'), 0))
+    assert_equal(0, RbReadline._rl_adjust_point("a".force_encoding('ASCII-8BIT'), 1))
+    assert_equal(0, RbReadline._rl_adjust_point(("a" * 40).force_encoding('ASCII-8BIT'), 0))
+    assert_equal(0, RbReadline._rl_adjust_point(("a" * 40).force_encoding('ASCII-8BIT'), 40))
+    assert_equal(2, RbReadline._rl_adjust_point(("\u3042" * 10).force_encoding('ASCII-8BIT'), 1))
+    assert_equal(1, RbReadline._rl_adjust_point(("\u3042" * 15).force_encoding('ASCII-8BIT'), 38))
+  ensure
+    RbReadline.instance_variable_set(:@encoding_name, encoding_name)
+  end if defined?(Encoding)
+end

data/test/test_readline.rb

@@ -0,0 +1,221 @@
+require 'minitest/autorun'
+require 'readline'
+
+class TestReadline < Minitest::Test
+  def setup
+    @proc = proc{ |s| ['alpha', 'beta'].grep( /^#{Regexp.escape(s)}/) }
+  end
+
+  def test_version
+    assert_equal('5.2', Readline::VERSION)
+  end
+
+  def test_readline_basic
+    assert_respond_to(Readline, :readline)
+  end
+
+  def test_readline_with_default_parameters_does_not_error
+    thread = Thread.new { Readline.readline }
+    sleep 0.1
+    assert thread.alive?
+  ensure
+    thread.kill
+  end
+
+  def test_input_basic
+    assert_respond_to(Readline, :input=)
+  end
+
+  def test_input
+    Readline.input = $stdin
+    assert_equal $stdin, RbReadline.rl_instream
+  end
+
+  def test_output_basic
+    assert_respond_to(Readline, :output=)
+  end
+
+  def test_output
+    Readline.output = $stdout
+    assert_equal $stdout, RbReadline.rl_outstream
+  end
+
+  def test_completion_proc_get_basic
+    assert_respond_to(Readline, :completion_proc)
+  end
+
+  def test_completion_proc_set_basic
+    assert_respond_to(Readline, :completion_proc=)
+  end
+
+  def test_completion_proc
+    Readline.completion_proc = @proc
+    assert_equal @proc, Readline.completion_proc
+  end
+
+  def test_completion_case_fold_get_basic
+    assert_respond_to(Readline, :completion_case_fold)
+  end
+
+  def test_completion_case_fold_default
+    assert_equal(false, Readline.completion_case_fold) # default
+  end
+
+  def test_completion_case_fold_set_basic
+    assert_respond_to(Readline, :completion_case_fold=)
+  end
+
+  def test_completion_case_fold_changed
+    Readline.completion_case_fold = false
+    refute Readline.completion_case_fold
+  end
+
+  def test_completion_proc_expected_errors
+    assert_raises(ArgumentError) { Readline.completion_proc = 1 }
+    assert_raises(ArgumentError) { Readline.completion_proc = 'a' }
+  end
+
+  def test_vi_editing_mode_basic
+    assert_respond_to(Readline, :vi_editing_mode)
+  end
+
+  def test_emacs_editing_mode_basic
+    assert_respond_to(Readline, :emacs_editing_mode)
+  end
+
+  def test_completion_append_character_get_basic
+    assert_respond_to(Readline, :completion_append_character)
+  end
+
+  def test_completion_append_character_get
+    assert_equal(' ', Readline.completion_append_character) # default
+  end
+
+  def test_completion_append_character_set_basic
+    assert_respond_to(Readline, :completion_append_character=)
+  end
+
+  def test_completion_append_character_set
+    assert_equal " ", Readline.completion_append_character
+  end
+
+  def test_completion_append_character
+    orig_char = Readline.completion_append_character
+    begin
+      [
+        [ "x", "x" ],
+        [ "xyx", "x" ],
+        [ " ", " " ],
+        [ "\t", "\t" ],
+        [ "", nil ],
+      ].each do |data, expected|
+        Readline.completion_append_character = data
+        assert_equal(expected, Readline.completion_append_character,
+          "failed case: [#{data.inspect}, #{expected.inspect}]")
+      end
+    ensure
+      Readline.completion_append_character = orig_char
+    end
+  end
+
+  def test_basic_word_break_characters_get_basic
+    assert_respond_to(Readline, :basic_word_break_characters)
+  end
+
+  def test_basic_word_break_characters_get
+    assert_equal(" \t\n\"\\'`@$><=|&{(", Readline.basic_word_break_characters)
+  end
+
+  def test_basic_word_break_characters_set_basic
+    assert_respond_to(Readline, :basic_word_break_characters=)
+  end
+
+  def test_basic_word_break_characters_set
+    chars = " \t\n\"\\'`@$><=|&{("
+    Readline.basic_word_break_characters = chars
+    assert_equal chars, Readline.basic_word_break_characters
+  end
+
+  def test_basic_quote_characters_get_basic
+    assert_respond_to(Readline, :basic_quote_characters)
+  end
+
+  def test_basic_quote_characters_get
+    assert_equal "\"'", Readline.basic_quote_characters
+  end
+
+  def test_basic_quote_characters_set_basic
+    assert_respond_to(Readline, :basic_quote_characters=)
+  end
+
+  def test_basic_quote_characters_set
+    chars = "\"'"
+    Readline.basic_quote_characters = chars
+    assert_equal chars, Readline.basic_quote_characters
+  end
+
+  def test_some_character_methods
+    expecteds = [ " ", " .,|\t", "" ]
+    [
+      :basic_word_break_characters,
+      :completer_word_break_characters,
+      :basic_quote_characters,
+      :completer_quote_characters,
+      :filename_quote_characters,
+    ].each do |method|
+      begin
+        saved = Readline.send(method)
+        expecteds.each do |e|
+          Readline.send("#{method}=".to_sym, e)
+          assert_equal(e, Readline.send(method),
+            "failed case #{e.inspect} for method #{method}")
+        end
+      ensure
+        Readline.send("#{method}=".to_sym, saved) if saved
+      end
+    end
+  end
+
+  def test_attempted_comp_func_returns_nil_when_no_completion_proc_set
+    assert_equal nil, Readline.readline_attempted_completion_function("12", 0, 1)
+  end
+
+  def test_attempted_comp_func_case_folding
+    Readline.completion_proc = Proc.new do |word|
+       %w( 123456 123abc abc123 ).grep(/^#{word}/i)
+    end
+
+    Readline.completion_case_fold = true
+
+    assert_equal [ "123", "123456", "123abc", nil ], Readline.readline_attempted_completion_function("123", 0, 3)
+
+    assert_equal [ "123abc", nil, nil ], Readline.readline_attempted_completion_function("123A", 0, 3)
+
+  ensure
+    Readline.completion_case_fold = false
+    Readline.module_eval do
+      @completion_proc = nil
+    end
+  end
+
+  def test_attempted_comp_func_removes_replacement_from_possible_matches
+    Readline.completion_proc = Proc.new do |word|
+       %w( 123456 123abc abc123 ).grep(/^#{word}/)
+    end
+
+    assert_equal [ "123", "123456", "123abc", nil ], Readline.readline_attempted_completion_function("12", 0, 1)
+
+    assert_equal [ "123", "123456", "123abc", nil ], Readline.readline_attempted_completion_function("123", 0, 2)
+
+    assert_equal [ "123456", nil, nil ], Readline.readline_attempted_completion_function("1234", 0, 3)
+
+  ensure
+    Readline.module_eval do
+      @completion_proc = nil
+    end
+  end
+
+  def teardown
+    @proc = nil
+  end
+end