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

fix: revert stylua config

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

4
after/ftplugin/cp.lua
View file

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

4
after/ftplugin/cpin.lua
View file

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

4
after/ftplugin/cpout.lua
View file

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

4
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",
}, },
}) })

54
lua/cp/cache.lua
View file

@ -18,17 +18,17 @@
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
@ -39,11 +39,11 @@ end
---@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
@ -67,7 +67,7 @@ function M.load()
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
@ -76,9 +76,9 @@ function M.load()
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
@ -86,8 +86,8 @@ end
---@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
@ -111,9 +111,9 @@ end
---@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
@ -122,7 +122,7 @@ function M.set_contest_data(platform, contest_id, problems)
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),
} }
@ -133,8 +133,8 @@ end
---@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
@ -149,13 +149,12 @@ end
---@return TestCase[]? ---@return TestCase[]?
function M.get_test_cases(platform, contest_id, problem_id) function M.get_test_cases(platform, contest_id, problem_id)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
problem_id = { problem_id, { 'string', 'nil' }, true }, problem_id = { problem_id, { "string", "nil" }, true },
}) })
local problem_key = problem_id and (contest_id .. '_' .. problem_id) local problem_key = problem_id and (contest_id .. "_" .. problem_id) or contest_id
or contest_id
if not cache_data[platform] or not cache_data[platform][problem_key] then if not cache_data[platform] or not cache_data[platform][problem_key] then
return nil return nil
end end
@ -168,14 +167,13 @@ end
---@param test_cases TestCase[] ---@param test_cases TestCase[]
function M.set_test_cases(platform, contest_id, problem_id, test_cases) function M.set_test_cases(platform, contest_id, problem_id, test_cases)
vim.validate({ vim.validate({
platform = { platform, 'string' }, platform = { platform, "string" },
contest_id = { contest_id, 'string' }, contest_id = { contest_id, "string" },
problem_id = { problem_id, { 'string', 'nil' }, true }, problem_id = { problem_id, { "string", "nil" }, true },
test_cases = { test_cases, 'table' }, test_cases = { test_cases, "table" },
}) })
local problem_key = problem_id and (contest_id .. '_' .. problem_id) local problem_key = problem_id and (contest_id .. "_" .. problem_id) or contest_id
or contest_id
if not cache_data[platform] then if not cache_data[platform] then
cache_data[platform] = {} cache_data[platform] = {}
end end

44
lua/cp/config.lua
View file

@ -48,7 +48,7 @@
---@field filename? fun(contest: string, contest_id: string, problem_id?: string, config: cp.Config, language?: string): string ---@field filename? fun(contest: string, contest_id: string, problem_id?: string, config: cp.Config, language?: string): string
local M = {} local M = {}
local constants = require('cp.constants') local constants = require("cp.constants")
---@type cp.Config ---@type cp.Config
M.defaults = { M.defaults = {
@ -68,34 +68,34 @@ M.defaults = {
---@return cp.Config ---@return cp.Config
function M.setup(user_config) function M.setup(user_config)
vim.validate({ vim.validate({
user_config = { user_config, { 'table', 'nil' }, true }, user_config = { user_config, { "table", "nil" }, true },
}) })
if user_config then if user_config then
vim.validate({ vim.validate({
contests = { user_config.contests, { 'table', 'nil' }, true }, contests = { user_config.contests, { "table", "nil" }, true },
snippets = { user_config.snippets, { 'table', 'nil' }, true }, snippets = { user_config.snippets, { "table", "nil" }, true },
hooks = { user_config.hooks, { 'table', 'nil' }, true }, hooks = { user_config.hooks, { "table", "nil" }, true },
debug = { user_config.debug, { 'boolean', 'nil' }, true }, debug = { user_config.debug, { "boolean", "nil" }, true },
tile = { user_config.tile, { 'function', 'nil' }, true }, tile = { user_config.tile, { "function", "nil" }, true },
filename = { user_config.filename, { 'function', 'nil' }, true }, filename = { user_config.filename, { "function", "nil" }, true },
}) })
if user_config.hooks then if user_config.hooks then
vim.validate({ vim.validate({
before_run = { before_run = {
user_config.hooks.before_run, user_config.hooks.before_run,
{ 'function', 'nil' }, { "function", "nil" },
true, true,
}, },
before_debug = { before_debug = {
user_config.hooks.before_debug, user_config.hooks.before_debug,
{ 'function', 'nil' }, { "function", "nil" },
true, true,
}, },
setup_code = { setup_code = {
user_config.hooks.setup_code, user_config.hooks.setup_code,
{ 'function', 'nil' }, { "function", "nil" },
true, true,
}, },
}) })
@ -104,26 +104,16 @@ function M.setup(user_config)
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(constants.filetype_to_language), lang_config.extension)
then
if
not vim.tbl_contains(
vim.tbl_keys(constants.filetype_to_language),
lang_config.extension
)
then then
error( error(
("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format( ("Invalid extension '%s' for language '%s' in contest '%s'. Valid extensions: %s"):format(
lang_config.extension, lang_config.extension,
lang_name, lang_name,
contest_name, contest_name,
table.concat( table.concat(vim.tbl_keys(constants.filetype_to_language), ", ")
vim.tbl_keys(
constants.filetype_to_language
),
', '
)
) )
) )
end end
@ -133,7 +123,7 @@ function M.setup(user_config)
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
@ -142,8 +132,8 @@ end
---@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

12
lua/cp/constants.lua
View file

@ -1,10 +1,10 @@
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 = {
@ -17,8 +17,8 @@ M.filetype_to_language = {
---@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

191
lua/cp/execute.lua
View file

@ -6,9 +6,9 @@
---@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
@ -16,16 +16,13 @@ local filetype_to_language = constants.filetype_to_language
---@return string ---@return string
local function get_language_from_file(source_file, contest_config) local function get_language_from_file(source_file, contest_config)
vim.validate({ vim.validate({
source_file = { source_file, 'string' }, source_file = { source_file, "string" },
contest_config = { contest_config, 'table' }, contest_config = { contest_config, "table" },
}) })
local extension = vim.fn.fnamemodify(source_file, ':e') local extension = vim.fn.fnamemodify(source_file, ":e")
local language = filetype_to_language[extension] local language = filetype_to_language[extension] or contest_config.default_language
or contest_config.default_language logger.log(("detected language: %s (extension: %s)"):format(language, extension))
logger.log(
('detected language: %s (extension: %s)'):format(language, extension)
)
return language return language
end end
@ -34,15 +31,15 @@ end
---@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
@ -55,9 +52,9 @@ end
---@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)
@ -68,25 +65,25 @@ local function build_command(cmd_template, executable, substitutions)
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
@ -94,33 +91,26 @@ end
---@return {code: integer, stderr: string} ---@return {code: integer, stderr: string}
local function compile_generic(language_config, substitutions) local function compile_generic(language_config, substitutions)
vim.validate({ vim.validate({
language_config = { language_config, 'table' }, language_config = { language_config, "table" },
substitutions = { substitutions, 'table' }, substitutions = { substitutions, "table" },
}) })
if not language_config.compile then if not language_config.compile then
logger.log('no compilation step required') logger.log("no compilation step required")
return { code = 0, stderr = '' } return { code = 0, stderr = "" }
end end
local compile_cmd = local compile_cmd = substitute_template(language_config.compile, substitutions)
substitute_template(language_config.compile, substitutions) logger.log(("compiling: %s"):format(table.concat(compile_cmd, " ")))
logger.log(('compiling: %s'):format(table.concat(compile_cmd, ' ')))
local start_time = vim.uv.hrtime() local start_time = vim.uv.hrtime()
local result = vim.system(compile_cmd, { text = true }):wait() local result = vim.system(compile_cmd, { text = true }):wait()
local compile_time = (vim.uv.hrtime() - start_time) / 1000000 local compile_time = (vim.uv.hrtime() - start_time) / 1000000
if result.code == 0 then if result.code == 0 then
logger.log(('compilation successful (%.1fms)'):format(compile_time)) logger.log(("compilation successful (%.1fms)"):format(compile_time))
else else
logger.log( logger.log(("compilation failed (%.1fms): %s"):format(compile_time, result.stderr), vim.log.levels.WARN)
('compilation failed (%.1fms): %s'):format(
compile_time,
result.stderr
),
vim.log.levels.WARN
)
end end
return result return result
@ -132,12 +122,12 @@ end
---@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()
@ -153,25 +143,16 @@ local function execute_command(cmd, input_data, timeout_ms)
local actual_code = result.code or 0 local actual_code = result.code or 0
if result.code == 124 then if result.code == 124 then
logger.log( logger.log(("execution timed out after %.1fms"):format(execution_time), vim.log.levels.WARN)
('execution timed out after %.1fms'):format(execution_time),
vim.log.levels.WARN
)
elseif actual_code ~= 0 then elseif actual_code ~= 0 then
logger.log( logger.log(("execution failed (exit code %d, %.1fms)"):format(actual_code, execution_time), vim.log.levels.WARN)
('execution failed (exit code %d, %.1fms)'):format(
actual_code,
execution_time
),
vim.log.levels.WARN
)
else else
logger.log(('execution successful (%.1fms)'):format(execution_time)) logger.log(("execution successful (%.1fms)"):format(execution_time))
end 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,
@ -184,40 +165,31 @@ end
---@return string ---@return string
local function format_output(exec_result, expected_file, is_debug) local function format_output(exec_result, expected_file, is_debug)
vim.validate({ vim.validate({
exec_result = { exec_result, 'table' }, exec_result = { exec_result, "table" },
expected_file = { expected_file, 'string' }, expected_file = { expected_file, "string" },
is_debug = { is_debug, 'boolean' }, is_debug = { is_debug, "boolean" },
}) })
local output_lines = { exec_result.stdout } local output_lines = { exec_result.stdout }
local metadata_lines = {} local metadata_lines = {}
if exec_result.timed_out then if exec_result.timed_out then
table.insert(metadata_lines, '[code]: 124 (TIMEOUT)') table.insert(metadata_lines, "[code]: 124 (TIMEOUT)")
elseif exec_result.code >= 128 then elseif exec_result.code >= 128 then
local signal_name = signal_codes[exec_result.code] or 'SIGNAL' local signal_name = signal_codes[exec_result.code] or "SIGNAL"
table.insert( table.insert(metadata_lines, ("[code]: %d (%s)"):format(exec_result.code, signal_name))
metadata_lines,
('[code]: %d (%s)'):format(exec_result.code, signal_name)
)
else else
table.insert(metadata_lines, ('[code]: %d'):format(exec_result.code)) table.insert(metadata_lines, ("[code]: %d"):format(exec_result.code))
end end
table.insert( table.insert(metadata_lines, ("[time]: %.2f ms"):format(exec_result.time_ms))
metadata_lines, table.insert(metadata_lines, ("[debug]: %s"):format(is_debug and "true" or "false"))
('[time]: %.2f ms'):format(exec_result.time_ms)
)
table.insert(
metadata_lines,
('[debug]: %s'):format(is_debug and 'true' or 'false')
)
if vim.fn.filereadable(expected_file) == 1 and exec_result.code == 0 then if vim.fn.filereadable(expected_file) == 1 and exec_result.code == 0 then
local expected_content = vim.fn.readfile(expected_file) local expected_content = vim.fn.readfile(expected_file)
local actual_lines = vim.split(exec_result.stdout, '\n') local actual_lines = vim.split(exec_result.stdout, "\n")
while #actual_lines > 0 and actual_lines[#actual_lines] == '' do while #actual_lines > 0 and actual_lines[#actual_lines] == "" do
table.remove(actual_lines) table.remove(actual_lines)
end end
@ -231,15 +203,10 @@ local function format_output(exec_result, expected_file, is_debug)
end end
end end
table.insert( table.insert(metadata_lines, ("[matches]: %s"):format(matches and "true" or "false"))
metadata_lines,
('[matches]: %s'):format(matches and 'true' or 'false')
)
end end
return table.concat(output_lines, '') return table.concat(output_lines, "") .. "\n" .. table.concat(metadata_lines, "\n")
.. '\n'
.. table.concat(metadata_lines, '\n')
end end
---@param ctx ProblemContext ---@param ctx ProblemContext
@ -247,9 +214,9 @@ end
---@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()
@ -258,10 +225,7 @@ function M.run_problem(ctx, contest_config, is_debug)
local language_config = contest_config[language] local language_config = contest_config[language]
if not language_config then if not language_config then
vim.fn.writefile( vim.fn.writefile({ "Error: No configuration for language: " .. language }, ctx.output_file)
{ 'Error: No configuration for language: ' .. language },
ctx.output_file
)
return return
end end
@ -271,8 +235,7 @@ function M.run_problem(ctx, contest_config, is_debug)
version = tostring(language_config.version), version = tostring(language_config.version),
} }
local compile_cmd = is_debug and language_config.debug local compile_cmd = is_debug and language_config.debug or language_config.compile
or language_config.compile
if compile_cmd then if compile_cmd then
local compile_result = compile_generic(language_config, substitutions) local compile_result = compile_generic(language_config, substitutions)
if compile_result.code ~= 0 then if compile_result.code ~= 0 then
@ -281,35 +244,23 @@ function M.run_problem(ctx, contest_config, is_debug)
end end
end end
local input_data = '' local input_data = ""
if vim.fn.filereadable(ctx.input_file) == 1 then if vim.fn.filereadable(ctx.input_file) == 1 then
input_data = table.concat(vim.fn.readfile(ctx.input_file), '\n') .. '\n' input_data = table.concat(vim.fn.readfile(ctx.input_file), "\n") .. "\n"
end end
local run_cmd = build_command( local run_cmd = build_command(language_config.run, language_config.executable, substitutions)
language_config.run, local exec_result = execute_command(run_cmd, input_data, contest_config.timeout_ms)
language_config.executable, local formatted_output = format_output(exec_result, ctx.expected_file, is_debug)
substitutions
)
local exec_result =
execute_command(run_cmd, input_data, contest_config.timeout_ms)
local formatted_output =
format_output(exec_result, ctx.expected_file, is_debug)
local output_buf = vim.fn.bufnr(ctx.output_file) local output_buf = vim.fn.bufnr(ctx.output_file)
if output_buf ~= -1 then if output_buf ~= -1 then
vim.api.nvim_buf_set_lines( vim.api.nvim_buf_set_lines(output_buf, 0, -1, false, vim.split(formatted_output, "\n"))
output_buf,
0,
-1,
false,
vim.split(formatted_output, '\n')
)
vim.api.nvim_buf_call(output_buf, function() vim.api.nvim_buf_call(output_buf, function()
vim.cmd.write() vim.cmd.write()
end) end)
else else
vim.fn.writefile(vim.split(formatted_output, '\n'), ctx.output_file) vim.fn.writefile(vim.split(formatted_output, "\n"), ctx.output_file)
end end
end end

72
lua/cp/health.lua
View file

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

247
lua/cp/init.lua
View file

@ -1,16 +1,16 @@
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
@ -29,24 +29,19 @@ local state = {
test_states = {}, test_states = {},
} }
local constants = require('cp.constants') local constants = require("cp.constants")
local platforms = constants.PLATFORMS local platforms = constants.PLATFORMS
local actions = constants.ACTIONS local actions = constants.ACTIONS
local function set_platform(platform) local function set_platform(platform)
if not vim.tbl_contains(platforms, platform) then if not vim.tbl_contains(platforms, platform) then
logger.log( logger.log(("unknown platform. Available: [%s]"):format(table.concat(platforms, ", ")), vim.log.levels.ERROR)
('unknown platform. Available: [%s]'):format(
table.concat(platforms, ', ')
),
vim.log.levels.ERROR
)
return false return false
end 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
@ -55,87 +50,55 @@ end
---@param language? string ---@param language? string
local function setup_problem(contest_id, problem_id, language) local function setup_problem(contest_id, problem_id, language)
if not state.platform then if not state.platform then
logger.log( logger.log("no platform set. run :CP <platform> <contest> first", vim.log.levels.ERROR)
'no platform set. run :CP <platform> <contest> first',
vim.log.levels.ERROR
)
return return
end end
local problem_name = state.platform == 'cses' and contest_id local problem_name = state.platform == "cses" and contest_id or (contest_id .. (problem_id or ""))
or (contest_id .. (problem_id or '')) logger.log(("setting up problem: %s"):format(problem_name))
logger.log(('setting up problem: %s'):format(problem_name))
local metadata_result = local metadata_result = scrape.scrape_contest_metadata(state.platform, contest_id)
scrape.scrape_contest_metadata(state.platform, contest_id)
if not metadata_result.success then if not metadata_result.success then
logger.log( logger.log(
'failed to load contest metadata: ' "failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN vim.log.levels.WARN
) )
end end
vim.cmd('silent only') vim.cmd("silent only")
state.contest_id = contest_id state.contest_id = contest_id
state.problem_id = problem_id state.problem_id = problem_id
local cached_test_cases = local cached_test_cases = cache.get_test_cases(state.platform, contest_id, problem_id)
cache.get_test_cases(state.platform, contest_id, problem_id)
if cached_test_cases then if cached_test_cases then
state.test_cases = cached_test_cases state.test_cases = cached_test_cases
end end
local scrape_ctx = problem.create_context( local scrape_ctx = problem.create_context(state.platform, contest_id, problem_id, config, language)
state.platform,
contest_id,
problem_id,
config,
language
)
local scrape_result = scrape.scrape_problem(scrape_ctx) local scrape_result = scrape.scrape_problem(scrape_ctx)
if not scrape_result.success then if not scrape_result.success then
logger.log( logger.log("scraping failed: " .. (scrape_result.error or "unknown error"), vim.log.levels.WARN)
'scraping failed: ' .. (scrape_result.error or 'unknown error'), logger.log("you can manually add test cases to io/ directory", vim.log.levels.INFO)
vim.log.levels.WARN
)
logger.log(
'you can manually add test cases to io/ directory',
vim.log.levels.INFO
)
state.test_cases = nil state.test_cases = nil
else else
local test_count = scrape_result.test_count or 0 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))
('scraped %d test case(s) for %s'):format(
test_count,
scrape_result.problem_id
)
)
state.test_cases = scrape_result.test_cases state.test_cases = scrape_result.test_cases
if scrape_result.test_cases then if scrape_result.test_cases then
cache.set_test_cases( cache.set_test_cases(state.platform, contest_id, problem_id, scrape_result.test_cases)
state.platform,
contest_id,
problem_id,
scrape_result.test_cases
)
end end
end end
vim.cmd.e(scrape_ctx.source_file) vim.cmd.e(scrape_ctx.source_file)
if vim.api.nvim_buf_get_lines(0, 0, -1, true)[1] == '' then if vim.api.nvim_buf_get_lines(0, 0, -1, true)[1] == "" then
local has_luasnip, luasnip = pcall(require, 'luasnip') local has_luasnip, luasnip = pcall(require, "luasnip")
if has_luasnip then if has_luasnip then
local prefixed_trigger = ('cp.nvim/%s.%s'):format( local prefixed_trigger = ("cp.nvim/%s.%s"):format(state.platform, language)
state.platform,
language
)
vim.api.nvim_buf_set_lines(0, 0, -1, false, { prefixed_trigger }) vim.api.nvim_buf_set_lines(0, 0, -1, false, { prefixed_trigger })
vim.api.nvim_win_set_cursor(0, { 1, #prefixed_trigger }) vim.api.nvim_win_set_cursor(0, { 1, #prefixed_trigger })
@ -145,23 +108,17 @@ local function setup_problem(contest_id, problem_id, language)
if luasnip.expandable() then if luasnip.expandable() then
luasnip.expand() luasnip.expand()
else else
vim.api.nvim_buf_set_lines(0, 0, 1, false, { '' }) vim.api.nvim_buf_set_lines(0, 0, 1, false, { "" })
vim.api.nvim_win_set_cursor(0, { 1, 0 }) vim.api.nvim_win_set_cursor(0, { 1, 0 })
end end
vim.cmd.stopinsert() vim.cmd.stopinsert()
end) end)
else else
vim.api.nvim_input(('i%s<c-space><esc>'):format(state.platform)) vim.api.nvim_input(("i%s<c-space><esc>"):format(state.platform))
end end
end end
local ctx = problem.create_context( local ctx = problem.create_context(state.platform, state.contest_id, state.problem_id, config, language)
state.platform,
state.contest_id,
state.problem_id,
config,
language
)
if config.hooks and config.hooks.setup_code then if config.hooks and config.hooks.setup_code then
config.hooks.setup_code(ctx) config.hooks.setup_code(ctx)
@ -174,13 +131,13 @@ local function setup_problem(contest_id, problem_id, language)
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
@ -192,20 +149,15 @@ local function run_problem()
return return
end end
logger.log(('running problem: %s'):format(problem_id)) logger.log(("running problem: %s"):format(problem_id))
if not state.platform then if not state.platform then
logger.log('no platform set', vim.log.levels.ERROR) logger.log("no platform set", vim.log.levels.ERROR)
return return
end end
local contest_config = config.contests[state.platform] local contest_config = config.contests[state.platform]
local ctx = problem.create_context( local ctx = problem.create_context(state.platform, state.contest_id, state.problem_id, config)
state.platform,
state.contest_id,
state.problem_id,
config
)
if config.hooks and config.hooks.before_run then if config.hooks and config.hooks.before_run then
config.hooks.before_run(ctx) config.hooks.before_run(ctx)
@ -224,17 +176,12 @@ local function debug_problem()
end end
if not state.platform then if not state.platform then
logger.log('no platform set', vim.log.levels.ERROR) logger.log("no platform set", vim.log.levels.ERROR)
return return
end end
local contest_config = config.contests[state.platform] local contest_config = config.contests[state.platform]
local ctx = problem.create_context( local ctx = problem.create_context(state.platform, state.contest_id, state.problem_id, config)
state.platform,
state.contest_id,
state.problem_id,
config
)
if config.hooks and config.hooks.before_debug then if config.hooks and config.hooks.before_debug then
config.hooks.before_debug(ctx) config.hooks.before_debug(ctx)
@ -250,35 +197,28 @@ end
---@param language? string ---@param language? string
local function navigate_problem(delta, language) local function navigate_problem(delta, language)
if not state.platform or not state.contest_id then if not state.platform or not state.contest_id then
logger.log( logger.log("no contest set. run :CP <platform> <contest> first", vim.log.levels.ERROR)
'no contest set. run :CP <platform> <contest> first',
vim.log.levels.ERROR
)
return return
end end
cache.load() cache.load()
local contest_data = local contest_data = cache.get_contest_data(state.platform, state.contest_id)
cache.get_contest_data(state.platform, state.contest_id)
if not contest_data or not contest_data.problems then if not contest_data or not contest_data.problems then
logger.log( logger.log("no contest metadata found. set up a problem first to cache contest data", vim.log.levels.ERROR)
'no contest metadata found. set up a problem first to cache contest data',
vim.log.levels.ERROR
)
return return
end 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
@ -291,24 +231,21 @@ local function navigate_problem(delta, language)
end end
if not current_index then if not current_index then
logger.log('current problem not found in contest', vim.log.levels.ERROR) logger.log("current problem not found in contest", vim.log.levels.ERROR)
return return
end end
local new_index = current_index + delta local new_index = current_index + delta
if new_index < 1 or new_index > #problems then if new_index < 1 or new_index > #problems then
local direction = delta > 0 and 'next' or 'previous' local direction = delta > 0 and "next" or "previous"
logger.log( logger.log(("no %s problem available"):format(direction), vim.log.levels.INFO)
('no %s problem available'):format(direction),
vim.log.levels.INFO
)
return return
end 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)
@ -318,54 +255,54 @@ end
local function parse_command(args) local function parse_command(args)
if #args == 0 then if #args == 0 then
return { return {
type = 'error', type = "error",
message = 'Usage: :CP <platform> <contest> [problem] [--lang=<language>] | :CP <action> | :CP <problem>', message = "Usage: :CP <platform> <contest> [problem] [--lang=<language>] | :CP <action> | :CP <problem>",
} }
end end
local language = nil local language = nil
for i, arg in ipairs(args) do for i, arg in ipairs(args) do
local lang_match = arg:match('^--lang=(.+)$') local lang_match = arg:match("^--lang=(.+)$")
if lang_match then if lang_match then
language = lang_match language = lang_match
elseif arg == '--lang' then elseif arg == "--lang" then
if i + 1 <= #args then if i + 1 <= #args then
language = args[i + 1] language = args[i + 1]
else else
return { type = 'error', message = '--lang requires a value' } return { type = "error", message = "--lang requires a value" }
end end
end end
end end
local filtered_args = vim.tbl_filter(function(arg) local filtered_args = vim.tbl_filter(function(arg)
return not (arg:match('^--lang') or arg == language) return not (arg:match("^--lang") or arg == language)
end, args) end, args)
local first = filtered_args[1] local first = filtered_args[1]
if vim.tbl_contains(actions, first) then if vim.tbl_contains(actions, first) then
return { type = 'action', action = first, language = language } return { type = "action", action = first, language = language }
end end
if vim.tbl_contains(platforms, first) then if vim.tbl_contains(platforms, first) then
if #filtered_args == 1 then if #filtered_args == 1 then
return { return {
type = 'platform_only', type = "platform_only",
platform = first, platform = first,
language = language, language = language,
} }
elseif #filtered_args == 2 then elseif #filtered_args == 2 then
if first == 'cses' then if first == "cses" then
return { return {
type = 'cses_problem', type = "cses_problem",
platform = first, platform = first,
problem = filtered_args[2], problem = filtered_args[2],
language = language, language = language,
} }
else else
return { return {
type = 'contest_setup', type = "contest_setup",
platform = first, platform = first,
contest = filtered_args[2], contest = filtered_args[2],
language = language, language = language,
@ -373,92 +310,80 @@ local function parse_command(args)
end end
elseif #filtered_args == 3 then elseif #filtered_args == 3 then
return { return {
type = 'full_setup', type = "full_setup",
platform = first, platform = first,
contest = filtered_args[2], contest = filtered_args[2],
problem = filtered_args[3], problem = filtered_args[3],
language = language, language = language,
} }
else else
return { type = 'error', message = 'Too many arguments' } return { type = "error", message = "Too many arguments" }
end end
end end
if state.platform and state.contest_id then if state.platform and state.contest_id then
return { type = 'problem_switch', problem = first, language = language } return { type = "problem_switch", problem = first, language = language }
end end
return { type = 'error', message = 'Unknown command or no contest context' } return { type = "error", message = "Unknown command or no contest context" }
end end
function M.handle_command(opts) function M.handle_command(opts)
local cmd = parse_command(opts.fargs) local cmd = parse_command(opts.fargs)
if cmd.type == 'error' then if cmd.type == "error" then
logger.log(cmd.message, vim.log.levels.ERROR) logger.log(cmd.message, vim.log.levels.ERROR)
return return
end end
if cmd.type == 'action' then if cmd.type == "action" then
if cmd.action == 'run' then if cmd.action == "run" then
run_problem() run_problem()
elseif cmd.action == 'debug' then elseif cmd.action == "debug" then
debug_problem() debug_problem()
elseif cmd.action == 'next' then elseif cmd.action == "next" then
navigate_problem(1, cmd.language) navigate_problem(1, cmd.language)
elseif cmd.action == 'prev' then elseif cmd.action == "prev" then
navigate_problem(-1, cmd.language) navigate_problem(-1, cmd.language)
end end
return return
end end
if cmd.type == 'platform_only' then if cmd.type == "platform_only" then
set_platform(cmd.platform) set_platform(cmd.platform)
return return
end end
if cmd.type == 'contest_setup' then if cmd.type == "contest_setup" then
if set_platform(cmd.platform) then if set_platform(cmd.platform) then
state.contest_id = cmd.contest state.contest_id = cmd.contest
local metadata_result = local metadata_result = scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
if not metadata_result.success then if not metadata_result.success then
logger.log( logger.log(
'failed to load contest metadata: ' "failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN vim.log.levels.WARN
) )
else else
logger.log( logger.log(
('loaded %d problems for %s %s'):format( ("loaded %d problems for %s %s"):format(#metadata_result.problems, cmd.platform, cmd.contest)
#metadata_result.problems,
cmd.platform,
cmd.contest
)
) )
end end
end end
return return
end end
if cmd.type == 'full_setup' then if cmd.type == "full_setup" then
if set_platform(cmd.platform) then if set_platform(cmd.platform) then
state.contest_id = cmd.contest state.contest_id = cmd.contest
local metadata_result = local metadata_result = scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
scrape.scrape_contest_metadata(cmd.platform, cmd.contest)
if not metadata_result.success then if not metadata_result.success then
logger.log( logger.log(
'failed to load contest metadata: ' "failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN vim.log.levels.WARN
) )
else else
logger.log( logger.log(
('loaded %d problems for %s %s'):format( ("loaded %d problems for %s %s"):format(#metadata_result.problems, cmd.platform, cmd.contest)
#metadata_result.problems,
cmd.platform,
cmd.contest
)
) )
end end
@ -467,14 +392,12 @@ function M.handle_command(opts)
return return
end end
if cmd.type == 'cses_problem' then if cmd.type == "cses_problem" then
if set_platform(cmd.platform) then if set_platform(cmd.platform) then
local metadata_result = local metadata_result = scrape.scrape_contest_metadata(cmd.platform, "")
scrape.scrape_contest_metadata(cmd.platform, '')
if not metadata_result.success then if not metadata_result.success then
logger.log( logger.log(
'failed to load contest metadata: ' "failed to load contest metadata: " .. (metadata_result.error or "unknown error"),
.. (metadata_result.error or 'unknown error'),
vim.log.levels.WARN vim.log.levels.WARN
) )
end end
@ -483,8 +406,8 @@ function M.handle_command(opts)
return return
end 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)

2
lua/cp/log.lua
View file

@ -9,7 +9,7 @@ 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

41
lua/cp/problem.lua
View file

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

122
lua/cp/scrape.lua
View file

@ -1,51 +1,41 @@
local M = {} local M = {}
local logger = require('cp.log') local logger = require("cp.log")
local cache = require('cp.cache') local cache = require("cp.cache")
local function get_plugin_path() local function get_plugin_path()
local plugin_path = debug.getinfo(1, 'S').source:sub(2) local plugin_path = debug.getinfo(1, "S").source:sub(2)
return vim.fn.fnamemodify(plugin_path, ':h:h:h') return vim.fn.fnamemodify(plugin_path, ":h:h:h")
end end
local function ensure_io_directory() local function ensure_io_directory()
vim.fn.mkdir('io', 'p') vim.fn.mkdir("io", "p")
end end
local function check_internet_connectivity() local function check_internet_connectivity()
local result = vim.system( local result = vim.system({ "ping", "-c", "1", "-W", "3", "8.8.8.8" }, { text = true }):wait()
{ 'ping', '-c', '1', '-W', '3', '8.8.8.8' },
{ text = true }
):wait()
return result.code == 0 return result.code == 0
end end
local function setup_python_env() local function setup_python_env()
local plugin_path = get_plugin_path() local plugin_path = get_plugin_path()
local venv_dir = plugin_path .. '/.venv' local venv_dir = plugin_path .. "/.venv"
if vim.fn.executable('uv') == 0 then if vim.fn.executable("uv") == 0 then
logger.log( logger.log(
'uv is not installed. Install it to enable problem scraping: https://docs.astral.sh/uv/', "uv is not installed. Install it to enable problem scraping: https://docs.astral.sh/uv/",
vim.log.levels.WARN vim.log.levels.WARN
) )
return false return false
end end
if vim.fn.isdirectory(venv_dir) == 0 then if vim.fn.isdirectory(venv_dir) == 0 then
logger.log('setting up Python environment for scrapers...') logger.log("setting up Python environment for scrapers...")
local result = vim.system( local result = vim.system({ "uv", "sync" }, { cwd = plugin_path, text = true }):wait()
{ 'uv', 'sync' },
{ cwd = plugin_path, text = true }
)
:wait()
if result.code ~= 0 then if result.code ~= 0 then
logger.log( logger.log("failed to setup Python environment: " .. result.stderr, vim.log.levels.ERROR)
'failed to setup Python environment: ' .. result.stderr,
vim.log.levels.ERROR
)
return false return false
end end
logger.log('python environment setup complete') logger.log("python environment setup complete")
end end
return true return true
@ -56,8 +46,8 @@ end
---@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()
@ -73,38 +63,38 @@ function M.scrape_contest_metadata(platform, contest_id)
if not check_internet_connectivity() then if not check_internet_connectivity() then
return { return {
success = false, success = false,
error = 'No internet connection available', error = "No internet connection available",
} }
end end
if not setup_python_env() then if not setup_python_env() then
return { return {
success = false, success = false,
error = 'Python environment setup failed', error = "Python environment setup failed",
} }
end end
local plugin_path = get_plugin_path() local plugin_path = get_plugin_path()
local scraper_path = plugin_path .. '/scrapers/' .. platform .. '.py' local scraper_path = plugin_path .. "/scrapers/" .. platform .. ".py"
local args local args
if platform == 'cses' then if platform == "cses" then
args = { args = {
'uv', "uv",
'run', "run",
'--directory', "--directory",
plugin_path, plugin_path,
scraper_path, scraper_path,
'metadata', "metadata",
} }
else else
args = { args = {
'uv', "uv",
'run', "run",
'--directory', "--directory",
plugin_path, plugin_path,
scraper_path, scraper_path,
'metadata', "metadata",
contest_id, contest_id,
} }
end end
@ -118,8 +108,7 @@ function M.scrape_contest_metadata(platform, contest_id)
if result.code ~= 0 then if result.code ~= 0 then
return { return {
success = false, success = false,
error = 'Failed to run metadata scraper: ' error = "Failed to run metadata scraper: " .. (result.stderr or "Unknown error"),
.. (result.stderr or 'Unknown error'),
} }
end end
@ -127,8 +116,7 @@ function M.scrape_contest_metadata(platform, contest_id)
if not ok then if not ok then
return { return {
success = false, success = false,
error = 'Failed to parse metadata scraper output: ' error = "Failed to parse metadata scraper output: " .. tostring(data),
.. tostring(data),
} }
end end
@ -137,9 +125,8 @@ function M.scrape_contest_metadata(platform, contest_id)
end end
local problems_list local problems_list
if platform == 'cses' then if platform == "cses" then
problems_list = data.categories and data.categories['CSES Problem Set'] problems_list = data.categories and data.categories["CSES Problem Set"] or {}
or {}
else else
problems_list = data.problems or {} problems_list = data.problems or {}
end end
@ -155,15 +142,12 @@ end
---@return {success: boolean, problem_id: string, test_count?: number, test_cases?: table[], url?: string, error?: string} ---@return {success: boolean, problem_id: string, test_count?: number, test_cases?: table[], url?: string, error?: string}
function M.scrape_problem(ctx) function M.scrape_problem(ctx)
vim.validate({ vim.validate({
ctx = { ctx, 'table' }, ctx = { ctx, "table" },
}) })
ensure_io_directory() ensure_io_directory()
if if vim.fn.filereadable(ctx.input_file) == 1 and vim.fn.filereadable(ctx.expected_file) == 1 then
vim.fn.filereadable(ctx.input_file) == 1
and vim.fn.filereadable(ctx.expected_file) == 1
then
return { return {
success = true, success = true,
problem_id = ctx.problem_name, problem_id = ctx.problem_name,
@ -175,7 +159,7 @@ function M.scrape_problem(ctx)
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
@ -183,32 +167,32 @@ function M.scrape_problem(ctx)
return { return {
success = false, success = false,
problem_id = ctx.problem_name, problem_id = ctx.problem_name,
error = 'Python environment setup failed', error = "Python environment setup failed",
} }
end end
local plugin_path = get_plugin_path() local plugin_path = get_plugin_path()
local scraper_path = plugin_path .. '/scrapers/' .. ctx.contest .. '.py' local scraper_path = plugin_path .. "/scrapers/" .. ctx.contest .. ".py"
local args local args
if ctx.contest == 'cses' then if ctx.contest == "cses" then
args = { args = {
'uv', "uv",
'run', "run",
'--directory', "--directory",
plugin_path, plugin_path,
scraper_path, scraper_path,
'tests', "tests",
ctx.contest_id, ctx.contest_id,
} }
else else
args = { args = {
'uv', "uv",
'run', "run",
'--directory', "--directory",
plugin_path, plugin_path,
scraper_path, scraper_path,
'tests', "tests",
ctx.contest_id, ctx.contest_id,
ctx.problem_id, ctx.problem_id,
} }
@ -224,8 +208,7 @@ function M.scrape_problem(ctx)
return { return {
success = false, success = false,
problem_id = ctx.problem_name, problem_id = ctx.problem_name,
error = 'Failed to run tests scraper: ' error = "Failed to run tests scraper: " .. (result.stderr or "Unknown error"),
.. (result.stderr or 'Unknown error'),
} }
end end
@ -234,7 +217,7 @@ function M.scrape_problem(ctx)
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
@ -243,14 +226,11 @@ function M.scrape_problem(ctx)
end end
if data.test_cases and #data.test_cases > 0 then if data.test_cases and #data.test_cases > 0 then
local combined_input = data.test_cases[1].input:gsub('\r', '') local combined_input = data.test_cases[1].input:gsub("\r", "")
local combined_output = data.test_cases[1].output:gsub('\r', '') local combined_output = data.test_cases[1].output:gsub("\r", "")
vim.fn.writefile(vim.split(combined_input, '\n', true), ctx.input_file) vim.fn.writefile(vim.split(combined_input, "\n", true), ctx.input_file)
vim.fn.writefile( vim.fn.writefile(vim.split(combined_output, "\n", true), ctx.expected_file)
vim.split(combined_output, '\n', true),
ctx.expected_file
)
end end
return { return {

23
lua/cp/snippets.lua
View file

@ -1,20 +1,16 @@
local M = {} local M = {}
local logger = require('cp.log') local logger = require("cp.log")
function M.setup(config) function M.setup(config)
local ok, ls = pcall(require, 'luasnip') local ok, ls = pcall(require, "luasnip")
if not ok then if not ok then
logger.log( logger.log("LuaSnip not available - snippets disabled", vim.log.levels.INFO)
'LuaSnip not available - snippets disabled',
vim.log.levels.INFO
)
return return
end end
local s, i, fmt = local s, i, fmt = ls.snippet, ls.insert_node, require("luasnip.extras.fmt").fmt
ls.snippet, ls.insert_node, require('luasnip.extras.fmt').fmt
local constants = require('cp.constants') local constants = require("cp.constants")
local filetype_to_language = constants.filetype_to_language local filetype_to_language = constants.filetype_to_language
local language_to_filetype = {} local language_to_filetype = {}
@ -114,17 +110,14 @@ if __name__ == "__main__":
local filetype = constants.canonical_filetypes[language] local filetype = constants.canonical_filetypes[language]
for contest, template in pairs(template_set) do for contest, template in pairs(template_set) do
local prefixed_trigger = ('cp.nvim/%s.%s'):format(contest, language) local prefixed_trigger = ("cp.nvim/%s.%s"):format(contest, language)
if not user_overrides[prefixed_trigger] then if not user_overrides[prefixed_trigger] then
table.insert( table.insert(snippets, s(prefixed_trigger, fmt(template, { i(1) })))
snippets,
s(prefixed_trigger, fmt(template, { i(1) }))
)
end end
end end
for trigger, snippet in pairs(user_overrides) do for trigger, snippet in pairs(user_overrides) do
local prefix_match = trigger:match('^cp%.nvim/[^.]+%.(.+)$') local prefix_match = trigger:match("^cp%.nvim/[^.]+%.(.+)$")
if prefix_match == language then if prefix_match == language then
table.insert(snippets, snippet) table.insert(snippets, snippet)
end end

71
lua/cp/test.lua
View file

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

20
lua/cp/version.lua
View file

@ -1,29 +1,25 @@
local M = {} local M = {}
local function get_git_version() local function get_git_version()
local plugin_path = debug.getinfo(1, 'S').source:sub(2) local plugin_path = debug.getinfo(1, "S").source:sub(2)
local plugin_root = vim.fn.fnamemodify(plugin_path, ':h:h:h') local plugin_root = vim.fn.fnamemodify(plugin_path, ":h:h:h")
local result = vim.system( local result = vim.system({ "git", "describe", "--tags", "--always", "--dirty" }, {
{ 'git', 'describe', '--tags', '--always', '--dirty' },
{
cwd = plugin_root, cwd = plugin_root,
text = true, text = true,
} }):wait()
)
: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),

66
lua/cp/window.lua
View file

@ -10,14 +10,14 @@
---@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
@ -46,8 +46,8 @@ end
---@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
@ -56,40 +56,32 @@ function M.restore_layout(state, tile_fn)
vim.cmd.diffoff() vim.cmd.diffoff()
local problem_id = vim.fn.expand('%:t:r') local problem_id = vim.fn.expand("%:t:r")
if problem_id == '' then if problem_id == "" then
for win, win_state in pairs(state.windows) do for win, win_state in pairs(state.windows) do
if if vim.api.nvim_win_is_valid(win) and vim.api.nvim_buf_is_valid(win_state.bufnr) then
vim.api.nvim_win_is_valid(win)
and vim.api.nvim_buf_is_valid(win_state.bufnr)
then
local bufname = vim.api.nvim_buf_get_name(win_state.bufnr) local bufname = vim.api.nvim_buf_get_name(win_state.bufnr)
if if not bufname:match("%.in$") and not bufname:match("%.out$") and not bufname:match("%.expected$") then
not bufname:match('%.in$') problem_id = vim.fn.fnamemodify(bufname, ":t:r")
and not bufname:match('%.out$')
and not bufname:match('%.expected$')
then
problem_id = vim.fn.fnamemodify(bufname, ':t:r')
break break
end end
end end
end end
end end
if problem_id ~= '' then if problem_id ~= "" then
vim.cmd('silent only') vim.cmd("silent only")
local base_fp = vim.fn.getcwd() local base_fp = vim.fn.getcwd()
local input_file = ('%s/io/%s.in'):format(base_fp, problem_id) local input_file = ("%s/io/%s.in"):format(base_fp, problem_id)
local output_file = ('%s/io/%s.out'):format(base_fp, problem_id) local output_file = ("%s/io/%s.out"):format(base_fp, problem_id)
local source_files = vim.fn.glob(problem_id .. '.*') local source_files = vim.fn.glob(problem_id .. ".*")
local source_file local source_file
if source_files ~= '' then if source_files ~= "" then
local files = vim.split(source_files, '\n') local files = vim.split(source_files, "\n")
local valid_extensions = local valid_extensions = vim.tbl_keys(constants.filetype_to_language)
vim.tbl_keys(constants.filetype_to_language)
for _, file in ipairs(files) do for _, file in ipairs(files) do
local ext = vim.fn.fnamemodify(file, ':e') local ext = vim.fn.fnamemodify(file, ":e")
if vim.tbl_contains(valid_extensions, ext) then if vim.tbl_contains(valid_extensions, ext) then
source_file = file source_file = file
break break
@ -135,22 +127,22 @@ end
---@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

41
plugin/cp.lua
View file

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

4
stylua.toml
View file

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