barrett/cp.nvim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 13

many fixes

Browse source
This commit is contained in:
Barrett Ruth 2025-10-02 22:35:30 -04:00
parent 1a4573a4e4
commit d9537e72ba
9 changed files with 396 additions and 482 deletions
Download patch file Download diff file Expand all files Collapse all files

5
lua/cp/cache.lua
View file

@ -15,11 +15,6 @@
---@field name string
---@field id string
---@class CacheData
---@field [string] table<string, ContestData>
---@field file_states? table<string, FileState>
---@field contest_lists? table<string, ContestSummary>
---@class Problem
---@field id string
---@field name? string

22
lua/cp/health.lua
View file

@ -10,6 +10,27 @@ local function check_nvim_version()
end
end
local function check_gnu_time()
local sysname = vim.loop.os_uname().sysname
if sysname == 'Windows_NT' then
vim.health.error('Windows is not supported for runs (GNU time is required).')
return
end
local cap = utils.time_capability()
if cap.ok then
vim.health.ok('GNU time found: ' .. cap.path)
return
end
vim.health.error('GNU time not found: ' .. (cap.reason or ''))
if sysname == 'Darwin' then
vim.health.info('Install via Homebrew: brew install coreutils (binary: gtime)')
else
vim.health.info('Install via your package manager, e.g., Debian/Ubuntu: sudo apt install time')
end
end
local function check_uv()
if vim.fn.executable('uv') == 1 then
vim.health.ok('uv executable found')
@ -55,6 +76,7 @@ function M.check()
check_uv()
check_python_env()
check_luasnip()
check_gnu_time()
end
return M

332
lua/cp/runner/execute.lua
View file

@ -2,42 +2,35 @@
---@field stdout string
---@field code integer
---@field time_ms number
---@field timed_out boolean
---@field tled boolean
---@field mled boolean
---@field peak_mb number
---@field signal string|nil
local M = {}
local logger = require('cp.log')
local constants = require('cp.constants')
local logger = require('cp.log')
local utils = require('cp.utils')
local filetype_to_language = constants.filetype_to_language
---@param source_file string
---@param contest_config table
---@return string
local function get_language_from_file(source_file, contest_config)
local extension = vim.fn.fnamemodify(source_file, ':e')
local language = filetype_to_language[extension] or contest_config.default_language
return language
local ext = vim.fn.fnamemodify(source_file, ':e')
return filetype_to_language[ext] or contest_config.default_language
end
---@param cmd_template string[]
---@param substitutions table<string, string>
---@return string[]
local function substitute_template(cmd_template, substitutions)
local result = {}
for _, arg in ipairs(cmd_template) do
local substituted = arg
for key, value in pairs(substitutions) do
substituted = substituted:gsub('{' .. key .. '}', value)
local out = {}
for _, a in ipairs(cmd_template) do
local s = a
for k, v in pairs(substitutions) do
s = s:gsub('{' .. k .. '}', v)
end
table.insert(result, substituted)
table.insert(out, s)
end
return result
return out
end
---@param cmd_template string[]
---@param executable? string
---@param substitutions table<string, string>
---@return string[]
local function build_command(cmd_template, executable, substitutions)
local cmd = substitute_template(cmd_template, substitutions)
if executable then
@ -46,245 +39,158 @@ local function build_command(cmd_template, executable, substitutions)
return cmd
end
---@param language_config table
---@param substitutions table<string, string>
---@return {code: integer, stdout: string}
function M.compile_generic(language_config, substitutions)
function M.compile(language_config, substitutions)
if not language_config.compile then
logger.log('No compilation step required for language - skipping.')
return { code = 0, stderr = '' }
return { code = 0, stdout = '' }
end
local compile_cmd = substitute_template(language_config.compile, substitutions)
local redirected_cmd = vim.deepcopy(compile_cmd)
if #redirected_cmd > 0 then
redirected_cmd[#redirected_cmd] = redirected_cmd[#redirected_cmd] .. ' 2>&1'
end
local cmd = substitute_template(language_config.compile, substitutions)
local sh = table.concat(cmd, ' ') .. ' 2>&1'
local start_time = vim.uv.hrtime()
local result = vim
.system({ 'sh', '-c', table.concat(redirected_cmd, ' ') }, { text = false })
:wait()
local compile_time = (vim.uv.hrtime() - start_time) / 1000000
local t0 = vim.uv.hrtime()
local r = vim.system({ 'sh', '-c', sh }, { text = false }):wait()
local dt = (vim.uv.hrtime() - t0) / 1e6
local ansi = require('cp.ui.ansi')
result.stdout = ansi.bytes_to_string(result.stdout or '')
r.stdout = ansi.bytes_to_string(r.stdout or '')
if result.code == 0 then
logger.log(('Compilation successful in %.1fms.'):format(compile_time), vim.log.levels.INFO)
if r.code == 0 then
logger.log(('Compilation successful in %.1fms.'):format(dt), vim.log.levels.INFO)
else
logger.log(('Compilation failed in %.1fms.'):format(compile_time))
logger.log(('Compilation failed in %.1fms.'):format(dt))
end
return result
return r
end
---@param cmd string[]
---@param input_data string
---@param timeout_ms number
---@return ExecuteResult
local function execute_command(cmd, input_data, timeout_ms)
local redirected_cmd = vim.deepcopy(cmd)
if #redirected_cmd > 0 then
redirected_cmd[#redirected_cmd] = redirected_cmd[#redirected_cmd] .. ' 2>&1'
local function parse_and_strip_time_v(output, memory_mb)
local lines = vim.split(output or '', '\n', { plain = true })
local timing_idx
for i = #lines, 1, -1 do
if lines[i]:match('^%s*Command being timed:') then
timing_idx = i
break
end
end
local start_time = vim.uv.hrtime()
local start_idx = timing_idx
local k = timing_idx - 1
while k >= 1 and lines[k]:match('^%s*Command ') do
start_idx = k
k = k - 1
end
local result = vim
.system({ 'sh', '-c', table.concat(redirected_cmd, ' ') }, {
stdin = input_data,
local peak_mb, mled = 0, false
for j = timing_idx, #lines do
local kb = lines[j]:match('Maximum resident set size %(kbytes%):%s*(%d+)')
if kb then
peak_mb = tonumber(kb) / 1024.0
if memory_mb and memory_mb > 0 and peak_mb > memory_mb then
mled = true
end
end
end
for j = #lines, start_idx, -1 do
table.remove(lines, j)
end
while #lines > 0 and lines[#lines]:match('^%s*$') do
table.remove(lines, #lines)
end
return table.concat(lines, '\n'), peak_mb, mled
end
function M.run(cmd, stdin, timeout_ms, memory_mb)
local prog = table.concat(cmd, ' ')
local pre = {}
if memory_mb and memory_mb > 0 then
table.insert(pre, ('ulimit -v %d'):format(memory_mb * 1024))
end
local prefix = (#pre > 0) and (table.concat(pre, '; ') .. '; ') or ''
local time_bin = utils.time_path()
local sh = prefix .. ('%s -v sh -c %q 2>&1'):format(time_bin, prog)
local t0 = vim.uv.hrtime()
local r = vim
.system({ 'sh', '-c', sh }, {
stdin = stdin,
timeout = timeout_ms,
text = true,
})
:wait()
local dt = (vim.uv.hrtime() - t0) / 1e6
local end_time = vim.uv.hrtime()
local execution_time = (end_time - start_time) / 1000000
local code = r.code or 0
local raw = r.stdout or ''
local cleaned, peak_mb, mled = parse_and_strip_time_v(raw, memory_mb)
local tled = (code == 124)
local actual_code = result.code or 0
local signal = nil
if code >= 128 then
signal = constants.signal_codes[code]
end
if result.code == 124 then
logger.log(('Execution timed out in %.1fms.'):format(execution_time), vim.log.levels.WARN)
elseif actual_code ~= 0 then
logger.log(
('Execution failed in %.1fms (exit code %d).'):format(execution_time, actual_code),
vim.log.levels.WARN
)
if tled then
logger.log(('Execution timed out in %.1fms.'):format(dt), vim.log.levels.WARN)
elseif mled then
logger.log(('Execution memory limit exceeded in %.1fms.'):format(dt))
elseif code ~= 0 then
logger.log(('Execution failed in %.1fms (exit code %d).'):format(dt, code))
else
logger.log(('Execution successful in %.1fms.'):format(execution_time))
logger.log(('Execution successful in %.1fms.'):format(dt))
end
return {
stdout = result.stdout or '',
code = actual_code,
time_ms = execution_time,
timed_out = result.code == 124,
stdout = cleaned,
code = code,
time_ms = dt,
tled = tled,
mled = mled,
peak_mb = peak_mb,
signal = signal,
}
end
---@param exec_result ExecuteResult
---@param expected_file string
---@param is_debug boolean
---@return string
local function format_output(exec_result, expected_file, is_debug)
local output_lines = { exec_result.stdout }
local metadata_lines = {}
if exec_result.timed_out then
table.insert(metadata_lines, '[code]: 124 (TIMEOUT)')
elseif exec_result.code >= 128 then
local signal_name = constants.signal_codes[exec_result.code] or 'SIGNAL'
table.insert(metadata_lines, ('[code]: %d (%s)'):format(exec_result.code, signal_name))
else
table.insert(metadata_lines, ('[code]: %d'):format(exec_result.code))
end
table.insert(metadata_lines, ('[time]: %.2f ms'):format(exec_result.time_ms))
table.insert(metadata_lines, ('[debug]: %s'):format(is_debug and 'true' or 'false'))
if vim.fn.filereadable(expected_file) == 1 and exec_result.code == 0 then
local expected_content = vim.fn.readfile(expected_file)
local actual_lines = vim.split(exec_result.stdout, '\n')
while #actual_lines > 0 and actual_lines[#actual_lines] == '' do
table.remove(actual_lines)
end
local ok = #actual_lines == #expected_content
if ok then
for i, line in ipairs(actual_lines) do
if line ~= expected_content[i] then
ok = false
break
end
end
end
table.insert(metadata_lines, ('[ok]: %s'):format(ok and 'true' or 'false'))
end
return table.concat(output_lines, '') .. '\n' .. table.concat(metadata_lines, '\n')
end
---@param contest_config ContestConfig
---@param is_debug? boolean
---@return {success: boolean, output: string?}
function M.compile_problem(contest_config, is_debug)
local state = require('cp.state')
local source_file = state.get_source_file()
if not source_file then
logger.log('No source file found.', vim.log.levels.ERROR)
return { success = false, output = 'No source file found.' }
end
local language = get_language_from_file(source_file, contest_config)
local language_config = contest_config[language]
if not language_config then
logger.log('No configuration for language: ' .. language, vim.log.levels.ERROR)
return { success = false, output = ('No configuration for language %s.'):format(language) }
end
local binary_file = state.get_binary_file()
local substitutions = {
source = source_file,
binary = binary_file,
}
local substitutions = { source = source_file, binary = binary_file }
local compile_cmd = (is_debug and language_config.debug) and language_config.debug
local chosen = (is_debug and language_config.debug) and language_config.debug
or language_config.compile
if compile_cmd then
language_config.compile = compile_cmd
local compile_result = M.compile_generic(language_config, substitutions)
if compile_result.code ~= 0 then
return { success = false, output = compile_result.stdout or 'unknown error' }
end
if not chosen then
return { success = true, output = nil }
end
local saved = language_config.compile
language_config.compile = chosen
local r = M.compile(language_config, substitutions)
language_config.compile = saved
if r.code ~= 0 then
return { success = false, output = r.stdout or 'unknown error' }
end
return { success = true, output = nil }
end
---@param contest_config ContestConfig
---@param is_debug boolean
function M.run_problem(contest_config, is_debug)
local state = require('cp.state')
local source_file = state.get_source_file()
local output_file = state.get_output_file()
if not source_file or not output_file then
logger.log(
('Missing required file paths %s and %s'):format(source_file, output_file),
vim.log.levels.ERROR
)
return
end
vim.system({ 'mkdir', '-p', 'build', 'io' }):wait()
local language = get_language_from_file(source_file, contest_config)
local language_config = contest_config[language]
if not language_config then
vim.fn.writefile({ 'Error: No configuration for language: ' .. language }, output_file)
return
end
local binary_file = state.get_binary_file()
local substitutions = {
source = source_file,
binary = binary_file,
}
local compile_cmd = is_debug and language_config.debug or language_config.compile
if compile_cmd then
local compile_result = M.compile_generic(language_config, substitutions)
if compile_result.code ~= 0 then
vim.fn.writefile({ compile_result.stdout }, output_file)
return
end
end
local input_file = state.get_input_file()
local input_data = ''
if input_file and vim.fn.filereadable(input_file) == 1 then
input_data = table.concat(vim.fn.readfile(input_file), '\n') .. '\n'
end
local cache = require('cp.cache')
cache.load()
local platform = state.get_platform()
local contest_id = state.get_contest_id()
local problem_id = state.get_problem_id()
local expected_file = state.get_expected_file()
if not platform or not contest_id or not expected_file then
logger.log('Configure a contest before running a problem', vim.log.levels.ERROR)
return
end
local timeout_ms, _ = cache.get_constraints(platform, contest_id, problem_id)
timeout_ms = timeout_ms or 2000
local run_cmd = build_command(language_config.test, language_config.executable, substitutions)
local exec_result = execute_command(run_cmd, input_data, timeout_ms)
local formatted_output = format_output(exec_result, expected_file, is_debug)
local output_buf = vim.fn.bufnr(output_file)
if output_buf ~= -1 then
local was_modifiable = vim.api.nvim_get_option_value('modifiable', { buf = output_buf })
local was_readonly = vim.api.nvim_get_option_value('readonly', { buf = output_buf })
vim.api.nvim_set_option_value('readonly', false, { buf = output_buf })
vim.api.nvim_set_option_value('modifiable', true, { buf = output_buf })
vim.api.nvim_buf_set_lines(output_buf, 0, -1, false, vim.split(formatted_output, '\n'))
vim.api.nvim_set_option_value('modifiable', was_modifiable, { buf = output_buf })
vim.api.nvim_set_option_value('readonly', was_readonly, { buf = output_buf })
vim.api.nvim_buf_call(output_buf, function()
vim.cmd.write()
end)
else
vim.fn.writefile(vim.split(formatted_output, '\n'), output_file)
end
end
M._util = {
get_language_from_file = get_language_from_file,
substitute_template = substitute_template,
build_command = build_command,
}
return M

313
lua/cp/runner/run.lua
View file

@ -2,7 +2,7 @@
---@field index number
---@field input string
---@field expected string
---@field status "pending"|"pass"|"fail"|"running"|"timeout"
---@field status "pending"|"pass"|"fail"|"running"|"tle"|"mle"
---@field actual string?
---@field actual_highlights? Highlight[]
---@field time_ms number?
@ -12,7 +12,8 @@
---@field code number?
---@field ok boolean?
---@field signal string?
---@field timed_out boolean?
---@field tled boolean?
---@field mled boolean?
---@class ProblemConstraints
---@field timeout_ms number
@ -42,221 +43,149 @@ local run_panel_state = {
constraints = nil,
}
---@param index number
---@param input string
---@param expected string
---@return RanTestCase
local function create_test_case(index, input, expected)
return {
index = index,
input = input,
expected = expected,
status = 'pending',
actual = nil,
time_ms = nil,
error = nil,
selected = true,
}
end
---@param platform string
---@param contest_id string
---@param problem_id string?
---@return RanTestCase[]
local function parse_test_cases_from_cache(platform, contest_id, problem_id)
local cache = require('cp.cache')
cache.load()
local cached_test_cases = cache.get_test_cases(platform, contest_id, problem_id) or {}
if vim.tbl_isempty(cached_test_cases) then
return {}
end
local test_cases = {}
for i, test_case in ipairs(cached_test_cases) do
local index = test_case.index or i
local expected = test_case.expected or test_case.output or ''
table.insert(test_cases, create_test_case(index, test_case.input, expected))
end
return test_cases
return cache.get_test_cases(platform, contest_id, problem_id) or {}
end
---@param platform string
---@param contest_id string
---@param problem_id string?
---@return ProblemConstraints?
local function load_constraints_from_cache(platform, contest_id, problem_id)
local cache = require('cp.cache')
cache.load()
local timeout_ms, memory_mb = cache.get_constraints(platform, contest_id, problem_id)
if timeout_ms and memory_mb then
return {
timeout_ms = timeout_ms,
memory_mb = memory_mb,
}
return { timeout_ms = timeout_ms, memory_mb = memory_mb }
end
return nil
end
---@param contest_config ContestConfig
---@param test_case RanTestCase
---@return table
local function create_sentinal_panel_data(test_cases)
local out = {}
for i, tc in ipairs(test_cases) do
out[i] = {
index = tc.index or i,
input = tc.input or '',
expected = tc.expected or '',
status = 'pending',
selected = false,
}
end
return out
end
local function build_command(language_config, substitutions)
local exec_util = require('cp.runner.execute')._util
return exec_util.build_command(language_config.test, language_config.executable, substitutions)
end
local function run_single_test_case(contest_config, cp_config, test_case)
local state = require('cp.state')
local exec = require('cp.runner.execute')
local source_file = state.get_source_file()
local language = vim.fn.fnamemodify(source_file or '', ':e')
local language_name = constants.filetype_to_language[language] or contest_config.default_language
local language_config = contest_config[language_name]
local function substitute_template(cmd_template, substitutions)
local result = {}
for _, arg in ipairs(cmd_template) do
local substituted = arg
for key, value in pairs(substitutions) do
substituted = substituted:gsub('{' .. key .. '}', value)
end
table.insert(result, substituted)
end
return result
end
local function build_command(cmd_template, executable, substitutions)
local cmd = substitute_template(cmd_template, substitutions)
if executable then
table.insert(cmd, 1, executable)
end
return cmd
end
local ext = vim.fn.fnamemodify(source_file or '', ':e')
local lang_name = constants.filetype_to_language[ext] or contest_config.default_language
local language_config = contest_config[lang_name]
local binary_file = state.get_binary_file()
local substitutions = {
source = source_file,
binary = binary_file,
}
local substitutions = { source = source_file, binary = binary_file }
if language_config.compile and binary_file and vim.fn.filereadable(binary_file) == 0 then
logger.log('Binary not found - compiling first.')
local compile_cmd = substitute_template(language_config.compile, substitutions)
local redirected_cmd = vim.deepcopy(compile_cmd)
redirected_cmd[#redirected_cmd] = redirected_cmd[#redirected_cmd] .. ' 2>&1'
local compile_result = vim
.system({ 'sh', '-c', table.concat(redirected_cmd, ' ') }, { text = false })
:wait()
local cr = exec.compile(language_config, substitutions)
local ansi = require('cp.ui.ansi')
compile_result.stdout = ansi.bytes_to_string(compile_result.stdout or '')
compile_result.stderr = ansi.bytes_to_string(compile_result.stderr or '')
if compile_result.code ~= 0 then
local clean = ansi.bytes_to_string(cr.stdout or '')
if cr.code ~= 0 then
return {
status = 'fail',
actual = '',
error = 'Compilation failed: ' .. (compile_result.stdout or 'Unknown error'),
stderr = compile_result.stdout or '',
actual = clean,
actual_highlights = {},
error = 'Compilation failed',
stderr = clean,
time_ms = 0,
code = compile_result.code,
code = cr.code,
ok = false,
signal = nil,
timed_out = false,
actual_highlights = {},
tled = false,
mled = false,
}
end
end
local run_cmd = build_command(language_config.test, language_config.executable, substitutions)
local cmd = build_command(language_config, substitutions)
local stdin_content = (test_case.input or '') .. '\n'
local timeout_ms = (run_panel_state.constraints and run_panel_state.constraints.timeout_ms)
or 2000
local memory_mb = run_panel_state.constraints and run_panel_state.constraints.memory_mb or nil
local stdin_content = test_case.input .. '\n'
local start_time = vim.uv.hrtime()
local timeout_ms = run_panel_state.constraints and run_panel_state.constraints.timeout_ms or 2000
local redirected_run_cmd = vim.deepcopy(run_cmd)
redirected_run_cmd[#redirected_run_cmd] = redirected_run_cmd[#redirected_run_cmd] .. ' 2>&1'
local result = vim
.system({ 'sh', '-c', table.concat(redirected_run_cmd, ' ') }, {
stdin = stdin_content,
timeout = timeout_ms,
text = false,
})
:wait()
local execution_time = (vim.uv.hrtime() - start_time) / 1000000
local r = exec.run(cmd, stdin_content, timeout_ms, memory_mb)
local ansi = require('cp.ui.ansi')
local stdout_str = ansi.bytes_to_string(result.stdout or '')
local actual_output = stdout_str:gsub('\n$', '')
local out = (r.stdout or ''):gsub('\n$', '')
local actual_highlights = {}
if actual_output ~= '' then
local highlights = {}
if out ~= '' then
if cp_config.run_panel.ansi then
local parsed = ansi.parse_ansi_text(actual_output)
actual_output = table.concat(parsed.lines, '\n')
actual_highlights = parsed.highlights
local parsed = ansi.parse_ansi_text(out)
out = table.concat(parsed.lines, '\n')
highlights = parsed.highlights
else
actual_output = actual_output:gsub('\027%[[%d;]*[a-zA-Z]', '')
out = out:gsub('\027%[[%d;]*[a-zA-Z]', '')
end
end
local max_lines = cp_config.run_panel.max_output_lines
local output_lines = vim.split(actual_output, '\n')
if #output_lines > max_lines then
local trimmed_lines = {}
local lines = vim.split(out, '\n')
if #lines > max_lines then
local trimmed = {}
for i = 1, max_lines do
table.insert(trimmed_lines, output_lines[i])
table.insert(trimmed, lines[i])
end
table.insert(trimmed_lines, string.format('... (output trimmed after %d lines)', max_lines))
actual_output = table.concat(trimmed_lines, '\n')
table.insert(trimmed, string.format('... (output trimmed after %d lines)', max_lines))
out = table.concat(trimmed, '\n')
end
local expected_output = test_case.expected:gsub('\n$', '')
local ok = actual_output == expected_output
local expected = (test_case.expected or ''):gsub('\n$', '')
local ok = out == expected
local signal = r.signal
if not signal and r.code and r.code >= 128 then
signal = constants.signal_codes[r.code]
end
local status
local timed_out = result.code == 143 or result.code == 124
if timed_out then
status = 'timeout'
elseif result.code == 0 and ok then
if r.tled then
status = 'tle'
elseif r.mled then
status = 'mle'
elseif ok then
status = 'pass'
else
status = 'fail'
end
local signal = nil
if result.code >= 128 then
signal = constants.signal_codes[result.code]
end
return {
status = status,
actual = actual_output,
actual_highlights = actual_highlights,
error = result.code ~= 0 and actual_output or nil,
actual = out,
actual_highlights = highlights,
error = (r.code ~= 0 and not ok) and out or nil,
stderr = '',
time_ms = execution_time,
code = result.code,
time_ms = r.time_ms,
code = r.code,
ok = ok,
signal = signal,
timed_out = timed_out,
tled = r.tled or false,
mled = r.mled or false,
}
end
---@param state table
---@return boolean
function M.load_test_cases(state)
local test_cases = parse_test_cases_from_cache(
local tcs = parse_test_cases_from_cache(
state.get_platform() or '',
state.get_contest_id() or '',
state.get_problem_id()
) or {}
)
-- TODO: re-fetch/cache-populating mechanism to ge the test cases if not in the cache
run_panel_state.test_cases = test_cases
run_panel_state.test_cases = create_sentinal_panel_data(tcs)
run_panel_state.current_index = 1
run_panel_state.constraints = load_constraints_from_cache(
state.get_platform() or '',
@ -264,50 +193,43 @@ function M.load_test_cases(state)
state.get_problem_id()
)
logger.log(('Loaded %d test case(s)'):format(#test_cases), vim.log.levels.INFO)
return #test_cases > 0
logger.log(('Loaded %d test case(s)'):format(#tcs), vim.log.levels.INFO)
return #tcs > 0
end
---@param contest_config ContestConfig
---@param index number
---@return boolean
function M.run_test_case(contest_config, cp_config, index)
local test_case = run_panel_state.test_cases[index]
if not test_case then
local tc = run_panel_state.test_cases[index]
if not tc then
return false
end
test_case.status = 'running'
tc.status = 'running'
local r = run_single_test_case(contest_config, cp_config, tc)
local result = run_single_test_case(contest_config, cp_config, test_case)
test_case.status = result.status
test_case.actual = result.actual
test_case.actual_highlights = result.actual_highlights
test_case.error = result.error
test_case.stderr = result.stderr
test_case.time_ms = result.time_ms
test_case.code = result.code
test_case.ok = result.ok
test_case.signal = result.signal
test_case.timed_out = result.timed_out
tc.status = r.status
tc.actual = r.actual
tc.actual_highlights = r.actual_highlights
tc.error = r.error
tc.stderr = r.stderr
tc.time_ms = r.time_ms
tc.code = r.code
tc.ok = r.ok
tc.signal = r.signal
tc.tled = r.tled
tc.mled = r.mled
return true
end
---@param contest_config ContestConfig
---@param cp_config cp.Config
---@return RanTestCase[]
function M.run_all_test_cases(contest_config, cp_config)
local results = {}
for i, _ in ipairs(run_panel_state.test_cases) do
for i = 1, #run_panel_state.test_cases do
M.run_test_case(contest_config, cp_config, i)
table.insert(results, run_panel_state.test_cases[i])
results[i] = run_panel_state.test_cases[i]
end
return results
end
---@return RunPanelState
function M.get_run_panel_state()
return run_panel_state
end
@ -316,28 +238,29 @@ function M.handle_compilation_failure(compilation_output)
local ansi = require('cp.ui.ansi')
local config = require('cp.config').setup()
local clean_text
local highlights = {}
local txt
local hl = {}
if config.run_panel.ansi then
local parsed = ansi.parse_ansi_text(compilation_output or '')
clean_text = table.concat(parsed.lines, '\n')
highlights = parsed.highlights
local p = ansi.parse_ansi_text(compilation_output or '')
txt = table.concat(p.lines, '\n')
hl = p.highlights
else
clean_text = (compilation_output or ''):gsub('\027%[[%d;]*[a-zA-Z]', '')
txt = (compilation_output or ''):gsub('\027%[[%d;]*[a-zA-Z]', '')
end
for _, test_case in ipairs(run_panel_state.test_cases) do
test_case.status = 'fail'
test_case.actual = clean_text
test_case.actual_highlights = highlights
test_case.error = 'Compilation failed'
test_case.stderr = ''
test_case.time_ms = 0
test_case.code = 1
test_case.ok = false
test_case.signal = nil
test_case.timed_out = false
for _, tc in ipairs(run_panel_state.test_cases) do
tc.status = 'fail'
tc.actual = txt
tc.actual_highlights = hl
tc.error = 'Compilation failed'
tc.stderr = ''
tc.time_ms = 0
tc.code = 1
tc.ok = false
tc.signal = nil
tc.tled = false
tc.mled = false
end
end

27
lua/cp/runner/run_render.lua
View file

@ -26,22 +26,22 @@ local exit_code_names = {
---@param ran_test_case RanTestCase
---@return StatusInfo
function M.get_status_info(ran_test_case)
if ran_test_case.status == 'pass' then
if ran_test_case.ok then
return { text = 'AC', highlight_group = 'CpTestAC' }
elseif ran_test_case.status == 'fail' then
if ran_test_case.timed_out then
return { text = 'TLE', highlight_group = 'CpTestTLE' }
elseif ran_test_case.code and ran_test_case.code >= 128 then
return { text = 'RTE', highlight_group = 'CpTestRTE' }
else
return { text = 'WA', highlight_group = 'CpTestWA' }
end
elseif ran_test_case.status == 'timeout' then
return { text = 'TLE', highlight_group = 'CpTestTLE' }
elseif ran_test_case.status == 'running' then
end
if ran_test_case.actual == '' then
return { text = '...', highlight_group = 'CpTestPending' }
end
if ran_test_case.tled then
return { text = 'TLE', highlight_group = 'CpTestTLE' }
elseif ran_test_case.mled then
return { text = 'MLE', highlight_group = 'CpTestMLE' }
elseif ran_test_case.code and ran_test_case.code >= 128 then
return { text = 'RTE', highlight_group = 'CpTestRTE' }
else
return { text = '', highlight_group = 'CpTestPending' }
return { text = 'WA', highlight_group = 'CpTestWA' }
end
end
@ -354,6 +354,7 @@ function M.get_highlight_groups()
CpTestAC = { fg = '#10b981' },
CpTestWA = { fg = '#ef4444' },
CpTestTLE = { fg = '#f59e0b' },
CpTestMLE = { fg = '#f59e0b' },
CpTestRTE = { fg = '#8b5cf6' },
CpTestPending = { fg = '#6b7280' },
CpDiffRemoved = { fg = '#ef4444', bg = '#1f1f1f' },

38
lua/cp/ui/layouts.lua
View file

@ -1,10 +1,10 @@
local M = {}
local buffer_utils = require('cp.utils.buffer')
local utils = require('cp.utils')
local function create_none_diff_layout(parent_win, expected_content, actual_content)
local expected_buf = buffer_utils.create_buffer_with_options()
local actual_buf = buffer_utils.create_buffer_with_options()
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()
@ -24,8 +24,8 @@ local function create_none_diff_layout(parent_win, expected_content, actual_cont
local expected_lines = vim.split(expected_content, '\n', { plain = true, trimempty = true })
local actual_lines = vim.split(actual_content, '\n', { plain = true, trimempty = true })
buffer_utils.update_buffer_content(expected_buf, expected_lines, {})
buffer_utils.update_buffer_content(actual_buf, actual_lines, {})
utils.update_buffer_content(expected_buf, expected_lines, {})
utils.update_buffer_content(actual_buf, actual_lines, {})
return {
buffers = { expected_buf, actual_buf },
@ -40,8 +40,8 @@ local function create_none_diff_layout(parent_win, expected_content, actual_cont
end
local function create_vim_diff_layout(parent_win, expected_content, actual_content)
local expected_buf = buffer_utils.create_buffer_with_options()
local actual_buf = buffer_utils.create_buffer_with_options()
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()
@ -61,8 +61,8 @@ local function create_vim_diff_layout(parent_win, expected_content, actual_conte
local expected_lines = vim.split(expected_content, '\n', { plain = true, trimempty = true })
local actual_lines = vim.split(actual_content, '\n', { plain = true, trimempty = true })
buffer_utils.update_buffer_content(expected_buf, expected_lines, {})
buffer_utils.update_buffer_content(actual_buf, actual_lines, {})
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 })
@ -88,7 +88,7 @@ local function create_vim_diff_layout(parent_win, expected_content, actual_conte
end
local function create_git_diff_layout(parent_win, expected_content, actual_content)
local diff_buf = buffer_utils.create_buffer_with_options()
local diff_buf = utils.create_buffer_with_options()
vim.api.nvim_set_current_win(parent_win)
vim.cmd.split()
@ -109,7 +109,7 @@ local function create_git_diff_layout(parent_win, expected_content, actual_conte
highlight.parse_and_apply_diff(diff_buf, diff_result.raw_diff, diff_namespace)
else
local lines = vim.split(actual_content, '\n', { plain = true, trimempty = true })
buffer_utils.update_buffer_content(diff_buf, lines, {})
utils.update_buffer_content(diff_buf, lines, {})
end
return {
@ -123,9 +123,9 @@ local function create_git_diff_layout(parent_win, expected_content, actual_conte
end
local function create_single_layout(parent_win, content)
local buf = buffer_utils.create_buffer_with_options()
local buf = utils.create_buffer_with_options()
local lines = vim.split(content, '\n', { plain = true, trimempty = true })
buffer_utils.update_buffer_content(buf, lines, {})
utils.update_buffer_content(buf, lines, {})
vim.api.nvim_set_current_win(parent_win)
vim.cmd.split()
@ -219,7 +219,7 @@ function M.update_diff_panes(
else
if desired_mode == 'single' then
local lines = vim.split(actual_content, '\n', { plain = true, trimempty = true })
buffer_utils.update_buffer_content(
utils.update_buffer_content(
current_diff_layout.buffers[1],
lines,
actual_highlights,
@ -238,7 +238,7 @@ function M.update_diff_panes(
)
else
local lines = vim.split(actual_content, '\n', { plain = true, trimempty = true })
buffer_utils.update_buffer_content(
utils.update_buffer_content(
current_diff_layout.buffers[1],
lines,
actual_highlights,
@ -248,8 +248,8 @@ function M.update_diff_panes(
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, trimempty = true })
buffer_utils.update_buffer_content(current_diff_layout.buffers[1], expected_lines, {})
buffer_utils.update_buffer_content(
utils.update_buffer_content(current_diff_layout.buffers[1], expected_lines, {})
utils.update_buffer_content(
current_diff_layout.buffers[2],
actual_lines,
actual_highlights,
@ -258,8 +258,8 @@ function M.update_diff_panes(
else
local expected_lines = vim.split(expected_content, '\n', { plain = true, trimempty = true })
local actual_lines = vim.split(actual_content, '\n', { plain = true, trimempty = true })
buffer_utils.update_buffer_content(current_diff_layout.buffers[1], expected_lines, {})
buffer_utils.update_buffer_content(
utils.update_buffer_content(current_diff_layout.buffers[1], expected_lines, {})
utils.update_buffer_content(
current_diff_layout.buffers[2],
actual_lines,
actual_highlights,

6
lua/cp/ui/panel.lua
View file

@ -1,10 +1,10 @@
local M = {}
local buffer_utils = require('cp.utils.buffer')
local config_module = require('cp.config')
local layouts = require('cp.ui.layouts')
local logger = require('cp.log')
local state = require('cp.state')
local utils = require('cp.utils')
local current_diff_layout = nil
local current_mode = nil
@ -194,7 +194,7 @@ function M.toggle_run_panel(is_debug)
vim.cmd(('mksession! %s'):format(state.saved_session))
vim.cmd('silent only')
local tab_buf = buffer_utils.create_buffer_with_options()
local tab_buf = utils.create_buffer_with_options()
local main_win = vim.api.nvim_get_current_win()
vim.api.nvim_win_set_buf(main_win, tab_buf)
vim.api.nvim_set_option_value('filetype', 'cptest', { buf = tab_buf })
@ -224,7 +224,7 @@ function M.toggle_run_panel(is_debug)
run_render.setup_highlights()
local test_state = run.get_run_panel_state()
local tab_lines, tab_highlights = run_render.render_test_list(test_state)
buffer_utils.update_buffer_content(
utils.update_buffer_content(
test_buffers.tab_buf,
tab_lines,
tab_highlights,

104
lua/cp/utils.lua
View file

@ -2,6 +2,76 @@ local M = {}
local logger = require('cp.log')
local uname = vim.loop.os_uname()
local _time_cached = false
local _time_path = nil
local _time_reason = nil
local function is_windows()
return uname and uname.sysname == 'Windows_NT'
end
local function check_time_is_gnu_time(bin)
local ok = vim.fn.executable(bin) == 1
if not ok then
return false
end
local r = vim.system({ bin, '--version' }, { text = true }):wait()
if r and r.code == 0 and r.stdout and r.stdout:lower():find('gnu time', 1, true) then
return true
end
return false
end
local function find_gnu_time()
if _time_cached then
return _time_path, _time_reason
end
if is_windows() then
_time_cached = true
_time_path = nil
_time_reason = 'unsupported on Windows'
return _time_path, _time_reason
end
local candidates
if uname and uname.sysname == 'Darwin' then
candidates = { 'gtime', '/opt/homebrew/bin/gtime', '/usr/local/bin/gtime' }
else
candidates = { '/usr/bin/time', 'time' }
end
for _, bin in ipairs(candidates) do
if check_time_is_gnu_time(bin) then
_time_cached = true
_time_path = bin
_time_reason = nil
return _time_path, _time_reason
end
end
_time_cached = true
_time_path = nil
_time_reason = 'GNU time not found (install `time` on Linux or `brew install coreutils` on macOS)'
return _time_path, _time_reason
end
--- Return the validated GNU time binary path
--- Fails closed: returns nil if GNU time is unavailable.
---@return string|nil path
function M.time_path()
local path = find_gnu_time()
return path
end
---@return {ok:boolean, path:string|nil, reason:string|nil}
function M.time_capability()
local path, reason = find_gnu_time()
return { ok = path ~= nil, path = path, reason = reason }
end
---@return string
function M.get_plugin_path()
local plugin_path = debug.getinfo(1, 'S').source:sub(2)
@ -28,17 +98,45 @@ function M.setup_python_env()
end
if vim.fn.isdirectory(venv_dir) == 0 then
logger.log('setting up Python environment for scrapers...')
logger.log('Setting up Python environment for scrapers...')
local result = vim.system({ 'uv', 'sync' }, { cwd = plugin_path, text = true }):wait()
if result.code ~= 0 then
logger.log('failed to setup Python environment: ' .. result.stderr, vim.log.levels.ERROR)
logger.log('Failed to setup Python environment: ' .. result.stderr, vim.log.levels.ERROR)
return false
end
logger.log('Python environment setup complete')
logger.log('Python environment setup complete.')
end
python_env_setup = true
return true
end
--- Configure the buffer with good defaults
---@param filetype? string
function M.create_buffer_with_options(filetype)
local buf = vim.api.nvim_create_buf(false, true)
vim.api.nvim_set_option_value('bufhidden', 'wipe', { buf = buf })
vim.api.nvim_set_option_value('readonly', true, { buf = buf })
vim.api.nvim_set_option_value('modifiable', false, { buf = buf })
if filetype then
vim.api.nvim_set_option_value('filetype', filetype, { buf = buf })
end
return buf
end
function M.update_buffer_content(bufnr, lines, highlights, namespace)
local was_readonly = vim.api.nvim_get_option_value('readonly', { buf = bufnr })
vim.api.nvim_set_option_value('readonly', false, { buf = bufnr })
vim.api.nvim_set_option_value('modifiable', true, { buf = bufnr })
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
vim.api.nvim_set_option_value('modifiable', false, { buf = bufnr })
vim.api.nvim_set_option_value('readonly', was_readonly, { buf = bufnr })
if highlights and namespace then
local highlight = require('cp.ui.highlight')
highlight.apply_highlights(bufnr, highlights, namespace)
end
end
return M

31
lua/cp/utils/buffer.lua
View file

@ -1,31 +0,0 @@
local M = {}
--- Configure the buffer with good defaults
---@param filetype? string
function M.create_buffer_with_options(filetype)
local buf = vim.api.nvim_create_buf(false, true)
vim.api.nvim_set_option_value('bufhidden', 'wipe', { buf = buf })
vim.api.nvim_set_option_value('readonly', true, { buf = buf })
vim.api.nvim_set_option_value('modifiable', false, { buf = buf })
if filetype then
vim.api.nvim_set_option_value('filetype', filetype, { buf = buf })
end
return buf
end
function M.update_buffer_content(bufnr, lines, highlights, namespace)
local was_readonly = vim.api.nvim_get_option_value('readonly', { buf = bufnr })
vim.api.nvim_set_option_value('readonly', false, { buf = bufnr })
vim.api.nvim_set_option_value('modifiable', true, { buf = bufnr })
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
vim.api.nvim_set_option_value('modifiable', false, { buf = bufnr })
vim.api.nvim_set_option_value('readonly', was_readonly, { buf = bufnr })
if highlights and namespace then
local highlight = require('cp.ui.highlight')
highlight.apply_highlights(bufnr, highlights, namespace)
end
end
return M