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

feat(ci): use new stylua config

Browse source
This commit is contained in:
Barrett Ruth 2025-09-15 18:10:11 -04:00
parent c06a0d8a84
commit fe4cf2b680
20 changed files with 1581 additions and 1328 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,17 +148,18 @@ 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) or contest_id local problem_key = problem_id and (contest_id .. '_' .. problem_id)
if not cache_data[platform] or not cache_data[platform][problem_key] then or contest_id
return nil if not cache_data[platform] or not cache_data[platform][problem_key] then
end return nil
return cache_data[platform][problem_key].test_cases end
return cache_data[platform][problem_key].test_cases
end end
---@param platform string ---@param platform string
@ -166,24 +167,25 @@ 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) or contest_id local problem_key = problem_id and (contest_id .. '_' .. problem_id)
if not cache_data[platform] then or contest_id
cache_data[platform] = {} if not cache_data[platform] then
end cache_data[platform] = {}
if not cache_data[platform][problem_key] then end
cache_data[platform][problem_key] = {} if not cache_data[platform][problem_key] then
end cache_data[platform][problem_key] = {}
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

146
lua/cp/config.lua
View file

@ -48,87 +48,109 @@
---@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 languages = require("cp.languages") 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 = { user_config.hooks.before_run, { "function", "nil" }, true }, before_run = {
before_debug = { user_config.hooks.before_debug, { "function", "nil" }, true }, user_config.hooks.before_run,
setup_code = { user_config.hooks.setup_code, { "function", "nil" }, true }, { 'function', 'nil' },
}) true,
end },
before_debug = {
user_config.hooks.before_debug,
{ 'function', 'nil' },
true,
},
setup_code = {
user_config.hooks.setup_code,
{ 'function', 'nil' },
true,
},
})
end
if user_config.contests then 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 type(lang_config) == "table" and lang_config.extension then if
if type(lang_config) == 'table' and lang_config.extension
not vim.tbl_contains(vim.tbl_keys(languages.filetype_to_language), lang_config.extension) then
then if
error( not vim.tbl_contains(
("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format( vim.tbl_keys(constants.filetype_to_language),
lang_config.extension, lang_config.extension
lang_name, )
contest_name, then
table.concat(vim.tbl_keys(languages.filetype_to_language), ", ") error(
) ("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format(
) lang_config.extension,
end lang_name,
end contest_name,
end table.concat(
end vim.tbl_keys(
end constants.filetype_to_language
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,44 +6,47 @@
---@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] or contest_config.default_language local language = filetype_to_language[extension]
logger.log(("detected language: %s (extension: %s)"):format(language, extension)) or contest_config.default_language
return language logger.log(
('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[]
@ -51,69 +54,76 @@ 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 = substitute_template(language_config.compile, substitutions) local compile_cmd =
logger.log(("compiling: %s"):format(table.concat(compile_cmd, " "))) substitute_template(language_config.compile, substitutions)
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(("compilation failed (%.1fms): %s"):format(compile_time, result.stderr), vim.log.levels.WARN) logger.log(
end ('compilation failed (%.1fms): %s'):format(
compile_time,
result.stderr
),
vim.log.levels.WARN
)
end
return result return result
end end
---@param cmd string[] ---@param cmd string[]
@ -121,42 +131,51 @@ 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(("execution timed out after %.1fms"):format(execution_time), vim.log.levels.WARN) logger.log(
elseif actual_code ~= 0 then ('execution timed out after %.1fms'):format(execution_time),
logger.log(("execution failed (exit code %d, %.1fms)"):format(actual_code, execution_time), vim.log.levels.WARN) vim.log.levels.WARN
else )
logger.log(("execution successful (%.1fms)"):format(execution_time)) elseif actual_code ~= 0 then
end logger.log(
('execution failed (exit code %d, %.1fms)'):format(
actual_code,
execution_time
),
vim.log.levels.WARN
)
else
logger.log(('execution successful (%.1fms)'):format(execution_time))
end
return { 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
@ -164,104 +183,134 @@ 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(metadata_lines, ("[code]: %d (%s)"):format(exec_result.code, signal_name)) table.insert(
else metadata_lines,
table.insert(metadata_lines, ("[code]: %d"):format(exec_result.code)) ('[code]: %d (%s)'):format(exec_result.code, signal_name)
end )
else
table.insert(metadata_lines, ('[code]: %d'):format(exec_result.code))
end
table.insert(metadata_lines, ("[time]: %.2f ms"):format(exec_result.time_ms)) table.insert(
table.insert(metadata_lines, ("[debug]: %s"):format(is_debug and "true" or "false")) metadata_lines,
('[time]: %.2f ms'):format(exec_result.time_ms)
)
table.insert(
metadata_lines,
('[debug]: %s'):format(is_debug and 'true' or 'false')
)
if vim.fn.filereadable(expected_file) == 1 and exec_result.code == 0 then 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(metadata_lines, ("[matches]: %s"):format(matches and "true" or "false")) table.insert(
end metadata_lines,
('[matches]: %s'):format(matches and 'true' or 'false')
)
end
return table.concat(output_lines, "") .. "\n" .. table.concat(metadata_lines, "\n") return table.concat(output_lines, '')
.. '\n'
.. table.concat(metadata_lines, '\n')
end 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({ "Error: No configuration for language: " .. language }, ctx.output_file) vim.fn.writefile(
return { 'Error: No configuration for language: ' .. language },
end ctx.output_file
)
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 or language_config.compile local compile_cmd = is_debug and language_config.debug
if compile_cmd then or language_config.compile
local compile_result = compile_generic(language_config, substitutions) if compile_cmd then
if compile_result.code ~= 0 then local compile_result = compile_generic(language_config, substitutions)
vim.fn.writefile({ compile_result.stderr }, ctx.output_file) if compile_result.code ~= 0 then
return vim.fn.writefile({ compile_result.stderr }, ctx.output_file)
end return
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(language_config.run, language_config.executable, substitutions) local run_cmd = build_command(
local exec_result = execute_command(run_cmd, input_data, contest_config.timeout_ms) language_config.run,
local formatted_output = format_output(exec_result, ctx.expected_file, is_debug) language_config.executable,
substitutions
)
local exec_result =
execute_command(run_cmd, input_data, contest_config.timeout_ms)
local formatted_output =
format_output(exec_result, ctx.expected_file, is_debug)
local output_buf = vim.fn.bufnr(ctx.output_file) 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(output_buf, 0, -1, false, vim.split(formatted_output, "\n")) vim.api.nvim_buf_set_lines(
vim.api.nvim_buf_call(output_buf, function() output_buf,
vim.cmd.write() 0,
end) -1,
else false,
vim.fn.writefile(vim.split(formatted_output, "\n"), ctx.output_file) vim.split(formatted_output, '\n')
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,95 +1,101 @@
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("uv not found - install from https://docs.astral.sh/uv/ for problem scraping") vim.health.warn(
end 'uv not found - install from https://docs.astral.sh/uv/ for problem scraping'
)
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("Python virtual environment not set up - run :CP command to initialize") vim.health.warn(
end 'Python virtual environment not set up - run :CP command to initialize'
)
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("LuaSnip not available - template expansion will be limited") vim.health.info(
end 'LuaSnip not available - template expansion will be limited'
)
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

729
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,409 +20,500 @@ 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(("unknown platform. Available: [%s]"):format(table.concat(platforms, ", ")), vim.log.levels.ERROR) logger.log(
return false ('unknown platform. Available: [%s]'):format(
end table.concat(platforms, ', ')
),
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("no platform set. run :CP <platform> <contest> first", vim.log.levels.ERROR) logger.log(
return 'no platform set. run :CP <platform> <contest> first',
end vim.log.levels.ERROR
)
return
end
local problem_name = state.platform == "cses" and contest_id or (contest_id .. (problem_id or "")) local problem_name = state.platform == 'cses' and contest_id
logger.log(("setting up problem: %s"):format(problem_name)) or (contest_id .. (problem_id or ''))
logger.log(('setting up problem: %s'):format(problem_name))
local metadata_result = scrape.scrape_contest_metadata(state.platform, contest_id) local metadata_result =
if not metadata_result.success then scrape.scrape_contest_metadata(state.platform, contest_id)
logger.log( if not metadata_result.success then
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"), logger.log(
vim.log.levels.WARN 'failed to load contest metadata: '
) .. (metadata_result.error or 'unknown error'),
end vim.log.levels.WARN
)
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 = cache.get_test_cases(state.platform, contest_id, problem_id) local cached_test_cases =
if cached_test_cases then cache.get_test_cases(state.platform, contest_id, problem_id)
state.test_cases = cached_test_cases if cached_test_cases then
end state.test_cases = cached_test_cases
end
local scrape_ctx = problem.create_context(state.platform, contest_id, problem_id, config, language) local scrape_ctx = problem.create_context(
state.platform,
contest_id,
problem_id,
config,
language
)
local scrape_result = scrape.scrape_problem(scrape_ctx) local scrape_result = scrape.scrape_problem(scrape_ctx)
if not scrape_result.success then if not scrape_result.success then
logger.log("scraping failed: " .. (scrape_result.error or "unknown error"), vim.log.levels.WARN) logger.log(
logger.log("you can manually add test cases to io/ directory", vim.log.levels.INFO) 'scraping failed: ' .. (scrape_result.error or 'unknown error'),
state.test_cases = nil vim.log.levels.WARN
else )
local test_count = scrape_result.test_count or 0 logger.log(
logger.log(("scraped %d test case(s) for %s"):format(test_count, scrape_result.problem_id)) 'you can manually add test cases to io/ directory',
state.test_cases = scrape_result.test_cases vim.log.levels.INFO
)
state.test_cases = nil
else
local test_count = scrape_result.test_count or 0
logger.log(
('scraped %d test case(s) for %s'):format(
test_count,
scrape_result.problem_id
)
)
state.test_cases = scrape_result.test_cases
if scrape_result.test_cases then if scrape_result.test_cases then
cache.set_test_cases(state.platform, contest_id, problem_id, scrape_result.test_cases) cache.set_test_cases(
end state.platform,
end contest_id,
problem_id,
scrape_result.test_cases
)
end
end
vim.cmd.e(scrape_ctx.source_file) vim.cmd.e(scrape_ctx.source_file)
if vim.api.nvim_buf_get_lines(0, 0, -1, true)[1] == "" then 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(state.platform, language) local prefixed_trigger = ('cp.nvim/%s.%s'):format(
state.platform,
language
)
vim.api.nvim_buf_set_lines(0, 0, -1, false, { prefixed_trigger }) vim.api.nvim_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(state.platform, state.contest_id, state.problem_id, config, language) local ctx = problem.create_context(
state.platform,
state.contest_id,
state.problem_id,
config,
language
)
if config.hooks and config.hooks.setup_code then 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(state.platform, state.contest_id, state.problem_id, config) local ctx = problem.create_context(
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(state.platform, state.contest_id, state.problem_id, config) local ctx = problem.create_context(
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("no contest set. run :CP <platform> <contest> first", vim.log.levels.ERROR) logger.log(
return 'no contest set. run :CP <platform> <contest> first',
end vim.log.levels.ERROR
)
return
end
cache.load() cache.load()
local contest_data = cache.get_contest_data(state.platform, state.contest_id) local contest_data =
if not contest_data or not contest_data.problems then cache.get_contest_data(state.platform, state.contest_id)
logger.log("no contest metadata found. set up a problem first to cache contest data", vim.log.levels.ERROR) if not contest_data or not contest_data.problems then
return logger.log(
end 'no contest metadata found. set up a problem first to cache contest data',
vim.log.levels.ERROR
)
return
end
local problems = contest_data.problems local 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(("no %s problem available"):format(direction), vim.log.levels.INFO) logger.log(
return ('no %s problem available'):format(direction),
end vim.log.levels.INFO
)
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 { type = "platform_only", platform = first, language = language } return {
elseif #filtered_args == 2 then type = 'platform_only',
if first == "cses" then platform = first,
return { type = "cses_problem", platform = first, problem = filtered_args[2], language = language } language = language,
else }
return { type = "contest_setup", platform = first, contest = filtered_args[2], language = language } elseif #filtered_args == 2 then
end if first == 'cses' then
elseif #filtered_args == 3 then return {
return { type = 'cses_problem',
type = "full_setup", platform = first,
platform = first, problem = filtered_args[2],
contest = filtered_args[2], language = language,
problem = filtered_args[3], }
language = language, else
} return {
else type = 'contest_setup',
return { type = "error", message = "Too many arguments" } platform = first,
end contest = filtered_args[2],
end language = language,
}
end
elseif #filtered_args == 3 then
return {
type = 'full_setup',
platform = first,
contest = filtered_args[2],
problem = filtered_args[3],
language = language,
}
else
return { type = 'error', message = 'Too many arguments' }
end
end
if state.platform and state.contest_id then 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 = scrape.scrape_contest_metadata(cmd.platform, cmd.contest) local metadata_result =
if not metadata_result.success then scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
logger.log( if not metadata_result.success then
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"), logger.log(
vim.log.levels.WARN 'failed to load contest metadata: '
) .. (metadata_result.error or 'unknown error'),
else vim.log.levels.WARN
logger.log( )
("loaded %d problems for %s %s"):format(#metadata_result.problems, cmd.platform, cmd.contest) else
) logger.log(
end ('loaded %d problems for %s %s'):format(
end #metadata_result.problems,
return cmd.platform,
end cmd.contest
)
)
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 = scrape.scrape_contest_metadata(cmd.platform, cmd.contest) local metadata_result =
if not metadata_result.success then scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
logger.log( if not metadata_result.success then
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"), logger.log(
vim.log.levels.WARN 'failed to load contest metadata: '
) .. (metadata_result.error or 'unknown error'),
else vim.log.levels.WARN
logger.log( )
("loaded %d problems for %s %s"):format(#metadata_result.problems, cmd.platform, cmd.contest) else
) logger.log(
end ('loaded %d problems for %s %s'):format(
#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 = scrape.scrape_contest_metadata(cmd.platform, "") local metadata_result =
if not metadata_result.success then scrape.scrape_contest_metadata(cmd.platform, '')
logger.log( if not metadata_result.success then
"failed to load contest metadata: " .. (metadata_result.error or "unknown error"), logger.log(
vim.log.levels.WARN 'failed to load contest metadata: '
) .. (metadata_result.error or 'unknown error'),
end vim.log.levels.WARN
setup_problem(cmd.problem, nil, cmd.language) )
end end
return setup_problem(cmd.problem, nil, cmd.language)
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

21
lua/cp/languages.lua
View file

@ -1,21 +0,0 @@
local M = {}
M.CPP = "cpp"
M.PYTHON = "python"
---@type table<string, string>
M.filetype_to_language = {
cc = M.CPP,
cxx = M.CPP,
cpp = M.CPP,
py = M.PYTHON,
py3 = M.PYTHON,
}
---@type table<string, string>
M.canonical_filetypes = {
[M.CPP] = "cpp",
[M.PYTHON] = "python",
}
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,50 +18,61 @@ 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(("No language config found for '%s' in contest '%s'"):format(target_language, contest)) error(
end ("No language config found for '%s' in contest '%s'"):format(
if not language_config.extension then target_language,
error(("No extension configured for language '%s' in contest '%s'"):format(target_language, contest)) 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 = config.filename(contest, contest_id, problem_id, config, language) local source_file =
base_name = vim.fn.fnamemodify(source_file, ":t:r") config.filename(contest, contest_id, problem_id, config, language)
else base_name = vim.fn.fnamemodify(source_file, ':t:r')
local default_filename = require("cp.config").default_filename else
base_name = default_filename(contest_id, problem_id) local default_filename = require('cp.config').default_filename
end base_name = default_filename(contest_id, problem_id)
end
local source_file = base_name .. "." .. language_config.extension local source_file = base_name .. '.' .. language_config.extension
return { 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

370
lua/cp/scrape.lua
View file

@ -1,213 +1,265 @@
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({ "ping", "-c", "1", "-W", "3", "8.8.8.8" }, { text = true }):wait() local result = vim.system(
return result.code == 0 { 'ping', '-c', '1', '-W', '3', '8.8.8.8' },
{ 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({ "uv", "sync" }, { cwd = plugin_path, text = true }):wait() local result = vim.system(
if result.code ~= 0 then { 'uv', 'sync' },
logger.log("failed to setup Python environment: " .. result.stderr, vim.log.levels.ERROR) { cwd = plugin_path, text = true }
return false )
end :wait()
logger.log("python environment setup complete") if result.code ~= 0 then
end logger.log(
'failed to setup Python environment: ' .. result.stderr,
vim.log.levels.ERROR
)
return false
end
logger.log('python environment setup complete')
end
return true return true
end 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 = { "uv", "run", "--directory", plugin_path, scraper_path, "metadata" } args = {
else 'uv',
args = { "uv", "run", "--directory", plugin_path, scraper_path, "metadata", contest_id } 'run',
end '--directory',
plugin_path,
scraper_path,
'metadata',
}
else
args = {
'uv',
'run',
'--directory',
plugin_path,
scraper_path,
'metadata',
contest_id,
}
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: " .. (result.stderr or "Unknown error"), error = 'Failed to run metadata scraper: '
} .. (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: " .. tostring(data), error = 'Failed to parse metadata scraper output: '
} .. 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"] or {} problems_list = data.categories and data.categories['CSES Problem Set']
else or {}
problems_list = data.problems or {} else
end problems_list = data.problems or {}
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 vim.fn.filereadable(ctx.input_file) == 1 and vim.fn.filereadable(ctx.expected_file) == 1 then if
return { vim.fn.filereadable(ctx.input_file) == 1
success = true, and vim.fn.filereadable(ctx.expected_file) == 1
problem_id = ctx.problem_name, then
test_count = 1, return {
} success = true,
end problem_id = ctx.problem_name,
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 = { "uv", "run", "--directory", plugin_path, scraper_path, "tests", ctx.contest_id } args = {
else 'uv',
args = { "uv", "run", "--directory", plugin_path, scraper_path, "tests", ctx.contest_id, ctx.problem_id } 'run',
end '--directory',
plugin_path,
scraper_path,
'tests',
ctx.contest_id,
}
else
args = {
'uv',
'run',
'--directory',
plugin_path,
scraper_path,
'tests',
ctx.contest_id,
ctx.problem_id,
}
end
local result = vim.system(args, { 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: " .. (result.stderr or "Unknown error"), error = 'Failed to run tests scraper: '
} .. (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.split(combined_output, "\n", true), ctx.expected_file) vim.fn.writefile(
end vim.split(combined_output, '\n', true),
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,28 +1,32 @@
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("LuaSnip not available - snippets disabled", vim.log.levels.INFO) logger.log(
return 'LuaSnip not available - snippets disabled',
end vim.log.levels.INFO
)
return
end
local s, i, fmt = ls.snippet, ls.insert_node, require("luasnip.extras.fmt").fmt local s, i, fmt =
ls.snippet, ls.insert_node, require('luasnip.extras.fmt').fmt
local constants = require("cp.constants") local 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;
@ -43,7 +47,7 @@ int main() {{
return 0; return 0;
}}]], }}]],
atcoder = [[#include <bits/stdc++.h> atcoder = [[#include <bits/stdc++.h>
using namespace std; using namespace std;
@ -68,7 +72,7 @@ int main() {{
return 0; return 0;
}}]], }}]],
cses = [[#include <bits/stdc++.h> cses = [[#include <bits/stdc++.h>
using namespace std; using namespace std;
@ -79,10 +83,10 @@ int main() {{
return 0; return 0;
}}]], }}]],
}, },
python = { python = {
codeforces = [[def solve(): codeforces = [[def solve():
{} {}
if __name__ == "__main__": if __name__ == "__main__":
@ -90,41 +94,44 @@ 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(snippets, s(prefixed_trigger, fmt(template, { i(1) }))) table.insert(
end snippets,
end s(prefixed_trigger, fmt(template, { i(1) }))
)
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,163 +1,180 @@
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 = cache.get_test_cases(platform, contest_id, problem_id) local cached_test_cases =
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(test_cases, create_test_case(i, test_case.input, test_case.output)) table.insert(
end test_cases,
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 vim.fn.filereadable(input_file) == 0 or vim.fn.filereadable(expected_file) == 0 then if
return {} vim.fn.filereadable(input_file) == 0
end or vim.fn.filereadable(expected_file) == 0
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] or contest_config.default_language local language_name = constants.filetype_to_language[language]
local language_config = contest_config[language_name] or contest_config.default_language
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(language_config.run, language_config.executable, substitutions) local run_cmd = build_command(
language_config.run,
language_config.executable,
substitutions
)
local start_time = vim.uv.hrtime() local 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(state.platform, state.contest_id, state.problem_id) local test_cases = parse_test_cases_from_cache(
state.platform,
state.contest_id,
state.problem_id
)
if #test_cases == 0 then if #test_cases == 0 then
test_cases = parse_test_cases_from_files(ctx.input_file, ctx.expected_file) test_cases =
end parse_test_cases_from_files(ctx.input_file, ctx.expected_file)
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,33 +1,37 @@
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({ "git", "describe", "--tags", "--always", "--dirty" }, { local result = vim.system(
cwd = plugin_root, { 'git', 'describe', '--tags', '--always', '--dirty' },
text = true, {
}):wait() cwd = plugin_root,
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,139 +10,147 @@
---@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 vim.api.nvim_win_is_valid(win) and vim.api.nvim_buf_is_valid(win_state.bufnr) then if
local bufname = vim.api.nvim_buf_get_name(win_state.bufnr) vim.api.nvim_win_is_valid(win)
if not bufname:match("%.in$") and not bufname:match("%.out$") and not bufname:match("%.expected$") then and vim.api.nvim_buf_is_valid(win_state.bufnr)
problem_id = vim.fn.fnamemodify(bufname, ":t:r") then
break local bufname = vim.api.nvim_buf_get_name(win_state.bufnr)
end if
end not bufname:match('%.in$')
end and not bufname:match('%.out$')
end and not bufname:match('%.expected$')
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 = vim.tbl_keys(constants.filetype_to_language) local valid_extensions =
for _, file in ipairs(files) do vim.tbl_keys(constants.filetype_to_language)
local ext = vim.fn.fnamemodify(file, ":e") for _, file in ipairs(files) do
if vim.tbl_contains(valid_extensions, ext) then local ext = vim.fn.fnamemodify(file, ':e')
source_file = file if vim.tbl_contains(valid_extensions, ext) then
break source_file = file
end break
end end
source_file = source_file or files[1] end
end source_file = source_file or files[1]
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,88 +1,89 @@
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 = cache.get_contest_data(context.platform, context.contest_id) local contest_data =
if contest_data and contest_data.problems then cache.get_contest_data(context.platform, context.contest_id)
for _, problem in ipairs(contest_data.problems) do if contest_data and contest_data.problems then
table.insert(candidates, problem.id) for _, problem in ipairs(contest_data.problems) do
end table.insert(candidates, problem.id)
end end
else end
vim.list_extend(candidates, platforms) else
end vim.list_extend(candidates, platforms)
return vim.tbl_filter(function(cmd) end
return cmd:find(ArgLead, 1, true) == 1 return vim.tbl_filter(function(cmd)
end, candidates) return cmd:find(ArgLead, 1, true) == 1
elseif args[#args - 1] == "--lang" then end, candidates)
return vim.tbl_filter(function(lang) elseif args[#args - 1] == '--lang' then
return lang:find(ArgLead, 1, true) == 1 return vim.tbl_filter(function(lang)
end, languages) return lang:find(ArgLead, 1, true) == 1
elseif num_args == 4 and not lang_flag_present then end, languages)
if vim.tbl_contains(platforms, args[2]) then elseif num_args == 4 and not lang_flag_present then
local cache = require("cp.cache") if vim.tbl_contains(platforms, args[2]) then
cache.load() local cache = require('cp.cache')
local contest_data = cache.get_contest_data(args[2], args[3]) cache.load()
if contest_data and contest_data.problems then local contest_data = cache.get_contest_data(args[2], args[3])
local candidates = { "--lang" } if contest_data and contest_data.problems then
for _, problem in ipairs(contest_data.problems) do local candidates = { '--lang' }
table.insert(candidates, problem.id) for _, problem in ipairs(contest_data.problems) do
end table.insert(candidates, problem.id)
return vim.tbl_filter(function(cmd) end
return cmd:find(ArgLead, 1, true) == 1 return vim.tbl_filter(function(cmd)
end, candidates) return cmd:find(ArgLead, 1, true) == 1
end end, candidates)
end end
end end
return {} end
end, return {}
end,
}) })

4
stylua.toml Normal file
View file

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