290 lines
10 KiB
Lua
290 lines
10 KiB
Lua
local M = {}
|
|
|
|
local utils = require('cp.utils')
|
|
|
|
local function create_none_diff_layout(parent_win, expected_content, actual_content)
|
|
local expected_buf = utils.create_buffer_with_options()
|
|
local actual_buf = utils.create_buffer_with_options()
|
|
|
|
vim.api.nvim_set_current_win(parent_win)
|
|
vim.cmd.split()
|
|
vim.cmd('resize ' .. math.floor(vim.o.lines * 0.35))
|
|
local actual_win = vim.api.nvim_get_current_win()
|
|
vim.api.nvim_win_set_buf(actual_win, actual_buf)
|
|
|
|
vim.cmd.vsplit()
|
|
local expected_win = vim.api.nvim_get_current_win()
|
|
vim.api.nvim_win_set_buf(expected_win, expected_buf)
|
|
|
|
vim.api.nvim_set_option_value('filetype', 'cptest', { buf = expected_buf })
|
|
vim.api.nvim_set_option_value('filetype', 'cptest', { buf = actual_buf })
|
|
vim.api.nvim_set_option_value('winbar', 'Expected', { win = expected_win })
|
|
vim.api.nvim_set_option_value('winbar', 'Actual', { win = actual_win })
|
|
|
|
local expected_lines = vim.split(expected_content, '\n', { plain = true, trimempty = true })
|
|
local actual_lines = vim.split(actual_content, '\n', { plain = true })
|
|
|
|
utils.update_buffer_content(expected_buf, expected_lines, {})
|
|
utils.update_buffer_content(actual_buf, actual_lines, {})
|
|
|
|
return {
|
|
buffers = { expected_buf, actual_buf },
|
|
windows = { expected_win, actual_win },
|
|
cleanup = function()
|
|
pcall(vim.api.nvim_win_close, expected_win, true)
|
|
pcall(vim.api.nvim_win_close, actual_win, true)
|
|
pcall(vim.api.nvim_buf_delete, expected_buf, { force = true })
|
|
pcall(vim.api.nvim_buf_delete, actual_buf, { force = true })
|
|
end,
|
|
}
|
|
end
|
|
|
|
local function create_vim_diff_layout(parent_win, expected_content, actual_content)
|
|
local expected_buf = utils.create_buffer_with_options()
|
|
local actual_buf = utils.create_buffer_with_options()
|
|
|
|
vim.api.nvim_set_current_win(parent_win)
|
|
vim.cmd.split()
|
|
vim.cmd('resize ' .. math.floor(vim.o.lines * 0.35))
|
|
local actual_win = vim.api.nvim_get_current_win()
|
|
vim.api.nvim_win_set_buf(actual_win, actual_buf)
|
|
|
|
vim.cmd.vsplit()
|
|
local expected_win = vim.api.nvim_get_current_win()
|
|
vim.api.nvim_win_set_buf(expected_win, expected_buf)
|
|
|
|
vim.api.nvim_set_option_value('filetype', 'cptest', { buf = expected_buf })
|
|
vim.api.nvim_set_option_value('filetype', 'cptest', { buf = actual_buf })
|
|
vim.api.nvim_set_option_value('winbar', 'Expected', { win = expected_win })
|
|
vim.api.nvim_set_option_value('winbar', 'Actual', { win = actual_win })
|
|
|
|
local expected_lines = vim.split(expected_content, '\n', { plain = true, trimempty = true })
|
|
local actual_lines = vim.split(actual_content, '\n', { plain = true })
|
|
|
|
utils.update_buffer_content(expected_buf, expected_lines, {})
|
|
utils.update_buffer_content(actual_buf, actual_lines, {})
|
|
|
|
vim.api.nvim_set_option_value('diff', true, { win = expected_win })
|
|
vim.api.nvim_set_option_value('diff', true, { win = actual_win })
|
|
vim.api.nvim_win_call(expected_win, function()
|
|
vim.cmd.diffthis()
|
|
end)
|
|
vim.api.nvim_win_call(actual_win, function()
|
|
vim.cmd.diffthis()
|
|
end)
|
|
vim.api.nvim_set_option_value('foldcolumn', '0', { win = expected_win })
|
|
vim.api.nvim_set_option_value('foldcolumn', '0', { win = actual_win })
|
|
|
|
return {
|
|
buffers = { expected_buf, actual_buf },
|
|
windows = { expected_win, actual_win },
|
|
cleanup = function()
|
|
pcall(vim.api.nvim_win_close, expected_win, true)
|
|
pcall(vim.api.nvim_win_close, actual_win, true)
|
|
pcall(vim.api.nvim_buf_delete, expected_buf, { force = true })
|
|
pcall(vim.api.nvim_buf_delete, actual_buf, { force = true })
|
|
end,
|
|
}
|
|
end
|
|
|
|
local function create_git_diff_layout(parent_win, expected_content, actual_content)
|
|
local diff_buf = utils.create_buffer_with_options()
|
|
|
|
vim.api.nvim_set_current_win(parent_win)
|
|
vim.cmd.split()
|
|
vim.cmd('resize ' .. math.floor(vim.o.lines * 0.35))
|
|
local diff_win = vim.api.nvim_get_current_win()
|
|
vim.api.nvim_win_set_buf(diff_win, diff_buf)
|
|
|
|
vim.api.nvim_set_option_value('filetype', 'cptest', { buf = diff_buf })
|
|
vim.api.nvim_set_option_value('winbar', 'Expected vs Actual', { win = diff_win })
|
|
|
|
local diff_backend = require('cp.ui.diff')
|
|
local backend = diff_backend.get_best_backend('git')
|
|
local diff_result = backend.render(expected_content, actual_content)
|
|
local highlight = require('cp.ui.highlight')
|
|
local diff_namespace = highlight.create_namespace()
|
|
|
|
if diff_result.raw_diff and diff_result.raw_diff ~= '' then
|
|
highlight.parse_and_apply_diff(diff_buf, diff_result.raw_diff, diff_namespace)
|
|
else
|
|
local lines = vim.split(actual_content, '\n', { plain = true })
|
|
utils.update_buffer_content(diff_buf, lines, {})
|
|
end
|
|
|
|
return {
|
|
buffers = { diff_buf },
|
|
windows = { diff_win },
|
|
cleanup = function()
|
|
pcall(vim.api.nvim_win_close, diff_win, true)
|
|
pcall(vim.api.nvim_buf_delete, diff_buf, { force = true })
|
|
end,
|
|
}
|
|
end
|
|
|
|
local function create_single_layout(parent_win, content)
|
|
local buf = utils.create_buffer_with_options()
|
|
local lines = vim.split(content, '\n', { plain = true })
|
|
utils.update_buffer_content(buf, lines, {})
|
|
|
|
vim.api.nvim_set_current_win(parent_win)
|
|
vim.cmd.split()
|
|
vim.cmd('resize ' .. math.floor(vim.o.lines * 0.35))
|
|
local win = vim.api.nvim_get_current_win()
|
|
vim.api.nvim_win_set_buf(win, buf)
|
|
vim.api.nvim_set_option_value('filetype', 'cptest', { buf = buf })
|
|
|
|
return {
|
|
buffers = { buf },
|
|
windows = { win },
|
|
cleanup = function()
|
|
pcall(vim.api.nvim_win_close, win, true)
|
|
pcall(vim.api.nvim_buf_delete, buf, { force = true })
|
|
end,
|
|
}
|
|
end
|
|
|
|
function M.create_diff_layout(mode, parent_win, expected_content, actual_content)
|
|
if mode == 'single' then
|
|
return create_single_layout(parent_win, actual_content)
|
|
elseif mode == 'none' then
|
|
return create_none_diff_layout(parent_win, expected_content, actual_content)
|
|
elseif mode == 'git' then
|
|
return create_git_diff_layout(parent_win, expected_content, actual_content)
|
|
else
|
|
return create_vim_diff_layout(parent_win, expected_content, actual_content)
|
|
end
|
|
end
|
|
|
|
function M.update_diff_panes(
|
|
current_diff_layout,
|
|
current_mode,
|
|
main_win,
|
|
run,
|
|
config,
|
|
setup_keybindings_for_buffer
|
|
)
|
|
local test_state = run.get_run_panel_state()
|
|
local current_test = test_state.test_cases[test_state.current_index]
|
|
|
|
if not current_test then
|
|
return current_diff_layout, current_mode
|
|
end
|
|
|
|
local expected_content = current_test.expected or ''
|
|
local actual_content = current_test.actual or '(not run yet)'
|
|
local actual_highlights = current_test.actual_highlights or {}
|
|
local is_compilation_failure = current_test.error
|
|
and current_test.error:match('Compilation failed')
|
|
local should_show_diff = current_test.status == 'fail'
|
|
and current_test.actual
|
|
and not is_compilation_failure
|
|
|
|
if not should_show_diff then
|
|
expected_content = expected_content
|
|
actual_content = actual_content
|
|
end
|
|
|
|
local desired_mode = is_compilation_failure and 'single' or config.run_panel.diff_mode
|
|
local highlight = require('cp.ui.highlight')
|
|
local diff_namespace = highlight.create_namespace()
|
|
local ansi_namespace = vim.api.nvim_create_namespace('cp_ansi_highlights')
|
|
|
|
if current_diff_layout and current_mode ~= desired_mode then
|
|
local saved_pos = vim.api.nvim_win_get_cursor(0)
|
|
current_diff_layout.cleanup()
|
|
current_diff_layout = nil
|
|
current_mode = nil
|
|
|
|
current_diff_layout =
|
|
M.create_diff_layout(desired_mode, main_win, expected_content, actual_content)
|
|
current_mode = desired_mode
|
|
|
|
for _, buf in ipairs(current_diff_layout.buffers) do
|
|
setup_keybindings_for_buffer(buf)
|
|
end
|
|
|
|
pcall(vim.api.nvim_win_set_cursor, 0, saved_pos)
|
|
return current_diff_layout, current_mode
|
|
end
|
|
|
|
if not current_diff_layout then
|
|
current_diff_layout =
|
|
M.create_diff_layout(desired_mode, main_win, expected_content, actual_content)
|
|
current_mode = desired_mode
|
|
|
|
for _, buf in ipairs(current_diff_layout.buffers) do
|
|
setup_keybindings_for_buffer(buf)
|
|
end
|
|
else
|
|
if desired_mode == 'single' then
|
|
local lines = vim.split(actual_content, '\n', { plain = true })
|
|
utils.update_buffer_content(
|
|
current_diff_layout.buffers[1],
|
|
lines,
|
|
actual_highlights,
|
|
ansi_namespace
|
|
)
|
|
elseif desired_mode == 'git' then
|
|
local diff_backend = require('cp.ui.diff')
|
|
local backend = diff_backend.get_best_backend('git')
|
|
local diff_result = backend.render(expected_content, actual_content)
|
|
|
|
if diff_result.raw_diff and diff_result.raw_diff ~= '' then
|
|
highlight.parse_and_apply_diff(
|
|
current_diff_layout.buffers[1],
|
|
diff_result.raw_diff,
|
|
diff_namespace
|
|
)
|
|
else
|
|
local lines = vim.split(actual_content, '\n', { plain = true })
|
|
utils.update_buffer_content(
|
|
current_diff_layout.buffers[1],
|
|
lines,
|
|
actual_highlights,
|
|
ansi_namespace
|
|
)
|
|
end
|
|
elseif desired_mode == 'none' then
|
|
local expected_lines = vim.split(expected_content, '\n', { plain = true, trimempty = true })
|
|
local actual_lines = vim.split(actual_content, '\n', { plain = true })
|
|
utils.update_buffer_content(current_diff_layout.buffers[1], expected_lines, {})
|
|
utils.update_buffer_content(
|
|
current_diff_layout.buffers[2],
|
|
actual_lines,
|
|
actual_highlights,
|
|
ansi_namespace
|
|
)
|
|
else
|
|
local expected_lines = vim.split(expected_content, '\n', { plain = true, trimempty = true })
|
|
local actual_lines = vim.split(actual_content, '\n', { plain = true })
|
|
utils.update_buffer_content(current_diff_layout.buffers[1], expected_lines, {})
|
|
utils.update_buffer_content(
|
|
current_diff_layout.buffers[2],
|
|
actual_lines,
|
|
actual_highlights,
|
|
ansi_namespace
|
|
)
|
|
|
|
if should_show_diff then
|
|
vim.api.nvim_set_option_value('diff', true, { win = current_diff_layout.windows[1] })
|
|
vim.api.nvim_set_option_value('diff', true, { win = current_diff_layout.windows[2] })
|
|
vim.api.nvim_win_call(current_diff_layout.windows[1], function()
|
|
vim.cmd.diffthis()
|
|
end)
|
|
vim.api.nvim_win_call(current_diff_layout.windows[2], function()
|
|
vim.cmd.diffthis()
|
|
end)
|
|
vim.api.nvim_set_option_value('foldcolumn', '0', { win = current_diff_layout.windows[1] })
|
|
vim.api.nvim_set_option_value('foldcolumn', '0', { win = current_diff_layout.windows[2] })
|
|
else
|
|
vim.api.nvim_set_option_value('diff', false, { win = current_diff_layout.windows[1] })
|
|
vim.api.nvim_set_option_value('diff', false, { win = current_diff_layout.windows[2] })
|
|
end
|
|
end
|
|
end
|
|
|
|
return current_diff_layout, current_mode
|
|
end
|
|
|
|
return M
|