vimamsa 0.1.12 → 0.1.14

data/lib/vimamsa/buffer_changetext.rb

@@ -0,0 +1,255 @@
+# Operations that change the content of the buffer
+# e.g. insert, delete
+
+class Buffer < String
+
+  #TODO: change to apply=true as default
+  def add_delta(delta, apply = false, auto_update_cpos = false)
+    return if !is_delta_ok(delta)
+    if delta[1] == DELETE
+      return if delta[0] >= self.size
+      # If go over length of buffer
+      if delta[0] + delta[2] >= self.size
+        delta[2] = self.size - delta[0]
+      end
+    end
+
+    @edit_version += 1
+    @redo_stack = []
+    if apply
+      delta = run_delta(delta, auto_update_cpos)
+    else
+      @deltas << delta
+    end
+    @edit_history << delta
+    if self[-1] != "\n"
+      add_delta([self.size, INSERT, 1, "\n"], true)
+    end
+    reset_larger_cpos #TODO: correct here?
+  end
+
+  # TODO: rename ot auto-format. separate module?
+  # Indents whole buffer using external program
+  def indent()
+    file = Tempfile.new("out")
+    infile = Tempfile.new("in")
+    file.write(self.to_s)
+    file.flush
+    bufc = "FOO"
+
+    tmppos = @pos
+
+    message("Auto format #{@fname}")
+
+    ftype = get_file_type()
+    if ["chdr", "c", "cpp", "cpphdr"].include?(ftype)
+
+      #C/C++/Java/JavaScript/Objective-C/Protobuf code
+      system("clang-format -style='{BasedOnStyle: LLVM, ColumnLimit: 100,  SortIncludes: false}' #{file.path} > #{infile.path}")
+      bufc = IO.read(infile.path)
+    elsif ftype == "Javascript"
+      cmd = "clang-format #{file.path} > #{infile.path}'"
+      debug cmd
+      system(cmd)
+      bufc = IO.read(infile.path)
+    elsif ftype == "ruby"
+      cmd = "rufo #{file.path}"
+      debug cmd
+      system(cmd)
+      bufc = IO.read(file.path)
+    else
+      message("No auto-format handler for file of type: #{ftype}")
+      return
+    end
+    self.update_content(bufc)
+    center_on_current_line #TODO: needed?
+    file.close; file.unlink
+    infile.close; infile.unlink
+  end
+
+  # Create a new line after current line and insert text on that line
+  def put_to_new_next_line(txt)
+    l = current_line_range()
+    insert_txt_at(txt, l.end + 1)
+    set_pos(l.end + 1)
+  end
+
+  # Start asynchronous read of system clipboard
+  def paste_start(at, register)
+    @clipboard_paste_running = true
+    clipboard = vma.gui.window.display.clipboard
+    clipboard.read_text_async do |_clipboard, result|
+      begin
+        text = clipboard.read_text_finish(result)
+      rescue Gio::IOError::NotSupported
+        # Happens when pasting from KeePassX and clipboard cleared
+        debug Gio::IOError::NotSupported
+      else
+        paste_finish(text, at, register)
+      end
+    end
+  end
+
+  def paste_finish(text, at, register)
+    debug "PASTE: #{text}"
+
+    # If we did not put this text to clipboard
+    if text != vma.clipboard[-1]
+      @paste_lines = false
+    end
+
+    text = sanitize_input(text)
+
+    vma.clipboard << text
+
+    return if text == ""
+
+    if @paste_lines
+      debug "PASTE LINES"
+      put_to_new_next_line(text)
+    else
+      debug "PASTE !LINES"
+      if at_end_of_buffer? or at_end_of_line? or at == BEFORE
+        pos = @pos
+      else
+        pos = @pos + 1
+      end
+      insert_txt_at(text, pos)
+      set_pos(pos + text.size)
+    end
+    set_pos(@pos)
+    @clipboard_paste_running = false
+  end
+
+  def paste(at = AFTER, register = nil)
+    # Macro's don't work with asynchronous call using GTK
+    # TODO: implement as synchronous?
+    # Use internal clipboard
+    if vma.macro.running_macro
+      text = vma.clipboard.get()
+      paste_finish(text, at, register)
+    else
+      # Get clipboard using GUI
+      paste_start(at, register)
+    end
+    return true
+  end
+
+  def delete2(range_id, mark = nil)
+    @paste_lines = false
+    range = get_range(range_id, mark: mark)
+    return if range == nil
+    debug "RANGE"
+    debug range.inspect
+    debug range.inspect
+    debug "------"
+    delete_range(range.first, range.last)
+    pos = [range.first, @pos].min
+    set_pos(pos)
+  end
+
+  def delete(op, x = nil)
+    @paste_lines = false
+    # Delete selection
+    if op == SELECTION && visual_mode?
+      (startpos, endpos) = get_visual_mode_range2
+      delete_range(startpos, endpos, x)
+      @pos = [@pos, @selection_start].min
+      end_visual_mode
+      #return
+
+      # Delete current char
+    elsif op == CURRENT_CHAR_FORWARD
+      return if @pos >= self.size - 1 # May not delete last '\n'
+      add_delta([@pos, DELETE, 1], true)
+
+      # Delete current char and then move backward
+    elsif op == CURRENT_CHAR_BACKWARD
+      add_delta([@pos, DELETE, 1], true)
+      @pos -= 1
+
+      # Delete the char before current char and move backward
+    elsif op == BACKWARD_CHAR and @pos > 0
+      add_delta([@pos - 1, DELETE, 1], true)
+      @pos -= 1
+    elsif op == FORWARD_CHAR #TODO: ok?
+      add_delta([@pos + 1, DELETE, 1], true)
+    end
+    set_pos(@pos)
+    #recalc_line_ends
+    calculate_line_and_column_pos
+    #need_redraw!
+  end
+
+  def delete_range(startpos, endpos, x = nil)
+    s = self[startpos..endpos]
+    if startpos == endpos or s == ""
+      return
+    end
+    if x == :append
+      debug "APPEND"
+      s += "\n" + vma.clipboard.get()
+    end
+    vma.clipboard.set(s)
+    add_delta([startpos, DELETE, (endpos - startpos + 1)], true)
+    #recalc_line_ends
+    calculate_line_and_column_pos
+  end
+
+  def is_delta_ok(delta)
+    ret = true
+    pos = delta[0]
+    if pos < 0
+      ret = false
+      debug "pos=#{pos} < 0"
+    elsif pos > self.size
+      debug "pos=#{pos} > self.size=#{self.size}"
+      ret = false
+    end
+    if ret == false
+      # crash("DELTA OK=#{ret}")
+    end
+    return ret
+  end
+
+  def delete_line()
+    vma.kbd.method_handles_repeat = true
+    num_lines = 1
+    if !vma.kbd.next_command_count.nil? and vma.kbd.next_command_count > 0
+      num_lines = vma.kbd.next_command_count
+      debug "copy num_lines:#{num_lines}"
+    end
+    lrange = line_range(@lpos, num_lines)
+    s = self[lrange]
+    add_delta([lrange.begin, DELETE, lrange.end - lrange.begin + 1], true)
+    vma.clipboard.set(s)
+    update_pos(lrange.begin)
+    @paste_lines = true
+    #recalc_line_ends
+  end
+
+  def insert_tab
+    convert = conf(:tab_to_spaces_default)
+    convert = true if conf(:tab_to_spaces_languages).include?(@lang)
+    convert = false if conf(:tab_to_spaces_not_languages).include?(@lang)
+    tw = conf(:tab_width)
+    if convert
+      indent_to = (@cpos / tw) * tw + tw
+      indentdiff = indent_to - @cpos
+      insert_txt(" " * indentdiff)
+    else
+      insert_txt("\t")
+    end
+  end
+
+  def insert_image_after_current_line(fname)
+    lr = current_line_range()
+    a = "⟦img:#{fname}⟧\n"
+    b = " \n"
+    txt = a + b
+    insert_txt_at(txt, lr.end + 1)
+    buf.view.handle_deltas
+    imgpos = lr.end + 1 + a.size
+    add_image(fname, imgpos)
+  end
+end

data/lib/vimamsa/buffer_cursor.rb

@@ -0,0 +1,303 @@
+# Buffer operations related to cursor position, e.g. moving the cursor (backward, forward, next line etc.)
+class Buffer < String
+
+  def line(lpos)
+    if @line_ends.size == 0
+      return self
+    end
+
+    #TODO: implement using line_range()
+    if lpos >= @line_ends.size
+      debug("lpos too large") #TODO
+      return ""
+    elsif lpos == @line_ends.size
+    end
+    start = @line_ends[lpos - 1] + 1 if lpos > 0
+    start = 0 if lpos == 0
+    _end = @line_ends[lpos]
+    debug "start: _#{start}, end: #{_end}"
+    return self[start.._end]
+  end
+
+  def at_end_of_line?()
+    return (self[@pos] == "\n" or at_end_of_buffer?)
+  end
+
+  def at_end_of_buffer?()
+    return @pos == self.size
+  end
+
+  def refresh_cursor
+    self.view.set_cursor_pos(@pos)
+  end
+  
+  def set_pos(new_pos)
+    if new_pos >= self.size
+      @pos = self.size - 1 # TODO:??right side of last char
+    elsif new_pos >= 0
+      @pos = new_pos
+    end
+    self.view.set_cursor_pos(pos)
+     # gui_set_cursor_pos(@id, @pos)
+    calculate_line_and_column_pos
+
+    check_if_modified_outside
+  end
+
+  # Get the line number of character position
+  def get_line_pos(pos)
+    lpos = @line_ends.bsearch_index { |x, _| x >= pos }
+    return lpos
+  end
+
+  # Calculate the two dimensional column and line positions based on
+  # (one dimensional) position in the buffer.
+  def get_line_and_col_pos(pos)
+    pos = self.size if pos > self.size
+    pos = 0 if pos < 0
+
+    lpos = get_line_pos(pos)
+
+    lpos = @line_ends.size if lpos == nil
+    cpos = pos
+    cpos -= @line_ends[lpos - 1] + 1 if lpos > 0
+
+    return [lpos, cpos]
+  end
+
+  def calculate_line_and_column_pos(reset = true)
+    @lpos, @cpos = get_line_and_col_pos(@pos)
+    reset_larger_cpos if reset
+  end
+
+  def set_line_and_column_pos(lpos, cpos, _reset_larger_cpos = true)
+    @lpos = lpos if !lpos.nil?
+    @cpos = cpos if !cpos.nil?
+    if @lpos > 0
+      new_pos = @line_ends[@lpos - 1] + 1
+    else
+      new_pos = 0
+    end
+
+    if @cpos > (line(@lpos).size - 1)
+      debug("$cpos too large: #{@cpos} #{@lpos}")
+      if @larger_cpos < @cpos
+        @larger_cpos = @cpos
+      end
+      @cpos = line(@lpos).size - 1
+    end
+    new_pos += @cpos
+    set_pos(new_pos)
+    reset_larger_cpos if _reset_larger_cpos
+  end
+
+  # Calculate the one dimensional array index based on column and line positions
+  def calculate_pos_from_cpos_lpos(reset = true)
+    set_line_and_column_pos(nil, nil)
+  end
+
+  def update_pos(pos)
+    @pos = pos
+    calculate_line_and_column_pos
+  end
+
+  def is_legal_pos(pos, op = :read)
+    return false if pos < 0
+    if op == :add
+      return false if pos > self.size
+    elsif op == :read
+      return false if pos >= self.size
+    end
+    return true
+  end
+
+  def jump_to_last_edit()
+    return if @edit_pos_history.empty?
+    @edit_pos_history_i += 1
+
+    if @edit_pos_history_i > @edit_pos_history.size
+      @edit_pos_history_i = 0
+    end
+
+    #        if @edit_pos_history.size >= @edit_pos_history_i
+    set_pos(@edit_pos_history[-@edit_pos_history_i])
+    center_on_current_line
+    return true
+    #        end
+  end
+
+  def jump_to_next_edit()
+    return if @edit_pos_history.empty?
+    @edit_pos_history_i -= 1
+    @edit_pos_history_i = @edit_pos_history.size - 1 if @edit_pos_history_i < 0
+    debug "@edit_pos_history_i=#{@edit_pos_history_i}"
+    set_pos(@edit_pos_history[-@edit_pos_history_i])
+    center_on_current_line
+    return true
+  end
+
+  def jump_to_random_pos()
+    set_pos(rand(self.size))
+  end
+
+  def jump_to_next_instance_of_word()
+    if $kbd.last_action == $kbd.cur_action and @current_word != nil
+      # debug "REPEATING *"
+    else
+      start_search = [@pos - 150, 0].max
+
+      search_str1 = self[start_search..(@pos)]
+      wsmarks = scan_indexes(search_str1, /(?<=[^\p{Word}])\p{Word}/)
+      a = wsmarks[-1]
+      a = 0 if a == nil
+
+      search_str2 = self[(@pos)..(@pos + 150)]
+      wemarks = scan_indexes(search_str2, /(?<=\p{Word})[^\p{Word}]/)
+      b = wemarks[0]
+      word_start = (@pos - search_str1.size + a + 1)
+      word_start = 0 if !(word_start >= 0)
+      @current_word = self[word_start..(@pos + b - 1)]
+    end
+
+    #TODO: search for /[^\p{Word}]WORD[^\p{Word}]/
+    position_of_next_word = self.index(@current_word, @pos + 1)
+    if position_of_next_word != nil
+      set_pos(position_of_next_word)
+    else #Search from beginning
+      position_of_next_word = self.index(@current_word)
+      set_pos(position_of_next_word) if position_of_next_word != nil
+    end
+    center_on_current_line
+    return true
+  end
+
+  def jump_word(direction, wordpos)
+    offset = 0
+    if direction == FORWARD
+      debug "POS: #{@pos},"
+      search_str = self[(@pos)..(@pos + 250)]
+      return if search_str == nil
+      if wordpos == WORD_START # vim 'w'
+        wsmarks = scan_indexes(search_str, /(?<=[^\p{Word}])\p{Word}|\Z/) # \Z = end of string, just before last newline.
+        wsmarks2 = scan_indexes(search_str, /\n[ \t]*\n/) # "empty" lines that have whitespace
+        wsmarks2 = wsmarks2.collect { |x| x + 1 }
+        wsmarks = (wsmarks2 + wsmarks).sort.uniq
+        offset = 0
+        if wsmarks.any?
+          next_pos = @pos + wsmarks[0] + offset
+          set_pos(next_pos)
+        end
+      elsif wordpos == WORD_END
+        search_str = self[(@pos + 1)..(@pos + 150)]
+        wsmarks = scan_indexes(search_str, /(?<=\p{Word})[^\p{Word}]/)
+        offset = -1
+        if wsmarks.any?
+          next_pos = @pos + 1 + wsmarks[0] + offset
+          set_pos(next_pos)
+        end
+      end
+    end
+    if direction == BACKWARD #  vim 'b'
+      start_search = @pos - 150 #TODO 150 length limit
+      start_search = 0 if start_search < 0
+      search_str = self[start_search..(@pos - 1)]
+      return if search_str == nil
+      wsmarks = scan_indexes(search_str,
+                             #/(^|(\W)\w|\n)/) #TODO 150 length limit
+                             #/^|(?<=[^\p{Word}])\p{Word}|(?<=\n)\n/) #include empty lines?
+                             /\A|(?<=[^\p{Word}])\p{Word}/) # Start of string or nonword,word.
+
+      offset = 0
+
+      if wsmarks.any?
+        next_pos = start_search + wsmarks.last + offset
+        set_pos(next_pos)
+      end
+    end
+  end
+
+  def jump_to_mark(mark_char)
+    p = @marks[mark_char]
+    set_pos(p) if p
+    center_on_current_line
+    return true
+  end
+
+  def jump(target)
+    if target == START_OF_BUFFER
+      set_pos(0)
+    end
+    if target == END_OF_BUFFER
+      set_pos(self.size - 1)
+    end
+    if target == BEGINNING_OF_LINE
+      @cpos = 0
+      calculate_pos_from_cpos_lpos
+    end
+    if target == END_OF_LINE
+      @cpos = line(@lpos).size - 1
+      calculate_pos_from_cpos_lpos
+    end
+
+    if target == FIRST_NON_WHITESPACE
+      l = current_line()
+      debug l.inspect
+      @cpos = line(@lpos).size - 1
+      a = scan_indexes(l, /\S/)
+      debug a.inspect
+      if a.any?
+        @cpos = a[0]
+      else
+        @cpos = 0
+      end
+      calculate_pos_from_cpos_lpos
+    end
+  end
+
+  def jump_to_line(line_n = 1)
+
+    #    $method_handles_repeat = true
+    #    if !$next_command_count.nil? and $next_command_count > 0
+    #        line_n = $next_command_count
+    #        debug "jump to line:#{line_n}"
+    #    end
+    debug "jump to line:#{line_n}"
+    line_n = get_repeat_num() if line_n == 1
+
+    if line_n > @line_ends.size
+      debug("lpos too large") #TODO
+      return
+    end
+    if line_n == 1
+      set_pos(0)
+    else
+      set_pos(@line_ends[line_n - 2] + 1)
+    end
+  end
+
+  def jump_to_next_instance_of_char(char, direction = FORWARD)
+    if direction == FORWARD
+      position_of_next_char = self.index(char, @pos + 1)
+      if position_of_next_char != nil
+        @pos = position_of_next_char
+      end
+    elsif direction == BACKWARD
+      start_search = @pos - 250
+      start_search = 0 if start_search < 0
+      search_substr = self[start_search..(@pos - 1)]
+      _pos = search_substr.reverse.index(char)
+      if _pos != nil
+        @pos -= (_pos + 1)
+      end
+    end
+    m = method("jump_to_next_instance_of_char")
+    set_last_command({ method: m, params: [char, direction] })
+    $last_find_command = { char: char, direction: direction }
+    set_pos(@pos)
+    return true
+  end
+
+  def jump_to_pos(new_pos)
+    set_pos(new_pos)
+  end
+end

data/lib/vimamsa/buffer_list.rb

@@ -1,4 +1,3 @@
-
 def save_buffer_list()
   message("Save buffer list")
   buffn = get_dot_path("buffers.txt")
@@ -21,13 +20,13 @@ def load_buffer_list()
 end
 
 class BufferList < Array
-  attr_reader :current_buf, :last_dir, :buffer_history
+  attr_reader :current_buf, :last_dir, :last_file, :buffer_history
 
   def initialize()
     @last_dir = File.expand_path(".")
     @buffer_history = []
     super
-    @current_buf=0
+    @current_buf = 0
   end
 
   # lastdir = File.expand_path(".") if lastdir.nil?
@@ -39,7 +38,8 @@ class BufferList < Array
     @recent_ind = 0
     $hook.call(:change_buffer, vma.buf)
     vma.gui.set_current_buffer(vma.buf.id)
-    gui_set_cursor_pos(vma.buf.id, vma.buf.pos)
+    # gui_set_cursor_pos(vma.buf.id, vma.buf.pos)
+    vma.buf.view.set_cursor_pos(vma.buf.pos)
     update_last_dir(_buf)
   end
 
@@ -111,8 +111,13 @@ class BufferList < Array
   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
+    if !vma.buf.nil? and vma.kbd.get_mode != :browse #TODO
+      # Save keyboard mode status of old buffer when switching buffer
+      vma.buf.mode_stack = vma.kbd.default_mode_stack.clone
+    end
     vma.buf = self[buffer_i]
     return if !vma.buf
+    update_last_dir(vma.buf)
     @current_buf = buffer_i
     debug "SWITCH BUF2. bufsize:#{self.size}, curbuf: #{@current_buf}"
     fpath = vma.buf.fname
@@ -123,24 +128,36 @@ class BufferList < Array
     if update_history
       add_current_buf_to_history
     end
-
     vma.hook.call(:change_buffer, vma.buf)
-    vma.buf.set_active
+    vma.buf.set_active # TODO
 
     vma.gui.set_current_buffer(vma.buf.id)
 
+    if !vma.buf.mode_stack.nil? and vma.kbd.get_mode != :browse #TODO
+      debug "set kbd mode stack #{vma.buf.mode_stack}  #{vma.buf.id}", 2
+      # Reload previously saved keyboard mode status
+      # vma.kbd.set_mode_stack(vma.buf.mode_stack.clone) #TODO:needed?
+      vma.kbd.set_mode_stack([vma.buf.default_mode])
+    end
+    vma.kbd.set_mode_to_default
+
     gui_set_window_title(vma.buf.title, vma.buf.subtitle)
 
     if vma.buf.fname
       @last_dir = File.dirname(vma.buf.fname)
     end
 
-    # hpt_scan_images() if $debug # experimental
+    # hpt_scan_images() if cnf.debug? # experimental
+  end
+
+  def to_s
+    return self.class.to_s
   end
 
   def update_last_dir(buf)
     if buf.fname
       @last_dir = File.dirname(buf.fname)
+      @last_file = buf.fname
     end
   end
 
@@ -213,8 +230,8 @@ class BufferList < Array
       if from_recent
         @current_buf = jump_to_buf
       else
-      	# Find last edited buffer that is not already open
-        @current_buf = @buffer_history.filter{|x| !vma.gui.is_buffer_open(self[x].id)}.last
+        # Find last edited buffer that is not already open
+        @current_buf = @buffer_history.filter { |x| !vma.gui.is_buffer_open(self[x].id) }.last
       end
     end
     if self.size == 0 or @current_buf.nil?

data/lib/vimamsa/buffer_manager.rb

@@ -7,11 +7,12 @@ class BufferManager
   end
 
   def self.init()
-    vma.kbd.add_minor_mode("bmgr", :buf_mgr, :command)
+    # vma.kbd.add_minor_mode("bmgr", :buf_mgr, :command)
+    vma.kbd.add_minor_mode("bmgr", :bmgr, :command)
     reg_act(:bmgr_select, proc { buf.module.select_line }, "")
     reg_act(:bmgr_close, proc { buf.module.close_selected }, "")
 
-    reg_act(:start_buf_manager, proc { BufferManager.new.run; vma.kbd.set_mode(:buf_mgr) }, "Buffer manager")
+    reg_act(:start_buf_manager, proc { BufferManager.new.run; vma.kbd.set_mode(:bmgr) }, "Buffer manager")
 
     bindkey "bmgr enter", :bmgr_select
     bindkey "bmgr c", :bmgr_close
@@ -84,6 +85,7 @@ class BufferManager
 
     if @buf.nil?
       @buf = create_new_buffer(s,"bufmgr")
+      @buf.default_mode = :buf_mgr
       @buf.module = self
       @buf.active_kbd_mode = :buf_mgr
     else

data/lib/vimamsa/clipboard.rb

@@ -0,0 +1,35 @@
+class Clipboard
+  def initialize
+    @clipboard = []
+  end
+
+  def [](key)
+    return @clipboard[key]
+  end
+
+  def <<(str)
+    return @clipboard << str
+  end
+
+  def set(s)
+    if !(s.class <= String) or s.size == 0
+      debug s.inspect
+      debug [s, s.class, s.size]
+      log_error("s.class != String or s.size == 0")
+      return
+    end
+    @clipboard << s
+    set_system_clipboard(s)
+    vma.register[vma.cur_register] = s
+    debug "SET CLIPBOARD: [#{s}]"
+    debug "REGISTER: #{vma.cur_register}:#{vma.register[vma.cur_register]}"
+  end
+
+  def get()
+    return @clipboard[-1]
+  end
+end
+
+def set_system_clipboard(arg)
+  vma.gui.window.display.clipboard.set(arg)
+end