Ivar Fatland
497 lines
16 KiB
Lua
497 lines
16 KiB
Lua
-- GENERAL SETTINGS
|
|
vim.cmd [[ autocmd VimEnter * NoMatchParen ]]
|
|
do
|
|
local leader_key = ','
|
|
vim.g.mapleader = leader_key
|
|
vim.g.maplocalleader = leader_key
|
|
end
|
|
vim.opt.tabstop = 4
|
|
vim.opt.shiftwidth = 0
|
|
vim.opt.rnu = true
|
|
vim.opt.nu = true
|
|
vim.opt.wrap = false
|
|
vim.opt.shiftround = true
|
|
vim.opt.expandtab = true
|
|
vim.opt.hlsearch = false
|
|
vim.opt.incsearch = true
|
|
vim.opt.scrolloff = 8
|
|
|
|
vim.api.nvim_set_option("clipboard", "unnamedplus")
|
|
|
|
do
|
|
local navigation_move_to_panel_left = '<c-h>'
|
|
local navigation_move_to_panel_down = '<c-j>'
|
|
local navigation_move_to_panel_up = '<c-k>'
|
|
local navigation_move_to_panel_right = '<c-l>'
|
|
|
|
vim.api.nvim_set_keymap('n', navigation_move_to_panel_left, '<cmd>wincmd h<CR>', {silent = true})
|
|
vim.api.nvim_set_keymap('n', navigation_move_to_panel_down, '<cmd>wincmd j<CR>', {silent = true})
|
|
vim.api.nvim_set_keymap('n', navigation_move_to_panel_up, '<cmd>wincmd k<CR>', {silent = true})
|
|
vim.api.nvim_set_keymap('n', navigation_move_to_panel_right, '<cmd>wincmd l<CR>', {silent = true})
|
|
vim.api.nvim_set_keymap('t', navigation_move_to_panel_left, '<cmd>wincmd h<CR>', {silent = true})
|
|
vim.api.nvim_set_keymap('t', navigation_move_to_panel_down, '<cmd>wincmd j<CR>', {silent = true})
|
|
vim.api.nvim_set_keymap('t', navigation_move_to_panel_up, '<cmd>wincmd k<CR>', {silent = true})
|
|
vim.api.nvim_set_keymap('t', navigation_move_to_panel_right, '<cmd>wincmd l<CR>', {silent = true})
|
|
end
|
|
|
|
vim.api.nvim_set_keymap('t', '<esc>', '<C-\\><C-n>', {silent = true})
|
|
vim.cmd [[ autocmd BufEnter * if &buftype == 'terminal' | :startinsert | endif ]]
|
|
|
|
vim.cmd [[ autocmd BufWinLeave *.* silent! mkview ]]
|
|
vim.cmd [[ autocmd BufWinEnter *.* silent! loadview ]]
|
|
|
|
vim.g.c_syntax_for_h = 1
|
|
vim.g.python_indent = { -- Fixes retarded default python indentation.
|
|
open_paren = 'shiftwidth()',
|
|
nested_paren = 'shiftwidth()',
|
|
continue = 'shiftwidth()',
|
|
closed_paren_align_last_line = false,
|
|
searchpair_timeout = 300,
|
|
}
|
|
|
|
vim.o.exrc = true -- Allows project specific .nvim.lua config files.
|
|
|
|
vim.cmd [[ autocmd FileType * set formatoptions-=cro ]] -- Disable automatic comment.
|
|
|
|
-- HELPER FUNCTIONS
|
|
---@param name string
|
|
---@return boolean
|
|
local function file_exists(name)
|
|
local f = io.open(name,"r")
|
|
|
|
if f~=nil then
|
|
f:close()
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- SNIPPET EDIT FUNCTIONALITY. REQUIRES SNIPPY.
|
|
-- Opens a default .snippets file for the filetype you are currently editing in a horizontal split pane.
|
|
-- If the .snippets file does not exist, it will be created.
|
|
-- This requires the snippets folder to exist in the config folder.
|
|
-- If the folder does not exist, the command will print out a helpful error message showing what the path
|
|
-- should look like.
|
|
vim.api.nvim_create_user_command(
|
|
'S',
|
|
function ()
|
|
---@type string
|
|
local snippets_path = vim.fn.stdpath('config') .. '/snippets/' .. vim.api.nvim_buf_get_option(0, "filetype") .. '.snippets'
|
|
|
|
if not file_exists(snippets_path) then
|
|
local file = io.open( snippets_path, 'w' )
|
|
assert(
|
|
file ~= nil,
|
|
("io.open('%s', 'w') returned nil.\n"):format(snippets_path) ..
|
|
"Make sure the snippets folder in the above path exists."
|
|
)
|
|
file:close()
|
|
print('created file: ', snippets_path)
|
|
end
|
|
|
|
vim.api.nvim_command(('SnippyEdit %s'):format(snippets_path))
|
|
end,
|
|
{ nargs = 0 }
|
|
)
|
|
|
|
-- JSON2GO COMMAND. CONVERT SELECTED JSON INTO A GO STRUCT BY USING JSON2STRUCT TERMINAL COMMAND. (INSTALL SEPARATELEY)
|
|
vim.api.nvim_create_user_command(
|
|
'Json2go',
|
|
function(opts)
|
|
local lstart = opts.line1 - 1
|
|
local lend = opts.line2
|
|
local lines = vim.api.nvim_buf_get_lines(
|
|
vim.api.nvim_get_current_buf(),
|
|
lstart,
|
|
lend,
|
|
false
|
|
)
|
|
local lines_str = vim.fn.join(lines, ' ')
|
|
lines_str = lines_str:gsub('\\', '\\\\')
|
|
lines_str = lines_str:gsub("'", "\\'")
|
|
---@type string[]
|
|
local struct_lines = {}
|
|
|
|
local file = io.popen( "json2struct -s " .. "'" .. lines_str .. "'", "r" )
|
|
assert(file ~= nil)
|
|
for line in file:lines() do
|
|
table.insert(struct_lines, line)
|
|
end
|
|
file:close()
|
|
|
|
vim.api.nvim_buf_set_lines(0, lstart, lend, false, struct_lines)
|
|
|
|
end,
|
|
{ range = true }
|
|
)
|
|
|
|
-- EXECUTE PROJECT SPECIFIC SCRIPTS
|
|
do
|
|
---Returns function that runs the given script_name in the current working directory.
|
|
---Only implemented for Linux. ( Uses the sh command )
|
|
---@param script_name string
|
|
---@return fun()
|
|
local function get_run_script_function(script_name)
|
|
return function()
|
|
---@type "Linux" | "Darwin" | "Windows_NT"
|
|
local os_name = vim.loop.os_uname().sysname
|
|
if os_name == "Windows_NT" then
|
|
error('run_file not implemented for non-unix platforms')
|
|
end
|
|
|
|
local run_script_path = vim.fn.getcwd() .. "/" .. script_name
|
|
if not file_exists(run_script_path) then
|
|
error(
|
|
"The run script: '" .. run_script_path .. "' does not exist.\n"..
|
|
"All this command does, is to execute that file."
|
|
)
|
|
end
|
|
|
|
vim.cmd([[ TermExec cmd="sh ]].. run_script_path ..[[" direction=vertical size=80 ]])
|
|
end
|
|
end
|
|
|
|
-- To create a script that runs when typing the command "<leader>er",
|
|
-- create a script called ".r.sh" in the current directory.
|
|
local alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
|
|
for i = 1, #alphabet do
|
|
local char = alphabet:sub(i, i)
|
|
vim.keymap.set(
|
|
'n',
|
|
"<leader>e" .. char,
|
|
get_run_script_function("." .. char .. ".sh"),
|
|
{ silent = true }
|
|
)
|
|
end
|
|
end
|
|
|
|
-- SPLIT LINE FUNCTIONALITY
|
|
---@type function
|
|
local split_line
|
|
do
|
|
|
|
-- split_line settings
|
|
local SPLIT_WHITESPACE = ' '
|
|
local SPLIT_DELIMETERS = { -- single characters only
|
|
[','] = true,
|
|
[';'] = true,
|
|
}
|
|
local SPLIT_BETWEEN = { -- single characters only
|
|
['('] = ')',
|
|
['['] = ']',
|
|
['{'] = '}',
|
|
}
|
|
local SPLIT_IGNORE_BETWEEN = { --single characters only
|
|
['"'] = '"',
|
|
["'"] = "'",
|
|
}
|
|
|
|
split_line = function()
|
|
local line = vim.api.nvim_get_current_line()
|
|
local _, col = unpack(vim.api.nvim_win_get_cursor(0))
|
|
col = col + 1 -- Doing this to make it 1-indexed
|
|
|
|
---@type integer?
|
|
local first_bracket_i = nil
|
|
for i = col, #line do
|
|
local char = line:sub(i, i)
|
|
if SPLIT_BETWEEN[char] ~= nil then
|
|
first_bracket_i = i
|
|
break
|
|
end
|
|
end
|
|
|
|
if not first_bracket_i then
|
|
print('No opening brackets found after cursor on this line.')
|
|
return
|
|
end
|
|
|
|
---@type integer[]
|
|
local split_indexes = {} -- Populate this array
|
|
---@type integer?
|
|
local last_bracket_i = nil -- And find this index
|
|
|
|
do
|
|
---@type string[]
|
|
local closing_bracket_stack = {}
|
|
local icon_to_close_ignore = ''
|
|
local in_ignore = false
|
|
|
|
for i = first_bracket_i, #line do
|
|
local char = line:sub(i,i)
|
|
|
|
if in_ignore then
|
|
in_ignore = not (char == icon_to_close_ignore)
|
|
goto continue
|
|
end
|
|
|
|
if SPLIT_IGNORE_BETWEEN[char] ~= nil then
|
|
icon_to_close_ignore = SPLIT_IGNORE_BETWEEN[char]
|
|
in_ignore = true
|
|
goto continue
|
|
end
|
|
-- string handling complete
|
|
|
|
if SPLIT_BETWEEN[char] ~= nil then
|
|
table.insert(
|
|
closing_bracket_stack,
|
|
SPLIT_BETWEEN[char]
|
|
)
|
|
end
|
|
|
|
if char == closing_bracket_stack[#closing_bracket_stack] then
|
|
table.remove(closing_bracket_stack)
|
|
end
|
|
|
|
if #closing_bracket_stack == 1 and SPLIT_DELIMETERS[char] then
|
|
table.insert(split_indexes, i)
|
|
end
|
|
|
|
if #closing_bracket_stack == 0 then
|
|
last_bracket_i = i
|
|
break
|
|
end
|
|
::continue::
|
|
end
|
|
end
|
|
|
|
if not last_bracket_i then
|
|
print("The first opening bracket found after the cursor was not closed on this line.")
|
|
return
|
|
end
|
|
if #split_indexes == 0 then
|
|
print('No comma separated items within brackets that were opened and closed after the cursor.')
|
|
return
|
|
end
|
|
|
|
---@type string
|
|
local leading_whitespace = string.match(line, "^%s*")
|
|
local first_line = line:sub(1, first_bracket_i)
|
|
local last_line = leading_whitespace .. line:sub(last_bracket_i, #line)
|
|
|
|
local middle_lines = {}
|
|
table.insert(
|
|
middle_lines,
|
|
line:sub(first_bracket_i+1, split_indexes[1])
|
|
)
|
|
for i = 1, #split_indexes-1 do
|
|
table.insert(
|
|
middle_lines,
|
|
line:sub(split_indexes[i], split_indexes[i+1])
|
|
)
|
|
end
|
|
table.insert(
|
|
middle_lines,
|
|
line:sub(split_indexes[#split_indexes], last_bracket_i-1)
|
|
)
|
|
|
|
local leading_pattern = "^[%s"
|
|
for k, _ in pairs(SPLIT_DELIMETERS) do
|
|
leading_pattern = leading_pattern .. k
|
|
end
|
|
leading_pattern = leading_pattern .. "]*"
|
|
|
|
-- Cleanup step
|
|
for i, middle_line in ipairs(middle_lines) do
|
|
middle_line = middle_line:gsub(leading_pattern, leading_whitespace .. SPLIT_WHITESPACE, 1)
|
|
middle_line = middle_line:gsub("[%s]*$", '', 1)
|
|
middle_lines[i] = middle_line
|
|
end
|
|
|
|
local row, _ = unpack(vim.api.nvim_win_get_cursor(0))
|
|
vim.api.nvim_buf_set_lines(0, row-1, row, false, {first_line})
|
|
vim.api.nvim_buf_set_lines(0, row, row, false, {last_line})
|
|
vim.api.nvim_buf_set_lines(0, row, row, false, middle_lines)
|
|
end
|
|
end
|
|
|
|
vim.keymap.set(
|
|
'n',
|
|
"<leader>s",
|
|
split_line,
|
|
{ silent = true }
|
|
)
|
|
|
|
-- LAZY.NVIM BOOTSTRAP
|
|
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
|
|
if not (vim.uv or vim.loop).fs_stat(lazypath) then
|
|
vim.fn.system({
|
|
"git",
|
|
"clone",
|
|
"--filter=blob:none",
|
|
"https://github.com/folke/lazy.nvim.git",
|
|
"--branch=stable", -- latest stable release
|
|
lazypath,
|
|
})
|
|
end
|
|
vim.opt.rtp:prepend(lazypath)
|
|
|
|
require('lazy').setup(
|
|
{
|
|
{ 'neovim/nvim-lspconfig',
|
|
config = function()
|
|
local lspconfig = require('lspconfig')
|
|
lspconfig.lua_ls.setup{
|
|
settings = {
|
|
Lua = {
|
|
runtime = {
|
|
version = 'LuaJIT'
|
|
},
|
|
diagnostics = {
|
|
globals = {
|
|
'vim'
|
|
}
|
|
},
|
|
workspace = {
|
|
checktirdparty = true,
|
|
library = {
|
|
vim.env.VIMRUNTIME
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
lspconfig.gopls.setup{}
|
|
lspconfig.pyright.setup{}
|
|
|
|
vim.keymap.set("n", "<leader>ca", vim.lsp.buf.code_action, { desc = "Perform code action" })
|
|
vim.keymap.set("n", "<leader>rn", vim.lsp.buf.rename, { desc = "Rename token under cursor" })
|
|
end,
|
|
},
|
|
{ 'dcampos/nvim-snippy',
|
|
config = function()
|
|
require('snippy').setup({
|
|
enable_auto = true,
|
|
mappings = {
|
|
-- is = {
|
|
-- ['<Tab>'] = 'expand_or_advance',
|
|
-- ['<S-Tab>'] = 'previous',
|
|
-- },
|
|
nx = {
|
|
['<leader>x'] = 'cut_text',
|
|
},
|
|
},
|
|
})
|
|
end
|
|
},
|
|
{ 'hrsh7th/nvim-cmp',
|
|
dependencies = {
|
|
'dcampos/cmp-snippy',
|
|
'hrsh7th/cmp-nvim-lsp'
|
|
},
|
|
config = function()
|
|
local cmp = require('cmp')
|
|
local snippy = require('snippy')
|
|
cmp.setup{
|
|
snippet = {
|
|
expand = function(args)
|
|
snippy.expand_snippet(args.body)
|
|
end,
|
|
},
|
|
sources = {
|
|
{name = 'snippy'},
|
|
{name = 'nvim_lsp'},
|
|
},
|
|
mapping = {
|
|
['<c-j>'] = function (_) cmp.confirm({select = true}) end,
|
|
['<c-k>'] = function (_) snippy.next() end,
|
|
['<c-h>'] = function (_) snippy.previous() end,
|
|
},
|
|
}
|
|
end,
|
|
},
|
|
{ 'kylechui/nvim-surround',
|
|
version = '*', -- Use for stability; omit to use `main` branch for the latest features
|
|
event = 'VeryLazy',
|
|
config = function()
|
|
require('nvim-surround').setup({
|
|
-- Configuration here, or leave empty to use defaults
|
|
})
|
|
end
|
|
},
|
|
{ 'nvim-treesitter/nvim-treesitter',
|
|
build = ':TSUpdate',
|
|
config = function ()
|
|
local configs = require('nvim-treesitter.configs')
|
|
|
|
configs.setup({
|
|
ensure_installed = 'all',
|
|
sync_install = false,
|
|
highlight = { enable = true },
|
|
indent = { enable = true },
|
|
})
|
|
end,
|
|
},
|
|
{ 'nvim-telescope/telescope.nvim',
|
|
tag = '0.1.6',
|
|
dependencies = { 'nvim-lua/plenary.nvim' },
|
|
config = function()
|
|
local builtin = require('telescope.builtin')
|
|
|
|
---@param key string
|
|
---@param fun function
|
|
local map = function(key, fun)
|
|
vim.keymap.set('n', '<leader>f' .. key, fun, {})
|
|
end
|
|
|
|
map('f', builtin.find_files)
|
|
map('o', builtin.oldfiles)
|
|
map('g', builtin.live_grep)
|
|
map('b', builtin.buffers)
|
|
map('h', builtin.help_tags)
|
|
map('m', builtin.man_pages)
|
|
map('r', builtin.lsp_references)
|
|
map('d', builtin.lsp_definitions)
|
|
map('i', builtin.lsp_implementations)
|
|
map('t', builtin.lsp_type_definitions)
|
|
map('e', builtin.diagnostics)
|
|
|
|
end,
|
|
},
|
|
{ 'sainnhe/everforest', -- THE THEME SETUP
|
|
lazy = false,
|
|
priority = 1000,
|
|
config = function()
|
|
vim.o.termguicolors = true
|
|
vim.g.everforest_enable_italic = true
|
|
vim.cmd.colorscheme('everforest')
|
|
end,
|
|
},
|
|
{ 'folke/zen-mode.nvim',
|
|
config = function ()
|
|
vim.keymap.set(
|
|
'n',
|
|
"<leader>z",
|
|
vim.cmd.ZenMode,
|
|
{ silent = true }
|
|
)
|
|
end
|
|
},
|
|
{ 'stevearc/oil.nvim',
|
|
dependencies = { 'nvim-tree/nvim-web-devicons', },
|
|
config = function ()
|
|
local oil = require('oil')
|
|
oil.setup{
|
|
default_file_explorer = true,
|
|
columns = {'icon'},
|
|
view_options = {
|
|
show_hidden = true,
|
|
},
|
|
}
|
|
vim.keymap.set("n", "-", vim.cmd.Oil, { desc = "Open parent directory" })
|
|
end,
|
|
},
|
|
{ 'akinsho/toggleterm.nvim',
|
|
version = "*",
|
|
config = function ()
|
|
require('toggleterm').setup{
|
|
direction = 'vertical',
|
|
size = 80,
|
|
}
|
|
vim.keymap.set("n", "<leader>t", vim.cmd.ToggleTerm, { desc = "Toggle terminal" })
|
|
end,
|
|
},
|
|
}
|
|
)
|