341 lines
9.3 KiB
Lua
341 lines
9.3 KiB
Lua
vim.opt.number = true
|
|
vim.opt.relativenumber = true
|
|
vim.opt.smartcase = true
|
|
vim.opt.ignorecase = true
|
|
vim.opt.ts = 4
|
|
vim.opt.sw = 0
|
|
vim.opt.foldmethod = "indent"
|
|
vim.opt.foldlevel = 99
|
|
vim.opt.clipboard = "unnamedplus"
|
|
vim.opt.signcolumn = "yes"
|
|
vim.opt.termguicolors = true
|
|
|
|
vim.pack.add({
|
|
{ src = "https://github.com/stevearc/oil.nvim" },
|
|
{ src = "https://github.com/echasnovski/mini.pick" },
|
|
{ src = "https://github.com/echasnovski/mini.icons" },
|
|
{ src = "https://github.com/nvim-treesitter/nvim-treesitter" },
|
|
{ src = "https://github.com/neovim/nvim-lspconfig" },
|
|
{ src = "https://github.com/sainnhe/everforest" },
|
|
{ src = "https://github.com/nvim-lualine/lualine.nvim" },
|
|
|
|
-- autoclosing tags
|
|
{ src = "https://github.com/windwp/nvim-ts-autotag" },
|
|
{ src = "https://github.com/terrortylor/nvim-comment" },
|
|
-- required by nvim-comment
|
|
{ src = "https://github.com/JoosepAlviste/nvim-ts-context-commentstring" },
|
|
|
|
-- java support
|
|
{ src = "https://github.com/mfussenegger/nvim-jdtls" },
|
|
|
|
{ src = "https://github.com/folke/which-key.nvim" },
|
|
})
|
|
|
|
require('nvim_comment').setup({
|
|
hook = function()
|
|
require('ts_context_commentstring.internal').update_commentstring()
|
|
end,
|
|
})
|
|
|
|
|
|
require('nvim-ts-autotag').setup()
|
|
|
|
-- local function hello()
|
|
-- local x = vim.fn["nvim_treesitter#statusline(90)"]()
|
|
-- -- print(x)
|
|
-- return "test"
|
|
-- end
|
|
require('lualine').setup({
|
|
options = {
|
|
theme = "everforest",
|
|
},
|
|
-- sections = {
|
|
-- -- lualine_a = { 'mode' },
|
|
-- -- lualine_b = { 'branch', 'diff', 'diagnostics' },
|
|
-- -- lualine_c = { 'filename' },
|
|
-- lualine_c = { 'filename', hello },
|
|
-- -- lualine_x = { 'encoding', 'fileformat', 'filetype' },
|
|
-- -- lualine_y = { 'progress' },
|
|
-- -- lualine_z = { 'location' }
|
|
-- },
|
|
})
|
|
|
|
vim.cmd([[colorscheme everforest]])
|
|
require('mini.icons').setup()
|
|
|
|
|
|
require('oil').setup({
|
|
view_options = {
|
|
show_hidden = false,
|
|
sort = {
|
|
{ "type", "asc" },
|
|
{ "name", "asc" },
|
|
},
|
|
},
|
|
keymaps = {
|
|
["<leader>o"] = {
|
|
desc = "Recursively Open directores",
|
|
callback = function()
|
|
local oil = require("oil")
|
|
local dir = oil.get_current_dir()
|
|
local cursor = oil.get_cursor_entry()
|
|
|
|
local function openRecursively()
|
|
oil.open(dir .. cursor.name)
|
|
vim.wait(50)
|
|
|
|
dir = oil.get_current_dir()
|
|
cursor = oil.get_cursor_entry()
|
|
|
|
local bn = vim.fn.bufnr()
|
|
local lines = vim.api.nvim_buf_line_count(bn)
|
|
|
|
if lines == 1 and cursor ~= nil and cursor.type == "directory" then
|
|
openRecursively()
|
|
end
|
|
end
|
|
|
|
openRecursively()
|
|
end,
|
|
},
|
|
},
|
|
})
|
|
|
|
vim.api.nvim_create_autocmd('LspAttach', {
|
|
callback = function(ev)
|
|
local client = vim.lsp.get_client_by_id(ev.data.client_id)
|
|
if client == nil then
|
|
return
|
|
end
|
|
if client:supports_method('textDocument/completion') then
|
|
vim.lsp.completion.enable(true, client.id, ev.buf, { autotrigger = true })
|
|
end
|
|
|
|
if client:supports_method("textDocument/inlayHint") or client.server_capabilities.inlayHintProvider then
|
|
vim.lsp.inlay_hint.enable(true, { bufnr = ev.buf })
|
|
end
|
|
end,
|
|
})
|
|
vim.cmd("set completeopt+=menuone,noselect,popup")
|
|
|
|
vim.lsp.config('gopls', {
|
|
settings = {
|
|
['gopls'] = {
|
|
hints = {
|
|
assignVariableTypes = true,
|
|
parameterNames = true
|
|
}
|
|
},
|
|
},
|
|
})
|
|
vim.lsp.config('tailwindcss', {
|
|
settings = {
|
|
tailwindCSS = {
|
|
colorDecorators = false
|
|
},
|
|
}
|
|
})
|
|
vim.lsp.config('lua_ls', {
|
|
settings = {
|
|
Lua = {
|
|
runtime = {
|
|
version = 'LuaJIT',
|
|
},
|
|
workspace = {
|
|
library = vim.api.nvim_get_runtime_file("", true),
|
|
}
|
|
},
|
|
}
|
|
})
|
|
vim.lsp.config('jdtls', {
|
|
cmd = { "jdtls", "--jvm-arg=-javaagent:/usr/share/java/lombok/lombok.jar" },
|
|
settings = {
|
|
java = {
|
|
completion = {
|
|
favoriteStaticMembers = {
|
|
"org.assertj.core.api.Assertions.*",
|
|
"org.assertj.core.api.BDDAssertions.*",
|
|
"org.mockito.Mockito.*",
|
|
"org.mockito.ArgumentMatchers.*",
|
|
"org.mockito.BDDMockito.*",
|
|
"org.hamcrest.MatcherAssert.*",
|
|
"org.hamcrest.Matchers.*",
|
|
"java.util.Collections.*",
|
|
"java.util.Comparator.*",
|
|
"java.util.stream.Collectors.*",
|
|
"java.util.Arrays.*",
|
|
"java.lang.Math.*",
|
|
"org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*",
|
|
"org.springframework.test.web.servlet.result.MockMvcResultMatchers.*",
|
|
"org.springframework.test.web.servlet.setup.MockMvcBuilders.*",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
vim.lsp.enable({
|
|
"lua_ls",
|
|
"gopls",
|
|
"templ",
|
|
"ts_ls",
|
|
"tailwindcss",
|
|
"bashls",
|
|
"jdtls",
|
|
})
|
|
|
|
-- Enables filtered completions for tailwindcss class names, e.g. "mt-<C-n>".
|
|
-- Otherwise the completion contains EVERYTHING
|
|
vim.api.nvim_create_autocmd("FileType", {
|
|
pattern = { "html", "templ", "javascript", "typescript", "css" },
|
|
callback = function()
|
|
vim.opt_local.iskeyword:append("-")
|
|
end,
|
|
})
|
|
|
|
require "mini.pick".setup()
|
|
require "nvim-treesitter.configs".setup({
|
|
auto_install = true,
|
|
highlight = {
|
|
enable = true,
|
|
},
|
|
incremental_selection = {
|
|
enable = true,
|
|
}
|
|
})
|
|
|
|
-- Treesitter Java class + method lookup
|
|
local ts = vim.treesitter
|
|
|
|
local function java_symbol_under_cursor()
|
|
local parser = ts.get_parser(0, "java")
|
|
if not parser then return nil, nil end
|
|
|
|
local tree = parser:parse()[1]
|
|
local root = tree:root()
|
|
|
|
local cursor = vim.api.nvim_win_get_cursor(0)
|
|
local row, col = cursor[1] - 1, cursor[2]
|
|
|
|
local node = root:named_descendant_for_range(row, col, row, col)
|
|
if not node then return nil, nil end
|
|
|
|
local class_name = nil
|
|
local method_name = nil
|
|
|
|
-- Walk up the syntax tree
|
|
while node do
|
|
local type = node:type()
|
|
if type == "class_declaration" and not class_name then
|
|
local name_node = node:field("name")[1]
|
|
if name_node then
|
|
class_name = ts.get_node_text(name_node, 0)
|
|
end
|
|
elseif type == "method_declaration" and not method_name then
|
|
local name_node = node:field("name")[1]
|
|
if name_node then
|
|
method_name = ts.get_node_text(name_node, 0)
|
|
end
|
|
end
|
|
node = node:parent()
|
|
end
|
|
|
|
return class_name, method_name
|
|
end
|
|
|
|
local function run_selected_gradle_tests()
|
|
local class_name, method_name = java_symbol_under_cursor()
|
|
if class_name and method_name then
|
|
local cmd = string.format("./gradlew clean test --tests %s.%s", class_name, method_name)
|
|
vim.cmd("vsplit | terminal " .. cmd)
|
|
end
|
|
end
|
|
|
|
local function run_all_gradle_tests()
|
|
local cmd = string.format("./gradlew clean test")
|
|
vim.cmd("vsplit | terminal " .. cmd)
|
|
end
|
|
|
|
|
|
-- Keymap to print class + method under cursor
|
|
|
|
vim.api.nvim_create_autocmd('TextYankPost', {
|
|
desc = 'Hightlight selection on yank',
|
|
pattern = '*',
|
|
callback = function()
|
|
vim.highlight.on_yank { higroup = 'IncSearch', timeout = 500 }
|
|
end,
|
|
})
|
|
|
|
vim.api.nvim_create_autocmd('BufWritePost', {
|
|
desc = 'Autoformat code on safe with prettier',
|
|
pattern = '*.html',
|
|
callback = function()
|
|
local filepath = vim.fn.expand('%:p')
|
|
vim.fn.system({ 'npx', 'prettier', '--write', filepath })
|
|
vim.cmd('edit!')
|
|
end,
|
|
})
|
|
vim.api.nvim_create_autocmd('BufWritePre', {
|
|
desc = 'Autoformat code on save with lsp',
|
|
pattern = '*',
|
|
callback = function()
|
|
local filetype = vim.bo.filetype
|
|
if filetype == "html" then
|
|
return
|
|
end
|
|
|
|
vim.lsp.buf.format({ async = false })
|
|
end,
|
|
})
|
|
|
|
|
|
vim.filetype.add({ extension = { templ = "templ" } })
|
|
|
|
|
|
vim.g.mapleader = " "
|
|
|
|
vim.keymap.set('i', '<C-n>', vim.lsp.completion.get, {})
|
|
vim.keymap.set('i', '<C-z>', "<C-y>", {})
|
|
vim.keymap.set('n', 'gd', vim.lsp.buf.definition, {})
|
|
vim.keymap.set('n', 'gr', vim.lsp.buf.references, {})
|
|
vim.keymap.set('n', '<S-F6>', vim.lsp.buf.rename, {})
|
|
vim.keymap.set('n', '<F4>', vim.lsp.buf.code_action, {})
|
|
|
|
vim.keymap.set('n', '<leader>q', ':q<CR>', { desc = "Quit current Buffer" })
|
|
vim.keymap.set('n', '<leader>w', ':w<CR>', { desc = "Write current Buffer" })
|
|
vim.keymap.set('n', '<leader>c', ':noh<CR>', { desc = "Clear search selection" })
|
|
vim.keymap.set('n', '<F2>', vim.diagnostic.goto_next, {})
|
|
|
|
vim.keymap.set("n", "<C-h>", "<C-w>h")
|
|
-- Terminal is sending Backspace instead of <C-h>, so this needs to be different
|
|
vim.keymap.set("n", "<BS>", "<C-w>h")
|
|
vim.keymap.set("n", "<C-j>", "<C-w>j")
|
|
vim.keymap.set("n", "<C-k>", "<C-w>k")
|
|
vim.keymap.set("n", "<C-l>", "<C-w>l")
|
|
|
|
vim.keymap.set('n', '<leader>ff', ":Pick files<CR>", { desc = "Find files" })
|
|
vim.keymap.set('n', '<leader>fg', ":Pick grep<CR><CR>", { desc = "Search in files" })
|
|
-- vim.keymap.set('v', '<leader>fg', ":Pick grep<CR>'<,'><CR>", { desc = "Search in files" })
|
|
vim.keymap.set('n', '<leader>fb', ":Pick buffers<CR>", { desc = "Find buffers" })
|
|
vim.keymap.set('n', '<leader>fh', ":Pick help<CR>", { desc = "Search vim help" })
|
|
|
|
vim.keymap.set("n", "-", "<CMD>Oil<CR>", { desc = "Open parent directory" })
|
|
|
|
|
|
vim.keymap.set("n", "<leader>oi", require 'jdtls'.organize_imports, { desc = "Organize imports" })
|
|
vim.keymap.set("n", "<leader>ev", require 'jdtls'.extract_variable, { desc = "Extract variable" })
|
|
vim.keymap.set("n", "<leader>ec", require 'jdtls'.extract_constant, { desc = "Extract constant" })
|
|
vim.keymap.set("n", "<leader>em", require 'jdtls'.extract_method, { desc = "Extract method" })
|
|
vim.keymap.set("v", "<leader>em", ":lua require'jdtls'.extract_method(true)<CR>",
|
|
{ desc = "Extract method", silent = true })
|
|
|
|
vim.keymap.set("n", "<leader>rtc", run_selected_gradle_tests, { desc = "Run Gradle tests under cursor" })
|
|
vim.keymap.set("n", "<leader>rta", run_all_gradle_tests, { desc = "Run all Gradle tests" })
|
|
|
|
vim.keymap.set({ "n", "v" }, "<leader>?", function() require("which-key").show({ global = false }) end,
|
|
{ desc = "Buffer Local Keymaps (which-key)" })
|
|
|
|
|
|
-- TODO: Snippets like new java class
|