vimamsa 0.1.13 → 0.1.15

data/lib/vimamsa/gui_sourceview_autocomplete.rb

@@ -0,0 +1,141 @@
+# require "trie"
+require "rambling-trie"
+
+class Autocomplete
+  @@trie = Rambling::Trie.create
+
+  def self.init
+    vma.hook.register(:file_saved, self.method("update_index"))
+  end
+
+  def self.update_index(bu)
+    debug "self.update_index", 2
+    add_words bu.scan_all_words
+  end
+
+  def self.update_dict
+    for bu in vma.buffers.list
+      for w in bu.scan_all_words
+        trie << w
+      end
+    end
+    @@trie = trie
+  end
+
+  def self.add_words(words)
+    for w in words
+      @@trie << w
+    end
+  end
+
+  def self.word_list
+    return @@dict.keys
+  end
+
+  def self.matching_words(beginning)
+    return @@trie.scan(beginning)
+  end
+end
+
+class VSourceView < GtkSource::View
+  def hide_completions
+    if @acwin.class == Gtk::Popover
+      @acwin.hide
+    end
+    @autocp_active = false
+  end
+
+  def autocp_select
+    return if !@autocp_active
+    bufo.complete_current_word(@cpl_list[@autocp_selected])
+    autocp_exit
+  end
+
+  def autocp_select_previous
+    return if @autocp_selected <= 0
+    autocp_hilight(@autocp_selected)
+    autocp_unhilight(@autocp_selected)
+    @autocp_selected -= 1
+    autocp_hilight(@autocp_selected)
+  end
+
+  def autocp_hilight(id)
+    l = @autocp_items[id]
+    l.set_text("<span foreground='#00ff00' weight='ultrabold'>#{cpl_list[id]}</span>")
+    l.use_markup = true
+  end
+
+  def autocp_unhilight(id)
+    l = @autocp_items[id]
+    l.set_text("<span>#{cpl_list[id]}</span>")
+    l.use_markup = true
+  end
+
+  def autocp_select_next
+    return if @autocp_selected >= cpl_list.size - 1
+    debug "autocp_select_next", 2
+    autocp_unhilight(@autocp_selected)
+    @autocp_selected += 1
+    autocp_hilight(@autocp_selected)
+  end
+
+  def autocp_exit
+    @autocp_items = []
+    @autocp_active = true
+    hide_completions
+  end
+
+  def try_autocomplete
+  end
+
+  def show_completions
+    hide_completions
+    bu = vma.buf
+    (w, range) = bu.get_word_in_pos(bu.pos - 1, boundary: :word)
+    debug [w, range].to_s, 2
+    matches = Autocomplete.matching_words w
+    return if matches.empty?
+    @autocp_active = true
+    @cpl_list = cpl_list = matches
+    win = Gtk::Popover.new()
+    win.parent = self
+    vbox = Gtk::Grid.new()
+    win.set_child(vbox)
+
+    i = 0
+    @autocp_items = []
+    @autocp_selected = 0
+    for x in cpl_list
+      l = Gtk::Label.new(x)
+      @autocp_items << l
+      # numbers: left, top, width, height
+      vbox.attach(l, 0, i, 1, 1)
+      i += 1
+    end
+    autocp_hilight(0)
+    (x, y) = cur_pos_xy
+    rec = Gdk::Rectangle.new(x, y + 8, 10, 10)
+    win.has_arrow = false
+    win.set_pointing_to(rec)
+    win.autohide = false
+    win.popup
+    gui_remove_controllers(win)
+    @acwin = win
+  end
+
+  def start_autocomplete
+    return
+    # Roughly following these examples:
+    # https://stackoverflow.com/questions/52359721/howto-maintain-gtksourcecompletion-when-changing-buffers-in-a-gtksourceview
+    # and gedit-plugins-41.0/plugins/wordcompletion/gedit-word-completion-plugin.c
+    # .. but it doesn't work. So implementing using Popover.
+    # Keeping this for reference
+
+    cp = self.completion
+    prov = GtkSource::CompletionWords.new("Autocomplete") # (name,icon)
+    prov.register(self.buffer)
+    cp.add_provider(prov)
+    pp prov
+    self.show_completion
+  end
+end

data/lib/vimamsa/gui_text.rb

@@ -0,0 +1,49 @@
+module Gui
+  def self.hilight_range(bf, r, color: "#aa0000ff", weight: nil, tag: nil)
+    vbuf = bf.view.buffer
+
+    if tag.nil?
+      tag = vma.gui.view.buffer.create_tag
+      tag.weight = weight if !weight.nil?
+      tag.foreground = color
+    end
+
+    itr = vbuf.get_iter_at(:offset => r.begin)
+    itr2 = vbuf.get_iter_at(:offset => r.last)
+    vbuf.apply_tag(tag, itr, itr2)
+  end
+
+  def self.highlight_match(bf, str, color: "#aa0000ff", weight: 650)
+    r = Regexp.new(Regexp.escape(str), Regexp::IGNORECASE)
+    tag = vma.gui.view.buffer.create_tag
+    tag.weight = weight
+    tag.foreground = color
+    ind = scan_indexes(bf, r)
+    ind.each { |x|
+      r = x..(x + str.size)
+      self.hilight_range(bf, r, tag: tag)
+    }
+  end
+
+  def self.highlight_match_old(bf, str, color: "#aa0000ff")
+    vbuf = bf.view.buffer
+    r = Regexp.new(Regexp.escape(str), Regexp::IGNORECASE)
+
+    hlparts = []
+
+    tt = vma.gui.view.buffer.tag_table.lookup("highlight_match_tag")
+    if tt.nil?
+      tt = vma.gui.view.buffer.create_tag("highlight_match_tag")
+    end
+
+    tt.weight = 650
+    tt.foreground = color
+
+    ind = scan_indexes(bf, r)
+    ind.each { |x|
+      itr = vbuf.get_iter_at(:offset => x)
+      itr2 = vbuf.get_iter_at(:offset => x + str.size)
+      vbuf.apply_tag(tt, itr, itr2)
+    }
+  end
+end

data/lib/vimamsa/hyper_plain_text.rb

@@ -1,9 +1,7 @@
 def hpt_check_cur_word(w)
   debug "check_cur_word(w)"
-  m = w.match(/⟦((audio|img):)(.*)⟧/)
+  m = w.match(/⟦((audio|img):)?(.*)⟧/)
   if m
-    # Ripl.start :binding => binding
-
     fpfx = m[3]
     if vma.buf.fname
       dn = File.dirname(vma.buf.fname)
@@ -17,8 +15,9 @@ def hpt_check_cur_word(w)
       fcands << File.expand_path("#{fpfx}.txt")
 
       fn = nil
+
       for fc in fcands
-        if File.exists?(fc)
+        if File.exist?(fc)
           fn = fc
           break
         end
@@ -27,8 +26,12 @@ def hpt_check_cur_word(w)
       if fn
         if m[2] == "audio"
           # Thread.new { Audio.play(fn) }
-          Audio.play(fn) 
+          Audio.play(fn)
         else
+          if !file_is_text_file(fn)
+            message "Not text file #{fn}"
+            return nil
+          end
           message "HPT opening file #{fn}"
           return fn
         end
@@ -36,12 +39,23 @@ def hpt_check_cur_word(w)
         # return true
       else
         message "File not found: #{fpfx}"
+        newfn = fcands[0]
+        if File.extname(newfn) == ""
+          newfn = fcands[1]
+        end
+         Gui.confirm("File does not exist. Create a new file? \r #{newfn}",
+                    proc{hpt_create_new_file(newfn)})
+                   
       end
     end
   end
   return nil
 end
 
+def hpt_create_new_file(fn)
+  create_new_file(fn)
+end
+
 def translate_path(fn, bf)
   if File.exist?(fn)
     outfn = fn

data/lib/vimamsa/key_actions.rb

@@ -28,13 +28,18 @@ def is_visual_mode()
   return 0
 end
 
+reg_act(:command_to_buf, proc { command_to_buf }, "Execute command, output to buffer")
+
 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")
+reg_act(:enable_debug, proc { cnf.debug = true }, "Enable debug")
+reg_act(:disable_debug, proc { cnf.debug = false }, "Disable debug")
 
 reg_act(:easy_jump, proc { EasyJump.start }, "Easy jump")
+reg_act(:gui_ensure_cursor_visible, proc { vma.gui.view.ensure_cursor_visible }, "Scroll to current cursor position")
+reg_act(:gui_refresh_cursor, proc { vma.buf.refresh_cursor }, "Refresh cursor")
+
 reg_act(:savedebug, "savedebug", "Save debug info", { :group => :debug })
 reg_act(:open_file_dialog, "open_file_dialog", "Open file", { :group => :file })
 reg_act(:create_new_file, "create_new_file", "Create new file", { :group => :file })
@@ -44,7 +49,7 @@ reg_act(:e_move_backward_char, "e_move_backward_char", "", { :group => [:move, :
 reg_act(:history_switch_backwards, "history_switch_backwards", "", { :group => :file })
 reg_act(:history_switch_forwards, "history_switch_forwards", "", { :group => :file })
 reg_act(:center_on_current_line, "center_on_current_line", "", { :group => :view })
-reg_act(:run_last_macro, proc { $macro.run_last_macro }, "Run last recorded or executed macro", { :group => :macro })
+reg_act(:run_last_macro, proc { vma.macro.run_last_macro }, "Run last recorded or executed macro", { :group => :macro })
 reg_act(:jump_to_next_edit, "jump_to_next_edit", "")
 reg_act(:jump_to_last_edit, proc { buf.jump_to_last_edit }, "")
 reg_act(:jump_to_random, proc { buf.jump_to_random_pos }, "")
@@ -57,7 +62,7 @@ reg_act(:put_file_ref_to_clipboard, proc { buf.put_file_ref_to_clipboard }, "Put
 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")
 reg_act(:set_executable, proc { buf.set_executable }, "Set current file permissions to executable")
-reg_act(:close_all_buffers, proc { bufs.close_all_buffers() }, "Close all buffers")
+# reg_act(:close_all_buffers, proc { bufs.close_all_buffers() }, "Close all buffers")
 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] })
@@ -89,13 +94,23 @@ 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 :start_browse_mode, proc {
+  vma.kbd.set_mode(:browse)
+  bufs.reset_navigation
+}, "Start browse mode"
+reg_act :kbd_dump_state, proc { vma.kbd.dump_state }, "Dump keyboard tree state"
+
 reg_act :exit_browse_mode, proc {
-  bufs.add_current_buf_to_history(); $kbd.set_mode(:command); $kbd.set_default_mode(:command)
+  bufs.add_current_buf_to_history
+  # Load previously saved buffer specific mode stack
+  buf.restore_kbd_mode
 }, "Exit browse mode"
 
-reg_act :page_down, proc { page_down }, "Page down", :group => [:move, :basic]
-reg_act :page_up, proc { page_up }, "Page up", :group => [:move, :basic]
+# reg_act :page_down, proc { page_down }, "Page down", :group => [:move, :basic]
+reg_act :page_down, proc { vma.gui.page_down }, "Page down", :group => [:move, :basic]
+
+reg_act :page_up, proc { vma.gui.page_up }, "Page up", :group => [:move, :basic]
 reg_act :jump_to_start_of_buffer, proc { buf.jump(START_OF_BUFFER) }, "Jump to start of buffer"
 reg_act :jump_to_end_of_buffer, proc { buf.jump(END_OF_BUFFER) }, "Jump to end of buffer"
 reg_act(:auto_indent_buffer, proc { buf.indent }, "Auto format buffer")
@@ -104,10 +119,8 @@ reg_act(:execute_current_line_in_terminal_autoclose, proc { buf.execute_current_
 reg_act(:show_images, proc { hpt_scan_images() }, "Show images inserted with ⟦img:file.png⟧ syntax")
 reg_act(:delete_current_file, proc { bufs.delete_current_buffer() }, "Delete current file")
 
-
 reg_act(:audio_stop, proc { Audio.stop }, "Stop audio playback")
 
-
 act_list = {
   # File handling
   :buf_save => { :proc => proc { buf.save },
@@ -159,7 +172,7 @@ act_list = {
   :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 },
+  :toggle_two_column => { :proc => proc { vma.gui.toggle_two_column },
                           :desc => "Set two column mode", :group => :search },
 
   :content_search => { :proc => proc { FileContentSearch.start_gui },
@@ -168,199 +181,25 @@ act_list = {
   :quit => { :proc => proc { _quit },
              :desc => "Quit", :group => :app },
 
-}
+  :run_tests => { :proc => proc { run_tests },
+                  :desc => "Run tests" },
 
-for k, v in act_list
-  reg_act(k, v[:proc], v[:desc])
-end
+  :debug_buf_hex => { :proc => proc { puts "SHA256: " + (Digest::SHA2.hexdigest vma.buf.to_s) },
+                      :desc => "Output SHA256 hex digest of curent buffer" },
 
-act_list_todo = {
+  :start_autocomplete => { :proc => proc { vma.buf.view.start_autocomplete },
+                      :desc => "Start autocomplete" },
+                      
+  :show_autocomplete => { :proc => proc { 
+  # vma.buf.view.signal_emit("show-completion")
+  # vma.buf.view.show_completion
+  vma.buf.view.show_completions
+   },
+                      :desc => "Show autocomplete" },
+                     
 
-  # Buffer handling
-  # : =>  {proc => proc {bufs.switch}, :desc => "", :group => :},
-  :buf_switch_to_last => { :proc => proc { bufs.switch_to_last_buf },
-                           :desc => "", :group => :file },
-  #    'C , s'=> 'gui_select_buffer',
-  :buf_revert => { :proc => proc { buf.revert },
-                   :desc => "Reload/revert file from disk", :group => :file },
-  :buf_close => { :proc => proc { bufs.close_current_buffer },
-                  :desc => "Close current file", :group => :file },
-  #"C , b" => '$kbd.set_mode("S");gui_select_buffer',
-
-  # MOVING
-  #    'VC h' => 'buf.move(BACKWARD_CHAR)',
-  :m_forward_char => { :proc => proc { buf.move(FORWARD_CHAR) },
-                       :desc => "Move cursor one char forward",
-                       :group => :move },
-  # "VC j" => "buf.move(FORWARD_LINE)",
-  # "VC k" => "buf.move(BACKWARD_LINE)",
-
-  "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)",
-
-  "VC w" => "buf.jump_word(FORWARD,WORD_START)",
-  "VC b" => "buf.jump_word(BACKWARD,WORD_START)",
-  "VC e" => "buf.jump_word(FORWARD,WORD_END)",
-  #    '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)",
-  "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 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)",
-  # 'C 0'=> 'buf.jump(BEGINNING_OF_LINE)',
-  "VC g g" => "buf.jump(START_OF_BUFFER)",
-  "VC g ;" => "buf.jump_to_last_edit",
-  "VC G" => "buf.jump(END_OF_BUFFER)",
-  #    'VC z z' => 'center_on_current_line',
-  "VC *" => "buf.jump_to_next_instance_of_word",
-
-  # MINIBUFFER bindings
-  "VC /" => "invoke_search",
-  # 'VC :' => 'invoke_command', #TODO
-  "C , e" => "invoke_command", # Currently eval
-  "M enter" => "minibuffer_end()",
-  # "M return" => "minibuffer_end()",
-  "M esc" => "minibuffer_cancel()",
-  "M backspace" => "minibuffer_delete()",
-  "M <char>" => "minibuffer_new_char(<char>)",
-  "M ctrl-v" => "$minibuffer.paste(BEFORE)",
-
-  # READCHAR bindings
-
-  "R <char>" => "readchar_new_char(<char>)",
-
-  "C n" => "$search.jump_to_next()",
-  "C N" => "$search.jump_to_previous()",
-
-  # Debug
-  "C , d r p" => "start_ripl",
-  "C , D" => "debug_print_buffer",
-  "C , c s" => "bufs.close_scrap_buffers",
-  "C , d b" => "debug_print_buffer",
-  "C , d c" => "debug_dump_clipboard",
-  "C , d d" => "debug_dump_deltas",
-  "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 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 J" => "buf.join_lines()",
-  "C u" => "buf.undo()",
-
-  "C ^" => "buf.jump(BEGINNING_OF_LINE)",
-  "C /[1-9]/" => "set_next_command_count(<char>)",
-
-  # Command mode only:
-  "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>)",
-  "C space space" => "buf.insert_txt(' ')",
-  "C y y" => "buf.copy_line",
-  "C y O" => "buf.copy(:to_line_end)",
-  "C y 0" => "buf.copy(:to_line_start)",
-  "C y e" => "buf.copy(:to_word_end)", # TODO
-  #### Deleting
-  "C x" => "buf.delete(CURRENT_CHAR_FORWARD)",
-  # 'C d k'=> 'delete_line(BACKWARD)', #TODO
-  # 'C d j'=> 'delete_line(FORWARD)', #TODO
-  # 'C d d'=> 'buf.delete_cur_line',
-  "C d e" => "buf.delete2(:to_word_end)",
-  "C d O" => "buf.delete2(:to_line_end)",
-  "C d $" => "buf.delete2(:to_line_end)",
-  #    'C d e'=> 'buf.delete_to_next_word_end',
-  "C d <num> e" => "delete_next_word",
-  "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 , p <char>" => "buf.paste(BEFORE,<char>)", # TODO
-
-  "C ctrl-c" => "buf.comment_line()",
-  "C ctrl-x" => "buf.comment_line(:uncomment)",
-
-  # 'C 0($next_command_count==nil)'=> 'jump_to_beginning_of_line',
-
-  # Visual mode only:
-  "V esc" => "buf.end_visual_mode",
-  "V ctrl!" => "buf.end_visual_mode",
-  "V y" => "buf.copy_active_selection(:foo)",
-  "V g U" => "buf.transform_selection(:upcase)",
-  "V g u" => "buf.transform_selection(:downcase)",
-  "V g c" => "buf.transform_selection(:capitalize)",
-  "V g s" => "buf.transform_selection(:swapcase)",
-  "V g r" => "buf.transform_selection(:reverse)",
-
-  "V x" => "buf.delete(SELECTION)",
-  # "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>)",
-  '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)",
-
-  # 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 , t r" => "run_tests()",
-
-  "C ." => "repeat_last_action", # TODO
-  "VC ;" => "repeat_last_find",
-  "CV ctrl-q" => "_quit",
-  "CV , R" => "restart_application",
-  "I ctrl!" => "$kbd.set_mode(:command)",
-  "C shift!" => "buf.save",
-  "I <char>" => "buf.insert_txt(<char>)",
-  "I esc" => "$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)",
-
-  "I tab" => 'buf.insert_txt("	")',
-  "I space" => 'buf.insert_txt(" ")',
-#  "I return" => 'buf.insert_new_line()',
 }
 
-# default_keys.each { |key, value|
-# bindkey(key, value)
-# }
+for k, v in act_list
+  reg_act(k, v[:proc], v[:desc])
+end