462 lines
14 KiB
Lua
462 lines
14 KiB
Lua
local dev_plugins = {
|
|
'midnight.nvim',
|
|
'live-server.nvim',
|
|
'nonicons.nvim',
|
|
'canola.nvim',
|
|
'pending.nvim',
|
|
'cp.nvim',
|
|
'diffs.nvim',
|
|
'render.nvim',
|
|
}
|
|
|
|
local opt_dir = vim.fn.stdpath('data') .. '/site/pack/dev/opt/'
|
|
vim.fn.mkdir(opt_dir, 'p')
|
|
for _, name in ipairs(dev_plugins) do
|
|
local link = opt_dir .. name
|
|
if not vim.uv.fs_lstat(link) then
|
|
vim.uv.fs_symlink(vim.fn.expand('~/dev/' .. name), link)
|
|
end
|
|
end
|
|
|
|
local function parse_output(proc)
|
|
local result = proc:wait()
|
|
local ret = {}
|
|
if result.code == 0 then
|
|
for line in
|
|
vim.gsplit(result.stdout, '\n', { plain = true, trimempty = true })
|
|
do
|
|
ret[line:gsub('/$', '')] = true
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
local function new_git_status()
|
|
return setmetatable({}, {
|
|
__index = function(self, key)
|
|
local ignored_proc = vim.system({
|
|
'git',
|
|
'ls-files',
|
|
'--ignored',
|
|
'--exclude-standard',
|
|
'--others',
|
|
'--directory',
|
|
}, { cwd = key, text = true })
|
|
local tracked_proc = vim.system(
|
|
{ 'git', 'ls-tree', 'HEAD', '--name-only' },
|
|
{ cwd = key, text = true }
|
|
)
|
|
local ret = {
|
|
ignored = parse_output(ignored_proc),
|
|
tracked = parse_output(tracked_proc),
|
|
}
|
|
rawset(self, key, ret)
|
|
return ret
|
|
end,
|
|
})
|
|
end
|
|
|
|
local git_status = new_git_status()
|
|
|
|
local clang_format = [[BasedOnStyle: LLVM
|
|
IndentWidth: 2
|
|
UseTab: Never
|
|
|
|
AllowShortIfStatementsOnASingleLine: Never
|
|
AllowShortLoopsOnASingleLine: false
|
|
AllowShortFunctionsOnASingleLine: None
|
|
AllowShortLambdasOnASingleLine: None
|
|
AllowShortBlocksOnASingleLine: Never
|
|
AllowShortEnumsOnASingleLine: false
|
|
AllowShortCaseExpressionOnASingleLine: false
|
|
|
|
BreakBeforeBraces: Attach
|
|
ColumnLimit: 100
|
|
AlignAfterOpenBracket: Align
|
|
BinPackArguments: false
|
|
BinPackParameters: false]]
|
|
|
|
local cpp_base = [[#include <bits/stdc++.h> // {{{
|
|
|
|
#include <version>
|
|
#ifdef __cpp_lib_ranges_enumerate
|
|
#include <ranges>
|
|
namespace rv = std::views;
|
|
namespace rs = std::ranges;
|
|
#endif
|
|
|
|
#pragma GCC optimize("O2,unroll-loops")
|
|
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
|
|
|
|
using namespace std;
|
|
|
|
using i32 = int32_t;
|
|
using u32 = uint32_t;
|
|
using i64 = int64_t;
|
|
using u64 = uint64_t;
|
|
using f64 = double;
|
|
using f128 = long double;
|
|
|
|
#if __cplusplus >= 202002L
|
|
template <typename T>
|
|
constexpr T MIN = std::numeric_limits<T>::min();
|
|
|
|
template <typename T>
|
|
constexpr T MAX = std::numeric_limits<T>::max();
|
|
#endif
|
|
|
|
#ifdef LOCAL
|
|
#define db(...) std::print(__VA_ARGS__)
|
|
#define dbln(...) std::println(__VA_ARGS__)
|
|
#else
|
|
#define db(...)
|
|
#define dbln(...)
|
|
#endif
|
|
// }}}
|
|
|
|
void solve() {
|
|
<++>
|
|
}
|
|
|
|
int main() { // {{{
|
|
std::cin.exceptions(std::cin.failbit);
|
|
#ifdef LOCAL
|
|
std::cerr.rdbuf(std::cout.rdbuf());
|
|
std::cout.setf(std::ios::unitbuf);
|
|
std::cerr.setf(std::ios::unitbuf);
|
|
#else
|
|
std::cin.tie(nullptr)->sync_with_stdio(false);
|
|
#endif
|
|
]]
|
|
|
|
local cpp_single = cpp_base .. [[ solve();
|
|
return 0;
|
|
} // }}}]]
|
|
|
|
local cpp_multi = cpp_base
|
|
.. [[ u32 tc = 1;
|
|
std::cin >> tc;
|
|
for (u32 t = 0; t < tc; ++t) {
|
|
solve();
|
|
}
|
|
return 0;
|
|
} // }}}]]
|
|
|
|
local templates = {
|
|
cpp = {
|
|
default = cpp_multi,
|
|
codeforces = cpp_multi,
|
|
atcoder = cpp_single,
|
|
cses = cpp_single,
|
|
},
|
|
python = {
|
|
default = [[def main() -> None:
|
|
<++>
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()]],
|
|
},
|
|
}
|
|
|
|
local function insert_template(buf, lang, platform)
|
|
local lang_templates = templates[lang]
|
|
if not lang_templates then
|
|
return false
|
|
end
|
|
|
|
local template = lang_templates[platform] or lang_templates.default
|
|
if not template then
|
|
return false
|
|
end
|
|
|
|
local lines = vim.split(template, '\n')
|
|
vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
|
|
|
|
for lnum, line in ipairs(lines) do
|
|
local col = line:find('<++>', 1, true)
|
|
if col then
|
|
local new_line = line:sub(1, col - 1) .. line:sub(col + 4)
|
|
vim.api.nvim_buf_set_lines(buf, lnum - 1, lnum, false, { new_line })
|
|
vim.api.nvim_win_set_cursor(0, { lnum, col - 1 })
|
|
break
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
return {
|
|
{
|
|
'barrettruth/midnight.nvim',
|
|
enabled = false,
|
|
after = function()
|
|
vim.cmd.colorscheme('midnight')
|
|
end,
|
|
},
|
|
{
|
|
'barrettruth/live-server.nvim',
|
|
enabled = false,
|
|
before = function()
|
|
vim.g.live_server = {
|
|
debug = false,
|
|
}
|
|
end,
|
|
keys = { { '<leader>l', '<cmd>LiveServerToggle<cr>' } },
|
|
},
|
|
{
|
|
'barrettruth/nonicons.nvim',
|
|
enabled = false,
|
|
},
|
|
{
|
|
'barrettruth/canola.nvim',
|
|
enabled = true,
|
|
after = function()
|
|
require('oil').setup({
|
|
skip_confirm_for_simple_edits = true,
|
|
prompt_save_on_select_new_entry = false,
|
|
float = { border = 'single' },
|
|
view_options = {
|
|
is_hidden_file = function(name, bufnr)
|
|
local dir = require('oil').get_current_dir(bufnr)
|
|
local is_dotfile = vim.startswith(name, '.')
|
|
and name ~= '..'
|
|
if not dir then
|
|
return is_dotfile
|
|
end
|
|
if is_dotfile then
|
|
return not git_status[dir].tracked[name]
|
|
else
|
|
return git_status[dir].ignored[name]
|
|
end
|
|
end,
|
|
},
|
|
keymaps = {
|
|
['<C-h>'] = false,
|
|
['<C-t>'] = false,
|
|
['<C-l>'] = false,
|
|
['<C-r>'] = 'actions.refresh',
|
|
['<C-s>'] = { 'actions.select', opts = { vertical = true } },
|
|
['<C-x>'] = {
|
|
'actions.select',
|
|
opts = { horizontal = true },
|
|
},
|
|
q = function()
|
|
local ok, bufremove = pcall(require, 'mini.bufremove')
|
|
if ok then
|
|
bufremove.delete()
|
|
else
|
|
vim.cmd.bd()
|
|
end
|
|
end,
|
|
},
|
|
})
|
|
local refresh = require('oil.actions').refresh
|
|
local orig_refresh = refresh.callback
|
|
refresh.callback = function(...)
|
|
git_status = new_git_status()
|
|
orig_refresh(...)
|
|
end
|
|
vim.api.nvim_create_autocmd('BufEnter', {
|
|
callback = function()
|
|
local ft = vim.bo.filetype
|
|
if ft == '' then
|
|
local path = vim.fn.expand('%:p')
|
|
if vim.fn.isdirectory(path) == 1 then
|
|
vim.cmd('Oil ' .. path)
|
|
end
|
|
end
|
|
end,
|
|
group = vim.api.nvim_create_augroup('AOil', { clear = true }),
|
|
})
|
|
end,
|
|
event = 'DeferredUIEnter',
|
|
keys = {
|
|
{ '-', '<cmd>e .<cr>' },
|
|
{ '_', '<cmd>Oil<cr>' },
|
|
},
|
|
},
|
|
{
|
|
'barrettruth/pending.nvim',
|
|
before = function()
|
|
vim.g.pending = { debug = true }
|
|
end,
|
|
keys = { { '<leader>p', '<cmd>Pending<cr>' } },
|
|
},
|
|
{
|
|
'barrettruth/cp.nvim',
|
|
cmd = 'CP',
|
|
keys = {
|
|
{ '<leader>ce', '<cmd>CP edit<cr>' },
|
|
{ '<leader>cp', '<cmd>CP panel<cr>' },
|
|
{ '<leader>cP', '<cmd>CP pick<cr>' },
|
|
{ '<leader>cr', '<cmd>CP run all<cr>' },
|
|
{ '<leader>cd', '<cmd>CP run --debug<cr>' },
|
|
{ ']c', '<cmd>CP next<cr>' },
|
|
{ '[c', '<cmd>CP prev<cr>' },
|
|
},
|
|
before = function()
|
|
vim.g.cp = {
|
|
debug = false,
|
|
languages = {
|
|
cpp = {
|
|
extension = 'cc',
|
|
commands = {
|
|
build = {
|
|
'g++',
|
|
'-std=c++23',
|
|
'-O2',
|
|
'-Wall',
|
|
'-Wextra',
|
|
'-Wpedantic',
|
|
'-Wshadow',
|
|
'-Wconversion',
|
|
'-Wformat=2',
|
|
'-Wfloat-equal',
|
|
'-Wundef',
|
|
'-fdiagnostics-color=always',
|
|
'-DLOCAL',
|
|
'{source}',
|
|
'-o',
|
|
'{binary}',
|
|
},
|
|
run = { '{binary}' },
|
|
debug = {
|
|
'g++',
|
|
'-std=c++23',
|
|
'-g3',
|
|
'-fsanitize=address,undefined',
|
|
'-fno-omit-frame-pointer',
|
|
'-fstack-protector-all',
|
|
'-D_GLIBCXX_DEBUG',
|
|
'-DLOCAL',
|
|
'{source}',
|
|
'-o',
|
|
'{binary}',
|
|
},
|
|
},
|
|
},
|
|
python = {
|
|
extension = 'py',
|
|
commands = {
|
|
run = { 'python', '{source}' },
|
|
debug = { 'python', '{source}' },
|
|
},
|
|
},
|
|
},
|
|
platforms = {
|
|
codeforces = {
|
|
enabled_languages = { 'cpp', 'python' },
|
|
default_language = 'cpp',
|
|
},
|
|
atcoder = {
|
|
enabled_languages = { 'cpp', 'python' },
|
|
default_language = 'cpp',
|
|
},
|
|
cses = {},
|
|
},
|
|
ui = {
|
|
picker = 'fzf-lua',
|
|
panel = { diff_modes = { 'side-by-side', 'git' } },
|
|
},
|
|
hooks = {
|
|
setup_io_input = function(buf)
|
|
require('cp.helpers').clearcol(buf)
|
|
end,
|
|
setup_io_output = function(buf)
|
|
require('cp.helpers').clearcol(buf)
|
|
end,
|
|
before_run = function(_)
|
|
require('config.lsp').format()
|
|
end,
|
|
before_debug = function(_)
|
|
require('config.lsp').format()
|
|
end,
|
|
setup_code = function(state)
|
|
vim.opt_local.winbar = ''
|
|
vim.opt_local.foldlevel = 0
|
|
vim.opt_local.foldmethod = 'marker'
|
|
vim.opt_local.foldmarker = '{{{,}}}'
|
|
vim.opt_local.foldtext = ''
|
|
vim.diagnostic.enable(false)
|
|
|
|
local buf = vim.api.nvim_get_current_buf()
|
|
local lines =
|
|
vim.api.nvim_buf_get_lines(buf, 0, 1, true)
|
|
if #lines > 1 or (#lines == 1 and lines[1] ~= '') then
|
|
return
|
|
end
|
|
|
|
local lang = state.get_language()
|
|
local platform = state.get_platform()
|
|
insert_template(buf, lang, platform)
|
|
|
|
local clang_format_path = vim.fn.getcwd()
|
|
.. '/.clang-format'
|
|
if vim.fn.filereadable(clang_format_path) == 0 then
|
|
vim.fn.writefile(
|
|
vim.split(clang_format, '\n'),
|
|
clang_format_path
|
|
)
|
|
end
|
|
end,
|
|
},
|
|
filename = function(_, _, problem_id)
|
|
return problem_id
|
|
end,
|
|
}
|
|
end,
|
|
},
|
|
{
|
|
'barrettruth/render.nvim',
|
|
ft = { 'typst', 'tex', 'markdown' },
|
|
before = function()
|
|
vim.g.render = {
|
|
providers = {
|
|
typst = {
|
|
cmd = { 'typst', 'compile' },
|
|
args = function(ctx)
|
|
return { ctx.file }
|
|
end,
|
|
output = function(ctx)
|
|
return ctx.file:gsub('%.typ$', '.pdf')
|
|
end,
|
|
},
|
|
latexmk = {
|
|
cmd = { 'latexmk' },
|
|
args = function(ctx)
|
|
return { '-pdf', '-interaction=nonstopmode', ctx.file }
|
|
end,
|
|
output = function(ctx)
|
|
return ctx.file:gsub('%.tex$', '.pdf')
|
|
end,
|
|
clean = { 'latexmk', '-c' },
|
|
},
|
|
pandoc = {
|
|
cmd = { 'pandoc' },
|
|
args = function(ctx)
|
|
local output = ctx.file:gsub('%.md$', '.html')
|
|
return { ctx.file, '-s', '--embed-resources', '-o', output }
|
|
end,
|
|
output = function(ctx)
|
|
return ctx.file:gsub('%.md$', '.html')
|
|
end,
|
|
clean = function(ctx)
|
|
return { 'rm', '-f', ctx.file:gsub('%.md$', '.html') }
|
|
end,
|
|
},
|
|
},
|
|
providers_by_ft = {
|
|
typst = 'typst',
|
|
tex = 'latexmk',
|
|
markdown = 'pandoc',
|
|
},
|
|
}
|
|
end,
|
|
keys = {
|
|
{ '<leader>rr', '<cmd>Render compile<cr>' },
|
|
{ '<leader>rs', '<cmd>Render stop<cr>' },
|
|
{ '<leader>rc', '<cmd>Render clean<cr>' },
|
|
},
|
|
},
|
|
}
|