133 lines
4.9 KiB
Lua
133 lines
4.9 KiB
Lua
local default_buffer_session = function()
|
|
local buffer_path = vim.api.nvim_buf_get_name(0) or vim.fn.tempname()
|
|
local temp_path = vim.fn.stdpath("run") .. "/molten-sessions" .. buffer_path .. ".json"
|
|
|
|
local dir = vim.fn.fnamemodify(temp_path, ":p:h")
|
|
if vim.fn.getftype(dir) ~= "dir" then
|
|
vim.fn.mkdir(dir, "p")
|
|
end
|
|
|
|
return temp_path
|
|
end
|
|
|
|
-- Start quarto session
|
|
local startsession = function(file, args)
|
|
file = file or default_buffer_session()
|
|
local path = require("util").get_python_venv()
|
|
vim.g["python3_host_prog"] = path
|
|
|
|
if vim.fn.executable("jupyter-console") ~= 1 then
|
|
return
|
|
end
|
|
|
|
if args then
|
|
file = args[0]
|
|
end
|
|
local once = false
|
|
vim.fn.jobstart({ "jupyter", "console", "-f", file }, {
|
|
on_stdout = function(_)
|
|
if not once then
|
|
vim.cmd("MoltenInit " .. file)
|
|
end
|
|
once = true
|
|
end,
|
|
on_exit = function(_)
|
|
vim.notify(string.format("jupyter kernel stopped: %s", file), vim.log.levels.INFO)
|
|
end,
|
|
stdin = nil,
|
|
})
|
|
end
|
|
vim.api.nvim_create_user_command("JupyterStart", function()
|
|
startsession()
|
|
end, {})
|
|
|
|
local map = vim.keymap.set
|
|
|
|
local function molten_mappings_set()
|
|
-- Operate jupyter notebooks from within vim
|
|
map("n", "<localleader>cc", ":MoltenEvaluateLine<cr>", { silent = true })
|
|
map(
|
|
"n",
|
|
"<localleader>C",
|
|
require("quarto.runner").run_cell,
|
|
{ silent = true, desc = "Evaluate current code cell" }
|
|
)
|
|
map("x", "<localleader>c", ":<C-u>MoltenEvaluateVisual<cr>", { silent = true })
|
|
map(
|
|
"n",
|
|
"<localleader>c",
|
|
"nvim_exec('MoltenEvaluateOperator', v:true)",
|
|
{ expr = true, silent = true, desc = "+code-evaluation" }
|
|
)
|
|
map("n", "<localleader>cr", ":MoltenReevaluateCell<cr>", { silent = true })
|
|
map("n", "<localleader>cu", ":MoltenShowOutput<cr>", { silent = true })
|
|
map("n", "<localleader>cU", ":noautocmd :MoltenEnterOutput<cr>", { silent = true, desc = "Molten enter output" })
|
|
map("n", "<localleader>cd", ":MoltenDelete<cr>", { silent = true })
|
|
map("n", "<localleader>ci", ":MoltenInterrupt<cr>")
|
|
map("n", "<localleader>cN", ":MoltenInit ")
|
|
map("n", "<localleader>cD", ":MoltenDeinit<cr>")
|
|
map("n", "<localleader>cR", ":MoltenRestart<cr>")
|
|
map("n", "<localleader>cA", require("quarto.runner").run_all, { silent = true, desc = "Evaluate all code cells" })
|
|
map(
|
|
"n",
|
|
"<localleader>ca",
|
|
require("quarto.runner").run_above,
|
|
{ silent = true, desc = "Evaluate cells above current" }
|
|
)
|
|
map(
|
|
"n",
|
|
"<localleader>cb",
|
|
require("quarto.runner").run_below,
|
|
{ silent = true, desc = "Evaluate cells below current" }
|
|
)
|
|
|
|
-- jump to beginning of previous/ next cell code
|
|
map("n", "]c", "/^```{<cr>}:nohl<cr>", { desc = "Next quarto cell" })
|
|
map("n", "[c", "?^```<cr>n}:nohl<cr>", { desc = "Previous quarto cell" })
|
|
-- insert cell header above/below
|
|
map("n", "<localleader>co", "o```{python}<cr><cr>```<esc>k", { desc = "Insert quarto cell below" })
|
|
map("n", "<localleader>cO", "O```{python}<cr><cr>```<esc>k", { desc = "Insert quarto cell above" })
|
|
end
|
|
|
|
vim.api.nvim_create_autocmd("User", {
|
|
pattern = "MoltenInitPost",
|
|
callback = molten_mappings_set,
|
|
})
|
|
local bufnr = 0
|
|
map("n", "[d", "<cmd>lua vim.diagnostic.goto_prev()<cr>", { buffer = bufnr, desc = "Previous diagnostic" })
|
|
map("n", "]d", "<cmd>lua vim.diagnostic.goto_next()<cr>", { buffer = bufnr, desc = "Next diagnostic" })
|
|
map(
|
|
"n",
|
|
"[e",
|
|
"<cmd>lua vim.diagnostic.goto_prev({severity = vim.diagnostic.severity.ERROR})<cr>",
|
|
{ buffer = bufnr, desc = "Previous error" }
|
|
)
|
|
map(
|
|
"n",
|
|
"]e",
|
|
"<cmd>lua vim.diagnostic.goto_next({severity = vim.diagnostic.severity.ERROR})<cr>",
|
|
{ buffer = bufnr, desc = "Next error" }
|
|
)
|
|
|
|
-- TODO find better way to enable lsp key mappings for quarto buffers
|
|
local prefix = require("which-key").register
|
|
prefix({ ["<localleader>l"] = { name = "+lsp" } })
|
|
map("n", "<localleader>li", "<cmd>LspInfo<cr>", { buffer = bufnr, desc = "Lsp Info" })
|
|
map("n", "<localleader>ld", "<cmd>lua vim.diagnostic.open_float()<cr>", { buffer = bufnr, desc = "Line diagnostics" })
|
|
map("n", "<localleader>la", "<cmd>lua vim.lsp.buf.code_action()<cr>", { buffer = bufnr, desc = "Codeactions" })
|
|
map("n", "<localleader>ln", "<cmd>lua vim.lsp.buf.rename()<cr>", { buffer = bufnr, desc = "Rename element" })
|
|
map("n", "<localleader>lr", "<cmd>lua vim.lsp.buf.references()<cr>", { buffer = bufnr, desc = "References" })
|
|
|
|
map("n", "K", "<cmd>lua vim.lsp.buf.hover()<cr>", { buffer = bufnr, desc = "Hover definition" })
|
|
map("n", "gd", "<cmd>lua vim.lsp.buf.definition()<cr>", { buffer = bufnr, desc = "Definition" })
|
|
map("n", "gD", "<cmd>lua vim.lsp.buf.declaration()<cr>", { buffer = bufnr, desc = "Declaration" })
|
|
map("n", "gs", "<cmd>lua vim.lsp.buf.signature_help()<cr>", { buffer = bufnr, desc = "Signature help" })
|
|
map("n", "gI", "<cmd>lua vim.lsp.buf.implementation()<cr>", { buffer = bufnr, desc = "Implementation" })
|
|
map("n", "gt", "<cmd>lua vim.lsp.buf.type_definition()<cr>", { buffer = bufnr, desc = "Type definition" })
|
|
|
|
if vim.b["sessionfile"] == nil then
|
|
local path = default_buffer_session()
|
|
vim.b["sessionfile"] = path
|
|
vim.schedule_wrap(startsession(path))
|
|
end
|