vimamsa 0.1.13 → 0.1.15

data/lib/vimamsa/key_binding_tree.rb

@@ -18,31 +18,18 @@
 # 'I ctrl-a'=> 'vma.buf.jump(BEGINNING_OF_LINE)',
 #
 
-$cnf = {} # TODO
-
-def conf(id)
-  return $cnf[id]
-end
-
-def set_conf(id, val)
-  $cnf[id] = val
-end
-
-def setcnf(id, val)
-  set_conf(id, val)
-end
-
 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, :cursor_type
-  attr_reader :cur_mode
+  attr_reader :cur_mode, :scope
 
-  def initialize(key_name, eval_rule = "", ctype = :command)
+  def initialize(key_name, eval_rule = "", ctype = :command, scope: :buffer)
     @key_name = key_name
     @eval_rule = eval_rule
     @children = []
+    @scope = scope
     @major_modes = []
     @action = nil
     @level = 0
@@ -55,18 +42,21 @@ class State
 end
 
 class KeyBindingTree
-  attr_accessor :C, :I, :cur_state, :root, :match_state, :last_action, :cur_action, :modifiers
-  attr_reader :mode_root_state, :state_trail, :act_bindings
+  attr_accessor :C, :I, :cur_state, :root, :match_state, :last_action, :cur_action, :modifiers, :next_command_count, :method_handles_repeat, :default_mode
+  attr_reader :mode_root_state, :state_trail, :act_bindings, :default_mode_stack
 
   def initialize()
+    @next_command_count = nil
     @modes = {}
     @root = State.new("ROOT")
     @cur_state = @root # used for building the tree
     @default_mode = nil
+    @default_mode_stack = []
     @mode_history = []
     @state_trail = []
     @last_action = nil
     @cur_action = nil
+    @method_handles_repeat = false
 
     @modifiers = { :ctrl => false, :shift => false, :alt => false } # TODO: create a queue
     @last_event = [nil, nil, nil, nil, nil]
@@ -76,18 +66,62 @@ class KeyBindingTree
     @act_bindings = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
   end
 
-  def set_default_mode(label)
+  def set_mode(label)
     @match_state = [@modes[label]] # used for matching input
     @mode_root_state = @modes[label]
+    # @default_mode = label
+    @default_mode_stack << label
+
+    __set_mode(label)
+    if !vma.buf.nil?
+      # vma.buf.mode_stack = @default_mode_stack.clone
+    end
+  end
+
+  def set_default_mode(label)
+    @match_state = [@modes[label]]
+    @mode_root_state = @modes[label]
     @default_mode = label
+    set_mode_stack [label]
+  end
+
+  def set_mode_stack(ms)
+    debug "set_mode_stack(#{ms})", 2
+    show_caller if cnf.debug? # TODO: remove 
+    @default_mode_stack = ms
+    label = @default_mode_stack[-1]
+    @match_state = [@modes[label]]
+    @mode_root_state = @modes[label]
+  end
+
+  def dump_state
+    debug "dump_state", 2
+    pp ["@default_mode_stack", @default_mode_stack]
+    pp ["@default_mode", @default_mode]
+    pp ["vma.buf.mode_stack", vma.buf.mode_stack]
+    pp ["scope", self.get_scope]
+    # pp ["@mode_root_state", @mode_root_state]
+    # pp ["@match_state", @match_state]
   end
 
   def set_mode_to_default()
-    set_mode(@default_mode)
+    # set_mode(@default_mode)
+    set_mode_stack [@default_mode_stack[0]]
+    __set_mode(@default_mode_stack[0])
   end
 
-  def add_mode(id, label, cursortype = :command, name: nil)
-    mode = State.new(id, "", cursortype)
+  def to_previous_mode()
+    debug "to_previous_mode",2
+    pp @default_mode_stack
+    if @default_mode_stack.size > 1
+      @default_mode_stack.pop
+    end
+    pp @default_mode_stack
+    __set_mode(@default_mode_stack[-1])
+  end
+
+  def add_mode(id, label, cursortype = :command, name: nil, scope: :buffer)
+    mode = State.new(id, "", cursortype, scope: scope)
     mode.level = 1
     @modes[label] = mode
     @root.children << mode
@@ -100,6 +134,10 @@ class KeyBindingTree
   def add_minor_mode(id, label, major_mode_label)
     mode = State.new(id)
     @modes[label] = mode
+    if @root.nil?
+      show_caller
+      Ripl.start :binding => binding
+    end
     @root.children << mode
     mode.major_modes << major_mode_label
   end
@@ -161,7 +199,8 @@ class KeyBindingTree
     vma.gui.statnfo.markup = "<span weight='ultrabold'>#{st}</span>"
   end
 
-  def set_mode(label)
+  def __set_mode(label)
+    debug "__set_mode(#{label})"
     @mode_history << @mode_root_state
 
     # Check if label in form :label
@@ -178,13 +217,19 @@ class KeyBindingTree
     end
     @cur_mode = label
 
+    if self.get_scope != :editor and !vma.buf.nil?
+      vma.buf.mode_stack = @default_mode_stack.clone
+    end
+
     if !vma.gui.view.nil?
       vma.gui.view.draw_cursor()  #TODO: handle outside this class
-
-      # Ripl.start :binding => binding
     end
   end
 
+  def get_scope
+    @mode_root_state.scope
+  end
+
   def cur_mode_str()
     return @mode_root_state.key_name
   end
@@ -220,6 +265,7 @@ class KeyBindingTree
 
   # Print key bindings to show as documentation or for debugging
   def to_s()
+    # return self.class.to_s
     s = ""
     # @cur_state = @root
     stack = [[@root, ""]]
@@ -284,9 +330,21 @@ class KeyBindingTree
       act_s = cstate.action.to_s if cstate.action != nil
       children << "  #{cstate.to_s} #{act_s}\n"
     end
+    if !@next_command_count.nil?
+      s_trail << " #{@next_command_count}"
+    end
     return [s_trail, children]
   end
 
+  def set_next_command_count(num)
+    if @next_command_count != nil
+      @next_command_count = @next_command_count * 10 + num.to_i
+    else
+      @next_command_count = num.to_i
+    end
+    debug("NEXT COMMAND COUNT: #{@next_command_count}")
+  end
+
   # Modifies state of key binding tree (move to new state) based on received event
   # Checks child nodes of current state if they match received event
   # if yes, change state to child
@@ -354,7 +412,7 @@ class KeyBindingTree
       if event_type == :key_press and c != "shift"
         # TODO:include other modifiers in addition to shift?
         set_state_to_root
-        printf(", BACK TO ROOT") if $debug
+        printf(", BACK TO ROOT") if cnf.debug?
       end
 
       if event_type == :key_release and c == "shift!"
@@ -362,10 +420,10 @@ class KeyBindingTree
         # only on key release when no other key has been pressed
         # after said modifier key (shift).
         set_state_to_root
-        printf(", BACK TO ROOT") if $debug
+        printf(", BACK TO ROOT") if cnf.debug?
       end
 
-      printf("\n") if $debug
+      printf("\n") if cnf.debug?
     else
 
       # Don't execute action if one of the states has children
@@ -394,6 +452,8 @@ class KeyBindingTree
 
   def bindkey(key, action)
     if key.class != Array
+      # Handle syntax like :
+      # "X esc || X ctrl!" => "vma.kbd.to_previous_mode",
       key = key.split("||")
     end
 
@@ -424,10 +484,19 @@ class KeyBindingTree
     end
 
     m = key.match(/^(\S+)\s(\S.*)$/)
+    # Match/split e.g. "VC , , s" to "VC" and ", , s"
     if m
       modetmp = m[1]
       debug [key, modetmp, m].inspect
+
+      # If all of first word are uppercase, e.g. in
+      # "VCIX left" => "buf.move(BACKWARD_CHAR)",
+      # interpret as each char representing a mode
       modes = modetmp.split("") if modetmp.match(/^\p{Lu}+$/) # Uppercase
+
+      # If all of first word is down case, like in:
+      # bindkey "audio space", :audio_stop
+      # interpret as whole word representing a mode.
       modes = [modetmp] if modetmp.match(/^\p{Ll}+$/) # Lowercase
       keydef = m[2]
     else
@@ -440,7 +509,15 @@ class KeyBindingTree
     }
   end
 
+  # Binds a keyboard key combination to an action,
+  # for a given keyboard mode like insert ("I") or command ("C")
   def mode_bind_key(mode_id, keydef, action)
+    # debug "mode_bind_key #{mode_id.inspect}, #{keydef.inspect}, #{action.inspect}", 2
+    # Example:
+    # bindkey "C , f", :gui_file_finder
+    # mode_id = "C", keydef = ", f"
+    # and action = :gui_file_finder
+
     set_state(mode_id, "") # TODO: check is ok?
     start_state = @cur_state
 
@@ -448,23 +525,32 @@ class KeyBindingTree
 
     prev_state = nil
     s1 = start_state
-    k_arr.each { |i|
+
+    k_arr.each_with_index { |k, idx|
       # check if key has rules for context like q has in
       # "C q(cntx.recording_macro==true)"
-      match = /(.+)\((.*)\)/.match(i)
+      last_item = false
+      if k_arr.size - 1 == idx
+        last_item = true
+      end
+      match = /(.+)\((.*)\)/.match(k)
       eval_rule = ""
       if match
         key_name = match[1]
         eval_rule = match[2]
       else
-        key_name = i
+        key_name = k
       end
 
       prev_state = s1
       # Create a new state for key if it doesn't exist
       s1 = find_state(key_name, eval_rule)
-      if s1 == nil
+      if s1 == nil or last_item
         new_state = State.new(key_name, eval_rule)
+        if last_item
+          # Override existing key definition
+          @cur_state.children.delete(s1)
+        end
         s1 = new_state
         @cur_state.children << new_state
       end
@@ -481,11 +567,10 @@ class KeyBindingTree
 
   def handle_key_bindigs_action(action, c)
     $acth << action
-    $method_handles_repeat = false #TODO:??
+    @method_handles_repeat = false #TODO:??
     n = 1
-    if $next_command_count and !(action.class == String and action.include?("set_next_command_count"))
-      n = $next_command_count
-      # $next_command_count = nil
+    if @next_command_count and !(action.class == String and action.include?("set_next_command_count"))
+      n = @next_command_count
       debug("COUNT command #{n} times")
     end
 
@@ -493,15 +578,18 @@ class KeyBindingTree
       n.times do
         ret = exec_action(action)
 
-        if $macro.is_recording and ret != false
-          $macro.record_action(action)
+        if vma.macro.is_recording and ret != false
+          debug "RECORD ACTION:#{action}", 2
+          vma.macro.record_action(action)
         end
-        break if $method_handles_repeat
+        break if @method_handles_repeat
         # Some methods have specific implementation for repeat,
         #   like '5yy' => copy next five lines. (copy_line())
         # By default the same command is just repeated n times
         #   like '20j' => go to next line 20 times.
+        # But methods can also handle the number input themselves if vma.kbd.method_handles_repeat=true is set,
       end
+      # run_as_idle proc { vma.buf.refresh_cursor; vma.buf.refresh_cursor }, delay: 0.05
     rescue SyntaxError
       message("SYNTAX ERROR with eval cmd #{action}: " + $!.to_s)
       # rescue NoMethodError
@@ -521,8 +609,8 @@ class KeyBindingTree
       end
     end
 
-    if action.class == String and !action.include?("set_next_command_count")
-      $next_command_count = nil
+    if !(action.class == String and action.include?("set_next_command_count"))
+      @next_command_count = nil
     end
   end
 end

data/lib/vimamsa/key_bindings_vimlike.rb

@@ -3,21 +3,20 @@ 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("audio", :audio, :command)
 vma.kbd.add_minor_mode("audio", :audio, :command)
-vma.kbd.add_mode("B", :browse, :command)
+vma.kbd.add_mode("B", :browse, :command, scope: :editor)
 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
+vma.kbd.__set_mode(:command) #TODO:needed?
+# vma.kbd.show_state_trail
+
 
 bindkey ["VCB M", "B m"], :run_last_macro
 
 bindkey "VC s", :easy_jump
-bindkey "VC , m f", [:find_macro_gui, proc { $macro.find_macro_gui }, "Find named macro"]
-bindkey "C , m n", [:gui_name_macro, proc { $macro.gui_name_macro }, "Name last macro"]
+bindkey "VC , m f", [:find_macro_gui, proc { vma.macro.find_macro_gui }, "Find named macro"]
+bindkey "C , m n", [:gui_name_macro, proc { vma.macro.gui_name_macro }, "Name last macro"]
 bindkey "C , j r", :jump_to_random
-bindkey "I enter", :insert_new_line
 bindkey "C , ; s k", :show_key_bindings #TODO: better binding
 bindkey "C , , c b", :put_file_path_to_clipboard #TODO: better binding or remove?
 bindkey "C , , e", :encrypt_file #TODO: better binding
@@ -52,13 +51,13 @@ bindkey "C , w", :toggle_active_window
 bindkey "C , , w", :toggle_two_column
 
 bindkey "C , u s", :audio_stop
-bindkey "C m a", "vma.kbd.set_mode(:audio)"
+bindkey "C , m a", "vma.kbd.set_mode(:audio)"
 bindkey "audio s", :audio_stop
-bindkey "audio space", :audio_stop
-bindkey "audio q || audio esc", "vma.kbd.set_mode_to_default"
-
-
+bindkey "audio f || audio right", [:audio_forward, proc { Audio.seek_forward }, "Seek forward in audio stream"]
+bindkey "audio left", [:audio_backward, proc { Audio.seek_forward(-5.0) }, "Seek backward in audio stream"]
 
+bindkey "audio space", :audio_stop
+bindkey "audio q || audio esc", "vma.kbd.to_previous_mode"
 
 # bindkey "C , f o", :open_file_dialog
 bindkey "CI ctrl-o", :open_file_dialog
@@ -72,14 +71,16 @@ bindkey "VC h", :e_move_backward_char
 bindkey "C , , .", :backup_all_buffers
 bindkey "C z ", :start_browse_mode
 bindkey "B h", :history_switch_backwards
+# bindkey "B h", [:browse_file_backwards, proc { vma.kbd.to_previous_mode; call_action(:history_switch_backwards);  }, "Browse previous file"]
 bindkey "B l", :history_switch_forwards
 #bindkey 'B z', :center_on_current_line
 bindkey "B z", "center_on_current_line();call_action(:exit_browse_mode)"
 bindkey "B enter || B return || B esc || B j || B ctrl!", :exit_browse_mode
 bindkey "B s", :page_up
 bindkey "B d", :page_down
-bindkey "B s", :page_up
-bindkey "B d", :page_down
+bindkey "B r", proc { vma.gui.page_down(multip:0.25)}
+bindkey "B e", proc { vma.gui.page_up(multip:0.25)}
+
 bindkey "B i", :jump_to_start_of_buffer
 bindkey "B o", :jump_to_end_of_buffer
 bindkey "B c", :close_current_buffer
@@ -87,7 +88,6 @@ bindkey "B ;", "buf.jump_to_last_edit"
 bindkey "B q", :jump_to_last_edit
 bindkey "B w", :jump_to_next_edit
 # bindkey "C , d", :diff_buffer
-bindkey "C , g", :invoke_grep_search
 #bindkey 'C , g', proc{invoke_grep_search}
 bindkey "C , v", :auto_indent_buffer
 bindkey "C , , d", :savedebug
@@ -105,12 +105,11 @@ default_keys = {
   "C ctrl-s" => :buf_save,
 
   # Buffer handling
-  "C B" => "bufs.switch",
+  # "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 , b" => 'vma.kbd.set_mode("S");gui_select_buffer',
   "C , n b" => :buf_new,
   # "C , , ." => "backup_all_buffers()",
   "VC , , s" => :search_actions,
@@ -118,11 +117,22 @@ default_keys = {
   # 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)",
+  # "VC j" => "buf.move(FORWARD_LINE)",
+  # "VC k" => "buf.move(BACKWARD_LINE)",
 
-  "VC pagedown" => "page_down",
-  "VC pageup" => "page_up",
+  "VC pagedown" => :page_down,
+  "VC pageup" => :page_up,
+
+  "I down(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select_next",
+  "I tab(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select_next",
+  "I up(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select_previous",
+  "I shift-tab(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select_previous",
+  "I enter(vma.buf.view.autocp_active)" => "vma.buf.view.autocp_select",
+  
+  "I tab" => 'buf.insert_tab',
+  "I shift-tab" => 'buf.unindent',
+  
+  "I enter" => :insert_new_line,
 
   "VCIX left" => "buf.move(BACKWARD_CHAR)",
   "VCIX right" => "buf.move(FORWARD_CHAR)",
@@ -138,16 +148,16 @@ default_keys = {
   "VC f space" => "buf.jump_to_next_instance_of_char(' ')",
   "VC F space" => "buf.jump_to_next_instance_of_char(' ',BACKWARD)",
 
-  "VC /[1-9]/" => "set_next_command_count(<char>)",
+  "VC /[1-9]/" => "vma.kbd.set_next_command_count(<char>)",
   #    'VC number=/[0-9]/+ g'=> 'jump_to_line(<number>)',
   #    'VC X=/[0-9]/+ * Y=/[0-9]/+ '=> 'x_times_y(<X>,<Y>)',
-  "VC ^" => "buf.jump(BEGINNING_OF_LINE)",
-  "VC G($next_command_count!=nil)" => "buf.jump_to_line()",
-  "VC 0($next_command_count!=nil)" => "set_next_command_count(<char>)",
-  "VC 0($next_command_count==nil)" => "buf.jump(BEGINNING_OF_LINE)",
+  "VC G(vma.kbd.next_command_count!=nil)" => "buf.jump_to_line()",
+  "VC 0(vma.kbd.next_command_count!=nil)" => "set_next_command_count(<char>)",
+  "VC 0(vma.kbd.next_command_count==nil)" => "buf.jump(BEGINNING_OF_LINE)",
   # 'C 0'=> 'buf.jump(BEGINNING_OF_LINE)',
   "VC g g" => "buf.jump(START_OF_BUFFER)",
   "VC g ;" => "buf.jump_to_last_edit",
+  "VC ^" => "buf.jump(BEGINNING_OF_LINE)",
   "VC G" => "buf.jump(END_OF_BUFFER)",
   #    'VC z z' => 'center_on_current_line',
   "VC *" => "buf.jump_to_next_instance_of_word",
@@ -173,6 +183,7 @@ default_keys = {
   "C , d b" => "debug_print_buffer",
   "C , d c" => "debug_dump_clipboard",
   "C , d d" => "debug_dump_deltas",
+  "C , d m" => :kbd_dump_state,
   
   "VC O" => "buf.jump(END_OF_LINE)",
   "VC $" => "buf.jump(END_OF_LINE)",
@@ -186,11 +197,10 @@ default_keys = {
   "C u" => "buf.undo()",
 
   "C ^" => "buf.jump(BEGINNING_OF_LINE)",
-  "C /[1-9]/" => "set_next_command_count(<char>)",
+  # "C /[1-9]/" => "vma.kbd.set_next_command_count(<char>)",
 
   # Command mode only:
   "C ctrl-r" => "buf.redo()", # TODO:???
-  "C R" => "buf.redo()",
   "C v" => "buf.start_visual_mode",
   "C P" => "buf.paste(BEFORE)", # TODO: implement as replace for visual mode
   "C space <char>" => "buf.insert_txt(<char>)",
@@ -213,7 +223,7 @@ default_keys = {
   "C r <char>" => "buf.replace_with_char(<char>)", # TODO
   "C , l b" => "load_buffer_list",
   "C , l l" => "save_buffer_list",
-  "C , r <char>" => "set_register(<char>)", # TODO
+  "C , r <char>" => "vma.set_register(<char>)", # TODO
   "C , p <char>" => "buf.paste(BEFORE,<char>)", # TODO
 
   "C ctrl-c" => "buf.comment_line()",
@@ -247,30 +257,27 @@ default_keys = {
   'CV \' <char>' => "buf.jump_to_mark(<char>)",
   # "CV ''" =>'jump_to_mark(NEXT_MARK)', #TODO
 
-  # Switch to other mode
+  # Switch to another 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)",
+  # Replace mode
+  "X esc || X ctrl!" => "vma.kbd.to_previous_mode",
   "X <char>" => "buf.replace_with_char(<char>);buf.move(FORWARD_CHAR)",
 
   # Macros
   # (experimental, may not work correctly)
-  # "C q a" => '$macro.start_recording("a")',
-  "VC q <char>" => "$macro.start_recording(<char>)",
-  "VC q($macro.is_recording==true) " => "$macro.end_recording", # TODO
-  # 'C q'=> '$macro.end_recording', #TODO
-  "C q v" => "$macro.end_recording",
-  # 'C v'=> '$macro.end_recording',
-  # "C M" => '$macro.run_last_macro',
-  "C @ <char>" => "$macro.run_macro(<char>)",
-  "C , m S" => '$macro.save_macro("a")',
-  "C , m s" => "$macro.save",
+  # "C q a" => 'vma.macro.start_recording("a")',
+  "VC q <char>" => "vma.macro.start_recording(<char>)",
+  "VC q(vma.macro.is_recording==true) " => "$macro.end_recording", # TODO
+  # 'C q'=> 'vma.macro.end_recording', #TODO
+  "C q v" => "vma.macro.end_recording",
+  # '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 , t r" => "run_tests()",
 
   # "C ." => "repeat_last_action", # TODO
@@ -278,10 +285,10 @@ default_keys = {
   # "CV Q" => :quit,
   "CV ctrl-q" => :quit,
   "CV , R" => "restart_application",
-  "I ctrl!" => "vma.kbd.set_mode(:command)",
+  # "I ctrl!" => "vma.kbd.to_previous_mode",
   "C shift!" => "buf.save",
   "I <char>" => "buf.insert_txt(<char>)",
-  "I esc" => "vma.kbd.set_mode(:command)",
+  "I esc || I ctrl!" => "vma.kbd.to_previous_mode",
 
   "I ctrl-d" => "buf.delete2(:to_word_end)",
 
@@ -295,7 +302,10 @@ default_keys = {
   "IX alt-f" => "buf.jump_word(FORWARD,WORD_START)",
   "IX alt-b" => "buf.jump_word(BACKWARD,WORD_START)",
 
-  "I tab" => 'buf.insert_txt("	")',
+  "I ctrl-h" => :show_autocomplete,
+  "I ctrl-j" => "vma.buf.view.hide_completions",
+  
+
   "I space" => 'buf.insert_txt(" ")',
 #  "I return" => 'buf.insert_new_line()',
 }

data/lib/vimamsa/langservp.rb

@@ -19,13 +19,31 @@ class LangSrv
 
   def initialize(lang)
     @error = true
-    clsp = conf(:custom_lsp)
 
     # Use LSP server specified by user if available
     @lang = lang
-    lspconf = clsp[lang]
+
+    lspconf = nil
+    ret = cnf.lsp.server?.find { |k, v| v[:languages].include?(@lang) }
+    lspconf = ret[1] unless ret.nil?
+
     if !lspconf.nil?
-      @io = IO.popen(lspconf[:command], "r+")
+      error = false
+      begin
+        @io = IO.popen(lspconf[:command], "r+")
+      rescue Errno::ENOENT => e
+        pp e
+        error = true
+      rescue StandardError => e
+        debug "StandardError @io = IO.popen(lspconf[:command] ...", 2
+        pp e
+        error = true
+      end
+      if error or @io.nil?
+        message("Could not start lsp server #{lspconf[:name]}")
+        error = true
+        return nil
+      end
     else
       return nil
     end
@@ -37,6 +55,8 @@ class LangSrv
     for c in conf(:workspace_folders)
       wf << LSP::Interface::WorkspaceFolder.new(uri: c[:uri], name: c[:name])
     end
+    debug "WORKSPACE FOLDERS", 2
+    debug wf.inspect, 2
 
     pid = Process.pid