vimamsa 0.1.21 → 0.1.23

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, :root, :parent
   attr_reader :cur_mode, :scope
 
   def initialize(key_name, eval_rule = "", ctype = :command, scope: :buffer)
@@ -29,8 +28,11 @@ class State
     @children = []
     @scope = scope
     @major_modes = []
+    @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]
@@ -68,8 +71,9 @@ class KeyBindingTree
     return if get_mode == :label
     @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?
@@ -86,7 +90,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 +114,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 +139,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 +168,7 @@ class KeyBindingTree
 
   def match(key_name)
     new_state = []
+    debug = false
     @match_state.each { |parent|
       parent.children.each { |c|
         # printf(" KEY MATCH: ")
@@ -174,6 +178,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 +190,10 @@ class KeyBindingTree
       }
     }
 
+    if debug
+      # require "pry"; binding.pry
+    end
+
     if new_state.any? # Match found
       @match_state = new_state
       return new_state
@@ -251,25 +262,83 @@ 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
 
+  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 +366,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")
@@ -317,7 +388,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
@@ -426,11 +503,39 @@ 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 }
 
+      # 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
+        # end
         debug "FOUND MATCH:#{eval_s}"
         debug "CHAR: #{c}"
         c.gsub!("\\", %q{\\\\} * 4) # Escape \ -chars
@@ -449,7 +554,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 +574,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 +612,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 +633,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
@@ -552,6 +665,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?
@@ -561,10 +676,12 @@ class KeyBindingTree
     else
       @cur_state.action = action
     end
+    @cur_state.keywords = keywords
     @cur_state = @root
   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
@@ -611,16 +728,37 @@ 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}"
+        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
+      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
 
-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,14 +768,76 @@ def exec_action(action)
   end
 end
 
+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 << "◼ 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"])
+
+  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
+
 # Try to clear modifiers when program loses focus
 # e.g. after alt-tab
 # TODO
 # def focus_out
-  # debug "RB Clear modifiers"
-  # $kbd.clear_modifiers()
+# debug "RB Clear modifiers"
+# vma.kbd.clear_modifiers()
 # end
 
 # def handle_key_event(event)
-  # $kbd.handle_key_event(event)
+# vma.kbd.handle_key_event(event)
 # end