refactor(configs): completely overhauled how projects and files are handled

1. Run is now handled by the global run function instead
of language specific runs
2. Fixed some notifications, making them more unified and informational
3. Cleaned up c/c++ code that was broken from create_file changes
4. Create_file has new architecture. It still takes in a function but
   can be disabled to be skipped (this will most likely change later as
   its unoptimized)
5. Added rust support
6. Keybinds are now only setup for language specific
7. Project creation has error and nil checking allowing for skipping and
   more customizable templates and setups for future languages
This commit is contained in:
DarthMooMancer committed 2026-10-30 13:24:38 -04:00
1 parent 72951f7327
commit 9a6eb90efc
22 files changed
+562 -407

No files matched your search

+198
View File
@@ -0,0 +1,198 @@
local M = {}
local utils = require("vern-nvim.utils")
local templates = require("vern-nvim.templates")
---Imitate create_file so you can skip over and use for each filetype
M.create_project = function(opts)
opts = opts or {}
vim.ui.input(
{ prompt = "Project language (e.g. python): ", completion = "filetype" },
function(ft)
ft = ft and vim.trim(ft)
if not ft or vim.trim(ft) == "" then
vim.notify("Unknown Filetype: " .. ft, vim.log.levels.WARN, {
title = "Vern Project",
})
return
end
local ok, configs = pcall(require, "vern-nvim.configs." .. ft)
if not ok or type(configs) ~= "table" then return end
local args = vim.tbl_deep_extend("force", {}, configs, opts or {})
if not args[ft] or type(args[ft]) ~= "table" then return end
vim.ui.input({ prompt = "Enter project name: " }, function(pname)
pname = pname and vim.trim(pname)
if not pname or pname == "" then return end
local root = vim.fs.joinpath(
vim.fn.expand(args.workspace_root),
args[ft].root,
pname
)
local ctx = {
project_name = pname,
company_name = args.env.author,
file_name = "",
}
vim.fn.mkdir(root, "p")
local tpl = args[ft].templates or {}
local dirs = args[ft].dirs
if type(dirs) == "table" and next(dirs) then
for _, dir in pairs(dirs) do
local path = vim.fs.normalize(
vim.fs.joinpath(root, utils.fmt(dir, ctx))
)
vim.fn.mkdir(path, "p")
end
end
local bin
local project = tpl.project
if type(project) == "table" and next(project) then
for tbl_name, tbl in pairs(project) do
local raw_path = vim.fs.joinpath(tbl.path, tbl.name)
local path =
utils.resolve_path(raw_path, args[ft].dirs, ctx)
if tbl_name == "primary" then
bin = vim.fs.joinpath(root, path)
end
if tbl.kind then
local abs_file_path =
vim.fs.normalize(vim.fs.joinpath(root, path))
local abs_dir_path = vim.fs.dirname(abs_file_path)
if
abs_dir_path ~= root
and not vim.startswith(root, abs_dir_path)
then
vim.fn.mkdir(abs_dir_path, "p")
end
utils.dump(
abs_file_path,
templates.fetch(tbl.kind_path, tbl.kind, ctx)
)
end
end
end
local extras = tpl.extras
if type(extras) == "table" and next(extras) then
for _, tbl in pairs(extras) do
if tbl.enabled ~= false and tbl.kind then
local raw_path = vim.fs.joinpath(tbl.path, tbl.name)
local path =
utils.resolve_path(raw_path, args[ft].dirs, ctx)
local abs_file_path =
vim.fs.normalize(vim.fs.joinpath(root, path))
local abs_dir_path = vim.fs.dirname(abs_file_path)
if
abs_dir_path ~= root
and not vim.startswith(root, abs_dir_path)
then
vim.fn.mkdir(abs_dir_path, "p")
end
utils.dump(
abs_file_path,
templates.fetch(tbl.kind_path, tbl.kind, ctx)
)
end
end
end
if type(configs.create_project) == "function" then
configs.create_project(root)
end
utils.init_git(root, ft)
utils.init_readme(root)
if bin then vim.cmd.edit(vim.fn.fnameescape(bin)) end
vim.notify(
"Project: " .. pname .. " has been created!",
vim.log.levels.INFO,
{ title = "Vern Project" }
)
end)
end
)
end
M.create_file = function(opts)
opts = opts or {}
local filetype = vim.bo.filetype
local ft_ok, config = pcall(require, "vern-nvim.configs." .. filetype)
---@type VernCreateFile
if
not filetype
or filetype == ""
or not ft_ok
or type(config) ~= "table"
then
vim.notify("Unknown Filetype: " .. filetype, vim.log.levels.WARN, {
title = "Vern File",
})
return
else
local args = vim.tbl_deep_extend("force", {}, config, opts or {})
local cf = args.create_file
local function function_write(mod, fname)
local raw_path = vim.fs.joinpath(mod.path, mod.name)
local context = {
project_name = utils.proj_name(),
company_name = args.env.author,
file_name = fname,
}
local path =
utils.resolve_path(raw_path, args[filetype].dirs or {}, context)
local full_path = vim.fs.joinpath(utils.proj_root(), path)
utils.dump(
full_path,
templates.fetch(mod.kind_path, mod.kind, context)
)
vim.cmd.edit(vim.fn.fnameescape(full_path))
vim.notify(
fname .. " has been created!",
vim.log.levels.INFO,
{ title = "Vern File" }
)
end
vim.ui.input({ prompt = "Enter file name: " }, function(fname)
fname = fname and vim.trim(fname)
if not fname or fname == "" then return end
local done = function(mod)
if not mod or vim.tbl_isempty(mod) then return end
function_write(mod, fname)
end
if cf and type(cf.func) == "function" and cf.allowed then
cf.func(args, done)
else
done(args[filetype].templates.file.source)
end
end)
end
end
M.run = function(opts)
opts = opts or {}
local filetype = vim.bo.filetype
local ft_ok, action = pcall(require, "vern-nvim.actions." .. filetype)
if
not filetype
or filetype == ""
or not ft_ok
or type(action.run) ~= "function"
then
vim.notify("Unknown Filetype: " .. filetype, vim.log.levels.WARN, {
title = "Vern Run",
})
return
else
action.run(opts)
end
end
return M
+25 -54
View File
@@ -2,78 +2,49 @@ local M = {}
local utils = require("vern-nvim.utils")
---@param root string
M.create_project = function(root)
local build_cmd = "cd " .. root .. " && cmake -S . -B build && cmake --build build"
local _ = vim.system({ "sh", "-c", build_cmd }):wait()
end
---@param opts VernCConfig
M.create_file = function(opts)
opts = opts or {}
vim.ui.input({ prompt = "Enter type (c/h): " }, function(ft)
ft = ft and vim.trim(ft)
if not ft or ft == "" then
return
end
local mod = {}
if ft == "c" then
mod = opts.c.templates.file.source or {}
end
if ft == "h" then
mod = opts.c.templates.file.header or {}
end
vim.ui.input({ prompt = "Enter file name: " }, function(fname)
fname = fname and vim.trim(fname)
if not fname or fname == "" then
return
end
local raw_path = vim.fs.joinpath(mod.path, mod.name)
local context = {
project_name = utils.proj_name(),
company_name = opts.env.author,
file_name = fname,
}
local path = utils.resolve_path(raw_path, opts.c.dirs or {}, context)
local root = utils.proj_root()
utils.dump(
vim.fs.joinpath(root, path),
require("vern-nvim.templates").fetch(mod.kind_path, mod.kind, context)
)
vim.cmd.edit(vim.fn.expand(path))
vim.notify(fname .. " has been created!", vim.log.levels.INFO, { title = "Vern File" })
end)
end)
end
---@param opts? VernCConfig Takes a table for the runtime
function M.run(opts)
opts = opts or {}
local root = utils.proj_root() or "."
local pname = vim.fs.basename(root)
local build_dir = root .. "/build"
local build_cmd = "cd " .. build_dir .. " && cmake --build ."
local build_cmd =
string.format("cd %s/build && cmake --build .", utils.proj_root())
vim.system({ "sh", "-c", build_cmd }, { text = true }, function(obj)
if obj.code ~= 0 then
vim.schedule(function()
local error_obj = (obj.stderr ~= "" and obj.stderr) or obj.stdout or ""
local error_obj = (obj.stderr ~= "" and obj.stderr)
or obj.stdout
or ""
local error_lines = vim.list_extend(
{ "Error During compilation" },
vim.split(error_obj, "\n", { trimempty = true })
)
local buf, _ = utils.term({ "echo 'compilation failed'" }, opts.terminal, true)
local buf, _ = utils.term(
{ "echo 'compilation failed'" },
opts.terminal,
true
)
if buf and vim.api.nvim_buf_is_valid(buf) then
vim.api.nvim_set_option_value("modifiable", true, { buf = buf })
vim.api.nvim_set_option_value(
"modifiable",
true,
{ buf = buf }
)
vim.api.nvim_buf_set_lines(buf, 0, -1, false, error_lines)
vim.api.nvim_set_option_value("modifiable", false, { buf = buf })
vim.api.nvim_set_option_value(
"modifiable",
false,
{ buf = buf }
)
end
end)
else
vim.schedule(function()
local run_cmd = "cd '" .. build_dir .. "' && ./" .. pname
local run_cmd = string.format(
"cd %s/build && ./%s",
utils.proj_root(),
utils.proj_name()
)
utils.term({ run_cmd }, opts.terminal, false)
end)
end
+14 -56
View File
@@ -2,78 +2,36 @@ local M = {}
local utils = require("vern-nvim.utils")
---@param root string
M.create_project = function(root)
local build_cmd = "cd " .. root .. " && cmake -S . -B build && cmake --build build"
local _ = vim.system({ "sh", "-c", build_cmd }):wait()
end
---@param opts VernCPPConfig
M.create_file = function(opts)
opts = opts or {}
vim.ui.input({ prompt = "Enter type (c/h): " }, function(ft)
ft = ft and vim.trim(ft)
if not ft or ft == "" then
return
end
local mod = {}
if ft == "c" then
mod = opts.cpp.templates.file.source or {}
end
if ft == "h" then
mod = opts.cpp.templates.file.header or {}
end
vim.ui.input({ prompt = "Enter file name: " }, function(fname)
fname = fname and vim.trim(fname)
if not fname or fname == "" then
return
end
local raw_path = vim.fs.joinpath(mod.path, mod.name)
local context = {
project_name = utils.proj_name(),
company_name = opts.env.author,
file_name = fname,
}
local path = utils.resolve_path(raw_path, opts.cpp.dirs or {}, context)
local root = utils.proj_root()
utils.dump(
vim.fs.joinpath(root, path),
require("vern-nvim.templates").fetch(mod.kind_path, mod.kind, context)
)
vim.cmd.edit(vim.fn.expand(path))
vim.notify(fname .. " has been created!", vim.log.levels.INFO, { title = "Vern File" })
end)
end)
end
---@param opts? VernCPPConfig Takes a table for the runtime
function M.run(opts)
opts = opts or {}
local root = utils.proj_root() or "."
local pname = vim.fs.basename(root)
local build_dir = root .. "/build"
local build_dir = (utils.proj_root() or ".") .. "/build"
local build_cmd = "cd " .. build_dir .. " && cmake --build ."
vim.system({ "sh", "-c", build_cmd }, { text = true }, function(obj)
if obj.code ~= 0 then
vim.schedule(function()
local error_obj = (obj.stderr ~= "" and obj.stderr) or obj.stdout or ""
local error_obj = (obj.stderr ~= "" and obj.stderr)
or obj.stdout
or ""
local error_lines = vim.list_extend(
{ "Error During compilation" },
vim.split(error_obj, "\n", { trimempty = true })
)
local buf, _ = utils.term({ "echo 'compilation failed'" }, opts.terminal, true)
if buf and vim.api.nvim_buf_is_valid(buf) then
vim.api.nvim_set_option_value("modifiable", true, { buf = buf })
vim.api.nvim_buf_set_lines(buf, 0, -1, false, error_lines)
vim.api.nvim_set_option_value("modifiable", false, { buf = buf })
end
local buf, _ = utils.term(
{ "echo 'compilation failed'" },
opts.terminal,
true
)
utils.term_override(buf, error_lines)
end)
else
vim.schedule(function()
local run_cmd = "cd '" .. build_dir .. "' && ./" .. pname
local run_cmd = "cd '"
.. build_dir
.. "' && ./"
.. utils.proj_name()
utils.term({ run_cmd }, opts.terminal, false)
end)
end
-150
View File
@@ -1,150 +0,0 @@
local M = {}
---TODO
---Split filetype only and just change a filetype variable and vairables both share and then run the duplicate code
local utils = require("vern-nvim.utils")
local templates = require("vern-nvim.templates")
M.create_project = function(opts)
opts = opts or {}
vim.ui.input(
{ prompt = "Project language (e.g. python): ", completion = "filetype" },
function(ft)
ft = ft and vim.trim(ft)
if not ft or vim.trim(ft) == "" then
vim.notify("Unknown Filetype: " .. ft, vim.log.levels.WARN, {
title = "Vern Project",
})
return
end
local ok, actions = pcall(require, "vern-nvim.actions." .. ft)
local configs = require("vern-nvim.configs." .. ft)
local args = vim.tbl_deep_extend("force", {}, configs, opts or {})
vim.ui.input({ prompt = "Enter project name: " }, function(pname)
pname = pname and vim.trim(pname)
if not pname or pname == "" then
return
end
local root =
vim.fs.joinpath(vim.fn.expand(args.workspace_root), args[ft].root, pname)
local ctx = {
project_name = pname,
company_name = args.env.author,
file_name = "",
}
vim.fn.mkdir(root, "p")
for _, dir in pairs(args[ft].dirs) do
local path = vim.fs.normalize(vim.fs.joinpath(root, utils.fmt(dir, ctx)))
vim.fn.mkdir(path, "p")
end
local bin
for tbl_name, tbl in pairs(args[ft].templates.project) do
local raw_path = vim.fs.joinpath(tbl.path, tbl.name)
local path = utils.resolve_path(raw_path, args[ft].dirs, ctx)
if tbl_name == "primary" then
bin = vim.fs.joinpath(root, path)
end
local abs_file_path = vim.fs.normalize(vim.fs.joinpath(root, path))
local abs_dir_path = vim.fs.dirname(abs_file_path)
if abs_dir_path ~= root and not vim.startswith(root, abs_dir_path) then
vim.fn.mkdir(abs_dir_path, "p")
end
utils.dump(abs_file_path, templates.fetch(tbl.kind_path, tbl.kind, ctx))
end
for _, tbl in pairs(args[ft].templates.extras) do
if tbl.enabled then
local raw_path = vim.fs.joinpath(tbl.path, tbl.name)
local path = utils.resolve_path(raw_path, args[ft].dirs, ctx)
local abs_file_path = vim.fs.normalize(vim.fs.joinpath(root, path))
local abs_dir_path = vim.fs.dirname(abs_file_path)
if abs_dir_path ~= root and not vim.startswith(root, abs_dir_path) then
vim.fn.mkdir(abs_dir_path, "p")
end
utils.dump(abs_file_path, templates.fetch(tbl.kind_path, tbl.kind, ctx))
end
end
utils.init_git(root, ft)
utils.init_readme(root)
if ok and actions and type(actions.create_project) == "function" then
actions.create_project(root)
end
vim.cmd.edit(vim.fn.fnameescape(bin))
vim.notify(
"Project: " .. pname .. " has been created!",
vim.log.levels.INFO,
{ title = "Vern Project" }
)
end)
end
)
end
M.create_file = function(opts)
opts = opts or {}
local filetype = vim.bo.filetype
local function continue_filetype(ft)
filetype = ft
local ok, actions = pcall(require, "vern-nvim.actions." .. filetype)
if not ok then
vim.notify("Unknown Filetype: " .. filetype, vim.log.levels.WARN, {
title = "Vern File",
})
return
end
local configs = require("vern-nvim.configs." .. filetype)
local args = vim.tbl_deep_extend("force", {}, configs, opts or {})
vim.ui.input({ prompt = "Enter file name: " }, function(fname)
fname = fname and vim.trim(fname)
if not fname or fname == "" then
return
end
local mod
if ok and actions and type(actions.create_file) == "function" then
mod = actions.create_file(args[filetype])
or args[filetype].templates.file.source
or {}
end
local raw_path = vim.fs.joinpath(mod.path, mod.name)
local context = {
project_name = utils.proj_name(),
company_name = opts.env.author,
file_name = fname,
}
local path = utils.resolve_path(raw_path, args[filetype].dirs or {}, context)
local root = utils.proj_root()
utils.dump(
vim.fs.joinpath(root, path),
templates.fetch(mod.kind_path, mod.kind, context)
)
vim.cmd.edit(vim.fn.fnameescape(path))
vim.notify(fname .. " has been created!", vim.log.levels.INFO, { title = "Vern File" })
end)
end
local ft_ok, ft_config = pcall(require, "vern-nvim.configs." .. filetype)
if not filetype or filetype == "" or not ft_ok or type(ft_config) ~= "table" then
vim.ui.input({
prompt = "File language (e.g. python): ",
completion = "filetype",
}, function(ft)
ft = ft and vim.trim(ft)
if not ft or vim.trim(ft) == "" then
return
end
continue_filetype(ft)
end)
else
continue_filetype(filetype)
end
end
return M
+22 -10
View File
@@ -2,10 +2,6 @@ local M = {}
local utils = require("vern-nvim.utils")
M.create_project = function() end
M.create_file = function() end
---@param opts VernJavaConfig Takes a table for the runtime
function M.run(opts)
opts = opts or {}
@@ -16,8 +12,10 @@ function M.run(opts)
file_name = "",
}
local src_root =
vim.fs.joinpath(root, utils.resolve_path(opts.java.dirs.src, opts.java.dirs, context))
local src_root = vim.fs.joinpath(
root,
utils.resolve_path(opts.java.dirs.src, opts.java.dirs, context)
)
local build_dir = root .. "/bin"
local build_cmd = string.format(
"javac -d %s -sourcepath %s $(find %s -name '*java')",
@@ -29,16 +27,30 @@ function M.run(opts)
vim.system({ "sh", "-c", build_cmd }, { text = true }, function(obj)
if obj.code ~= 0 then
vim.schedule(function()
local error_obj = (obj.stderr ~= "" and obj.stderr) or obj.stdout or ""
local error_obj = (obj.stderr ~= "" and obj.stderr)
or obj.stdout
or ""
local error_lines = vim.list_extend(
{ "Error During compilation" },
vim.split(error_obj, "\n", { trimempty = true })
)
local buf, _ = utils.term({ "echo 'compilation failed'" }, opts.terminal, true)
local buf, _ = utils.term(
{ "echo 'compilation failed'" },
opts.terminal,
true
)
if buf and vim.api.nvim_buf_is_valid(buf) then
vim.api.nvim_set_option_value("modifiable", true, { buf = buf })
vim.api.nvim_set_option_value(
"modifiable",
true,
{ buf = buf }
)
vim.api.nvim_buf_set_lines(buf, 0, -1, false, error_lines)
vim.api.nvim_set_option_value("modifiable", false, { buf = buf })
vim.api.nvim_set_option_value(
"modifiable",
false,
{ buf = buf }
)
end
end)
else
+8 -11
View File
@@ -2,20 +2,17 @@ local M = {}
local utils = require("vern-nvim.utils")
M.create_project = function() end
M.create_file = function() end
---@param opts VernCPPConfig Takes a table for the runtime
---@param opts VernLuaConfig Takes a table for the runtime
function M.run(opts)
opts = opts or {}
local root = utils.proj_root() or "."
local pname = vim.fs.basename(root)
local full_path =
vim.fs.joinpath(utils.proj_root(), "lua", utils.proj_name())
local full_path = vim.fs.joinpath(root, "lua", pname)
print(full_path .. "/init.lua")
utils.term({ "lua " .. full_path .. "/init.lua" }, opts.terminal or {}, false)
utils.term(
{ "lua " .. full_path .. "/init.lua" },
opts.terminal or {},
false
)
end
return M
+22 -12
View File
@@ -2,13 +2,6 @@ local M = {}
local utils = require("vern-nvim.utils")
---@param root string
M.create_project = function(root)
vim.fn.system("python3 -m venv " .. root .. "/venv")
end
M.create_file = function() end
---@param opts VernPythonConfig Takes a table for the runtime
function M.run(opts)
opts = opts or {}
@@ -20,7 +13,8 @@ function M.run(opts)
}
local bin = opts.python.templates.project.primary
local exe = vim.fs.joinpath(bin.path, bin.name) or "src/{project_name}/main.py"
local exe = vim.fs.joinpath(bin.path, bin.name)
or "src/{project_name}/main.py"
local exe_path = utils.resolve_path(exe, opts.python.dirs, context)
local full_path = vim.fs.joinpath(vim.fn.expand(root), exe_path)
utils.term({ "python3 " .. full_path }, opts.terminal or {}, false)
@@ -30,16 +24,32 @@ function M.pip_install()
vim.ui.input({ prompt = "Enter pip module: " }, function(mod)
mod = mod and vim.trim(mod)
if not mod or mod == "" then
vim.notify("Pip Cancelled", vim.log.levels.WARN)
vim.notify(
"Pip Cancelled",
vim.log.levels.WARN,
{ title = "Vern Python" }
)
return
end
vim.notify("Installing " .. mod, vim.log.levels.INFO)
vim.notify(
"Installing " .. mod,
vim.log.levels.INFO,
{ title = "Vern Python" }
)
vim.system({ "pip", "install", mod }, { text = true }, function(obj)
vim.schedule(function()
if obj.code ~= 0 then
vim.notify("Pip failed: " .. obj.stderr, vim.log.levels.WARN)
vim.notify(
"Pip failed: " .. obj.stderr,
vim.log.levels.WARN,
{ title = "Vern Python" }
)
else
vim.notify("Pip installed " .. mod, vim.log.levels.INFO)
vim.notify(
"Pip installed " .. mod,
vim.log.levels.INFO,
{ title = "Vern Python" }
)
end
end)
end)
+15
View File
@@ -0,0 +1,15 @@
local M = {}
local utils = require("vern-nvim.utils")
---@param opts VernRustConfig Takes a table for the runtime
function M.run(opts)
opts = opts or {}
utils.term(
{ "cd " .. utils.proj_root() .. " && cargo run" },
opts.terminal or {},
false
)
end
return M
+28 -12
View File
@@ -2,6 +2,33 @@ local M = {}
M.attach = function() end
---@param root string
M.create_project = function(root)
local build_cmd = "cd "
.. root
.. " && cmake -S . -B build && cmake --build build"
local _ = vim.system({ "sh", "-c", build_cmd }):wait()
end
---@type VernCreateFile
M.create_file = {
allowed = true,
---@param opts VernCConfig
func = function(opts, continue)
opts = opts or {}
local file = vim.tbl_get(opts, "c", "templates", "file")
local items = { "source", "header" }
vim.ui.select(items, {
prompt = "Select type:",
format_item = function(item) return item end,
}, function(choice, _)
if choice == items[1] then return continue(file.source) end
if choice == items[2] then return continue(file.header) end
continue(nil)
end)
end,
}
---@type VernLanguageConfig
M.c = {
root = "C",
@@ -9,18 +36,7 @@ M.c = {
src = "src",
include = "include/{project_name}",
},
keybinds = {
["<leader>pr"] = {
user_command = "CRun",
desc = "Executes c code",
action = require("vern-nvim.actions.c").run,
},
["<leader>pf"] = {
user_command = "CCreateFile",
desc = "Creates source/header files",
action = require("vern-nvim.actions.c").create_file,
},
},
keybinds = {},
templates = {
project = {
primary = {
+28 -12
View File
@@ -2,6 +2,33 @@ local M = {}
M.attach = function() end
---@param root string
M.create_project = function(root)
local build_cmd = "cd "
.. root
.. " && cmake -S . -B build && cmake --build build"
local _ = vim.system({ "sh", "-c", build_cmd }):wait()
end
---@type VernCreateFile
M.create_file = {
allowed = true,
---@param opts VernCPPConfig
func = function(opts, continue)
opts = opts or {}
local file = vim.tbl_get(opts, "cpp", "templates", "file")
local items = { "source", "header" }
vim.ui.select(items, {
prompt = "Select type:",
format_item = function(item) return item end,
}, function(choice, _)
if choice == items[1] then return continue(file.source) end
if choice == items[2] then return continue(file.header) end
continue(nil)
end)
end,
}
---@type VernLanguageConfig
M.cpp = {
root = "CPP",
@@ -9,18 +36,7 @@ M.cpp = {
src = "src",
include = "include/{project_name}",
},
keybinds = {
["<leader>pr"] = {
user_command = "CPPRun",
desc = "Executes cpp code",
action = require("vern-nvim.actions.cpp").run,
},
["<leader>pf"] = {
user_command = "CPPCreateFile",
desc = "Creates source/header files",
action = require("vern-nvim.actions.cpp").create_file,
},
},
keybinds = {},
templates = {
project = {
primary = {
+9 -4
View File
@@ -15,13 +15,18 @@ return {
},
["<leader>pf"] = {
user_command = "VernCreateFile",
desc = "Creates a new project file",
desc = "Creates a new project file based on current buffer filetype",
action = actions.create_file,
},
["<leader>pr"] = {
user_command = "VernRunProject",
desc = "Builds and runs project based on current buffer filetype",
action = actions.run,
},
},
terminal = {
mode = {
type = "split",
type = "split", --- (float)|(split)
win = {
float = {
padding = {
@@ -36,8 +41,8 @@ return {
},
},
split = {
direction = "horizontal",
anchor = "bottom",
direction = "horizontal", --- (vertical)|(horizontal)
anchor = "bottom", --- (right)|(bottom)
size = "20",
},
},
+9 -7
View File
@@ -2,6 +2,14 @@ local M = {}
M.attach = function() end
M.create_project = function() end
---@type VernCreateFile
M.create_file = {
allowed = false,
func = function(_, _) return nil end,
}
---@type VernLanguageConfig
M.java = {
root = "Java",
@@ -9,13 +17,7 @@ M.java = {
src = "src/com/{company_name}/{project_name}",
bin = "bin",
},
keybinds = {
["<leader>pr"] = {
user_command = "JavaRun",
desc = "Executes java code",
action = require("vern-nvim.actions.java").run,
},
},
keybinds = {},
templates = {
project = {
primary = {
+9 -7
View File
@@ -2,19 +2,21 @@ local M = {}
M.attach = function() end
M.create_project = function() end
---@type VernCreateFile
M.create_file = {
allowed = false,
func = function(_, _) return nil end,
}
---@type VernLanguageConfig
M.lua = {
root = "Lua",
dirs = {
src = "lua/{project_name}",
},
keybinds = {
["<leader>pr"] = {
user_command = "LuaRun",
desc = "Executes lua code",
action = require("vern-nvim.actions.lua").run,
},
},
keybinds = {},
templates = {
project = {
primary = {
+20 -9
View File
@@ -2,9 +2,7 @@ local M = {}
M.attach = function()
local root = require("vern-nvim.utils").proj_root()
if not root then
return
end
if not root then return end
local venv_dir = nil
if vim.uv.fs_stat(root .. "/venv/bin/python") then
venv_dir = root .. "/venv"
@@ -17,6 +15,24 @@ M.attach = function()
end
end
---@param root string
M.create_project = function(root)
local obj = vim.system({ "python3", "-m", "venv", root, "/venv" }):wait()
if obj.code ~= 0 then
vim.notify(
"Virtual environment failed to initialize " .. obj.stderr,
vim.log.levels.ERROR,
{ title = "Vern Python" }
)
end
end
---@type VernCreateFile
M.create_file = {
allowed = false,
func = function(_, _) return nil end,
}
---@type VernLanguageConfig
M.python = {
root = "Python",
@@ -24,13 +40,8 @@ M.python = {
src = "src/{project_name}",
},
keybinds = {
["<leader>pr"] = {
user_command = "Pythonrun",
desc = "Executes python code",
action = require("vern-nvim.actions.python").run,
},
["<leader>pi"] = {
user_command = "Pythonpip",
user_command = "VernPythonPip",
desc = "Install python packages for environment",
action = require("vern-nvim.actions.python").pip_install,
},
+46
View File
@@ -0,0 +1,46 @@
local M = {}
M.attach = function() end
M.create_project = function(root)
local obj = vim.system({
"cargo",
"init",
vim.fn.expand(root),
"--name",
vim.fs.basename(root),
}):wait()
if obj.code ~= 0 then
vim.notify("Cargo init failed:" .. obj.stderr, vim.log.levels.ERROR)
end
end
---@type VernCreateFile
M.create_file = {
allowed = false,
func = function(_, _) return nil end,
}
---@type VernLanguageConfig
M.rust = {
root = "Rust",
dirs = nil,
keybinds = {},
templates = {
project = {
primary = { path = "src", name = "main.rs" },
},
file = {
source = {
path = "src",
name = "{file_name}.rs",
kind = "source",
kind_path = "vern-nvim.templates.rust",
},
},
extras = {},
},
}
return M
+29 -27
View File
@@ -17,52 +17,54 @@ function M.setup(user_opts)
for key, def in pairs(M.opts.keybinds or {}) do
if type(def.action) == "function" then
vim.api.nvim_create_user_command(def.user_command, function()
def.action(M.opts)
end, { nargs = "*", desc = def.desc })
vim.keymap.set("n", key, function()
def.action(M.opts)
end, {
vim.api.nvim_create_user_command(
def.user_command,
function() def.action(M.opts) end,
{ nargs = "*", desc = def.desc }
)
vim.keymap.set("n", key, function() def.action(M.opts) end, {
silent = true,
desc = def.desc,
})
end
end
local group = vim.api.nvim_create_augroup("VernAutocommands", { clear = true })
local group =
vim.api.nvim_create_augroup("VernAutocommands", { clear = true })
vim.api.nvim_create_autocmd("FileType", {
group = group,
pattern = "*",
callback = function(args)
local ft = vim.bo[args.buf].filetype
if not ft or ft == "" then
return
end
local has_config, mod = pcall(require, "vern-nvim.configs." .. ft)
if not has_config then
return
end
if not ft or ft == "" then return end
local ok, mod = pcall(require, "vern-nvim.configs." .. ft)
if not ok then return end
local opts = vim.tbl_deep_extend("force", {}, mod, M.opts or {})
if opts[ft] and opts[ft].keybinds then
for key, def in pairs(opts[ft].keybinds or {}) do
if type(def.action) == "function" then
vim.api.nvim_buf_create_user_command(args.buf, def.user_command, function()
def.action(opts)
end, { nargs = "*", desc = def.desc })
vim.keymap.set("n", key, function()
def.action(opts)
end, {
buffer = args.buf,
silent = true,
desc = def.desc,
})
vim.api.nvim_buf_create_user_command(
args.buf,
def.user_command,
function() def.action(opts) end,
{ nargs = "*", desc = def.desc }
)
vim.keymap.set(
"n",
key,
function() def.action(opts) end,
{
buffer = args.buf,
silent = true,
desc = def.desc,
}
)
end
end
end
local ok, attach_mod = pcall(require, "vern-nvim.configs." .. ft)
if ok and type(attach_mod.attach) == "function" then
attach_mod.attach(args.buf, opts)
if ok and type(mod.attach) == "function" then
mod.attach(args.buf, opts)
end
end,
desc = "Attach languages to buffer",
File renamed without changes.
@@ -42,6 +42,15 @@ bin/
*.class
*.jar
]=]),
rust = vim.trim([=[
debug
target
**/*.rs.bk
*.pdb
**/mutants.out*/
rustc-ice-*.txt
#.idea/
]=]),
}
local extra = (lang and lang_block[lang]) or ""
+9
View File
@@ -0,0 +1,9 @@
return {
--[[ =====================================================================
TEMPLATE: SOURCE (Standalone File)
File: {name}.rs
Target: src/{name}.rs
===================================================================== --]]
source = vim.trim([=[
]=]) .. "\n",
}
+13 -6
View File
@@ -2,6 +2,10 @@
---@alias SplitDirection "vertical" | "horizontal"
---@alias SplitAnchorType "right" | "bottom"
---@class VernCreateFile
---@field allowed boolean Determines whether actions/init.lua uses the function
---@field func fun(opts: any, continue: fun(mod: VernFileLayout|nil)): any?
---@class VernKeybindItem
---@field user_command string
---@field desc string
@@ -39,20 +43,20 @@
---@class VernFileLayout
---@field path string
---@field name string
---@field kind string
---@field kind_path string
---@field kind? string
---@field kind_path? string
---@class VernExtrasLayout : VernFileLayout
---@field enabled boolean
---@class VernLanguageTemplates
---@field project table<string, VernFileLayout>
---@field file table<string, VernFileLayout>
---@field extras table<string, VernExtrasLayout>
---@field project table<string, VernFileLayout>|nil
---@field file table<string, VernFileLayout>|nil
---@field extras table<string, VernExtrasLayout>|nil
---@class VernLanguageConfig
---@field root string
---@field dirs table<string, string>
---@field dirs table<string, string>|nil
---@field keybinds table<string, VernKeybindItem>
---@field templates VernLanguageTemplates
@@ -70,3 +74,6 @@
---
---@class VernJavaConfig : VernCoreConfig
---@field java? VernLanguageConfig
---@class VernRustConfig : VernCoreConfig
---@field rust? VernLanguageConfig
+46 -28
View File
@@ -11,11 +11,10 @@ end
---@param str string String to replace
---@param ctx table<string, string> Replacment characters
---@return string
function M.fmt(str, ctx)
return (str:gsub("{([^}]+)}", ctx))
end
function M.fmt(str, ctx) return (str:gsub("{([^}]+)}", ctx)) end
---@param bufnr? integer Default is 0 (current buffer)
---@return string
function M.proj_root(bufnr)
bufnr = bufnr or 0
local root_markers = {
@@ -26,42 +25,48 @@ function M.proj_root(bufnr)
"CMakeLists",
"Cargo.toml",
}
return vim.fs.root(bufnr, root_markers) or vim.uv.cwd()
return vim.fs.root(bufnr, root_markers) or vim.uv.cwd() or "."
end
---@return string
function M.proj_name() return vim.fs.basename(M.proj_root()) or "" end
---@param raw_path string Combination of tbl.path and tbl.name to override
---@param dir_tbl table<string, string> Strings to replace raw directories in {dirs.<>} with
---@param ctx table<string, string> Strings to replace raw names like {project_name} with
---@return string path Fully replaced path
function M.resolve_path(raw_path, dir_tbl, ctx)
--- Replace the {dirs.<key>}
raw_path = raw_path:gsub("{dirs%.([%w_]+)}", function(dir_key)
return dir_tbl and dir_tbl[dir_key] or dir_key
end)
raw_path = raw_path:gsub(
"{dirs%.([%w_]+)}",
function(dir_key) return dir_tbl and dir_tbl[dir_key] or dir_key end
)
--- Replace the {<key>}
local path = raw_path:gsub("{([%w_]+)}", function(key)
return ctx and ctx[key] or ("{" .. key .. "}")
end)
local path = raw_path:gsub(
"{([%w_]+)}",
function(key) return ctx and ctx[key] or ("{" .. key .. "}") end
)
return path
end
---@return string
function M.proj_name()
return vim.fn.fnamemodify(M.proj_root(), ":t")
end
---@param path string
---@param ft string
function M.init_git(path, ft)
ft = ft and vim.trim(ft)
if not ft or ft == "" then
return
end
if not ft or ft == "" then return end
local gitignore = require("vern-nvim.templates.extras.gitignore").template(ft)
vim.fn.system({ "git", "-C", path, "init" })
local gitignore =
require("vern-nvim.templates.extras.gitignore").template(ft)
local obj = vim.system({ "git", "-C", path, "init" }):wait()
if obj.code ~= 0 then
vim.notify(
"Git init failed " .. obj.stderr,
vim.log.levels.ERROR,
{ title = "Vern Git" }
)
end
M.dump(vim.fs.joinpath(path, ".gitignore"), gitignore)
end
@@ -98,7 +103,12 @@ function M.term(cmd, opts, scratch)
local pos = {
row = math.floor(
(ui.height - (vim.o.laststatus == 3 and 1 or 0) - vim.o.cmdheight - dim.height) / 2
(
ui.height
- (vim.o.laststatus == 3 and 1 or 0)
- vim.o.cmdheight
- dim.height
) / 2
),
col = math.floor((ui.width - dim.width) / 2),
}
@@ -111,11 +121,11 @@ function M.term(cmd, opts, scratch)
row = pos.row,
col = pos.col,
style = "minimal",
border = opts.mode.win.float.border.enabled and opts.mode.win.float.border.type or nil,
border = opts.mode.win.float.border.enabled
and opts.mode.win.float.border.type
or nil,
})
if scratch then
return buf, win
end
if scratch then return buf, win end
end
if opts.mode.type == "split" then
if opts.mode.win.split.direction == "vertical" then
@@ -135,9 +145,7 @@ function M.term(cmd, opts, scratch)
win = vim.api.nvim_get_current_win()
vim.api.nvim_win_set_buf(0, buf)
if scratch then
return buf, win
end
if scratch then return buf, win end
end
local full_cmd = type(cmd) == "table" and table.concat(cmd, " ") or cmd
vim.fn.jobstart(full_cmd, { term = true })
@@ -151,4 +159,14 @@ function M.term(cmd, opts, scratch)
return buf, win
end
---@param buf integer
---@param lines table
function M.term_override(buf, lines)
if buf and vim.api.nvim_buf_is_valid(buf) then
vim.api.nvim_set_option_value("modifiable", true, { buf = buf })
vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
vim.api.nvim_set_option_value("modifiable", false, { buf = buf })
end
end
return M