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

fix: revert stylua config

Browse source
This commit is contained in:
Barrett Ruth 2025-09-15 18:10:35 -04:00
parent fe4cf2b680
commit d4fd02499d
19 changed files with 1363 additions and 1579 deletions
Download patch file Download diff file Expand all files Collapse all files

204
lua/cp/cache.lua
View file

@ -18,129 +18,129 @@
local M = {}
local cache_file = vim.fn.stdpath('data') .. '/cp-nvim.json'
local cache_file = vim.fn.stdpath("data") .. "/cp-nvim.json"
local cache_data = {}
---@param platform string
---@return number?
local function get_expiry_date(platform)
vim.validate({
platform = { platform, 'string' },
})
vim.validate({
platform = { platform, "string" },
})
if platform == 'cses' then
return os.time() + (30 * 24 * 60 * 60)
end
return nil
if platform == "cses" then
return os.time() + (30 * 24 * 60 * 60)
end
return nil
end
---@param contest_data ContestData
---@param platform string
---@return boolean
local function is_cache_valid(contest_data, platform)
vim.validate({
contest_data = { contest_data, 'table' },
platform = { platform, 'string' },
})
vim.validate({
contest_data = { contest_data, "table" },
platform = { platform, "string" },
})
if platform ~= 'cses' then
return true
end
if platform ~= "cses" then
return true
end
local expires_at = contest_data.expires_at
if not expires_at then
return false
end
local expires_at = contest_data.expires_at
if not expires_at then
return false
end
return os.time() < expires_at
return os.time() < expires_at
end
function M.load()
if vim.fn.filereadable(cache_file) == 0 then
cache_data = {}
return
end
if vim.fn.filereadable(cache_file) == 0 then
cache_data = {}
return
end
local content = vim.fn.readfile(cache_file)
if #content == 0 then
cache_data = {}
return
end
local content = vim.fn.readfile(cache_file)
if #content == 0 then
cache_data = {}
return
end
local ok, decoded = pcall(vim.json.decode, table.concat(content, '\n'))
if ok then
cache_data = decoded
else
cache_data = {}
end
local ok, decoded = pcall(vim.json.decode, table.concat(content, "\n"))
if ok then
cache_data = decoded
else
cache_data = {}
end
end
function M.save()
vim.fn.mkdir(vim.fn.fnamemodify(cache_file, ':h'), 'p')
local encoded = vim.json.encode(cache_data)
vim.fn.writefile(vim.split(encoded, '\n'), cache_file)
vim.fn.mkdir(vim.fn.fnamemodify(cache_file, ":h"), "p")
local encoded = vim.json.encode(cache_data)
vim.fn.writefile(vim.split(encoded, "\n"), cache_file)
end
---@param platform string
---@param contest_id string
---@return ContestData?
function M.get_contest_data(platform, contest_id)
vim.validate({
platform = { platform, 'string' },
contest_id = { contest_id, 'string' },
})
vim.validate({
platform = { platform, "string" },
contest_id = { contest_id, "string" },
})
if not cache_data[platform] then
return nil
end
if not cache_data[platform] then
return nil
end
local contest_data = cache_data[platform][contest_id]
if not contest_data then
return nil
end
local contest_data = cache_data[platform][contest_id]
if not contest_data then
return nil
end
if not is_cache_valid(contest_data, platform) then
return nil
end
if not is_cache_valid(contest_data, platform) then
return nil
end
return contest_data
return contest_data
end
---@param platform string
---@param contest_id string
---@param problems Problem[]
function M.set_contest_data(platform, contest_id, problems)
vim.validate({
platform = { platform, 'string' },
contest_id = { contest_id, 'string' },
problems = { problems, 'table' },
})
vim.validate({
platform = { platform, "string" },
contest_id = { contest_id, "string" },
problems = { problems, "table" },
})
if not cache_data[platform] then
cache_data[platform] = {}
end
if not cache_data[platform] then
cache_data[platform] = {}
end
cache_data[platform][contest_id] = {
problems = problems,
scraped_at = os.date('%Y-%m-%d'),
expires_at = get_expiry_date(platform),
}
cache_data[platform][contest_id] = {
problems = problems,
scraped_at = os.date("%Y-%m-%d"),
expires_at = get_expiry_date(platform),
}
M.save()
M.save()
end
---@param platform string
---@param contest_id string
function M.clear_contest_data(platform, contest_id)
vim.validate({
platform = { platform, 'string' },
contest_id = { contest_id, 'string' },
})
vim.validate({
platform = { platform, "string" },
contest_id = { contest_id, "string" },
})
if cache_data[platform] and cache_data[platform][contest_id] then
cache_data[platform][contest_id] = nil
M.save()
end
if cache_data[platform] and cache_data[platform][contest_id] then
cache_data[platform][contest_id] = nil
M.save()
end
end
---@param platform string
@ -148,18 +148,17 @@ end
---@param problem_id? string
---@return TestCase[]?
function M.get_test_cases(platform, contest_id, problem_id)
vim.validate({
platform = { platform, 'string' },
contest_id = { contest_id, 'string' },
problem_id = { problem_id, { 'string', 'nil' }, true },
})
vim.validate({
platform = { platform, "string" },
contest_id = { contest_id, "string" },
problem_id = { problem_id, { "string", "nil" }, true },
})
local problem_key = problem_id and (contest_id .. '_' .. problem_id)
or contest_id
if not cache_data[platform] or not cache_data[platform][problem_key] then
return nil
end
return cache_data[platform][problem_key].test_cases
local problem_key = problem_id and (contest_id .. "_" .. problem_id) or contest_id
if not cache_data[platform] or not cache_data[platform][problem_key] then
return nil
end
return cache_data[platform][problem_key].test_cases
end
---@param platform string
@ -167,25 +166,24 @@ end
---@param problem_id? string
---@param test_cases TestCase[]
function M.set_test_cases(platform, contest_id, problem_id, test_cases)
vim.validate({
platform = { platform, 'string' },
contest_id = { contest_id, 'string' },
problem_id = { problem_id, { 'string', 'nil' }, true },
test_cases = { test_cases, 'table' },
})
vim.validate({
platform = { platform, "string" },
contest_id = { contest_id, "string" },
problem_id = { problem_id, { "string", "nil" }, true },
test_cases = { test_cases, "table" },
})
local problem_key = problem_id and (contest_id .. '_' .. problem_id)
or contest_id
if not cache_data[platform] then
cache_data[platform] = {}
end
if not cache_data[platform][problem_key] then
cache_data[platform][problem_key] = {}
end
local problem_key = problem_id and (contest_id .. "_" .. problem_id) or contest_id
if not cache_data[platform] then
cache_data[platform] = {}
end
if not cache_data[platform][problem_key] then
cache_data[platform][problem_key] = {}
end
cache_data[platform][problem_key].test_cases = test_cases
cache_data[platform][problem_key].test_cases_cached_at = os.time()
M.save()
cache_data[platform][problem_key].test_cases = test_cases
cache_data[platform][problem_key].test_cases_cached_at = os.time()
M.save()
end
return M

158
lua/cp/config.lua
View file

@ -48,109 +48,99 @@
---@field filename? fun(contest: string, contest_id: string, problem_id?: string, config: cp.Config, language?: string): string
local M = {}
local constants = require('cp.constants')
local constants = require("cp.constants")
---@type cp.Config
M.defaults = {
contests = {},
snippets = {},
hooks = {
before_run = nil,
before_debug = nil,
setup_code = nil,
},
debug = false,
tile = nil,
filename = nil,
contests = {},
snippets = {},
hooks = {
before_run = nil,
before_debug = nil,
setup_code = nil,
},
debug = false,
tile = nil,
filename = nil,
}
---@param user_config cp.UserConfig|nil
---@return cp.Config
function M.setup(user_config)
vim.validate({
user_config = { user_config, { 'table', 'nil' }, true },
})
vim.validate({
user_config = { user_config, { "table", "nil" }, true },
})
if user_config then
vim.validate({
contests = { user_config.contests, { 'table', 'nil' }, true },
snippets = { user_config.snippets, { 'table', 'nil' }, true },
hooks = { user_config.hooks, { 'table', 'nil' }, true },
debug = { user_config.debug, { 'boolean', 'nil' }, true },
tile = { user_config.tile, { 'function', 'nil' }, true },
filename = { user_config.filename, { 'function', 'nil' }, true },
})
if user_config then
vim.validate({
contests = { user_config.contests, { "table", "nil" }, true },
snippets = { user_config.snippets, { "table", "nil" }, true },
hooks = { user_config.hooks, { "table", "nil" }, true },
debug = { user_config.debug, { "boolean", "nil" }, true },
tile = { user_config.tile, { "function", "nil" }, true },
filename = { user_config.filename, { "function", "nil" }, true },
})
if user_config.hooks then
vim.validate({
before_run = {
user_config.hooks.before_run,
{ 'function', 'nil' },
true,
},
before_debug = {
user_config.hooks.before_debug,
{ 'function', 'nil' },
true,
},
setup_code = {
user_config.hooks.setup_code,
{ 'function', 'nil' },
true,
},
})
end
if user_config.hooks then
vim.validate({
before_run = {
user_config.hooks.before_run,
{ "function", "nil" },
true,
},
before_debug = {
user_config.hooks.before_debug,
{ "function", "nil" },
true,
},
setup_code = {
user_config.hooks.setup_code,
{ "function", "nil" },
true,
},
})
end
if user_config.contests then
for contest_name, contest_config in pairs(user_config.contests) do
for lang_name, lang_config in pairs(contest_config) do
if
type(lang_config) == 'table' and lang_config.extension
then
if
not vim.tbl_contains(
vim.tbl_keys(constants.filetype_to_language),
lang_config.extension
)
then
error(
("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format(
lang_config.extension,
lang_name,
contest_name,
table.concat(
vim.tbl_keys(
constants.filetype_to_language
),
', '
)
)
)
end
end
end
end
end
end
if user_config.contests then
for contest_name, contest_config in pairs(user_config.contests) do
for lang_name, lang_config in pairs(contest_config) do
if type(lang_config) == "table" and lang_config.extension then
if
not vim.tbl_contains(vim.tbl_keys(constants.filetype_to_language), lang_config.extension)
then
error(
("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format(
lang_config.extension,
lang_name,
contest_name,
table.concat(vim.tbl_keys(constants.filetype_to_language), ", ")
)
)
end
end
end
end
end
end
local config = vim.tbl_deep_extend('force', M.defaults, user_config or {})
return config
local config = vim.tbl_deep_extend("force", M.defaults, user_config or {})
return config
end
---@param contest_id string
---@param problem_id? string
---@return string
local function default_filename(contest_id, problem_id)
vim.validate({
contest_id = { contest_id, 'string' },
problem_id = { problem_id, { 'string', 'nil' }, true },
})
vim.validate({
contest_id = { contest_id, "string" },
problem_id = { problem_id, { "string", "nil" }, true },
})
if problem_id then
return problem_id:lower()
else
return contest_id:lower()
end
if problem_id then
return problem_id:lower()
else
return contest_id:lower()
end
end
M.default_filename = default_filename

22
lua/cp/constants.lua
View file

@ -1,24 +1,24 @@
local M = {}
M.PLATFORMS = { 'atcoder', 'codeforces', 'cses' }
M.ACTIONS = { 'run', 'debug', 'test', 'next', 'prev' }
M.PLATFORMS = { "atcoder", "codeforces", "cses" }
M.ACTIONS = { "run", "debug", "test", "next", "prev" }
M.CPP = 'cpp'
M.PYTHON = 'python'
M.CPP = "cpp"
M.PYTHON = "python"
---@type table<string, string>
M.filetype_to_language = {
cc = M.CPP,
cxx = M.CPP,
cpp = M.CPP,
py = M.PYTHON,
py3 = M.PYTHON,
cc = M.CPP,
cxx = M.CPP,
cpp = M.CPP,
py = M.PYTHON,
py3 = M.PYTHON,
}
---@type table<string, string>
M.canonical_filetypes = {
[M.CPP] = 'cpp',
[M.PYTHON] = 'python',
[M.CPP] = "cpp",
[M.PYTHON] = "python",
}
return M

395
lua/cp/execute.lua
View file

@ -6,47 +6,44 @@
---@field timed_out boolean
local M = {}
local logger = require('cp.log')
local logger = require("cp.log")
local constants = require('cp.constants')
local constants = require("cp.constants")
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)
vim.validate({
source_file = { source_file, 'string' },
contest_config = { contest_config, 'table' },
})
vim.validate({
source_file = { source_file, "string" },
contest_config = { contest_config, "table" },
})
local extension = vim.fn.fnamemodify(source_file, ':e')
local language = filetype_to_language[extension]
or contest_config.default_language
logger.log(
('detected language: %s (extension: %s)'):format(language, extension)
)
return language
local extension = vim.fn.fnamemodify(source_file, ":e")
local language = filetype_to_language[extension] or contest_config.default_language
logger.log(("detected language: %s (extension: %s)"):format(language, extension))
return language
end
---@param cmd_template string[]
---@param substitutions table<string, string>
---@return string[]
local function substitute_template(cmd_template, substitutions)
vim.validate({
cmd_template = { cmd_template, 'table' },
substitutions = { substitutions, 'table' },
})
vim.validate({
cmd_template = { cmd_template, "table" },
substitutions = { substitutions, "table" },
})
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
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
---@param cmd_template string[]
@ -54,76 +51,69 @@ end
---@param substitutions table<string, string>
---@return string[]
local function build_command(cmd_template, executable, substitutions)
vim.validate({
cmd_template = { cmd_template, 'table' },
executable = { executable, { 'string', 'nil' }, true },
substitutions = { substitutions, 'table' },
})
vim.validate({
cmd_template = { cmd_template, "table" },
executable = { executable, { "string", "nil" }, true },
substitutions = { substitutions, "table" },
})
local cmd = substitute_template(cmd_template, substitutions)
if executable then
table.insert(cmd, 1, executable)
end
return cmd
local cmd = substitute_template(cmd_template, substitutions)
if executable then
table.insert(cmd, 1, executable)
end
return cmd
end
local signal_codes = {
[128] = 'SIGILL',
[130] = 'SIGINT',
[131] = 'SIGQUIT',
[132] = 'SIGILL',
[133] = 'SIGTRAP',
[134] = 'SIGABRT',
[135] = 'SIGBUS',
[136] = 'SIGFPE',
[137] = 'SIGKILL',
[138] = 'SIGUSR1',
[139] = 'SIGSEGV',
[140] = 'SIGUSR2',
[141] = 'SIGPIPE',
[142] = 'SIGALRM',
[143] = 'SIGTERM',
[128] = "SIGILL",
[130] = "SIGINT",
[131] = "SIGQUIT",
[132] = "SIGILL",
[133] = "SIGTRAP",
[134] = "SIGABRT",
[135] = "SIGBUS",
[136] = "SIGFPE",
[137] = "SIGKILL",
[138] = "SIGUSR1",
[139] = "SIGSEGV",
[140] = "SIGUSR2",
[141] = "SIGPIPE",
[142] = "SIGALRM",
[143] = "SIGTERM",
}
local function ensure_directories()
vim.system({ 'mkdir', '-p', 'build', 'io' }):wait()
vim.system({ "mkdir", "-p", "build", "io" }):wait()
end
---@param language_config table
---@param substitutions table<string, string>
---@return {code: integer, stderr: string}
local function compile_generic(language_config, substitutions)
vim.validate({
language_config = { language_config, 'table' },
substitutions = { substitutions, 'table' },
})
vim.validate({
language_config = { language_config, "table" },
substitutions = { substitutions, "table" },
})
if not language_config.compile then
logger.log('no compilation step required')
return { code = 0, stderr = '' }
end
if not language_config.compile then
logger.log("no compilation step required")
return { code = 0, stderr = "" }
end
local compile_cmd =
substitute_template(language_config.compile, substitutions)
logger.log(('compiling: %s'):format(table.concat(compile_cmd, ' ')))
local compile_cmd = substitute_template(language_config.compile, substitutions)
logger.log(("compiling: %s"):format(table.concat(compile_cmd, " ")))
local start_time = vim.uv.hrtime()
local result = vim.system(compile_cmd, { text = true }):wait()
local compile_time = (vim.uv.hrtime() - start_time) / 1000000
local start_time = vim.uv.hrtime()
local result = vim.system(compile_cmd, { text = true }):wait()
local compile_time = (vim.uv.hrtime() - start_time) / 1000000
if result.code == 0 then
logger.log(('compilation successful (%.1fms)'):format(compile_time))
else
logger.log(
('compilation failed (%.1fms): %s'):format(
compile_time,
result.stderr
),
vim.log.levels.WARN
)
end
if result.code == 0 then
logger.log(("compilation successful (%.1fms)"):format(compile_time))
else
logger.log(("compilation failed (%.1fms): %s"):format(compile_time, result.stderr), vim.log.levels.WARN)
end
return result
return result
end
---@param cmd string[]
@ -131,51 +121,42 @@ end
---@param timeout_ms integer
---@return ExecuteResult
local function execute_command(cmd, input_data, timeout_ms)
vim.validate({
cmd = { cmd, 'table' },
input_data = { input_data, 'string' },
timeout_ms = { timeout_ms, 'number' },
})
vim.validate({
cmd = { cmd, "table" },
input_data = { input_data, "string" },
timeout_ms = { timeout_ms, "number" },
})
logger.log(('executing: %s'):format(table.concat(cmd, ' ')))
logger.log(("executing: %s"):format(table.concat(cmd, " ")))
local start_time = vim.uv.hrtime()
local start_time = vim.uv.hrtime()
local result = vim.system(cmd, {
stdin = input_data,
timeout = timeout_ms,
text = true,
}):wait()
local result = vim.system(cmd, {
stdin = input_data,
timeout = timeout_ms,
text = true,
}):wait()
local end_time = vim.uv.hrtime()
local execution_time = (end_time - start_time) / 1000000
local end_time = vim.uv.hrtime()
local execution_time = (end_time - start_time) / 1000000
local actual_code = result.code or 0
local actual_code = result.code or 0
if result.code == 124 then
logger.log(
('execution timed out after %.1fms'):format(execution_time),
vim.log.levels.WARN
)
elseif actual_code ~= 0 then
logger.log(
('execution failed (exit code %d, %.1fms)'):format(
actual_code,
execution_time
),
vim.log.levels.WARN
)
else
logger.log(('execution successful (%.1fms)'):format(execution_time))
end
if result.code == 124 then
logger.log(("execution timed out after %.1fms"):format(execution_time), vim.log.levels.WARN)
elseif actual_code ~= 0 then
logger.log(("execution failed (exit code %d, %.1fms)"):format(actual_code, execution_time), vim.log.levels.WARN)
else
logger.log(("execution successful (%.1fms)"):format(execution_time))
end
return {
stdout = result.stdout or '',
stderr = result.stderr or '',
code = actual_code,
time_ms = execution_time,
timed_out = result.code == 124,
}
return {
stdout = result.stdout or "",
stderr = result.stderr or "",
code = actual_code,
time_ms = execution_time,
timed_out = result.code == 124,
}
end
---@param exec_result ExecuteResult
@ -183,134 +164,104 @@ end
---@param is_debug boolean
---@return string
local function format_output(exec_result, expected_file, is_debug)
vim.validate({
exec_result = { exec_result, 'table' },
expected_file = { expected_file, 'string' },
is_debug = { is_debug, 'boolean' },
})
vim.validate({
exec_result = { exec_result, "table" },
expected_file = { expected_file, "string" },
is_debug = { is_debug, "boolean" },
})
local output_lines = { exec_result.stdout }
local metadata_lines = {}
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 = 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
if exec_result.timed_out then
table.insert(metadata_lines, "[code]: 124 (TIMEOUT)")
elseif exec_result.code >= 128 then
local signal_name = 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')
)
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')
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
while #actual_lines > 0 and actual_lines[#actual_lines] == "" do
table.remove(actual_lines)
end
local matches = #actual_lines == #expected_content
if matches then
for i, line in ipairs(actual_lines) do
if line ~= expected_content[i] then
matches = false
break
end
end
end
local matches = #actual_lines == #expected_content
if matches then
for i, line in ipairs(actual_lines) do
if line ~= expected_content[i] then
matches = false
break
end
end
end
table.insert(
metadata_lines,
('[matches]: %s'):format(matches and 'true' or 'false')
)
end
table.insert(metadata_lines, ("[matches]: %s"):format(matches and "true" or "false"))
end
return table.concat(output_lines, '')
.. '\n'
.. table.concat(metadata_lines, '\n')
return table.concat(output_lines, "") .. "\n" .. table.concat(metadata_lines, "\n")
end
---@param ctx ProblemContext
---@param contest_config table
---@param is_debug boolean
function M.run_problem(ctx, contest_config, is_debug)
vim.validate({
ctx = { ctx, 'table' },
contest_config = { contest_config, 'table' },
is_debug = { is_debug, 'boolean' },
})
vim.validate({
ctx = { ctx, "table" },
contest_config = { contest_config, "table" },
is_debug = { is_debug, "boolean" },
})
ensure_directories()
ensure_directories()
local language = get_language_from_file(ctx.source_file, contest_config)
local language_config = contest_config[language]
local language = get_language_from_file(ctx.source_file, contest_config)
local language_config = contest_config[language]
if not language_config then
vim.fn.writefile(
{ 'Error: No configuration for language: ' .. language },
ctx.output_file
)
return
end
if not language_config then
vim.fn.writefile({ "Error: No configuration for language: " .. language }, ctx.output_file)
return
end
local substitutions = {
source = ctx.source_file,
binary = ctx.binary_file,
version = tostring(language_config.version),
}
local substitutions = {
source = ctx.source_file,
binary = ctx.binary_file,
version = tostring(language_config.version),
}
local compile_cmd = is_debug and language_config.debug
or language_config.compile
if compile_cmd then
local compile_result = compile_generic(language_config, substitutions)
if compile_result.code ~= 0 then
vim.fn.writefile({ compile_result.stderr }, ctx.output_file)
return
end
end
local compile_cmd = is_debug and language_config.debug or language_config.compile
if compile_cmd then
local compile_result = compile_generic(language_config, substitutions)
if compile_result.code ~= 0 then
vim.fn.writefile({ compile_result.stderr }, ctx.output_file)
return
end
end
local input_data = ''
if vim.fn.filereadable(ctx.input_file) == 1 then
input_data = table.concat(vim.fn.readfile(ctx.input_file), '\n') .. '\n'
end
local input_data = ""
if vim.fn.filereadable(ctx.input_file) == 1 then
input_data = table.concat(vim.fn.readfile(ctx.input_file), "\n") .. "\n"
end
local run_cmd = build_command(
language_config.run,
language_config.executable,
substitutions
)
local exec_result =
execute_command(run_cmd, input_data, contest_config.timeout_ms)
local formatted_output =
format_output(exec_result, ctx.expected_file, is_debug)
local run_cmd = build_command(language_config.run, language_config.executable, substitutions)
local exec_result = execute_command(run_cmd, input_data, contest_config.timeout_ms)
local formatted_output = format_output(exec_result, ctx.expected_file, is_debug)
local output_buf = vim.fn.bufnr(ctx.output_file)
if output_buf ~= -1 then
vim.api.nvim_buf_set_lines(
output_buf,
0,
-1,
false,
vim.split(formatted_output, '\n')
)
vim.api.nvim_buf_call(output_buf, function()
vim.cmd.write()
end)
else
vim.fn.writefile(vim.split(formatted_output, '\n'), ctx.output_file)
end
local output_buf = vim.fn.bufnr(ctx.output_file)
if output_buf ~= -1 then
vim.api.nvim_buf_set_lines(output_buf, 0, -1, false, vim.split(formatted_output, "\n"))
vim.api.nvim_buf_call(output_buf, function()
vim.cmd.write()
end)
else
vim.fn.writefile(vim.split(formatted_output, "\n"), ctx.output_file)
end
end
return M

136
lua/cp/health.lua
View file

@ -1,101 +1,95 @@
local M = {}
local function check_nvim_version()
if vim.fn.has('nvim-0.10.0') == 1 then
vim.health.ok('Neovim 0.10.0+ detected')
else
vim.health.error('cp.nvim requires Neovim 0.10.0+')
end
if vim.fn.has("nvim-0.10.0") == 1 then
vim.health.ok("Neovim 0.10.0+ detected")
else
vim.health.error("cp.nvim requires Neovim 0.10.0+")
end
end
local function check_uv()
if vim.fn.executable('uv') == 1 then
vim.health.ok('uv executable found')
if vim.fn.executable("uv") == 1 then
vim.health.ok("uv executable found")
local result = vim.system({ 'uv', '--version' }, { text = true }):wait()
if result.code == 0 then
vim.health.info('uv version: ' .. result.stdout:gsub('\n', ''))
end
else
vim.health.warn(
'uv not found - install from https://docs.astral.sh/uv/ for problem scraping'
)
end
local result = vim.system({ "uv", "--version" }, { text = true }):wait()
if result.code == 0 then
vim.health.info("uv version: " .. result.stdout:gsub("\n", ""))
end
else
vim.health.warn("uv not found - install from https://docs.astral.sh/uv/ for problem scraping")
end
end
local function check_python_env()
local plugin_path = debug.getinfo(1, 'S').source:sub(2)
plugin_path = vim.fn.fnamemodify(plugin_path, ':h:h:h')
local venv_dir = plugin_path .. '/.venv'
local plugin_path = debug.getinfo(1, "S").source:sub(2)
plugin_path = vim.fn.fnamemodify(plugin_path, ":h:h:h")
local venv_dir = plugin_path .. "/.venv"
if vim.fn.isdirectory(venv_dir) == 1 then
vim.health.ok('Python virtual environment found at ' .. venv_dir)
else
vim.health.warn(
'Python virtual environment not set up - run :CP command to initialize'
)
end
if vim.fn.isdirectory(venv_dir) == 1 then
vim.health.ok("Python virtual environment found at " .. venv_dir)
else
vim.health.warn("Python virtual environment not set up - run :CP command to initialize")
end
end
local function check_scrapers()
local plugin_path = debug.getinfo(1, 'S').source:sub(2)
plugin_path = vim.fn.fnamemodify(plugin_path, ':h:h:h')
local plugin_path = debug.getinfo(1, "S").source:sub(2)
plugin_path = vim.fn.fnamemodify(plugin_path, ":h:h:h")
local scrapers = { 'atcoder.py', 'codeforces.py', 'cses.py' }
for _, scraper in ipairs(scrapers) do
local scraper_path = plugin_path .. '/scrapers/' .. scraper
if vim.fn.filereadable(scraper_path) == 1 then
vim.health.ok('Scraper found: ' .. scraper)
else
vim.health.error('Missing scraper: ' .. scraper)
end
end
local scrapers = { "atcoder.py", "codeforces.py", "cses.py" }
for _, scraper in ipairs(scrapers) do
local scraper_path = plugin_path .. "/scrapers/" .. scraper
if vim.fn.filereadable(scraper_path) == 1 then
vim.health.ok("Scraper found: " .. scraper)
else
vim.health.error("Missing scraper: " .. scraper)
end
end
end
local function check_luasnip()
local has_luasnip, luasnip = pcall(require, 'luasnip')
if has_luasnip then
vim.health.ok('LuaSnip integration available')
local snippet_count = #luasnip.get_snippets('all')
vim.health.info('LuaSnip snippets loaded: ' .. snippet_count)
else
vim.health.info(
'LuaSnip not available - template expansion will be limited'
)
end
local has_luasnip, luasnip = pcall(require, "luasnip")
if has_luasnip then
vim.health.ok("LuaSnip integration available")
local snippet_count = #luasnip.get_snippets("all")
vim.health.info("LuaSnip snippets loaded: " .. snippet_count)
else
vim.health.info("LuaSnip not available - template expansion will be limited")
end
end
local function check_config()
vim.health.ok('Plugin ready')
vim.health.ok("Plugin ready")
local cp = require('cp')
local context = cp.get_current_context()
if context.platform then
local info = context.platform
if context.contest_id then
info = info .. ' ' .. context.contest_id
if context.problem_id then
info = info .. ' ' .. context.problem_id
end
end
vim.health.info('Current context: ' .. info)
else
vim.health.info('No contest context set')
end
local cp = require("cp")
local context = cp.get_current_context()
if context.platform then
local info = context.platform
if context.contest_id then
info = info .. " " .. context.contest_id
if context.problem_id then
info = info .. " " .. context.problem_id
end
end
vim.health.info("Current context: " .. info)
else
vim.health.info("No contest context set")
end
end
function M.check()
local version = require('cp.version')
vim.health.start('cp.nvim health check')
local version = require("cp.version")
vim.health.start("cp.nvim health check")
vim.health.info('Version: ' .. version.version)
vim.health.info("Version: " .. version.version)
check_nvim_version()
check_uv()
check_python_env()
check_scrapers()
check_luasnip()
check_config()
check_nvim_version()
check_uv()
check_python_env()
check_scrapers()
check_luasnip()
check_config()
end
return M

743
lua/cp/init.lua
View file

@ -1,17 +1,17 @@
local M = {}
local config_module = require('cp.config')
local snippets = require('cp.snippets')
local execute = require('cp.execute')
local scrape = require('cp.scrape')
local window = require('cp.window')
local logger = require('cp.log')
local problem = require('cp.problem')
local cache = require('cp.cache')
local config_module = require("cp.config")
local snippets = require("cp.snippets")
local execute = require("cp.execute")
local scrape = require("cp.scrape")
local window = require("cp.window")
local logger = require("cp.log")
local problem = require("cp.problem")
local cache = require("cp.cache")
if not vim.fn.has('nvim-0.10.0') then
vim.notify('[cp.nvim]: requires nvim-0.10.0+', vim.log.levels.ERROR)
return {}
if not vim.fn.has("nvim-0.10.0") then
vim.notify("[cp.nvim]: requires nvim-0.10.0+", vim.log.levels.ERROR)
return {}
end
local user_config = {}
@ -20,500 +20,423 @@ logger.set_config(config)
local snippets_initialized = false
local state = {
platform = nil,
contest_id = nil,
problem_id = nil,
saved_layout = nil,
saved_session = nil,
test_cases = nil,
test_states = {},
platform = nil,
contest_id = nil,
problem_id = nil,
saved_layout = nil,
saved_session = nil,
test_cases = nil,
test_states = {},
}
local constants = require('cp.constants')
local constants = require("cp.constants")
local platforms = constants.PLATFORMS
local actions = constants.ACTIONS
local function set_platform(platform)
if not vim.tbl_contains(platforms, platform) then
logger.log(
('unknown platform. Available: [%s]'):format(
table.concat(platforms, ', ')
),
vim.log.levels.ERROR
)
return false
end
if not vim.tbl_contains(platforms, platform) then
logger.log(("unknown platform. Available: [%s]"):format(table.concat(platforms, ", ")), vim.log.levels.ERROR)
return false
end
state.platform = platform
vim.fn.mkdir('build', 'p')
vim.fn.mkdir('io', 'p')
return true
state.platform = platform
vim.fn.mkdir("build", "p")
vim.fn.mkdir("io", "p")
return true
end
---@param contest_id string
---@param problem_id? string
---@param language? string
local function setup_problem(contest_id, problem_id, language)
if not state.platform then
logger.log(
'no platform set. run :CP <platform> <contest> first',
vim.log.levels.ERROR
)
return
end
if not state.platform then
logger.log("no platform set. run :CP <platform> <contest> first", vim.log.levels.ERROR)
return
end
local problem_name = state.platform == 'cses' and contest_id
or (contest_id .. (problem_id or ''))
logger.log(('setting up problem: %s'):format(problem_name))
local problem_name = state.platform == "cses" and contest_id or (contest_id .. (problem_id or ""))
logger.log(("setting up problem: %s"):format(problem_name))
local metadata_result =
scrape.scrape_contest_metadata(state.platform, contest_id)
if not metadata_result.success then
logger.log(
'failed to load contest metadata: '
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN
)
end
local metadata_result = scrape.scrape_contest_metadata(state.platform, contest_id)
if not metadata_result.success then
logger.log(
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
vim.log.levels.WARN
)
end
vim.cmd('silent only')
vim.cmd("silent only")
state.contest_id = contest_id
state.problem_id = problem_id
state.contest_id = contest_id
state.problem_id = problem_id
local cached_test_cases =
cache.get_test_cases(state.platform, contest_id, problem_id)
if cached_test_cases then
state.test_cases = cached_test_cases
end
local cached_test_cases = cache.get_test_cases(state.platform, contest_id, problem_id)
if cached_test_cases then
state.test_cases = cached_test_cases
end
local scrape_ctx = problem.create_context(
state.platform,
contest_id,
problem_id,
config,
language
)
local scrape_ctx = problem.create_context(state.platform, contest_id, problem_id, config, language)
local scrape_result = scrape.scrape_problem(scrape_ctx)
local scrape_result = scrape.scrape_problem(scrape_ctx)
if not scrape_result.success then
logger.log(
'scraping failed: ' .. (scrape_result.error or 'unknown error'),
vim.log.levels.WARN
)
logger.log(
'you can manually add test cases to io/ directory',
vim.log.levels.INFO
)
state.test_cases = nil
else
local test_count = scrape_result.test_count or 0
logger.log(
('scraped %d test case(s) for %s'):format(
test_count,
scrape_result.problem_id
)
)
state.test_cases = scrape_result.test_cases
if not scrape_result.success then
logger.log("scraping failed: " .. (scrape_result.error or "unknown error"), vim.log.levels.WARN)
logger.log("you can manually add test cases to io/ directory", vim.log.levels.INFO)
state.test_cases = nil
else
local test_count = scrape_result.test_count or 0
logger.log(("scraped %d test case(s) for %s"):format(test_count, scrape_result.problem_id))
state.test_cases = scrape_result.test_cases
if scrape_result.test_cases then
cache.set_test_cases(
state.platform,
contest_id,
problem_id,
scrape_result.test_cases
)
end
end
if scrape_result.test_cases then
cache.set_test_cases(state.platform, contest_id, problem_id, scrape_result.test_cases)
end
end
vim.cmd.e(scrape_ctx.source_file)
vim.cmd.e(scrape_ctx.source_file)
if vim.api.nvim_buf_get_lines(0, 0, -1, true)[1] == '' then
local has_luasnip, luasnip = pcall(require, 'luasnip')
if has_luasnip then
local prefixed_trigger = ('cp.nvim/%s.%s'):format(
state.platform,
language
)
if vim.api.nvim_buf_get_lines(0, 0, -1, true)[1] == "" then
local has_luasnip, luasnip = pcall(require, "luasnip")
if has_luasnip then
local prefixed_trigger = ("cp.nvim/%s.%s"):format(state.platform, language)
vim.api.nvim_buf_set_lines(0, 0, -1, false, { prefixed_trigger })
vim.api.nvim_win_set_cursor(0, { 1, #prefixed_trigger })
vim.cmd.startinsert({ bang = true })
vim.api.nvim_buf_set_lines(0, 0, -1, false, { prefixed_trigger })
vim.api.nvim_win_set_cursor(0, { 1, #prefixed_trigger })
vim.cmd.startinsert({ bang = true })
vim.schedule(function()
if luasnip.expandable() then
luasnip.expand()
else
vim.api.nvim_buf_set_lines(0, 0, 1, false, { '' })
vim.api.nvim_win_set_cursor(0, { 1, 0 })
end
vim.cmd.stopinsert()
end)
else
vim.api.nvim_input(('i%s<c-space><esc>'):format(state.platform))
end
end
vim.schedule(function()
if luasnip.expandable() then
luasnip.expand()
else
vim.api.nvim_buf_set_lines(0, 0, 1, false, { "" })
vim.api.nvim_win_set_cursor(0, { 1, 0 })
end
vim.cmd.stopinsert()
end)
else
vim.api.nvim_input(("i%s<c-space><esc>"):format(state.platform))
end
end
local ctx = problem.create_context(
state.platform,
state.contest_id,
state.problem_id,
config,
language
)
local ctx = problem.create_context(state.platform, state.contest_id, state.problem_id, config, language)
if config.hooks and config.hooks.setup_code then
config.hooks.setup_code(ctx)
end
if config.hooks and config.hooks.setup_code then
config.hooks.setup_code(ctx)
end
local source_buf = vim.api.nvim_get_current_buf()
local input_buf = vim.fn.bufnr(ctx.input_file, true)
local output_buf = vim.fn.bufnr(ctx.output_file, true)
local source_buf = vim.api.nvim_get_current_buf()
local input_buf = vim.fn.bufnr(ctx.input_file, true)
local output_buf = vim.fn.bufnr(ctx.output_file, true)
local tile_fn = config.tile or window.default_tile
tile_fn(source_buf, input_buf, output_buf)
local tile_fn = config.tile or window.default_tile
tile_fn(source_buf, input_buf, output_buf)
logger.log(('switched to problem %s'):format(ctx.problem_name))
logger.log(("switched to problem %s"):format(ctx.problem_name))
end
local function get_current_problem()
local filename = vim.fn.expand('%:t:r')
if filename == '' then
logger.log('no file open', vim.log.levels.ERROR)
return nil
end
return filename
local filename = vim.fn.expand("%:t:r")
if filename == "" then
logger.log("no file open", vim.log.levels.ERROR)
return nil
end
return filename
end
local function run_problem()
local problem_id = get_current_problem()
if not problem_id then
return
end
local problem_id = get_current_problem()
if not problem_id then
return
end
logger.log(('running problem: %s'):format(problem_id))
logger.log(("running problem: %s"):format(problem_id))
if not state.platform then
logger.log('no platform set', vim.log.levels.ERROR)
return
end
if not state.platform then
logger.log("no platform set", vim.log.levels.ERROR)
return
end
local contest_config = config.contests[state.platform]
local ctx = problem.create_context(
state.platform,
state.contest_id,
state.problem_id,
config
)
local contest_config = config.contests[state.platform]
local ctx = problem.create_context(state.platform, state.contest_id, state.problem_id, config)
if config.hooks and config.hooks.before_run then
config.hooks.before_run(ctx)
end
if config.hooks and config.hooks.before_run then
config.hooks.before_run(ctx)
end
vim.schedule(function()
execute.run_problem(ctx, contest_config, false)
vim.cmd.checktime()
end)
vim.schedule(function()
execute.run_problem(ctx, contest_config, false)
vim.cmd.checktime()
end)
end
local function debug_problem()
local problem_id = get_current_problem()
if not problem_id then
return
end
local problem_id = get_current_problem()
if not problem_id then
return
end
if not state.platform then
logger.log('no platform set', vim.log.levels.ERROR)
return
end
if not state.platform then
logger.log("no platform set", vim.log.levels.ERROR)
return
end
local contest_config = config.contests[state.platform]
local ctx = problem.create_context(
state.platform,
state.contest_id,
state.problem_id,
config
)
local contest_config = config.contests[state.platform]
local ctx = problem.create_context(state.platform, state.contest_id, state.problem_id, config)
if config.hooks and config.hooks.before_debug then
config.hooks.before_debug(ctx)
end
if config.hooks and config.hooks.before_debug then
config.hooks.before_debug(ctx)
end
vim.schedule(function()
execute.run_problem(ctx, contest_config, true)
vim.cmd.checktime()
end)
vim.schedule(function()
execute.run_problem(ctx, contest_config, true)
vim.cmd.checktime()
end)
end
---@param delta number 1 for next, -1 for prev
---@param language? string
local function navigate_problem(delta, language)
if not state.platform or not state.contest_id then
logger.log(
'no contest set. run :CP <platform> <contest> first',
vim.log.levels.ERROR
)
return
end
if not state.platform or not state.contest_id then
logger.log("no contest set. run :CP <platform> <contest> first", vim.log.levels.ERROR)
return
end
cache.load()
local contest_data =
cache.get_contest_data(state.platform, state.contest_id)
if not contest_data or not contest_data.problems then
logger.log(
'no contest metadata found. set up a problem first to cache contest data',
vim.log.levels.ERROR
)
return
end
cache.load()
local contest_data = cache.get_contest_data(state.platform, state.contest_id)
if not contest_data or not contest_data.problems then
logger.log("no contest metadata found. set up a problem first to cache contest data", vim.log.levels.ERROR)
return
end
local problems = contest_data.problems
local current_problem_id
local problems = contest_data.problems
local current_problem_id
if state.platform == 'cses' then
current_problem_id = state.contest_id
else
current_problem_id = state.problem_id
end
if state.platform == "cses" then
current_problem_id = state.contest_id
else
current_problem_id = state.problem_id
end
if not current_problem_id then
logger.log('no current problem set', vim.log.levels.ERROR)
return
end
if not current_problem_id then
logger.log("no current problem set", vim.log.levels.ERROR)
return
end
local current_index = nil
for i, prob in ipairs(problems) do
if prob.id == current_problem_id then
current_index = i
break
end
end
local current_index = nil
for i, prob in ipairs(problems) do
if prob.id == current_problem_id then
current_index = i
break
end
end
if not current_index then
logger.log('current problem not found in contest', vim.log.levels.ERROR)
return
end
if not current_index then
logger.log("current problem not found in contest", vim.log.levels.ERROR)
return
end
local new_index = current_index + delta
local new_index = current_index + delta
if new_index < 1 or new_index > #problems then
local direction = delta > 0 and 'next' or 'previous'
logger.log(
('no %s problem available'):format(direction),
vim.log.levels.INFO
)
return
end
if new_index < 1 or new_index > #problems then
local direction = delta > 0 and "next" or "previous"
logger.log(("no %s problem available"):format(direction), vim.log.levels.INFO)
return
end
local new_problem = problems[new_index]
local new_problem = problems[new_index]
if state.platform == 'cses' then
setup_problem(new_problem.id, nil, language)
else
setup_problem(state.contest_id, new_problem.id, language)
end
if state.platform == "cses" then
setup_problem(new_problem.id, nil, language)
else
setup_problem(state.contest_id, new_problem.id, language)
end
end
local function parse_command(args)
if #args == 0 then
return {
type = 'error',
message = 'Usage: :CP <platform> <contest> [problem] [--lang=<language>] | :CP <action> | :CP <problem>',
}
end
if #args == 0 then
return {
type = "error",
message = "Usage: :CP <platform> <contest> [problem] [--lang=<language>] | :CP <action> | :CP <problem>",
}
end
local language = nil
local language = nil
for i, arg in ipairs(args) do
local lang_match = arg:match('^--lang=(.+)$')
if lang_match then
language = lang_match
elseif arg == '--lang' then
if i + 1 <= #args then
language = args[i + 1]
else
return { type = 'error', message = '--lang requires a value' }
end
end
end
for i, arg in ipairs(args) do
local lang_match = arg:match("^--lang=(.+)$")
if lang_match then
language = lang_match
elseif arg == "--lang" then
if i + 1 <= #args then
language = args[i + 1]
else
return { type = "error", message = "--lang requires a value" }
end
end
end
local filtered_args = vim.tbl_filter(function(arg)
return not (arg:match('^--lang') or arg == language)
end, args)
local filtered_args = vim.tbl_filter(function(arg)
return not (arg:match("^--lang") or arg == language)
end, args)
local first = filtered_args[1]
local first = filtered_args[1]
if vim.tbl_contains(actions, first) then
return { type = 'action', action = first, language = language }
end
if vim.tbl_contains(actions, first) then
return { type = "action", action = first, language = language }
end
if vim.tbl_contains(platforms, first) then
if #filtered_args == 1 then
return {
type = 'platform_only',
platform = first,
language = language,
}
elseif #filtered_args == 2 then
if first == 'cses' then
return {
type = 'cses_problem',
platform = first,
problem = filtered_args[2],
language = language,
}
else
return {
type = 'contest_setup',
platform = first,
contest = filtered_args[2],
language = language,
}
end
elseif #filtered_args == 3 then
return {
type = 'full_setup',
platform = first,
contest = filtered_args[2],
problem = filtered_args[3],
language = language,
}
else
return { type = 'error', message = 'Too many arguments' }
end
end
if vim.tbl_contains(platforms, first) then
if #filtered_args == 1 then
return {
type = "platform_only",
platform = first,
language = language,
}
elseif #filtered_args == 2 then
if first == "cses" then
return {
type = "cses_problem",
platform = first,
problem = filtered_args[2],
language = language,
}
else
return {
type = "contest_setup",
platform = first,
contest = filtered_args[2],
language = language,
}
end
elseif #filtered_args == 3 then
return {
type = "full_setup",
platform = first,
contest = filtered_args[2],
problem = filtered_args[3],
language = language,
}
else
return { type = "error", message = "Too many arguments" }
end
end
if state.platform and state.contest_id then
return { type = 'problem_switch', problem = first, language = language }
end
if state.platform and state.contest_id then
return { type = "problem_switch", problem = first, language = language }
end
return { type = 'error', message = 'Unknown command or no contest context' }
return { type = "error", message = "Unknown command or no contest context" }
end
function M.handle_command(opts)
local cmd = parse_command(opts.fargs)
local cmd = parse_command(opts.fargs)
if cmd.type == 'error' then
logger.log(cmd.message, vim.log.levels.ERROR)
return
end
if cmd.type == "error" then
logger.log(cmd.message, vim.log.levels.ERROR)
return
end
if cmd.type == 'action' then
if cmd.action == 'run' then
run_problem()
elseif cmd.action == 'debug' then
debug_problem()
elseif cmd.action == 'next' then
navigate_problem(1, cmd.language)
elseif cmd.action == 'prev' then
navigate_problem(-1, cmd.language)
end
return
end
if cmd.type == "action" then
if cmd.action == "run" then
run_problem()
elseif cmd.action == "debug" then
debug_problem()
elseif cmd.action == "next" then
navigate_problem(1, cmd.language)
elseif cmd.action == "prev" then
navigate_problem(-1, cmd.language)
end
return
end
if cmd.type == 'platform_only' then
set_platform(cmd.platform)
return
end
if cmd.type == "platform_only" then
set_platform(cmd.platform)
return
end
if cmd.type == 'contest_setup' then
if set_platform(cmd.platform) then
state.contest_id = cmd.contest
local metadata_result =
scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
if not metadata_result.success then
logger.log(
'failed to load contest metadata: '
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN
)
else
logger.log(
('loaded %d problems for %s %s'):format(
#metadata_result.problems,
cmd.platform,
cmd.contest
)
)
end
end
return
end
if cmd.type == "contest_setup" then
if set_platform(cmd.platform) then
state.contest_id = cmd.contest
local metadata_result = scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
if not metadata_result.success then
logger.log(
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
vim.log.levels.WARN
)
else
logger.log(
("loaded %d problems for %s %s"):format(#metadata_result.problems, cmd.platform, cmd.contest)
)
end
end
return
end
if cmd.type == 'full_setup' then
if set_platform(cmd.platform) then
state.contest_id = cmd.contest
local metadata_result =
scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
if not metadata_result.success then
logger.log(
'failed to load contest metadata: '
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN
)
else
logger.log(
('loaded %d problems for %s %s'):format(
#metadata_result.problems,
cmd.platform,
cmd.contest
)
)
end
if cmd.type == "full_setup" then
if set_platform(cmd.platform) then
state.contest_id = cmd.contest
local metadata_result = scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
if not metadata_result.success then
logger.log(
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
vim.log.levels.WARN
)
else
logger.log(
("loaded %d problems for %s %s"):format(#metadata_result.problems, cmd.platform, cmd.contest)
)
end
setup_problem(cmd.contest, cmd.problem, cmd.language)
end
return
end
setup_problem(cmd.contest, cmd.problem, cmd.language)
end
return
end
if cmd.type == 'cses_problem' then
if set_platform(cmd.platform) then
local metadata_result =
scrape.scrape_contest_metadata(cmd.platform, '')
if not metadata_result.success then
logger.log(
'failed to load contest metadata: '
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN
)
end
setup_problem(cmd.problem, nil, cmd.language)
end
return
end
if cmd.type == "cses_problem" then
if set_platform(cmd.platform) then
local metadata_result = scrape.scrape_contest_metadata(cmd.platform, "")
if not metadata_result.success then
logger.log(
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
vim.log.levels.WARN
)
end
setup_problem(cmd.problem, nil, cmd.language)
end
return
end
if cmd.type == 'problem_switch' then
if state.platform == 'cses' then
setup_problem(cmd.problem, nil, cmd.language)
else
setup_problem(state.contest_id, cmd.problem, cmd.language)
end
return
end
if cmd.type == "problem_switch" then
if state.platform == "cses" then
setup_problem(cmd.problem, nil, cmd.language)
else
setup_problem(state.contest_id, cmd.problem, cmd.language)
end
return
end
end
function M.setup(opts)
opts = opts or {}
user_config = opts
config = config_module.setup(user_config)
logger.set_config(config)
if not snippets_initialized then
snippets.setup(config)
snippets_initialized = true
end
opts = opts or {}
user_config = opts
config = config_module.setup(user_config)
logger.set_config(config)
if not snippets_initialized then
snippets.setup(config)
snippets_initialized = true
end
end
function M.get_current_context()
return {
platform = state.platform,
contest_id = state.contest_id,
problem_id = state.problem_id,
}
return {
platform = state.platform,
contest_id = state.contest_id,
problem_id = state.problem_id,
}
end
function M.is_initialized()
return true
return true
end
return M

10
lua/cp/log.lua
View file

@ -3,14 +3,14 @@ local M = {}
local config = nil
function M.set_config(user_config)
config = user_config
config = user_config
end
function M.log(msg, level)
level = level or vim.log.levels.INFO
if not config or config.debug or level >= vim.log.levels.WARN then
vim.notify(('[cp.nvim]: %s'):format(msg), level)
end
level = level or vim.log.levels.INFO
if not config or config.debug or level >= vim.log.levels.WARN then
vim.notify(("[cp.nvim]: %s"):format(msg), level)
end
end
return M

89
lua/cp/problem.lua
View file

@ -18,61 +18,50 @@ local M = {}
---@param language? string
---@return ProblemContext
function M.create_context(contest, contest_id, problem_id, config, language)
vim.validate({
contest = { contest, 'string' },
contest_id = { contest_id, 'string' },
problem_id = { problem_id, { 'string', 'nil' }, true },
config = { config, 'table' },
language = { language, { 'string', 'nil' }, true },
})
vim.validate({
contest = { contest, "string" },
contest_id = { contest_id, "string" },
problem_id = { problem_id, { "string", "nil" }, true },
config = { config, "table" },
language = { language, { "string", "nil" }, true },
})
local contest_config = config.contests[contest]
if not contest_config then
error(("No contest config found for '%s'"):format(contest))
end
local contest_config = config.contests[contest]
if not contest_config then
error(("No contest config found for '%s'"):format(contest))
end
local target_language = language or contest_config.default_language
local language_config = contest_config[target_language]
if not language_config then
error(
("No language config found for '%s' in contest '%s'"):format(
target_language,
contest
)
)
end
if not language_config.extension then
error(
("No extension configured for language '%s' in contest '%s'"):format(
target_language,
contest
)
)
end
local target_language = language or contest_config.default_language
local language_config = contest_config[target_language]
if not language_config then
error(("No language config found for '%s' in contest '%s'"):format(target_language, contest))
end
if not language_config.extension then
error(("No extension configured for language '%s' in contest '%s'"):format(target_language, contest))
end
local base_name
if config.filename then
local source_file =
config.filename(contest, contest_id, problem_id, config, language)
base_name = vim.fn.fnamemodify(source_file, ':t:r')
else
local default_filename = require('cp.config').default_filename
base_name = default_filename(contest_id, problem_id)
end
local base_name
if config.filename then
local source_file = config.filename(contest, contest_id, problem_id, config, language)
base_name = vim.fn.fnamemodify(source_file, ":t:r")
else
local default_filename = require("cp.config").default_filename
base_name = default_filename(contest_id, problem_id)
end
local source_file = base_name .. '.' .. language_config.extension
local source_file = base_name .. "." .. language_config.extension
return {
contest = contest,
contest_id = contest_id,
problem_id = problem_id,
source_file = source_file,
binary_file = ('build/%s.run'):format(base_name),
input_file = ('io/%s.cpin'):format(base_name),
output_file = ('io/%s.cpout'):format(base_name),
expected_file = ('io/%s.expected'):format(base_name),
problem_name = base_name,
}
return {
contest = contest,
contest_id = contest_id,
problem_id = problem_id,
source_file = source_file,
binary_file = ("build/%s.run"):format(base_name),
input_file = ("io/%s.cpin"):format(base_name),
output_file = ("io/%s.cpout"):format(base_name),
expected_file = ("io/%s.expected"):format(base_name),
problem_name = base_name,
}
end
return M

402
lua/cp/scrape.lua
View file

@ -1,265 +1,245 @@
local M = {}
local logger = require('cp.log')
local cache = require('cp.cache')
local logger = require("cp.log")
local cache = require("cp.cache")
local function get_plugin_path()
local plugin_path = debug.getinfo(1, 'S').source:sub(2)
return vim.fn.fnamemodify(plugin_path, ':h:h:h')
local plugin_path = debug.getinfo(1, "S").source:sub(2)
return vim.fn.fnamemodify(plugin_path, ":h:h:h")
end
local function ensure_io_directory()
vim.fn.mkdir('io', 'p')
vim.fn.mkdir("io", "p")
end
local function check_internet_connectivity()
local result = vim.system(
{ 'ping', '-c', '1', '-W', '3', '8.8.8.8' },
{ text = true }
):wait()
return result.code == 0
local result = vim.system({ "ping", "-c", "1", "-W", "3", "8.8.8.8" }, { text = true }):wait()
return result.code == 0
end
local function setup_python_env()
local plugin_path = get_plugin_path()
local venv_dir = plugin_path .. '/.venv'
local plugin_path = get_plugin_path()
local venv_dir = plugin_path .. "/.venv"
if vim.fn.executable('uv') == 0 then
logger.log(
'uv is not installed. Install it to enable problem scraping: https://docs.astral.sh/uv/',
vim.log.levels.WARN
)
return false
end
if vim.fn.executable("uv") == 0 then
logger.log(
"uv is not installed. Install it to enable problem scraping: https://docs.astral.sh/uv/",
vim.log.levels.WARN
)
return false
end
if vim.fn.isdirectory(venv_dir) == 0 then
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
)
return false
end
logger.log('python environment setup complete')
end
if vim.fn.isdirectory(venv_dir) == 0 then
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)
return false
end
logger.log("python environment setup complete")
end
return true
return true
end
---@param platform string
---@param contest_id string
---@return {success: boolean, problems?: table[], error?: string}
function M.scrape_contest_metadata(platform, contest_id)
vim.validate({
platform = { platform, 'string' },
contest_id = { contest_id, 'string' },
})
vim.validate({
platform = { platform, "string" },
contest_id = { contest_id, "string" },
})
cache.load()
cache.load()
local cached_data = cache.get_contest_data(platform, contest_id)
if cached_data then
return {
success = true,
problems = cached_data.problems,
}
end
local cached_data = cache.get_contest_data(platform, contest_id)
if cached_data then
return {
success = true,
problems = cached_data.problems,
}
end
if not check_internet_connectivity() then
return {
success = false,
error = 'No internet connection available',
}
end
if not check_internet_connectivity() then
return {
success = false,
error = "No internet connection available",
}
end
if not setup_python_env() then
return {
success = false,
error = 'Python environment setup failed',
}
end
if not setup_python_env() then
return {
success = false,
error = "Python environment setup failed",
}
end
local plugin_path = get_plugin_path()
local scraper_path = plugin_path .. '/scrapers/' .. platform .. '.py'
local plugin_path = get_plugin_path()
local scraper_path = plugin_path .. "/scrapers/" .. platform .. ".py"
local args
if platform == 'cses' then
args = {
'uv',
'run',
'--directory',
plugin_path,
scraper_path,
'metadata',
}
else
args = {
'uv',
'run',
'--directory',
plugin_path,
scraper_path,
'metadata',
contest_id,
}
end
local args
if platform == "cses" then
args = {
"uv",
"run",
"--directory",
plugin_path,
scraper_path,
"metadata",
}
else
args = {
"uv",
"run",
"--directory",
plugin_path,
scraper_path,
"metadata",
contest_id,
}
end
local result = vim.system(args, {
cwd = plugin_path,
text = true,
timeout = 30000,
}):wait()
local result = vim.system(args, {
cwd = plugin_path,
text = true,
timeout = 30000,
}):wait()
if result.code ~= 0 then
return {
success = false,
error = 'Failed to run metadata scraper: '
.. (result.stderr or 'Unknown error'),
}
end
if result.code ~= 0 then
return {
success = false,
error = "Failed to run metadata scraper: " .. (result.stderr or "Unknown error"),
}
end
local ok, data = pcall(vim.json.decode, result.stdout)
if not ok then
return {
success = false,
error = 'Failed to parse metadata scraper output: '
.. tostring(data),
}
end
local ok, data = pcall(vim.json.decode, result.stdout)
if not ok then
return {
success = false,
error = "Failed to parse metadata scraper output: " .. tostring(data),
}
end
if not data.success then
return data
end
if not data.success then
return data
end
local problems_list
if platform == 'cses' then
problems_list = data.categories and data.categories['CSES Problem Set']
or {}
else
problems_list = data.problems or {}
end
local problems_list
if platform == "cses" then
problems_list = data.categories and data.categories["CSES Problem Set"] or {}
else
problems_list = data.problems or {}
end
cache.set_contest_data(platform, contest_id, problems_list)
return {
success = true,
problems = problems_list,
}
cache.set_contest_data(platform, contest_id, problems_list)
return {
success = true,
problems = problems_list,
}
end
---@param ctx ProblemContext
---@return {success: boolean, problem_id: string, test_count?: number, test_cases?: table[], url?: string, error?: string}
function M.scrape_problem(ctx)
vim.validate({
ctx = { ctx, 'table' },
})
vim.validate({
ctx = { ctx, "table" },
})
ensure_io_directory()
ensure_io_directory()
if
vim.fn.filereadable(ctx.input_file) == 1
and vim.fn.filereadable(ctx.expected_file) == 1
then
return {
success = true,
problem_id = ctx.problem_name,
test_count = 1,
}
end
if vim.fn.filereadable(ctx.input_file) == 1 and vim.fn.filereadable(ctx.expected_file) == 1 then
return {
success = true,
problem_id = ctx.problem_name,
test_count = 1,
}
end
if not check_internet_connectivity() then
return {
success = false,
problem_id = ctx.problem_name,
error = 'No internet connection available',
}
end
if not check_internet_connectivity() then
return {
success = false,
problem_id = ctx.problem_name,
error = "No internet connection available",
}
end
if not setup_python_env() then
return {
success = false,
problem_id = ctx.problem_name,
error = 'Python environment setup failed',
}
end
if not setup_python_env() then
return {
success = false,
problem_id = ctx.problem_name,
error = "Python environment setup failed",
}
end
local plugin_path = get_plugin_path()
local scraper_path = plugin_path .. '/scrapers/' .. ctx.contest .. '.py'
local plugin_path = get_plugin_path()
local scraper_path = plugin_path .. "/scrapers/" .. ctx.contest .. ".py"
local args
if ctx.contest == 'cses' then
args = {
'uv',
'run',
'--directory',
plugin_path,
scraper_path,
'tests',
ctx.contest_id,
}
else
args = {
'uv',
'run',
'--directory',
plugin_path,
scraper_path,
'tests',
ctx.contest_id,
ctx.problem_id,
}
end
local args
if ctx.contest == "cses" then
args = {
"uv",
"run",
"--directory",
plugin_path,
scraper_path,
"tests",
ctx.contest_id,
}
else
args = {
"uv",
"run",
"--directory",
plugin_path,
scraper_path,
"tests",
ctx.contest_id,
ctx.problem_id,
}
end
local result = vim.system(args, {
cwd = plugin_path,
text = true,
timeout = 30000,
}):wait()
local result = vim.system(args, {
cwd = plugin_path,
text = true,
timeout = 30000,
}):wait()
if result.code ~= 0 then
return {
success = false,
problem_id = ctx.problem_name,
error = 'Failed to run tests scraper: '
.. (result.stderr or 'Unknown error'),
}
end
if result.code ~= 0 then
return {
success = false,
problem_id = ctx.problem_name,
error = "Failed to run tests scraper: " .. (result.stderr or "Unknown error"),
}
end
local ok, data = pcall(vim.json.decode, result.stdout)
if not ok then
return {
success = false,
problem_id = ctx.problem_name,
error = 'Failed to parse tests scraper output: ' .. tostring(data),
}
end
local ok, data = pcall(vim.json.decode, result.stdout)
if not ok then
return {
success = false,
problem_id = ctx.problem_name,
error = "Failed to parse tests scraper output: " .. tostring(data),
}
end
if not data.success then
return data
end
if not data.success then
return data
end
if data.test_cases and #data.test_cases > 0 then
local combined_input = data.test_cases[1].input:gsub('\r', '')
local combined_output = data.test_cases[1].output:gsub('\r', '')
if data.test_cases and #data.test_cases > 0 then
local combined_input = data.test_cases[1].input:gsub("\r", "")
local combined_output = data.test_cases[1].output:gsub("\r", "")
vim.fn.writefile(vim.split(combined_input, '\n', true), ctx.input_file)
vim.fn.writefile(
vim.split(combined_output, '\n', true),
ctx.expected_file
)
end
vim.fn.writefile(vim.split(combined_input, "\n", true), ctx.input_file)
vim.fn.writefile(vim.split(combined_output, "\n", true), ctx.expected_file)
end
return {
success = true,
problem_id = ctx.problem_name,
test_count = data.test_cases and #data.test_cases or 0,
test_cases = data.test_cases,
url = data.url,
}
return {
success = true,
problem_id = ctx.problem_name,
test_count = data.test_cases and #data.test_cases or 0,
test_cases = data.test_cases,
url = data.url,
}
end
return M

103
lua/cp/snippets.lua
View file

@ -1,32 +1,28 @@
local M = {}
local logger = require('cp.log')
local logger = require("cp.log")
function M.setup(config)
local ok, ls = pcall(require, 'luasnip')
if not ok then
logger.log(
'LuaSnip not available - snippets disabled',
vim.log.levels.INFO
)
return
end
local ok, ls = pcall(require, "luasnip")
if not ok then
logger.log("LuaSnip not available - snippets disabled", vim.log.levels.INFO)
return
end
local s, i, fmt =
ls.snippet, ls.insert_node, require('luasnip.extras.fmt').fmt
local s, i, fmt = ls.snippet, ls.insert_node, require("luasnip.extras.fmt").fmt
local constants = require('cp.constants')
local filetype_to_language = constants.filetype_to_language
local constants = require("cp.constants")
local filetype_to_language = constants.filetype_to_language
local language_to_filetype = {}
for ext, lang in pairs(filetype_to_language) do
if not language_to_filetype[lang] then
language_to_filetype[lang] = ext
end
end
local language_to_filetype = {}
for ext, lang in pairs(filetype_to_language) do
if not language_to_filetype[lang] then
language_to_filetype[lang] = ext
end
end
local template_definitions = {
cpp = {
codeforces = [[#include <bits/stdc++.h>
local template_definitions = {
cpp = {
codeforces = [[#include <bits/stdc++.h>
using namespace std;
@ -47,7 +43,7 @@ int main() {{
return 0;
}}]],
atcoder = [[#include <bits/stdc++.h>
atcoder = [[#include <bits/stdc++.h>
using namespace std;
@ -72,7 +68,7 @@ int main() {{
return 0;
}}]],
cses = [[#include <bits/stdc++.h>
cses = [[#include <bits/stdc++.h>
using namespace std;
@ -83,10 +79,10 @@ int main() {{
return 0;
}}]],
},
},
python = {
codeforces = [[def solve():
python = {
codeforces = [[def solve():
{}
if __name__ == "__main__":
@ -94,44 +90,41 @@ if __name__ == "__main__":
for _ in range(tc):
solve()]],
atcoder = [[def solve():
atcoder = [[def solve():
{}
if __name__ == "__main__":
solve()]],
cses = [[{}]],
},
}
cses = [[{}]],
},
}
local user_overrides = {}
for _, snippet in ipairs(config.snippets or {}) do
user_overrides[snippet.trigger] = snippet
end
local user_overrides = {}
for _, snippet in ipairs(config.snippets or {}) do
user_overrides[snippet.trigger] = snippet
end
for language, template_set in pairs(template_definitions) do
local snippets = {}
local filetype = constants.canonical_filetypes[language]
for language, template_set in pairs(template_definitions) do
local snippets = {}
local filetype = constants.canonical_filetypes[language]
for contest, template in pairs(template_set) do
local prefixed_trigger = ('cp.nvim/%s.%s'):format(contest, language)
if not user_overrides[prefixed_trigger] then
table.insert(
snippets,
s(prefixed_trigger, fmt(template, { i(1) }))
)
end
end
for contest, template in pairs(template_set) do
local prefixed_trigger = ("cp.nvim/%s.%s"):format(contest, language)
if not user_overrides[prefixed_trigger] then
table.insert(snippets, s(prefixed_trigger, fmt(template, { i(1) })))
end
end
for trigger, snippet in pairs(user_overrides) do
local prefix_match = trigger:match('^cp%.nvim/[^.]+%.(.+)$')
if prefix_match == language then
table.insert(snippets, snippet)
end
end
for trigger, snippet in pairs(user_overrides) do
local prefix_match = trigger:match("^cp%.nvim/[^.]+%.(.+)$")
if prefix_match == language then
table.insert(snippets, snippet)
end
end
ls.add_snippets(filetype, snippets)
end
ls.add_snippets(filetype, snippets)
end
end
return M

243
lua/cp/test.lua
View file

@ -1,180 +1,163 @@
local M = {}
local logger = require('cp.log')
local execute = require('cp.execute')
local logger = require("cp.log")
local execute = require("cp.execute")
local test_panel_state = {
test_cases = {},
current_index = 1,
buffer = nil,
namespace = nil,
is_active = false,
saved_layout = nil,
test_cases = {},
current_index = 1,
buffer = nil,
namespace = nil,
is_active = false,
saved_layout = nil,
}
local function create_test_case(index, input, expected)
return {
index = index,
input = input,
expected = expected,
status = 'pending',
actual = nil,
time_ms = nil,
error = nil,
}
return {
index = index,
input = input,
expected = expected,
status = "pending",
actual = nil,
time_ms = nil,
error = nil,
}
end
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)
local cache = require("cp.cache")
cache.load()
local cached_test_cases = cache.get_test_cases(platform, contest_id, problem_id)
if not cached_test_cases or #cached_test_cases == 0 then
return {}
end
if not cached_test_cases or #cached_test_cases == 0 then
return {}
end
local test_cases = {}
for i, test_case in ipairs(cached_test_cases) do
table.insert(
test_cases,
create_test_case(i, test_case.input, test_case.output)
)
end
local test_cases = {}
for i, test_case in ipairs(cached_test_cases) do
table.insert(test_cases, create_test_case(i, test_case.input, test_case.output))
end
return test_cases
return test_cases
end
local function parse_test_cases_from_files(input_file, expected_file)
if
vim.fn.filereadable(input_file) == 0
or vim.fn.filereadable(expected_file) == 0
then
return {}
end
if vim.fn.filereadable(input_file) == 0 or vim.fn.filereadable(expected_file) == 0 then
return {}
end
local input_content = table.concat(vim.fn.readfile(input_file), '\n')
local expected_content = table.concat(vim.fn.readfile(expected_file), '\n')
local input_content = table.concat(vim.fn.readfile(input_file), "\n")
local expected_content = table.concat(vim.fn.readfile(expected_file), "\n")
return { create_test_case(1, input_content, expected_content) }
return { create_test_case(1, input_content, expected_content) }
end
local function run_single_test_case(ctx, contest_config, test_case)
local language = vim.fn.fnamemodify(ctx.source_file, ':e')
local constants = require('cp.constants')
local language_name = constants.filetype_to_language[language]
or contest_config.default_language
local language_config = contest_config[language_name]
local language = vim.fn.fnamemodify(ctx.source_file, ":e")
local constants = require("cp.constants")
local language_name = constants.filetype_to_language[language] or contest_config.default_language
local language_config = contest_config[language_name]
if not language_config then
return {
status = 'fail',
actual = '',
error = 'No language configuration',
time_ms = 0,
}
end
if not language_config then
return {
status = "fail",
actual = "",
error = "No language configuration",
time_ms = 0,
}
end
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 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 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 substitutions = {
source = ctx.source_file,
binary = ctx.binary_file,
version = tostring(language_config.version or ''),
}
local substitutions = {
source = ctx.source_file,
binary = ctx.binary_file,
version = tostring(language_config.version or ""),
}
local run_cmd = build_command(
language_config.run,
language_config.executable,
substitutions
)
local run_cmd = build_command(language_config.run, language_config.executable, substitutions)
local start_time = vim.uv.hrtime()
local result = vim.system(run_cmd, {
stdin = test_case.input .. '\n',
timeout = contest_config.timeout_ms or 2000,
text = true,
}):wait()
local execution_time = (vim.uv.hrtime() - start_time) / 1000000
local start_time = vim.uv.hrtime()
local result = vim.system(run_cmd, {
stdin = test_case.input .. "\n",
timeout = contest_config.timeout_ms or 2000,
text = true,
}):wait()
local execution_time = (vim.uv.hrtime() - start_time) / 1000000
local actual_output = (result.stdout or ''):gsub('\n$', '')
local expected_output = test_case.expected:gsub('\n$', '')
local matches = actual_output == expected_output
local actual_output = (result.stdout or ""):gsub("\n$", "")
local expected_output = test_case.expected:gsub("\n$", "")
local matches = actual_output == expected_output
return {
status = result.code == 0 and matches and 'pass' or 'fail',
actual = actual_output,
error = result.code ~= 0 and result.stderr or nil,
time_ms = execution_time,
}
return {
status = result.code == 0 and matches and "pass" or "fail",
actual = actual_output,
error = result.code ~= 0 and result.stderr or nil,
time_ms = execution_time,
}
end
function M.load_test_cases(ctx, state)
local test_cases = parse_test_cases_from_cache(
state.platform,
state.contest_id,
state.problem_id
)
local test_cases = parse_test_cases_from_cache(state.platform, state.contest_id, state.problem_id)
if #test_cases == 0 then
test_cases =
parse_test_cases_from_files(ctx.input_file, ctx.expected_file)
end
if #test_cases == 0 then
test_cases = parse_test_cases_from_files(ctx.input_file, ctx.expected_file)
end
test_panel_state.test_cases = test_cases
test_panel_state.current_index = 1
test_panel_state.test_cases = test_cases
test_panel_state.current_index = 1
logger.log(('loaded %d test case(s)'):format(#test_cases))
return #test_cases > 0
logger.log(("loaded %d test case(s)"):format(#test_cases))
return #test_cases > 0
end
function M.run_test_case(ctx, contest_config, index)
local test_case = test_panel_state.test_cases[index]
if not test_case then
return false
end
local test_case = test_panel_state.test_cases[index]
if not test_case then
return false
end
logger.log(('running test case %d'):format(index))
test_case.status = 'running'
logger.log(("running test case %d"):format(index))
test_case.status = "running"
local result = run_single_test_case(ctx, contest_config, test_case)
local result = run_single_test_case(ctx, contest_config, test_case)
test_case.status = result.status
test_case.actual = result.actual
test_case.error = result.error
test_case.time_ms = result.time_ms
test_case.status = result.status
test_case.actual = result.actual
test_case.error = result.error
test_case.time_ms = result.time_ms
return true
return true
end
function M.run_all_test_cases(ctx, contest_config)
local results = {}
for i, _ in ipairs(test_panel_state.test_cases) do
M.run_test_case(ctx, contest_config, i)
table.insert(results, test_panel_state.test_cases[i])
end
return results
local results = {}
for i, _ in ipairs(test_panel_state.test_cases) do
M.run_test_case(ctx, contest_config, i)
table.insert(results, test_panel_state.test_cases[i])
end
return results
end
function M.get_test_panel_state()
return test_panel_state
return test_panel_state
end
return M

48
lua/cp/version.lua
View file

@ -1,37 +1,33 @@
local M = {}
local function get_git_version()
local plugin_path = debug.getinfo(1, 'S').source:sub(2)
local plugin_root = vim.fn.fnamemodify(plugin_path, ':h:h:h')
local plugin_path = debug.getinfo(1, "S").source:sub(2)
local plugin_root = vim.fn.fnamemodify(plugin_path, ":h:h:h")
local result = vim.system(
{ 'git', 'describe', '--tags', '--always', '--dirty' },
{
cwd = plugin_root,
text = true,
}
)
:wait()
local result = vim.system({ "git", "describe", "--tags", "--always", "--dirty" }, {
cwd = plugin_root,
text = true,
}):wait()
if result.code == 0 then
return result.stdout:gsub('\n', '')
else
return 'unknown'
end
if result.code == 0 then
return result.stdout:gsub("\n", "")
else
return "unknown"
end
end
local function parse_semver(version_string)
local semver = version_string:match('^v?(%d+%.%d+%.%d+)')
if semver then
local major, minor, patch = semver:match('(%d+)%.(%d+)%.(%d+)')
return {
full = semver,
major = tonumber(major),
minor = tonumber(minor),
patch = tonumber(patch),
}
end
return nil
local semver = version_string:match("^v?(%d+%.%d+%.%d+)")
if semver then
local major, minor, patch = semver:match("(%d+)%.(%d+)%.(%d+)")
return {
full = semver,
major = tonumber(major),
minor = tonumber(minor),
patch = tonumber(patch),
}
end
return nil
end
M.version = get_git_version()

216
lua/cp/window.lua
View file

@ -10,147 +10,139 @@
---@field height integer
local M = {}
local constants = require('cp.constants')
local constants = require("cp.constants")
function M.clearcol()
vim.api.nvim_set_option_value('number', false, { scope = 'local' })
vim.api.nvim_set_option_value('relativenumber', false, { scope = 'local' })
vim.api.nvim_set_option_value('statuscolumn', '', { scope = 'local' })
vim.api.nvim_set_option_value('signcolumn', 'no', { scope = 'local' })
vim.api.nvim_set_option_value('foldcolumn', '0', { scope = 'local' })
vim.api.nvim_set_option_value("number", false, { scope = "local" })
vim.api.nvim_set_option_value("relativenumber", false, { scope = "local" })
vim.api.nvim_set_option_value("statuscolumn", "", { scope = "local" })
vim.api.nvim_set_option_value("signcolumn", "no", { scope = "local" })
vim.api.nvim_set_option_value("foldcolumn", "0", { scope = "local" })
end
---@return WindowState
function M.save_layout()
local windows = {}
for _, win in ipairs(vim.api.nvim_list_wins()) do
if vim.api.nvim_win_is_valid(win) then
local bufnr = vim.api.nvim_win_get_buf(win)
windows[win] = {
bufnr = bufnr,
view = vim.fn.winsaveview(),
width = vim.api.nvim_win_get_width(win),
height = vim.api.nvim_win_get_height(win),
}
end
end
local windows = {}
for _, win in ipairs(vim.api.nvim_list_wins()) do
if vim.api.nvim_win_is_valid(win) then
local bufnr = vim.api.nvim_win_get_buf(win)
windows[win] = {
bufnr = bufnr,
view = vim.fn.winsaveview(),
width = vim.api.nvim_win_get_width(win),
height = vim.api.nvim_win_get_height(win),
}
end
end
return {
windows = windows,
current_win = vim.api.nvim_get_current_win(),
layout = vim.fn.winrestcmd(),
}
return {
windows = windows,
current_win = vim.api.nvim_get_current_win(),
layout = vim.fn.winrestcmd(),
}
end
---@param state? WindowState
---@param tile_fn? fun(source_buf: integer, input_buf: integer, output_buf: integer)
function M.restore_layout(state, tile_fn)
vim.validate({
state = { state, { 'table', 'nil' }, true },
tile_fn = { tile_fn, { 'function', 'nil' }, true },
})
vim.validate({
state = { state, { "table", "nil" }, true },
tile_fn = { tile_fn, { "function", "nil" }, true },
})
if not state then
return
end
if not state then
return
end
vim.cmd.diffoff()
vim.cmd.diffoff()
local problem_id = vim.fn.expand('%:t:r')
if problem_id == '' then
for win, win_state in pairs(state.windows) do
if
vim.api.nvim_win_is_valid(win)
and vim.api.nvim_buf_is_valid(win_state.bufnr)
then
local bufname = vim.api.nvim_buf_get_name(win_state.bufnr)
if
not bufname:match('%.in$')
and not bufname:match('%.out$')
and not bufname:match('%.expected$')
then
problem_id = vim.fn.fnamemodify(bufname, ':t:r')
break
end
end
end
end
local problem_id = vim.fn.expand("%:t:r")
if problem_id == "" then
for win, win_state in pairs(state.windows) do
if vim.api.nvim_win_is_valid(win) and vim.api.nvim_buf_is_valid(win_state.bufnr) then
local bufname = vim.api.nvim_buf_get_name(win_state.bufnr)
if not bufname:match("%.in$") and not bufname:match("%.out$") and not bufname:match("%.expected$") then
problem_id = vim.fn.fnamemodify(bufname, ":t:r")
break
end
end
end
end
if problem_id ~= '' then
vim.cmd('silent only')
if problem_id ~= "" then
vim.cmd("silent only")
local base_fp = vim.fn.getcwd()
local input_file = ('%s/io/%s.in'):format(base_fp, problem_id)
local output_file = ('%s/io/%s.out'):format(base_fp, problem_id)
local source_files = vim.fn.glob(problem_id .. '.*')
local source_file
if source_files ~= '' then
local files = vim.split(source_files, '\n')
local valid_extensions =
vim.tbl_keys(constants.filetype_to_language)
for _, file in ipairs(files) do
local ext = vim.fn.fnamemodify(file, ':e')
if vim.tbl_contains(valid_extensions, ext) then
source_file = file
break
end
end
source_file = source_file or files[1]
end
local base_fp = vim.fn.getcwd()
local input_file = ("%s/io/%s.in"):format(base_fp, problem_id)
local output_file = ("%s/io/%s.out"):format(base_fp, problem_id)
local source_files = vim.fn.glob(problem_id .. ".*")
local source_file
if source_files ~= "" then
local files = vim.split(source_files, "\n")
local valid_extensions = vim.tbl_keys(constants.filetype_to_language)
for _, file in ipairs(files) do
local ext = vim.fn.fnamemodify(file, ":e")
if vim.tbl_contains(valid_extensions, ext) then
source_file = file
break
end
end
source_file = source_file or files[1]
end
if not source_file or vim.fn.filereadable(source_file) == 0 then
return
end
if not source_file or vim.fn.filereadable(source_file) == 0 then
return
end
vim.cmd.edit(source_file)
local source_buf = vim.api.nvim_get_current_buf()
local input_buf = vim.fn.bufnr(input_file, true)
local output_buf = vim.fn.bufnr(output_file, true)
vim.cmd.edit(source_file)
local source_buf = vim.api.nvim_get_current_buf()
local input_buf = vim.fn.bufnr(input_file, true)
local output_buf = vim.fn.bufnr(output_file, true)
if tile_fn then
tile_fn(source_buf, input_buf, output_buf)
else
M.default_tile(source_buf, input_buf, output_buf)
end
else
vim.cmd(state.layout)
if tile_fn then
tile_fn(source_buf, input_buf, output_buf)
else
M.default_tile(source_buf, input_buf, output_buf)
end
else
vim.cmd(state.layout)
for win, win_state in pairs(state.windows) do
if vim.api.nvim_win_is_valid(win) then
vim.api.nvim_set_current_win(win)
if vim.api.nvim_get_current_buf() == win_state.bufnr then
vim.fn.winrestview(win_state.view)
end
end
end
for win, win_state in pairs(state.windows) do
if vim.api.nvim_win_is_valid(win) then
vim.api.nvim_set_current_win(win)
if vim.api.nvim_get_current_buf() == win_state.bufnr then
vim.fn.winrestview(win_state.view)
end
end
end
if vim.api.nvim_win_is_valid(state.current_win) then
vim.api.nvim_set_current_win(state.current_win)
end
end
if vim.api.nvim_win_is_valid(state.current_win) then
vim.api.nvim_set_current_win(state.current_win)
end
end
end
---@param source_buf integer
---@param input_buf integer
---@param output_buf integer
local function default_tile(source_buf, input_buf, output_buf)
vim.validate({
source_buf = { source_buf, 'number' },
input_buf = { input_buf, 'number' },
output_buf = { output_buf, 'number' },
})
vim.validate({
source_buf = { source_buf, "number" },
input_buf = { input_buf, "number" },
output_buf = { output_buf, "number" },
})
vim.api.nvim_set_current_buf(source_buf)
vim.cmd.vsplit()
vim.api.nvim_set_current_buf(output_buf)
vim.bo.filetype = 'cp'
M.clearcol()
vim.cmd(('vertical resize %d'):format(math.floor(vim.o.columns * 0.3)))
vim.cmd.split()
vim.api.nvim_set_current_buf(input_buf)
vim.bo.filetype = 'cp'
M.clearcol()
vim.cmd.wincmd('h')
vim.api.nvim_set_current_buf(source_buf)
vim.cmd.vsplit()
vim.api.nvim_set_current_buf(output_buf)
vim.bo.filetype = "cp"
M.clearcol()
vim.cmd(("vertical resize %d"):format(math.floor(vim.o.columns * 0.3)))
vim.cmd.split()
vim.api.nvim_set_current_buf(input_buf)
vim.bo.filetype = "cp"
M.clearcol()
vim.cmd.wincmd("h")
end
M.default_tile = default_tile