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

4
after/ftplugin/cp.lua
View file

@ -1,6 +1,6 @@
vim.opt_local.number = false vim.opt_local.number = false
vim.opt_local.relativenumber = false vim.opt_local.relativenumber = false
vim.opt_local.statuscolumn = '' vim.opt_local.statuscolumn = ""
vim.opt_local.signcolumn = 'no' vim.opt_local.signcolumn = "no"
vim.opt_local.wrap = true vim.opt_local.wrap = true
vim.opt_local.linebreak = true vim.opt_local.linebreak = true

4
after/ftplugin/cpin.lua
View file

@ -1,6 +1,6 @@
vim.opt_local.number = false vim.opt_local.number = false
vim.opt_local.relativenumber = false vim.opt_local.relativenumber = false
vim.opt_local.statuscolumn = '' vim.opt_local.statuscolumn = ""
vim.opt_local.signcolumn = 'no' vim.opt_local.signcolumn = "no"
vim.opt_local.wrap = true vim.opt_local.wrap = true
vim.opt_local.linebreak = true vim.opt_local.linebreak = true

4
after/ftplugin/cpout.lua
View file

@ -1,7 +1,7 @@
vim.opt_local.number = false vim.opt_local.number = false
vim.opt_local.relativenumber = false vim.opt_local.relativenumber = false
vim.opt_local.statuscolumn = '' vim.opt_local.statuscolumn = ""
vim.opt_local.signcolumn = 'no' vim.opt_local.signcolumn = "no"
vim.opt_local.wrap = true vim.opt_local.wrap = true
vim.opt_local.linebreak = true vim.opt_local.linebreak = true
vim.opt_local.modifiable = true vim.opt_local.modifiable = true

8
ftdetect/cp.lua
View file

@ -1,6 +1,6 @@
vim.filetype.add({ vim.filetype.add({
extension = { extension = {
cpin = 'cpin', cpin = "cpin",
cpout = 'cpout', cpout = "cpout",
}, },
}) })

204
lua/cp/cache.lua
View file

@ -18,129 +18,129 @@
local M = {} 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 = {} local cache_data = {}
---@param platform string ---@param platform string
---@return number? ---@return number?
local function get_expiry_date(platform) local function get_expiry_date(platform)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
}) })
if platform == 'cses' then if platform == "cses" then
return os.time() + (30 * 24 * 60 * 60) return os.time() + (30 * 24 * 60 * 60)
end end
return nil return nil
end end
---@param contest_data ContestData ---@param contest_data ContestData
---@param platform string ---@param platform string
---@return boolean ---@return boolean
local function is_cache_valid(contest_data, platform) local function is_cache_valid(contest_data, platform)
vim.validate({ vim.validate({
contest_data = { contest_data, 'table' }, contest_data = { contest_data, "table" },
platform = { platform, 'string' }, platform = { platform, "string" },
}) })
if platform ~= 'cses' then if platform ~= "cses" then
return true return true
end end
local expires_at = contest_data.expires_at local expires_at = contest_data.expires_at
if not expires_at then if not expires_at then
return false return false
end end
return os.time() < expires_at return os.time() < expires_at
end end
function M.load() function M.load()
if vim.fn.filereadable(cache_file) == 0 then if vim.fn.filereadable(cache_file) == 0 then
cache_data = {} cache_data = {}
return return
end end
local content = vim.fn.readfile(cache_file) local content = vim.fn.readfile(cache_file)
if #content == 0 then if #content == 0 then
cache_data = {} cache_data = {}
return return
end end
local ok, decoded = pcall(vim.json.decode, table.concat(content, '\n')) local ok, decoded = pcall(vim.json.decode, table.concat(content, "\n"))
if ok then if ok then
cache_data = decoded cache_data = decoded
else else
cache_data = {} cache_data = {}
end end
end end
function M.save() function M.save()
vim.fn.mkdir(vim.fn.fnamemodify(cache_file, ':h'), 'p') vim.fn.mkdir(vim.fn.fnamemodify(cache_file, ":h"), "p")
local encoded = vim.json.encode(cache_data) local encoded = vim.json.encode(cache_data)
vim.fn.writefile(vim.split(encoded, '\n'), cache_file) vim.fn.writefile(vim.split(encoded, "\n"), cache_file)
end end
---@param platform string ---@param platform string
---@param contest_id string ---@param contest_id string
---@return ContestData? ---@return ContestData?
function M.get_contest_data(platform, contest_id) function M.get_contest_data(platform, contest_id)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
}) })
if not cache_data[platform] then if not cache_data[platform] then
return nil return nil
end end
local contest_data = cache_data[platform][contest_id] local contest_data = cache_data[platform][contest_id]
if not contest_data then if not contest_data then
return nil return nil
end end
if not is_cache_valid(contest_data, platform) then if not is_cache_valid(contest_data, platform) then
return nil return nil
end end
return contest_data return contest_data
end end
---@param platform string ---@param platform string
---@param contest_id string ---@param contest_id string
---@param problems Problem[] ---@param problems Problem[]
function M.set_contest_data(platform, contest_id, problems) function M.set_contest_data(platform, contest_id, problems)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
problems = { problems, 'table' }, problems = { problems, "table" },
}) })
if not cache_data[platform] then if not cache_data[platform] then
cache_data[platform] = {} cache_data[platform] = {}
end end
cache_data[platform][contest_id] = { cache_data[platform][contest_id] = {
problems = problems, problems = problems,
scraped_at = os.date('%Y-%m-%d'), scraped_at = os.date("%Y-%m-%d"),
expires_at = get_expiry_date(platform), expires_at = get_expiry_date(platform),
} }
M.save() M.save()
end end
---@param platform string ---@param platform string
---@param contest_id string ---@param contest_id string
function M.clear_contest_data(platform, contest_id) function M.clear_contest_data(platform, contest_id)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
}) })
if cache_data[platform] and cache_data[platform][contest_id] then if cache_data[platform] and cache_data[platform][contest_id] then
cache_data[platform][contest_id] = nil cache_data[platform][contest_id] = nil
M.save() M.save()
end end
end end
---@param platform string ---@param platform string
@ -148,18 +148,17 @@ end
---@param problem_id? string ---@param problem_id? string
---@return TestCase[]? ---@return TestCase[]?
function M.get_test_cases(platform, contest_id, problem_id) function M.get_test_cases(platform, contest_id, problem_id)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
problem_id = { problem_id, { 'string', 'nil' }, true }, problem_id = { problem_id, { "string", "nil" }, true },
}) })
local problem_key = problem_id and (contest_id .. '_' .. problem_id) local problem_key = problem_id and (contest_id .. "_" .. problem_id) or contest_id
or contest_id if not cache_data[platform] or not cache_data[platform][problem_key] then
if not cache_data[platform] or not cache_data[platform][problem_key] then return nil
return nil end
end return cache_data[platform][problem_key].test_cases
return cache_data[platform][problem_key].test_cases
end end
---@param platform string ---@param platform string
@ -167,25 +166,24 @@ end
---@param problem_id? string ---@param problem_id? string
---@param test_cases TestCase[] ---@param test_cases TestCase[]
function M.set_test_cases(platform, contest_id, problem_id, test_cases) function M.set_test_cases(platform, contest_id, problem_id, test_cases)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
problem_id = { problem_id, { 'string', 'nil' }, true }, problem_id = { problem_id, { "string", "nil" }, true },
test_cases = { test_cases, 'table' }, test_cases = { test_cases, "table" },
}) })
local problem_key = problem_id and (contest_id .. '_' .. problem_id) local problem_key = problem_id and (contest_id .. "_" .. problem_id) or contest_id
or contest_id if not cache_data[platform] then
if not cache_data[platform] then cache_data[platform] = {}
cache_data[platform] = {} end
end if not cache_data[platform][problem_key] then
if not cache_data[platform][problem_key] then cache_data[platform][problem_key] = {}
cache_data[platform][problem_key] = {} end
end
cache_data[platform][problem_key].test_cases = test_cases cache_data[platform][problem_key].test_cases = test_cases
cache_data[platform][problem_key].test_cases_cached_at = os.time() cache_data[platform][problem_key].test_cases_cached_at = os.time()
M.save() M.save()
end end
return M 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 ---@field filename? fun(contest: string, contest_id: string, problem_id?: string, config: cp.Config, language?: string): string
local M = {} local M = {}
local constants = require('cp.constants') local constants = require("cp.constants")
---@type cp.Config ---@type cp.Config
M.defaults = { M.defaults = {
contests = {}, contests = {},
snippets = {}, snippets = {},
hooks = { hooks = {
before_run = nil, before_run = nil,
before_debug = nil, before_debug = nil,
setup_code = nil, setup_code = nil,
}, },
debug = false, debug = false,
tile = nil, tile = nil,
filename = nil, filename = nil,
} }
---@param user_config cp.UserConfig|nil ---@param user_config cp.UserConfig|nil
---@return cp.Config ---@return cp.Config
function M.setup(user_config) function M.setup(user_config)
vim.validate({ vim.validate({
user_config = { user_config, { 'table', 'nil' }, true }, user_config = { user_config, { "table", "nil" }, true },
}) })
if user_config then if user_config then
vim.validate({ vim.validate({
contests = { user_config.contests, { 'table', 'nil' }, true }, contests = { user_config.contests, { "table", "nil" }, true },
snippets = { user_config.snippets, { 'table', 'nil' }, true }, snippets = { user_config.snippets, { "table", "nil" }, true },
hooks = { user_config.hooks, { 'table', 'nil' }, true }, hooks = { user_config.hooks, { "table", "nil" }, true },
debug = { user_config.debug, { 'boolean', 'nil' }, true }, debug = { user_config.debug, { "boolean", "nil" }, true },
tile = { user_config.tile, { 'function', 'nil' }, true }, tile = { user_config.tile, { "function", "nil" }, true },
filename = { user_config.filename, { 'function', 'nil' }, true }, filename = { user_config.filename, { "function", "nil" }, true },
}) })
if user_config.hooks then if user_config.hooks then
vim.validate({ vim.validate({
before_run = { before_run = {
user_config.hooks.before_run, user_config.hooks.before_run,
{ 'function', 'nil' }, { "function", "nil" },
true, true,
}, },
before_debug = { before_debug = {
user_config.hooks.before_debug, user_config.hooks.before_debug,
{ 'function', 'nil' }, { "function", "nil" },
true, true,
}, },
setup_code = { setup_code = {
user_config.hooks.setup_code, user_config.hooks.setup_code,
{ 'function', 'nil' }, { "function", "nil" },
true, true,
}, },
}) })
end end
if user_config.contests then if user_config.contests then
for contest_name, contest_config in pairs(user_config.contests) do for contest_name, contest_config in pairs(user_config.contests) do
for lang_name, lang_config in pairs(contest_config) do for lang_name, lang_config in pairs(contest_config) do
if if type(lang_config) == "table" and lang_config.extension then
type(lang_config) == 'table' and lang_config.extension if
then not vim.tbl_contains(vim.tbl_keys(constants.filetype_to_language), lang_config.extension)
if then
not vim.tbl_contains( error(
vim.tbl_keys(constants.filetype_to_language), ("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format(
lang_config.extension lang_config.extension,
) lang_name,
then contest_name,
error( table.concat(vim.tbl_keys(constants.filetype_to_language), ", ")
("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format( )
lang_config.extension, )
lang_name, end
contest_name, end
table.concat( end
vim.tbl_keys( end
constants.filetype_to_language end
), end
', '
)
)
)
end
end
end
end
end
end
local config = vim.tbl_deep_extend('force', M.defaults, user_config or {}) local config = vim.tbl_deep_extend("force", M.defaults, user_config or {})
return config return config
end end
---@param contest_id string ---@param contest_id string
---@param problem_id? string ---@param problem_id? string
---@return string ---@return string
local function default_filename(contest_id, problem_id) local function default_filename(contest_id, problem_id)
vim.validate({ vim.validate({
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
problem_id = { problem_id, { 'string', 'nil' }, true }, problem_id = { problem_id, { "string", "nil" }, true },
}) })
if problem_id then if problem_id then
return problem_id:lower() return problem_id:lower()
else else
return contest_id:lower() return contest_id:lower()
end end
end end
M.default_filename = default_filename M.default_filename = default_filename

22
lua/cp/constants.lua
View file

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

395
lua/cp/execute.lua
View file

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

136
lua/cp/health.lua
View file

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

743
lua/cp/init.lua
View file

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

10
lua/cp/log.lua
View file

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

89
lua/cp/problem.lua
View file

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

402
lua/cp/scrape.lua
View file

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

103
lua/cp/snippets.lua
View file

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

243
lua/cp/test.lua
View file

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

48
lua/cp/version.lua
View file

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

216
lua/cp/window.lua
View file

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

149
plugin/cp.lua
View file

@ -1,89 +1,88 @@
if vim.g.loaded_cp then if vim.g.loaded_cp then
return return
end end
vim.g.loaded_cp = 1 vim.g.loaded_cp = 1
local constants = require('cp.constants') local constants = require("cp.constants")
local platforms = constants.PLATFORMS local platforms = constants.PLATFORMS
local actions = constants.ACTIONS local actions = constants.ACTIONS
vim.api.nvim_create_user_command('CP', function(opts) vim.api.nvim_create_user_command("CP", function(opts)
local cp = require('cp') local cp = require("cp")
cp.handle_command(opts) cp.handle_command(opts)
end, { end, {
nargs = '*', nargs = "*",
desc = 'Competitive programming helper', desc = "Competitive programming helper",
complete = function(ArgLead, CmdLine, _) complete = function(ArgLead, CmdLine, _)
local languages = vim.tbl_keys(constants.canonical_filetypes) local languages = vim.tbl_keys(constants.canonical_filetypes)
if ArgLead:match('^--lang=') then if ArgLead:match("^--lang=") then
local lang_completions = {} local lang_completions = {}
for _, lang in ipairs(languages) do for _, lang in ipairs(languages) do
table.insert(lang_completions, '--lang=' .. lang) table.insert(lang_completions, "--lang=" .. lang)
end end
return vim.tbl_filter(function(completion) return vim.tbl_filter(function(completion)
return completion:find(ArgLead, 1, true) == 1 return completion:find(ArgLead, 1, true) == 1
end, lang_completions) end, lang_completions)
end end
if ArgLead:match('^%-') and not ArgLead:match('^--lang') then if ArgLead:match("^%-") and not ArgLead:match("^--lang") then
return vim.tbl_filter(function(completion) return vim.tbl_filter(function(completion)
return completion:find(ArgLead, 1, true) == 1 return completion:find(ArgLead, 1, true) == 1
end, { '--lang' }) end, { "--lang" })
end end
local args = vim.split(vim.trim(CmdLine), '%s+') local args = vim.split(vim.trim(CmdLine), "%s+")
local num_args = #args local num_args = #args
if CmdLine:sub(-1) == ' ' then if CmdLine:sub(-1) == " " then
num_args = num_args + 1 num_args = num_args + 1
end end
local lang_flag_present = vim.tbl_contains(args, '--lang') local lang_flag_present = vim.tbl_contains(args, "--lang")
or vim.iter(args):any(function(arg) or vim.iter(args):any(function(arg)
return arg:match('^--lang=') return arg:match("^--lang=")
end) end)
if num_args == 2 then if num_args == 2 then
local candidates = { '--lang' } local candidates = { "--lang" }
vim.list_extend(candidates, actions) vim.list_extend(candidates, actions)
local cp = require('cp') local cp = require("cp")
local context = cp.get_current_context() local context = cp.get_current_context()
if context.platform and context.contest_id then if context.platform and context.contest_id then
local cache = require('cp.cache') local cache = require("cp.cache")
cache.load() cache.load()
local contest_data = local contest_data = cache.get_contest_data(context.platform, context.contest_id)
cache.get_contest_data(context.platform, context.contest_id) if contest_data and contest_data.problems then
if contest_data and contest_data.problems then for _, problem in ipairs(contest_data.problems) do
for _, problem in ipairs(contest_data.problems) do table.insert(candidates, problem.id)
table.insert(candidates, problem.id) end
end end
end else
else vim.list_extend(candidates, platforms)
vim.list_extend(candidates, platforms) end
end return vim.tbl_filter(function(cmd)
return vim.tbl_filter(function(cmd) return cmd:find(ArgLead, 1, true) == 1
return cmd:find(ArgLead, 1, true) == 1 end, candidates)
end, candidates) elseif args[#args - 1] == "--lang" then
elseif args[#args - 1] == '--lang' then return vim.tbl_filter(function(lang)
return vim.tbl_filter(function(lang) return lang:find(ArgLead, 1, true) == 1
return lang:find(ArgLead, 1, true) == 1 end, languages)
end, languages) elseif num_args == 4 and not lang_flag_present then
elseif num_args == 4 and not lang_flag_present then if vim.tbl_contains(platforms, args[2]) then
if vim.tbl_contains(platforms, args[2]) then local cache = require("cp.cache")
local cache = require('cp.cache') cache.load()
cache.load() local contest_data = cache.get_contest_data(args[2], args[3])
local contest_data = cache.get_contest_data(args[2], args[3]) if contest_data and contest_data.problems then
if contest_data and contest_data.problems then local candidates = { "--lang" }
local candidates = { '--lang' } for _, problem in ipairs(contest_data.problems) do
for _, problem in ipairs(contest_data.problems) do table.insert(candidates, problem.id)
table.insert(candidates, problem.id) end
end return vim.tbl_filter(function(cmd)
return vim.tbl_filter(function(cmd) return cmd:find(ArgLead, 1, true) == 1
return cmd:find(ArgLead, 1, true) == 1 end, candidates)
end, candidates) end
end end
end end
end return {}
return {} end,
end,
}) })

4
stylua.toml
View file

@ -1,4 +0,0 @@
quote_style = "AutoPreferSingle"
indent_type = "Spaces"
column_width = 80
collapse_simple_statement = "Never"