vimamsa 0.1.9 → 0.1.11

data/lib/vimamsa/hyper_plain_text.rb

@@ -3,8 +3,8 @@ def hpt_check_cur_word(w)
   m = w.match(/⟦(.*)⟧/)
   if m
     fpfx = m[1]
-    if $buffer.fname
-      dn = File.dirname($buffer.fname)
+    if vma.buf.fname
+      dn = File.dirname(vma.buf.fname)
 
       fcands = []
       if fpfx[0] != "/"
@@ -51,6 +51,35 @@ def translate_path(fn, bf)
   return outfn
 end
 
+# Scan audio files inserted with ⟦audio:filepath⟧ syntax
+#TODO: merge code with hpt_scan_images
+def hpt_scan_audio(bf = nil)
+  bf = buf() if bf.nil?
+  return if bf.nil?
+  return if !bf.fname
+  return if !bf.fname.match(/.*txt$/)
+  imgpos = scan_indexes(bf, /⟦audio:.+?⟧/)
+  imgtags = bf.scan(/(⟦audio:(.+?)⟧)/)
+  c = 0
+  imgpos.each.with_index { |x, i|
+    a = imgpos[i]
+    t = imgtags[i]
+    insert_pos = a + t[0].size + c
+    fn = t[1]
+    imgfn = translate_path(fn, bf)
+    next if !File.exist?(imgfn)
+    # Show as image in gui, handle as empty space in txt file
+
+    if bf[insert_pos..(insert_pos + 2)] != "\n \n"
+      bf.insert_txt_at("\n \n", insert_pos)
+      bf.view.handle_deltas
+      c += 3
+    end
+    bf.add_audio(imgfn, insert_pos + 1)
+  }
+  # vma.gui.delex.run #TODO:gtk4
+end
+
 # Scan images inserted with ⟦img:filepath⟧ syntax
 def hpt_scan_images(bf = nil)
   bf = buf() if bf.nil?
@@ -76,5 +105,9 @@ def hpt_scan_images(bf = nil)
     end
     bf.add_image(imgfn, insert_pos + 1)
   }
-  vma.gui.delex.run
+
+  # Need to scale after buffer loaded
+  GLib::Idle.add(proc { vma.gui.scale_all_images })
+
+  # vma.gui.delex.run #TODO:gtk4
 end

data/lib/vimamsa/key_actions.rb

@@ -28,6 +28,9 @@ def is_visual_mode()
   return 0
 end
 
+reg_act(:lsp_debug, proc { vma.buf.lsp_get_def }, "LSP get definition")
+reg_act(:lsp_jump_to_definition, proc { vma.buf.lsp_jump_to_def }, "LSP jump to definition")
+
 reg_act(:enable_debug, proc { $debug = true }, "Enable debug")
 reg_act(:disable_debug, proc { $debug = false }, "Disable debug")
 
@@ -48,6 +51,8 @@ reg_act(:jump_to_random, proc { buf.jump_to_random_pos }, "")
 reg_act(:insert_new_line, proc { buf.insert_new_line() }, "")
 reg_act(:show_key_bindings, proc { show_key_bindings }, "Show key bindings")
 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")
+
 # reg_act(:encrypt_file, proc{buf.set_encrypted},"Set current file to encrypt on save")
 reg_act(:encrypt_file, proc { encrypt_cur_buffer }, "Set current file to encrypt on save")
 reg_act(:set_unencrypted, proc { buf.set_unencrypted }, "Set current file to save unencrypted")
@@ -80,8 +85,9 @@ reg_act(:diff_buffer, "diff_buffer", "")
 # reg_act(:invoke_grep_search, proc{invoke_grep_search}, "")
 reg_act(:invoke_grep_search, proc { gui_grep }, "Grep current buffer")
 reg_act(:ack_search, proc { gui_ack }, "") #invoke_ack_search
-reg_act :update_file_index, proc { update_file_index }, "Update file index"
+reg_act :update_file_index, proc { FileFinder.update_index }, "Update file index"
 reg_act :delete_to_word_end, proc { buf.delete2(:to_word_end) }, "Delete to file end", { :group => [:edit, :basic] }
+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 :start_browse_mode, proc { $kbd.set_mode(:browse); $kbd.set_default_mode(:browse) }, "Start browse mode"
 reg_act :exit_browse_mode, proc {
@@ -146,6 +152,12 @@ act_list = {
   :search_actions => { :proc => proc { search_actions },
                        :desc => "Search actions", :group => :search },
 
+  :toggle_active_window => { :proc => proc { vma.gui.toggle_active_window },
+                             :desc => "Toggle active window", :group => :search },
+
+  :toggle_two_column => { :proc => proc { vma.gui.set_two_column },
+                          :desc => "Set two column mode", :group => :search },
+
   :content_search => { :proc => proc { FileContentSearch.start_gui },
                        :desc => "Search content of files", :group => :search },
 

data/lib/vimamsa/key_binding_tree.rb

@@ -15,7 +15,7 @@
 # 'C , r v b'=> 'revert_buffer',
 #
 # In insert mode: press and hold ctrl, press "a"
-# 'I ctrl-a'=> '$buffer.jump(BEGINNING_OF_LINE)',
+# 'I ctrl-a'=> 'vma.buf.jump(BEGINNING_OF_LINE)',
 #
 
 $cnf = {} # TODO
@@ -36,15 +36,17 @@ setcnf :indent_based_on_last_line, true
 setcnf :extensions_to_open, [".txt", ".h", ".c", ".cpp", ".hpp", ".rb", ".inc", ".php", ".sh", ".m", ".gd", ".js"]
 
 class State
-  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level
+  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level, :cursor_type
+  attr_reader :cur_mode
 
-  def initialize(key_name, eval_rule = "")
+  def initialize(key_name, eval_rule = "", ctype = :command)
     @key_name = key_name
     @eval_rule = eval_rule
     @children = []
     @major_modes = []
     @action = nil
     @level = 0
+    @cursor_type = ctype
   end
 
   def to_s()
@@ -53,7 +55,7 @@ class State
 end
 
 class KeyBindingTree
-  attr_accessor :C, :I, :cur_state, :root, :match_state, :last_action, :cur_action
+  attr_accessor :C, :I, :cur_state, :root, :match_state, :last_action, :cur_action, :modifiers
   attr_reader :mode_root_state, :state_trail, :act_bindings
 
   def initialize()
@@ -66,7 +68,7 @@ class KeyBindingTree
     @last_action = nil
     @cur_action = nil
 
-    @modifiers = [] # TODO: create a queue
+    @modifiers = { :ctrl => false, :shift => false, :alt => false } # TODO: create a queue
     @last_event = [nil, nil, nil, nil, nil]
 
     @override_keyhandling_callback = nil
@@ -84,9 +86,8 @@ class KeyBindingTree
     set_mode(@default_mode)
   end
 
-  # $kbd.add_mode("I", :insert)
-  def add_mode(id, label)
-    mode = State.new(id)
+  def add_mode(id, label, cursortype = :command, name: nil)
+    mode = State.new(id, "", cursortype)
     mode.level = 1
     @modes[label] = mode
     @root.children << mode
@@ -95,6 +96,7 @@ class KeyBindingTree
     end
   end
 
+  # Add keyboard key binding mode based on another mode
   def add_minor_mode(id, label, major_mode_label)
     mode = State.new(id)
     @modes[label] = mode
@@ -103,7 +105,7 @@ class KeyBindingTree
   end
 
   def clear_modifiers()
-    @modifiers = []
+    # @modifiers = [] #TODO:remove?
   end
 
   def find_state(key_name, eval_rule)
@@ -174,14 +176,27 @@ class KeyBindingTree
         end
       end
     end
+    @cur_mode = label
+
+    if !vma.gui.view.nil?
+      vma.gui.view.draw_cursor()  #TODO: handle outside this class
 
-    $view.draw_cursor()
+      # Ripl.start :binding => binding
+    end
   end
 
   def cur_mode_str()
     return @mode_root_state.key_name
   end
 
+  def get_cursor_type
+    @mode_root_state.cursor_type
+  end
+
+  def get_mode
+    return @cur_mode
+  end
+
   def set_state(key_name, eval_rule = "")
     new_state = find_state(key_name, eval_rule)
     if new_state != nil
@@ -201,8 +216,6 @@ class KeyBindingTree
     end
 
     @state_trail = [@mode_root_state]
-    # debug get_state_trail_str()
-    # $next_command_count = nil # TODO: set somewhere else?
   end
 
   # Print key bindings to show as documentation or for debugging
@@ -274,8 +287,7 @@ class KeyBindingTree
   # if yes, change state to child
   # if no, go back to root
   def match_key_conf(c, translated_c, event_type)
-    # $cur_key_dict = $key_bind_dict[$context[:mode]]
-    print "MATCH KEY CONF: #{[c, translated_c]}" if $debug
+    debug "MATCH KEY CONF: #{[c, translated_c]}"
 
     if !@override_keyhandling_callback.nil?
       ret = @override_keyhandling_callback.call(c, event_type)
@@ -333,7 +345,7 @@ class KeyBindingTree
     end
 
     if new_state == nil
-      printf("NO MATCH") if $debug
+      debug("NO MATCH")
       if event_type == :key_press and c != "shift"
         # TODO:include other modifiers in addition to shift?
         set_state_to_root
@@ -485,17 +497,17 @@ class KeyBindingTree
         #   like '20j' => go to next line 20 times.
       end
     rescue SyntaxError
-      debug("SYNTAX ERROR with eval cmd #{action}: " + $!.to_s)
+      message("SYNTAX ERROR with eval cmd #{action}: " + $!.to_s)
       # rescue NoMethodError
       # debug("NoMethodError with eval cmd #{action}: " + $!.to_s)
       # rescue NameError
       # debug("NameError with eval cmd #{action}: " + $!.to_s)
       # raise
     rescue Exception => e
-      debug "BACKTRACE"
-      debug e.backtrace
-      debug e.inspect
-      debug "BACKTRACE END"
+      puts "BACKTRACE"
+      puts e.backtrace
+      puts e.inspect
+      puts "BACKTRACE END"
       if $!.class == SystemExit
         exit
       else

data/lib/vimamsa/key_bindings_vimlike.rb

@@ -1,3 +1,14 @@
+vma.kbd.add_mode("C", :command)
+vma.kbd.add_mode("I", :insert, :insert)
+vma.kbd.add_mode("V", :visual, :visual)
+vma.kbd.add_mode("M", :minibuffer) #TODO: needed?
+vma.kbd.add_mode("R", :readchar)
+vma.kbd.add_mode("B", :browse, :command)
+vma.kbd.add_mode("X", :replace, :command, name: "Replace")
+vma.kbd.set_default_mode(:command)
+vma.kbd.set_mode(:command)
+vma.kbd.show_state_trail
+
 bindkey ["VCB M", "B m"], :run_last_macro
 
 bindkey "VC s", :easy_jump
@@ -15,6 +26,11 @@ bindkey "C x", :delete_char_forward
 bindkey "C , , l t", :load_theme
 bindkey "C , f", :gui_file_finder
 bindkey "C , h", :gui_file_history_finder
+bindkey "C , z", :gui_file_finder
+
+bindkey "C ` k", :lsp_debug
+bindkey "C ` j", :lsp_jump_to_definition
+
 bindkey "C , r r", :gui_search_replace
 bindkey "V , r r", :gui_search_replace
 bindkey "V , t b", :set_style_bold
@@ -30,11 +46,15 @@ bindkey "C , t b", :set_line_style_bold
 bindkey "C , t t", :set_line_style_title
 bindkey "C , t c", :clear_line_styles
 bindkey "C , b", :start_buf_manager
+bindkey "C , w", :toggle_active_window
+bindkey "C , , w", :toggle_two_column
+
 # bindkey "C , f o", :open_file_dialog
 bindkey "CI ctrl-o", :open_file_dialog
 # bindkey "M enter", :minibuffer_end
 bindkey "C , a", :ack_search
-bindkey "C d w", :delete_to_word_end
+bindkey "C d w", :delete_to_next_word_start
+
 bindkey "C d 0", :delete_to_line_start
 bindkey "C , , f", :file_finder
 bindkey "VC h", :e_move_backward_char
@@ -66,6 +86,7 @@ bindkey "C d d", [:delete_line, proc { buf.delete_line }, "Delete current line"]
 bindkey "C enter || C return", [:line_action, proc { buf.handle_line_action() }, "Line action"]
 bindkey "C p", [:paste_after, proc { buf.paste(AFTER) }, ""] # TODO: implement as replace for visual mode
 bindkey "V d", [:delete_selection, proc { buf.delete(SELECTION) }, ""]
+bindkey "V a d", [:delete_append_selection, proc { buf.delete(SELECTION, :append) }, "Delete and append selection"]
 
 default_keys = {
 
@@ -78,7 +99,7 @@ default_keys = {
   #    'C , s'=> 'gui_select_buffer',
   "C , r v b" => :buf_revert,
   "C , c b" => "bufs.close_current_buffer",
-  #"C , b" => '$kbd.set_mode("S");gui_select_buffer',
+  #"C , b" => 'vma.kbd.set_mode("S");gui_select_buffer',
   "C , n b" => :buf_new,
   # "C , , ." => "backup_all_buffers()",
   "VC , , s" => :search_actions,
@@ -92,10 +113,10 @@ default_keys = {
   "VC pagedown" => "page_down",
   "VC pageup" => "page_up",
 
-  "VCI left" => "buf.move(BACKWARD_CHAR)",
-  "VCI right" => "buf.move(FORWARD_CHAR)",
-  "VCI down" => "buf.move(FORWARD_LINE)",
-  "VCI up" => "buf.move(BACKWARD_LINE)",
+  "VCIX left" => "buf.move(BACKWARD_CHAR)",
+  "VCIX right" => "buf.move(FORWARD_CHAR)",
+  "VCIX down" => "buf.move(FORWARD_LINE)",
+  "VCIX up" => "buf.move(BACKWARD_LINE)",
 
   "VC w" => "buf.jump_word(FORWARD,WORD_START)",
   "VC b" => "buf.jump_word(BACKWARD,WORD_START)",
@@ -131,7 +152,6 @@ default_keys = {
   "C n" => "$search.jump_to_next()",
   "C N" => "$search.jump_to_previous()",
 
-
   "C C" => :content_search,
 
   # Debug
@@ -144,11 +164,11 @@ default_keys = {
   "VC O" => "buf.jump(END_OF_LINE)",
   "VC $" => "buf.jump(END_OF_LINE)",
 
-  "C o" => 'buf.jump(END_OF_LINE);buf.insert_txt("\n");$kbd.set_mode(:insert)',
+  "C o" => 'buf.jump(END_OF_LINE);buf.insert_txt("\n");vma.kbd.set_mode(:insert)',
   "C X" => 'buf.jump(END_OF_LINE);buf.insert_txt("\n");',
-  "C A" => "buf.jump(END_OF_LINE);$kbd.set_mode(:insert)",
-  "C I" => "buf.jump(FIRST_NON_WHITESPACE);$kbd.set_mode(:insert)",
-  "C a" => "buf.move(FORWARD_CHAR);$kbd.set_mode(:insert)",
+  "C A" => "buf.jump(END_OF_LINE);vma.kbd.set_mode(:insert)",
+  "C I" => "buf.jump(FIRST_NON_WHITESPACE);vma.kbd.set_mode(:insert)",
+  "C a" => "buf.move(FORWARD_CHAR);vma.kbd.set_mode(:insert)",
   "C J" => "buf.join_lines()",
   "C u" => "buf.undo()",
 
@@ -197,7 +217,7 @@ default_keys = {
   "V g c" => :selection_capitalize,
   "V g s" => :selection_swapcase,
   "V g r" => :selection_reverse,
-  
+
   "VC j" => :forward_line,
   "VC k" => :backward_line,
 
@@ -213,8 +233,17 @@ default_keys = {
   'CV \' <char>' => "buf.jump_to_mark(<char>)",
   # "CV ''" =>'jump_to_mark(NEXT_MARK)', #TODO
 
-  "C i" => "$kbd.set_mode(:insert)",
-  "C ctrl!" => "$kbd.set_mode(:insert)",
+  # Switch to other mode
+  "C i" => "vma.kbd.set_mode(:insert)",
+  "C R" => "vma.kbd.set_mode(:replace)",
+  "C ctrl!" => "vma.kbd.set_mode(:insert)",
+  "C ctrl!" => "vma.kbd.set_mode(:insert)",
+  
+
+  # "R esc || R ctrl!" => "vma.kbd.set_mode(:command)",
+  "X esc" => "vma.kbd.set_mode(:command)",
+  "X ctrl!" => "vma.kbd.set_mode(:command)",
+  "X <char>" => "buf.replace_with_char(<char>);buf.move(FORWARD_CHAR)",
 
   # Macros
   # (experimental, may not work correctly)
@@ -235,22 +264,22 @@ default_keys = {
   # "CV Q" => :quit,
   "CV ctrl-q" => :quit,
   "CV , R" => "restart_application",
-  "I ctrl!" => "$kbd.set_mode(:command)",
+  "I ctrl!" => "vma.kbd.set_mode(:command)",
   "C shift!" => "buf.save",
   "I <char>" => "buf.insert_txt(<char>)",
-  "I esc" => "$kbd.set_mode(:command)",
+  "I esc" => "vma.kbd.set_mode(:command)",
 
   "I ctrl-d" => "buf.delete2(:to_word_end)",
 
-  # INSERT MODE: Moving
-  "I ctrl-a" => "buf.jump(BEGINNING_OF_LINE)",
-  "I ctrl-b" => "buf.move(BACKWARD_CHAR)",
-  "I ctrl-f" => "buf.move(FORWARD_CHAR)",
-  "I ctrl-n" => "buf.move(FORWARD_LINE)",
-  "I ctrl-p" => "buf.move(BACKWARD_LINE)",
-  "I ctrl-e" => "buf.jump(END_OF_LINE)", # context: mode:I, buttons down: {C}
-  "I alt-f" => "buf.jump_word(FORWARD,WORD_START)",
-  "I alt-b" => "buf.jump_word(BACKWARD,WORD_START)",
+  # Insert and Replace modes: Moving
+  "IX ctrl-a" => "buf.jump(BEGINNING_OF_LINE)",
+  "IX ctrl-b" => "buf.move(BACKWARD_CHAR)",
+  "IX ctrl-f" => "buf.move(FORWARD_CHAR)",
+  "IX ctrl-n" => "buf.move(FORWARD_LINE)",
+  "IX ctrl-p" => "buf.move(BACKWARD_LINE)",
+  "IX ctrl-e" => "buf.jump(END_OF_LINE)", # context: mode:I, buttons down: {C}
+  "IX alt-f" => "buf.jump_word(FORWARD,WORD_START)",
+  "IX alt-b" => "buf.jump_word(BACKWARD,WORD_START)",
 
   "I tab" => 'buf.insert_txt("	")',
   "I space" => 'buf.insert_txt(" ")',

data/lib/vimamsa/langservp.rb

@@ -0,0 +1,172 @@
+require "language_server-protocol"
+LSP = LanguageServer::Protocol
+
+class LangSrv
+  @@languages = {}
+  attr_accessor :error
+
+  def self.get(lang)
+    if @@languages[lang].nil?
+      @@languages[lang] = LangSrv.new(lang)
+      @@languages[lang] = nil if @@languages[lang].error
+    end
+    return @@languages[lang]
+  end
+
+  def new_id()
+    return @id += 1
+  end
+
+  def initialize(lang)
+    @error = true
+    clsp = conf(:custom_lsp)
+
+    # Use LSP server specified by user if available
+    @lang = lang
+    lspconf = clsp[lang]
+    if !lspconf.nil?
+      @io = IO.popen(lspconf[:command], "r+")
+    else
+      return nil
+    end
+    @writer = LSP::Transport::Io::Writer.new(@io)
+    @reader = LSP::Transport::Io::Reader.new(@io)
+    @id = 0
+
+    wf = []
+    for c in conf(:workspace_folders)
+      wf << LSP::Interface::WorkspaceFolder.new(uri: c[:uri], name: c[:name])
+    end
+
+    pid = Process.pid
+
+    if lspconf[:name] == "phpactor"
+      initp = LSP::Interface::InitializeParams.new(
+        process_id: pid,
+        root_uri: lspconf[:rooturi],
+        workspace_folders: wf,
+        capabilities: { 'workspace': { 'workspaceFolders': true } },
+      )
+    else
+      initp = LSP::Interface::InitializeParams.new(
+        process_id: pid,
+        root_uri: "null",
+        workspace_folders: wf,
+        capabilities: { 'workspace': { 'workspaceFolders': true } },
+      )
+    end
+    @resp = {}
+
+    @writer.write(id: new_id, params: initp, method: "initialize")
+
+    @lst = Thread.new {
+      @reader.read do |r|
+        @resp[r[:id]] = r
+        pp r
+        # exit
+      end
+    }
+    @error = false
+  end
+
+  def handle_delta(delta, fpath, version)
+    fpuri = URI.join("file:///", fpath).to_s
+
+    # delta[0]: char position
+    # delta[1]: INSERT or DELETE
+    # delta[2]: number of chars affected
+    # delta[3]: text to add in case of insert
+
+    changes = nil
+    if delta[1] == INSERT
+      changes = [{ 'rangeLength': 0, 'range': { 'start': { 'line': delta[4][0], 'character': delta[4][1] }, 'end': { 'line': delta[4][0], 'character': delta[4][1] } }, 'text': delta[3] }]
+    elsif delta[1] == DELETE
+      changes = [{ 'rangeLength': delta[2], 'range': { 'start': { 'line': delta[4][0], 'character': delta[4][1] }, 'end': { 'line': delta[5][0], 'character': delta[5][1] } }, 'text': "" }]
+    end
+    debug changes.inspect, 2
+
+    if !changes.nil?
+      a = LSP::Interface::DidChangeTextDocumentParams.new(
+        text_document: LSP::Interface::VersionedTextDocumentIdentifier.new(uri: fpuri, version: version),
+        content_changes: changes,
+      )
+      id = new_id
+      pp a
+      @writer.write(id: id, params: a, method: "textDocument/didChange")
+    end
+  end
+
+  def wait_for_response(id)
+    t = Time.now
+    debug "Waiting for response id:#{id}"
+    while @resp[id].nil?
+      sleep 0.03
+      if Time.now - t > 5
+        debug "Timeout LSP call id:#{id}"
+        return nil
+      end
+    end
+    debug "End waiting id:#{id}"
+    return @resp[id]
+  end
+
+  def add_workspaces() # TODO
+    # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_workspaceFolders
+    debug "Add workspaces", 2
+    a = [LSP::Interface::WorkspaceFolder.new(uri: "file:///...", name: "vimamsa")]
+    id = new_id
+    # @writer.write(id: id, params: a, method: "textDocument/definition")
+    # @writer.write(id: id, params: a, method: "workspace/workspaceFolders")
+    @writer.write(id: id, params: a, method: "workspace/didChangeWorkspaceFolders")
+    r = wait_for_response(id)
+    pp r
+  end
+
+  def handle_responses()
+    #TODO
+    # r = @resp.delete_at(0)
+  end
+
+  def get_definition(fpuri, lpos, cpos)
+    a = LSP::Interface::DefinitionParams.new(
+      position: LSP::Interface::Position.new(line: lpos, character: cpos),
+      text_document: LSP::Interface::TextDocumentIdentifier.new(uri: fpuri),
+    )
+    id = new_id
+    pp a
+    @writer.write(id: id, params: a, method: "textDocument/definition")
+    r = wait_for_response(id)
+    return nil if r.nil?
+    # Ripl.start :binding => binding
+    pp r
+    line = HSafe.new(r)[:result][0][:range][:start][:line].val
+    uri = HSafe.new(r)[:result][0][:uri].val
+
+    if !uri.nil? and !line.nil?
+      puts "LINE:" + line.to_s
+      puts "URI:" + uri
+      fpath = URI.parse(uri).path
+      line = line + 1
+      return [fpath, line]
+    end
+
+    return nil
+  end
+
+  def open_file(fp, fc = nil)
+    debug "open_file", 2
+    fc = IO.read(fp) if fc.nil?
+    fpuri = URI.join("file:///", fp).to_s
+
+    a = LSP::Interface::DidOpenTextDocumentParams.new(
+      text_document: LSP::Interface::TextDocumentItem.new(
+        uri: fpuri,
+        text: fc,
+        language_id: "c++",
+        version: 1,
+      ),
+    )
+
+    @writer.write(method: "textDocument/didOpen", params: a)
+  end
+end

data/lib/vimamsa/macro.rb

@@ -1,4 +1,3 @@
-
 def gui_find_macro_update_callback(search_str = "")
   debug "gui_find_macro_update_callback: #{search_str}"
   heystack = $macro.named_macros
@@ -24,7 +23,7 @@ def gui_find_macro_select_callback(search_str, idx)
 end
 
 class Macro
-  # attr_reader :recorded_macros, :recording, :named_macros
+  attr_reader :running_macro
   attr_accessor :recorded_macros, :recording, :named_macros, :last_macro
 
   def initialize()
@@ -33,11 +32,12 @@ class Macro
     @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", {})
-    $hook.register(:shutdown, self.method("save"))
+    vma.hook.register(:shutdown, self.method("save"))
   end
 
   def save()
@@ -52,15 +52,13 @@ class Macro
   end
 
   def find_macro_gui()
-    # Ripl.start :binding => binding
-
     l = $macro.named_macros.keys.sort.collect { |x| [x, 0] }
     $macro_search_list = l
     $select_keys = ["h", "l", "f", "d", "s", "a", "g", "z"]
 
     gui_select_update_window(l, $select_keys.collect { |x| x.upcase },
-                            "gui_find_macro_select_callback",
-                            "gui_find_macro_update_callback")
+                             "gui_find_macro_select_callback",
+                             "gui_find_macro_update_callback")
   end
 
   def name_macro(name, id = nil)
@@ -129,14 +127,16 @@ class Macro
     end
     acts = @recorded_macros[name]
     if acts.kind_of?(Array) and acts.any?
+      @running_macro = true
       set_last_command({ method: $macro.method("run_macro"), params: [name] })
       #
-      # Ripl.start :binding => binding
       for a in acts
         ret = exec_action(a)
         debug ret
         if ret == false
           message("Error while running macro")
+          Ripl.start :binding => binding
+
           break
         end
       end
@@ -144,6 +144,7 @@ class Macro
       # debug(eval_str)
       # eval(eval_str)
     end
+    @running_macro = false
     buf.set_pos(buf.pos)
   end
 

data/lib/vimamsa/main.rb

@@ -24,7 +24,6 @@ $command_history = []
 $clipboard = []
 $register = Hash.new("")
 $cnf = {}
-$search_dirs = []
 $errors = []
 
 $cur_register = "a"
@@ -37,15 +36,15 @@ $experimental = false
 
 # Return currently active buffer
 def buf()
-  return $buffer
+  return vma.buf
 end
 
 def bufs()
-  return $buffers
+  return vma.buffers
 end
 
 def buflist()
-  return $buffers
+  return vma.buffers
 end
 
 require "vimamsa/editor.rb"