vimamsa 0.1.22 → 0.1.24

data/tests/test_copy_paste.rb

@@ -0,0 +1,88 @@
+class TestCopyPaste < VmaTest
+
+  def test_copy_line_paste_after
+    act 'buf.insert_txt("hello\n")'
+    act :jump_to_start_of_buffer
+    act :copy_cur_line
+    act :jump_to_end_of_buffer
+    act :paste_after_cursor
+    assert_buf "hello\n\nhello\n"
+  end
+
+  def test_copy_line_paste_before
+    act 'buf.insert_txt("hello\n")'
+    act 'buf.insert_txt("world")'
+    act :jump_to_start_of_buffer
+    act :copy_cur_line
+    act "buf.move(FORWARD_LINE)"
+    act :paste_before_cursor
+    assert_buf "hello\nhello\nworld\n"
+  end
+
+  def test_copy_paste_twice
+    act 'buf.insert_txt("abc")'
+    act :jump_to_start_of_buffer
+    act :copy_cur_line
+    act :jump_to_end_of_buffer
+    act :paste_after_cursor
+    act :paste_after_cursor
+    assert_buf "abc\nabc\nabc\n"
+  end
+
+  def test_cut_selection_paste
+    act 'buf.insert_txt("hello world")'
+    act :jump_to_start_of_buffer
+    # Select "hello" (5 chars)
+    act "buf.start_selection"
+    4.times { act "buf.move(FORWARD_CHAR)" }
+    act :cut_selection
+    assert_buf " world\n"
+    act "buf.jump(END_OF_LINE)"
+    act :paste_after_cursor
+    assert_buf " worldhello\n"
+  end
+
+  def test_copy_selection_paste
+    act 'buf.insert_txt("foo bar")'
+    act :jump_to_start_of_buffer
+    act "buf.start_selection"
+    2.times { act "buf.move(FORWARD_CHAR)" }
+    act :copy_selection
+    # Original buffer unchanged
+    assert_buf "foo bar\n"
+    act "buf.jump(END_OF_LINE)"
+    act :paste_after_cursor
+    assert_buf "foo barfoo\n"
+  end
+
+  def test_clipboard_set_get
+    vma.clipboard.set("testvalue")
+    assert_eq "testvalue", vma.clipboard.get
+  end
+
+  def test_copy_line_updates_clipboard
+    act 'buf.insert_txt("myline")'
+    act :jump_to_start_of_buffer
+    act :copy_cur_line
+    assert_eq "myline\n", vma.clipboard.get
+  end
+
+  def test_cut_selection_updates_clipboard
+    act 'buf.insert_txt("hello")'
+    act :jump_to_start_of_buffer
+    act "buf.start_selection"
+    2.times { act "buf.move(FORWARD_CHAR)" }
+    act :cut_selection
+    assert_eq "hel", vma.clipboard.get
+  end
+
+  def test_paste_multiline
+    act 'buf.insert_txt("line1\nline2\nline3")'
+    act :jump_to_start_of_buffer
+    act :copy_cur_line
+    act :jump_to_end_of_buffer
+    act :paste_after_cursor
+    assert_buf "line1\nline2\nline3\nline1\n"
+  end
+
+end

data/tests/test_key_bindings.rb

@@ -0,0 +1,152 @@
+class TestKeyBindings < VmaTest
+
+  # ── bindkey / basic dispatch ─────────────────────────────────────────────
+
+  def test_bindkey_symbol_action_fires
+    triggered = false
+    reg_act(:_test_bindkey_symbol, proc { triggered = true }, "test")
+    bindkey "C t e s t 1", :_test_bindkey_symbol
+    keys "t e s t 1"
+    assert triggered, "action should have fired"
+  end
+
+  def test_bindkey_string_action_fires
+    $test_str_fired = false
+    bindkey "C t e s t 2", '$test_str_fired = true'
+    keys "t e s t 2"
+    assert $test_str_fired, "string action should have fired"
+  end
+
+  def test_bindkey_proc_via_array
+    $test_arr_fired = false
+    bindkey "C t e s t 3", [:_test_arr_action, proc { $test_arr_fired = true }, "test"]
+    keys "t e s t 3"
+    assert $test_arr_fired, "array-style action should have fired"
+  end
+
+  # ── multi-key chord ──────────────────────────────────────────────────────
+
+  def test_chord_requires_full_sequence
+    count = 0
+    reg_act(:_test_chord, proc { count += 1 }, "test chord")
+    bindkey "C , x q", :_test_chord
+
+    keys ","       # partial — should not fire yet
+    assert_eq 0, count, "should not fire after partial chord"
+
+    keys "x q"     # complete chord
+    assert_eq 1, count, "should fire after complete chord"
+  end
+
+  def test_chord_wrong_key_resets
+    count = 0
+    reg_act(:_test_chord_reset, proc { count += 1 }, "test")
+    bindkey "C , x r", :_test_chord_reset
+
+    keys ", x z"   # wrong last key — resets, does not fire
+    assert_eq 0, count, "wrong key should not fire the action"
+
+    keys ", x r"   # correct sequence
+    assert_eq 1, count, "correct chord should fire"
+  end
+
+  # ── mode specificity ─────────────────────────────────────────────────────
+
+  def test_command_binding_does_not_fire_in_insert_mode
+    count = 0
+    reg_act(:_test_cmd_only, proc { count += 1 }, "test")
+    bindkey "C , x c", :_test_cmd_only
+
+    # Switch to insert mode and send the keys
+    vma.kbd.set_mode(:insert)
+    keys ", x c"
+    vma.kbd.set_mode(:command)
+    assert_eq 0, count, "command binding should not fire in insert mode"
+  end
+
+  def test_insert_binding_fires_in_insert_mode
+    count = 0
+    reg_act(:_test_ins_only, proc { count += 1 }, "test")
+    bindkey "I ctrl-F9", :_test_ins_only   # unlikely to conflict
+
+    vma.kbd.set_mode(:insert)
+    keys "ctrl-F9"
+    vma.kbd.set_mode(:command)
+    assert_eq 1, count, "insert binding should fire in insert mode"
+  end
+
+  # ── unbindkey ────────────────────────────────────────────────────────────
+
+  def test_unbindkey_removes_binding
+    count = 0
+    reg_act(:_test_unbind, proc { count += 1 }, "test")
+    bindkey "C , x u", :_test_unbind
+
+    keys ", x u"
+    assert_eq 1, count, "should fire before unbind"
+
+    unbindkey "C , x u"
+
+    keys ", x u"
+    assert_eq 1, count, "should not fire after unbind"
+  end
+
+  def test_unbindkey_pipe_syntax
+    count = 0
+    reg_act(:_test_unbind_pipe, proc { count += 1 }, "test")
+    bindkey "C , x p || C , x q", :_test_unbind_pipe
+
+    keys ", x p"
+    keys ", x q"
+    assert_eq 2, count, "both bindings should fire"
+
+    unbindkey "C , x p || C , x q"
+
+    keys ", x p"
+    keys ", x q"
+    assert_eq 2, count, "neither binding should fire after unbind"
+  end
+
+  # ── || (pipe) multi-binding syntax ───────────────────────────────────────
+
+  def test_pipe_syntax_both_keys_trigger_same_action
+    count = 0
+    reg_act(:_test_pipe, proc { count += 1 }, "test")
+    bindkey "C , x a || C , x b", :_test_pipe
+
+    keys ", x a"
+    assert_eq 1, count
+    keys ", x b"
+    assert_eq 2, count
+  end
+
+  # ── repeat count ─────────────────────────────────────────────────────────
+
+  def test_repeat_count_executes_action_n_times
+    count = 0
+    reg_act(:_test_repeat, proc { count += 1 }, "test")
+    bindkey "C , x 9", :_test_repeat
+
+    # Set repeat count to 3 then fire action
+    vma.kbd.set_next_command_count(3)
+    keys ", x 9"
+    assert_eq 3, count, "action should run 3 times with count=3"
+  end
+
+  # ── mode switching ───────────────────────────────────────────────────────
+
+  def test_escape_returns_to_command_from_insert
+    keys "i"
+    assert_mode :insert
+    keys "esc"
+    assert_mode :command
+  end
+
+  def test_i_enters_insert_mode
+    assert_mode :command
+    keys "i"
+    assert_mode :insert
+    keys "esc"
+  end
+
+end

data/tests/test_module_interface.rb

@@ -0,0 +1,98 @@
+class TestModuleInterface < VmaTest
+  # Ensure the calculator is inactive before each test that needs a clean slate.
+  def ensure_disabled
+    if vma.actions.include?(:insert_calculator)
+      calculator_disable if respond_to?(:calculator_disable, true)
+    end
+  end
+
+  def load_calculator
+    load ppath("modules/calculator/calculator.rb")
+  end
+
+  # --- _info ---
+
+  def test_info_structure
+    load ppath("modules/calculator/calculator_info.rb")
+    info = calculator_info
+    assert info[:name].is_a?(String),  "name should be a String"
+    assert !info[:name].empty?,        "name should not be empty"
+    assert info.key?(:no_restart),     "no_restart key missing"
+    assert_eq true, info[:no_restart], "calculator should be no_restart"
+  end
+
+  # --- _init ---
+
+  def test_init_registers_action
+    ensure_disabled
+    load_calculator
+    calculator_init
+    assert vma.actions.include?(:insert_calculator), "action not registered after init"
+  ensure
+    calculator_disable
+  end
+
+  def test_init_adds_menu_item
+    ensure_disabled
+    load_calculator
+    calculator_init
+    assert vma.gui.menu.module_action?(:insert_calculator), "menu item missing after init"
+  ensure
+    calculator_disable
+  end
+
+  # --- _disable ---
+
+  def test_disable_unregisters_action
+    ensure_disabled
+    load_calculator
+    calculator_init
+    calculator_disable
+    assert !vma.actions.include?(:insert_calculator), "action still registered after disable"
+  end
+
+  def test_disable_removes_menu_item
+    ensure_disabled
+    load_calculator
+    calculator_init
+    calculator_disable
+    assert !vma.gui.menu.module_action?(:insert_calculator), "menu item still present after disable"
+  end
+
+  # --- cycle ---
+
+  def test_init_disable_cycle
+    ensure_disabled
+    load_calculator
+    3.times do |i|
+      calculator_init
+      assert vma.actions.include?(:insert_calculator),        "action missing after init (cycle #{i})"
+      assert vma.gui.menu.module_action?(:insert_calculator), "menu missing after init (cycle #{i})"
+      calculator_disable
+      assert !vma.actions.include?(:insert_calculator),        "action present after disable (cycle #{i})"
+      assert !vma.gui.menu.module_action?(:insert_calculator), "menu present after disable (cycle #{i})"
+    end
+  end
+
+  # --- all_settings_defs ---
+
+  def test_settings_defs_has_modules_section
+    defs = all_settings_defs
+    assert defs.any? { |s| s[:label] == "Modules" }, "no Modules section"
+  end
+
+  def test_settings_defs_calculator_key_present
+    defs = all_settings_defs
+    mod = defs.find { |s| s[:label] == "Modules" }
+    assert !mod.nil?, "no Modules section"
+    calc = mod[:settings].find { |s| s[:key] == [:modules, :calculator, :enabled] }
+    assert !calc.nil?, "calculator key missing from Modules section"
+  end
+
+  def test_settings_defs_no_restart_flag
+    defs = all_settings_defs
+    mod  = defs.find { |s| s[:label] == "Modules" }
+    calc = mod[:settings].find { |s| s[:key] == [:modules, :calculator, :enabled] }
+    assert_eq true, calc[:no_restart], "calculator should have no_restart: true"
+  end
+end

data/tests/test_undo.rb

@@ -0,0 +1,201 @@
+class TestUndo < VmaTest
+
+  # ── Basic undo / redo ────────────────────────────────────────────────────
+
+  def test_undo_restores_empty_buffer
+    act 'buf.insert_txt("hello")'
+    act :undo
+    assert_buf "\n"
+  end
+
+  def test_undo_on_empty_buffer_is_noop
+    act :undo
+    assert_buf "\n"
+  end
+
+  def test_redo_after_undo
+    act 'buf.insert_txt("hello")'
+    act :undo
+    act :redo
+    assert_buf "hello\n"
+  end
+
+  def test_redo_on_empty_stack_is_noop
+    act :undo
+    act :redo
+    assert_buf "\n"
+  end
+
+  def test_new_edit_clears_redo_stack
+    act 'buf.insert_txt("hello")'
+    act :undo
+    assert_buf "\n"
+    act 'buf.insert_txt("world")'
+    # redo stack was cleared — redo should be a no-op
+    act :redo
+    assert_buf "world\n"
+  end
+
+  def test_undo_delete_char
+    act 'buf.insert_txt("abcde")'
+    act :jump_to_start_of_buffer
+    vma.buf.new_undo_group
+    act :delete_char_forward
+    act :delete_char_forward
+    vma.buf.new_undo_group
+    assert_buf "cde\n"
+    act :undo
+    assert_buf "abcde\n"
+  end
+
+  def test_undo_delete_line
+    act 'buf.insert_txt("first\n")'
+    act 'buf.insert_txt("second")'
+    vma.buf.new_undo_group
+    act :jump_to_start_of_buffer
+    act :delete_line
+    vma.buf.new_undo_group
+    assert_buf "second\n"
+    act :undo
+    assert_buf "first\nsecond\n"
+  end
+
+  def test_undo_redo_multiple_times
+    act 'buf.insert_txt("first")'
+    vma.buf.new_undo_group
+    act 'buf.insert_txt(" second")'
+    assert_buf "first second\n"
+
+    act :undo
+    assert_buf "first\n"
+    act :redo
+    assert_buf "first second\n"
+    act :undo
+    assert_buf "first\n"
+    act :undo
+    assert_buf "\n"
+  end
+
+  # ── Explicit group boundaries ─────────────────────────────────────────────
+
+  def test_new_undo_group_creates_separate_steps
+    act 'buf.insert_txt("aaa")'
+    vma.buf.new_undo_group
+    act 'buf.insert_txt("bbb")'
+    vma.buf.new_undo_group
+    act 'buf.insert_txt("ccc")'
+    vma.buf.new_undo_group
+    assert_buf "aaabbbccc\n"
+
+    act :undo
+    assert_buf "aaabbb\n"
+    act :undo
+    assert_buf "aaa\n"
+    act :undo
+    assert_buf "\n"
+  end
+
+  # ── Mode-change group boundaries ─────────────────────────────────────────
+
+  def test_mode_change_creates_undo_group_boundary
+    # Each insert-mode session should be a separate undo group
+    keys "i h e l l o esc"
+    keys "i space w o r l d esc"
+    assert_buf "hello world\n"
+
+    act :undo
+    assert_buf "hello\n"  # second insert session (" world") undone
+    act :undo
+    assert_buf "\n"       # first insert session ("hello") undone
+  end
+
+  # ── Macro undo ────────────────────────────────────────────────────────────
+
+  def test_macro_run_is_single_undo_group
+    # An entire macro run should collapse into one undo step
+    vma.macro.run_actions([
+      'buf.insert_txt("line1\n")',
+      'buf.insert_txt("line2\n")',
+      'buf.insert_txt("line3")',
+    ])
+    drain_idle
+    assert_buf "line1\nline2\nline3\n"
+
+    act :undo
+    assert_buf "\n"
+  end
+
+  def test_macro_multiple_runs_each_undoable_separately
+    # Each run of the macro should be its own undo group
+    vma.macro.run_actions(['buf.insert_txt("abc")'])
+    drain_idle
+    vma.macro.run_actions(['buf.insert_txt("def")'])
+    drain_idle
+    assert_buf "abcdef\n"
+
+    act :undo
+    assert_buf "abc\n"
+    act :undo
+    assert_buf "\n"
+  end
+
+  def test_macro_does_not_undo_pre_existing_content
+    # Content that existed before the macro run should survive macro undo
+    act 'buf.insert_txt("base")'
+    vma.buf.new_undo_group
+    vma.macro.run_actions(['buf.insert_txt(" appended")'])
+    drain_idle
+    assert_buf "base appended\n"
+
+    act :undo
+    assert_buf "base\n"
+    act :undo
+    assert_buf "\n"
+  end
+
+  def test_macro_record_and_run_then_undo
+    # Record a macro via key sequence, run it, then undo each step
+    keys "q a"              # start recording into slot "a"
+    keys "i f o o esc"      # insert "foo", return to (macro) command mode
+    keys "q"                # end recording
+    drain_idle
+    assert_buf "foo\n"      # recording-time insertion is in the buffer
+
+    vma.macro.run_macro("a")
+    drain_idle
+    assert_buf "foofoo\n"
+
+    act :undo               # undo the macro run
+    assert_buf "foo\n"
+    act :undo               # undo the recording-time insertion
+    assert_buf "\n"
+  end
+
+  def test_macro_redo_after_undo
+    vma.macro.run_actions(['buf.insert_txt("hello")'])
+    drain_idle
+    assert_buf "hello\n"
+
+    act :undo
+    assert_buf "\n"
+    act :redo
+    assert_buf "hello\n"
+  end
+
+  def test_macro_with_delete_is_single_undo_group
+    act 'buf.insert_txt("hello world")'
+    vma.buf.new_undo_group
+
+    # Macro that jumps to start and deletes a word
+    vma.macro.run_actions([
+      'buf.jump(BEGINNING_OF_LINE)',
+      'buf.delete2(:to_word_end)',
+    ])
+    drain_idle
+    assert_buf " world\n"
+
+    act :undo
+    assert_buf "hello world\n"
+  end
+
+end

data/vimamsa.gemspec

@@ -22,17 +22,18 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib","ext"]
 
-  spec.add_development_dependency "bundler", "~> 2.4.21"
+  spec.add_development_dependency "bundler", ">= 2.4"
   spec.add_development_dependency "rake", "~> 13.1.0"
   
   spec.add_runtime_dependency 'rufo', '~> 0.16.2'
   
   spec.add_runtime_dependency 'ripl', '~> 0.7.1'
   spec.add_runtime_dependency 'ripl-multi_line', '~> 0.3.1'
-  spec.add_runtime_dependency 'gdk4', '~> 4.2.1'
-  spec.add_runtime_dependency 'gtk4', '~> 4.2.1'
-  spec.add_runtime_dependency 'gtksourceview5', '~> 4.2.1'
-  spec.add_runtime_dependency 'gstreamer', '~> 4.2.1'
+  spec.add_runtime_dependency 'gdk4', '~> 4.3.5'
+  spec.add_runtime_dependency 'gtk4', '~> 4.3.5'
+  spec.add_runtime_dependency 'gtksourceview5', '~> 4.3.5'
+  spec.add_runtime_dependency 'gstreamer', '~> 4.3.5'
+  spec.add_runtime_dependency 'vte4', '~> 4.3.5'
   spec.add_runtime_dependency 'rambling-trie', '~> 2.3.1'
   
   spec.add_runtime_dependency 'differ', '~>  0.1.2'