vimamsa 0.1.20 → 0.1.22

data/lib/vimamsa/key_actions.rb

@@ -19,12 +19,12 @@ def jump_to_next_edit
 end
 
 def is_command_mode()
-  return true if $kbd.mode_root_state.to_s() == "C"
+  return true if vma.kbd.mode_root_state.to_s() == "C"
   return false
 end
 
 def is_visual_mode()
-  return 1 if $kbd.mode_root_state.to_s() == "V"
+  return 1 if vma.kbd.mode_root_state.to_s() == "V"
   return 0
 end
 
@@ -33,6 +33,8 @@ reg_act(:command_to_buf, proc { command_to_buf }, "Execute command, output to bu
 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(:eval_buf, proc { vma.buf.eval_whole_buf }, "Eval whole current buffer as ruby code (DANGEROUS)")
+
 reg_act(:enable_debug, proc { cnf.debug = true }, "Enable debug")
 reg_act(:disable_debug, proc { cnf.debug = false }, "Disable debug")
 
@@ -67,7 +69,6 @@ reg_act(:set_executable, proc { buf.set_executable }, "Set current file permissi
 reg_act(:close_current_buffer, proc { bufs.close_current_buffer(true) }, "Close current buffer")
 reg_act(:comment_selection, proc { buf.comment_selection }, "")
 reg_act(:delete_char_forward, proc { buf.delete(CURRENT_CHAR_FORWARD) }, "Delete char forward", { :group => [:edit, :basic] })
-reg_act(:load_theme, proc { load_theme }, "Load theme")
 reg_act(:gui_file_finder, proc { vma.FileFinder.start_gui }, "Fuzzy file finder")
 reg_act(:gui_file_history_finder, proc { vma.FileHistory.start_gui }, "Fuzzy file history finder")
 reg_act(:gui_search_replace, proc { gui_search_replace }, "Search and replace")
@@ -83,7 +84,7 @@ reg_act(:set_line_style_h4, proc { buf.set_line_style(:h4) }, "Set cur line as H
 reg_act(:set_line_style_bold, proc { buf.set_line_style(:bold) }, "Set style of current line as bold")
 reg_act(:set_line_style_title, proc { buf.set_line_style(:title) }, "Set style of current line as title")
 reg_act(:clear_line_styles, proc { buf.set_line_style(:clear) }, "Clear styles of current line")
-reg_act(:gui_select_buffer, proc { $kbd.set_mode("S"); gui_select_buffer }, "Select buffer")
+reg_act(:gui_select_buffer, proc { vma.kbd.set_mode("S"); gui_select_buffer }, "Select buffer")
 reg_act :open_file_dialog, "open_file_dialog", "Open file"
 reg_act :minibuffer_end, proc { minibuffer_end }
 reg_act(:invoke_replace, "invoke_replace", "")
@@ -96,6 +97,30 @@ 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 }, "") 
+
+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(: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_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(: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(:jump_last_edit, proc { buf.jump_to_last_edit }, "Jump to the last edit location")
+
+
 reg_act :start_browse_mode, proc {
   vma.kbd.set_mode(:browse)
   bufs.reset_navigation

data/lib/vimamsa/key_binding_tree.rb

@@ -7,8 +7,8 @@
 #
 # Change mode from INSERT into COMMAND when ctrl key is released immediately
 # after it has been pressed (there are no other key events between key press and key release).
-#        'I ctrl!'=> '$kbd.set_mode(:command)',
-#        'C ctrl!'=> '$kbd.set_mode(:insert)',
+#        'I ctrl!'=> 'vma.kbd.set_mode(:command)',
+#        'C ctrl!'=> 'vma.kbd.set_mode(:insert)',
 
 #
 # In command mode: press keys "," "r" "v" and "b" sequentially.
@@ -18,9 +18,8 @@
 # 'I ctrl-a'=> 'vma.buf.jump(BEGINNING_OF_LINE)',
 #
 
-
 class State
-  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level, :cursor_type
+  attr_accessor :key_name, :eval_rule, :children, :action, :label, :major_modes, :level, :cursor_type, :keywords
   attr_reader :cur_mode, :scope
 
   def initialize(key_name, eval_rule = "", ctype = :command, scope: :buffer)
@@ -29,6 +28,7 @@ class State
     @children = []
     @scope = scope
     @major_modes = []
+    @keywords = []
     @action = nil
     @level = 0
     @cursor_type = ctype
@@ -86,7 +86,7 @@ class KeyBindingTree
 
   def set_mode_stack(ms)
     debug "set_mode_stack(#{ms})", 2
-    show_caller if cnf.debug? # TODO: remove 
+    show_caller if cnf.debug? # TODO: remove
     @default_mode_stack = ms
     label = @default_mode_stack[-1]
     @match_state = [@modes[label]]
@@ -110,7 +110,7 @@ class KeyBindingTree
   end
 
   def to_previous_mode()
-    debug "to_previous_mode",2
+    debug "to_previous_mode", 2
     debug @default_mode_stack
     if @default_mode_stack.size > 1
       @default_mode_stack.pop
@@ -135,7 +135,6 @@ class KeyBindingTree
     @modes[label] = mode
     if @root.nil?
       show_caller
-      Ripl.start :binding => binding
     end
     @root.children << mode
     mode.major_modes << major_mode_label
@@ -165,6 +164,7 @@ class KeyBindingTree
 
   def match(key_name)
     new_state = []
+    debug = false
     @match_state.each { |parent|
       parent.children.each { |c|
         # printf(" KEY MATCH: ")
@@ -174,6 +174,9 @@ class KeyBindingTree
         elsif c.key_name == key_name and c.eval_rule != ""
           debug "CHECK EVAL: #{c.eval_rule}"
           if eval(c.eval_rule)
+            # if eval_rule.match(/macro/)
+            debug = true
+            # end
             new_state << c
             debug "EVAL TRUE"
           else
@@ -183,6 +186,10 @@ class KeyBindingTree
       }
     }
 
+    if debug
+      # require "pry"; binding.pry
+    end
+
     if new_state.any? # Match found
       @match_state = new_state
       return new_state
@@ -262,14 +269,66 @@ class KeyBindingTree
     @state_trail = [@mode_root_state]
   end
 
+  def get_by_keywords(modes: [], keywords: [])
+    s = ""
+    stack = [[@root, ""]]
+    lines = []
+
+    # Traverse the tree (class State objects) using a stack
+    while stack.any?
+      t, p = *stack.pop # t = current state, p = current path
+      if t.children.any?
+        t.children.reverse.each { |c|
+
+          # Restrict by modes if specified
+          if c.level == 1 and !modes.empty?
+            next if !modes.include?(c.key_name)
+          end
+
+          if c.eval_rule.size > 0
+            new_p = "#{p} #{c.key_name}(#{c.eval_rule})"
+          else
+            if c.level == 1
+              new_p = "#{p} [#{c.key_name}]"
+            else
+              new_p = "#{p} #{c.key_name}"
+            end
+          end
+          stack << [c, new_p]
+        }
+        # stack.concat[t.children]
+
+      else
+        method_desc = t.action
+        if t.action.class == Symbol
+          if vma.actions.include?(t.action)
+            a = vma.actions[t.action].method_name
+            if !a.nil? and !a.empty?
+              method_desc = a
+            end
+          end
+        end
+
+        if (keywords - t.keywords).empty? # All keywords are present
+          kw = ""
+          # kw = ", [#{t.keywords.join(",")}]" if !t.keywords.empty?
+          lines << p + " : #{method_desc}#{kw}"
+        end
+      end
+    end
+    s = lines.sort.join("\n")
+    return s
+  end
+
   # Print key bindings to show as documentation or for debugging
   def to_s()
-    # return self.class.to_s
+    return self.class.to_s
     s = ""
     # @cur_state = @root
     stack = [[@root, ""]]
     lines = []
 
+    # Traverse the tree (class State objects) using a stack
     while stack.any?
       t, p = *stack.pop # t = current state, p = current path
       if t.children.any?
@@ -297,7 +356,9 @@ class KeyBindingTree
           end
         end
 
-        lines << p + " : #{method_desc}"
+        kw = ""
+        # kw = ", " + t.keywords.join(",") if !t.keywords.empty?
+        lines << p + " : #{method_desc}#{kw}"
       end
     end
     s = lines.sort.join("\n")
@@ -426,11 +487,15 @@ class KeyBindingTree
     else
 
       # Don't execute action if one of the states has children
+      # TODO: why?
       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?
+      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
+        # end
         debug "FOUND MATCH:#{eval_s}"
         debug "CHAR: #{c}"
         c.gsub!("\\", %q{\\\\} * 4) # Escape \ -chars
@@ -449,7 +514,12 @@ class KeyBindingTree
     return true
   end
 
-  def bindkey(key, action)
+  def bindkey(key, action, keywords: "")
+    # puts "keywords #{keywords}" if !keywords.empty?
+    if keywords.class == String
+      keywords = keywords.split(" ")
+    end
+    # puts "keywords #{keywords}" if !keywords.empty?
     if key.class != Array
       # Handle syntax like :
       # "X esc || X ctrl!" => "vma.kbd.to_previous_mode",
@@ -464,10 +534,10 @@ class KeyBindingTree
       msg = action[2]
       reg_act(label, proc, msg)
     end
-    key.each { |k| _bindkey(k, a) }
+    key.each { |k| _bindkey(k, a, keywords: keywords) }
   end
 
-  def _bindkey(key, action)
+  def _bindkey(key, action, keywords: [])
     key.strip!
     key.gsub!(/\s+/, " ")
 
@@ -502,15 +572,18 @@ class KeyBindingTree
       fatal_error("Error in keydef #{key.inspect}")
     end
 
+    # puts "keywords #{keywords}"
     modes.each { |mode_id|
-      mode_bind_key(mode_id, keydef, action)
+      mode_bind_key(mode_id, keydef, action, keywords: keywords)
+
+      # Map froma actions to keybindings (e.g. to show bindings in menu)
       @act_bindings[mode_id][action] = keydef
     }
   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)
+  def mode_bind_key(mode_id, keydef, action, keywords: [])
     # debug "mode_bind_key #{mode_id.inspect}, #{keydef.inspect}, #{action.inspect}", 2
     # Example:
     # bindkey "C , f", :gui_file_finder
@@ -520,7 +593,7 @@ class KeyBindingTree
     set_state(mode_id, "") # TODO: check is ok?
     start_state = @cur_state
 
-    k_arr = keydef.split
+    k_arr = keydef.split #e.g. definition: "C y e" = > ["C", "y", "e"]
 
     prev_state = nil
     s1 = start_state
@@ -561,6 +634,7 @@ class KeyBindingTree
     else
       @cur_state.action = action
     end
+    @cur_state.keywords = keywords
     @cur_state = @root
   end
 
@@ -614,13 +688,19 @@ class KeyBindingTree
   end
 end
 
-def bindkey(key, action)
-  $kbd.bindkey(key, action)
+def bindkey(key, action, keywords: "")
+  vma.kbd.bindkey(key, action, keywords: keywords)
+end
+
+def add_keys(keywords, to_add)
+  to_add.each { |key, value|
+    bindkey(key, value, keywords: keywords)
+  }
 end
 
 def exec_action(action)
-  $kbd.last_action = $kbd.cur_action
-  $kbd.cur_action = action
+  vma.kbd.last_action = vma.kbd.cur_action
+  vma.kbd.cur_action = action
   if action.class == Symbol
     return call_action(action)
   elsif action.class == Proc
@@ -630,13 +710,70 @@ def exec_action(action)
   end
 end
 
-# Try to clear modifiers when program loses focus
-# e.g. after alt-tab
-def focus_out
-  debug "RB Clear modifiers"
-  $kbd.clear_modifiers()
+def show_key_bindings()
+  kbd_s = "❙Key bindings❙\n"
+  kbd_s << "\n⦁[Mode] <keys> : <action>⦁\n"
+  done = []
+
+  kbd_s << "[B]=Browse, [C]=Command, [I]=Insert, [V]=Visual\n"
+  kbd_s << "<key>!: Press <key> once, release before pressing any other keys\n"
+  kbd_s << "===============================================\n"
+  kbd_s << "◼ Basic\n"
+  kbd_s << "◼◼ Command mode\n"
+
+  x = vma.kbd.get_by_keywords(modes: ["C"], keywords: ["intro"])
+  done.concat(x.lines); kbd_s << x
+
+  kbd_s << "\n"
+  kbd_s << "◼◼ Insert mode\n"
+  x = vma.kbd.get_by_keywords(modes: ["I"], keywords: ["intro"])
+  done.concat(x.lines); kbd_s << x
+  kbd_s << "\n"
+  kbd_s << "◼◼ Visual mode\n"
+  x = vma.kbd.get_by_keywords(modes: ["V"], keywords: ["intro"])
+  done.concat(x.lines); kbd_s << x
+  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"])
+
+  done.concat(x.lines); kbd_s << x
+  kbd_s << "\n"
+
+  kbd_s << "◼ Debug / Experimental\n"
+  x = vma.kbd.get_by_keywords(modes: [], keywords: ["experimental"])
+  done.concat(x.lines); kbd_s << x
+  kbd_s << "\n"
+
+  kbd_s << "◼ Others\n"
+  # x = vma.kbd.get_by_keywords(modes: [], keywords:["experimental"])
+  # x = vma.kbd.to_s
+  x = vma.kbd.get_by_keywords(modes: [], keywords: [])
+  done << x.lines - done
+  kbd_s << (x.lines - done).join
+  kbd_s << "\n"
+
+  kbd_s << "===============================================\n"
+  # x = vma.kbd.to_s
+  # # require "pry"; binding.pry
+  # done << x.lines - done
+  # kbd_s << (x.lines - done).join
+  # kbd_s << "\n"
+  # kbd_s << "===============================================\n"
+  b = create_new_buffer(kbd_s, "key-bindings")
+  gui_set_file_lang(b.id, "hyperplaintext")
+  #
 end
 
-def handle_key_event(event)
-  $kbd.handle_key_event(event)
-end
+# Try to clear modifiers when program loses focus
+# e.g. after alt-tab
+# TODO
+# def focus_out
+# debug "RB Clear modifiers"
+# vma.kbd.clear_modifiers()
+# end
+
+# def handle_key_event(event)
+# vma.kbd.handle_key_event(event)
+# end