rb-readline 0.4.2 → 0.5.0

data/test/test_completion.rb

@@ -68,8 +68,6 @@ class TestCompletion < Test::Unit::TestCase
   end
 
   def test_make_quoted_replacement_calls_filename_quoting_function
-    match = RbReadline::SINGLE_MATCH
-
     assert_equal "dir/with\\ space", make_quoted_replacement("dir/with space", RbReadline::SINGLE_MATCH, 0.chr)
   end
 

data/test/test_filename_completion_proc.rb

@@ -1,9 +1,10 @@
 require 'test/unit'
 require 'fileutils'
 require 'readline'
+require "rbconfig"
 require "#{File.expand_path(File.dirname(__FILE__))}/filesystem_completion_helper"
 
-class TC_FILENAME_COMPLETION_PROC < Test::Unit::TestCase
+class TestFilenameCompletionProc < Test::Unit::TestCase
   include FilesystemCompletionHelper
 
   def setup
@@ -66,4 +67,21 @@ class TC_FILENAME_COMPLETION_PROC < Test::Unit::TestCase
   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 "test/unit"
+require "readline"
+
+class TestHistory < Test::Unit::TestCase
+
+  # RbReadline::HISTORY_WORD_DELIMITERS.inspect
+  # => " \t\n;&()|<>"
+  # RbReadline::HISTORY_QUOTE_CHARACTERS   = "\"'`"
+  # => "\"'`"
+  def test_history_arg_extract
+    assert_raise(RuntimeError) { RbReadline.history_arg_extract("!", "$", "one two three") }
+    assert_raise(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

@@ -1,9 +1,23 @@
 require 'test/unit'
 require 'rbreadline'
 
-class TC_RbReadline < Test::Unit::TestCase
-   def test_versions
-      assert_equal('5.2', RbReadline::RL_LIBRARY_VERSION)
-      assert_equal(0x0502, RbReadline::RL_READLINE_VERSION)
-   end
+class TestRbReadline < Test::Unit::TestCase
+  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

@@ -1,168 +1,209 @@
 require 'test/unit'
 require 'readline'
 
-class TC_Readline < Test::Unit::TestCase
-   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_expected_errors
-      assert_raise(ArgumentError){ Readline.readline }
-   end
-
-   def test_input_basic
-      assert_respond_to(Readline, :input=)
-   end
-
-   def test_input
-      assert_nothing_raised{ Readline.input = $stdin }
-   end
-
-   def test_output_basic
-      assert_respond_to(Readline, :output=)
-   end
-
-   def test_output
-      assert_nothing_raised{ Readline.output = $stdout }
-   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
-      assert_nothing_raised{ Readline.completion_proc = @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
-      assert_nothing_raised{ Readline.completion_case_fold = false }
-   end
-
-   def test_completion_proc_expected_errors
-      assert_raise(ArgumentError){ Readline.completion_proc = 1 }
-      assert_raise(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_nothing_raised{ Readline.completion_append_character }
-   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
-      assert_nothing_raised{ Readline.basic_word_break_characters = " \t\n\"\\'`@$><=|&{(" }
-   end
-
-   def test_basic_quote_characters_get_basic
-      assert_respond_to(Readline, :basic_quote_characters)
-   end
-
-   def test_basic_quote_characters_get
-      assert_nothing_raised{ Readline.basic_quote_characters }
-      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
-      assert_nothing_raised{ Readline.basic_quote_characters = "\"'" }
-   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|
+class TestReadline < Test::Unit::TestCase
+  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_expected_errors
+    assert_raise(ArgumentError){ Readline.readline }
+  end
+
+  def test_input_basic
+    assert_respond_to(Readline, :input=)
+  end
+
+  def test_input
+    assert_nothing_raised{ Readline.input = $stdin }
+  end
+
+  def test_output_basic
+    assert_respond_to(Readline, :output=)
+  end
+
+  def test_output
+    assert_nothing_raised{ Readline.output = $stdout }
+  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
+    assert_nothing_raised{ Readline.completion_proc = @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
+    assert_nothing_raised{ Readline.completion_case_fold = false }
+  end
+
+  def test_completion_proc_expected_errors
+    assert_raise(ArgumentError){ Readline.completion_proc = 1 }
+    assert_raise(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_nothing_raised{ 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
+    assert_nothing_raised{ Readline.basic_word_break_characters = " \t\n\"\\'`@$><=|&{(" }
+  end
+
+  def test_basic_quote_characters_get_basic
+    assert_respond_to(Readline, :basic_quote_characters)
+  end
+
+  def test_basic_quote_characters_get
+    assert_nothing_raised{ Readline.basic_quote_characters }
+    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
+    assert_nothing_raised{ 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
+    end
 
-     Readline.completion_case_fold = true
+    Readline.completion_case_fold = true
 
-     assert_equal [ "123", "123456", "123abc", nil ], Readline.readline_attempted_completion_function("123", 0, 3)
+    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)
+    assert_equal [ "123abc", nil, nil ], Readline.readline_attempted_completion_function("123A", 0, 3)
 
-   ensure
-     Readline.module_eval do
-       @completion_proc = nil
-     end
-   end
+  ensure
+    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|
+  def test_attempted_comp_func_removes_replacement_from_possible_matches
+    Readline.completion_proc = Proc.new do |word|
        %w( 123456 123abc abc123 ).grep(/^#{word}/)
-     end
+    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("12", 0, 1)
 
-     assert_equal [ "123", "123456", "123abc", nil ], Readline.readline_attempted_completion_function("123", 0, 2)
+    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)
+    assert_equal [ "123456", nil, nil ], Readline.readline_attempted_completion_function("1234", 0, 3)
 
-   ensure
-     Readline.module_eval do
-       @completion_proc = nil
-     end
-   end
+  ensure
+    Readline.module_eval do
+      @completion_proc = nil
+    end
+  end
 
-   def teardown
-      @proc = nil
-   end
+  def teardown
+    @proc = nil
+  end
 end