vimamsa 0.1.22 → 0.1.24

data/lib/vimamsa/key_binding_tree.rb

@@ -19,7 +19,7 @@
 #
 
 class State
-  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level, :cursor_type, :keywords
+  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level, :cursor_type, :keywords, :root, :parent
   attr_reader :cur_mode, :scope
 
   def initialize(key_name, eval_rule = "", ctype = :command, scope: :buffer)
@@ -31,6 +31,8 @@ class State
     @keywords = []
     @action = nil
     @level = 0
+    @root = self # parent of a parent ... until mode root
+    @parent = nil
     @cursor_type = ctype
   end
 
@@ -55,6 +57,7 @@ class KeyBindingTree
     @last_action = nil
     @cur_action = nil
     @method_handles_repeat = false
+    @overwriting_state = nil # A branch which has priority over other branches
 
     @modifiers = { :ctrl => false, :shift => false, :alt => false } # TODO: create a queue
     @last_event = [nil, nil, nil, nil, nil]
@@ -66,10 +69,12 @@ 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]
-    # @default_mode = label
-    @default_mode_stack << 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]
 
     __set_mode(label)
     if !vma.buf.nil?
@@ -258,17 +263,78 @@ class KeyBindingTree
   end
 
   def set_state_to_root
+    # if root state is a minor mode
     if @mode_root_state.major_modes.size == 1
-      modelabel = @mode_root_state.major_modes[0]
-      mmode = @modes[modelabel]
-      @match_state = [@mode_root_state, mmode]
+      modelabel = @mode_root_state.major_modes[0] #TODO: support multiple inheritance?
+      parent_mode = @modes[modelabel]
+      # Have two branches for the matching (both major and minor modes)
+      # @mode_root_state = minor, parent_mode = major
+      @match_state = [@mode_root_state, parent_mode]
+      @overwriting_state = @mode_root_state # States from this branch have priority over others.
     else
+      # if root state is a major mode
+      @overwriting_state = nil
       @match_state = [@mode_root_state]
     end
 
     @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, ""]]
@@ -378,7 +444,13 @@ class KeyBindingTree
           mmid = st.major_modes.first
           trailpfx = "#{@modes[mmid].to_s}>"
         end
-        s_trail << "[#{trailpfx}#{st.to_s}]"
+        mode_str = st.to_s
+        mode_str = "COMMAND" if mode_str == "C"
+        mode_str = "INSERT" if mode_str == "I"
+        mode_str = "VISUAL" if mode_str == "V"
+        mode_str = "BROWSE" if mode_str == "B"
+
+        s_trail << "[#{trailpfx}#{mode_str}]"
       else
         s_trail << " #{st.to_s}"
       end
@@ -491,7 +563,31 @@ class KeyBindingTree
       state_with_children = new_state.select { |s| s.children.any? }
       s_act = new_state.select { |s| s.action != nil }
 
-      if s_act.any? #and !state_with_children.any?
+      # Multiple matching states/modes (search has forked)
+      if new_state.size > 1
+        # puts "AAA"
+        # Conflict: One of them has actions (matching should stop),
+        # another has children (matching should continue)
+        if s_act.any? and state_with_children.any?
+          # puts "AAA1"
+          a = s_act[0]
+          b = state_with_children[0]
+          # Running major+minor mode. Minor mode overwriting the major mode
+          if a.root == @overwriting_state or b.root == @overwriting_state
+            # puts "AAA3:del"
+            # Remove those states not belonging to the overwriting branch (minor mode)
+            [s_act, state_with_children, new_state].each { |z| z.delete_if { |x| x.root != @overwriting_state } }
+          end
+        end
+      end
+      # new_state[0].root.key_name
+
+      if s_act.any? and state_with_children.any?
+        # debug "Conflict: s_act.any? and state_with_children.any?"
+        # require "pry"; binding.pry
+      end
+
+      if s_act.any? and !state_with_children.any?
         eval_s = s_act.first.action if eval_s == nil
         # if eval_s.to_s.match(/end_recording/)
         # require "pry"; binding.pry
@@ -537,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+/, " ")
@@ -625,6 +729,8 @@ class KeyBindingTree
         end
         s1 = new_state
         @cur_state.children << new_state
+        new_state.root = @cur_state.root
+        new_state.parent = @cur_state
       end
 
       set_state(key_name, eval_rule) # TODO: check is ok?
@@ -639,6 +745,7 @@ class KeyBindingTree
   end
 
   def handle_key_bindigs_action(action, c)
+    trail_str = get_state_trail_str[0]
     # $acth << action #TODO:needed here?
     @method_handles_repeat = false #TODO:??
     n = 1
@@ -685,6 +792,20 @@ class KeyBindingTree
     if !(action.class == String and action.include?("set_next_command_count"))
       @next_command_count = nil
     end
+
+    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}"
+      else
+        action_desc = vma.actions[action]&.method_name || action.to_s
+        action_desc = action_desc[0..len_limit] if action_desc.size > len_limit
+      end
+      trail_str = trail_str.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+      vma.gui.action_trail_label.markup = "<span weight='bold'>#{action_desc}|#{trail_str}</span>"
+    end
   end
 end
 
@@ -692,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)
@@ -705,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"
@@ -734,6 +874,12 @@ def show_key_bindings()
   done.concat(x.lines); kbd_s << x
   kbd_s << "\n"
 
+  kbd_s << "◼ Hyper Plaintext\n"
+  x = vma.kbd.get_by_keywords(modes: ["C"], keywords: ["hyperplaintext"])
+  x2 = vma.kbd.get_by_keywords(modes: ["V"], keywords: ["hyperplaintext"])
+  done.concat(x.lines); kbd_s << x << "\n" << x2
+  kbd_s << "\n"
+
   kbd_s << "◼ Core\n"
   x = vma.kbd.get_by_keywords(modes: [], keywords: ["core"])
   x << vma.kbd.get_by_keywords(modes: ["X"], keywords: ["intro"])

data/lib/vimamsa/key_bindings_vimlike.rb

@@ -42,6 +42,14 @@ def insert_move(op)
 end
 
 add_keys "intro", {
+  "VCX up" => "buf.move(BACKWARD_LINE)",
+  "VCX down" => "buf.move(FORWARD_LINE)",
+  "VCX right" => "buf.move(FORWARD_CHAR)",
+  "VCX left" => "buf.move(BACKWARD_CHAR)",
+ "C , b" => :start_buf_manager,
+  "VC l" => "buf.move(FORWARD_CHAR)",
+  "VC , , s" => :search_actions,
+  "C , n b" => :buf_new,
   "C y y" => :copy_cur_line,
   "C P" => :paste_before_cursor,
   "C p" => :paste_after_cursor,
@@ -70,6 +78,20 @@ add_keys "intro", {
   "IX ctrl-n" => :move_next_line,
   "IX ctrl-b" => :move_backward_char,
   "IX ctrl-a" => :jump_beginning_of_line,
+  
+  "CI ctrl-v" => :paste_before_cursor,
+  "I ctrl-c" => :copy_selection, #TODO: in control mode also?
+  "CI ctrl-x" => :cut_selection,
+  "CI ctrl-z" => :undo,
+  "CI ctrl-w" => :close_current_buffer,
+  "I ctrl-y" => :redo,
+  "CI backspace" => :insert_backspace,
+ "CI ctrl-o" => :open_file_dialog,
+ "I ctrl-l" => :find_in_buffer,
+ "I ctrl-g" => :find_next,
+  
+  "I shift-up" => :insert_select_up,
+  "I shift-down" => :insert_select_down, 
 }
 
 add_keys "intro delete", {
@@ -83,21 +105,16 @@ add_keys "core", {
   # File handling
   "C ctrl-s" => :buf_save,
 
+  "V J" => :V_join_lines,
   # Buffer handling
   # "C B" => "bufs.switch",
   "C tab" => "bufs.switch_to_last_buf",
   #    'C , s'=> 'gui_select_buffer',
   "C , r v b" => :buf_revert,
   "C , c b" => "bufs.close_current_buffer",
-  "C , n b" => :buf_new,
   # "C , , ." => "backup_all_buffers()",
-  "VC , , s" => :search_actions,
 
   # MOVING
-  #    'VC h' => 'buf.move(BACKWARD_CHAR)',
-  "VC l" => "buf.move(FORWARD_CHAR)",
-  # "VC j" => "buf.move(FORWARD_LINE)",
-  # "VC k" => "buf.move(BACKWARD_LINE)",
 
   "VCI pagedown" => :page_down,
   "VCI pageup" => :page_up,
@@ -113,10 +130,10 @@ add_keys "core", {
 
   "I enter" => :insert_new_line,
 
-  "I shift-down" => "insert_select_move(BACKWARD_CHAR)",
+
+  "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-up" => "insert_select_move(BACKWARD_LINE)",
   "I shift-pagedown" => "insert_select_move(:pagedown)",
   "I shift-pageup" => "insert_select_move(:pageup)",
 
@@ -127,14 +144,6 @@ add_keys "core", {
   "I pagedown" => "insert_move(:pagedown)",
   "I pageup" => "insert_move(:pageup)",
 
-  #TODO:
-  "I @shift-click" => "insert_mode_shift_click(charpos)",
-
-  "VCX left" => "buf.move(BACKWARD_CHAR)",
-  "VCX right" => "buf.move(FORWARD_CHAR)",
-  "VCX down" => "buf.move(FORWARD_LINE)",
-  "VCX up" => "buf.move(BACKWARD_LINE)",
-
   #    'C '=> 'buf.jump_word(BACKWARD,END)',#TODO
   "VC f <char>" => "buf.jump_to_next_instance_of_char(<char>)",
   "VC F <char>" => "buf.jump_to_next_instance_of_char(<char>,BACKWARD)",
@@ -159,7 +168,7 @@ add_keys "core", {
 
   "R <char>" => "readchar_new_char(<char>)",
 
-  "C n" => "$search.jump_to_next()",
+  "C n" => :find_next,
   "C N" => "$search.jump_to_previous()",
 
   "C C" => :content_search,
@@ -224,8 +233,6 @@ add_keys "core", {
   # "V ctrl-c" => "buf.comment_selection",
   "V ctrl-x" => "buf.comment_selection(:uncomment)",
 
-  "CI ctrl-v" => "buf.paste(BEFORE)",
-  "CI backspace" => "buf.delete(BACKWARD_CHAR)",
 
   # Marks
   "CV m <char>" => "buf.mark_current_position(<char>)",
@@ -237,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
@@ -244,19 +253,22 @@ add_keys "core", {
   # "C q a" => 'vma.macro.start_recording("a")',
   
   "macro q" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
-  "macro q z" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
+  # "macro q z" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
   
   # "VC q(vma.macro.is_recording==true)" => "vma.macro.end_recording", # TODO: does not work
   # "VC o(vma.macro.is_recording==true)" => "vma.macro.end_recording", # TODO: does not work
   # "VC q q(vma.macro.is_recording==true)" => "vma.macro.end_recording",
   "VC q <char>" => "vma.kbd.set_mode(:macro);vma.macro.start_recording(<char>)",
   # 'C q'=> 'vma.macro.end_recording', #TODO
-  "C q v" => "vma.kbd.to_previous_mode; vma.macro.end_recording",
+  
+  # "C q v" => "vma.kbd.to_previous_mode; vma.macro.end_recording", #TODO
+  
   # 'C v'=> 'vma.macro.end_recording',
   # "C M" => 'vma.macro.run_last_macro',
   "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",
@@ -277,7 +289,6 @@ add_keys "core", {
   "I space" => 'buf.insert_txt(" ")',
 #  "I return" => 'buf.insert_new_line()',
 
- "CI ctrl-o" => :open_file_dialog,
  "C , a" => :ack_search,
  "C d w" => :delete_to_next_word_start,
 
@@ -305,19 +316,6 @@ add_keys "core", {
  "C , , u" => :update_file_index,
  "C , s a" => :buf_save_as,
  "VC , r r" => :gui_search_replace,
- "V , t b" => :set_style_bold,
- "V , t l" => :set_style_link,
- "V J" => :V_join_lines,
- "V , t c" => :clear_formats,
- "C , t h" => :set_line_style_heading,
- "C , t 1" => :set_line_style_h1,
- "C , t 2" => :set_line_style_h2,
- "C , t 3" => :set_line_style_h3,
- "C , t 4" => :set_line_style_h4,
- "C , t b" => :set_line_style_bold,
- "C , t t" => :set_line_style_title,
- "C , t c" => :clear_line_styles,
- "C , b" => :start_buf_manager,
  "C , w" => :toggle_active_window,
  "C , , w" => :toggle_two_column,
 
@@ -341,6 +339,20 @@ add_keys "core", {
  "V a d" => [:delete_append_selection, proc { buf.delete(SELECTION, :append) }, "Delete and append selection"]
 }
 
+add_keys "hyperplaintext", {
+  "V , t b" => :set_style_bold,
+  "V , t l" => :set_style_link,
+  "V , t c" => :clear_formats,
+  "C , t h" => :set_line_style_heading,
+  "C , t 1" => :set_line_style_h1,
+  "C , t 2" => :set_line_style_h2,
+  "C , t 3" => :set_line_style_h3,
+  "C , t 4" => :set_line_style_h4,
+  "C , t b" => :set_line_style_bold,
+  "C , t t" => :set_line_style_title,
+  "C , t c" => :clear_line_styles,
+}
+
 bindkey ["VCB M", "B m"], :run_last_macro
 
 add_keys "experimental", {
@@ -352,6 +364,7 @@ add_keys "experimental", {
   # "CV , R" => "restart_application", #TODO: does not work
   "I ctrl-h" => :show_autocomplete, #TODO: does not work
   "C , d m" => :kbd_dump_state,
+  "C , ; ." => :increment_word,
   "C , d d" => "debug_dump_deltas",
   "C , d c" => "debug_dump_clipboard",
   "C , d b" => "debug_print_buffer",

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