vimamsa 0.1.0 → 0.1.1

data/lib/vimamsa/buffer_list.rb

@@ -0,0 +1,207 @@
+
+def save_buffer_list()
+  message("Save buffer list")
+  buffn = get_dot_path("buffers.txt")
+  f = File.open(buffn, "w")
+  bufstr = $buffers.collect { |buf| buf.fname }.inspect
+  f.write(bufstr)
+  f.close()
+end
+
+def load_buffer_list()
+  message("Load buffer list")
+  buffn = get_dot_path("buffers.txt")
+  return if !File.exist?(buffn)
+  bufstr = IO.read(buffn)
+  bufl = eval(bufstr)
+  debug bufl
+  for b in bufl
+    load_buffer(b) if b != nil and File.file?(b)
+  end
+end
+
+class BufferList < Array
+  attr_reader :current_buf
+
+  def <<(_buf)
+    super
+    $buffer = _buf
+    @current_buf = self.size - 1
+    $buffer_history << @current_buf
+    @recent_ind = 0
+    $hook.call(:change_buffer, $buffer)
+    qt_set_current_buffer($buffer.id)
+    qt_set_cursor_pos($buffer.id, $buffer.pos)
+  end
+
+  def switch()
+    debug "SWITCH BUF. bufsize:#{self.size}, curbuf: #{@current_buf}"
+    @current_buf += 1
+    @current_buf = 0 if @current_buf >= self.size
+    m = method("switch")
+    set_last_command({ method: m, params: [] })
+    set_current_buffer(@current_buf)
+  end
+
+  def switch_to_last_buf()
+    debug "SWITCH TO LAST BUF:"
+    debug $buffer_history
+    last_buf = $buffer_history[-2]
+    if last_buf
+      set_current_buffer(last_buf)
+    end
+  end
+
+  def get_buffer_by_filename(fname)
+    #TODO: check using stat/inode?  http://ruby-doc.org/core-1.9.3/File/Stat.html#method-i-ino
+    buf_idx = self.index { |b| b.fname == fname }
+    return buf_idx
+  end
+
+  def add_current_buf_to_history()
+    @recent_ind = 0
+    $buffer_history << @current_buf
+    compact_buf_history()
+  end
+
+  def set_current_buffer(buffer_i, update_history = true)
+    buffer_i = self.size -1 if buffer_i > self.size
+    buffer_i = 0 if buffer_i < 0
+    $buffer = self[buffer_i]
+    return if !$buffer
+    @current_buf = buffer_i
+    debug "SWITCH BUF2. bufsize:#{self.size}, curbuf: #{@current_buf}"
+    fpath = $buffer.fname
+    if fpath and fpath.size > 50
+      fpath = fpath[-50..-1]
+    end
+
+    if update_history
+      add_current_buf_to_history
+    end
+
+    $hook.call(:change_buffer, $buffer)
+    $buffer.set_active
+
+    set_window_title("Vimamsa - #{fpath}")
+    qt_set_current_buffer($buffer.id)
+
+    # hpt_scan_images() if $debug # experimental
+  end
+
+  def get_last_dir
+    lastdir = nil
+    if $buffer.fname
+      lastdir = File.dirname($buffer.fname)
+    else
+      for bufid in $buffer_history.reverse[1..-1]
+        bf = $buffers[bufid]
+        debug "FNAME:#{bf.fname}"
+        if bf.fname
+          lastdir = File.dirname(bf.fname)
+          break
+        end
+      end
+    end
+    lastdir = File.expand_path(".") if lastdir.nil?
+    return lastdir
+  end
+
+  def get_recent_buffers()
+    bufs = []; b = {}
+    $buffer_history.reverse.each { |x| bufs << x if !b[x] && x < self.size; b[x] = true }
+    return bufs
+  end
+
+  def history_switch_backwards()
+    recent = get_recent_buffers()
+    @recent_ind += 1
+    @recent_ind = 0 if @recent_ind >= recent.size
+    bufid = recent[@recent_ind]
+    debug "IND:#{@recent_ind} RECENT:#{recent.join(" ")}"
+    set_current_buffer(bufid, false)
+  end
+
+  def history_switch_forwards()
+    recent = get_recent_buffers()
+    @recent_ind -= 1
+    @recent_ind = self.size - 1 if @recent_ind < 0
+    bufid = recent[@recent_ind]
+    debug "IND:#{@recent_ind} RECENT:#{recent.join(" ")}"
+    set_current_buffer(bufid, false)
+  end
+
+  def compact_buf_history()
+    h = {}
+    # Keep only first occurence in history
+    bh = $buffer_history.reverse.select { |x| r = h[x] == nil; h[x] = true; r }
+    $buffer_history = bh.reverse
+  end
+
+  def close_buffer(buffer_i, from_recent = false)
+    return if self.size <= buffer_i
+    
+    bufname = self[buffer_i].basename
+    message("Closed buffer #{bufname}")
+    recent = get_recent_buffers
+    jump_to_buf = recent[@recent_ind + 1]
+    jump_to_buf = 0 if jump_to_buf == nil
+
+    self.slice!(buffer_i)
+    $buffer_history = $buffer_history.collect { |x| r = x; r = x - 1 if x > buffer_i; r = nil if x == buffer_i; r }.compact
+
+    if @current_buf == buffer_i
+      if from_recent
+        @current_buf = jump_to_buf
+      else
+        @current_buf = $buffer_history.last
+      end
+    end
+    # Ripl.start :binding => binding
+    if self.size == 0
+      self << Buffer.new("\n")
+      @current_buf = 0
+    else
+      @current_buf = 0 if @current_buf >= self.size
+    end
+    set_current_buffer(@current_buf, false)
+  end
+
+  def close_all_buffers()
+    message("Closing all buffers")
+    while true
+      if self.size == 1
+        close_buffer(0)
+        break
+      else
+        close_buffer(0)
+      end
+    end
+    # self << Buffer.new("\n")
+  end
+
+  def close_scrap_buffers()
+    i = 0
+    while i < self.size
+      if !self[i].pathname
+        close_buffer(i)
+      else
+        i += 1
+      end
+    end
+  end
+
+  def close_current_buffer(from_recent = false)
+    close_buffer(@current_buf, from_recent)
+  end
+
+  def delete_current_buffer(from_recent = false)
+    fn = buf.fname
+    close_buffer(@current_buf, from_recent)
+    #TODO: confirm with user, "Do you want to delete file X"
+    if is_existing_file(fn)
+      message("Deleting file: #{fn}")
+      File.delete(fn)
+    end
+  end
+end

data/lib/vimamsa/constants.rb

@@ -0,0 +1,44 @@
+
+NEXT_MARK = 1001
+PREVIOUS_MARK = 1002
+BACKWARD = 1003
+FORWARD = 1004
+BEFORE = 1005
+AFTER = 1006
+SELECTION = 1007
+
+FORWARD_CHAR = 2001
+BACKWARD_CHAR = 2002
+FORWARD_LINE = 2003
+BACKWARD_LINE = 2004
+CURRENT_CHAR_FORWARD = 2005
+CURRENT_CHAR_BACKWARD = 2006
+START_OF_BUFFER = 2007
+END_OF_BUFFER = 2008
+BACKWARD = 2009
+FORWARD = 2010
+END_OF_LINE = 2011
+BEGINNING_OF_LINE = 2012
+WORD_START = 2013
+WORD_END = 2014
+FIRST_NON_WHITESPACE = 2014
+
+INSERT = 2
+DELETE = 3001
+REPLACE = 3002
+
+KEY_PRESS = 6
+KEY_RELEASE = 7 # QEvent::KeyRelease
+
+# http://qt-project.org/doc/qt-5.0/qtcore/qt.html#KeyboardModifier-enum
+ALTMODIFIER = 0x08000000
+NOMODIFIER = 0x00000000 #    No modifier key is pressed.
+SHIFTMODIFIER = 0x02000000 #    A Shift key on the keyboard is pressed.
+CONTROLMODIFIER = 0x04000000 #    A Ctrl key on the keyboard is pressed.
+ALTMODIFIER = 0x08000000 #    An Alt key on the keyboard is pressed.
+METAMODIFIER = 0x10000000 #    A Meta key on the keyboard is pressed.
+KEYPADMODIFIER = 0x20000000 #    A keypad button is pressed.
+
+
+
+

data/lib/vimamsa/debug.rb

@@ -0,0 +1,142 @@
+require "fileutils"
+
+def debug(message)
+  if $debug
+    puts "[#{DateTime.now().strftime("%H:%M:%S")}] #{message}"
+    $stdout.flush
+  end
+end
+
+def debug_print_buffer(c)
+  puts buf.inspect
+  puts buf
+end
+
+def debug_dump_clipboard()
+  puts $clipboard.inspect
+end
+
+def debug_dump_deltas()
+  puts buf.edit_history.inspect
+end
+
+$log_messages = []
+def log_message(message)
+  puts message
+  $log_messages << message
+end
+
+def log_error(message)
+  puts "====== ERROR ====="
+  puts caller[0]
+  puts message
+  puts "=================="
+  $errors << [message, caller]
+  #TODO
+end
+
+def crash(message, e = nil)
+  puts "FATAL ERROR:#{message}"
+  puts caller().join("\n")
+  # savedebug(message, e)
+  _quit()
+end
+
+def savedebug(message, e)
+  FileUtils.mkdir_p("debug")
+  puts "savedebug()"
+  dbginfo = {}
+  dbginfo["message"] = message
+  dbginfo["debuginfo"] = $debuginfo
+  dbginfo["trace"] = caller()
+  dbginfo["trace"] = e.backtrace() if e
+  dbginfo["trace_str"] = dbginfo["trace"].join("\n")
+  dbginfo["edit_history"] = buf.edit_history
+  dbginfo["cnf"] = $cnf
+  dbginfo["register"] = $register
+  dbginfo["clipboard"] = $clipboard
+  # dbginfo["last_event"] = $last_event
+  dbginfo["buffer"] = {}
+  dbginfo["buffer"]["str"] = buf.to_s
+  dbginfo["buffer"]["lpos"] = buf.lpos
+  dbginfo["buffer"]["cpos"] = buf.cpos
+  dbginfo["buffer"]["pos"] = buf.pos
+
+  pfxs = DateTime.now().strftime("%d%m%Y_%H%M%S")
+  save_fn_dump = sprintf("debug/crash_%s.marshal", pfxs)
+  save_fn_json = sprintf("debug/crash_%s.json", pfxs)
+  mdump = Marshal.dump(dbginfo)
+  IO.binwrite(save_fn_dump, mdump)
+  IO.write(save_fn_json, dbginfo.to_json)
+  puts "SAVED CRASH INFO TO:"
+  puts save_fn_dump
+  puts save_fn_json
+end
+
+def run_tests()
+  run_test("01")
+  run_test("02")
+end
+
+def run_test(test_id)
+  target_results = read_file("", "tests/test_#{test_id}_output.txt")
+  old_buffer = $buffer
+  $buffer = Buffer.new("", "")
+  load "tests/test_#{test_id}.rb"
+  test_ok = $buffer.to_s.strip == target_results.strip
+  puts "##################"
+  puts target_results
+  puts "##################"
+  puts $buffer.to_s
+  puts "##################"
+  puts "TEST OK" if test_ok
+  puts "TEST FAILED" if !test_ok
+  puts "##################"
+  $buffer = old_buffer
+end
+
+def qt_sleep(t2)
+  t1 = Time.now()
+  while Time.now < t1 + t2
+    qt_process_events
+    sleep(0.02)
+  end
+end
+
+def run_random_jump_test__tmpl(test_time = 60 * 60 * 10)
+  open_new_file("TODO"); qt_sleep(0.1)
+
+  ttstart = Time.now
+  Kernel.srand(1231)
+  step = 0
+  while Time.now < ttstart + test_time
+    debug "step=#{step}"
+    buf.jump_to_random_pos
+    buf.insert_txt("Z") if rand() > 0.25
+    buf.reset_highlight() if rand() > 0.1
+    qt_trigger_event
+
+    # puts "========line:========="
+    # puts buf.current_line()
+    # puts "======================"
+
+    render_buffer($buffer)
+
+    qt_sleep(rand() / 2)
+    if rand() < (1 / 40.0)
+      buf.revert
+    end
+
+    qt_trigger_event
+    buf.insert_txt("X") if rand() > 0.25
+    render_buffer($buffer)
+
+    $buffers.set_current_buffer(rand($buffers.size)) if rand > 0.25
+    step += 1
+  end
+end
+
+
+def start_ripl
+  Ripl.start :binding => binding
+end

data/lib/vimamsa/default_key_bindings.rb

@@ -0,0 +1,445 @@
+
+def e_move_forward_char
+  buf.move(FORWARD_CHAR)
+end
+
+def e_move_backward_char
+  buf.move(BACKWARD_CHAR)
+end
+
+def history_switch_backwards
+  bufs.history_switch_backwards
+end
+
+def history_switch_forwards
+  bufs.history_switch_forwards
+end
+
+def jump_to_next_edit
+  buf.jump_to_next_edit
+end
+
+def is_command_mode()
+  return true if $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 0
+end
+
+reg_act(:easy_jump, proc { easy_jump(:visible_area) }, "Easy jump")
+bindkey "VC s", :easy_jump
+
+reg_act(:savedebug, "savedebug", "Save debug info")
+
+# reg_act(:file_finder, "gui_file_finder", "Fuzzy file finder")
+
+reg_act(:open_file_dialog, "open_file_dialog", "Open file")
+reg_act(:create_new_file, "create_new_file", "Create new file")
+reg_act(:backup_all_buffers, "backup_all_buffers", "Backup all buffers")
+reg_act(:invoke_ack_search, "invoke_ack_search", "Invoke ack search")
+reg_act(:e_move_forward_char, "e_move_forward_char", "")
+reg_act(:e_move_backward_char, "e_move_backward_char", "")
+reg_act(:history_switch_backwards, "history_switch_backwards", "")
+reg_act(:history_switch_forwards, "history_switch_forwards", "")
+
+reg_act(:center_on_current_line, "center_on_current_line", "")
+
+# a = Action.new(:transform_upcase, "Transform selection upcase", proc{ buf.transform_selection(:upcase)  } , [:selection]) 
+
+reg_act(:run_last_macro, proc { $macro.run_last_macro }, "Run last recorded or executed macro")
+bindkey ["VCB M","B m"], :run_last_macro
+
+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"]
+
+
+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 }, "")
+bindkey "C , j r", :jump_to_random
+
+reg_act(:insert_new_line, proc { buf.insert_new_line()}, "")
+bindkey "I enter", :insert_new_line
+
+reg_act(:show_key_bindings, proc { show_key_bindings }, "Show key bindings")
+bindkey "C , ; s k", :show_key_bindings #TODO: better binding
+
+reg_act(:put_file_path_to_clipboard, proc { buf.put_file_path_to_clipboard }, "Put file path of current file to clipboard")
+bindkey "C , , c b", :put_file_path_to_clipboard #TODO: better binding or remove?
+
+# 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")
+bindkey "C , , e", :encrypt_file #TODO: better binding
+
+reg_act(:set_unencrypted, proc { buf.set_unencrypted }, "Set current file to save unencrypted")
+bindkey "C , ; u", :set_unencrypted #TODO: better binding
+
+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")
+bindkey "C , c b", :close_current_buffer
+
+reg_act(:comment_selection, proc { buf.comment_selection }, "")
+bindkey "V ctrl-c", :comment_selection
+
+reg_act(:delete_char_forward, proc { buf.delete(CURRENT_CHAR_FORWARD) }, "Delete char forward")
+bindkey "C x", :delete_char_forward
+
+reg_act(:load_theme, proc { load_theme }, "Load theme")
+bindkey "C , , l t", :load_theme
+
+reg_act(:gui_file_finder, proc { vma.FileFinder.start_gui }, "Fuzzy file finder")
+bindkey "C , f", :gui_file_finder
+
+
+reg_act(:gui_file_history_finder, proc { vma.FileHistory.start_gui }, "Fuzzy file history finder")
+bindkey "C , h", :gui_file_history_finder
+
+
+reg_act(:gui_search_replace, proc { gui_search_replace }, "Search and replace")
+bindkey "C , r r", :gui_search_replace
+bindkey "V , r r", :gui_search_replace
+
+reg_act(:set_style_bold, proc { buf.style_transform(:bold) }, "Set text weight to bold")
+bindkey "V , t b", :set_style_bold
+
+reg_act(:set_style_link, proc { buf.style_transform(:link) }, "Set text as link")
+bindkey "V , t l", :set_style_link
+
+reg_act(:V_join_lines, proc { vma.buf.convert_selected_text(:joinlines) }, "Join lines")
+bindkey "V J", :V_join_lines
+
+
+reg_act(:clear_formats, proc { buf.style_transform(:clear) }, "Clear style formats")
+bindkey "V , t c", :clear_formats
+
+reg_act(:set_line_style_heading, proc { buf.set_line_style(:heading) }, "Set style of current line as heading")
+bindkey "C , t h", :set_line_style_heading
+
+reg_act(:set_line_style_h1, proc { buf.set_line_style(:h1) }, "Set cur line as Heading 1")
+bindkey "C , t 1", :set_line_style_h1
+reg_act(:set_line_style_h2, proc { buf.set_line_style(:h2) }, "Set cur line as Heading 1")
+bindkey "C , t 2", :set_line_style_h2
+reg_act(:set_line_style_h3, proc { buf.set_line_style(:h3) }, "Set cur line as Heading 1")
+bindkey "C , t 3", :set_line_style_h3
+reg_act(:set_line_style_h4, proc { buf.set_line_style(:h4) }, "Set cur line as Heading 1")
+bindkey "C , t 4", :set_line_style_h4
+
+
+reg_act(:set_line_style_bold, proc { buf.set_line_style(:bold) }, "Set style of current line as bold")
+bindkey "C , t b", :set_line_style_bold
+
+reg_act(:set_line_style_title, proc { buf.set_line_style(:title) }, "Set style of current line as title")
+bindkey "C , t t", :set_line_style_title
+
+reg_act(:clear_line_styles, proc { buf.set_line_style(:clear) }, "Clear styles of current line")
+bindkey "C , t c", :clear_line_styles
+
+reg_act(:gui_select_buffer, proc { $kbd.set_mode("S"); gui_select_buffer }, "Select buffer")
+bindkey "C , b", :gui_select_buffer
+
+reg_act :open_file_dialog, "open_file_dialog", "Open file"
+# bindkey "C , f o", :open_file_dialog
+bindkey "CI ctrl-o", :open_file_dialog
+
+reg_act :minibuffer_end, proc { minibuffer_end }
+bindkey "M enter", :minibuffer_end
+
+reg_act(:invoke_replace, "invoke_replace", "")
+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
+bindkey "C , a", :ack_search
+
+reg_act :update_file_index, proc { update_file_index }, "Update file index"
+
+
+reg_act :delete_to_word_end, proc { buf.delete2(:to_word_end) }, "Delete to file end"
+bindkey  "C d w", :delete_to_word_end
+
+reg_act :delete_to_line_start, proc { buf.delete2(:to_line_start) }, "Delete to line start"
+bindkey  "C d 0", :delete_to_line_start
+
+
+bindkey "C , , f", :file_finder
+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 l", :history_switch_forwards
+#bindkey 'B z', :center_on_current_line
+bindkey "B z", "center_on_current_line();call(:exit_browse_mode)"
+
+reg_act :start_browse_mode, proc { $kbd.set_mode(:browse); $kbd.set_default_mode(:browse) }, "Start browse mode"
+
+reg_act :exit_browse_mode, proc { bufs.add_current_buf_to_history();$kbd.set_mode(:command); $kbd.set_default_mode(:command)
+}, "Exit browse mode"
+#TODO: Need to deside which of these is best:
+bindkey "B enter || B return || B esc || B j || B ctrl!", :exit_browse_mode
+
+reg_act :page_down, proc {page_down}
+reg_act :page_up, proc {page_up}
+bindkey "B s", :page_up
+bindkey "B d", :page_down
+bindkey "B s", :page_up
+bindkey "B d", :page_down
+
+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"
+
+bindkey "B i", :jump_to_start_of_buffer
+bindkey "B o", :jump_to_end_of_buffer
+
+bindkey "B c", :close_current_buffer
+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}
+
+reg_act(:auto_indent_buffer, proc { buf.indent }, "Auto format buffer")
+bindkey "C , v", :auto_indent_buffer
+bindkey "C , , d", :savedebug
+bindkey "C , , u", :update_file_index
+
+bindkey "C , s a", "buf.save_as()"
+
+
+
+reg_act(:execute_current_line_in_terminal, proc { buf.execute_current_line_in_terminal }, "Execute current line in terminal")
+
+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")
+
+
+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)},""]
+
+
+# reg_act(:start_file_selector, proc { FileSelector.new.run; $kbd.set_mode(:file_exp) }, "File selector")
+# bindkey "C , j f", :start_file_selector
+# bindkey "C , f", :start_file_selector
+
+# $kbd.add_minor_mode('fexp', :file_exp, :command)
+
+# bindkey  "fexp l" , [:fexp_right,proc{puts "==fexp_right=="},""]
+# bindkey  "fexp esc" , [:fexp_quit,proc{$kbd.set_mode(:command)},""]
+# bindkey  "fexp enter" , [:fexp_select,proc{buf.module.select_line},""]
+
+# bindkey "C , j j", [:mode_file_exp, proc{$kbd.set_mode(:file_exp)}, "fexp"]
+
+#bindkey 'C z h', :history_switch_backwards
+#bindkey 'C z l', :history_switch_forwards
+
+
+#TODO: Change these evals into  proc{}'s
+default_keys = {
+
+  # File handling
+  "C ctrl-s" => "buf.save",
+  "C W" => "buf.save",
+
+  # Buffer handling
+  "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" => '$kbd.set_mode("S");gui_select_buffer',
+  "C , n b" => "create_new_file()",
+  "C , ." => "buf.backup()",
+  # "C , , ." => "backup_all_buffers()",
+  "VC , , s" => "search_actions()",
+
+
+  # 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 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 /[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 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>)",
+  "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",
+  "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 Q" => "_quit",
+  "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)
+}