vimamsa 0.1.23 → 0.1.25

data/lib/vimamsa/key_actions.rb

@@ -18,15 +18,6 @@ def jump_to_next_edit
   buf.jump_to_next_edit
 end
 
-def is_command_mode()
-  return true if vma.kbd.mode_root_state.to_s() == "C"
-  return false
-end
-
-def is_visual_mode()
-  return 1 if vma.kbd.mode_root_state.to_s() == "V"
-  return 0
-end
 
 reg_act(:command_to_buf, proc { command_to_buf }, "Execute command, output to buffer")
 
@@ -40,7 +31,7 @@ reg_act(:cut_selection, proc { buf.delete(SELECTION) }, "Cut selection to clipbo
 
 reg_act(:insert_backspace, proc { buf.selection_active? ? buf.delete(SELECTION) : buf.delete(BACKWARD_CHAR) }, "Delete backwards")
 reg_act(:insert_select_up, proc { insert_select_move(BACKWARD_LINE) }, "Select texte upwards")
-reg_act(:insert_select_down, proc { insert_select_move(BACKWARD_CHAR) }, "Select text downwards")
+reg_act(:insert_select_down, proc { insert_select_move(FORWARD_LINE) }, "Select text downwards")
 
 reg_act(:copy_selection, proc { buf.copy_active_selection }, "Copy selection to clipboard")
 reg_act(:enable_debug, proc { cnf.debug = true }, "Enable debug")
@@ -59,8 +50,8 @@ reg_act(:backup_all_buffers, proc { backup_all_buffers }, "Backup all buffers",
 reg_act(:e_move_forward_char, "e_move_forward_char", "Move forward", { :group => [:move, :basic] })
 reg_act(:e_move_backward_char, "e_move_backward_char", "Move forward", { :group => [:move, :basic] })
 # reg_act(:history_switch_backwards, proc{bufs.history_switch_backwards}, "", { :group => :file })
-reg_act(:history_switch_backwards, proc{bufs.history_switch(-1)}, "Prev buffer", { :group => :file })
-reg_act(:history_switch_forwards, proc{bufs.history_switch(+1)}, "Next buffer", { :group => :file })
+reg_act(:history_switch_backwards, proc { bufs.history_switch(-1) }, "Prev buffer", { :group => :file })
+reg_act(:history_switch_forwards, proc { bufs.history_switch(+1) }, "Next buffer", { :group => :file })
 reg_act(:print_buffer_access_list, proc { bufs.print_by_access_time }, "Print buffers by access time", { :group => :file })
 reg_act(:center_on_current_line, "center_on_current_line", "", { :group => :view })
 reg_act(:run_last_macro, proc { vma.macro.run_last_macro }, "Run last recorded or executed macro", { :group => :macro })
@@ -69,6 +60,7 @@ reg_act(:jump_to_last_edit, proc { buf.jump_to_last_edit }, "Jump to last edit p
 reg_act(:jump_to_random, proc { buf.jump_to_random_pos }, "")
 reg_act(:insert_new_line, proc { buf.insert_new_line() }, "Insert new line")
 reg_act(:show_key_bindings, proc { show_key_bindings }, "Show key bindings")
+reg_act(:show_free_key_bindings, proc { show_free_key_bindings }, "Show available (unbound) key binding slots")
 reg_act(:put_file_path_to_clipboard, proc { buf.put_file_path_to_clipboard }, "Put file path of current file to clipboard")
 reg_act(:put_file_ref_to_clipboard, proc { buf.put_file_ref_to_clipboard }, "Put file ref of current file to clipboard")
 
@@ -79,6 +71,11 @@ reg_act(:set_executable, proc { buf.set_executable }, "Set current file permissi
 # reg_act(:close_all_buffers, proc { bufs.close_all_buffers() }, "Close all buffers")
 reg_act(:close_current_buffer, proc { bufs.close_current_buffer(true) }, "Close current buffer")
 reg_act(:toggle_file_panel, proc { vma.gui.toggle_file_panel }, "Toggle file panel")
+reg_act(:show_message_history, proc { vma.gui.show_message_history }, "Show message history")
+reg_act(:toggle_func_panel, proc { vma.gui.toggle_func_panel }, "Toggle LSP function panel")
+reg_act(:refresh_func_panel, proc { vma.gui.func_panel_refresh }, "Refresh LSP function panel")
+reg_act(:git_diff_w, proc { git_diff_w }, "Show git diff -w for whole repository")
+reg_act(:lsp_print_functions, proc { lsp_print_functions }, "LSP print functions in current file")
 reg_act(:comment_selection, proc { buf.comment_selection }, "Comment selection")
 reg_act(:delete_char_forward, proc { buf.delete(CURRENT_CHAR_FORWARD) }, "Delete char forward", { :group => [:edit, :basic] })
 reg_act(:gui_file_finder, proc { vma.FileFinder.start_gui }, "Fuzzy file finder")
@@ -86,7 +83,6 @@ reg_act(:gui_file_history_finder, proc { vma.FileHistory.start_gui }, "Fuzzy fil
 reg_act(:gui_search_replace, proc { gui_search_replace }, "Search and replace")
 reg_act(:find_next, proc { $search.jump_to_next() }, "Find next")
 
-
 reg_act(:set_style_bold, proc { buf.style_transform(:bold) }, "Set text weight to bold")
 reg_act(:set_style_link, proc { buf.style_transform(:link) }, "Set text as link")
 reg_act(:V_join_lines, proc { vma.buf.convert_selected_text(:joinlines) }, "Join lines")
@@ -114,37 +110,42 @@ reg_act :delete_to_word_end, proc { buf.delete2(:to_word_end) }, "Delete to file
 reg_act :delete_to_next_word_start, proc { buf.delete2(:to_next_word) }, "Delete to start of next word", { :group => [:edit, :basic] }
 reg_act :delete_to_line_start, proc { buf.delete2(:to_line_start) }, "Delete to line start", { :group => [:edit, :basic] }
 
+reg_act(:ack_search, proc { gui_ack }, "Ack")
 
-reg_act(:ack_search, proc { gui_ack }, "Ack") 
-
-reg_act(:copy_cur_line, proc {buf.copy_line}, "Copy the current line") 
-reg_act(:paste_before_cursor, proc {buf.paste(BEFORE)}, "Paste text before the cursor") 
-reg_act(:paste_after_cursor, proc {buf.paste(AFTER)}, "Paste text after the cursor") 
-reg_act(:redo, proc {buf.redo()}, "Redo the last undone action")
-reg_act(:undo, proc {buf.undo()}, "Undo the last action")
+reg_act(:copy_cur_line, proc { buf.copy_line }, "Copy the current line")
+reg_act(:paste_before_cursor, proc { buf.paste(BEFORE) }, "Paste text before the cursor")
+reg_act(:paste_after_cursor, proc { buf.paste(AFTER) }, "Paste text after the cursor")
+reg_act(:paste_over_after, proc { buf.paste_over(AFTER) }, "Paste over selection or after cursor")
+reg_act(:paste_over_before, proc { buf.paste_over(BEFORE) }, "Paste over selection or before cursor")
+reg_act(:redo, proc { buf.redo() }, "Redo the last undone action")
+reg_act(:undo, proc { buf.undo() }, "Undo the last action")
 reg_act(:jump_end_of_line, proc { buf.jump(END_OF_LINE) }, "Move to the end of the current line")
-reg_act(:jump_end_of_buffer, proc {buf.jump(END_OF_BUFFER)}, "Move to the end of the buffer")
+reg_act(:jump_end_of_buffer, proc { buf.jump(END_OF_BUFFER) }, "Move to the end of the buffer")
 reg_act(:jump_start_of_buffer, proc { buf.jump(START_OF_BUFFER) }, "Move to the start of the buffer")
 reg_act(:jump_beginning_of_line, proc { buf.jump(BEGINNING_OF_LINE) }, "Move to the beginning of the current line")
-reg_act(:jump_next_word_end, proc { buf.jump_word(FORWARD,WORD_END) }, "Jump to the end of the next word")
-reg_act(:jump_prev_word_start, proc { buf.jump_word(BACKWARD,WORD_START) }, "Jump to the start of the previous word")
-reg_act(:jump_next_word_start, proc { buf.jump_word(FORWARD,WORD_START) }, "Jump to the start of the next word")
+reg_act(:jump_next_word_end, proc { buf.jump_word(FORWARD, WORD_END) }, "Jump to the end of the next word")
+reg_act(:jump_prev_word_start, proc { buf.jump_word(BACKWARD, WORD_START) }, "Jump to the start of the previous word")
+reg_act(:jump_next_word_start, proc { buf.jump_word(FORWARD, WORD_START) }, "Jump to the start of the next word")
 reg_act(:insert_mode, proc { vma.kbd.set_mode(:insert) }, "Switch to INSERT mode")
 reg_act(:prev_mode, proc { vma.kbd.to_previous_mode }, "Return to the previous mode")
 reg_act(:move_prev_line, proc { buf.move(BACKWARD_LINE) }, "Move the cursor to the previous line")
 reg_act(:move_next_line, proc { buf.move(FORWARD_LINE) }, "Move the cursor to the next line")
 reg_act(:move_backward_char, proc { buf.move(BACKWARD_CHAR) }, "Move one character backward")
-reg_act(:start_visual_mode, proc { buf.start_selection;vma.kbd.set_mode(:visual) }, "Enter VISUAL mode (for selections)") 
+reg_act(:start_visual_mode, proc { buf.start_selection; vma.kbd.set_mode(:visual) }, "Enter VISUAL mode (for selections)")
 reg_act(:jump_last_edit, proc { buf.jump_to_last_edit }, "Jump to the last edit location")
 reg_act(:install_demo_files, proc { install_demo_files }, "Install and show Demo")
 reg_act(:reload_customrb, proc { reload_customrb }, "Reload custom.rb")
 
-
 reg_act :start_browse_mode, proc {
   vma.kbd.set_mode(:browse)
   bufs.reset_navigation
 }, "Start browse mode"
 reg_act :kbd_dump_state, proc { vma.kbd.dump_state }, "Dump keyboard tree state"
+reg_act :toggle_kbd_passthrough, proc {
+  vma.gui.instance_variable_set(:@kbd_passthrough, !vma.gui.instance_variable_get(:@kbd_passthrough))
+  state = vma.gui.instance_variable_get(:@kbd_passthrough) ? "ON" : "OFF"
+  message("Keyboard passthrough: #{state}")
+}, "Toggle keyboard event passthrough (allow other widgets to receive key events)"
 
 reg_act :exit_browse_mode, proc {
   bufs.add_current_buf_to_history
@@ -207,9 +208,9 @@ act_list = {
 
   :backward_line => { :proc => proc { buf.move(BACKWARD_LINE) },
                       :desc => "Move one line backward", :group => [:move, :basic] },
-                                             
-  :increment_word => { :proc => proc { buf.increment_current_word},
-                      :desc => "Increment word", :group => [:edit, :extra] },                                            
+
+  :increment_word => { :proc => proc { buf.increment_current_word },
+                       :desc => "Increment word", :group => [:edit, :extra] },
 
   # { :proc => proc {  },
   # :desc => "", :group => : },

data/lib/vimamsa/key_binding_tree.rb

@@ -69,9 +69,10 @@ class KeyBindingTree
 
   def set_mode(label)
     return if get_mode == :label
+    vma.buf&.new_undo_group
     @match_state = [@modes[label]] # used for matching input
     @mode_root_state = @modes[label]
-    
+
     #TODO: should not happen? @default_mode_stack[-1] should be always the same as get_mode ?
     @default_mode_stack << label if label != @default_mode_stack[-1]
 
@@ -279,6 +280,61 @@ class KeyBindingTree
     @state_trail = [@mode_root_state]
   end
 
+  # Returns a list of key positions that are free (no action bound) under each
+  # existing node in the tree. For each intermediate node (chord prefix),
+  # shows which common keys are not yet bound as its children.
+  # Does NOT recurse into free positions — only checks children of existing nodes.
+  def get_free_bindings(modes: [])
+    common_keys = ("a".."z").to_a + %w[
+      space return esc tab backspace
+      , . / ; ' [ ] \\ `
+    ]
+    # delete ! @  # $ % ^ & * ( )  :  " < > ?
+    # left right up down home end pageup pagedown
+    # 0 1 2 3 4 5 6 7 8 9
+    # ctrl-a ctrl-b ctrl-d ctrl-e ctrl-f ctrl-g ctrl-h
+    # ctrl-j ctrl-k ctrl-l ctrl-n ctrl-o ctrl-p ctrl-q ctrl-r
+    # ctrl-s ctrl-t ctrl-u ctrl-v ctrl-w ctrl-x ctrl-y ctrl-z
+    # shift-left shift-right shift-up shift-down
+    # F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12
+
+    lines = []
+    stack = [[@root, ""]]
+
+    while stack.any?
+      t, p = *stack.pop
+      next unless t.children.any?
+
+      t.children.each { |c|
+        if c.level == 1 && !modes.empty?
+          next unless modes.include?(c.key_name)
+        end
+
+        if c.level == 1
+          new_p = "[#{c.key_name}]"
+        elsif c.eval_rule.size > 0
+          new_p = "#{p} #{c.key_name}(#{c.eval_rule})"
+        else
+          new_p = p.empty? ? c.key_name.to_s : "#{p} #{c.key_name}"
+        end
+
+        next unless c.children.any?
+        next if c.children.any? { |gc| gc.key_name == "<char>" }
+
+        bound = c.children.map(&:key_name).to_set
+        free = common_keys.reject { |k| bound.include?(k) }
+        lines << "#{new_p} : #{free.join("  ")}" if free.any?
+
+        stack << [c, new_p]
+      }
+    end
+
+    lines.sort_by { |l|
+      prefix = l.split(" : ").first.split
+      [prefix.first, prefix.size, l]
+    }.join("\n")
+  end
+
   def get_by_keywords(modes: [], keywords: [])
     s = ""
     stack = [[@root, ""]]
@@ -577,6 +633,14 @@ class KeyBindingTree
     key.each { |k| _bindkey(k, a, keywords: keywords) }
   end
 
+  def unbindkey(key)
+    if key.class != Array
+      key = key.split("||")
+    end
+    #TODO: test
+    key.each { |k| _bindkey(k.strip, :delete_state) }
+  end
+
   def _bindkey(key, action, keywords: [])
     key.strip!
     key.gsub!(/\s+/, " ")
@@ -729,13 +793,12 @@ class KeyBindingTree
       @next_command_count = nil
     end
 
-    if cnf.kbd.show_prev_action? and trail_str.class==String
+    if cnf.kbd.show_prev_action? and trail_str.class == String
       len_limit = 35
       action_desc = "UNK"
       if action.class == String && (m = action.match(/\Abuf\.insert_txt\((.+)\)\z/))
         char_part = m[1].gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
         action_desc = "insert #{char_part}"
-        puts action_desc.inspect
       else
         action_desc = vma.actions[action]&.method_name || action.to_s
         action_desc = action_desc[0..len_limit] if action_desc.size > len_limit
@@ -750,6 +813,10 @@ def bindkey(key, action, keywords: "")
   vma.kbd.bindkey(key, action, keywords: keywords)
 end
 
+def unbindkey(key)
+  vma.kbd.unbindkey(key)
+end
+
 def add_keys(keywords, to_add)
   to_add.each { |key, value|
     bindkey(key, value, keywords: keywords)
@@ -763,11 +830,26 @@ def exec_action(action)
     return call_action(action)
   elsif action.class == Proc
     return action.call
+  elsif action.class == String && vma.actions.include?(action.to_sym)
+    # Symbols serialised through JSON become plain strings; dispatch them as actions.
+    return call_action(action.to_sym)
   else
     return eval(action)
   end
 end
 
+def show_free_key_bindings()
+  kbd_s = "❙Free key binding slots❙\n"
+  kbd_s << "\n⦁[Mode] <prefix> : <free keys>⦁\n"
+  kbd_s << "[B]=Browse, [C]=Command, [I]=Insert, [V]=Visual\n"
+  kbd_s << "Free = not yet bound under that prefix\n"
+  kbd_s << "===============================================\n"
+  kbd_s << vma.kbd.get_free_bindings
+  kbd_s << "\n"
+  b = create_new_buffer(kbd_s, "free-key-bindings")
+  gui_set_file_lang(b.id, "hyperplaintext")
+end
+
 def show_key_bindings()
   kbd_s = "❙Key bindings❙\n"
   kbd_s << "\n⦁[Mode] <keys> : <action>⦁\n"

data/lib/vimamsa/key_bindings_vimlike.rb

@@ -131,6 +131,7 @@ add_keys "core", {
   "I enter" => :insert_new_line,
 
 
+  "I shift-left" => "insert_select_move(BACKWARD_CHAR)",
   "I shift-right" => "insert_select_move(FORWARD_CHAR)",
   "I shift-down" => "insert_select_move(FORWARD_LINE)",
   "I shift-pagedown" => "insert_select_move(:pagedown)",
@@ -243,6 +244,8 @@ add_keys "core", {
 
   # Replace mode
   "X esc || X ctrl!" => "vma.kbd.to_previous_mode",
+  # "X p" => :paste_over_after, #TODO
+  "X ctrl-v" => :paste_over_before,
   "X <char>" => "buf.replace_with_char(<char>);buf.move(FORWARD_CHAR)",
 
   # Macros
@@ -265,6 +268,7 @@ add_keys "core", {
   "C @ <char>" => "vma.macro.run_macro(<char>)",
   "C , m S" => 'vma.macro.save_macro("a")',
   "C , m s" => "vma.macro.save",
+  "C , m h" => :show_message_history,
 
   # "C ." => "repeat_last_action", # TODO
   "VC ;" => "repeat_last_find",

data/lib/vimamsa/langservp.rb

@@ -90,7 +90,7 @@ class LangSrv
   end
 
   def handle_delta(delta, fpath, version)
-    fpuri = URI.join("file:///", fpath).to_s
+    fpuri = file_uri(fpath)
 
     # delta[0]: char position
     # delta[1]: INSERT or DELETE
@@ -147,7 +147,8 @@ class LangSrv
     # r = @resp.delete_at(0)
   end
 
-  def get_definition(fpuri, lpos, cpos)
+  def get_definition(fpath_or_uri, lpos, cpos)
+    fpuri = fpath_or_uri.start_with?("file://") ? fpath_or_uri : file_uri(fpath_or_uri)
     a = LSP::Interface::DefinitionParams.new(
       position: LSP::Interface::Position.new(line: lpos, character: cpos),
       text_document: LSP::Interface::TextDocumentIdentifier.new(uri: fpuri),
@@ -172,22 +173,175 @@ class LangSrv
     return nil
   end
 
-  def open_file(fp, fc = nil)
+  # LSP SymbolKind values for callable things
+  FUNCTION_KINDS = [6, 9, 12].freeze  # Function, Constructor, Method
+  CLASS_KINDS    = [5, 10, 11, 23].freeze  # Class, Module, Interface, Namespace
+
+  # Recursively collect symbols of function kinds.
+  # Handles both flat SymbolInformation[] and nested DocumentSymbol[] (with :children).
+  def collect_functions(symbols)
+    result = []
+    symbols.each do |s|
+      result << s if FUNCTION_KINDS.include?(s[:kind])
+      result.concat(collect_functions(s[:children])) if s[:children].is_a?(Array)
+    end
+    result
+  end
+
+  # Flatten all FUNCTION_KINDS from a symbol subtree into [{name:, line:}, ...].
+  def flatten_functions(symbols)
+    result = []
+    symbols.each do |s|
+      if FUNCTION_KINDS.include?(s[:kind])
+        line = s.dig(:range, :start, :line)
+        result << { name: s[:name], line: line ? line + 1 : 0 }
+      end
+      result.concat(flatten_functions(s[:children])) if s[:children].is_a?(Array)
+    end
+    result
+  end
+
+  # Build groups from a nested DocumentSymbol[].
+  # Returns [{name:, line:, functions: [{name:, line:}, ...]}, ...]
+  # name: nil = top-level (ungrouped) functions.
+  def collect_groups_nested(symbols)
+    groups = []
+    top_funcs = []
+    symbols.each do |s|
+      if CLASS_KINDS.include?(s[:kind])
+        line = s.dig(:range, :start, :line)
+        funcs = s[:children].is_a?(Array) ? flatten_functions(s[:children]) : []
+        groups << { name: s[:name], line: line ? line + 1 : 0, functions: funcs }
+      elsif FUNCTION_KINDS.include?(s[:kind])
+        line = s.dig(:range, :start, :line)
+        top_funcs << { name: s[:name], line: line ? line + 1 : 0 }
+      end
+    end
+    groups.unshift({ name: nil, line: nil, functions: top_funcs }) unless top_funcs.empty?
+    groups
+  end
+
+  # Build groups from a flat SymbolInformation[] using :containerName.
+  def collect_groups_flat(symbols)
+  
+    by_container = {}
+    symbols.each do |s|
+      next unless FUNCTION_KINDS.include?(s[:kind])
+      container = s[:containerName] || ""
+      line = s.dig(:location, :range, :start, :line)
+      by_container[container] ||= []
+      by_container[container] << { name: s[:name], line: line ? line + 1 : 0 }
+    end
+    groups = []
+    top_funcs = by_container.delete("") || []
+    by_container.keys.sort.each do |container|
+      groups << { name: container, line: 0, functions: by_container[container] }
+    end
+    groups << { name: nil, line: nil, functions: top_funcs } unless top_funcs.empty?
+    
+    groups
+  end
+
+  # Send textDocument/documentSymbol and return [{name:, line:}, ...] for functions/methods.
+  # Returns nil on error, empty array if no functions found.
+  def document_functions(fpath)
+    ensure_file_open(fpath)
+    fpuri = file_uri(fpath)
+    a = LSP::Interface::DocumentSymbolParams.new(
+      text_document: LSP::Interface::TextDocumentIdentifier.new(uri: fpuri),
+    )
+    id = new_id
+    @writer.write(id: id, params: a, method: "textDocument/documentSymbol")
+    r = wait_for_response(id)
+    return nil if r.nil?
+
+    symbols = r[:result]
+    return nil if !symbols.is_a?(Array)
+
+    functions = collect_functions(symbols)
+    functions.map do |s|
+      line = s.dig(:range, :start, :line) || s.dig(:location, :range, :start, :line)
+      { name: s[:name], line: line ? line + 1 : 0 }
+    end
+  end
+
+  # Like document_functions but returns functions grouped by class/module.
+  # Returns [{name:, line:, functions: [{name:, line:}, ...]}, ...]
+  # name: nil means top-level (ungrouped) functions.
+  def document_functions_grouped(fpath)
+    ensure_file_open(fpath)
+    fpuri = file_uri(fpath)
+    a = LSP::Interface::DocumentSymbolParams.new(
+      text_document: LSP::Interface::TextDocumentIdentifier.new(uri: fpuri),
+    )
+    id = new_id
+    @writer.write(id: id, params: a, method: "textDocument/documentSymbol")
+    r = wait_for_response(id)
+    return nil if r.nil?
+
+    symbols = r[:result]
+    return nil unless symbols.is_a?(Array)
+
+    # Detect nested (DocumentSymbol) vs flat (SymbolInformation) format
+    if symbols.any? { |s| s.key?(:children) }
+      collect_groups_nested(symbols)
+    else
+      collect_groups_flat(symbols)
+    end
+  end
+
+  # Send textDocument/documentSymbol, filter to functions/methods, and puts them.
+  def print_functions(fpath)
+    funcs = document_functions(fpath)
+    if funcs.nil? || funcs.empty?
+      puts "(no functions found in #{File.basename(fpath)})"
+      return
+    end
+
+    puts "=== Functions in #{File.basename(fpath)} ==="
+    funcs.each do |f|
+      line_str = f[:line] > 0 ? ":#{f[:line]}" : ""
+      puts "  #{f[:name]}#{line_str}"
+    end
+  end
+
+  def file_uri(fp)
+    URI.join("file:///", fp).to_s
+  end
+
+  def open_file(fp, fc = nil, lang: nil)
     debug "open_file", 2
+    @opened_files ||= {}
+    fpuri = file_uri(fp)
     fc = IO.read(fp) if fc.nil?
-
-    encoded_filepath = URI.encode_www_form_component(fp)
-    fpuri = URI.parse("file://#{encoded_filepath}")
+    lang ||= @lang
 
     a = LSP::Interface::DidOpenTextDocumentParams.new(
       text_document: LSP::Interface::TextDocumentItem.new(
         uri: fpuri,
         text: fc,
-        language_id: "c++",
+        language_id: lang,
         version: 1,
       ),
     )
 
     @writer.write(method: "textDocument/didOpen", params: a)
+    @opened_files[fpuri] = true
+  end
+
+  def ensure_file_open(fp, fc = nil)
+    @opened_files ||= {}
+    fpuri = file_uri(fp)
+    open_file(fp, fc) unless @opened_files[fpuri]
+  end
+end
+
+def lsp_print_functions
+  return unless vma.buf&.fname
+  lsp = LangSrv.get(vma.buf.lang)
+  if lsp.nil?
+    message("No LSP server available for #{vma.buf.lang}")
+    return
   end
+  lsp.print_functions(vma.buf.fname)
 end

data/lib/vimamsa/macro.rb

@@ -26,22 +26,51 @@ class Macro
   attr_reader :running_macro
   attr_accessor :recorded_macros, :recording, :named_macros, :last_macro
 
+  NAMED_MACROS_FILE = "named_macros.json"
+
   def initialize()
     @recording = false
-    # @recorded_macros = {}
     @current_recording = []
     @current_name = nil
     @last_macro = "a"
     @running_macro = false
 
-    #TODO:
     @recorded_macros = vma.marshal_load("macros", {})
-    @named_macros = vma.marshal_load("named_macros", {})
+    @named_macros = load_named_macros
     vma.hook.register(:shutdown, self.method("save"))
   end
 
+  def named_macros_path
+    get_dot_path(NAMED_MACROS_FILE)
+  end
+
+  # Save named macros as JSON immediately — called automatically after name_macro.
+  def save_named_macros
+    require "json"
+    File.write(named_macros_path, JSON.pretty_generate(@named_macros))
+  rescue => e
+    error("Failed to save named macros: #{e}")
+  end
+
+  # Load named macros from JSON. Falls back to Marshal data from older versions.
+  def load_named_macros
+    require "json"
+    path = named_macros_path
+    if File.exist?(path)
+      data = JSON.parse(File.read(path))
+      # JSON keys are always strings; action lists are arrays of strings — correct types
+      return data
+    end
+    # Fallback: migrate from old Marshal-based storage
+    vma.marshal_load("named_macros", {})
+  rescue => e
+    error("Failed to load named macros: #{e}")
+    {}
+  end
+
   def save()
     vma.marshal_save("macros", @recorded_macros)
+    # named_macros are kept current via save_named_macros; save a Marshal copy as backup
     vma.marshal_save("named_macros", @named_macros)
   end
 
@@ -56,17 +85,31 @@ class Macro
     $macro_search_list = l
     $select_keys = ["h", "l", "f", "d", "s", "a", "g", "z"]
 
+    delete_cb = proc { |name, refresh|
+      Gui.confirm("Delete macro '#{name}'?", proc {
+        vma.macro.delete_named_macro(name)
+        refresh.call
+      })
+    }
+
     gui_select_update_window(l, $select_keys.collect { |x| x.upcase },
                              "gui_find_macro_select_callback",
-                             "gui_find_macro_update_callback")
+                             "gui_find_macro_update_callback",
+                             { delete_callback: delete_cb })
+  end
+
+  def delete_named_macro(name)
+    @named_macros.delete(name)
+    save_named_macros
+    message("Macro '#{name}' deleted")
   end
 
   def name_macro(name, id = nil)
     debug "NAME MACRO #{name}"
-    if id.nil?
-      id = @last_macro
-    end
+    id = @last_macro if id.nil?
     @named_macros[name] = @recorded_macros[id].clone
+    save_named_macros
+    message("Macro '#{name}' saved")
   end
 
   def start_recording(name)
@@ -122,6 +165,8 @@ class Macro
     isok = true
     # if acts.kind_of?(Array) and acts.any?
     if acts.any?
+      vma.buf&.new_undo_group
+      vma.buf&.instance_variable_set(:@macro_group_active, true)
       @running_macro = true
       # TODO:needed?
       # set_last_command({ method: vma.macro.method("run_macro"), params: [name] })
@@ -138,6 +183,8 @@ class Macro
       end
     end
     @running_macro = false
+    vma.buf&.instance_variable_set(:@macro_group_active, false)
+    vma.buf&.new_undo_group
     buf.set_pos(buf.pos)
     # TODO: Should be a better way to trigger this. Sometimes need to wait for GTK to process things before updating the cursor.
     run_as_idle proc { vma.buf.refresh_cursor; vma.buf.refresh_cursor }, delay: 0.15

data/lib/vimamsa/rbvma.rb

@@ -33,6 +33,7 @@ require "vimamsa/gui_menu"
 require "vimamsa/gui_dialog"
 require "vimamsa/gui_settings"
 require "vimamsa/gui_file_panel"
+require "vimamsa/gui_func_panel"
 require "vimamsa/gui_select_window"
 require "vimamsa/gui_sourceview"
 require "vimamsa/gui_sourceview_autocomplete"
@@ -49,6 +50,7 @@ require "vimamsa/buffer_manager"
 require "vimamsa/constants"
 require "vimamsa/debug"
 require "vimamsa/tests"
+require "vimamsa/test_framework"
 require "vimamsa/easy_jump"
 require "vimamsa/encrypt"
 require "vimamsa/file_finder"