diff --git a/README.md b/README.md index 6d78cb72..3724ab6b 100644 --- a/README.md +++ b/README.md @@ -166,6 +166,7 @@ Both methods automatically place the library in the plugin root directory. conflict_result_position = "bottom", -- "bottom" (default): result below diff panes or "center": result between diff panes (three columns) conflict_result_height = 30, -- Height of result pane in bottom layout (% of total height) conflict_result_width_ratio = { 1, 1, 1 }, -- Width ratio for center layout panes {left, center, right} (e.g., {1, 2, 1} for wider result) + conflict_show_base = false, -- Show the merge base (:1) as a 4th pane in the middle of the top row cycle_next_hunk = true, -- Wrap around when navigating hunks (]c/[c): false to stop at first/last cycle_next_file = true, -- Wrap around when navigating files (]f/[f): false to stop at first/last cycle_hunks_across_files = false, -- ]c/[c at file boundary hops to first/last hunk of next/prev file (explorer/history) @@ -302,6 +303,7 @@ Both methods automatically place the library in the plugin root directory. prev_conflict = "[x", -- Jump to previous conflict diffget_incoming = "2do", -- Get hunk from incoming (left/theirs) buffer diffget_current = "3do", -- Get hunk from current (right/ours) buffer + toggle_base = "cm", -- Show/hide the merge base (:1) pane }, }, }, diff --git a/doc/codediff.txt b/doc/codediff.txt index c877d3d1..dc630105 100644 --- a/doc/codediff.txt +++ b/doc/codediff.txt @@ -171,6 +171,14 @@ Git merge tool: git config --global merge.tool codediff git config --global mergetool.codediff.cmd 'nvim "$MERGED" -c "CodeDiff merge \"$MERGED\""' < + *codediff-merge-base* +The conflict view shows Incoming, Current and Result. Press `cm` +(`keymaps.conflict.toggle_base`) to show or hide a read-only Base pane with +the common ancestor (:1), or set `diff.conflict_show_base = true` to open it +by default. Base appears in the middle of the top row: between Incoming and +Current when Result is at the bottom, and above Result when +`conflict_result_position = "center"`. It scrolls with the inputs and is +aligned line-for-line with them. ============================================================================== CONFIGURATION *codediff-configuration* @@ -274,6 +282,7 @@ Setup entry point: conflict_result_position = "bottom", conflict_result_height = 30, conflict_result_width_ratio = { 1, 1, 1 }, + conflict_show_base = false, jump_to_first_change = true, highlight_added_deleted_files = false, highlight_priority = 100, @@ -381,6 +390,7 @@ Setup entry point: prev_conflict = "[x", diffget_incoming = "2do", diffget_current = "3do", + toggle_base = "cm", }, }, }) diff --git a/lua/codediff/config.lua b/lua/codediff/config.lua index 59a4139f..dc4ccdab 100644 --- a/lua/codediff/config.lua +++ b/lua/codediff/config.lua @@ -40,6 +40,7 @@ M.defaults = { conflict_result_position = "bottom", -- Position of result buffer in conflict view: "bottom" or "center" conflict_result_height = 30, -- Height of result buffer in bottom layout (percentage of total height) conflict_result_width_ratio = { 1, 1, 1 }, -- Width ratio for center layout panes {left, center, right} (e.g., {1, 2, 1} for wider result) + conflict_show_base = false, -- Show the merge base (:1) as a 4th conflict pane in the middle of the top row (toggle with keymaps.conflict.toggle_base) cycle_next_hunk = true, -- Wrap around when navigating hunks (]c/[c): true = cycle, false = stop at first/last cycle_next_file = true, -- Wrap around when navigating files (]f/[f): true = cycle, false = stop at first/last cycle_hunks_across_files = false, -- ]c/[c at file boundary jumps to first/last hunk of next/prev file (explorer/history mode) @@ -178,6 +179,7 @@ M.defaults = { -- Vimdiff-style numbered diffget (from result buffer) diffget_incoming = "2do", -- Get hunk from incoming (left/theirs) buffer diffget_current = "3do", -- Get hunk from current (right/ours) buffer + toggle_base = "cm", -- Show/hide the merge base (:1) pane }, }, } diff --git a/lua/codediff/ui/conflict/keymaps.lua b/lua/codediff/ui/conflict/keymaps.lua index c328d4c5..7497f582 100644 --- a/lua/codediff/ui/conflict/keymaps.lua +++ b/lua/codediff/ui/conflict/keymaps.lua @@ -16,6 +16,17 @@ local REPEATABLE_ACTIONS = { { key = "discard", fn = resolution.discard, desc = "Discard changes (keep base)" }, } +-- Required lazily: the Base view requires codediff.ui.conflict, which loads +-- this module, so a top-level require would be circular. `fn` must be a +-- function taking the tabpage, like every other action. +local TOGGLE_BASE = { + key = "toggle_base", + fn = function(tabpage) + require("codediff.ui.conflict.view.base").toggle(tabpage) + end, + desc = "Toggle merge base pane", +} + local PLAIN_ACTIONS = { { key = "accept_all_incoming", fn = resolution.accept_all_incoming, desc = "Accept ALL incoming changes" }, { key = "accept_all_current", fn = resolution.accept_all_current, desc = "Accept ALL current changes" }, @@ -23,6 +34,7 @@ local PLAIN_ACTIONS = { { key = "discard_all", fn = resolution.discard_all, desc = "Discard ALL, reset to base" }, { key = "next_conflict", fn = navigation.navigate_next_conflict, desc = "Next conflict" }, { key = "prev_conflict", fn = navigation.navigate_prev_conflict, desc = "Previous conflict" }, + TOGGLE_BASE, } -- Vimdiff-style numbered diffget, only meaningful on the result buffer. @@ -92,6 +104,23 @@ function M.setup_keymaps(tabpage) end end + -- The read-only Base pane only needs a way to hide itself and to quit. + local base_bufnr = session.base_bufnr + if base_bufnr and vim.api.nvim_buf_is_valid(base_bufnr) then + bind(base_bufnr, TOGGLE_BASE, { + rhs = function() + TOGGLE_BASE.fn(tabpage) + end, + extra = { desc = TOGGLE_BASE.desc }, + }) + local quit = resolve.keymaps_for("view").quit + if quit then + lifecycle.set_buf_keymap(tabpage, base_bufnr, "n", quit, function() + lifecycle.close(tabpage) + end, vim.tbl_extend("force", base_opts, { desc = "Close codediff tab" })) + end + end + lifecycle.end_keymap_scope(tabpage, "conflict") end diff --git a/lua/codediff/ui/conflict/merge/fillers.lua b/lua/codediff/ui/conflict/merge/fillers.lua index fae600c3..bdd46e54 100644 --- a/lua/codediff/ui/conflict/merge/fillers.lua +++ b/lua/codediff/ui/conflict/merge/fillers.lua @@ -52,14 +52,18 @@ end -- Compute fillers AND identify which changes are in conflict regions -- A conflict region is where BOTH input1 and input2 have changes to the same base region -- This matches VSCode's behavior of only highlighting conflicting changes -function M.compute_merge_fillers_and_conflicts(base_to_input1_diff, base_to_input2_diff, base_lines, input1_lines, input2_lines) +-- @param include_base boolean?: also align a visible Base pane, adding `base_fillers` +-- to the result and padding the inputs where Base is taller. +function M.compute_merge_fillers_and_conflicts(base_to_input1_diff, base_to_input2_diff, base_lines, input1_lines, input2_lines, include_base) -- Use VSCode's MappingAlignment.compute approach local mapping_alignments = compute_mapping_alignments(base_to_input1_diff.changes, base_to_input2_diff.changes) local all_left_fillers = {} local all_right_fillers = {} + local all_base_fillers = {} local left_total = 0 local right_total = 0 + local base_total = 0 -- Track which changes are in conflict regions local conflict_left_changes = {} @@ -109,8 +113,13 @@ function M.compute_merge_fillers_and_conflicts(base_to_input1_diff, base_to_inpu if a.input1_line and a.input2_line then local left_adj = a.input1_line + left_total local right_adj = a.input2_line + right_total + local base_adj = include_base and a.base_line and (a.base_line + base_total) local mx = math.max(left_adj, right_adj) + if base_adj then + mx = math.max(mx, base_adj) + end + if mx - left_adj > 0 then table.insert(all_left_fillers, { after_line = a.input1_line - 1, count = mx - left_adj }) left_total = left_total + (mx - left_adj) @@ -119,6 +128,10 @@ function M.compute_merge_fillers_and_conflicts(base_to_input1_diff, base_to_inpu table.insert(all_right_fillers, { after_line = a.input2_line - 1, count = mx - right_adj }) right_total = right_total + (mx - right_adj) end + if base_adj and mx - base_adj > 0 then + table.insert(all_base_fillers, { after_line = a.base_line - 1, count = mx - base_adj }) + base_total = base_total + (mx - base_adj) + end end end end @@ -126,8 +139,11 @@ function M.compute_merge_fillers_and_conflicts(base_to_input1_diff, base_to_inpu return { left_fillers = all_left_fillers, right_fillers = all_right_fillers, + base_fillers = include_base and all_base_fillers or nil, conflict_blocks = conflict_blocks, - }, conflict_left_changes, conflict_right_changes + }, + conflict_left_changes, + conflict_right_changes end return M diff --git a/lua/codediff/ui/conflict/view/base.lua b/lua/codediff/ui/conflict/view/base.lua new file mode 100644 index 00000000..c0efe228 --- /dev/null +++ b/lua/codediff/ui/conflict/view/base.lua @@ -0,0 +1,266 @@ +-- Optional fourth conflict pane showing the merge base (:1:). +-- +-- The pane sits in the middle of the top row: between Incoming and Current in +-- the bottom-result layout, and above Result in the center-result layout. It is +-- read-only, scroll-bound with the inputs, and aligned with them through the +-- same filler computation, so a line in Base stays level with its counterpart +-- on both sides. +local M = {} + +local lifecycle = require("codediff.ui.lifecycle") +local config = require("codediff.config") +local virtual_file = require("codediff.core.virtual_file") + +local WINBAR = " Base (Common ancestor)" + +local function valid_win(win) + return win and vim.api.nvim_win_is_valid(win) +end + +local function valid_buf(bufnr) + return bufnr and vim.api.nvim_buf_is_valid(bufnr) +end + +--- Whether the Base pane should be shown for this session. +--- The session keeps its own preference once toggled; until then the config +--- default applies. +--- @param session table +--- @return boolean +function M.is_enabled(session) + if session.show_base ~= nil then + return session.show_base + end + return config.options.diff.conflict_show_base == true +end + +--- True when the Base pane is currently on screen. +--- @param session table +--- @return boolean +function M.is_visible(session) + if not valid_win(session.base_win) or not valid_buf(session.base_bufnr) then + return false + end + return vim.api.nvim_win_get_buf(session.base_win) == session.base_bufnr +end + +--- Buffer for the visible Base pane, or nil. +--- @param session table +--- @return number|nil +function M.visible_bufnr(session) + if session and M.is_visible(session) then + return session.base_bufnr + end + return nil +end + +--- Replace the Base buffer content. +--- @param session table +--- @param base_lines table +function M.set_lines(session, base_lines) + local bufnr = session.base_bufnr + if not valid_buf(bufnr) then + return + end + local relative = session.original and session.original.relative + if relative and session.git_root then + -- The same codediff:/// stage-:1 URL as any other virtual revision buffer. + -- If another buffer already holds the name, keep this one unnamed. + local name = virtual_file.create_url(session.git_root, ":1", relative) + if vim.api.nvim_buf_get_name(bufnr) ~= name then + pcall(vim.api.nvim_buf_set_name, bufnr, name) + end + end + -- Shared with the virtual-file loader: read-only, Tree-sitter highlighting + -- without firing FileType, so no LSP attaches to the codediff:// URI. + virtual_file.set_content(bufnr, base_lines or {}, relative) +end + +-- The content is set from session.merge_base_lines, which the conflict view +-- already fetched, rather than loaded through the codediff:/// BufReadCmd: +-- that would run git again and its bufhidden=wipe would drop the buffer +-- every time the pane is toggled off. +local function ensure_buffer(session) + if valid_buf(session.base_bufnr) then + return session.base_bufnr + end + -- Listed, like the Incoming and Current revision buffers. + local bufnr = vim.api.nvim_create_buf(true, true) + vim.bo[bufnr].buftype = "nowrite" + vim.bo[bufnr].bufhidden = "hide" + vim.bo[bufnr].swapfile = false + session.base_bufnr = bufnr + return bufnr +end + +--- Leftmost of the two input windows. +local function left_input_win(session) + local orig_col = vim.api.nvim_win_get_position(session.original_win)[2] + local mod_col = vim.api.nvim_win_get_position(session.modified_win)[2] + return orig_col <= mod_col and session.original_win or session.modified_win +end + +local function open_window(session, bufnr) + local split + if config.options.diff.conflict_result_position == "center" then + split = { split = "above", win = session.result_win } + else + split = { split = "right", win = left_input_win(session) } + end + -- No codediff_restore flag: Base is auxiliary and must not change the + -- window count that decides when closing panes ends the session. + local win = vim.api.nvim_open_win(bufnr, false, split) + vim.wo[win].wrap = false + vim.wo[win].winbar = WINBAR + return win +end + +--- Re-render both inputs (and Base when visible) with matching alignment. +--- @param session table +function M.render(session) + if not session or not session.merge_base_lines then + return + end + if not valid_buf(session.original_bufnr) or not valid_buf(session.modified_bufnr) then + return + end + local original_lines = vim.api.nvim_buf_get_lines(session.original_bufnr, 0, -1, false) + local modified_lines = vim.api.nvim_buf_get_lines(session.modified_bufnr, 0, -1, false) + require("codediff.ui.conflict.view.inputs").compute_and_render_conflict( + session.original_bufnr, + session.modified_bufnr, + session.merge_base_lines, + original_lines, + modified_lines, + { base_bufnr = M.visible_bufnr(session) } + ) + -- Rendering clears the conflict namespace on the inputs; redraw the markers. + require("codediff.ui.conflict").refresh(session) +end + +--- Line the Base pane's view up with the inputs, using Current (or Incoming +--- when Current is gone) as the reference, and join their scrollbind group. +local function sync_view(session) + if not M.is_visible(session) then + return + end + local anchor = valid_win(session.modified_win) and session.modified_win or session.original_win + if not valid_win(anchor) then + return + end + local view = vim.api.nvim_win_call(anchor, vim.fn.winsaveview) + vim.api.nvim_win_call(session.base_win, function() + local line_count = vim.api.nvim_buf_line_count(session.base_bufnr) + vim.fn.winrestview({ topline = math.min(view.topline, line_count), lnum = math.min(view.lnum, line_count), col = 0 }) + end) + vim.wo[session.base_win].scrollbind = true + vim.api.nvim_win_call(anchor, function() + vim.cmd("syncbind") + end) +end + +--- Show the Base pane, creating its window and buffer when needed. +--- @param tabpage number +--- @return boolean shown +function M.show(tabpage) + local session = lifecycle.get_session(tabpage) + if not session or not valid_win(session.result_win) then + return false + end + if not valid_win(session.original_win) or not valid_win(session.modified_win) then + return false + end + + local bufnr = ensure_buffer(session) + M.set_lines(session, session.merge_base_lines or {}) + + if not valid_win(session.base_win) then + session.base_win = open_window(session, bufnr) + elseif vim.api.nvim_win_get_buf(session.base_win) ~= bufnr then + vim.api.nvim_win_set_buf(session.base_win, bufnr) + end + + M.render(session) + require("codediff.ui.layout").arrange(tabpage) + sync_view(session) + return true +end + +--- Close the Base window. The buffer is kept so a later toggle reuses it. +--- @param session table +function M.close_window(session) + local win = session.base_win + session.base_win = nil + if valid_win(win) then + pcall(vim.api.nvim_win_close, win, true) + end +end + +--- Hide the Base pane and restore two-column alignment of the inputs. +--- @param tabpage number +function M.hide(tabpage) + local session = lifecycle.get_session(tabpage) + if not session then + return + end + local was_visible = valid_win(session.base_win) + M.close_window(session) + if was_visible then + M.render(session) + require("codediff.ui.layout").arrange(tabpage) + end +end + +--- Make the pane match the session preference. Called whenever the conflict +--- view is (re)built for a file. +--- @param tabpage number +function M.sync(tabpage) + local session = lifecycle.get_session(tabpage) + if not session then + return + end + if M.is_enabled(session) then + M.show(tabpage) + else + M.hide(tabpage) + end +end + +--- Toggle the Base pane for this session. +--- @param tabpage number +function M.toggle(tabpage) + tabpage = tabpage or vim.api.nvim_get_current_tabpage() + local session = lifecycle.get_session(tabpage) + if not session or not valid_win(session.result_win) then + vim.notify("Base pane is only available in a merge conflict view", vim.log.levels.WARN) + return + end + local focused = vim.api.nvim_get_current_win() + local had_buffer = valid_buf(session.base_bufnr) + session.show_base = not M.is_visible(session) + M.sync(tabpage) + if session.show_base and not had_buffer then + -- A freshly created buffer still needs the conflict mappings (toggle + -- again, quit); an existing one kept them from the last bind. + require("codediff.ui.conflict").setup_keymaps(tabpage) + end + if valid_win(focused) then + vim.api.nvim_set_current_win(focused) + elseif valid_win(session.modified_win) then + vim.api.nvim_set_current_win(session.modified_win) + end +end + +--- Forget the Base pane when the session leaves conflict mode or ends. +--- @param session table +--- @param delete_buffer boolean +function M.teardown(session, delete_buffer) + M.close_window(session) + if delete_buffer and valid_buf(session.base_bufnr) then + pcall(vim.api.nvim_buf_delete, session.base_bufnr, { force = true }) + end + if delete_buffer then + session.base_bufnr = nil + end +end + +return M diff --git a/lua/codediff/ui/conflict/view/inputs.lua b/lua/codediff/ui/conflict/view/inputs.lua index 4139b077..859d1997 100644 --- a/lua/codediff/ui/conflict/view/inputs.lua +++ b/lua/codediff/ui/conflict/view/inputs.lua @@ -13,11 +13,15 @@ local diff_module = require("codediff.core.diff") -- @param base_lines table: Base content (:1:) -- @param original_lines table: Incoming content (:3:) -- @param modified_lines table: Current content (:2:) --- @param original_win number: Left window --- @param modified_win number: Right window --- @param auto_scroll_to_first_hunk boolean: Whether to scroll to first change +-- @param opts table?: Optional settings +-- - original_win number?: Left window; with modified_win, set up scrollbind +-- - modified_win number?: Right window +-- - auto_scroll_to_first_hunk boolean?: Scroll both windows to the first change +-- - base_bufnr number?: Base pane buffer (:1:) to align with both inputs, when shown -- @return table: { base_to_original_diff, base_to_modified_diff } -function M.compute_and_render_conflict(original_buf, modified_buf, base_lines, original_lines, modified_lines, original_win, modified_win, auto_scroll_to_first_hunk) +function M.compute_and_render_conflict(original_buf, modified_buf, base_lines, original_lines, modified_lines, opts) + opts = opts or {} + local original_win, modified_win = opts.original_win, opts.modified_win local diff_options = require("codediff.ui.view.render").diff_options() -- Compute base -> original (incoming) diff @@ -35,7 +39,8 @@ function M.compute_and_render_conflict(original_buf, modified_buf, base_lines, o end -- Render merge view with alignment and filler lines - local render_result = core.render_merge_view(original_buf, modified_buf, base_to_original_diff, base_to_modified_diff, base_lines, original_lines, modified_lines) + local render_result = + core.render_merge_view(original_buf, modified_buf, base_to_original_diff, base_to_modified_diff, base_lines, original_lines, modified_lines, opts.base_bufnr) -- Enable native scrollbind for the two conflict input panes. if original_win and modified_win and vim.api.nvim_win_is_valid(original_win) and vim.api.nvim_win_is_valid(modified_win) then @@ -47,7 +52,7 @@ function M.compute_and_render_conflict(original_buf, modified_buf, base_lines, o vim.wo[modified_win].scrollbind = true -- Scroll to first change in either buffer - if auto_scroll_to_first_hunk then + if opts.auto_scroll_to_first_hunk then local first_line = nil if #base_to_original_diff.changes > 0 then first_line = base_to_original_diff.changes[1].modified.start_line diff --git a/lua/codediff/ui/conflict/view/result.lua b/lua/codediff/ui/conflict/view/result.lua index da564ffb..b799ce59 100644 --- a/lua/codediff/ui/conflict/view/result.lua +++ b/lua/codediff/ui/conflict/view/result.lua @@ -159,6 +159,9 @@ function M.setup_conflict_result_window(tabpage, session_config, original_win, m end end + -- Optional fourth pane: the merge base, in the middle of the top row. + require("codediff.ui.conflict.view.base").sync(tabpage) + local conflict = require("codediff.ui.conflict") conflict.attach_gutter(original_win, modified_win) diff --git a/lua/codediff/ui/core.lua b/lua/codediff/ui/core.lua index 44bad115..1a3f61db 100644 --- a/lua/codediff/ui/core.lua +++ b/lua/codediff/ui/core.lua @@ -457,16 +457,23 @@ end -- base_lines: array of base content lines -- left_lines_content: array of input1 content lines -- right_lines_content: array of input2 content lines -function M.render_merge_view(left_bufnr, right_bufnr, base_to_left_diff, base_to_right_diff, base_lines, left_lines_content, right_lines_content) +-- base_bufnr: optional buffer showing base (:1); when given it is aligned with both inputs +function M.render_merge_view(left_bufnr, right_bufnr, base_to_left_diff, base_to_right_diff, base_lines, left_lines_content, right_lines_content, base_bufnr) local merge_alignment = require("codediff.ui.conflict.merge") + if base_bufnr and not vim.api.nvim_buf_is_valid(base_bufnr) then + base_bufnr = nil + end -- Clear existing highlights and fillers - vim.api.nvim_buf_clear_namespace(left_bufnr, ns_highlight, 0, -1) - vim.api.nvim_buf_clear_namespace(left_bufnr, ns_filler, 0, -1) - vim.api.nvim_buf_clear_namespace(left_bufnr, ns_conflict, 0, -1) - vim.api.nvim_buf_clear_namespace(right_bufnr, ns_highlight, 0, -1) - vim.api.nvim_buf_clear_namespace(right_bufnr, ns_filler, 0, -1) - vim.api.nvim_buf_clear_namespace(right_bufnr, ns_conflict, 0, -1) + local rendered_buffers = { left_bufnr, right_bufnr } + if base_bufnr then + table.insert(rendered_buffers, base_bufnr) + end + for _, bufnr in ipairs(rendered_buffers) do + vim.api.nvim_buf_clear_namespace(bufnr, ns_highlight, 0, -1) + vim.api.nvim_buf_clear_namespace(bufnr, ns_filler, 0, -1) + vim.api.nvim_buf_clear_namespace(bufnr, ns_conflict, 0, -1) + end gutter_signs.clear_buffer(left_bufnr) gutter_signs.clear_buffer(right_bufnr) @@ -475,8 +482,40 @@ function M.render_merge_view(left_bufnr, right_bufnr, base_to_left_diff, base_to local right_lines = vim.api.nvim_buf_get_lines(right_bufnr, 0, -1, false) -- Compute alignments to identify conflict regions (where both sides have changes) + local include_base = base_bufnr ~= nil local alignments, conflict_left_changes, conflict_right_changes = - merge_alignment.compute_merge_fillers_and_conflicts(base_to_left_diff, base_to_right_diff, base_lines, left_lines_content, right_lines_content) + merge_alignment.compute_merge_fillers_and_conflicts(base_to_left_diff, base_to_right_diff, base_lines, left_lines_content, right_lines_content, include_base) + + -- Base shows the text each side replaced in conflict regions. Both sides + -- often replaced the same base range, so each range is highlighted once. + if base_bufnr then + local base_buf_lines = vim.api.nvim_buf_get_lines(base_bufnr, 0, -1, false) + local highlighted = {} + local function first_time(kind, range) + local key = table.concat({ kind, range.start_line, range.start_col or 0, range.end_line, range.end_col or 0 }, ":") + if highlighted[key] then + return false + end + highlighted[key] = true + return true + end + for _, changes in ipairs({ conflict_left_changes, conflict_right_changes }) do + for _, change in ipairs(changes) do + local range = change.original + if range and range.end_line > range.start_line and first_time("line", range) then + apply_line_highlights(base_bufnr, range, "CodeDiffLineDelete") + end + for _, inner in ipairs(change.inner_changes or {}) do + if inner.original and not is_empty_range(inner.original) and first_time("char", inner.original) then + apply_char_highlight(base_bufnr, inner.original, "CodeDiffCharDelete", base_buf_lines) + end + end + end + end + for _, filler in ipairs(alignments.base_fillers or {}) do + filler_renderer.place(base_bufnr, filler.after_line - 1, filler.count) + end + end -- Render highlights ONLY for conflict regions (where both left and right modified the same base region) -- This matches VSCode's behavior of only highlighting conflicting changes diff --git a/lua/codediff/ui/keymap_help.lua b/lua/codediff/ui/keymap_help.lua index c9cbf978..76df77b2 100644 --- a/lua/codediff/ui/keymap_help.lua +++ b/lua/codediff/ui/keymap_help.lua @@ -152,6 +152,7 @@ local function build_sections(keymaps, is_bound, shape) { ckm.prev_conflict, "Previous conflict" }, { ckm.diffget_incoming, "Get hunk from incoming" }, { ckm.diffget_current, "Get hunk from current" }, + { ckm.toggle_base, "Toggle merge base pane" }, }, is_bound) ) end diff --git a/lua/codediff/ui/layout.lua b/lua/codediff/ui/layout.lua index 6d9db66f..cf39b195 100644 --- a/lua/codediff/ui/layout.lua +++ b/lua/codediff/ui/layout.lua @@ -67,6 +67,8 @@ function M.arrange(tabpage) end local has_result = result_win and vim.api.nvim_win_is_valid(result_win) + local base_win = session.base_win + local has_base = has_result and base_win and vim.api.nvim_win_is_valid(base_win) -- Step 2: Collect diff windows and sum their current widths -- In center layout, result is a sibling column — include it @@ -74,9 +76,13 @@ function M.arrange(tabpage) local result_position = config.options.diff.conflict_result_position local result_is_center = has_result and result_position == "center" + -- The Base pane is a top-row column of its own in bottom layout, and shares + -- the middle column with Result in center layout. local available = vim.api.nvim_win_get_width(original_win) + vim.api.nvim_win_get_width(modified_win) if result_is_center then available = available + vim.api.nvim_win_get_width(result_win) + elseif has_base then + available = available + vim.api.nvim_win_get_width(base_win) end -- Step 3: Handle result window height (bottom layout) @@ -103,6 +109,18 @@ function M.arrange(tabpage) vim.api.nvim_win_set_width(left_win, lw) vim.api.nvim_win_set_width(result_win, cw) vim.api.nvim_win_set_width(right_win, available - lw - cw) + + if has_base then + -- Base sits above Result, split the middle column evenly. + local column = vim.api.nvim_win_get_height(base_win) + vim.api.nvim_win_get_height(result_win) + vim.api.nvim_win_set_height(base_win, math.floor(column / 2)) + end + elseif has_base then + -- Three top-row panes: Incoming | Base | Current, equal split + local third = math.floor(available / 3) + vim.api.nvim_win_set_width(original_win, third) + vim.api.nvim_win_set_width(base_win, third) + vim.api.nvim_win_set_width(modified_win, available - 2 * third) else -- Two diff panes, equal split local half = math.floor(available / 2) diff --git a/lua/codediff/ui/lifecycle/accessors.lua b/lua/codediff/ui/lifecycle/accessors.lua index 1e3cd2a5..73a87913 100644 --- a/lua/codediff/ui/lifecycle/accessors.lua +++ b/lua/codediff/ui/lifecycle/accessors.lua @@ -450,6 +450,7 @@ function M.set_result(tabpage, result_bufnr, result_win) sess.keymaps:release_scope("conflict") end require("codediff.ui.conflict").teardown_gutter(tabpage) + require("codediff.ui.conflict.view.base").teardown(sess, false) sess.conflict_blocks = nil sess.result_base_lines = nil sess.merge_base_lines = nil diff --git a/lua/codediff/ui/lifecycle/cleanup.lua b/lua/codediff/ui/lifecycle/cleanup.lua index 1cdb874d..8749c5eb 100644 --- a/lua/codediff/ui/lifecycle/cleanup.lua +++ b/lua/codediff/ui/lifecycle/cleanup.lua @@ -83,6 +83,9 @@ local function cleanup_diff(tabpage) vim.w[diff.result_win].codediff_restore = nil end + -- Base pane (optional fourth conflict pane) is a codediff-owned scratch buffer. + require("codediff.ui.conflict.view.base").teardown(diff, true) + -- Clear conflict file tracking (buffers remain, just not tracked) diff.conflict_files = {} @@ -95,7 +98,7 @@ local function cleanup_diff(tabpage) end local function owns_window(diff, winid) - if diff.original_win == winid or diff.modified_win == winid or diff.result_win == winid then + if diff.original_win == winid or diff.modified_win == winid or diff.result_win == winid or diff.base_win == winid then return true end local panel_view = diff.panel and diff.panel.view diff --git a/lua/codediff/ui/lifecycle/session.lua b/lua/codediff/ui/lifecycle/session.lua index 703abc06..a39b499e 100644 --- a/lua/codediff/ui/lifecycle/session.lua +++ b/lua/codediff/ui/lifecycle/session.lua @@ -32,6 +32,9 @@ local keymap = require("codediff.keymap") -- -- Conflict mode result buffer (3-way merge) -- result_bufnr = number?, -- Real file buffer reset to BASE -- result_win = number?, -- Bottom window for result +-- base_bufnr = number?, -- Scratch buffer holding the merge base (:1) +-- base_win = number?, -- Optional Base pane (middle of the top row) +-- show_base = boolean?, -- Session Base-pane preference; nil follows config -- conflict_files = table?, -- { [file_path] = true } tracks files opened in conflict mode -- } -- } diff --git a/lua/codediff/ui/view/render.lua b/lua/codediff/ui/view/render.lua index 187fc351..12a7818c 100644 --- a/lua/codediff/ui/view/render.lua +++ b/lua/codediff/ui/view/render.lua @@ -194,7 +194,7 @@ function M.update(session, data, changes) local helpers = require("codediff.ui.view.helpers") local views = {} - for _, side in ipairs({ "original", "modified", "result" }) do + for _, side in ipairs({ "original", "modified", "result", "base" }) do local win = session[side .. "_win"] if win and api.nvim_win_is_valid(win) and not views[win] then views[win] = { view = api.nvim_win_call(win, vim.fn.winsaveview), scrollbind = vim.wo[win].scrollbind } @@ -212,8 +212,21 @@ function M.update(session, data, changes) end end if session.result_bufnr then - local diffs = - assert(require("codediff.ui.conflict.view.inputs").compute_and_render_conflict(session.original_bufnr, session.modified_bufnr, data.base, data.original, data.modified)) + local base_view = require("codediff.ui.conflict.view.base") + local base_bufnr = base_view.visible_bufnr(session) + if base_bufnr and changes.inputs then + base_view.set_lines(session, data.base) + end + local diffs = assert( + require("codediff.ui.conflict.view.inputs").compute_and_render_conflict( + session.original_bufnr, + session.modified_bufnr, + data.base, + data.original, + data.modified, + { base_bufnr = base_bufnr } + ) + ) if changes.inputs then result_view.set_inputs(session, data.base, diffs) end diff --git a/lua/codediff/ui/view/side_by_side/create.lua b/lua/codediff/ui/view/side_by_side/create.lua index 4e77c21f..e614b9ce 100644 --- a/lua/codediff/ui/view/side_by_side/create.lua +++ b/lua/codediff/ui/view/side_by_side/create.lua @@ -184,9 +184,7 @@ local function render_conflict_view(ctx) base_lines, ctx.original_lines, ctx.modified_lines, - original_win, - modified_win, - config.options.diff.jump_to_first_change + { original_win = original_win, modified_win = modified_win, auto_scroll_to_first_hunk = config.options.diff.jump_to_first_change } ) if not conflict_diffs then return diff --git a/lua/codediff/ui/view/side_by_side/update.lua b/lua/codediff/ui/view/side_by_side/update.lua index eaaad89d..ea3cba1a 100644 --- a/lua/codediff/ui/view/side_by_side/update.lua +++ b/lua/codediff/ui/view/side_by_side/update.lua @@ -232,8 +232,11 @@ function M.update(tabpage, session_config, auto_scroll_to_first_hunk) if not current() or not vim.api.nvim_buf_is_valid(original_info.bufnr) or not vim.api.nvim_buf_is_valid(modified_info.bufnr) then return end - local conflict_diffs = - compute_and_render_conflict(original_info.bufnr, modified_info.bufnr, base_lines, original_lines, modified_lines, original_win, modified_win, should_auto_scroll) + local conflict_diffs = compute_and_render_conflict(original_info.bufnr, modified_info.bufnr, base_lines, original_lines, modified_lines, { + original_win = original_win, + modified_win = modified_win, + auto_scroll_to_first_hunk = should_auto_scroll, + }) if conflict_diffs then lifecycle.update_buffers(tabpage, original_info.bufnr, modified_info.bufnr) diff --git a/tests/fixtures/keymap_matrix.txt b/tests/fixtures/keymap_matrix.txt index 5d7fcb8a..2b6b5750 100644 --- a/tests/fixtures/keymap_matrix.txt +++ b/tests/fixtures/keymap_matrix.txt @@ -228,6 +228,7 @@ original n \cO Accept ALL current changes original n \cT Accept ALL incoming changes original n \cX Discard ALL, reset to base original n \cb Accept both changes +original n \cm Toggle merge base pane original n \co Accept current change original n \ct Accept incoming change original n \cx Discard changes (keep base) @@ -251,6 +252,7 @@ modified n \cO Accept ALL current changes modified n \cT Accept ALL incoming changes modified n \cX Discard ALL, reset to base modified n \cb Accept both changes +modified n \cm Toggle merge base pane modified n \co Accept current change modified n \ct Accept incoming change modified n \cx Discard changes (keep base) @@ -276,6 +278,7 @@ result n \cO Accept ALL current changes result n \cT Accept ALL incoming changes result n \cX Discard ALL, reset to base result n \cb Accept both changes +result n \cm Toggle merge base pane result n \co Accept current change result n \ct Accept incoming change result n \cx Discard changes (keep base) diff --git a/tests/integration/keymap/actions_spec.lua b/tests/integration/keymap/actions_spec.lua index 3071c7c0..6caad2f3 100644 --- a/tests/integration/keymap/actions_spec.lua +++ b/tests/integration/keymap/actions_spec.lua @@ -130,6 +130,7 @@ local EXPECT = { prev_conflict = { "conflict" }, diffget_incoming = { "conflict" }, diffget_current = { "conflict" }, + toggle_base = { "conflict" }, }, } diff --git a/tests/integration/ui/conflict/file_switch_spec.lua b/tests/integration/ui/conflict/file_switch_spec.lua index 146916cf..9d5cc985 100644 --- a/tests/integration/ui/conflict/file_switch_spec.lua +++ b/tests/integration/ui/conflict/file_switch_spec.lua @@ -145,4 +145,34 @@ describe("conflict mode single-file switching", function() assert.is_true(vim.api.nvim_buf_is_valid(result_bufnr), "result buffer must stay valid") assert.is_true(vim.api.nvim_buf_is_loaded(result_bufnr), "result buffer must only be hidden, never unloaded") end) + + it("closes the Base pane with the conflict view and brings it back on return", function() + local config = require("codediff.config") + local saved_show_base = config.options.diff.conflict_show_base + config.options.diff.conflict_show_base = true + local ok, err = pcall(function() + local base_view = require("codediff.ui.conflict.view.base") + local lifecycle = require("codediff.ui.lifecycle") + open_conflict_view() + local session = lifecycle.get_session(tabpage) + assert.is_true(base_view.is_visible(session), "Base pane opens when enabled") + local window_count = #vim.api.nvim_tabpage_list_wins(tabpage) + + require("codediff.ui.view.side_by_side").show_untracked_file(tabpage, repo.path("fresh.txt")) + assert.is_false(base_view.is_visible(session), "Base pane must not survive into the single-file view") + assert.is_nil(session.base_win) + + reopen_conflict_view() + assert.is_true( + vim.wait(5000, function() + return base_view.is_visible(session) + end, 20), + "Base pane must be restored with the conflict view" + ) + assert.equals(window_count, #vim.api.nvim_tabpage_list_wins(tabpage)) + assert.same({ "base1", "base2", "base3" }, vim.api.nvim_buf_get_lines(session.base_bufnr, 0, -1, false)) + end) + config.options.diff.conflict_show_base = saved_show_base + assert.is_true(ok, err) + end) end) diff --git a/tests/integration/ui/conflict/layout_spec.lua b/tests/integration/ui/conflict/layout_spec.lua index 588e6044..735ee72e 100644 --- a/tests/integration/ui/conflict/layout_spec.lua +++ b/tests/integration/ui/conflict/layout_spec.lua @@ -5,23 +5,26 @@ describe("conflict editor layout", function() local repo local saved_layout local saved_result_position + local saved_show_base before_each(function() h.ensure_plugin_loaded() local config = require("codediff.config") saved_layout = config.options.diff.layout saved_result_position = config.options.diff.conflict_result_position + saved_show_base = config.options.diff.conflict_show_base config.options.diff.layout = "side-by-side" + -- Base is taller than either side so the Base pane needs input fillers. repo = h.create_temp_git_repo() - repo.write_file("file.txt", { "base" }) + repo.write_file("file.txt", { "top", "base 1", "base 2", "base 3", "bottom" }) repo.git("add file.txt") repo.git("commit -m base") repo.git("checkout -b feature") - repo.write_file("file.txt", { "feature" }) + repo.write_file("file.txt", { "top", "feature", "bottom" }) repo.git("commit -am feature") repo.git("checkout main") - repo.write_file("file.txt", { "main" }) + repo.write_file("file.txt", { "top", "main", "bottom" }) repo.git("commit -am main") local merge_output = repo.git("merge feature --no-edit") assert.is_true(merge_output:find("CONFLICT", 1, true) ~= nil, "merge must conflict") @@ -31,6 +34,7 @@ describe("conflict editor layout", function() local config = require("codediff.config") config.options.diff.layout = saved_layout config.options.diff.conflict_result_position = saved_result_position + config.options.diff.conflict_show_base = saved_show_base require("codediff.ui.lifecycle").cleanup_all() while vim.fn.tabpagenr("$") > 1 do vim.cmd("tabclose!") @@ -40,8 +44,7 @@ describe("conflict editor layout", function() end end) - it("places Result between the two inputs in center mode", function() - require("codediff.config").options.diff.conflict_result_position = "center" + local function open_conflict_editor() vim.cmd("edit " .. vim.fn.fnameescape(repo.path("file.txt"))) local ready = false @@ -71,9 +74,24 @@ describe("conflict editor layout", function() and vim.api.nvim_win_is_valid(session.modified_win) and vim.api.nvim_win_is_valid(session.result_win) end, 50), - "center conflict editor never became ready" + "conflict editor never became ready" ) + return session, tabpage + end + + local function displayed_rows(bufnr) + local rows = vim.api.nvim_buf_line_count(bufnr) + for _, count in pairs(require("codediff.ui.filler").get_virt_line_counts(bufnr)) do + rows = rows + count + end + return rows + end + it("places Result between the two inputs in center mode", function() + require("codediff.config").options.diff.conflict_result_position = "center" + local session = open_conflict_editor() + + assert.is_nil(session.base_win, "Base pane is opt-in") local original_position = vim.api.nvim_win_get_position(session.original_win) local modified_position = vim.api.nvim_win_get_position(session.modified_win) local result_position = vim.api.nvim_win_get_position(session.result_win) @@ -82,4 +100,100 @@ describe("conflict editor layout", function() assert.is_true(result_position[2] > math.min(original_position[2], modified_position[2])) assert.is_true(result_position[2] < math.max(original_position[2], modified_position[2])) end) + + it("places Base between the two inputs above Result when enabled in bottom mode", function() + local config = require("codediff.config") + config.options.diff.conflict_result_position = "bottom" + config.options.diff.conflict_show_base = true + local session = open_conflict_editor() + + assert.is_true(session.base_win ~= nil and vim.api.nvim_win_is_valid(session.base_win), "Base pane must open") + assert.same({ "top", "base 1", "base 2", "base 3", "bottom" }, vim.api.nvim_buf_get_lines(session.base_bufnr, 0, -1, false)) + assert.is_false(vim.bo[session.base_bufnr].modifiable) + -- A stage-:1 virtual revision buffer, highlighted without setting + -- filetype, so FileType never fires and no LSP attaches to it. + local base_name = vim.api.nvim_buf_get_name(session.base_bufnr) + assert.is_not_nil(base_name:match("^codediff:///.+///:1/file%.txt$"), base_name) + assert.equals("", vim.bo[session.base_bufnr].filetype) + assert.is_true(vim.bo[session.base_bufnr].buflisted) + assert.is_true(vim.wo[session.base_win].scrollbind) + assert.is_true(vim.wo[session.base_win].winbar:find("Base", 1, true) ~= nil) + + local original_position = vim.api.nvim_win_get_position(session.original_win) + local modified_position = vim.api.nvim_win_get_position(session.modified_win) + local base_position = vim.api.nvim_win_get_position(session.base_win) + local result_position = vim.api.nvim_win_get_position(session.result_win) + assert.equals(original_position[1], base_position[1]) + assert.equals(modified_position[1], base_position[1]) + assert.is_true(base_position[2] > math.min(original_position[2], modified_position[2])) + assert.is_true(base_position[2] < math.max(original_position[2], modified_position[2])) + assert.is_true(result_position[1] > base_position[1]) + + -- All three top panes show the same number of rows. + local base_rows = displayed_rows(session.base_bufnr) + assert.equals(base_rows, displayed_rows(session.original_bufnr)) + assert.equals(base_rows, displayed_rows(session.modified_bufnr)) + end) + + it("stacks Base above Result in the middle column in center mode", function() + local config = require("codediff.config") + config.options.diff.conflict_result_position = "center" + config.options.diff.conflict_show_base = true + local session = open_conflict_editor() + + assert.is_true(session.base_win ~= nil and vim.api.nvim_win_is_valid(session.base_win), "Base pane must open") + local base_position = vim.api.nvim_win_get_position(session.base_win) + local result_position = vim.api.nvim_win_get_position(session.result_win) + local original_position = vim.api.nvim_win_get_position(session.original_win) + assert.equals(result_position[2], base_position[2]) + assert.equals(original_position[1], base_position[1]) + assert.is_true(result_position[1] > base_position[1]) + end) + + it("toggles Base on and off and restores two-column alignment", function() + local session, tabpage = open_conflict_editor() + local base_view = require("codediff.ui.conflict.view.base") + local window_count = #vim.api.nvim_tabpage_list_wins(tabpage) + assert.equals(3, displayed_rows(session.original_bufnr)) + + base_view.toggle(tabpage) + assert.is_true(base_view.is_visible(session)) + assert.equals(window_count + 1, #vim.api.nvim_tabpage_list_wins(tabpage)) + assert.equals(5, displayed_rows(session.original_bufnr)) + assert.equals(5, displayed_rows(session.modified_bufnr)) + assert.equals(5, displayed_rows(session.base_bufnr)) + + base_view.toggle(tabpage) + assert.is_false(base_view.is_visible(session)) + assert.is_nil(session.base_win) + assert.equals(window_count, #vim.api.nvim_tabpage_list_wins(tabpage)) + assert.equals(3, displayed_rows(session.original_bufnr)) + assert.equals(3, displayed_rows(session.modified_bufnr)) + end) + + it("toggles Base with the configured key from an input pane and from Base itself", function() + local session = open_conflict_editor() + local base_view = require("codediff.ui.conflict.view.base") + + local function press_toggle(bufnr) + local lhs + for _, map in ipairs(vim.api.nvim_buf_get_keymap(bufnr, "n")) do + if map.desc == "Toggle merge base pane" then + lhs = map.lhs + end + end + assert.is_true(lhs ~= nil, "toggle_base must be mapped in buffer " .. bufnr) + vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(lhs, true, false, true), "x", false) + end + + vim.api.nvim_set_current_win(session.modified_win) + press_toggle(session.modified_bufnr) + assert.is_true(base_view.is_visible(session)) + assert.equals(session.modified_win, vim.api.nvim_get_current_win(), "toggling keeps focus") + + vim.api.nvim_set_current_win(session.base_win) + press_toggle(session.base_bufnr) + assert.is_false(base_view.is_visible(session)) + assert.equals(session.modified_win, vim.api.nvim_get_current_win(), "focus falls back to Current") + end) end) diff --git a/tests/unit/ui/conflict/merge_alignment_spec.lua b/tests/unit/ui/conflict/merge_alignment_spec.lua index f1ae2749..5aaed192 100644 --- a/tests/unit/ui/conflict/merge_alignment_spec.lua +++ b/tests/unit/ui/conflict/merge_alignment_spec.lua @@ -167,6 +167,74 @@ describe("Merge Alignment", function() end) end) +describe("Merge Alignment with a visible Base pane", function() + local include_base = true + + local function make_change(orig_start, orig_end, mod_start, mod_end) + return { + original = { start_line = orig_start, end_line = orig_end }, + modified = { start_line = mod_start, end_line = mod_end }, + inner_changes = {}, + } + end + + local function total(fillers) + local sum = 0 + for _, filler in ipairs(fillers or {}) do + sum = sum + filler.count + end + return sum + end + + local function displayed_rows(lines, fillers) + return #lines + total(fillers) + end + + it("omits base fillers unless requested", function() + local diff = { changes = { make_change(2, 5, 2, 3) } } + local fillers = merge_alignment.compute_merge_fillers_and_conflicts(diff, diff, { "a", "b", "c", "d", "e", "f" }, { "a", "X", "e", "f" }, { "a", "X", "e", "f" }) + assert.is_nil(fillers.base_fillers) + assert.equal(0, total(fillers.left_fillers)) + assert.equal(0, total(fillers.right_fillers)) + end) + + it("pads both inputs when Base is taller than either side", function() + local base_lines = { "a", "b", "c", "d", "e", "f" } + local left_lines = { "a", "X", "e", "f" } + local right_lines = { "a", "Y", "e", "f" } + local diff1 = { changes = { make_change(2, 5, 2, 3) } } + local diff2 = { changes = { make_change(2, 5, 2, 3) } } + + local fillers = merge_alignment.compute_merge_fillers_and_conflicts(diff1, diff2, base_lines, left_lines, right_lines, include_base) + + assert.equal(0, total(fillers.base_fillers)) + assert.equal(2, total(fillers.left_fillers)) + assert.equal(2, total(fillers.right_fillers)) + assert.equal(displayed_rows(base_lines, fillers.base_fillers), displayed_rows(left_lines, fillers.left_fillers)) + assert.equal(displayed_rows(base_lines, fillers.base_fillers), displayed_rows(right_lines, fillers.right_fillers)) + end) + + it("pads Base when the inputs grew", function() + local base_lines = { "a", "b", "c", "d" } + local left_lines = { "a", "L1", "L2", "L3", "c", "d" } + local right_lines = { "a", "R1", "R2", "c", "d" } + local diff1 = { changes = { make_change(2, 3, 2, 5) } } + local diff2 = { changes = { make_change(2, 3, 2, 4) } } + + local fillers = merge_alignment.compute_merge_fillers_and_conflicts(diff1, diff2, base_lines, left_lines, right_lines, include_base) + + assert.equal(2, total(fillers.base_fillers)) + assert.equal(0, total(fillers.left_fillers)) + assert.equal(1, total(fillers.right_fillers)) + assert.equal(6, displayed_rows(base_lines, fillers.base_fillers)) + assert.equal(6, displayed_rows(right_lines, fillers.right_fillers)) + for _, filler in ipairs(fillers.base_fillers) do + assert.is_number(filler.after_line) + assert.is_true(filler.count > 0) + end + end) +end) + describe("compute_auto_merged_result", function() local function make_diff(changes) return { changes = changes or {} }