vimamsa 0.1.22 → 0.1.24

data/lib/vimamsa/buffer_changetext.rb

@@ -22,7 +22,14 @@ class Buffer < String
     else
       @deltas << delta
     end
-    @edit_history << delta
+
+    unless @macro_group_active
+      if @last_delta_time && (Time.now - @last_delta_time) > cnf.undo.group_threshold!
+        new_undo_group
+      end
+    end
+    @current_group << delta
+    @last_delta_time = Time.now
     if self[-1] != "\n"
       add_delta([self.size, INSERT, 1, "\n"], true)
     end
@@ -81,19 +88,19 @@ class Buffer < String
     @clipboard_paste_running = true
     Thread.new {
       text = `xclip -selection c -o`
-      paste_finish(text, at, register)
+      GLib::Idle.add { paste_finish(text, at, register); false }
     }
     return nil
   end
 
   # Start asynchronous read of system clipboard
-  def paste_start(at, register)
+  def paste_start(at, register, overwrite: false)
     @clipboard_paste_running = true
 
-    if true or running_wayland? and !GLib::Version::or_later?(2, 79, 0)
-      return paste_start_xclip(at, register)
-    end
-    
+    # if true or running_wayland? and !GLib::Version::or_later?(2, 79, 0)
+      # return paste_start_xclip(at, register)
+    # end
+
     clipboard = vma.gui.window.display.clipboard
     clipboard.read_text_async do |_clipboard, result|
       begin
@@ -101,13 +108,13 @@ class Buffer < String
       rescue Gio::IOError::NotSupported
         debug Gio::IOError::NotSupported
       else
-        paste_finish(text, at, register)
+        paste_finish(text, at, register, overwrite: overwrite)
       end
     end
     return nil
   end
 
-  def paste_finish(text, at, register)
+  def paste_finish(text, at, register, overwrite: false)
     debug "PASTE: #{text}"
 
     # If we did not put this text to clipboard
@@ -121,9 +128,25 @@ class Buffer < String
 
     return if text == ""
 
-    if @paste_lines
+    cursor_at_start = cnf.paste.cursor_at_start!
+
+    if overwrite && !@paste_lines
+      # Delete as many chars forward as we are about to insert, stopping before newline
+      line_end = current_line_range.last - 1  # position of last char before \n
+      n = [text.size, [line_end - @pos + 1, 0].max].min
+      add_delta([@pos, DELETE, n], true) if n > 0
+      insert_txt_at(text, @pos)
+      set_pos(cursor_at_start ? @pos : @pos + text.size - 1)
+    elsif @paste_lines
       debug "PASTE LINES"
-      put_to_new_next_line(text)
+      if at == BEFORE
+        l = current_line_range()
+        insert_txt_at(text, l.begin)
+        set_pos(l.begin)
+      else
+        put_to_new_next_line(text)
+        set_pos(@pos) if cursor_at_start
+      end
     else
       debug "PASTE !LINES"
       if at_end_of_buffer? or at_end_of_line? or at == BEFORE
@@ -132,12 +155,23 @@ class Buffer < String
         pos = @pos + 1
       end
       insert_txt_at(text, pos)
-      set_pos(pos + text.size)
+      set_pos(cursor_at_start ? pos : pos + text.size)
     end
     set_pos(@pos)
+    vma.buf.view.after_action # redraw
     @clipboard_paste_running = false
   end
 
+  def paste_over(at = AFTER, register = nil)
+    if vma.macro.running_macro
+      text = vma.clipboard.get()
+      paste_finish(text, at, register, overwrite: true)
+    else
+      paste_start(at, register, overwrite: true)
+    end
+    return true
+  end
+
   def paste(at = AFTER, register = nil)
     # Macro's don't work with asynchronous call using GTK
     # TODO: implement as synchronous?
@@ -152,6 +186,22 @@ class Buffer < String
     return true
   end
 
+  def increment_current_word()
+    debug "increment_current_word", 2
+    p = @pos
+    return if !is_legal_pos(p)
+    (word, range) = get_word_in_pos(p, boundary: :word2)
+    if word.match(/(true|false)/i)
+      rep = flip_true_false(word)
+    else
+      num = word.to_i
+      num += 1
+      rep = num.to_s
+    end
+    debug [word, range].to_s, 2
+    replace_range(range, rep)
+  end
+
   def complete_current_word(rep)
     debug "complete_current_word", 2
     p = @pos - 1
@@ -189,7 +239,11 @@ class Buffer < String
       (startpos, endpos) = get_visual_mode_range2
       delete_range(startpos, endpos, x)
       @pos = [@pos, @selection_start].min
-      end_visual_mode
+      if vma.kbd.get_mode == :visual
+        end_visual_mode
+      else
+        end_selection
+      end
       #return
 
       # Delete current char
@@ -217,7 +271,7 @@ class Buffer < String
 
   def delete_range(startpos, endpos, x = nil)
     s = self[startpos..endpos]
-    if startpos == endpos or s == ""
+    if startpos > endpos or s == ""
       return
     end
     if x == :append

data/lib/vimamsa/buffer_cursor.rb

@@ -1,6 +1,5 @@
 # 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
@@ -30,15 +29,22 @@ class Buffer < String
   def refresh_cursor
     self.view.set_cursor_pos(@pos)
   end
-  
+
   def set_pos(new_pos)
+    # If user interacts with the buffer, we consider that the buffer has been accessed
+    # And navigation has ended
+    if new_pos != @pos
+      update_access_time
+      bufs.reset_navigation
+    end
     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)
+    # gui_set_cursor_pos(@id, @pos)
     calculate_line_and_column_pos
 
     check_if_modified_outside

data/lib/vimamsa/buffer_list.rb

@@ -20,12 +20,11 @@ def load_buffer_list()
 end
 
 class BufferList
-  attr_reader :current_buf, :last_dir, :last_file, :buffer_history
+  attr_reader :current_buf, :last_dir, :last_file
   attr_accessor :list
 
   def initialize()
     @last_dir = File.expand_path(".")
-    @buffer_history = []
     super
     @current_buf = 0
     @list = []
@@ -42,25 +41,14 @@ class BufferList
     vma.gui.set_current_buffer(vma.buf.id) #TODO: handle elswhere?
     # vma.buf.view.set_cursor_pos(vma.buf.pos)  #TODO: handle elswhere?
     update_last_dir(_buf)
+    vma.gui.file_panel_refresh
   end
 
   def add(_buf)
-    @buffer_history << _buf.id
-    # @navigation_idx = _buf.id #TODO:??
     @list << _buf
     @h[_buf.id] = _buf
   end
 
-  #NOTE: unused. enable?
-  # 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 slist
     # TODO: implement using heap/priorityque
     @list.sort_by! { |x| x.access_time }
@@ -72,6 +60,13 @@ class BufferList
     end
   end
 
+  def print_by_access_time
+    slist.reverse.each_with_index do |b, i|
+      name = b.fname || "(untitled)"
+      puts "#{i + 1}. #{b.access_time.strftime('%H:%M:%S')} #{name}"
+    end
+  end
+
   def get_last_visited_id
     last_buf = nil
     for i in 0..(slist.size - 1)
@@ -83,9 +78,6 @@ class BufferList
 
   def switch_to_last_buf()
     debug "SWITCH TO LAST BUF:"
-    # debug @buffer_history
-    # last_buf = @buffer_history[-2]
-
     last_buf = slist[-2]
     if !last_buf.nil?
       set_current_buffer(last_buf.id)
@@ -107,17 +99,6 @@ class BufferList
     return @h[id]
   end
 
-  def add_buf_to_history(buf_idx)
-    if @list.include?(buf_idx)
-      @buffer_history << @buf_idx
-      @navigation_idx = 0
-      # compact_buf_history()
-    else
-      debug "buffer_list, no such id:#{buf_idx}"
-      return
-    end
-  end
-
   def add_current_buf_to_history()
     @h[@current_buf].update_access_time
   end
@@ -143,7 +124,10 @@ class BufferList
 
     bu.set_active # TODO
     bu.update_access_time if update_history
+    reset_navigation if update_history
     vma.gui.set_current_buffer(idx)
+    vma.gui.file_panel_refresh
+    vma.gui.func_panel_refresh
 
     #TODO: delete?
     # if !vma.buf.mode_stack.nil? and vma.kbd.get_scope != :editor #TODO
@@ -255,6 +239,8 @@ class BufferList
 
     @list.delete(@h[idx])
     @h.delete(idx)
+    gui_close_buffer(idx)
+    vma.gui.file_panel_refresh
 
     if auto_open
       @current_buf = get_last_non_active_buffer

data/lib/vimamsa/buffer_manager.rb

@@ -60,7 +60,7 @@ class BufferManager
     @@cur = self
     @header = []
     @header << "Current buffers:"
-    @header << "keys: <enter> to select, <c> to close buffer, <x> exit"
+    @header << "keys: <enter> (or <double click>) to select, <c> to close buffer, <x> exit"
     @header << "=" * 40
 
     s = ""

data/lib/vimamsa/conf.rb

@@ -13,7 +13,7 @@ $confh = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
 # => $confh = {:foo=>{:bar=>{:baz=>3}}}
 def set(_id, val)
   a = $confh
-  id = _id.to_a
+  id = _id.to_a.dup
   last = id.pop
   for x in id
     a = a[x]
@@ -103,6 +103,28 @@ def cnf()
   return $vimamsa_conf
 end
 
+# Read a config value by key path array.
+# Uses the cnf accessor chain so key types match cnf.xxx! reads.
+# Example:
+#   cnf_get([:tab, :width])   # => 2
+#   cnf_get([:style_scheme])  # => "molokai_edit"
+def cnf_get(key)
+  obj = cnf
+  key[0..-2].each { |k| obj = obj.public_send(k) }
+  obj.public_send(:"#{key.last}!")
+end
+
+# Write a config value by key path array.
+# Uses the cnf accessor chain so the value is readable via cnf.xxx!
+# Example:
+#   cnf_set([:tab, :width], 4)
+#   cnf_set([:style_scheme], "soviet_cockpit")
+def cnf_set(key, val)
+  obj = cnf
+  key[0..-2].each { |k| obj = obj.public_send(k) }
+  obj.public_send(:"#{key.last}=", val)
+end
+
 cnf.indent_based_on_last_line = true
 cnf.extensions_to_open = [".txt", ".h", ".c", ".cpp", ".hpp", ".rb", ".inc", ".php", ".sh", ".m", ".gd", ".js", ".py"]
 cnf.default_search_extensions = ["txt", "rb"]
@@ -112,6 +134,8 @@ cnf.lsp.enabled = false
 cnf.fexp.experimental = false
 cnf.experimental = false
 
+cnf.kbd.show_prev_action = true
+
 cnf.tab.width = 2
 cnf.tab.to_spaces_default = false
 cnf.tab.to_spaces_languages = ["c", "java", "ruby", "hyperplaintext", "php"]
@@ -129,4 +153,12 @@ cnf.startup_file=false
 
 cnf.macro.animation_delay = 0.02
 
+cnf.undo.group_threshold = 1.8 # seconds of inactivity before starting a new undo group
+
+cnf.paste.cursor_at_start = false
+
+cnf.style_scheme = "molokai_edit"
+cnf.color_contrast = 1.0
+cnf.color_brightness = 0.0
+
 

data/lib/vimamsa/diff_buffer.rb

@@ -0,0 +1,185 @@
+# Map a "line number in a unified diff output" to the corresponding
+# line in the new/changed file (the + side), together with the file it belongs to.
+#
+# Handles multi-file diffs: each --- / +++ pair sets the active file; each @@
+# hunk header resets the line counters. Walking hunk lines:
+#   ' ' => old++, new++
+#   '-' => old++
+#   '+' => new++
+#
+# Returns [new_path, old_path, line_no] or nil for deleted / unmappable lines.
+#
+class DiffLineMapper
+  HUNK_RE = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/
+
+  def initialize(diff_text)
+    @lines = diff_text.lines
+  end
+
+  # Given a 1-based line number in the diff output, return:
+  #   - [new_path, old_path, Integer]: raw +++ path, raw --- path, 1-based new-file line
+  #   - nil: if the diff line is a deletion ('-') or cannot be mapped
+  def new_line_for_diff_lineno(diff_lineno)
+    raise ArgumentError, "diff line number must be >= 1" if diff_lineno.to_i < 1
+    idx = diff_lineno.to_i - 1
+    return nil if idx >= @lines.length
+
+    old_path = nil
+    new_path = nil
+    old = nil
+    new_ = nil
+    in_hunk = false
+
+    @lines.each_with_index do |line, i|
+      # File headers reset hunk state and record current file paths.
+      # These appear outside hunks, but guard against malformed diffs too.
+      if line.start_with?('--- ')
+        old_path = line[4..].split("\t").first.strip
+        in_hunk = false
+        old = new_ = nil
+        next
+      end
+
+      if line.start_with?('+++ ')
+        new_path = line[4..].split("\t").first.strip
+        in_hunk = false
+        old = new_ = nil
+        next
+      end
+
+      if (m = line.match(HUNK_RE))
+        old = m[1].to_i
+        new_ = m[3].to_i
+        in_hunk = true
+        next
+      end
+
+      next unless in_hunk
+
+      if i == idx
+        return nil unless new_
+        case line.getbyte(0)
+        when '+'.ord then return [new_path, old_path, new_]
+        when ' '.ord then return [new_path, old_path, new_]
+        when '-'.ord then return nil
+        else              return nil
+        end
+      end
+
+      next unless old && new_
+
+      case line.getbyte(0)
+      when ' '.ord then old += 1; new_ += 1
+      when '-'.ord then old += 1
+      when '+'.ord then new_ += 1
+      end
+    end
+
+    nil
+  end
+end
+
+def diff_buffer_init()
+  return if @diff_buffer_init_done
+  @diff_buffer_init_done = true
+  vma.kbd.add_minor_mode("diffview", :diffview, :command)
+  bindkey "diffview enter", :diff_buffer_jump_to_source
+end
+
+def diff_buffer()
+  return if !if_cmd_exists("diff")
+  diff_buffer_init
+  orig_path = vma.buf.fname
+  infile = Tempfile.new("in")
+  infile.write(vma.buf.to_s)
+  infile.flush
+  bufstr = run_cmd("diff -uw '#{orig_path}' #{infile.path}")
+  infile.close; infile.unlink
+  create_new_file(nil, bufstr)
+  gui_set_file_lang(vma.buf.id, "diff")
+  vma.kbd.set_mode(:diffview)
+end
+
+def diff_buffer_jump_to_source()
+  mapper = DiffLineMapper.new(vma.buf.to_s)
+  cur_lpos = vma.buf.lpos + 1
+  result = mapper.new_line_for_diff_lineno(cur_lpos)
+
+  if result.nil?
+    message("No source line for this position")
+    return
+  end
+
+  new_path, old_path, to_line = result
+  orig_path = resolve_diff_path(new_path, old_path)
+
+  if orig_path.nil? || !File.exist?(orig_path)
+    message("Could not find file: #{new_path || old_path}")
+    return
+  end
+
+  jump_to_file(orig_path, to_line)
+  center_on_current_line
+end
+
+# Resolve a +++ / --- path pair to an absolute filesystem path.
+# Prefers new_path (the post-change file); falls back to old_path
+# when new_path is /dev/null or a temp file that no longer exists.
+def resolve_diff_path(new_path, old_path)
+  git_root = `git rev-parse --show-toplevel 2>/dev/null`.strip
+
+  expand = lambda do |path|
+    return nil if path.nil? || path == "/dev/null"
+    # git diff uses "a/" / "b/" prefixes for old/new sides
+    if path.start_with?("b/") || path.start_with?("a/")
+      rel = path[2..]
+      return git_root.empty? ? File.expand_path(rel) : File.join(git_root, rel)
+    end
+    path.start_with?("/") ? path : File.expand_path(path)
+  end
+
+  path = expand.call(new_path)
+  return path if path && File.exist?(path)
+
+  expand.call(old_path)
+end
+
+def git_diff_w()
+  return if !if_cmd_exists("git")
+  diff_buffer_init
+
+  dir = vma.buf.fname ? File.dirname(vma.buf.fname) : Dir.pwd
+  git_root = `git -C #{Shellwords.escape(dir)} rev-parse --show-toplevel 2>/dev/null`.strip
+  if git_root.empty?
+    message("Not a git repository")
+    return
+  end
+
+  bufstr = run_cmd("git -C #{Shellwords.escape(git_root)} diff -w")
+  if bufstr.strip.empty?
+    message("git diff -w: no changes")
+    return
+  end
+
+  create_new_file(nil, bufstr)
+  gui_set_file_lang(vma.buf.id, "diff")
+  vma.kbd.set_mode(:diffview)
+end
+
+def git_diff_buffer()
+  return if !if_cmd_exists("git")
+  diff_buffer_init
+  fname = vma.buf.fname
+  if fname.nil?
+    message("Buffer has no file")
+    return
+  end
+  bufstr = run_cmd("git diff -w -- #{Shellwords.escape(fname)}")
+  if bufstr.strip.empty?
+    message("git diff: no changes")
+    return
+  end
+  create_new_file(nil, bufstr)
+  gui_set_file_lang(vma.buf.id, "diff")
+  vma.kbd.set_mode(:diffview)
+end