vimamsa 0.1.23 → 0.1.24

data/lib/vimamsa/diff_buffer.rb

@@ -1,16 +1,13 @@
 # Map a "line number in a unified diff output" to the corresponding
-# line number in the *new/changed file* (the + side).
+# line in the new/changed file (the + side), together with the file it belongs to.
 #
-# Key idea:
-#   @@ -old_start,old_count +new_start,new_count @@
-# sets starting counters. Then walk each hunk line:
+# Handles multi-file diffs: each --- / +++ pair sets the active file; each @@
+# hunk header resets the line counters. Walking hunk lines:
 #   ' ' => old++, new++
 #   '-' => old++
 #   '+' => new++
 #
-# If the target diff line is:
-#   ' ' or '+' => it corresponds to current new line (before increment)
-#   '-'        => it has no new-file line (deleted). We return nil.
+# Returns [new_path, old_path, line_no] or nil for deleted / unmappable lines.
 #
 class DiffLineMapper
   HUNK_RE = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/
@@ -20,18 +17,36 @@ class DiffLineMapper
   end
 
   # Given a 1-based line number in the diff output, return:
-  #   - Integer: 1-based line number in the new file
-  #   - nil:     if the diff line is a deletion ('-') or cannot be mapped
+  #   - [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
@@ -41,17 +56,11 @@ class DiffLineMapper
 
       next unless in_hunk
 
-      if line.start_with?('--- ', '+++ ')
-        in_hunk = false
-        old = new_ = nil
-        next
-      end
-
       if i == idx
         return nil unless new_
         case line.getbyte(0)
-        when '+'.ord then return new_
-        when ' '.ord then return new_
+        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
@@ -94,23 +103,18 @@ end
 def diff_buffer_jump_to_source()
   mapper = DiffLineMapper.new(vma.buf.to_s)
   cur_lpos = vma.buf.lpos + 1
-  to_line = mapper.new_line_for_diff_lineno(cur_lpos)
-
-  orig_path = nil
-  vma.buf.to_s.each_line do |l|
-    if l =~ /^--- (.+)/
-      path = $1.split("\t").first.strip
-      # git diff prefixes paths with "a/" — strip it and resolve from git root
-      if path.start_with?("a/")
-        git_root = `git rev-parse --show-toplevel 2>/dev/null`.strip
-        path = File.join(git_root, path[2..]) unless git_root.empty?
-      end
-      orig_path = path
-      break
-    end
+  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 original file in diff")
+    message("Could not find file: #{new_path || old_path}")
     return
   end
 
@@ -118,6 +122,50 @@ def diff_buffer_jump_to_source()
   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

data/lib/vimamsa/editor.rb

@@ -1,9 +1,5 @@
 require "pty"
 
-# def handle_drag_and_drop(fname)
-# debug "EDITOR:handle_drag_and_drop"
-# buf.handle_drag_and_drop(fname)
-# end
 
 class Editor
   attr_reader :file_content_search_paths, :file_name_search_paths, :gui, :hook, :macro, :actions
@@ -131,6 +127,22 @@ class Editor
       #TODO: if language enabled in config?
     end
 
+    # Load each module that is enabled in settings.
+    # Each module lives in modules/<name>/<name>.rb and may optionally define
+    # <name>_init to register actions, key bindings, etc.
+    Dir.glob(ppath("modules/*/")).sort.each do |mod_dir|
+      mod_name = File.basename(mod_dir)
+      if cnf.modules.public_send(mod_name).enabled?
+        main_file = File.join(mod_dir, "#{mod_name}.rb")
+        if File.exist?(main_file)
+          load main_file
+          # Call <name>_init if the module defines it.
+          init_fn = "#{mod_name}_init"
+          send(init_fn) if respond_to?(init_fn, true)
+        end
+      end
+    end
+
     fname = nil
     if cnf.startup_file?
       fname_ = File.expand_path(cnf.startup_file!)
@@ -171,6 +183,17 @@ class Editor
     check_session_restore unless argv_has_files
 
     @hook.call(:after_init)
+
+    if ARGV.include?("--test")
+      test_files = ARGV.select { |a| a.end_with?(".rb") && File.file?(a) }
+      run_as_idle proc {
+        test_files.each { |f| load f }
+        success = run_vma_tests
+        # Defer shutdown so GTK can drain all pending idle callbacks from test
+        # teardown before widget destruction begins (avoids heap corruption).
+        GLib::Timeout.add(300) { shutdown(); false }
+      }
+    end
   end
 
   def register_plugin(name, obj)
@@ -206,6 +229,7 @@ class Editor
 
   def save_var_to_file(varname, vardata)
     fn = get_dot_path(varname)
+    #TODO: check that save path is safe
     f = File.open(fn, "w")
     File.binwrite(f, vardata)
     f.close
@@ -253,6 +277,7 @@ class Editor
 
     fnames = File.read(session_path).lines.map(&:strip).reject(&:empty?)
     fnames.select! { |f| File.exist?(f) }
+    fnames.reject! { |f| vma.buffers.get_buffer_by_filename(f) }
     return if fnames.empty?
 
     n = fnames.size
@@ -404,12 +429,6 @@ def set_next_command_count(num)
   debug("NEXT COMMAND COUNT: #{$next_command_count}")
 end
 
-def start_minibuffer_cmd(bufname, bufstr, cmd)
-  vma.kbd.set_mode(:minibuffer)
-  $minibuffer = Buffer.new(bufstr, "")
-  $minibuffer.call_func = method(cmd)
-end
-
 def if_cmd_exists(cmd)
   cmd = cmd.gsub(/[^a-zA-Z0-9_\-]/, '')
   if !system("which #{cmd} > /dev/null 2>&1")
@@ -419,53 +438,6 @@ def if_cmd_exists(cmd)
  return true
 end
 
-def invoke_command()
-  start_minibuffer_cmd("", "", :execute_command)
-end
-
-def execute_command(input_str)
-  begin
-    out_str = eval(input_str, TOPLEVEL_BINDING) #TODO: Other binding?
-    $minibuffer.clear
-    $minibuffer << out_str.to_s #TODO: segfaults, why?
-  rescue SyntaxError
-    debug("SYNTAX ERROR with eval cmd #{action}: " + $!.to_s)
-  end
-end
-
-def minibuffer_end()
-  debug "minibuffer_end"
-  vma.kbd.set_mode(:command)
-  minibuffer_input = $minibuffer.to_s[0..-2]
-  return $minibuffer.call_func.call(minibuffer_input)
-end
-
-def minibuffer_cancel()
-  debug "minibuffer_cancel"
-  vma.kbd.set_mode(:command)
-  minibuffer_input = $minibuffer.to_s[0..-2]
-  # $minibuffer.call_func.call('')
-end
-
-def minibuffer_new_char(c)
-  if c == "\r"
-    raise "Should not come here"
-    debug "MINIBUFFER END"
-  else
-    $minibuffer.insert_txt(c)
-    debug "MINIBUFFER: #{c}"
-  end
-  #vma.buf = $minibuffer
-end
-
-# def readchar_new_char(c)
-# $input_char_call_func.call(c)
-# end
-
-def minibuffer_delete()
-  $minibuffer.delete(BACKWARD_CHAR)
-end
-
 def error(str)
   show_caller
   debug "#{caller[0]} ERROR: #{str}", 2
@@ -550,10 +522,13 @@ def load_buffer(fname)
   # If file already open in existing buffer
   existing_buffer = vma.buffers.get_buffer_by_filename(fname)
   if existing_buffer != nil
-    vma.buffers.add_buf_to_history(existing_buffer)
     return
   end
   return if !File.exist?(fname)
+  if Encrypt.is_encrypted?(fname)
+    decrypt_dialog(filename: fname)
+    return nil
+  end
   debug("LOAD BUFFER: #{fname}")
   buffer = Buffer.new(read_file("", fname), fname)
   # gui_set_current_buffer(buffer.id)
@@ -562,7 +537,6 @@ def load_buffer(fname)
   #buf = filter_buffer(buffer)
   #    debug("END FILTER: #{fname}")
   vma.buffers << buffer
-  #$buffer_history << vma.buffers.size - 1
   return buffer
 end
 
@@ -631,14 +605,9 @@ def scan_word_start_marks(search_str)
   return wsmarks
 end
 
-def hook_draw()
-  # TODO: as hook.register
-  # easy_jump_draw()
-end
-
 def get_dot_path(sfx)
   dot_dir = File.expand_path("~/.config/vimamsa")
-  Dir.mkdir(dot_dir) unless File.exist?(dot_dir)
+  FileUtils.mkdir_p(dot_dir) unless File.exist?(dot_dir)
   dpath = "#{dot_dir}/#{sfx}"
   return dpath
 end
@@ -655,6 +624,24 @@ def get_file_line_pointer(s)
   return nil
 end
 
+# Try to resolve a bare "filename.ext:line" reference (no directory component).
+# Searches the current buffer's directory and the last visited directory.
+def resolve_bare_file_line_pointer(s)
+  m = s.match(/\A([\w.\-]+\.[a-zA-Z0-9]+):(c?)(\d+)\z/)
+  return nil unless m
+  fname = m[1]
+  col   = m[2]
+  line  = m[3].to_i
+  dirs = []
+  dirs << File.dirname(vma.buf.fname) if vma.buf&.fname
+  dirs << bufs.last_dir              if bufs.last_dir
+  dirs.uniq.each do |dir|
+    candidate = File.join(dir, fname)
+    return [candidate, line, col] if File.exist?(candidate)
+  end
+  nil
+end
+
 def find_project_dir_of_fn(fn)
   pcomp = Pathname.new(fn).each_filename.to_a
   parent_dirs = (0..(pcomp.size - 2)).collect { |x| "/" + pcomp[0..x].join("/") }.reverse
@@ -693,9 +680,9 @@ end
 
 def save_settings_to_file
   settings_path = get_dot_path("settings.rb")
-  lines = SETTINGS_DEFS.flat_map { |section| section[:settings] }.map do |s|
+  lines = all_settings_defs.flat_map { |section| section[:settings] }.map do |s|
     key_str = "cnf." + s[:key].join(".")
-    val = get(s[:key])
+    val = cnf_get(s[:key])
     "#{key_str} = #{val.inspect}"
   end
   IO.write(settings_path, lines.join("\n") + "\n")

data/lib/vimamsa/file_finder.rb

@@ -39,12 +39,16 @@ class FileFinder
 
   def initialize()
     vma.hook.register(:shutdown, self.method("save"))
-    @@dir_list = vma.marshal_load("file_index")
+    # Load saved file list on startup (disabled for now, TODO)
+    # @@dir_list = vma.marshal_load("file_index")
     @@dir_list ||= []
-    update_search_idx
+    # update_search_idx
+    FileFinder.recursively_find_files
+    message("FileFinder initialized, directories: #{cnf.search_dirs!}")
   end
 
   def self.update_search_idx
+  
     Thread.new {
       sleep 0.1
       @@idx = StringIndex.new