[mini.git] Manage git conflicts | replace git-conflict.nvim with 200 lines

[drowning-cat]

About

Features

1. Enabled only during rebase/merge.
2. Automatically highlights merge conflicts.
3. Provides additional buffer-local keymaps for resolving conflicts.

Keymaps

Key	Action
co	Keep only ours (top) changes, removing parent (base) part.
ct	Keep only theirs (bottom) changes.
cb	Keep both ours and theirs changes, removing parent part.
c0	Delete the entire conflict block.
]x	Jump to the next conflict start <<<<<<<. Supports vim.v.count.
[x	Jump to the previous conflict start <<<<<<<. Supports vim.v.count.
]X	Jump to the first conflict in the file.
[X	Jump to the last conflict in the file.

* Unlike the motions provided by mini.bracketed keymaps ]x / [x jump only to the start of each conflict <<<<<<< — not to every conflict marker <<<<<<<, =======, or >>>>>>>.

Yapping

I tried not to make a mess, but...

Code

Version 1

local conflict_ns = vim.api.nvim_create_namespace("git_conflict")
local conflict_au = vim.api.nvim_create_augroup("git_conflict", { clear = true })

local function minigit_is_merge(buf)
  local git_summary = vim.b[buf].minigit_summary or {}
  local in_progress = git_summary.in_progress or ""
  return in_progress:find("merge") or in_progress:find("rebase")
end

-- get_buf_conflicts(buf) -> { { {1,5}, {3,5}, {5,7} }, ... }
--                               ours   base?  theirs
-- 1: <<<<<<< HEAD
-- 2: local a = "main"
-- 3: ||||||| parent of xxxxxxx (xxx)
-- 4: local a = "base"
-- 5: =======
-- 6: local a = "feature"
-- 7: >>>>>>> xxxxxxx (xxx)
--
local function buf_conflicts(buf)
  local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, true)
  local ours, base, theirs = {}, {}, {}
  local conflicts = {}
  local on_end_mark = function()
    local ok = function(val)
      return val[1] and val[2]
    end
    if ok(ours) and ok(theirs) then
      base = ok(base) and base or nil
      table.insert(conflicts, { ours, base, theirs })
      ours, base, theirs = {}, {}, {}
    end
  end
  -- stylua: ignore
  for ln, line in ipairs(lines) do
    if vim.startswith(line, "<<<<<<<") then ours[1] = ln end
    if vim.startswith(line, "|||||||") then base[1] = ln end
    if vim.startswith(line, "=======") then ours[2], base[2], theirs[1] = ln, ln, ln end
    if vim.startswith(line, ">>>>>>>") then theirs[2] = ln; on_end_mark() end
  end
  return conflicts
end

local function conflict_actions()
  local get_prev = function(count)
    count = count or 1
    local lnum = vim.api.nvim_win_get_cursor(0)[1]
    local conflicts = vim.b.git_conflicts or {}
    for i = #conflicts, 1, -1 do
      local ours, _, _ = unpack(conflicts[i])
      if lnum > ours[1] then
        if count <= 1 then
          return conflicts[i]
        end
        count = count - 1
      end
    end
  end
  local get_next = function(count)
    count = count or 1
    local lnum = vim.api.nvim_win_get_cursor(0)[1]
    local conflicts = vim.b.git_conflicts or {}
    for i = 1, #conflicts, 1 do
      local ours, _, _ = unpack(conflicts[i])
      if lnum < ours[1] then
        if count <= 1 then
          return conflicts[i]
        end
        count = count - 1
      end
    end
  end
  local get_curr = function()
    local lnum = vim.api.nvim_win_get_cursor(0)[1]
    for _, conflict in ipairs(vim.b.git_conflicts or {}) do
      local ours, _, theirs = unpack(conflict)
      if lnum >= ours[1] and lnum <= theirs[2] then
        return conflict
      end
    end
  end
  local get_lines = function(from, to)
    return vim.api.nvim_buf_get_lines(0, from - 1, to - 1, true)
  end
  local replace = function(conflict, lines)
    local ours, _, theirs = unpack(conflict)
    vim.api.nvim_buf_set_lines(0, ours[1] - 1, theirs[2], true, lines)
    vim.api.nvim_win_set_cursor(0, { ours[1], 0 })
  end
  local jump = function(conflict)
    local ours, _, _ = unpack(conflict)
    vim.api.nvim_win_set_cursor(0, { ours[1], 0 })
  end
  return {
    ours = function()
      local curr = get_curr()
      if curr then
        local ours, base, _ = unpack(curr)
        local repl = get_lines(ours[1] + 1, base[1] or ours[2])
        replace(curr, repl)
      end
    end,
    theirs = function()
      local curr = get_curr()
      if curr then
        local _, _, theirs = unpack(curr)
        local repl = get_lines(theirs[1] + 1, theirs[2])
        replace(curr, repl)
      end
    end,
    both = function()
      local curr = get_curr()
      if curr then
        local ours, base, theirs = unpack(curr)
        local repl = {}
        vim.list_extend(repl, get_lines(ours[1] + 1, base[1] or ours[2]))
        vim.list_extend(repl, get_lines(theirs[1] + 1, theirs[2]))
        replace(curr, repl)
      end
    end,
    none = function()
      local curr = get_curr()
      if curr then
        replace(curr, {})
      end
    end,
    forward = function()
      local next = get_next(vim.v.count1)
      if next then
        jump(next)
      end
    end,
    backward = function()
      local prev = get_prev(vim.v.count1)
      if prev then
        jump(prev)
      end
    end,
    last = function()
      local conflicts = vim.b.git_conflicts or {}
      local last = conflicts[#conflicts]
      if last then
        local ours, _, _ = unpack(last)
        local lnum = vim.api.nvim_win_get_cursor(0)[1]
        if lnum < ours[1] then
          jump(last)
        end
      end
    end,
    first = function()
      local conflicts = vim.b.git_conflicts or {}
      local first = conflicts[1]
      if first then
        local ours, _, _ = unpack(first)
        local lnum = vim.api.nvim_win_get_cursor(0)[1]
        if lnum > ours[1] then
          jump(first)
        end
      end
    end,
  }
end

local function conflict_update(buf)
  if not minigit_is_merge(buf) then
    vim.b[buf].git_conflicts = {}
    vim.api.nvim_buf_clear_namespace(buf, conflict_ns, 0, -1)
  else
    local conflicts = buf_conflicts(buf)
    vim.b[buf].git_conflicts = conflicts
    -- Refresh highlights
    vim.api.nvim_buf_clear_namespace(buf, conflict_ns, 0, -1)
    local hi = function(from, to, hl)
      vim.api.nvim_buf_set_extmark(buf, conflict_ns, from - 1, 0, {
        end_row = to,
        hl_group = hl,
        hl_eol = true,
      })
    end
    for _, conflict in ipairs(conflicts) do
      local ours, base, theirs = unpack(conflict)
      hi(ours[1], ours[2] - 1, "DiffText")
      if base then
        hi(base[1], base[2] - 1, "DiffDelete")
      end
      hi(theirs[1] + 1, theirs[2], "DiffAdd")
    end
  end
end

local conflict_autocmd = function(event, pattern, on_update)
  on_update = on_update or function() end
  vim.api.nvim_create_autocmd(event, {
    group = conflict_au,
    pattern = pattern,
    -- stylua: ignore
    callback = function(e) conflict_update(e.buf); on_update(e) end,
  })
end

conflict_autocmd("ModeChanged", "i:*")
conflict_autocmd("TextChanged")
conflict_autocmd("User", "MiniGitUpdated", function(e)
  local buf = e.buf
  -- Just create global keymaps?
  local actions = conflict_actions()
  if minigit_is_merge(buf) then
    vim.keymap.set("n", "co", actions.ours, { buffer = buf, desc = "Checkout ours" })
    vim.keymap.set("n", "ct", actions.theirs, { buffer = buf, desc = "Checkout theirs" })
    vim.keymap.set("n", "cb", actions.both, { buffer = buf, desc = "Checkout both" })
    vim.keymap.set("n", "c0", actions.none, { buffer = buf, desc = "Checkout none" })
    vim.keymap.set("n", "]x", actions.forward, { buffer = buf, desc = "Conflict forward" })
    vim.keymap.set("n", "[x", actions.backward, { buffer = buf, desc = "Conflict backward" })
    vim.keymap.set("n", "]X", actions.last, { buffer = buf, desc = "Conflict last" })
    vim.keymap.set("n", "[X", actions.first, { buffer = buf, desc = "Conflict first" })
  else
    pcall(function()
      vim.keymap.del("n", "co", { buffer = buf })
      vim.keymap.del("n", "ct", { buffer = buf })
      vim.keymap.del("n", "cb", { buffer = buf })
      vim.keymap.del("n", "c0", { buffer = buf })
      vim.keymap.del("n", "]x", { buffer = buf })
      vim.keymap.del("n", "[x", { buffer = buf })
      vim.keymap.del("n", "]X", { buffer = buf })
      vim.keymap.del("n", "[X", { buffer = buf })
    end)
  end
end)

Version 2

local conflict_ns = vim.api.nvim_create_namespace("git_conflict")
local conflict_au = vim.api.nvim_create_augroup("git_conflict", {})

-- get_buf_conflicts(buf) -> { { {1,5}, {3,5}, {5,7} }, ... }
--                               ours   base?  theirs
-- 1: <<<<<<< HEAD
-- 2: local a = "main"
-- 3: ||||||| parent of xxxxxxx (xxx)
-- 4: local a = "base"
-- 5: =======
-- 6: local a = "feature"
-- 7: >>>>>>> xxxxxxx (xxx)
--
local function find_conflicts(buf)
  buf = buf or 0
  local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, true)
  local ours, base, theirs = {}, {}, {}
  local conflicts = {}
  local on_end_mark = function()
    local full = function(val)
      return val[1] and val[2]
    end
    if full(ours) and full(theirs) then
      base = full(base) and base or nil
      table.insert(conflicts, { ours, base, theirs })
      ours, base, theirs = {}, {}, {}
    end
  end
  -- stylua: ignore
  for ln, line in ipairs(lines) do
    if vim.startswith(line, "<<<<<<<") then ours[1] = ln end
    if vim.startswith(line, "|||||||") then base[1] = ln end
    if vim.startswith(line, "=======") then ours[2], base[2], theirs[1] = ln, ln, ln end
    if vim.startswith(line, ">>>>>>>") then theirs[2] = ln; on_end_mark() end
  end
  return conflicts
end

local conflict_state = {}
local function toggle_conflicts(buf)
  buf = buf or 0
  if not vim.api.nvim_buf_is_valid(buf) then
    vim.notify(string.format("Invalid buffer: %d", buf), vim.log.levels.ERROR)
    return
  end
  conflict_state[buf] = not conflict_state[buf]
  if not conflict_state[buf] then
    vim.api.nvim_clear_autocmds({ group = conflict_au, buffer = buf })
    vim.api.nvim_buf_clear_namespace(buf, conflict_ns, 0, -1)
    vim.b[buf].minigit_conflicts = nil
  else
    local update = function() ---@diagnostic disable-line: redefined-local
      local conflicts = find_conflicts(buf)
      vim.b[buf].minigit_conflicts = conflicts
      vim.api.nvim_buf_clear_namespace(buf, conflict_ns, 0, -1)
      local hi = function(from, to, hl)
        vim.api.nvim_buf_set_extmark(buf, conflict_ns, from - 1, 0, {
          end_row = to,
          hl_group = hl,
          hl_eol = true,
        })
      end
      for _, conflict in ipairs(conflicts) do
        local ours, base, theirs = unpack(conflict)
        hi(ours[1], ours[2] - 1, "DiffText")
        hi(theirs[1] + 1, theirs[2], "DiffAdd")
        if base then
          hi(base[1], base[2] - 1, "DiffDelete")
        end
      end
    end
    update()
    vim.api.nvim_clear_autocmds({ group = conflict_au, buffer = buf })
    vim.api.nvim_create_autocmd("ModeChanged", { pattern = "i:*", group = conflict_au, callback = update })
    vim.api.nvim_create_autocmd("TextChanged", { group = conflict_au, buffer = buf, callback = update })
  end
end

local conflict_actions = {}
do
  local get_conflict = function()
    local lnum = vim.api.nvim_win_get_cursor(0)[1]
    for _, conflict in ipairs(vim.b.minigit_conflicts or {}) do
      local ours, _, theirs = unpack(conflict)
      if lnum >= ours[1] and lnum <= theirs[2] then
        return conflict
      end
    end
  end
  local replace_conflict = function(conflict, lines)
    local ours, _, theirs = unpack(conflict)
    vim.api.nvim_buf_set_lines(0, ours[1] - 1, theirs[2], true, lines)
    vim.api.nvim_win_set_cursor(0, { ours[1], 0 })
  end
  local get_lines = function(from, to)
    return vim.api.nvim_buf_get_lines(0, from - 1, to - 1, true)
  end
  local search = function(line, pattern, ...)
    line = type(line) == "number" and line or vim.fn.line(line)
    local saved_pos = vim.fn.getpos(".")
    vim.fn.cursor(line, 0)
    if vim.fn.search(pattern, ...) == 0 or vim.fn.line(".") == saved_pos[2] then
      vim.fn.cursor(saved_pos[2], saved_pos[3])
    end
  end
  --
  conflict_actions.ours = function()
    local conflict = get_conflict()
    if conflict then
      local ours, base, _ = unpack(conflict)
      local repl = get_lines(ours[1] + 1, base[1] or ours[2])
      replace_conflict(conflict, repl)
    end
  end
  conflict_actions.theirs = function()
    local conflict = get_conflict()
    if conflict then
      local _, _, theirs = unpack(conflict)
      local repl = get_lines(theirs[1] + 1, theirs[2])
      replace_conflict(conflict, repl)
    end
  end
  conflict_actions.both = function()
    local conflict = get_conflict()
    if conflict then
      local ours, base, theirs = unpack(conflict)
      local repl = {}
      vim.list_extend(repl, get_lines(ours[1] + 1, base[1] or ours[2]))
      vim.list_extend(repl, get_lines(theirs[1] + 1, theirs[2]))
      replace_conflict(conflict, repl)
    end
  end
  conflict_actions.none = function()
    local conflict = get_conflict()
    if conflict then
      replace_conflict(conflict, {})
    end
  end
  conflict_actions.forward = function()
    for _ = 1, vim.v.count1 do
      search(".", "^<<<<<<< ")
    end
  end
  conflict_actions.backward = function()
    for _ = 1, vim.v.count1 do
      search(".", "^<<<<<<< ", "b")
    end
  end
  conflict_actions.last = function()
    search("$", "^<<<<<<< ", "bW")
  end
  conflict_actions.first = function()
    search(1, "^<<<<<<< ", "cW")
  end
end

local function minigit_is_merge(buf)
  buf = buf or 0
  local git_summary = vim.b[buf].minigit_summary or {}
  local in_progress = git_summary.in_progress
  return in_progress and (in_progress:find("merge") or in_progress:find("rebase"))
end

vim.api.nvim_create_autocmd("User", {
  pattern = "MiniGitUpdated",
  group = conflict_au,
  callback = function(e)
    local buf = e.buf
    if minigit_is_merge(buf) then
      if not vim.b[buf].minigit_conflicts then
        toggle_conflicts(buf)
        vim.keymap.set("n", "co", conflict_actions.ours, { buffer = buf, desc = "Checkout ours" })
        vim.keymap.set("n", "ct", conflict_actions.theirs, { buffer = buf, desc = "Checkout theirs" })
        vim.keymap.set("n", "cb", conflict_actions.both, { buffer = buf, desc = "Checkout both" })
        vim.keymap.set("n", "c0", conflict_actions.none, { buffer = buf, desc = "Checkout none" })
        vim.keymap.set("n", "]x", conflict_actions.forward, { buffer = buf, desc = "Conflict forward" })
        vim.keymap.set("n", "[x", conflict_actions.backward, { buffer = buf, desc = "Conflict backward" })
        vim.keymap.set("n", "]X", conflict_actions.last, { buffer = buf, desc = "Conflict last" })
        vim.keymap.set("n", "[X", conflict_actions.first, { buffer = buf, desc = "Conflict first" })
      end
    else
      if vim.b[buf].minigit_conflicts then
        toggle_conflicts(buf)
        vim.keymap.del("n", "co", { buffer = buf })
        vim.keymap.del("n", "ct", { buffer = buf })
        vim.keymap.del("n", "cb", { buffer = buf })
        vim.keymap.del("n", "c0", { buffer = buf })
        vim.keymap.del("n", "]x", { buffer = buf })
        vim.keymap.del("n", "[x", { buffer = buf })
        vim.keymap.del("n", "]X", { buffer = buf })
        vim.keymap.del("n", "[X", { buffer = buf })
      end
    end
  end,
})

[drowning-cat]

It would also be great to choose where to jump with mini.bracketed conflict keymaps ]x, [x, e.g. start|base|end.

[echasnovski]

It would also be great to choose where to jump with mini.bracketed conflict keymaps ]x, [x, e.g. start|base|end.

To be perfectly honest, "conflict" target in 'mini.bracketed' felt more like a gimmick. Mostly because it feels more natural to use proper Git client to resolve conflicts. But occasionally it is useful.

The idea behind it is to be a universal "common denominator" for common actions related to conflicts. Like described in its docs.

[drowning-cat]

Using the anchor nil | "start" | "parent" | "base" | "end" allows jumping between conflicts, though keymaps for jumping can easily be created using the :h search() command.

[drowning-cat]

I think MiniBracketed.conflict can be a bit difficult to use for conflict checkout, especially since three-way merges aren’t supported due to the parent marker |||||||.

-- 1: <<<<<<< HEAD  
-- 2: -- File 2  
-- 3: ||||||| parent of xxxxxxx (xxx)  
-- 4: -- File 1  
-- 5: =======  
-- 6: -- File 3  
-- 7: >>>>>>> xxxxxxx (xxx)  

[echasnovski]

Thanks for sharing! That's... a lot of code :)

I like the idea of highlighting merge conflicts. Maybe something like toggle_conflicts() might be a thing in 'mini.git', but proper implementation would probably be not concise :(

[drowning-cat]

Wow, toggle_conflicts() would be a really great feature. But it’s definitely tricky to add new things to mini.git without making it too big, since git itself already has so many features.

I have a few ideas for how it could work. Not sure if they’re worth it, but I’ll share them anyway.

I really like vim.b.minigit_summary because it makes scripting easier. In the same way, conflicts could be stored in a variable like vim.b.minigit_conflicts (or added to vim.b.minigit_summary).

This variable could be updated from the start, or only after toggle_conflicts() is enabled along with highlights. That way, users who only need the data can disable highlights through the vim.api and just use the variable. Also, it is too much to include every possible conflict keymap directly in mini.git, but having the conflict data available would make it easier for users to build their own mappings.

Maybe toggle_buf_conflicts() could simply highlight conflict markers in the current buffer, leaving it up to users to decide when to enable it, for example during a rebase or merge.

[echasnovski]

Maybe toggle_buf_conflicts() could simply highlight conflict markers in the current buffer, leaving it up to users to decide when to enable it, for example during a rebase or merge.

Yes, that was the initial idea, same as with MiniDiff.toggle_overlay(buf_id): users themselves toggle the feature when they need it, starting with disabled.

The problem is adding all the machinery of keeping track of text to automatically adjust after conflict markers are added/removed. The 'mini.diff' already has it, so adding overlay is not a huge addition, but it will be for 'mini.git'.

I don't know. But an idea is interesting and I'll keep this in mind. Along with toggle_line_blame(buf_id) for an another (surprisingly) popular "show last author of the cursor line" functionality.

[drowning-cat]

The only issue with toggle_ function I see is that MiniGitUpdated may be triggered multiple times during a rebase or merge, causing toggle_conflicts to repeatedly turn highlights on and off. In Version 2 (see the original code), I handled this by checking the vim.b[buf].minigit_conflicts buffer variable, which can also be used to track whether the overlay is currently enabled for a buffer.