├── lua
    ├── usr
    │   ├── lsp
    │   │   ├── settings
    │   │   │   ├── lemminx.lua
    │   │   │   ├── r_language_server.lua
    │   │   │   ├── cmake.lua
    │   │   │   ├── matlab_ls.lua
    │   │   │   ├── init.lua
    │   │   │   ├── lua_ls.lua
    │   │   │   ├── bashls.lua
    │   │   │   ├── marksman.lua
    │   │   │   ├── texlab.lua
    │   │   │   ├── clangd.lua
    │   │   │   ├── vimlatex.lua
    │   │   │   ├── rust_analyzer.lua
    │   │   │   └── jsonls.lua
    │   │   ├── init.lua
    │   │   ├── blink.lua
    │   │   ├── null_ls.lua
    │   │   ├── lsp-installer.lua
    │   │   ├── lspMason.lua
    │   │   ├── handlers.lua
    │   │   └── util.lua
    │   ├── DAP
    │   │   ├── init.lua
    │   │   ├── settings
    │   │   │   ├── daplua.lua
    │   │   │   ├── bashdap.lua
    │   │   │   ├── dapcpp.lua
    │   │   │   └── dappy.lua
    │   │   ├── nvimdap.lua
    │   │   ├── virtual_text.lua
    │   │   └── ui.lua
    │   ├── ts
    │   │   ├── init.lua
    │   │   ├── treesitter.lua
    │   │   └── context.lua
    │   ├── impatient.lua
    │   ├── tscope
    │   │   ├── init.lua
    │   │   ├── adjustments.lua
    │   │   └── telescope_config.lua
    │   ├── core
    │   │   ├── init.lua
    │   │   ├── options.lua
    │   │   ├── util.lua
    │   │   ├── colorscheme.lua
    │   │   ├── autocomands.lua
    │   │   ├── icons.lua
    │   │   └── keymaps.lua
    │   ├── annotations.lua
    │   ├── navigation
    │   │   ├── init.lua
    │   │   ├── snippets.lua
    │   │   ├── scroll.lua
    │   │   ├── satellite.lua
    │   │   ├── dropbar.lua
    │   │   └── neotree.lua
    │   ├── copilot.lua
    │   ├── illuminate.lua
    │   ├── lazygit.lua
    │   ├── ccc.lua
    │   ├── autopairs.lua
    │   ├── snacks
    │   │   └── dashboard.lua
    │   ├── lazyManager.lua
    │   ├── comment.lua
    │   ├── toggleterm.lua
    │   ├── bufferline.lua
    │   ├── todo-comments.lua
    │   ├── gitsigns.lua
    │   ├── lualine.lua
    │   └── plugins
    │   │   └── init.lua
    └── .luarc.json
├── spell
    ├── da.utf-8.spl
    ├── da.utf-8.sug
    ├── de.utf-8.spl
    ├── sk.utf-8.spl
    ├── en.utf-8.add.spl
    ├── sk.utf-8.add.spl
    ├── en.utf-8.add
    └── sk.utf-8.add
├── ftplugin
    ├── r.lua
    ├── lua.lua
    ├── tex.lua
    ├── markdown.lua
    └── cpp.lua
├── .gitignore
├── init.lua
├── formats
    ├── google
    │   └── .clang_format
    └── qt
    │   └── .clang-format
├── README.md
└── lazy-lock.json


/lua/usr/lsp/settings/lemminx.lua:
--------------------------------------------------------------------------------
1 | return {
2 | 	
3 | }
4 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/init.lua:
--------------------------------------------------------------------------------
1 | require("usr.DAP.nvimdap")
2 | require("usr.DAP.ui")
3 | 


--------------------------------------------------------------------------------
/spell/da.utf-8.spl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fildo7525/nvim/HEAD/spell/da.utf-8.spl


--------------------------------------------------------------------------------
/spell/da.utf-8.sug:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fildo7525/nvim/HEAD/spell/da.utf-8.sug


--------------------------------------------------------------------------------
/spell/de.utf-8.spl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fildo7525/nvim/HEAD/spell/de.utf-8.spl


--------------------------------------------------------------------------------
/spell/sk.utf-8.spl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fildo7525/nvim/HEAD/spell/sk.utf-8.spl


--------------------------------------------------------------------------------
/lua/usr/ts/init.lua:
--------------------------------------------------------------------------------
1 | require('usr.ts.treesitter')
2 | --[[ require('usr.ts.context') ]]
3 | 


--------------------------------------------------------------------------------
/spell/en.utf-8.add.spl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fildo7525/nvim/HEAD/spell/en.utf-8.add.spl


--------------------------------------------------------------------------------
/spell/sk.utf-8.add.spl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Fildo7525/nvim/HEAD/spell/sk.utf-8.add.spl


--------------------------------------------------------------------------------
/lua/usr/impatient.lua:
--------------------------------------------------------------------------------
1 | local impatient = require('impatient')
2 | 
3 | impatient.enable_profile()
4 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/r_language_server.lua:
--------------------------------------------------------------------------------
1 | return {
2 | 	cmd = { "r-languageserver" },
3 | }
4 | 
5 | 


--------------------------------------------------------------------------------
/lua/usr/tscope/init.lua:
--------------------------------------------------------------------------------
1 | require("usr.tscope.telescope_config")
2 | require("usr.tscope.adjustments")
3 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/init.lua:
--------------------------------------------------------------------------------
1 | require("usr.lsp.lspMason")
2 | 
3 | require("usr.lsp.handlers").setup()
4 | require("usr.lsp.null_ls")
5 | 


--------------------------------------------------------------------------------
/ftplugin/r.lua:
--------------------------------------------------------------------------------
1 | 
2 | vim.api.keymap('n', '<leader>rp', ':!Rscript -e "rmarkdown::render(\'%\')"', { noremap = true, silent = true })
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | plugin/packer_compiled.lua
2 | test/
3 | tag.git
4 | 
5 | package-lock.json
6 | package.json
7 | node_modules
8 | .luarc.json
9 | 


--------------------------------------------------------------------------------
/lua/usr/core/init.lua:
--------------------------------------------------------------------------------
1 | require("usr.core.autocomands")
2 | require("usr.core.colorscheme")
3 | require("usr.core.options")
4 | require("usr.core.keymaps")
5 | 


--------------------------------------------------------------------------------
/lua/usr/annotations.lua:
--------------------------------------------------------------------------------
1 | local neogen = require("neogen")
2 | 
3 | neogen.setup {
4 | 	enabled = true,
5 | 	input_after_comment = true,
6 | 	snippet_engine = "luasnip",
7 | }
8 | 
9 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/cmake.lua:
--------------------------------------------------------------------------------
1 | return {
2 | 	cmd = { "cmake-language-server" },
3 | 	filetypes = { "cmake" },
4 | 	init_options = {
5 | 	  buildDirectory = "build",
6 | 	},
7 | 	single_file_support = true,
8 | }
9 | 


--------------------------------------------------------------------------------
/lua/usr/navigation/init.lua:
--------------------------------------------------------------------------------
1 | require("usr.navigation.dropbar")
2 | require("usr.navigation.neotree")
3 | require("usr.navigation.satellite")
4 | require("usr.navigation.scroll")
5 | require("usr.navigation.snippets")
6 | 
7 | 


--------------------------------------------------------------------------------
/lua/usr/copilot.lua:
--------------------------------------------------------------------------------
1 | -- copilot.lua
2 | --
3 | -- Copilot is a plugin that provides autocompletion for nvim.
4 | -- It is a wrapper around the copilot binary.
5 | -- 		generated by Copilot
6 | -- remaps <C-a> to accept the suggestion
7 | vim.cmd([[ imap <silent><script><expr> <C-a> copilot#Accept("\<CR>")]])
8 | vim.g.copilot_no_tab_map = true
9 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/matlab_ls.lua:
--------------------------------------------------------------------------------
 1 | return {
 2 | 	cmd = { "matlab-language-server", "--stdio" },
 3 | 	filetypes = { "matlab" },
 4 | 	{
 5 | 		MATLAB = {
 6 | 			indexWorkspace = false,
 7 | 			installPath = "",
 8 | 			matlabConnectionTiming = "onStart",
 9 | 			telemetry = true
10 | 		}
11 | 	},
12 | 	single_file_support = true,
13 | }
14 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/settings/daplua.lua:
--------------------------------------------------------------------------------
 1 | local dap = require('dap')
 2 | 
 3 | dap.configurations.lua = {
 4 | 	{
 5 | 		type = 'nlua',
 6 | 		request = 'attach',
 7 | 		name = "Attach to running Neovim instance",
 8 | 	}
 9 | }
10 | 
11 | function dap.adapters.nlua(callback, config)
12 | 	callback({ type = 'server', host = config.host or "127.0.0.1", port = config.port or 8086 })
13 | end
14 | 


--------------------------------------------------------------------------------
/lua/usr/illuminate.lua:
--------------------------------------------------------------------------------
1 | vim.g.Illuminate_ftblacklist = { 'alpha', 'NvimTree', 'neo-tree', 'dashboard', 'lazy', 'mason' }
2 | -- vim.g.Illuminate_highlightUnderCursor = 0
3 | vim.api.nvim_set_keymap('n', '.', '<cmd>lua require"illuminate".next_reference({wrap=true})<cr>', {noremap=true})
4 | vim.api.nvim_set_keymap('n', ',', '<cmd>lua require"illuminate".next_reference({reverse=true, wrap=true})<cr>', {noremap=true})
5 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/init.lua:
--------------------------------------------------------------------------------
 1 | local current_path = vim.fn.expand("%")
 2 | 
 3 | -- Find file in a input direcotory supplied into a function
 4 | local function find_file_in_dir(dir, file)
 5 | 	local file_path = dir .. "/" .. file
 6 | 	local f = io.open(file_path, "r")
 7 | 	if f ~= nil then
 8 | 		io.close(f)
 9 | 		return file_path
10 | 	end
11 | 	return nil
12 | end
13 | 
14 | local M = {
15 | 	vim = {
16 | 		vimlatex = find_file_in_dir(current_path, "vimlatex.vim"),
17 | 	}
18 | }
19 | 
20 | return M
21 | 


--------------------------------------------------------------------------------
/lua/usr/lazygit.lua:
--------------------------------------------------------------------------------
1 | vim.cmd [[
2 | 	let g:lazygit_floating_window_winblend = 0 " transparency of floating window
3 | 	let g:lazygit_floating_window_scaling_factor = 0.9 " scaling factor for floating window
4 | 	let g:lazygit_floating_window_corner_chars = ['╭', '╮', '╰', '╯'] " customize lazygit popup window corner characters
5 | 	let g:lazygit_floating_window_use_plenary = 0 " use plenary.nvim to manage floating window if available
6 | 	let g:lazygit_use_neovim_remote = 1 " fallback to 0 if neovim-remote is not installed
7 | ]]
8 | 


--------------------------------------------------------------------------------
/init.lua:
--------------------------------------------------------------------------------
 1 | -- This has to be first or else nothing will work
 2 | require("usr.lazyManager")
 3 | require("usr.core")
 4 | 
 5 | require("usr.annotations")
 6 | require("usr.autopairs")
 7 | require("usr.bufferline")
 8 | require("usr.ccc")
 9 | require("usr.comment")
10 | require("usr.DAP")
11 | require("usr.gitsigns")
12 | require("usr.illuminate")
13 | require("usr.impatient")
14 | require("usr.lsp")
15 | require("usr.lualine")
16 | require("usr.navigation")
17 | require("usr.todo-comments")
18 | require("usr.toggleterm")
19 | require("usr.ts")
20 | require("usr.tscope")
21 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/lua_ls.lua:
--------------------------------------------------------------------------------
 1 | return {
 2 | 	cmd = { "lua-language-server" },
 3 | 	filetypes = { "lua" },
 4 | 	root_markers = { ".luarc.json", ".luarc.jsonc", ".git", "stylua.toml" },
 5 | 	settings = {
 6 | 		Lua = {
 7 | 			hint = { enable = true, },
 8 | 			diagnostics = {
 9 | 				globals = { "vim" },
10 | 			},
11 | 			workspace = {
12 | 				library = {
13 | 					[vim.fn.expand("$VIMRUNTIME/lua")] = true,
14 | 					[vim.fn.stdpath("config") .. "/lua"] = true,
15 | 				},
16 | 			},
17 | 			telemetry = {
18 | 				enable = false,
19 | 			},
20 | 		},
21 | 	},
22 | }
23 | 


--------------------------------------------------------------------------------
/lua/usr/ccc.lua:
--------------------------------------------------------------------------------
 1 | 
 2 | local M = {}
 3 | 
 4 | function M.config()
 5 | 	local ok, ccc = pcall(require,"ccc")
 6 | 	if not ok then
 7 | 		print("Error loading ccc")
 8 | 		return
 9 | 	end
10 | 
11 | 	return {
12 | 		highlighter = {
13 | 			auto_enable = true,
14 | 			lsp = true,
15 | 		},
16 | 		inputs = {
17 | 			ccc.input.rgb,
18 | 			ccc.input.hsl,
19 | 			ccc.input.hsv,
20 | 			ccc.input.oklab,
21 | 		},
22 | 		outputs = {
23 | 			ccc.output.css_rgb,
24 | 			ccc.output.css_hsl,
25 | 			ccc.output.css_oklab,
26 | 			ccc.output.hex,
27 | 		}
28 | 	}
29 | end
30 | 
31 | return M
32 | 


--------------------------------------------------------------------------------
/ftplugin/lua.lua:
--------------------------------------------------------------------------------
1 | vim.api.nvim_set_keymap('n', '<F8>', [[:lua require"dap".toggle_breakpoint()<CR>]], { noremap = true })
2 | vim.api.nvim_set_keymap('n', '<F9>', [[:lua require"dap".continue()<CR>]], { noremap = true })
3 | vim.api.nvim_set_keymap('n', '<F10>', [[:lua require"dap".step_over()<CR>]], { noremap = true })
4 | vim.api.nvim_set_keymap('n', '<S-F10>', [[:lua require"dap".step_into()<CR>]], { noremap = true })
5 | vim.api.nvim_set_keymap('n', '<F12>', [[:lua require"dap.ui.widgets".hover()<CR>]], { noremap = true })
6 | vim.api.nvim_set_keymap('n', '<F5>', [[:lua require"osv".launch({port = 8086})<CR>]], { noremap = true })
7 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/bashls.lua:
--------------------------------------------------------------------------------
 1 | local util = require 'lspconfig.util'
 2 | 
 3 | local root_files = {
 4 | 	'.clangd',
 5 | 	'.clang-tidy',
 6 | 	'.clang-format',
 7 | 	'compile_commands.json',
 8 | 	'compile_flags.txt',
 9 | 	'compile', -- buildProject
10 | 	'configure.ac', -- AutoTools
11 | 	'run'
12 | }
13 | 
14 | 
15 | return {
16 | 	cmd = {
17 | 		"bash-language-server",
18 | 		"start",
19 | 	},
20 | 	cmd_env = {
21 | 		GLOB_PATTERN = "*@(.sh|.inc|.bash|.command)"
22 | 	},
23 | 	filetypes = {
24 | 		"sh",
25 | 		"zsh",
26 | 		"bash",
27 | 	},
28 | 	root_dir = vim.fs.root(0, root_files),
29 | 	single_file_support = true,
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/ftplugin/tex.lua:
--------------------------------------------------------------------------------
 1 | vim.opt.textwidth=120
 2 | 
 3 | local no_at_end = {
 4 | 	"a",
 5 | 	"aj",
 6 | 	"ak",
 7 | 	"ale",
 8 | 	"cez",
 9 | 	"do",
10 | 	"k",
11 | 	"kde",
12 | 	"ku",
13 | 	"na",
14 | 	"o",
15 | 	"od",
16 | 	"po",
17 | 	"pre",
18 | 	"preto",
19 | 	"pri",
20 | 	"s",
21 | 	"so",
22 | 	"sú",
23 | 	"tak",
24 | 	"to",
25 | 	"u",
26 | 	"už",
27 | 	"v",
28 | 	"vo",
29 | 	"z",
30 | 	"za",
31 | 	"zo",
32 | 	"že",
33 | 	"či",
34 | }
35 | 
36 | vim.keymap.set('n', '<leader>at', function ()
37 | 	for _, x in pairs(no_at_end) do
38 | 		vim.cmd('%s/\\<' .. x .. ' /' .. x .. '\\~/ge')
39 | 		x = x:gsub("(%l)(%w*)", function(a,b) return string.upper(a)..b end) 
40 | 		vim.cmd('%s/\\<' .. x .. ' /' .. x .. '\\~/ge')
41 | 	end
42 | end)
43 | 


--------------------------------------------------------------------------------
/lua/usr/tscope/adjustments.lua:
--------------------------------------------------------------------------------
 1 | local telescope = require("telescope.builtin")
 2 | 
 3 | local M = {}
 4 | 
 5 | function M.source_search ()
 6 | 	telescope.git_files {
 7 | 		cwd = "./src/",
 8 | 		use_git_root = false,
 9 | 		show_untracked = false,
10 | 		recurse_submodules = false,
11 | 		git_command = {"git","ls-files","--exclude-standard","--cached"},
12 | 	}
13 | end
14 | 
15 | function M.extend_live_grep(search_opened)
16 | 	telescope.live_grep {
17 | 		grep_open_files = search_opened or false,
18 | 		type_filter = "cpp",
19 | 		additional_args = {
20 | 			"--pretty",
21 | 			"--sort path",
22 | 		},
23 | 		disable_coordinates = false,
24 | 	}
25 | end
26 | 
27 | function M.extend_grep_string(search_opened, dir)
28 | 	telescope.grep_string {
29 | 		cwd = dir or "./src/",
30 | 		grep_open_files = search_opened or false,
31 | 	}
32 | end
33 | 
34 | return M
35 | 


--------------------------------------------------------------------------------
/lua/usr/navigation/snippets.lua:
--------------------------------------------------------------------------------
 1 | local status, luasnip = pcall(require, "luasnip")
 2 | if not status then
 3 | 	vim.notify("Lusnip cannot be required", vim.log.levels.ERROR)
 4 | 	return
 5 | end
 6 | 
 7 | require("luasnip/loaders/from_vscode").lazy_load()
 8 | 
 9 | luasnip.config.set_config({
10 | 	-- This tells LuaSnip to remember to keep around the last snippet.
11 | 	-- You can jump back into it even if you move outside of the selection
12 | 	history = false,
13 | 
14 | 	-- This one is cool cause if you have dynamic snippets, it updates as you type!
15 | 	updateevents = "TextChanged,TextChangedI",
16 | 
17 | 	-- Autosnippets:
18 | 	enable_autosnippets = false,
19 | 
20 | 	--[[ ext_opts = { ]]
21 | 	--[[ 	[types.choiceNode] = { ]]
22 | 	--[[ 		active = { ]]
23 | 	--[[ 			virt_text = { { " « ", "NonTest" } }, ]]
24 | 	--[[ 		}, ]]
25 | 	--[[ 	}, ]]
26 | 	--[[ }, ]]
27 | })
28 | 
29 | 


--------------------------------------------------------------------------------
/lua/usr/autopairs.lua:
--------------------------------------------------------------------------------
 1 | local autopairs = require("nvim-autopairs")
 2 | 
 3 | autopairs.setup {
 4 | 	check_ts = true,
 5 | 	ts_config = {
 6 | 		lua = { "string", "source" },
 7 | 		javascript = { "string", "template_string" },
 8 | 		java = false,
 9 | 	},
10 | 	disable_filetype = { "TelescopePrompt", "spectre_panel" },
11 | 	fast_wrap = {
12 | 		map = "<M-e>",
13 | 		chars = { "{", "[", "(", '"', "'" },
14 | 		pattern = string.gsub([[ [%'%"%)%>%]%)%}%,] ]], "%s+", ""),
15 | 		offset = 0, -- Offset from pattern match
16 | 		end_key = "$",
17 | 		keys = "qwertyuiopzxcvbnmasdfghjkl",
18 | 		check_comma = true,
19 | 		highlight = "PmenuSel",
20 | 		highlight_grey = "LineNr",
21 | 	},
22 | }
23 | 
24 | local cmp_autopairs = require("nvim-autopairs.completion.cmp")
25 | 
26 | local cmp = require("cmp")
27 | cmp.event:on("confirm_done", cmp_autopairs.on_confirm_done { map_char = { tex = "" } })
28 | 
29 | 
30 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/marksman.lua:
--------------------------------------------------------------------------------
 1 | local util = require 'lspconfig.util'
 2 | 
 3 | local bin_name = 'marksman'
 4 | local cmd = { bin_name, 'server' }
 5 | 
 6 | local root_files = {
 7 | 	'.marksman.toml',
 8 | 	'.marksman.yaml',
 9 | 	'.git',
10 | 	'.gitignore',
11 | 	'.gitmodules',
12 | }
13 | 
14 | return {
15 | 	default_config = {
16 | 		cmd = cmd,
17 | 		filetypes = { 'markdown', 'markdown.mdx' },
18 | 		root_dir = vim.fs.root(0, root_files),
19 | 		single_file_support = true,
20 | 	},
21 | 	docs = {
22 | 		description = [[
23 | https://github.com/artempyanykh/marksman
24 | 
25 | Marksman is a Markdown LSP server providing completion, cross-references, diagnostics, and more.
26 | 
27 | Marksman works on MacOS, Linux, and Windows and is distributed as a self-contained binary for each OS.
28 | 
29 | Pre-built binaries can be downloaded from https://github.com/artempyanykh/marksman/releases
30 | ]],
31 | 	},
32 | }
33 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/settings/bashdap.lua:
--------------------------------------------------------------------------------
 1 | local dap = require('dap')
 2 | 
 3 | dap.adapters.bashdb = {
 4 | 	type = 'executable';
 5 | 	command = vim.fn.stdpath("data") .. '/mason/packages/bash-debug-adapter/bash-debug-adapter';
 6 | 	name = 'bashdb';
 7 | }
 8 | 
 9 | dap.configurations.sh = {
10 | 	{
11 | 		type = 'bashdb';
12 | 		request = 'launch';
13 | 		name = "Launch file";
14 | 		showDebugOutput = true;
15 | 		pathBashdb = vim.fn.stdpath("data") .. '/mason/packages/bash-debug-adapter/extension/bashdb_dir/bashdb';
16 | 		pathBashdbLib = vim.fn.stdpath("data") .. '/mason/packages/bash-debug-adapter/extension/bashdb_dir';
17 | 		trace = true;
18 | 		file = "${file}";
19 | 		program = "${file}";
20 | 		cwd = '${workspaceFolder}';
21 | 		pathCat = "cat";
22 | 		pathBash = "/bin/bash";
23 | 		pathMkfifo = "mkfifo";
24 | 		pathPkill = "pkill";
25 | 		args = {};
26 | 		env = {};
27 | 		terminalKind = "integrated";
28 | 	}
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/lua/usr/navigation/scroll.lua:
--------------------------------------------------------------------------------
 1 | local scroll = require("neoscroll")
 2 | 
 3 | scroll.setup({
 4 | 	-- All these keys will be mapped to their corresponding default scrolling animation
 5 | 	mappings = {'<C-u>', '<C-d>', '<C-b>', '<C-f>',
 6 | 				'<C-y>', '<C-e>', 'zt', 'zz', 'zb'},
 7 | 	hide_cursor = true,				-- Hide cursor while scrolling
 8 | 	stop_eof = true,				-- Stop at <EOF> when scrolling downwards
 9 | 	use_local_scrolloff = false,	-- Use the local scope of scrolloff instead of the global scope
10 | 	respect_scrolloff = false,		-- Stop scrolling when the cursor reaches the scrolloff margin of the file
11 | 	cursor_scrolls_alone = true,	-- The cursor will keep on scrolling even if the window cannot scroll further
12 | 	easing_function = nil,	-- Default easing function
13 | 	pre_hook = nil,					-- Function to run before the scrolling animation starts
14 | 	post_hook = nil,				-- Function to run after the scrolling animation ends
15 | 	performance_mode = false,		-- Disable "Performance Mode" on all buffers.
16 | })
17 | 
18 | 


--------------------------------------------------------------------------------
/lua/usr/navigation/satellite.lua:
--------------------------------------------------------------------------------
 1 | local sat = require("satellite")
 2 | 
 3 | sat.setup {
 4 | 	current_only = false,
 5 | 	winblend = 50,
 6 | 	zindex = 40,
 7 | 	excluded_filetypes = {},
 8 | 	width = 2,
 9 | 	handlers = {
10 | 		cursor = {
11 | 			enable = true,
12 | 			symbols = { '⎺', '⎻', '⎼', '⎽' },
13 | 			overlap = true,
14 | 			priority = 0,
15 | 		},
16 | 		search = {
17 | 			enable = true,
18 | 		},
19 | 		diagnostic = {
20 | 			enable = true,
21 | 			signs = {'-', '=', '≡'},
22 | 			min_severity = vim.diagnostic.severity.HINT,
23 | 		},
24 | 		gitsigns = {
25 | 			enable = true,
26 | 			signs = { -- can only be a single character (multibyte is okay)
27 | 				add = "│",
28 | 				change = "│",
29 | 				delete = "-",
30 | 			},
31 | 		},
32 | 		marks = {
33 | 			enable = true,
34 | 			show_builtins = false, -- shows the builtin marks like [ ] < >
35 | 			key = "",
36 | 		},
37 | 		quickfix = {
38 | 			enable = true,
39 | 			overlap = true,
40 | 			priority = 3,
41 | 			signs = { '-', '=', '≡'},
42 | 		},
43 | 	},
44 | }
45 | 


--------------------------------------------------------------------------------
/lua/usr/snacks/dashboard.lua:
--------------------------------------------------------------------------------
 1 | ---@class snacks.dashboard.Config
 2 | ---@field enabled? boolean
 3 | ---@field sections snacks.dashboard.Section
 4 | ---@field formats table<string, snacks.dashboard.Text|fun(item:snacks.dashboard.Item, ctx:snacks.dashboard.Format.ctx):snacks.dashboard.Text>
 5 | return {
 6 | 	enabled = true,
 7 | 	sections = {
 8 | 		{ section = "header" },
 9 | 		{
10 | 			pane = 2,
11 | 			padding = 5,
12 | 		},
13 | 		{ section = "keys", gap = 1, padding = 1 },
14 | 		{ pane = 2, icon = " ", title = "Recent Files", section = "recent_files", indent = 2, padding = 1 },
15 | 		{ pane = 2, icon = " ", title = "Projects", section = "projects", indent = 2, padding = 1 },
16 | 		{
17 | 			pane = 2,
18 | 			icon = " ",
19 | 			title = "Git Status",
20 | 			section = "terminal",
21 | 			enabled = function()
22 | 				return Snacks.git.get_root() ~= nil
23 | 			end,
24 | 			cmd = "git status --short --branch --renames",
25 | 			height = 5,
26 | 			padding = 1,
27 | 			ttl = 5 * 60,
28 | 			indent = 3,
29 | 		},
30 | 		{ section = "startup" },
31 | 	},
32 | }
33 | 


--------------------------------------------------------------------------------
/lua/usr/lazyManager.lua:
--------------------------------------------------------------------------------
 1 | -- Bootstrap lazy.nvim
 2 | local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
 3 | if not (vim.uv or vim.loop).fs_stat(lazypath) then
 4 | 	local lazyrepo = "https://github.com/folke/lazy.nvim.git"
 5 | 	local out = vim.fn.system({
 6 | 		"git",
 7 | 		"clone",
 8 | 		"--filter=blob:none",
 9 | 		"--branch=stable",
10 | 		lazyrepo,
11 | 		lazypath
12 | 	})
13 | 	if vim.v.shell_error ~= 0 then
14 | 		vim.api.nvim_echo({
15 | 			{ "Failed to clone lazy.nvim:\n", "ErrorMsg" },
16 | 			{ out, "WarningMsg" },
17 | 			{ "\nPress any key to exit..." },
18 | 		}, true, {})
19 | 		vim.fn.getchar()
20 | 		os.exit(1)
21 | 	end
22 | end
23 | vim.opt.rtp:prepend(lazypath)
24 | 
25 | local opts = { noremap = true, silent = true }
26 | local keymap = vim.api.nvim_set_keymap
27 | 
28 | keymap("", "<SPACE>", "<NOP>", opts)
29 | vim.g.mapleader = " "
30 | vim.g.maplocalleader = " "
31 | 
32 | -- Use a protected call so we don't error out on first use
33 | local status_ok, lazy = pcall(require, "lazy")
34 | if not status_ok then
35 | 	vim.notify("lazy error")
36 | 	return
37 | end
38 | 
39 | -- Install your plugins here
40 | lazy.setup('usr.plugins')
41 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/nvimdap.lua:
--------------------------------------------------------------------------------
 1 | require("usr.DAP.settings.dapcpp")
 2 | require("usr.DAP.settings.bashdap")
 3 | require("usr.DAP.settings.daplua")
 4 | require("usr.DAP.settings.dappy")
 5 | 
 6 | local opts = { silent = true, }
 7 | local keymap = vim.api.nvim_set_keymap
 8 | 
 9 | -- require('dap')
10 | vim.fn.sign_define('DapBreakpoint', {text='', texthl='', linehl='', numhl=''})
11 | vim.fn.sign_define('DapStopped', {text='󰋇',  texthl='', linehl='', numhl=''})
12 | 
13 | keymap("n", "<leader>dc", ":lua require'dap'.continue()<CR>", opts)
14 | keymap("n", "<F8>", ":lua require'dap'.step_over()<CR>", opts)
15 | keymap("n", "<F9>", ":lua require'dap'.step_into()<CR>", opts)
16 | keymap("n", "<S-F9>", ":lua require'dap'.step_out()<CR>", opts)
17 | keymap("n", "<leader>de", ":lua require'dap'.close()<CR>", opts)
18 | keymap("n", "<leader>br", ":lua require'dap'.toggle_breakpoint()<CR>", opts)
19 | keymap("n", "<leader>tb", ":lua require'dapui'.toggle()<CR>", opts)
20 | keymap("n", "<leader>cb", ":lua require'dap'.set_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>", opts)
21 | keymap("n", "<leader>lb", ":lua require'dap'.set_breakpoint(nil, nil, vim.fn.input('Log point message: '))<CR>", opts)
22 | 
23 | 


--------------------------------------------------------------------------------
/lua/usr/core/options.lua:
--------------------------------------------------------------------------------
 1 | local util = require("usr.core.util")
 2 | 
 3 | local options = {
 4 | 	autoread = true,
 5 | 	clipboard = "unnamedplus",
 6 | 	conceallevel = 0, -- can create error on lazy installing plugins
 7 | 	cursorline = true,
 8 | 	expandtab = false,
 9 | 	fileencoding = "utf-8",
10 | 	foldenable = true,
11 | 	foldlevel = 99,
12 | 	foldexpr = 'v:lua.vim.lsp.foldexpr()',
13 | 	foldtext = "",
14 | 	foldcolumn = "0",
15 | 	hlsearch = true,
16 | 	linebreak = true,
17 | 	list = true,
18 | 	listchars = "tab:-->,trail:~,space:·",
19 | 	mouse = "a",
20 | 	mousemodel = "popup_setpos",
21 | 	number = true,
22 | 	relativenumber = false,
23 | 	shiftwidth = 4,
24 | 	smartindent = true,
25 | 	splitbelow = true,
26 | 	splitright = true,
27 | 	tabstop = 4,
28 | 	termguicolors = true,
29 | 	textwidth = 125,
30 | 	fillchars  = { util.opt.append, {fold = " "} },
31 | 	formatoptions = {util.opt.append, "cn", util.opt.remove, "ro"},
32 | 	iskeyword = {util.opt.append, "-"},
33 | 	shortmess = {util.opt.append, "c"},
34 | 	statusline = {util.opt.append, "%-{get(b:,'gitsigns_status','')}"},
35 | 	whichwrap = {util.opt.append, "<,>,[,],h,l"},
36 | 	winborder = "rounded",
37 | }
38 | 
39 | vim.g.clipboard = "osc52"
40 | 
41 | util.register_options(options)
42 | 


--------------------------------------------------------------------------------
/lua/usr/comment.lua:
--------------------------------------------------------------------------------
 1 | local comment = require("Comment")
 2 | 
 3 | comment.setup {
 4 | 	---Add a space b/w comment and the line
 5 | 	padding = true,
 6 | 
 7 | 	---Whether the cursor should stay at its position
 8 | 	sticky = true,
 9 | 
10 | 	---Lines to be ignored while (un)comment
11 | 	ignore = function()
12 | 		return '^$'
13 | 	end,
14 | 
15 | 	---LHS of toggle mappings in NORMAL mode
16 | 	toggler = {
17 | 		---Line-comment toggle keymap
18 | 		line = 'gcc',
19 | 		---Block-comment toggle keymap
20 | 		block = 'gbc',
21 | 	},
22 | 
23 | 	---LHS of operator-pending mappings in NORMAL and VISUAL mode
24 | 	opleader = {
25 | 		line = 'gc',	---Line-comment keymap
26 | 		block = 'gb',	---Block-comment keymap
27 | 	},
28 | 
29 | 	---LHS of extra mappings
30 | 	extra = {
31 | 		above = 'gcO',	---Add comment on the line above
32 | 		below = 'gco',	---Add comment on the line below
33 | 		eol = 'gcA',	---Add comment at the end of line
34 | 	},
35 | 
36 | 	---Enable keybindings
37 | 	---NOTE: If given `false` then the plugin won't create any mappings
38 | 	mappings = {
39 | 		basic = true,	---Operator-pending mapping; `gcc` `gbc` `gc[count]{motion}` `gb[count]{motion}`
40 | 		extra = true,	---Extra mapping; `gco`, `gcO`, `gcA`
41 | 	},
42 | 
43 | 	---Function to call before (un)comment
44 | 	pre_hook = nil,
45 | 
46 | 	---Function to call after (un)comment
47 | 	post_hook = nil,
48 | }
49 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/blink.lua:
--------------------------------------------------------------------------------
 1 | return {
 2 | 	completion = {
 3 | 		documentation = {
 4 | 			auto_show = true,
 5 | 			auto_show_delay_ms = 500,
 6 | 			treesitter_highlighting = true,
 7 | 			draw = function(opts)
 8 | 				if not opts.item or not opts.item.documentation or not opts.item.documentation.value then
 9 | 					vim.print("Leaving blink docs emtpy")
10 | 					return
11 | 				end
12 | 
13 | 				local out = require("pretty_hover.parser").parse(opts.item.documentation.value)
14 | 				opts.item.documentation.value = out:string()
15 | 				opts.default_implementation(opts)
16 | 			end,
17 | 			window = {
18 | 				border = "rounded",
19 | 			},
20 | 		},
21 | 		list = {
22 | 			selection = {
23 | 				preselect = true,
24 | 				auto_insert = true,
25 | 			},
26 | 		},
27 | 		menu = {
28 | 			draw = {
29 | 				treesitter = { 'lsp' },
30 | 			},
31 | 		},
32 | 	},
33 | 
34 | 	signature = {
35 | 		enabled = true,
36 | 		window = {
37 | 			border = "rounded",
38 | 		},
39 | 	},
40 | 
41 | 	keymap = {
42 | 		preset = 'default',
43 | 
44 | 		["<Tab>"] = { "select_next", "fallback"},
45 | 		["<S-Tab>"] = { "select_prev", "fallback"},
46 | 
47 | 		["<C-p>"] = { "snippet_forward", "fallback"},
48 | 		["<C-n>"] = { "snippet_backward", "fallback"},
49 | 		["<CR>"] = { "accept", "fallback" },
50 | 	},
51 | 	sources = {
52 | 		priority = {
53 | 			'lsp',
54 | 			'snippets',
55 | 			'path',
56 | 			'buffer',
57 | 		},
58 | 	},
59 | }
60 | 


--------------------------------------------------------------------------------
/lua/usr/core/util.lua:
--------------------------------------------------------------------------------
 1 | ---@class ConfigCoreUtil
 2 | ---@field opt table<string, string>
 3 | ---@field remove_trailing_whitespaces fun()
 4 | ---@field register_options fun(options:table<string, any>)
 5 | local M = {
 6 | 	opt = {
 7 | 		append = "a",
 8 | 		remove = "r",
 9 | 		prepend = "p",
10 | 	},
11 | }
12 | 
13 | function M.remove_trailing_whitespaces()
14 | 	local cursor_pos = vim.api.nvim_win_get_cursor(0)
15 | 
16 | 	-- Trim trailing whitespace
17 | 	if not vim.bo.modifiable then
18 | 		return
19 | 	end
20 | 
21 | 	vim.cmd("%s/\\s\\+$//e")
22 | 	local filename = vim.api.nvim_buf_get_name(0)
23 | 	vim.cmd.save(filename)
24 | 	vim.api.nvim_win_set_cursor(0, cursor_pos)
25 | end
26 | 
27 | 
28 | function M.register_options(options)
29 | 	for k, v in pairs(options) do
30 | 		if type(v) ~= "table" then
31 | 			vim.opt[k] = v
32 | 			goto continue
33 | 		end
34 | 
35 | 		if #v % 2 == 1 then
36 | 			vim.notify("Table must have an even number of elements. Option " .. k, vim.log.levels.ERROR)
37 | 			goto continue
38 | 		end
39 | 
40 | 		for i=1, #v/2 do
41 | 			if v[i*2-1] == M.opt.append then
42 | 				vim.opt[k]:append(v[i*2])
43 | 
44 | 			elseif v[i*2-1] == M.opt.remove then
45 | 				vim.opt[k]:remove(v[i*2])
46 | 
47 | 			elseif v[i*2-1] == M.opt.prepend then
48 | 				vim.opt[k]:prepend(v[i*2])
49 | 
50 | 			else
51 | 				error("Invalid option")
52 | 
53 | 			end
54 | 		end
55 | 
56 | 		::continue::
57 | 	end
58 | end
59 | 
60 | return M
61 | 


--------------------------------------------------------------------------------
/lua/usr/core/colorscheme.lua:
--------------------------------------------------------------------------------
 1 | local colorscheme = "catppuccin"
 2 | local scheme = require(colorscheme)
 3 | 
 4 | scheme.setup({
 5 | 	flavour = "mocha", -- latte, frappe, macchiato, mocha
 6 | 	background = { -- :h background
 7 | 		light = "latte",
 8 | 		dark = "mocha",
 9 | 	},
10 | 	transparent_background = false,
11 | 	term_colors = true,
12 | 	dim_inactive = {
13 | 		enabled = false,
14 | 		shade = "dark",
15 | 	},
16 | 	no_italic = false, -- Force no italic
17 | 	no_bold = false, -- Force no bold
18 | 	styles = {
19 | 		comments = { "italic" },
20 | 		conditionals = { "italic" },
21 | 		loops = {},
22 | 		functions = { "bold" },
23 | 		keywords = {},
24 | 		strings = {},
25 | 		variables = {},
26 | 		numbers = {},
27 | 		booleans = {},
28 | 		properties = {},
29 | 		types = {},
30 | 		operators = {},
31 | 	},
32 | 	color_overrides = {},
33 | 	custom_highlights = {},
34 | 	highlight_overrides = {
35 | 		mocha = {
36 | 			Comment = { fg = "#ADADAD" },
37 | 		},
38 | 	},
39 | 	integrations = {
40 | 		cmp = true,
41 | 		gitsigns = true,
42 | 		nvimtree = true,
43 | 		telescope = true,
44 | 		treesitter = true,
45 | 		integration = {
46 | 			dap = {
47 | 				enabled = true,
48 | 				enable_ui = true, -- enable nvim-dap-ui
49 | 			},
50 | 		}
51 | 		-- For more plugins integrations please scroll down (https://github.com/catppuccin/nvim#integrations)
52 | 	},
53 | })
54 | 
55 | vim.cmd.colorscheme(colorscheme)
56 | 
57 | -- transparent background
58 | local mocha = require("catppuccin.palettes").get_palette "mocha"
59 | 
60 | vim.api.nvim_set_hl(0, 'Normal', { bg = mocha.base })
61 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/null_ls.lua:
--------------------------------------------------------------------------------
 1 | local null_ls = require("null-ls")
 2 | 
 3 | -- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/formatting
 4 | local formatting = null_ls.builtins.formatting
 5 | -- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/diagnostics
 6 | local diagnostics = null_ls.builtins.diagnostics
 7 | -- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/completion
 8 | local completion = null_ls.builtins.completion
 9 | --https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/code_action
10 | local code_actions = null_ls.builtins.code_actions
11 | 
12 | null_ls.setup({
13 | 	debug = false,
14 | 	sources = {
15 | 		-- GITSIGNS
16 | 		code_actions.gitsigns,
17 | 
18 | 		-- LUA
19 | 		formatting.stylua,
20 | 
21 | 		-- C / C++ / Obj. C
22 | 		formatting.clang_format.with({
23 | 			extra_args = {
24 | 				"--sort-includes",
25 | 			},
26 | 		}),
27 | 		diagnostics.cppcheck.with({
28 | 			extra_args = {
29 | 				"--std=c++17",
30 | 				-- "--enable=all",
31 | 				"--language=c++",
32 | 				-- "--check-config",
33 | 				-- "-rp"
34 | 				-- "--project=compile_commands.json",
35 | 			},
36 | 		}),
37 | 
38 | 		-- CMAKE
39 | 		formatting.cmake_format.with({
40 | 			extra_args = {
41 | 				"--tab-size 4",
42 | 				"--use-tabchars true",
43 | 				"--enable-sort true",
44 | 			},
45 | 		}),
46 | 
47 | 		-- SPELL
48 | 		completion.spell,
49 | 
50 | 		-- Python
51 | 		diagnostics.mypy,
52 | 
53 | 		-- MARKDOWN
54 | 
55 | 		-- SNIPPETS
56 | 		-- completion.luasnip,
57 | 	},
58 | })
59 | 


--------------------------------------------------------------------------------
/spell/en.utf-8.add:
--------------------------------------------------------------------------------
  1 | texlive
  2 | mutex
  3 | ostream
  4 | json
  5 | doxygen
  6 | odometry
  7 | docstrings
  8 | Docstring
  9 | RRT
 10 | UR5
 11 | #RTConnect
 12 | RobWork
 13 | DOF
 14 | DK
 15 | PID
 16 | HLS
 17 | FPGA
 18 | tensorflow
 19 | MA
 20 | DMA
 21 | Vivado
 22 | Peta
 23 | Yocto
 24 | AXI
 25 | DynamixelSDK
 26 | Ultra96
 27 | MPSoc4Drones
 28 | ROS2
 29 | OpenCV
 30 | Dynamixel
 31 | Generalistic
 32 | Eigenfactor
 33 | famework
 34 | Mahalabobis
 35 | Kalman
 36 | frac
 37 | IMU
 38 | UAV
 39 | arctan
 40 | dt
 41 | UTM
 42 | d1
 43 | acos
 44 | asin
 45 | lat1
 46 | lat2
 47 | lon1
 48 | lon2
 49 | WSG84
 50 | GNSS
 51 | MEO
 52 | MCS
 53 | L1
 54 | L2
 55 | L5
 56 | NMEA
 57 | DOP
 58 | GDOP
 59 | PDOP
 60 | HDOP
 61 | VDOP
 62 | SPS
 63 | DGPS
 64 | RTK
 65 | yagi
 66 | uda
 67 | rx
 68 | tx
 69 | VLOS
 70 | AGL
 71 | MTOM
 72 | A1
 73 | A2
 74 | A3
 75 | STS
 76 | C5
 77 | UAS
 78 | BVLOS
 79 | C6
 80 | PDRA
 81 | S01
 82 | S02
 83 | G01
 84 | G02
 85 | G03
 86 | SORA
 87 | LUC
 88 | fx
 89 | #pecific
 90 | conspicuity
 91 | ANSP
 92 | TMPR
 93 | UA
 94 | OSO
 95 | #SOS
 96 | Pixhawk
 97 | PX4
 98 | QGroundControl
 99 | QGC
100 | mavros
101 | C2
102 | LiPo
103 | iGRC
104 | GRC
105 | PRS
106 | F3322
107 | Q1
108 | sUA
109 | Q2
110 | Q3
111 | Q4
112 | Q5
113 | CNMF
114 | Q6
115 | Q7
116 | FTS
117 | Q8
118 | MTD
119 | RPIC
120 | Q9
121 | Q10
122 | MDSL
123 | Q11
124 | Q12
125 | Q13
126 | sUAS
127 | slg
128 | ft3
129 | m3
130 | Q14
131 | UAs
132 | Q15
133 | Q16
134 | Q17
135 | ulg
136 | px4
137 | io
138 | png
139 | #fferes
140 | Ramer
141 | Peucker
142 | Visvalingam
143 | Whyatt
144 | gpsbabel
145 | gpsvisualizer
146 | #groundControl
147 | VSWR
148 | SWR
149 | ESCs
150 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/virtual_text.lua:
--------------------------------------------------------------------------------
 1 | return {
 2 | 	enabled = true,						-- enable this plugin (the default)
 3 | 	enabled_commands = true,			   -- create commands DapVirtualTextEnable, DapVirtualTextDisable, DapVirtualTextToggle, (DapVirtualTextForceRefresh for refreshing when debug adapter did not notify its termination)
 4 | 	highlight_changed_variables = true,	-- highlight changed values with NvimDapVirtualTextChanged, else always NvimDapVirtualText
 5 | 	highlight_new_as_changed = false,	  -- highlight new variables in the same way as changed variables (if highlight_changed_variables)
 6 | 	show_stop_reason = true,			   -- show stop reason when stopped for exceptions
 7 | 	commented = false,					 -- prefix virtual text with comment string
 8 | 	only_first_definition = true,		  -- only show virtual text at first definition (if there are multiple)
 9 | 	all_references = false,				-- show virtual text on all all references of the variable (not only definitions)
10 | 	filter_references_pattern = '<module', -- filter references (not definitions) pattern when all_references is activated (Lua gmatch pattern, default filters out Python modules)
11 | 	-- experimental features:
12 | 	virt_text_pos = 'eol',				 -- position of virtual text, see `:h nvim_buf_set_extmark()`
13 | 	all_frames = false,					-- show virtual text for all stack frames not only current. Only works for debugpy on my machine.
14 | 	virt_lines = false,					-- show virtual lines instead of virtual text (will flicker!)
15 | 	virt_text_win_col = nil				-- position the virtual text at a fixed window column (starting from the first text column) ,
16 | 										   -- e.g. 80 to position at column 80, see `:h nvim_buf_set_extmark()`
17 | }
18 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/texlab.lua:
--------------------------------------------------------------------------------
 1 | local util = require 'lspconfig.util'
 2 | 
 3 | local root_files = {
 4 | 	'.clangd',
 5 | 	'.clang-tidy',
 6 | 	'.clang-format',
 7 | 	'compile_commands.json',
 8 | 	'compile_flags.txt',
 9 | 	'build.sh', -- buildProject
10 | 	'configure.ac', -- AutoTools
11 | 	'.gitignore',
12 | }
13 | 
14 | return {
15 | 	cmd = {
16 | 		"texlab",
17 | 	},
18 | 	filetypes = { "tex", "plaintex", "bib" },
19 | 	root_dir = vim.fs.root(0, root_files),
20 | 	single_file_support = true,
21 | 	flags = {
22 | 		allow_incremental_sync = false,
23 | 	},
24 | 	settings = {
25 | 		texlab = {
26 | 			rootDirectory = rDir(fname),
27 | 			build = {
28 | 				args = { "-src", "-silent", "-output-directory=build", "-interaction=nonstopmode", "-synctex=1", "%f" },
29 | 				executable = "latexmk",
30 | 				forwardSearchAfter = true,
31 | 				onSave = false
32 | 			},
33 | 			auxDirectory = "build",
34 | 			--[[ forwardSearch = { ]]
35 | 			--[[ 	executable = "pdflatex", ]]
36 | 			--[[ 	args = { ]]
37 | 			--[[ 		" -synctex=1", ]]
38 | 			--[[ 		"-interaction=nonstopmode", ]]
39 | 			--[[ 		"-output-directory=.build", ]]
40 | 			--[[ 		"%f", ]]
41 | 			--[[ 	} ]]
42 | 			--[[ }, ]]
43 | 			forwardSearch = {
44 | 				args = { "--synctex-forward", "%l:1:%f", "%p" },
45 | 				executable = "zathura",
46 | 			},
47 | 			chktex = {
48 | 				onOpenAndSave = true,
49 | 				onEdit = false,
50 | 			},
51 | 			diagnosticsDelay = 300,
52 | 			diagnostic = {
53 | 				allowedPatterns = {},
54 | 				ignoredPatterns = {},
55 | 			},
56 | 			formatterLineLength = 125,
57 | 			bibtexFormatter = "texlab",
58 | 			latexFormatter = "latexindent",
59 | 			latexindent = {
60 | 				modifyLineBreaks = true,
61 | 			}
62 | 		}
63 | 	},
64 | }
65 | 
66 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/clangd.lua:
--------------------------------------------------------------------------------
 1 | ---@class lsp.ClientCapabilities
 2 | local local_cap = vim.lsp.protocol.make_client_capabilities()
 3 | local util = require 'lspconfig.util'
 4 | local_cap.offsetEncoding = { "utf-16" }
 5 | 
 6 | local root_files = {
 7 | 	'.clangd',
 8 | 	'.clang-tidy',
 9 | 	'.clang-format',
10 | 	'.git',
11 | 	'compile_commands.json',
12 | 	'compile_flags.txt',
13 | 	'build.sh', -- buildProject
14 | 	'configure.ac', -- AutoTools
15 | 	'run',
16 | 	'compile',
17 | }
18 | 
19 | local function get_clangd_path()
20 | 	local current_dir = vim.fn.getcwd()
21 | 	if current_dir:find("/esp") then
22 | 		return vim.fn.getenv("HOME") .. "/Documents/STU/LS/TP/esp-clang/bin/clangd"
23 | 	else
24 | 		return "clangd"
25 | 	end
26 | end
27 | 
28 | -- TODO: add clang-tidy to on_atach with clangd
29 | return {
30 | 	cmd = { get_clangd_path(),
31 | 		"--all-scopes-completion",
32 | 		"--background-index",
33 | 		"--clang-tidy",
34 | 		"--compile_args_from=filesystem", -- lsp-> does not come from compie_commands.json
35 | 		"--completion-parse=always",
36 | 		"--completion-style=bundled",
37 | 		"--debug-origin",
38 | 		"--enable-config", -- clangd 11+ supports reading from .clangd configuration file
39 | 		"--fallback-style=Qt",
40 | 		"--header-insertion=iwyu",
41 | 		"--pch-storage=memory", -- could also be disk
42 | 		"-j=4",		-- number of workers
43 | 		-- "--resource-dir="
44 | 		"--log=error",
45 | 		--[[ "--query-driver=/usr/bin/g++", ]]
46 | 	},
47 | 	filetypes = { "c", "cpp", "objc", "objcpp" },
48 | 	root_dir = vim.fs.root(0, root_files),
49 | 	single_file_support = true,
50 | 	init_options = {
51 | 		compilationDatabasePath = vim.fn.getcwd() .. "/build",
52 | 	},
53 | 	capabilities = local_cap,
54 | 	commands = {
55 | 
56 | 	},
57 | }
58 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/lsp-installer.lua:
--------------------------------------------------------------------------------
 1 | local M = {
 2 | 	configs = {},
 3 | }
 4 | 
 5 | local function setup_lua_settings()
 6 | 	local servers = require("mason-lspconfig").get_installed_servers()
 7 | 	for _, name in pairs(servers) do
 8 | 		local opts = {
 9 | 			on_attach = require("usr.lsp.handlers").on_attach,
10 | 			capabilities = require("usr.lsp.handlers").capabilities,
11 | 		}
12 | 
13 | 		local ok, setting = pcall(require, "usr.lsp.settings." .. name)
14 | 		if not ok then
15 | 			local conf_ok, tmp_setting = pcall(require, "lspconfig.configs." .. name)
16 | 			if conf_ok then
17 | 				setting = tmp_setting.default_config
18 | 			else
19 | 				vim.notify("No settings found for " .. name, vim.log.levels.WARN)
20 | 				setting = {}
21 | 			end
22 | 
23 | 		end
24 | 
25 | 		-- vim.print("Setting up LSP for " .. name)
26 | 		opts = vim.tbl_deep_extend("force", opts, setting)
27 | 		vim.lsp.config(name, opts)
28 | 		M.configs[name] = opts
29 | 	end
30 | 
31 | 	vim.lsp.enable(servers)
32 | end
33 | 
34 | function M.setup()
35 | 	setup_lua_settings()
36 | 
37 | 	-- Autocmd to start LSPs manually per buffer
38 | 	vim.api.nvim_create_autocmd("BufEnter", {
39 | 		callback = function(args)
40 | 			local ft = vim.o.filetype
41 | 
42 | 			for name, config in pairs(M.configs) do
43 | 				if not vim.tbl_contains(config.filetypes or {}, ft) then
44 | 					goto continue
45 | 				end
46 | 
47 | 				local bufnr = args.buf
48 | 				-- Avoid double attaching
49 | 				local clients = vim.lsp.get_clients({ bufnr = bufnr })
50 | 				local already_attached, id = vim.iter(clients):any(function(c) return c.name == name, c.id end)
51 | 
52 | 				if not already_attached then
53 | 					--[[ vim.print("Starting LSP for " .. name .. " on buffer " .. bufnr) ]]
54 | 					config.name = name
55 | 					config.buffers = { bufnr }
56 | 					vim.lsp.start(config)
57 | 				end
58 | 
59 | 				::continue::
60 | 			end
61 | 		end
62 | 	})
63 | 
64 | end
65 | 
66 | return M
67 | 


--------------------------------------------------------------------------------
/lua/usr/ts/treesitter.lua:
--------------------------------------------------------------------------------
 1 | local treesitter = require("nvim-treesitter.configs")
 2 | 
 3 | treesitter.setup({
 4 | 	-- One of "all", "maintained" (parsers with maintainers), or a list of languages
 5 | 	-- ensure_installed = "maintained",
 6 | 	ensure_installed = {
 7 | 		"bash", "bibtex", "c", "c_sharp", "cmake", "comment", "cpp", "desktop", "diff",
 8 | 		"dockerfile", "doxygen", "git_config", "git_rebase", "gitattributes", "gitcommit",
 9 | 		"gitignore", "html", "javascript", "json", "latex", "lua", "luadoc", "markdown",
10 | 		"markdown_inline", "python", "rust", "ssh_config", "thrift", "toml", "vim",
11 | 		"vimdoc", "xml", "yaml", "yaml",
12 | 	},
13 | 
14 | 	-- Install languages synchronously (only applied to `ensure_installed`)
15 | 	sync_install = false,
16 | 
17 | 	-- Automatically install missing parsers when entering buffer
18 | 	-- Recommendation: set to false if you don't have `tree-sitter` CLI installed locally
19 | 	auto_install = true,
20 | 
21 | 	-- List of parsers to ignore installing
22 | 	ignore_install = { "" },
23 | 
24 | 	highlight = {
25 | 		-- `false` will disable the whole extension
26 | 		enable = true,
27 | 
28 | 		-- list of language that will be disabled
29 | 		disable = function(lang, buf)
30 | 			local max_filesize = 100 * 1024 -- 100 KB
31 | 			local ok, stats = pcall(vim.loop.fs_stat, vim.api.nvim_buf_get_name(buf))
32 | 			if ok and stats and stats.size > max_filesize then
33 | 				return true
34 | 			end
35 | 
36 | 			return false
37 | 		end,
38 | 
39 | 		-- Setting this to true will run `:h syntax` and tree-sitter at the same time.
40 | 		-- Set this to `true` if you depend on 'syntax' being enabled (like for indentation).
41 | 		-- Using this option may slow down your editor, and you may see some duplicate highlights.
42 | 		-- Instead of true it can also be a list of languages
43 | 		additional_vim_regex_highlighting = false,
44 | 	},
45 | 
46 | 	indent = { enable = true, disable = { "yaml" } },
47 | })
48 | 


--------------------------------------------------------------------------------
/lua/usr/tscope/telescope_config.lua:
--------------------------------------------------------------------------------
 1 | local telescope = require("telescope")
 2 | local actions = require("telescope.actions")
 3 | local action_layout = require "telescope.actions.layout"
 4 | local icons = require("usr.core.icons")
 5 | 
 6 | telescope.setup {
 7 | 	defaults = {
 8 | 		layout_config = {
 9 | 			horizontal = {
10 | 				preview_cutoff = 0,
11 | 			},
12 | 			vertical = {
13 | 				preview_cutoff = 0,
14 | 			},
15 | 		},
16 | 		layout_strategy = 'vertical',
17 | 		-- horizontal (default)
18 | 		-- vertical
19 | 		-- cursor
20 | 		-- bottom_pane
21 | 		-- center
22 | 
23 | 		prompt_prefix = icons.telescope.Prompt,
24 | 		selection_caret = icons.telescope.Selection,
25 | 		path_display = { "truncate" },
26 | 		 -- path_display can be set to an array with a combination of:
27 | 			-- - "hidden"	hide file names
28 | 			-- - "tail"	  only display the file name, and not the path
29 | 			-- - "absolute"  display absolute paths
30 | 			-- - "smart"	 remove as much from the path as possible to only show
31 | 			--			   the difference between the displayed paths.
32 | 			--			   Warning: The nature of the algorithm might have a negative
33 | 			--			   performance impact!
34 | 			-- - "shorten"   only display the first character of each directory in
35 | 			--			   the path
36 | 			-- - "truncate"  truncates the start of the path when the whole path will
37 | 			--			   not fit. To increase the the gap between the path and the edge.
38 | 			--			   set truncate to number `truncate = 3`
39 | 
40 | 		mappings = {
41 | 			i = {
42 | 				["<C-k>"] = actions.cycle_history_prev,
43 | 				["<C-j>"] = actions.cycle_history_next,
44 | 				["<M-p>"] = action_layout.toggle_preview,
45 | 				["<C-o>"] = function(p_bufnr) require("telescope.actions").send_selected_to_qflist(p_bufnr) vim.cmd.cfdo("edit") end,
46 | 			},
47 | 			n = {
48 | 				["<M-p>"] = action_layout.toggle_preview,
49 | 			}
50 | 		}
51 | 	},
52 | }
53 | 
54 | -- telescope.load_extension('ros')
55 | 


--------------------------------------------------------------------------------
/lua/usr/ts/context.lua:
--------------------------------------------------------------------------------
 1 | local context = require('treesitter-context')
 2 | 
 3 | context.setup{
 4 | 	enable = true, -- Enable this plugin (Can be enabled/disabled later via commands)
 5 | 	max_lines = 2, -- How many lines the window should span. Values <= 0 mean no limit.
 6 | 	min_window_height = 10, -- Minimum editor window height to enable context. Values <= 0 mean no limit.
 7 | 	line_numbers = false,
 8 | 	multiline_threshold = 20, -- Maximum number of lines to collapse for a single context line.
 9 | 	trim_scope = 'outer', -- Which context lines to discard if `max_lines` is exceeded. Choices: 'inner', 'outer'
10 | 	patterns = { -- Match patterns for TS nodes. These get wrapped to match at word boundaries.
11 | 		-- For all filetypes
12 | 		-- Note that setting an entry here replaces all other patterns for this entry.
13 | 		-- By setting the 'default' entry below, you can control which nodes you want to
14 | 		-- appear in the context window.
15 | 		default = {
16 | 			'class',
17 | 			'function',
18 | 			'method',
19 | 			-- 'for', -- These won't appear in the context
20 | 			-- 'while',
21 | 			-- 'if',
22 | 			-- 'switch',
23 | 			-- 'case',
24 | 		},
25 | 		-- Example for a specific filetype.
26 | 		-- If a pattern is missing, *open a PR* so everyone can benefit.
27 | 		--   rust = {
28 | 		--	   'impl_item',
29 | 		--   },
30 | 	},
31 | 	exact_patterns = {
32 | 		-- Example for a specific filetype with Lua patterns
33 | 		-- Treat patterns.rust as a Lua pattern (i.e "^impl_item$" will
34 | 		-- exactly match "impl_item" only)
35 | 		-- rust = true,
36 | 	},
37 | 
38 | 	-- [!] The options below are exposed but shouldn't require your attention,
39 | 	--	 you can safely ignore them.
40 | 
41 | 	zindex = 20, -- The Z-index of the context window
42 | 	mode = 'cursor',  -- Line used to calculate context. Choices: 'cursor', 'topline'
43 | 	separator = '-', -- Separator between context and content. Should be a single character string, like '-'.
44 | }
45 | 
46 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/settings/dapcpp.lua:
--------------------------------------------------------------------------------
 1 | local dap = require('dap')
 2 | 
 3 | dap.adapters.cppdbg = {
 4 | 	id = 'cppdbg',
 5 | 	type = 'executable',
 6 | 	-- Must be from vscode cannot be cloned DUNNO why
 7 | 	command = vim.fn.stdpath("data") .. "/mason/bin/OpenDebugAD7",
 8 | }
 9 | 
10 | dap.configurations.cpp = {
11 | 	{
12 | 		name = "Launch file",
13 | 		type = "cppdbg",
14 | 		request = "launch",
15 | 		program = function()
16 | 			local cwd = vim.fn['getcwd']()
17 | 			local bin = vim.api.nvim_call_function('fnamemodify', {cwd, ":t"})
18 | 
19 | 			vim.notify(vim.fn.getcwd() .. '/build/' .. bin)
20 | 			return vim.fn.getcwd() .. '/build/' .. bin
21 | 
22 | 			--[[ return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/build/', 'file') ]]
23 | 		end,
24 | 		cwd = '${workspaceFolder}/build',
25 | 		stopOnEntry = true,
26 | 		setupCommands = {
27 | 			{
28 | 				text = '-enable-pretty-printing',
29 | 				description =  'enable pretty printing',
30 | 				ignoreFailures = false,
31 | 			},
32 | 		},
33 | 	},
34 | }
35 | 
36 | -- If you want to use this for rust and c, add something like this:
37 | 
38 | dap.configurations.c = dap.configurations.cpp
39 | dap.configurations.rust = {
40 | 	{
41 | 		name = "Launch file",
42 | 		type = "cppdbg",
43 | 		request = "launch",
44 | 		program = function()
45 | 			local cwd = vim.fn['getcwd']()
46 | 			local bin = vim.api.nvim_call_function('fnamemodify', {cwd, ":t"})
47 | 
48 | 			vim.notify(vim.fn.getcwd() .. '/target/debug/' .. bin)
49 | 			return vim.fn.getcwd() .. '/target/debug/' .. bin
50 | 
51 | 			--[[ return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/build/', 'file') ]]
52 | 		end,
53 | 		cwd = '${workspaceFolder}/target/debug',
54 | 		stopOnEntry = true,
55 | 		setupCommands = {
56 | 			{
57 | 				text = '-enable-pretty-printing',
58 | 				description =  'enable pretty printing',
59 | 				ignoreFailures = false,
60 | 			},
61 | 		},
62 | 	},
63 | }
64 | -- dap.configurations.rust = dap.configurations.cpp
65 | 


--------------------------------------------------------------------------------
/lua/usr/toggleterm.lua:
--------------------------------------------------------------------------------
 1 | local toggleterm = require("toggleterm")
 2 | 
 3 | toggleterm.setup({
 4 | 	size = 20,
 5 | 	open_mapping = [[<c-\>]],
 6 | 	hide_numbers = true,
 7 | 	shade_filetypes = {},
 8 | 	shade_terminals = true,
 9 | 	shading_factor = 2,
10 | 	start_in_insert = true,
11 | 	insert_mappings = true,
12 | 	persist_size = true,
13 | 	direction = "float",
14 | 	close_on_exit = true,
15 | 	shell = vim.o.shell,
16 | 	float_opts = {
17 | 		border = "curved",
18 | 		winblend = 0,
19 | 		highlights = {
20 | 			border = "Normal",
21 | 			background = "Normal",
22 | 		},
23 | 	},
24 | })
25 | 
26 | function _G.set_terminal_keymaps()
27 | 	local opts = {noremap = true}
28 | 	vim.api.nvim_buf_set_keymap(0, 't', '<esc>', [[<C-\><C-n>]], opts)
29 | 	vim.api.nvim_buf_set_keymap(0, 't', 'jk', [[<C-\><C-n>]], opts)
30 | 	vim.api.nvim_buf_set_keymap(0, 't', '<C-h>', [[<C-\><C-n><C-W>h]], opts)
31 | 	vim.api.nvim_buf_set_keymap(0, 't', '<C-j>', [[<C-\><C-n><C-W>j]], opts)
32 | 	vim.api.nvim_buf_set_keymap(0, 't', '<C-k>', [[<C-\><C-n><C-W>k]], opts)
33 | 	vim.api.nvim_buf_set_keymap(0, 't', '<C-l>', [[<C-\><C-n><C-W>l]], opts)
34 | end
35 | 
36 | vim.cmd('autocmd! TermOpen term://* lua set_terminal_keymaps()')
37 | 
38 | local Terminal = require("toggleterm.terminal").Terminal
39 | local lazygit = Terminal:new({ cmd = "lazygit", hidden = true })
40 | local node = Terminal:new({ cmd = "node", hidden = true })
41 | local ncdu = Terminal:new({ cmd = "ncdu", hidden = true })
42 | local htop = Terminal:new({ cmd = "htop", hidden = true })
43 | local python = Terminal:new({ cmd = "python", hidden = true })
44 | local r = Terminal:new({ cmd = "R", hidden = true })
45 | 
46 | local function _LAZYGIT_TOGGLE()
47 | 	lazygit:toggle()
48 | end
49 | 
50 | local function _NODE_TOGGLE()
51 | 	node:toggle()
52 | end
53 | 
54 | local function _NCDU_TOGGLE()
55 | 	ncdu:toggle()
56 | end
57 | 
58 | local function _HTOP_TOGGLE()
59 | 	htop:toggle()
60 | end
61 | 
62 | local function _PYTHON_TOGGLE()
63 | 	python:toggle()
64 | end
65 | 
66 | local function _R_TOGGLE()
67 | 	r:toggle()
68 | end
69 | 
70 | return {
71 | 	lazygit = _LAZYGIT_TOGGLE,
72 | 	node = _NODE_TOGGLE,
73 | 	ncdu = _NCDU_TOGGLE,
74 | 	htop = _HTOP_TOGGLE,
75 | 	python = _PYTHON_TOGGLE,
76 | 	r = _R_TOGGLE,
77 | }
78 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/settings/dappy.lua:
--------------------------------------------------------------------------------
 1 | local dap = require('dap')
 2 | 
 3 | local function getPipenvPath()
 4 | 	local env = os.getenv('VIRTUAL_ENV')
 5 | 	if env == nil or #env == 0 then
 6 | 		return '/usr/bin/python'
 7 | 	end
 8 | 	return env .. '/bin/python'
 9 | end
10 | 
11 | local enrich_config = function(config, on_config)
12 | 	if not config.pythonPath and not config.python then
13 | 		config.pythonPath = getPipenvPath()
14 | 	end
15 | 	if config.subProcess == nil then
16 | 		config.subProcess = false
17 | 	end
18 | 	on_config(config)
19 | end
20 | 
21 | 
22 | function dap.adapters.python(cb, config)
23 | 	if config.request == 'attach' then
24 | 		---@diagnostic disable-next-line: undefined-field
25 | 		local port = (config.connect or config).port
26 | 		---@diagnostic disable-next-line: undefined-field
27 | 		local host = (config.connect or config).host or '127.0.0.1'
28 | 		cb({
29 | 			type = 'server',
30 | 			port = assert(port, '`connect.port` is required for a python `attach` configuration'),
31 | 			host = host,
32 | 			enrich_config = enrich_config,
33 | 			options = {
34 | 				source_filetype = 'python',
35 | 			},
36 | 		})
37 | 	else
38 | 		cb({
39 | 			type = 'executable',
40 | 			command = getPipenvPath(),
41 | 			args = { '-m', 'debugpy.adapter' },
42 | 			enrich_config = enrich_config,
43 | 			options = {
44 | 				source_filetype = 'python',
45 | 			},
46 | 		})
47 | 	end
48 | end
49 | 
50 | dap.configurations.python = {
51 | 	{
52 | 		-- The first three options are required by nvim-dap
53 | 		type = 'python'; -- the type here established the link to the adapter definition: `dap.adapters.python`
54 | 		request = 'launch';
55 | 		name = "Launch file";
56 | 
57 | 		-- Options below are for debugpy, see https://github.com/microsoft/debugpy/wiki/Debug-configuration-settings for supported options
58 | 
59 | 		program = "${file}"; -- This configuration will launch the current file if used.
60 | 		pythonPath = function()
61 | 			-- debugpy supports launching an application with a different interpreter then the one used to launch debugpy itself.
62 | 			-- The code below looks for a `venv` or `.venv` folder in the current directly and uses the python within.
63 | 			-- You could adapt this - to for example use the `VIRTUAL_ENV` environment variable.
64 | 			return getPipenvPath()
65 | 		end;
66 | 	},
67 | }
68 | 


--------------------------------------------------------------------------------
/lua/usr/core/autocomands.lua:
--------------------------------------------------------------------------------
 1 | local opts = { clear = true }
 2 | local util = require("usr.core.util")
 3 | ---------------------------------
 4 | --           GROUPS            --
 5 | ---------------------------------
 6 | 
 7 | local filetype_id = vim.api.nvim_create_augroup("FileTypeSetting", opts)
 8 | 
 9 | local at_save = vim.api.nvim_create_augroup("Save", opts)
10 | 
11 | local at_exit = vim.api.nvim_create_augroup("Exit", opts)
12 | 
13 | ---------------------------------
14 | --        AUTOCOMMANDS         --
15 | ---------------------------------
16 | 
17 | -- Matlab file was always categorized as octave file.
18 | -- This autocommand will force neovim to recognize it as a matlab file.
19 | vim.api.nvim_create_autocmd({ "BufRead", "BufWritePost", "BufNewFile" }, {
20 | 	pattern = { "*.m" },
21 | 	callback = function()
22 | 		vim.bo.filetype = "matlab"
23 | 	end,
24 | 	group = filetype_id,
25 | })
26 | 
27 | -- Detect Office scripts as a typescript filetype. Which it actually is but trimmed down version.
28 | vim.api.nvim_create_autocmd({ "BufRead", "BufWritePost", "BufNewFile" }, {
29 | 	pattern = { "*.osts" },
30 | 	callback = function()
31 | 		vim.bo.filetype = "typescript"
32 | 	end,
33 | 	group = filetype_id,
34 | })
35 | 
36 | -- Detect Office scripts as a typescript filetype. Which it actually is but trimmed down version.
37 | vim.api.nvim_create_autocmd({ "BufRead", "BufEnter", "BufWritePost", "BufNewFile" }, {
38 | 	pattern = { "*.py" },
39 | 	callback = function()
40 | 		vim.opt.expandtab = true
41 | 		vim.opt.shiftwidth = 4
42 | 	end,
43 | 	group = filetype_id,
44 | })
45 | 
46 | vim.api.nvim_create_autocmd({ "BufLeave" }, {
47 | 	pattern = { "*.py" },
48 | 	callback = function()
49 | 		vim.opt.expandtab = false
50 | 		vim.opt.shiftwidth = 4
51 | 	end,
52 | 	group = filetype_id,
53 | })
54 | 
55 | vim.api.nvim_create_autocmd({ "BufRead", "BufEnter", "BufWritePost", "BufNewFile" }, {
56 | 	pattern = { "*.sdf" },
57 | 	callback = function()
58 | 		vim.opt.filetype = "xml"
59 | 	end,
60 | 	group = filetype_id,
61 | })
62 | 
63 | -- Trim trailing whitespace on save
64 | vim.api.nvim_create_autocmd({ "BufWrite" }, {
65 | 	pattern = { "*" },
66 | 	callback = util.remove_trailing_whitespaces,
67 | 	group = at_save,
68 | })
69 | 
70 | -- Save opened files
71 | vim.api.nvim_create_autocmd({ "ExitPre" }, {
72 | 	pattern = { "*" },
73 | 	callback = require('revolver').SaveOpenedFiles,
74 | 	group = at_exit,
75 | })
76 | 
77 | 


--------------------------------------------------------------------------------
/ftplugin/markdown.lua:
--------------------------------------------------------------------------------
 1 | function os.name()
 2 | 	local BinaryFormat = package.cpath:match("%p[\\|/]?%p(%a+)")
 3 | 	if BinaryFormat == "dll" then
 4 | 		return "Windows"
 5 | 	elseif BinaryFormat == "so" then
 6 | 		return "Linux"
 7 | 	end
 8 | 
 9 | 	return "MacOS"
10 | end
11 | 
12 | local keymap = vim.keymap.set
13 | 
14 | local function mdToPdf()
15 | 	vim.print("Converting " .. vim.fn.bufname() .. " to pdf")
16 | 	local data = io.popen("pandoc -f markdown -t pdf -o " .. vim.fn.expand("%:r") .. ".pdf " .. vim.fn.bufname())
17 | 	if data == nil then
18 | 		vim.notify("Error converting " .. vim.fn.bufname() .. " to pdf", vim.log.levels.ERROR, {
19 | 			title = "Markdown to PDF",
20 | 		})
21 | 		return
22 | 	end
23 | 
24 | 	local output = data:read("*all")
25 | 	data:close()
26 | 
27 | 	vim.notify(output, vim.log.levels.WARN, {
28 | 		title = "Markdown to PDF",
29 | 	})
30 | end
31 | 
32 | if os.name() == "Linux" then
33 | 	local http = require("socket.http")
34 | 	local html = require("htmlEntities")
35 | 
36 | 	local function scrape_and_find(url)
37 | 		-- Make the HTTP request.
38 | 		local body, code = http.request(url)
39 | 
40 | 		if code ~= 200 then
41 | 			print("Failed to fetch URL: " .. tostring(code))
42 | 			return nil
43 | 		end
44 | 
45 | 		-- Define a pattern to match UTF-8 characters in braces.
46 | 		local utf8_pattern = "</span>([^\\u0000-\\u007F]+)<span class=\"diskret\">"
47 | 
48 | 		-- This is not efficient but otherwise we cannot detect the pronauntiation (udtale).
49 | 		body = html.decode(body)
50 | 
51 | 		-- Search for the pattern.
52 | 		return body:match(utf8_pattern)
53 | 	end
54 | 
55 | 	local function addDictionaryLine()
56 | 		local line = vim.fn.input("Enter words in format: 'danish,english': ")
57 | 		local input = {danish = "", english = ""}
58 | 		-- This is the way how to capture utf-8 characters. This is needed for æ,ø,å
59 | 		for d, e in string.gmatch(line, "([^\r\n]+),([^\r\n]+)") do
60 | 			input.danish = d
61 | 			input.english = e
62 | 		end
63 | 
64 | 		local url = "https://ordnet.dk/ddo_en/dict?query=" .. input.danish
65 | 		local pronauntiation = scrape_and_find(url) or ""
66 | 
67 | 		local data = "| [" .. input.danish .. "](" .. url .. ") | [" .. pronauntiation .. "] | " .. input.english .. " |  |"
68 | 		local lineNo = vim.fn.line('.')
69 | 		vim.fn.appendbufline(vim.fn.bufnr(), lineNo, data)
70 | 	end
71 | 
72 | 	keymap("n", "<C-z>", addDictionaryLine)
73 | end
74 | 
75 | keymap("n", "<leader>mp", mdToPdf)
76 | 
77 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/vimlatex.lua:
--------------------------------------------------------------------------------
 1 | vim.cmd[[
 2 | 		" Follow for setup info
 3 | 	" https://www.ejmastnak.com/tutorials/vim-latex/pdf-reader/#ensure-zathura-synctex
 4 | 	"
 5 | 	" This is necessary for VimTeX to load properly. The "indent" is optional.
 6 | 	" Note that most plugin managers will do this automatically.
 7 | 	filetype plugin indent on
 8 | 
 9 | 	" This will only work if `vim --version` includes `+clientserver`!
10 | 	if empty(v:servername) && exists('*remote_startserver')
11 | 		call remote_startserver('VIM')
12 | 	endif
13 | 
14 | 	" This enables Vim's and neovim's syntax-related features. Without this, some
15 | 	" VimTeX features will not work (see ":help vimtex-requirements" for more
16 | 	" info).
17 | 	" syntax enable
18 | 
19 | 	" Viewer options: One may configure the viewer either by specifying a built-in
20 | 	" viewer method:
21 | 	let g:vimtex_view_forward_search_on_start = 1
22 | 	let g:vimtex_view_enabled = 1
23 | 	let g:vimtex_view_method = "zathura"
24 | 
25 | 	" Or with a generic interface:
26 | 	let g:vimtex_view_general_viewer = 'okular'
27 | 	let g:vimtex_view_general_options = '--unique file:@pdf\#src:@line@tex'
28 | 
29 | 	" VimTeX uses latexmk as the default compiler backend. If you use it, which is
30 | 	" strongly recommended, you probably don't need to configure anything. If you
31 | 	" want another compiler backend, you can change it as follows. The list of
32 | 	" supported backends and further explanation is provided in the documentation,
33 | 	" see ":help vimtex-compiler".
34 | 	let g:vimtex_compiler_method = 'latexmk'
35 | 	let g:vimtex_compiler_latexmk = {
36 | 		\ 'aux_dir' : '',
37 | 		\ 'out_dir' : '',
38 | 		\ 'callback' : 1,
39 | 		\ 'continuous' : 1,
40 | 		\ 'executable' : 'latexmk',
41 | 		\ 'hooks' : [],
42 | 		\ 'options' : [
43 | 		\   '-verbose',
44 | 		\   '-file-line-error',
45 | 		\   '-synctex=1',
46 | 		\   '-interaction=nonstopmode',
47 | 		\   '-shell-escape',
48 | 		\ ],
49 | 		\}
50 | 
51 | 	function! OpenZathura()
52 | 		let position = line('.') . ":" . col('.') . ":" . expand('%:p') . " "
53 | 		call jobstart("zathura -x 'nvr --remote +%{line} %{input}' --synctex-forward " . position . " " . substitute(expand('%:p'),"tex$","pdf", ""))
54 | 	endfunction
55 | 
56 | 	map <leader><lv> :call OpenZathura()<cr>
57 | 	augroup latex
58 | 		autocmd! BufWritePost,BufReadPre *.tex silent !compiler %
59 | 	augroup end
60 | 
61 | 	" Most VimTeX mappings rely on localleader and this can be changed with the
62 | 	" following line. The default is usually fine and is the symbol "\".
63 | 	" let maplocalleader = " "
64 | ]]
65 | 


--------------------------------------------------------------------------------
/spell/sk.utf-8.add:
--------------------------------------------------------------------------------
  1 | Robotický
  2 | ROS1
  3 | a
  4 | ROS2
  5 | V
  6 | o
  7 | v
  8 | s
  9 | k
 10 | ROSe
 11 | Vizualizácia
 12 | LAN
 13 | TCP
 14 | IP
 15 | zadefinovať
 16 | API
 17 | štrukturovanie
 18 | C
 19 | Python
 20 | monoliticky
 21 | Roscore
 22 | roscore
 23 | WLAN
 24 | z
 25 | IPC
 26 | parametrového
 27 | distribuovanosť
 28 | ROSu
 29 | Noetic
 30 | rosbridge
 31 | zoskupované
 32 | Obr
 33 | UDP
 34 | DDS
 35 | Matlabe
 36 | debugovania
 37 | inicializovanie
 38 | MAXON
 39 | enkóderov
 40 | Enkódery
 41 | ADVANTECH
 42 | MIO
 43 | Arduino
 44 | Uno
 45 | Hardware
 46 | Logovací
 47 | Logovanie
 48 | slúžiaci
 49 | ID
 50 | pýtajúci
 51 | procesová
 52 | prijímajúci
 53 | posielajúci
 54 | predediť
 55 | parametrový
 56 | nodelet
 57 | dependencií
 58 | kompilovaný
 59 | catkin
 60 | dependencie
 61 | cmake
 62 | colcon
 63 | modularite
 64 | Arduinom
 65 | všesmerovými
 66 | Ubuntu
 67 | rpm
 68 | Zašumený
 69 | skompilovali
 70 | JSON
 71 | enkódery
 72 | dolnopriepustný
 73 | prestavením
 74 | Udalostné
 75 | Lobpreis
 76 | udalostné
 77 | magnitúda
 78 | odometriu
 79 | zašumeného
 80 | Odometria
 81 | odometria
 82 | enkódermi
 83 | zašmený
 84 | enkodéroch
 85 | prenositeľný
 86 | robotického
 87 | vizualizácia
 88 | vizualizácii
 89 | repozitáre
 90 | preregulovania
 91 | preregulovaním
 92 | cvičiacim
 93 | odsimulovania
 94 | percentonová
 95 | perceptronovej
 96 | bábätiek
 97 | #kupin
 98 | enkódera
 99 | enkóderom
100 | Karteziánskej
101 | odometrii
102 | zašumeniu
103 | odosielajúceho
104 | prímajúceho
105 | ohrevnej
106 | ohrevnou
107 | Gaussovým
108 | maticového
109 | Odmocninová
110 | odmocninovej
111 | aproximovali
112 | odmocninová
113 | servosystému
114 | odchýliek
115 | enkóderu
116 | enkóder
117 | predpočítavaní
118 | Neprekrytie
119 | odometrie
120 | rozkmitaných
121 | predpočítavaním
122 | predpočítanie
123 | predpočítavania
124 | Robotickým
125 | dronoch
126 | Debugovanie
127 | robotický
128 | robotickým
129 | dolno
130 | prešmykuje
131 | zašumený
132 | Protišmykové
133 | protišmyková
134 | protišmykové
135 | prešmykovaniu
136 | protišmykovú
137 | robotickom
138 | robotickému
139 | HMI
140 | lidaru
141 | prekompilovať
142 | Ledka
143 | lidarom
144 | RMR
145 | riaditeľnosti
146 | kinematickú
147 | gyroskopu
148 | odometriou
149 | gyroodometria
150 | gyroodometria
151 | Prešmyky
152 | Štrukturované
153 | viaccestného
154 | jednoky
155 | monický
156 | zosumarizovať
157 | Nyquistov
158 | polrovine
159 | Hurwitzov
160 | SPR
161 | Wm
162 | Nyquistova
163 | L
164 | Simulink
165 | opisujúcou
166 | Nyquistovho
167 | Nyquistovým
168 | repozitára
169 | ESP
170 | IDF
171 | UART
172 | ESP32
173 | inkrementálny
174 | PWM
175 | prepäťovú
176 | zresetuje
177 | PID
178 | 


--------------------------------------------------------------------------------
/formats/google/.clang_format:
--------------------------------------------------------------------------------
 1 | # Google C/C++ Code Style settings
 2 | # https://clang.llvm.org/docs/ClangFormatStyleOptions.html
 3 | # Author: Kehan Xue, kehan.xue (at) gmail.com
 4 | 
 5 | Language: Cpp
 6 | BasedOnStyle: Google
 7 | AccessModifierOffset: -1
 8 | AlignAfterOpenBracket: Align
 9 | AlignConsecutiveAssignments: None
10 | AlignOperands: Align
11 | AllowAllArgumentsOnNextLine: true
12 | AllowAllConstructorInitializersOnNextLine: true
13 | AllowAllParametersOfDeclarationOnNextLine: false
14 | AllowShortBlocksOnASingleLine: Empty
15 | AllowShortCaseLabelsOnASingleLine: false
16 | AllowShortFunctionsOnASingleLine: Inline
17 | AllowShortIfStatementsOnASingleLine: Never  # To avoid conflict, set this "Never" and each "if statement" should include brace when coding
18 | AllowShortLambdasOnASingleLine: Inline
19 | AllowShortLoopsOnASingleLine: false
20 | AlwaysBreakAfterReturnType: None
21 | AlwaysBreakTemplateDeclarations: Yes
22 | BinPackArguments: true
23 | BreakBeforeBraces: Custom
24 | BraceWrapping:
25 |   AfterCaseLabel: false
26 |   AfterClass: false
27 |   AfterStruct: false
28 |   AfterControlStatement: Never
29 |   AfterEnum: false
30 |   AfterFunction: false
31 |   AfterNamespace: false
32 |   AfterUnion: false
33 |   AfterExternBlock: false
34 |   BeforeCatch: false
35 |   BeforeElse: false
36 |   BeforeLambdaBody: false
37 |   IndentBraces: false
38 |   SplitEmptyFunction: false
39 |   SplitEmptyRecord: false
40 |   SplitEmptyNamespace: false
41 | BreakBeforeBinaryOperators: None
42 | BreakBeforeTernaryOperators: true
43 | BreakConstructorInitializers: BeforeColon
44 | BreakInheritanceList: BeforeColon
45 | ColumnLimit: 80
46 | CompactNamespaces: false
47 | ContinuationIndentWidth: 4
48 | Cpp11BracedListStyle: true
49 | DerivePointerAlignment: false  # Make sure the * or & align on the left
50 | EmptyLineBeforeAccessModifier: LogicalBlock
51 | FixNamespaceComments: true
52 | IncludeBlocks: Preserve
53 | IndentCaseLabels: true
54 | IndentPPDirectives: None
55 | IndentWidth: 2
56 | KeepEmptyLinesAtTheStartOfBlocks: true
57 | MaxEmptyLinesToKeep: 1
58 | NamespaceIndentation: None
59 | ObjCSpaceAfterProperty: false
60 | ObjCSpaceBeforeProtocolList: true
61 | PointerAlignment: Left
62 | ReflowComments: false
63 | # SeparateDefinitionBlocks: Always   # Only support for clang-format 14
64 | SpaceAfterCStyleCast: false
65 | SpaceAfterLogicalNot: false
66 | SpaceAfterTemplateKeyword: true
67 | SpaceBeforeAssignmentOperators: true
68 | SpaceBeforeCpp11BracedList: false
69 | SpaceBeforeCtorInitializerColon: true
70 | SpaceBeforeInheritanceColon: true
71 | SpaceBeforeParens: ControlStatements
72 | SpaceBeforeRangeBasedForLoopColon: true
73 | SpaceBeforeSquareBrackets: false
74 | SpaceInEmptyParentheses: false
75 | SpacesBeforeTrailingComments: 2
76 | SpacesInAngles: false
77 | SpacesInCStyleCastParentheses: false
78 | SpacesInContainerLiterals: false
79 | SpacesInParentheses: false
80 | SpacesInSquareBrackets: false
81 | Standard: c++11
82 | TabWidth: 4
83 | UseTab: Never
84 | 


--------------------------------------------------------------------------------
/lua/usr/bufferline.lua:
--------------------------------------------------------------------------------
 1 | local bufferline = require("bufferline")
 2 | local icons = require("usr.core.icons")
 3 | 
 4 | bufferline.setup {
 5 | 	options = {
 6 | 		mode = "buffers", -- set to "tabs" to only show tabpages instead
 7 | 		numbers = "none", -- | "ordinal" | "buffer_id" | "both" | function({ ordinal, id, lower, raise }): string,
 8 | 		close_command = "bdelete! %d",       -- can be a string | function, see "Mouse actions"
 9 | 		right_mouse_command = "bdelete! %d", -- can be a string | function, see "Mouse actions"
10 | 		left_mouse_command = "buffer %d",    -- can be a string | function, see "Mouse actions"
11 | 		middle_mouse_command = nil,          -- can be a string | function, see "Mouse actions"
12 | 		style_preset = bufferline.style_preset.minimal, -- or bufferline.style_preset.minimal,
13 | 		themable = true, -- | false, -- allows highlight groups to be overriden i.e. sets highlights as default
14 | 		indicator = {
15 | 			icon = icons.git.BoldBar, -- this should be omitted if indicator style is not 'icon'
16 | 			style = 'icon', -- | 'underline' | 'none',
17 | 		},
18 | 		buffer_close_icon = icons.ui.Close,
19 | 		modified_icon = icons.git.Mod,
20 | 		close_icon = icons.ui.Close,
21 | 		left_trunc_marker = icons.ui.LeftMarker,
22 | 		right_trunc_marker = icons.ui.RightMarker,
23 | 		--- name_formatter can be used to change the buffer's label in the bufferline.
24 | 		--- Please note some names can/will break the
25 | 		--- bufferline so use this at your discretion knowing that it has
26 | 		--- some limitations that will *NOT* be fixed.
27 | 		-- name_formatter = function(buf)  -- buf contains:
28 | 			  -- name                | str        | the basename of the active file
29 | 			  -- path                | str        | the full path of the active file
30 | 			  -- bufnr (buffer only) | int        | the number of the active buffer
31 | 			  -- buffers (tabs only) | table(int) | the numbers of the buffers in the tab
32 | 			  -- tabnr (tabs only)   | int        | the "handle" of the tab, can be converted to its ordinal number using: `vim.api.nvim_tabpage_get_number(buf.tabnr)`
33 | 		--[[ end, ]]
34 | 		max_name_length = 30,
35 | 		max_prefix_length = 30, -- prefix used when a buffer is de-duplicated
36 | 		truncate_names = true, -- whether or not tab names should be truncated
37 | 		tab_size = 21,
38 | 		diagnostics = "nvim_lsp", -- "nvim_lsp" | "coc" | false ,
39 | 		diagnostics_update_in_insert = false,
40 | 		-- The diagnostics indicator can be set to nil to keep the buffer name highlight but delete the highlighting
41 | 		diagnostics_indicator = function(count, level) --, diagnostics_dict, context)
42 | 			local icon = level:match("error") and icons.diagnostics.Error or icons.diagnostics.Warning
43 | 			return " " .. icon .. count
44 | 		end,
45 | 		offsets = {
46 | 			{
47 | 				filetype = "NvimTree",
48 | 				text = "",
49 | 				text_align = "left",
50 | 				separator = true
51 | 			}
52 | 		},
53 | 		color_icons = true, -- | false, -- whether or not to add the filetype icon highlights
54 | 	}
55 | }
56 | 
57 | 


--------------------------------------------------------------------------------
/lua/usr/DAP/ui.lua:
--------------------------------------------------------------------------------
 1 | local dapui = require("dapui")
 2 | local icons = require("usr.core.icons")
 3 | 
 4 | dapui.setup({
 5 | 	icons = { expanded = "▾", collapsed = "▸", current_frame = icons.ui.Home },
 6 | 	mappings = {
 7 | 		-- Use a table to apply multiple mappings
 8 | 		expand = { "<CR>", "<2-LeftMouse>" },
 9 | 		open = "o",
10 | 		remove = "d",
11 | 		edit = "e",
12 | 		repl = "r",
13 | 		toggle = "t",
14 | 	},
15 | 	-- Expand lines larger than the window
16 | 	-- Requires >= 0.7
17 | 	expand_lines = vim.fn.has("nvim-0.7") == 1,
18 | 	-- Layouts define sections of the screen to place windows.
19 | 	-- The position can be "left", "right", "top" or "bottom".
20 | 	-- The size specifies the height/width depending on position. It can be an Int
21 | 	-- or a Float. Integer specifies height/width directly (i.e. 20 lines/columns) while
22 | 	-- Float value specifies percentage (i.e. 0.3 - 30% of available lines/columns)
23 | 	-- Elements are the elements shown in the layout (in order).
24 | 	-- Layouts are opened in order so that earlier layouts take priority in window sizing.
25 | 	layouts = {
26 | 		{
27 | 			elements = {
28 | 			-- Elements can be strings or table with id and size keys.
29 | 				{ id = "scopes", size = 0.5 },
30 | 				"watches",
31 | 				{ id = "breakpoints", size = 0.05},
32 | 				{ id = "stacks", size = 0.075 },
33 | 			},
34 | 			size = 40, -- 40 columns
35 | 			position = "left",
36 | 		},
37 | 		{
38 | 			elements = {
39 | 				"repl",
40 | 				"console",
41 | 			},
42 | 			size = 0.25, -- 25% of total lines
43 | 			position = "bottom",
44 | 		},
45 | 	},
46 | 	controls = {
47 | 		-- Requires Neovim nightly (or 0.8 when released)
48 | 		enabled = true,
49 | 		-- Display controls in this element
50 | 		element = "repl",
51 | 		icons = {
52 | 			pause = icons.dap.pause,
53 | 			play =icons.dap.play,
54 | 			step_into = icons.dap.stepInto,
55 | 			step_over = icons.dap.stepOver,
56 | 			step_out = icons.dap.stepOut,
57 | 			step_back = icons.dap.stepBack,
58 | 			run_last = icons.dap.runLast,
59 | 			terminate = icons.dap.terminate,
60 | 		},
61 | 	},
62 | 	floating = {
63 | 		max_height = nil, -- These can be integers or a float between 0 and 1.
64 | 		max_width = nil, -- Floats will be treated as percentage of your screen.
65 | 		border = "single", -- Border style. Can be "single", "double" or "rounded"
66 | 		mappings = {
67 | 			close = { "q", "<Esc>" },
68 | 		},
69 | 	},
70 | 	windows = { indent = 1 },
71 | 	render = {
72 | 		max_type_length = nil, -- Can be integer or nil.
73 | 		max_value_lines = 100, -- Can be integer or nil.
74 | 	}
75 | })
76 | 
77 | local dap = require("dap")
78 | 
79 | local keymap = vim.keymap.set
80 | 
81 | -- INSPECT the variable
82 | keymap('n', '<leader>k', function() require("dapui").eval() end)
83 | keymap('v', '<leader>k', function() require("dapui").eval() end)
84 | 
85 | dap.listeners.after.event_initialized["dapui_config"] = function()
86 | 	dapui.open()
87 | end
88 | dap.listeners.before.event_terminated["dapui_config"] = function()
89 | 	dapui.close()
90 | end
91 | dap.listeners.before.event_exited["dapui_config"] = function()
92 | 	dapui.close()
93 | end
94 | 
95 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/rust_analyzer.lua:
--------------------------------------------------------------------------------
  1 | local util = require 'lspconfig.util'
  2 | local async = require 'lspconfig.async'
  3 | 
  4 | ---@class lsp.ClientCapabilities
  5 | local local_cap = vim.lsp.protocol.make_client_capabilities()
  6 | local_cap.offsetEncoding = { "utf-16" }
  7 | 
  8 | local root_files = {
  9 | 	'Cargo.toml',
 10 | 	'.git',
 11 | }
 12 | 
 13 | 
 14 | local function reload_workspace(bufnr)
 15 | 	bufnr = util.validate_bufnr(bufnr)
 16 | 	local clients = vim.lsp.get_clients { bufnr = bufnr, name = 'rust_analyzer' }
 17 | 	for _, client in ipairs(clients) do
 18 | 		vim.notify 'Reloading Cargo Workspace'
 19 | 		client.request('rust-analyzer/reloadWorkspace', nil, function(err)
 20 | 			if err then
 21 | 				error(tostring(err))
 22 | 			end
 23 | 			vim.notify 'Cargo workspace reloaded'
 24 | 		end, 0)
 25 | 	end
 26 | end
 27 | 
 28 | local function is_library(fname)
 29 | 	local user_home = vim.fs.normalize(vim.env.HOME)
 30 | 	local cargo_home = os.getenv 'CARGO_HOME' or user_home .. '/.cargo'
 31 | 	local registry = cargo_home .. '/registry/src'
 32 | 	local git_registry = cargo_home .. '/git/checkouts'
 33 | 
 34 | 	local rustup_home = os.getenv 'RUSTUP_HOME' or user_home .. '/.rustup'
 35 | 	local toolchains = rustup_home .. '/toolchains'
 36 | 
 37 | 	for _, item in ipairs { toolchains, registry, git_registry } do
 38 | 		if util.path.is_descendant(item, fname) then
 39 | 			local clients = vim.lsp.get_clients { name = 'rust_analyzer' }
 40 | 			return #clients > 0 and clients[#clients].config.root_dir or nil
 41 | 		end
 42 | 	end
 43 | end
 44 | 
 45 | return {
 46 | 	default_config = {
 47 | 		cmd = { 'rust-analyzer' },
 48 | 		filetypes = { 'rust' },
 49 | 		single_file_support = true,
 50 | 		root_dir = function(fname)
 51 | 			local reuse_active = is_library(fname)
 52 | 			if reuse_active then
 53 | 				return reuse_active
 54 | 			end
 55 | 
 56 | 			local cargo_crate_dir = util.root_pattern 'Cargo.toml'(fname)
 57 | 			local cargo_workspace_root
 58 | 
 59 | 			if cargo_crate_dir ~= nil then
 60 | 				local cmd = {
 61 | 					'cargo',
 62 | 					'metadata',
 63 | 					'--no-deps',
 64 | 					'--format-version',
 65 | 					'1',
 66 | 					'--manifest-path',
 67 | 					cargo_crate_dir .. '/Cargo.toml',
 68 | 				}
 69 | 
 70 | 				local result = async.run_command(cmd)
 71 | 
 72 | 				if result and result[1] then
 73 | 					result = vim.json.decode(table.concat(result, ''))
 74 | 					if result['workspace_root'] then
 75 | 						cargo_workspace_root = vim.fs.normalize(result['workspace_root'])
 76 | 					end
 77 | 				end
 78 | 			end
 79 | 
 80 | 			return cargo_workspace_root
 81 | 				or cargo_crate_dir
 82 | 				or util.root_pattern 'rust-project.json'(fname)
 83 | 				or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1])
 84 | 		end,
 85 | 		capabilities = {
 86 | 			experimental = {
 87 | 				serverStatusNotification = true,
 88 | 			},
 89 | 		},
 90 | 		before_init = function(init_params, config)
 91 | 			-- See https://github.com/rust-lang/rust-analyzer/blob/eb5da56d839ae0a9e9f50774fa3eb78eb0964550/docs/dev/lsp-extensions.md?plain=1#L26
 92 | 			if config.settings and config.settings['rust-analyzer'] then
 93 | 				init_params.initializationOptions = config.settings['rust-analyzer']
 94 | 			end
 95 | 		end,
 96 | 	},
 97 | 	commands = {
 98 | 		CargoReload = {
 99 | 			function()
100 | 				reload_workspace(0)
101 | 			end,
102 | 			description = 'Reload current cargo workspace',
103 | 		},
104 | 	},
105 | }
106 | 


--------------------------------------------------------------------------------
/lua/usr/todo-comments.lua:
--------------------------------------------------------------------------------
 1 | local todo_comments = require("todo-comments")
 2 | local icons = require("usr.core.icons")
 3 | 
 4 | local error_red = "#F44747"
 5 | local warning_orange = "#ff8800"
 6 | local info_yellow = "#FFCC66"
 7 | local hint_blue = "#4FC1FF"
 8 | local perf_purple = "#7C3AED"
 9 | -- local note_green = '#10B981'
10 | 
11 | todo_comments.setup {
12 | 	signs = true, -- show icons in the signs column
13 | 	sign_priority = 8, -- sign priority
14 | 	-- keywords recognized as todo comments
15 | 	keywords = {
16 | 		FIX = {
17 | 			icon = icons.ui.Bug, -- icon used for the sign, and in search results
18 | 			color = error_red, -- can be a hex color, or a named color (see below)
19 | 			alt = { "FIXME", "BUG", "FIXIT", "ISSUE" }, -- a set of other keywords that all map to this FIX keywords
20 | 			-- signs = false, -- configure signs for some keywords individually
21 | 		},
22 | 		TODO = { icon = icons.ui.Check, color = hint_blue, alt = { "TIP" } },
23 | 		HACK = { icon = icons.ui.Fire, color = warning_orange },
24 | 		WARN = { icon = icons.diagnostics.Warning, color = warning_orange, alt = { "WARNING", "XXX" } },
25 | 		PERF = { icon = icons.ui.Dashboard, color = perf_purple, alt = { "OPTIM", "PERFORMANCE", "OPTIMIZE" } },
26 | 		NOTE = { icon = icons.ui.Note, color = hint_blue, alt = { "INFO" } },
27 | 		TEST = { icon = icons.ui.Test, color = info_yellow, alt = { "TESTING", "PASSED", "FAILED" } },
28 | 	},
29 | 	gui_style = {
30 | 		fg = "BOLD", -- The gui style to use for the fg highlight group.
31 | 		bg = "NONE", -- The gui style to use for the bg highlight group.
32 | 	},
33 | 	merge_keywords = true, -- when true, custom keywords will be merged with the defaults
34 | 	-- highlighting of the line containing the todo comment
35 | 	-- * before: highlights before the keyword (typically comment characters)
36 | 	-- * keyword: highlights of the keyword
37 | 	-- * after: highlights after the keyword (todo text)
38 | 	highlight = {
39 | 		before = "", -- "fg" or "bg" or empty
40 | 		keyword = "bg", -- "fg", "bg", "wide", "wide_bg", "wide_fg" or empty. (wide and wide_bg is the same as bg, but will also highlight surrounding characters, wide_fg acts accordingly but with fg)
41 | 		after = "fg", -- "fg" or "bg" or empty
42 | 		pattern = [[.*<(KEYWORDS)\s*:]], -- pattern or table of patterns, used for highlightng (vim regex)
43 | 		comments_only = true, -- uses treesitter to match keywords in comments only
44 | 		max_line_len = 400, -- ignore lines longer than this
45 | 		exclude = {}, -- list of file types to exclude highlighting
46 | 	},
47 | 	-- list of named colors where we try to extract the guifg from the
48 | 	-- list of highlight groups or use the hex color if hl not found as a fallback
49 | 	colors = {
50 | 		error = { "DiagnosticError", "ErrorMsg", "#DC2626" },
51 | 		warning = { "DiagnosticWarn", "WarningMsg", "#FBBF24" },
52 | 		info = { "DiagnosticInfo", "#2563EB" },
53 | 		hint = { "DiagnosticHint", "#10B981" },
54 | 		default = { "Identifier", "#7C3AED" },
55 | 		test = { "Identifier", "#FF00FF" }
56 | 	},
57 | 	search = {
58 | 		command = "rg",
59 | 		args = {
60 | 			"--color=never",
61 | 			"--no-heading",
62 | 			"--with-filename",
63 | 			"--line-number",
64 | 			"--column",
65 | 		},
66 | 		-- regex that will be used to match keywords.
67 | 		-- don't replace the (KEYWORDS) placeholder
68 | 		pattern = [[\b(KEYWORDS):]], -- ripgrep regex
69 | 		-- pattern = [[\b(KEYWORDS)\b]], -- match without the extra colon. You'll likely get false positives
70 | 	},
71 | }
72 | 
73 | 


--------------------------------------------------------------------------------
/lua/usr/gitsigns.lua:
--------------------------------------------------------------------------------
 1 | local gitsigns = require("gitsigns")
 2 | local icons = require("usr.core.icons")
 3 | 
 4 | gitsigns.setup {
 5 | 	signs = {
 6 | 		add = { text = icons.git.BoldBar },
 7 | 		change = { text = icons.git.BoldBar },
 8 | 		delete = { text = icons.git.Deleted },
 9 | 		topdelete = { text = icons.git.TopDeleted },
10 | 		changedelete = { text = icons.git.ChagneDeleted },
11 | 		untracked = { text = icons.git.Untracked },
12 | 	},
13 | 	signs_staged = {
14 | 		add					= { text = icons.git.BoldBar },
15 | 		change			 = { text = icons.git.BoldBar },
16 | 		delete			 = { text = icons.git.Deleted },
17 | 		topdelete		= { text = icons.git.TopDeleted },
18 | 		changedelete = { text = icons.git.ChagneDeleted },
19 | 		untracked		= { text = icons.git.Untracked },
20 | 	},
21 | 	signs_staged_enable = true,
22 | 	signcolumn = true, -- Toggle with `:Gitsigns toggle_signs`
23 | 	numhl = false, -- Toggle with `:Gitsigns toggle_numhl`
24 | 	linehl = false, -- Toggle with `:Gitsigns toggle_linehl`
25 | 	word_diff = false, -- Toggle with `:Gitsigns toggle_word_diff`
26 | 	watch_gitdir = {
27 | 		follow_files = true,
28 | 	},
29 | 	auto_attach = true,
30 | 	attach_to_untracked = false,
31 | 	current_line_blame = false, -- Toggle with `:Gitsigns toggle_current_line_blame`
32 | 	current_line_blame_opts = {
33 | 		virt_text = true,
34 | 		virt_text_pos = 'eol', -- 'eol' | 'overlay' | 'right_align'
35 | 		delay = 1000,
36 | 		ignore_whitespace = false,
37 | 		virt_text_priority = 100,
38 | 		use_focus = true,
39 | 	},
40 | 	current_line_blame_formatter = '<author>, <author_time:%Y-%m-%d> - <summary>',
41 | 	sign_priority = 6,
42 | 	update_debounce = 100,
43 | 	status_formatter = nil, -- Use default
44 | 	max_file_length = 40000, -- Disable if file is longer than this (in lines)
45 | 	preview_config = {
46 | 		-- Options passed to nvim_open_win
47 | 		style = "minimal",
48 | 		relative = "cursor",
49 | 		row = 0,
50 | 		col = 1,
51 | 	},
52 | 	on_attach = function(bufnr)
53 | 		local function map(mode, l, r, opts)
54 | 			opts = opts or { noremap = true, silent = true }
55 | 			opts.buffer = bufnr
56 | 			vim.keymap.set(mode, l, r, opts)
57 | 		end
58 | 
59 | 		-- Navigation
60 | 		map('n', 'gnh', function()
61 | 			if vim.wo.diff then
62 | 				vim.cmd.normal({']c', bang = true})
63 | 			else
64 | 				gitsigns.nav_hunk('next')
65 | 			end
66 | 		end)
67 | 
68 | 		map('n', 'gph', function()
69 | 			if vim.wo.diff then
70 | 				vim.cmd.normal({'[c', bang = true})
71 | 			else
72 | 				gitsigns.nav_hunk('prev')
73 | 			end
74 | 		end)
75 | 
76 | 		-- Actions
77 | 		map('n', '<leader>lb', gitsigns.toggle_current_line_blame)
78 | 		map('n', 'gfb', function() gitsigns.blame_line{full=true} end)
79 | 		map("n", "<leader>gd", function ()
80 | 				local commit = vim.fn.input("Enter commit: ", "HEAD~")
81 | 				require("gitsigns").diffthis(commit)
82 | 			end)
83 | 		map('n', 'gbl', gitsigns.blame_line)
84 | 		map('n', 'gpr', gitsigns.preview_hunk)
85 | 		map('n', 'grb', gitsigns.reset_buffer)
86 | 		map('n', 'grh', gitsigns.reset_hunk)
87 | 		map('n', 'gsb', gitsigns.stage_buffer)
88 | 		map('n', 'gsh', gitsigns.stage_hunk)
89 | 		map('n', 'gtd', gitsigns.toggle_deleted)
90 | 		map('n', 'guh', gitsigns.undo_stage_hunk)
91 | 		map('v', 'grl', function() gitsigns.reset_hunk {vim.fn.line('.'), vim.fn.line('v')} end)
92 | 		map('v', 'gsh', function() gitsigns.stage_hunk {vim.fn.line('.'), vim.fn.line('v')} end)
93 | 
94 | 		-- Text object
95 | 		map({'o', 'x'}, 'ih', ':<C-U>Gitsigns select_hunk<CR>')
96 | 	end
97 | }
98 | 


--------------------------------------------------------------------------------
/lua/usr/lualine.lua:
--------------------------------------------------------------------------------
  1 | local lualine = require("lualine")
  2 | local icons = require("usr.core.icons")
  3 | 
  4 | local function hide_in_width()
  5 | 	return vim.fn.winwidth(0) > 80
  6 | end
  7 | 
  8 | local diagnostics = {
  9 | 	"diagnostics",
 10 | 	sources = { "nvim_diagnostic" },
 11 | 	sections = { "error", "warn" },
 12 | 	symbols = {
 13 | 		error = icons.diagnostics.Error,
 14 | 		warn = icons.diagnostics.Warning,
 15 | 		info = icons.diagnostics.Info,
 16 | 		hint = icons.diagnostics.Hint
 17 | 	},
 18 | 	colored = true,
 19 | 	update_in_insert = false,
 20 | 	always_visible = true,
 21 | }
 22 | 
 23 | local function add_space(icon)
 24 | 	return " " .. icon
 25 | end
 26 | 
 27 | local diff = {
 28 | 	"diff",
 29 | 	colored = true,
 30 | 	symbols = {
 31 | 		added = add_space(icons.git.Add),
 32 | 		modified = add_space(icons.git.Mod),
 33 | 		removed = add_space(icons.git.Remove),
 34 | 	}, -- changes diff symbols
 35 | 	diff_color = { added = 'diffAdd', modified = 'diffChange', removed = 'diffDelete'},
 36 | 	cond = hide_in_width,
 37 | }
 38 | 
 39 | local mode = {
 40 | 	"mode",
 41 | 	fmt = function(str)
 42 | 		return " " .. str .. " "
 43 | 	end,
 44 | }
 45 | 
 46 | local filetype = {
 47 | 	"filetype",
 48 | 	icons_enabled = true,
 49 | 	icon = nil,
 50 | }
 51 | 
 52 | local branch = {
 53 | 	"branch",
 54 | 	icons_enabled = true,
 55 | 	icon = "",
 56 | }
 57 | 
 58 | local location = {
 59 | 	"location",
 60 | 	padding = 0,
 61 | }
 62 | 
 63 | local filename = {
 64 | 	"filename",
 65 | 	file_status = true,
 66 | 	path = 1,
 67 | 	symbols = {
 68 | 		readonly = icons.access.ReadOnly,
 69 | 		unnamed = icons.kind.Unnamed,
 70 | 		modified = icons.git.Mod,
 71 | 	},
 72 | }
 73 | 
 74 | local fileformat = {
 75 | 	"fileformat",
 76 | 	symbols = {
 77 | 		unix = icons.system.Linux,
 78 | 		dos = icons.system.Windows,
 79 | 		mac = icons.system.Apple,
 80 | 	},
 81 | }
 82 | 
 83 | -- cool function for progress
 84 | local function progress()
 85 | 	local current_line = vim.fn.line(".")
 86 | 	local total_lines = vim.fn.line("$")
 87 | 	local chars = {
 88 | 		icons.possition.Pos1,
 89 | 		icons.possition.Pos2,
 90 | 		icons.possition.Pos3,
 91 | 		icons.possition.Pos4,
 92 | 		icons.possition.Pos5,
 93 | 		icons.possition.Pos6,
 94 | 		icons.possition.Pos7,
 95 | 		icons.possition.Pos8,
 96 | 		icons.possition.Pos9,
 97 | 	}
 98 | 	local line_ratio = current_line / total_lines
 99 | 	local index = math.ceil(line_ratio * #chars)
100 | 	return chars[index]
101 | end
102 | 
103 | local function spaces()
104 | 	return "spaces: " .. vim.api.nvim_buf_get_option(0, "shiftwidth")
105 | end
106 | 
107 | lualine.setup({
108 | 	options = {
109 | 		icons_enabled = true,
110 | 		theme = "catppuccin",  --"catppuccin", -- "solarized_dark",
111 | 		component_separators = { left = "", right = "" },
112 | 		section_separators = { left = icons.ui.LeftSeparator, right = icons.ui.RightSeparator },
113 | 		disabled_filetypes = { "dashboard", "NvimTree", "Outline" },
114 | 		always_divide_middle = true,
115 | 	},
116 | 	sections = {
117 | 		lualine_a = { mode },
118 | 		lualine_b = { filename, branch, diff, diagnostics },
119 | 		lualine_c = {},
120 | 		-- lualine_x = { "encoding", "fileformat", "filetype" },
121 | 		lualine_x = { spaces, "encoding", fileformat, filetype },
122 | 		lualine_y = { location, progress },
123 | 		lualine_z = {},
124 | 	},
125 | 	inactive_sections = {
126 | 		lualine_a = {},
127 | 		lualine_b = {},
128 | 		lualine_c = { filename },
129 | 		lualine_x = { "location" },
130 | 		lualine_y = {},
131 | 		lualine_z = {},
132 | 	},
133 | 	tabline = {},
134 | 	extensions = {},
135 | })
136 | 


--------------------------------------------------------------------------------
/lua/usr/navigation/dropbar.lua:
--------------------------------------------------------------------------------
  1 | local ok, dropbar = pcall(require, "dropbar")
  2 | if not ok then
  3 | 	vim.notify("Nvim dropbar is not installed")
  4 | 	return
  5 | end
  6 | 
  7 | local utils = require('dropbar.utils')
  8 | local icons = require("usr.core.icons")
  9 | 
 10 | dropbar.setup{
 11 | 	icons = {
 12 | 		kinds = {
 13 | 			symbols = {
 14 | 				Array = icons.type.Array,
 15 | 				Boolean = icons.type.Boolean,
 16 | 				BreakStatement = icons.dap.StepBack,
 17 | 				Call = icons.kind.Call,
 18 | 				CaseStatement = icons.type.Case,
 19 | 				Class = icons.type.Class,
 20 | 				Color = icons.kind.Color,
 21 | 				Constant = icons.kind.Constant,
 22 | 				Constructor = icons.kind.Constructor,
 23 | 				ContinueStatement = icons.kind.Continue,
 24 | 				Copilot = icons.kind.Copilot,
 25 | 				Declaration = icons.kind.Declaration,
 26 | 				Delete = icons.kind.Delete,
 27 | 				DoStatement = icons.type.Do,
 28 | 				Enum = icons.type.Enum,
 29 | 				EnumMember = icons.type.EnumMember,
 30 | 				Event = icons.kind.Event,
 31 | 				Field = icons.kind.Field,
 32 | 				File = icons.documents.File,
 33 | 				Folder = icons.documents.EmptyFolder,
 34 | 				ForStatement = icons.type.For,
 35 | 				Function = icons.kind.Function,
 36 | 				Identifier = icons.kind.Variable,
 37 | 				IfStatement = icons.type.If,
 38 | 				Interface = icons.kind.Interface,
 39 | 				Keyword = icons.kind.Keyword,
 40 | 				List = icons.type.Array,
 41 | 				Log = icons.documents.File,
 42 | 				Lsp = icons.diagnostics.Lsp,
 43 | 				Macro = icons.kind.Snippet,
 44 | 				MarkdownH1 = icons.kind.Text,
 45 | 				MarkdownH2 = icons.kind.Text,
 46 | 				MarkdownH3 = icons.kind.Text,
 47 | 				MarkdownH4 = icons.kind.Text,
 48 | 				MarkdownH5 = icons.kind.Text,
 49 | 				MarkdownH6 = icons.kind.Text,
 50 | 				Method = icons.kind.Method,
 51 | 				Module = icons.kind.Module,
 52 | 				Namespace = icons.type.Namespace,
 53 | 				Null = icons.type.Null,
 54 | 				Number = icons.type.Number,
 55 | 				Object = icons.type.Object,
 56 | 				Operator = icons.kind.Operator,
 57 | 				Package = icons.ui.Package,
 58 | 				Property = icons.kind.Property,
 59 | 				Reference = icons.kind.Reference,
 60 | 				Regex = icons.ui.Regex,
 61 | 				Repeat = icons.type.Repeat,
 62 | 				Scope = icons.kind.Scope,
 63 | 				Snippet = icons.kind.Snippet,
 64 | 				Specifier = icons.kind.Constant,
 65 | 				Statement = icons.kind.Statement,
 66 | 				String = icons.type.String,
 67 | 				Struct = icons.type.Struct,
 68 | 				SwitchStatement = icons.type.Switch,
 69 | 				Text = icons.kind.Text,
 70 | 				Type = icons.kind.Type,
 71 | 				TypeParameter = icons.kind.TypeParameter,
 72 | 				Unit = icons.kind.Unit,
 73 | 				Value = icons.kind.Value,
 74 | 				Variable = icons.kind.Variable,
 75 | 				WhileStatement = icons.type.While,
 76 | 			},
 77 | 		},
 78 | 	},
 79 | 	menu = {
 80 | 		---@type table<string, string|function|table<string, string|function>>
 81 | 		keymaps = {
 82 | 			['l'] = function()
 83 | 				local menu = require('dropbar.api').get_current_dropbar_menu()
 84 | 				if not menu then
 85 | 					return
 86 | 				end
 87 | 				local cursor = vim.api.nvim_win_get_cursor(menu.win)
 88 | 				local component = menu.entries[cursor[1]]:first_clickable(cursor[2])
 89 | 				if component then
 90 | 					menu:click_on(component, nil, 1, 'l')
 91 | 				end
 92 | 			end,
 93 | 			['q'] = function ()
 94 | 				local menu = require('dropbar.api').get_current_dropbar_menu()
 95 | 				while menu do
 96 | 					menu:del()
 97 | 					menu = menu.prev_menu
 98 | 				end
 99 | 			end,
100 | 			['h'] = function ()
101 | 				require('dropbar.api').get_current_dropbar_menu():del()
102 | 			end,
103 | 		},
104 | 	},
105 | }
106 | 
107 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # nvim
  2 | 
  3 |  > The links are pasted here as full links. Some browsers might not be able to open them.
  4 |  > If you are using a browser that does not support the links, you can copy the link
  5 |  > and paste it into the address bar.
  6 | 
  7 | Table of Contents:
  8 | - [Compatibility](#compatibility)
  9 | - [Startup](#startup)
 10 | - [Dependencies](#dependencies)
 11 | - [Lsp](#lsp)
 12 | - [DAP](#dap)
 13 | - [Spelling](#spelling)
 14 | - [Markdown](#markdown)
 15 | 
 16 | | Language      | Files | Blank | Comment | Code  |
 17 | |---------------|-------|-------|---------|-------|
 18 | | Lua           | 73    | 448   | 567     | 3220  |
 19 | | JSON          | 4     | 0     | 0       | 173   |
 20 | | YAML          | 1     | 0     | 1       | 114   |
 21 | | Markdown      | 1     | 33    | 0       | 67    |
 22 | | **SUM:**      | 79    | 481   | 566     | 3574  |
 23 | 
 24 | 
 25 | ## Compatibility
 26 | 
 27 | nvim version >= 0.7 <br />
 28 | There is a specific branch for every branch from version 0.7.2. From version 0.11 (prerelease) I started using bob, (https://github.com/MordechaiHadad/bob)
 29 | command for nvim version management. The version is included in the tags of the releases if they changed. Otherwise you can find the neovim releases on
 30 | https://github.com/neovim/neovim/releases <br />
 31 | 
 32 | ## Startup
 33 | 
 34 |     git clone git@github.com:Fildo7525/nvim.git
 35 |     mv nvim/ ~/.config/
 36 | 
 37 | Open the config for the first time and install all the plugins
 38 | 
 39 | #### optional Latex
 40 | 
 41 | If you want to setup latex with tree-sitter:
 42 | 
 43 |     sudo npm install --save-dev tree-sitter-cli
 44 |     echo 'export PATH="\$PATH:$HOME/node_modules/.bin"' >> ~/.zshrc
 45 | 
 46 | setup guide [here](https://tree-sitter.github.io/tree-sitter/creating-parsers#installation)
 47 | 
 48 | ---
 49 | 
 50 | ### Dependencies
 51 | 
 52 | #### NerdFonts
 53 | 
 54 | Download Nerdfont from
 55 | https://www.nerdfonts.com/font-downloads
 56 | unzip it delete all unneccessery files (If you are on linux delete everything containing ```Windows```).
 57 | Move the remaining files to ```/usr/share/fonts``` so everyone can use them or to ```~/.fonts``` for your own usage.
 58 | 
 59 | #### Other
 60 | 
 61 | If you have any other unmet dependencies you can see them after invoking command ```:checkhealth```
 62 | 
 63 | ---
 64 | 
 65 | ### Lsp
 66 | 
 67 | The custom lsp configurations are located in ```lua/usr/lsp/settings/```
 68 | If you do no want to / need to change the confugration you can just install the servers using ```Mason``` command
 69 | the default configuration from mason-lspconfig will be used.
 70 | 
 71 | To use the LSP's type ```:Mason``` and install given servers
 72 | 
 73 | #### C++
 74 | 
 75 | To use lsp for c/cpp/objc download clangd, clangd-format, and clang-tidy using your package manager
 76 | The formating standard is based on WebKit (tabsize - 4, strictly using tabs)
 77 | 
 78 | ---
 79 | 
 80 | ### DAP
 81 | 
 82 | DAP is currently supported for `C/C++`, `bash`, `python3`, `lua`
 83 | Use `Mason` to install the debuggers. The configuration files are located in `lua/usr/DAP/`
 84 | 
 85 | ---
 86 | 
 87 | ### Spelling
 88 | 
 89 | If the spell file you are looking for in not downloaded by neovim automaticly head to the server ```https://ftp.nluug.nl/vim/runtime/spell/```
 90 | and download it manually to ```~/.config/nvim/spell/```. This will fix the issue.
 91 | 
 92 | ### Markdown
 93 | 
 94 | For the markdown ftplugins to work there are requirements
 95 | 
 96 | ```bash
 97 | sudo apt install luarocks
 98 | sudo luarocks install luasocket htmlparser luasec html-entities
 99 | luarocks path >> ~/.zshrc
100 | ```
101 | 


--------------------------------------------------------------------------------
/formats/qt/.clang-format:
--------------------------------------------------------------------------------
  1 | AccessModifierOffset: -4
  2 | AlignAfterOpenBracket: true
  3 | AlignConsecutiveAssignments: false
  4 | AlignConsecutiveDeclarations: false
  5 | AlignEscapedNewlines: Right
  6 | AlignOperands:   false
  7 | AlignTrailingComments: false
  8 | AllowAllParametersOfDeclarationOnNextLine: true
  9 | AllowShortBlocksOnASingleLine: false
 10 | AllowShortCaseLabelsOnASingleLine: false
 11 | AllowShortFunctionsOnASingleLine: false
 12 | AllowShortIfStatementsOnASingleLine: false
 13 | AllowShortLoopsOnASingleLine: false
 14 | AlwaysBreakAfterDefinitionReturnType: None
 15 | AlwaysBreakAfterReturnType: None
 16 | AlwaysBreakBeforeMultilineStrings: false
 17 | AlwaysBreakTemplateDeclarations: true
 18 | BasedOnStyle: WebKit
 19 | BinPackArguments: true
 20 | BinPackParameters: true
 21 | BraceWrapping:
 22 |     AfterClass: true
 23 |     AfterControlStatement: false
 24 |     AfterEnum: false
 25 |     AfterFunction: false
 26 |     AfterNamespace: false
 27 |     AfterObjCDeclaration: false
 28 |     AfterStruct: false
 29 |     AfterUnion: false
 30 |     BeforeCatch: false
 31 |     BeforeElse: false
 32 |     IndentBraces: true
 33 |     SplitEmptyFunction: true
 34 |     SplitEmptyRecord: true
 35 |     SplitEmptyNamespace: true
 36 | BreakAfterJavaFieldAnnotations: false
 37 | BreakBeforeBinaryOperators: NonAssignment
 38 | BreakBeforeBraces: Custom
 39 | BreakBeforeInheritanceComma: true
 40 | BreakBeforeTernaryOperators: true
 41 | BreakStringLiterals: true
 42 | BreakConstructorInitializersBeforeComma: false
 43 | BreakConstructorInitializers: BeforeComma
 44 | ColumnLimit: 120
 45 | CommentPragmas: "^!|^:"
 46 | CompactNamespaces: false
 47 | ConstructorInitializerAllOnOneLineOrOnePerLine: false
 48 | ConstructorInitializerIndentWidth: 4
 49 | ContinuationIndentWidth: None
 50 | Cpp11BracedListStyle: false
 51 | DerivePointerAlignment: false
 52 | DisableFormat:   false
 53 | ExperimentalAutoDetectBinPacking: false
 54 | FixNamespaceComments: true
 55 | ForEachMacros:
 56 |   - foreach
 57 |   - Q_FOREACH
 58 |   - BOOST_FOREACH
 59 |   - forever
 60 |   - Q_FOREVER
 61 |   - QBENCHMARK
 62 |   - QBENCHMARK_ONCE
 63 | IncludeCategories:
 64 |   - Regex:           '^"config\.h"'
 65 |     Priority:        -1
 66 |   # The main header for a source file automatically gets category 0
 67 |   - Regex:           '^<.*SoftLink.h>'
 68 |     Priority:        4
 69 |   - Regex:           '^".*SoftLink.h"'
 70 |     Priority:        3
 71 |   - Regex:           '^<.*>'
 72 |     Priority:        2
 73 |   - Regex:           '.*'
 74 |     Priority:        1
 75 | IncludeIsMainRegex: '(Test)?$'
 76 | IndentCaseLabels: false
 77 | IndentWidth: 4
 78 | IndentWrappedFunctionNames: false
 79 | JavaScriptQuotes: Leave
 80 | JavaScriptWrapImports: true
 81 | KeepEmptyLinesAtTheStartOfBlocks: true
 82 | MacroBlockBegin: ''
 83 | MacroBlockEnd:   ''
 84 | MaxEmptyLinesToKeep: 1
 85 | NamespaceIndentation: None
 86 | PenaltyBreakAssignment: 2
 87 | PenaltyBreakBeforeFirstCallParameter: 19
 88 | PenaltyBreakComment: 300
 89 | PenaltyBreakFirstLessLess: 120
 90 | PenaltyBreakString: 1000
 91 | PenaltyExcessCharacter: 1000000
 92 | PenaltyReturnTypeOnItsOwnLine: 60
 93 | PointerAlignment: Right
 94 | PointerBindsToType: false
 95 | ReflowComments:  true
 96 | SortIncludes: true
 97 | SortUsingDeclarations: true
 98 | SpaceAfterCStyleCast: false
 99 | SpaceAfterTemplateKeyword: false
100 | SpaceBeforeAssignmentOperators: true
101 | SpaceBeforeCpp11BracedList: true
102 | SpaceBeforeParens: ControlStatements
103 | SpaceInEmptyParentheses: false
104 | SpacesBeforeTrailingComments: 1
105 | SpacesInAngles:  false
106 | SpacesInContainerLiterals: true
107 | SpacesInCStyleCastParentheses: false
108 | SpacesInParentheses: false
109 | SpacesInSquareBrackets: false
110 | Standard: c++17
111 | TabWidth: 4
112 | UseCRLF: false
113 | UseTab: Always
114 | ---
115 | ...
116 | 


--------------------------------------------------------------------------------
/lua/usr/core/icons.lua:
--------------------------------------------------------------------------------
  1 | -- https://github.com/microsoft/vscode/blob/main/src/vs/base/common/codicons.ts
  2 | -- go to the above and then enter <c-v>u<unicode> and the symbold should appear
  3 | -- or go here and upload the font file: https://mathew-kurian.github.io/CharacterMap/
  4 | -- find more here: https://www.nerdfonts.com/cheat-sheet
  5 | return {
  6 | 	kind = {
  7 | 		Call = " ",
  8 | 		Color = " ",
  9 | 		Constant = " ",
 10 | 		Constructor = " ",
 11 | 		Container = " ",
 12 | 		Continue = '→ ',
 13 | 		Copilot = ' ',
 14 | 		Declaration = " ",
 15 | 		Delete = "󰚃 ",
 16 | 		Event = " ",
 17 | 		Field = " ",
 18 | 		Function = "󰡱 ",
 19 | 		Interface = " ",
 20 | 		Keyword = " ",
 21 | 		Method = "m ",
 22 | 		Module = " ",
 23 | 		Operator = " ",
 24 | 		Property = " ",
 25 | 		Quit = "󰩈 ",
 26 | 		RecentlyUsed = "󱦺 ",
 27 | 		Reference = " ",
 28 | 		Snippet = " ",
 29 | 		Text = "󰊄 ",
 30 | 		Type = "󰉺 ",
 31 | 		TextLines = " ",
 32 | 		TypeParameter = " ",
 33 | 		Unit = " ",
 34 | 		Unnamed = "󰺴 ",
 35 | 		Value = " ",
 36 | 		Variable = " ",
 37 | 	},
 38 | 	type = {
 39 | 		Array = " ",
 40 | 		Boolean = "󱎅 ",
 41 | 		Case = "󱓡 ",
 42 | 		Class = " ",
 43 | 		Do = " ",
 44 | 		Enum = " ",
 45 | 		EnumMember = " ",
 46 | 		For = " ",
 47 | 		If = "󰊴 ",
 48 | 		Namespace = " ",
 49 | 		NullName = "[] ",
 50 | 		Number = " ",
 51 | 		Null = "󰚃 ",
 52 | 		Object = " ",
 53 | 		Repeat = " ",
 54 | 		String = " ",
 55 | 		Struct = " ",
 56 | 		Switch = "󰔡 ",
 57 | 		While = " ",
 58 | 	},
 59 | 	documents = {
 60 | 		File = " ",
 61 | 		Files = " ",
 62 | 		EmptyFolder = " ",
 63 | 		FullFolder = " ",
 64 | 		OpenFolder = " ",
 65 | 		OpenFullFolder = "",
 66 | 		Symlink = " ",
 67 | 	},
 68 | 	git = {
 69 | 		Add = " ",
 70 | 		BoldBar = "▎",
 71 | 		ChagneDeleted = "~",
 72 | 		Deleted = "󰗩 ",
 73 | 		Diff = " ",
 74 | 		Ignore = " ",
 75 | 		Ignored = "◌ ",
 76 | 		Mod = "● ",
 77 | 		Remove = " ",
 78 | 		Rename = " ",
 79 | 		Renamed = "➜",
 80 | 		Repo = " ",
 81 | 		Staged = " ",
 82 | 		TopDeleted = '‾',
 83 | 		Unmerged = " ",
 84 | 		Unstaged = " ",
 85 | 		Untracked = "┆ ",
 86 | 	},
 87 | 	ui = {
 88 | 		ArrowClosed = " ",
 89 | 		ArrowOpen = " ",
 90 | 		BigCircle = " ",
 91 | 		BigUnfilledCircle = " ",
 92 | 		BookMark = " ",
 93 | 		Bug = " ",
 94 | 		Calendar = " ",
 95 | 		Check = "󰄬 ",
 96 | 		ChevronRight = "> ",
 97 | 		Circle = " ",
 98 | 		Close = " ",
 99 | 		CloudDownload = " ",
100 | 		Code = " ",
101 | 		Comment = " ",
102 | 		Configuration = " ",
103 | 		Dashboard = " ",
104 | 		Do = " ",
105 | 		Extends = '… ',
106 | 		File = " ",
107 | 		Fire = " ",
108 | 		Gear = " ",
109 | 		History = " ",
110 | 		Home = " ",
111 | 		Indicator = " ",
112 | 		LeftMarker = " ",
113 | 		LeftSeparator = "",
114 | 		Lightbulb = " ",
115 | 		List = " ",
116 | 		Lock = " ",
117 | 		NewFile = " ",
118 | 		Note = "󰎞 ",
119 | 		Operator = " ",
120 | 		Package = " ",
121 | 		Pencil = " ",
122 | 		Project = " ",
123 | 		Regex = ' ',
124 | 		RightMarker = " ",
125 | 		RightSeparator = "",
126 | 		Search = " ",
127 | 		Separator = ' ',
128 | 		SignIn = " ",
129 | 		SignOut = " ",
130 | 		Table = " ",
131 | 		Telescope = " ",
132 | 		Test = "󰙨 ",
133 | 	},
134 | 	diagnostics = {
135 | 		Lsp = ' ',
136 | 		Error = " ",
137 | 		Hint = " ",
138 | 		Information = " ",
139 | 		Question = " ",
140 | 		Warning = " ",
141 | 	},
142 | 	misc = {
143 | 		Robot = "󱨚 ",
144 | 		Squirrel = " ",
145 | 		Tag = " ",
146 | 		Watch = " ",
147 | 	},
148 | 	dap = {
149 | 		Pause = "󰏤 ",
150 | 		Play = " ",
151 | 		RunLast = "󰘁 ",
152 | 		StepBack = " ",
153 | 		StepInto = " ",
154 | 		StepOut = "󰆸 ",
155 | 		StepOver = " ",
156 | 		Terminate = "󰅜 ",
157 | 	},
158 | 	telescope = {
159 | 		Prompt = " ",
160 | 		Selection = " ",
161 | 	},
162 | 	system = {
163 | 		Apple = " ",
164 | 		Linux = " ",
165 | 		Windows = " ",
166 | 	},
167 | 	possition = {
168 | 		Pos1 = "__",
169 | 		Pos2= "▁▁",
170 | 		Pos3= "▂▂",
171 | 		Pos4= "▃▃",
172 | 		Pos5= "▄▄",
173 | 		Pos6= "▅▅",
174 | 		Pos7= "▆▆",
175 | 		Pos8= "▇▇",
176 | 		Pos9= "██",
177 | 	},
178 | 	access = {
179 | 		ReadOnly = " ",
180 | 
181 | 	}
182 | }
183 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/lspMason.lua:
--------------------------------------------------------------------------------
  1 | -- mason.lua
  2 | --
  3 | -- Configuration for mason plugin, which is a improved replacement for
  4 | -- Lsp-installer.
  5 | 
  6 | local installer = require("usr.lsp.lsp-installer")
  7 | local mason = require("mason")
  8 | local mason_lspconfig = require("mason-lspconfig")
  9 | 
 10 | ---@class MasonSettings
 11 | local DEFAULT_SETTINGS = {
 12 | 	---@since 1.0.0
 13 | 	-- Controls to which degree logs are written to the log file. It's useful to set this to vim.log.levels.DEBUG when
 14 | 	-- debugging issues with package installations.
 15 | 	log_level = vim.log.levels.INFO,
 16 | 
 17 | 	---@since 1.0.0
 18 | 	-- Limit for the maximum amount of packages to be installed at the same time. Once this limit is reached, any further
 19 | 	-- packages that are requested to be installed will be put in a queue.
 20 | 	max_concurrent_installers = 4,
 21 | 
 22 | 	github = {
 23 | 		---@since 1.0.0
 24 | 		-- The template URL to use when downloading assets from GitHub.
 25 | 		-- The placeholders are the following (in order):
 26 | 		-- 1. The repository (e.g. "rust-lang/rust-analyzer")
 27 | 		-- 2. The release version (e.g. "v0.3.0")
 28 | 		-- 3. The asset name (e.g. "rust-analyzer-v0.3.0-x86_64-unknown-linux-gnu.tar.gz")
 29 | 		download_url_template = "https://github.com/%s/releases/download/%s/%s",
 30 | 	},
 31 | 
 32 | 	pip = {
 33 | 		---@since 1.0.0
 34 | 		-- Whether to upgrade pip to the latest version in the virtual environment before installing packages.
 35 | 		upgrade_pip = false,
 36 | 
 37 | 		---@since 1.0.0
 38 | 		-- These args will be added to `pip install` calls. Note that setting extra args might impact intended behavior
 39 | 		-- and is not recommended.
 40 | 		--
 41 | 		-- Example: { "--proxy", "https://proxyserver" }
 42 | 		install_args = {},
 43 | 	},
 44 | 
 45 | 	ui = {
 46 | 		---@since 1.0.0
 47 | 		-- Whether to automatically check for new versions when opening the :Mason window.
 48 | 		check_outdated_packages_on_open = true,
 49 | 
 50 | 		---@since 1.0.0
 51 | 		-- The border to use for the UI window. Accepts same border values as |nvim_open_win()|.
 52 | 		border = "none",
 53 | 
 54 | 		---@since 1.0.0
 55 | 		-- Width of the window. Accepts:
 56 | 		-- - Integer greater than 1 for fixed width.
 57 | 		-- - Float in the range of 0-1 for a percentage of screen width.
 58 | 		width = 0.8,
 59 | 
 60 | 		---@since 1.0.0
 61 | 		-- Height of the window. Accepts:
 62 | 		-- - Integer greater than 1 for fixed height.
 63 | 		-- - Float in the range of 0-1 for a percentage of screen height.
 64 | 		height = 0.9,
 65 | 
 66 | 		icons = {
 67 | 			---@since 1.0.0
 68 | 			-- The list icon to use for installed packages.
 69 | 			package_installed = "◍",
 70 | 			---@since 1.0.0
 71 | 			-- The list icon to use for packages that are installing, or queued for installation.
 72 | 			package_pending = "◍",
 73 | 			---@since 1.0.0
 74 | 			-- The list icon to use for packages that are not installed.
 75 | 			package_uninstalled = "◍",
 76 | 		},
 77 | 
 78 | 		keymaps = {
 79 | 			---@since 1.0.0
 80 | 			-- Keymap to expand a package
 81 | 			toggle_package_expand = "<CR>",
 82 | 			---@since 1.0.0
 83 | 			-- Keymap to install the package under the current cursor position
 84 | 			install_package = "i",
 85 | 			---@since 1.0.0
 86 | 			-- Keymap to reinstall/update the package under the current cursor position
 87 | 			update_package = "u",
 88 | 			---@since 1.0.0
 89 | 			-- Keymap to check for new version for the package under the current cursor position
 90 | 			check_package_version = "c",
 91 | 			---@since 1.0.0
 92 | 			-- Keymap to update all installed packages
 93 | 			update_all_packages = "U",
 94 | 			---@since 1.0.0
 95 | 			-- Keymap to check which installed packages are outdated
 96 | 			check_outdated_packages = "C",
 97 | 			---@since 1.0.0
 98 | 			-- Keymap to uninstall a package
 99 | 			uninstall_package = "X",
100 | 			---@since 1.0.0
101 | 			-- Keymap to cancel a package installation
102 | 			cancel_installation = "<C-c>",
103 | 			---@since 1.0.0
104 | 			-- Keymap to apply language filter
105 | 			apply_language_filter = "<C-f>",
106 | 			---@since 1.1.0
107 | 			-- Keymap to toggle viewing package installation log
108 | 			toggle_package_install_log = "<CR>",
109 | 			---@since 1.8.0
110 | 			-- Keymap to toggle the help view
111 | 			toggle_help = "?",
112 | 		},
113 | 	},
114 | }
115 | 
116 | mason.setup(DEFAULT_SETTINGS)
117 | mason_lspconfig.setup()
118 | installer.setup()
119 | 
120 | 


--------------------------------------------------------------------------------
/lua/.luarc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "workspace.library": [
 3 |         "/home/fildo7525/.local/share/nvim/lazy/neodev.nvim/types/nightly",
 4 |         "/home/fildo7525/.local/share/bob/nightly/nvim-linux64/share/nvim/runtime/lua",
 5 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-treesitter-context/lua",
 6 |         "/home/fildo7525/.local/share/nvim/lazy/neoscroll.nvim/lua",
 7 |         "/home/fildo7525/.local/share/nvim/lazy/neogen/lua",
 8 |         "/home/fildo7525/.local/share/nvim/lazy/LuaSnip/lua",
 9 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-lspconfig/lua",
10 |         "/home/fildo7525/.local/share/nvim/lazy/todo-comments.nvim/lua",
11 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-lsp-installer/lua",
12 |         "/home/fildo7525/.local/share/nvim/lazy/vim-illuminate/lua",
13 |         "/home/fildo7525/.local/share/nvim/lazy/one-small-step-for-vimkind/lua",
14 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-cmp/lua",
15 |         "/home/fildo7525/.local/share/nvim/lazy/lsp-inlayhints.nvim/lua",
16 |         "/home/fildo7525/.local/share/nvim/lazy/Comment.nvim/lua",
17 |         "/home/fildo7525/.local/share/nvim/lazy/neodev.nvim/lua",
18 |         "/home/fildo7525/.local/share/nvim/lazy/cmp-buffer/lua",
19 |         "/home/fildo7525/.local/share/nvim/lazy/lsp_signature.nvim/lua",
20 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-ts-context-commentstring/lua",
21 |         "/home/fildo7525/.local/share/nvim/lazy/cmp-path/lua",
22 |         "/home/fildo7525/.local/share/nvim/lazy/null-ls.nvim/lua",
23 |         "/home/fildo7525/.local/share/nvim/lazy/gitsigns.nvim/lua",
24 |         "/home/fildo7525/.local/share/nvim/lazy/impatient.nvim/lua",
25 |         "/home/fildo7525/.local/share/nvim/lazy/lazygit.nvim/lua",
26 |         "/home/fildo7525/.local/share/nvim/lazy/alpha-nvim/lua",
27 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-dap/lua",
28 |         "/home/fildo7525/.local/share/nvim/lazy/project.nvim/lua",
29 |         "/home/fildo7525/.local/share/nvim/lazy/trouble.nvim/lua",
30 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-dap-ui/lua",
31 |         "/home/fildo7525/.local/share/nvim/lazy/popup.nvim/lua",
32 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-web-devicons/lua",
33 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-dap-virtual-text/lua",
34 |         "/home/fildo7525/.local/share/nvim/lazy/plenary.nvim/lua",
35 |         "/home/fildo7525/.local/share/nvim/lazy/refactoring.nvim/lua",
36 |         "/home/fildo7525/.local/share/nvim/lazy/dropbar.nvim/lua",
37 |         "/home/fildo7525/.local/share/nvim/lazy/lazy.nvim/lua",
38 |         "/home/fildo7525/.local/share/nvim/lazy/cmp-nvim-lsp/lua",
39 |         "/home/fildo7525/.local/share/nvim/lazy/copilot.vim/lua",
40 |         "/home/fildo7525/.local/share/nvim/lazy/ChatGPT.nvim/lua",
41 |         "/home/fildo7525/.local/share/nvim/lazy/cmp-nvim-lua/lua",
42 |         "/home/fildo7525/.local/share/nvim/lazy/Revolver/lua",
43 |         "/home/fildo7525/.local/share/nvim/lazy/nui.nvim/lua",
44 |         "/home/fildo7525/Documents/sourcing/pretty_hover/lua",
45 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-autopairs/lua",
46 |         "/home/fildo7525/.local/share/nvim/lazy/auto-hlsearch.nvim/lua",
47 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-tree.lua/lua",
48 |         "/home/fildo7525/.local/share/nvim/lazy/mason.nvim/lua",
49 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-semantic-tokens/lua",
50 |         "/home/fildo7525/.local/share/nvim/lazy/telescope.nvim/lua",
51 |         "/home/fildo7525/.local/share/nvim/lazy/mason-lspconfig.nvim/lua",
52 |         "/home/fildo7525/.local/share/nvim/lazy/toggleterm.nvim/lua",
53 |         "/home/fildo7525/.local/share/nvim/lazy/cmp_luasnip/lua",
54 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-treesitter/lua",
55 |         "/home/fildo7525/.local/share/nvim/lazy/stylua-nvim/lua",
56 |         "/home/fildo7525/.local/share/nvim/lazy/cmp-cmdline/lua",
57 |         "/home/fildo7525/.local/share/nvim/lazy/catppuccin/lua",
58 |         "/home/fildo7525/.local/share/nvim/lazy/lualine.nvim/lua",
59 |         "/home/fildo7525/.local/share/nvim/lazy/bufferline.nvim/lua",
60 |         "/home/fildo7525/.local/share/nvim/lazy/nvim-ts-rainbow/lua",
61 |         "/home/fildo7525/.local/share/nvim/lazy/bufdelete.nvim/lua",
62 |         "/home/fildo7525/.local/share/nvim/lazy/satellite.nvim/lua",
63 |         "/home/fildo7525/Documents/dotfiles/nvim/lua",
64 |         "${3rd}/luv/library"
65 |     ]
66 | }


--------------------------------------------------------------------------------
/lazy-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "Comment.nvim": { "branch": "master", "commit": "e30b7f2008e52442154b66f7c519bfd2f1e32acb" },
 3 |   "CopilotChat.nvim": { "branch": "main", "commit": "df5376c132382dd47e3e552612940cbf25b3580c" },
 4 |   "LuaSnip": { "branch": "master", "commit": "5a1e39223db9a0498024a77b8441169d260c8c25" },
 5 |   "Revolver": { "branch": "master", "commit": "0655102022bf6ae5d043c89ad542d391898c7f08" },
 6 |   "auto-hlsearch.nvim": { "branch": "main", "commit": "77502069b22e48ab7736fe9cf53e1fdac1923bca" },
 7 |   "blink.cmp": { "branch": "main", "commit": "b19413d214068f316c78978b08264ed1c41830ec" },
 8 |   "bufdelete.nvim": { "branch": "master", "commit": "f6bcea78afb3060b198125256f897040538bcb81" },
 9 |   "bufferline.nvim": { "branch": "main", "commit": "655133c3b4c3e5e05ec549b9f8cc2894ac6f51b3" },
10 |   "catppuccin": { "branch": "main", "commit": "ce4a8e0d5267e67056f9f4dcf6cb1d0933c8ca00" },
11 |   "ccc.nvim": { "branch": "main", "commit": "9d1a256e006decc574789dfc7d628ca11644d4c2" },
12 |   "cmp-nvim-lsp": { "branch": "main", "commit": "cbc7b02bb99fae35cb42f514762b89b5126651ef" },
13 |   "cmp_luasnip": { "branch": "master", "commit": "98d9cb5c2c38532bd9bdb481067b20fea8f32e90" },
14 |   "copilot.vim": { "branch": "release", "commit": "f89e977c87180519ba3b942200e3d05b17b1e2fc" },
15 |   "dropbar.nvim": { "branch": "master", "commit": "ce202248134e3949aac375fd66c28e5207785b10" },
16 |   "friendly-snippets": { "branch": "main", "commit": "572f5660cf05f8cd8834e096d7b4c921ba18e175" },
17 |   "gitsigns.nvim": { "branch": "main", "commit": "5813e4878748805f1518cee7abb50fd7205a3a48" },
18 |   "impatient.nvim": { "branch": "main", "commit": "47302af74be7b79f002773011f0d8e85679a7618" },
19 |   "indent-blankline.nvim": { "branch": "master", "commit": "005b56001b2cb30bfa61b7986bc50657816ba4ba" },
20 |   "lazy.nvim": { "branch": "main", "commit": "85c7ff3711b730b4030d03144f6db6375044ae82" },
21 |   "lazydev.nvim": { "branch": "main", "commit": "5231c62aa83c2f8dc8e7ba957aa77098cda1257d" },
22 |   "lualine.nvim": { "branch": "master", "commit": "47f91c416daef12db467145e16bed5bbfe00add8" },
23 |   "markdown-preview.nvim": { "branch": "master", "commit": "a923f5fc5ba36a3b17e289dc35dc17f66d0548ee" },
24 |   "mason-lspconfig.nvim": { "branch": "main", "commit": "7d527c76c43f46294de9c19d39c5a86317809b4b" },
25 |   "mason.nvim": { "branch": "main", "commit": "57e5a8addb8c71fb063ee4acda466c7cf6ad2800" },
26 |   "neo-tree.nvim": { "branch": "v3.x", "commit": "f3df514fff2bdd4318127c40470984137f87b62e" },
27 |   "neogen": { "branch": "main", "commit": "b2e78708876f4da507839726816010a68e33fec8" },
28 |   "neoscroll.nvim": { "branch": "master", "commit": "f957373912e88579e26fdaea4735450ff2ef5c9c" },
29 |   "nerdfix": { "branch": "main", "commit": "2ab60a5ba25d5ebea50c0095cc0b17775142b070" },
30 |   "none-ls.nvim": { "branch": "main", "commit": "1917c86818b5e058f53c2ea0ad38fc57534d62fc" },
31 |   "nui.nvim": { "branch": "main", "commit": "de740991c12411b663994b2860f1a4fd0937c130" },
32 |   "nvim-autopairs": { "branch": "master", "commit": "7a2c97cccd60abc559344042fefb1d5a85b3e33b" },
33 |   "nvim-cmp": { "branch": "main", "commit": "d97d85e01339f01b842e6ec1502f639b080cb0fc" },
34 |   "nvim-dap": { "branch": "master", "commit": "5860c7c501eb428d3137ee22c522828d20cca0b3" },
35 |   "nvim-dap-ui": { "branch": "master", "commit": "cf91d5e2d07c72903d052f5207511bf7ecdb7122" },
36 |   "nvim-dap-virtual-text": { "branch": "master", "commit": "fbdb48c2ed45f4a8293d0d483f7730d24467ccb6" },
37 |   "nvim-lspconfig": { "branch": "master", "commit": "effe4bf2e1afb881ea67291c648b68dd3dfc927a" },
38 |   "nvim-nio": { "branch": "master", "commit": "21f5324bfac14e22ba26553caf69ec76ae8a7662" },
39 |   "nvim-tetris": { "branch": "master", "commit": "d17c99fb527ada98ffb0212ffc87ccda6fd4f7d9" },
40 |   "nvim-treesitter": { "branch": "master", "commit": "42fc28ba918343ebfd5565147a42a26580579482" },
41 |   "nvim-web-devicons": { "branch": "master", "commit": "b34362b20a4942b3245f958e73ebe1b09b020ad1" },
42 |   "one-small-step-for-vimkind": { "branch": "main", "commit": "87eeca2bd4d90a94eed1ef0dbc66885117e7bacb" },
43 |   "plenary.nvim": { "branch": "master", "commit": "b9fd5226c2f76c951fc8ed5923d85e4de065e509" },
44 |   "popup.nvim": { "branch": "master", "commit": "b7404d35d5d3548a82149238289fa71f7f6de4ac" },
45 |   "project.nvim": { "branch": "main", "commit": "7d69648dfad76269670bb3a058d59b47774db308" },
46 |   "rainbow-delimiters.nvim": { "branch": "master", "commit": "8aafe2cbd89cd4090f573a98cab6b20366576fde" },
47 |   "render-markdown.nvim": { "branch": "main", "commit": "6e0e8902dac70fecbdd8ce557d142062a621ec38" },
48 |   "satellite.nvim": { "branch": "main", "commit": "7c2e5a4064abb0066a0bf157e7a137f1bcdeace2" },
49 |   "snacks.nvim": { "branch": "main", "commit": "fe7cfe9800a182274d0f868a74b7263b8c0c020b" },
50 |   "stylua-nvim": { "branch": "main", "commit": "ce59a353f02938cba3e0285e662fcd3901cd270f" },
51 |   "telescope.nvim": { "branch": "master", "commit": "a0bbec21143c7bc5f8bb02e0005fa0b982edc026" },
52 |   "todo-comments.nvim": { "branch": "main", "commit": "31e3c38ce9b29781e4422fc0322eb0a21f4e8668" },
53 |   "toggleterm.nvim": { "branch": "main", "commit": "9a88eae817ef395952e08650b3283726786fb5fb" },
54 |   "vim-devicons": { "branch": "master", "commit": "71f239af28b7214eebb60d4ea5bd040291fb7e33" },
55 |   "vim-illuminate": { "branch": "master", "commit": "0d1e93684da00ab7c057410fecfc24f434698898" },
56 |   "vim-polyglot": { "branch": "master", "commit": "f061eddb7cdcc614c8406847b2bfb53099832a4e" },
57 |   "vimtex": { "branch": "master", "commit": "32bcb3922c20588e00de68f73c86312eda2141ad" }
58 | }
59 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/handlers.lua:
--------------------------------------------------------------------------------
  1 | local M = {}
  2 | 
  3 | function M.setup()
  4 | 	local severity = vim.diagnostic.severity
  5 | 	local signs = {
  6 | 		text = {
  7 | 			[severity.ERROR] = "",
  8 | 			[severity.WARN] = "",
  9 | 			[severity.HINT] = "",
 10 | 			[severity.INFO] = "",
 11 | 		},
 12 | 		numhl = {
 13 | 			[severity.WARN] = 'WarningMsg',
 14 | 			[severity.ERROR] = 'ErrorMsg',
 15 | 			[severity.HINT] = 'MoreMsg',
 16 | 			[severity.INFO] = 'InfoMsg',
 17 | 		},
 18 | 	}
 19 | 
 20 | 	local config = {
 21 | 		-- disable virtual text
 22 | 		virtual_text = false,
 23 | 		-- show signs
 24 | 		signs = signs,
 25 | 		update_in_insert = true,
 26 | 		underline = true,
 27 | 		severity_sort = true,
 28 | 		float = {
 29 | 			focusable = true,
 30 | 			style = "minimal",
 31 | 			border = "rounded",
 32 | 			source = "always",
 33 | 			header = "",
 34 | 			prefix = "",
 35 | 		},
 36 | 	}
 37 | 
 38 | 	vim.diagnostic.config(config)
 39 | end
 40 | 
 41 | local function lsp_highlight_document(client)
 42 | 	-- Set autocommands conditional on server_capabilities
 43 | 	if client.server_capabilities.document_highlight then
 44 | 
 45 | 		vim.api.nvim_create_augroup("lsp_document_highlight", { clear = true })
 46 | 		vim.api.nvim_clear_autocmds({ group = "lsp_document_highlight", buffer = 0 })
 47 | 
 48 | 		vim.api.nvim_create_autocmd("CursorHold", {
 49 | 			group = "lsp_document_highlight",
 50 | 			buffer = 0,
 51 | 			callback = function()
 52 | 				print("Highlighting document")
 53 | 				vim.lsp.buf.document_highlight()
 54 | 			end,
 55 | 		})
 56 | 
 57 | 		vim.api.nvim_create_autocmd("CursorMoved", {
 58 | 			group = "lsp_document_highlight",
 59 | 			buffer = 0,
 60 | 			callback = function()
 61 | 				print("Clearing highlights")
 62 | 				vim.lsp.buf.clear_references()
 63 | 			end,
 64 | 		})
 65 |  	end
 66 | 
 67 | 	local illuminate = require("illuminate")
 68 | 	illuminate.on_attach(client)
 69 | end
 70 | 
 71 | --- @param options vim.lsp.LocationOpts
 72 | local function filter_duplicates(options)
 73 | 	local seen = {}
 74 | 	local filtered = {}
 75 | 
 76 | 	for _, item in ipairs(options.items) do
 77 | 		local key = item.filename .. ":" .. item.user_data.range.start.line .. ":" .. item.user_data.range.start.character
 78 | 		if not seen[key] then
 79 | 			table.insert(filtered, item)
 80 | 			seen[key] = true
 81 | 		end
 82 | 	end
 83 | 
 84 | 	options.items = filtered
 85 | 	vim.fn.setqflist({}, ' ', options)
 86 | 	vim.cmd.cfirst()
 87 | end
 88 | 
 89 | local function lsp_keymaps(bufnr)
 90 | 	local opts = { noremap = true, silent = true, buffer = bufnr }
 91 | 	local keymap = vim.keymap.set
 92 | 	keymap("n", "gD", vim.lsp.buf.declaration, opts)
 93 | 	keymap("n", "gd", function(_) vim.lsp.buf.definition({on_list=filter_duplicates}) end, opts)
 94 | 
 95 | 	keymap("n", "K", require('pretty_hover').hover, opts)
 96 | 	keymap("n", "gi", vim.lsp.buf.implementation, opts)
 97 | 	keymap("n", "<M-k>",vim.lsp.buf.signature_help, opts)
 98 | 	keymap("n", "<leader>rn", vim.lsp.buf.rename, opts)
 99 | 	keymap("n", "gr", vim.lsp.buf.references, opts)
100 | 	keymap("n", "<leader>ca", vim.lsp.buf.code_action, opts)
101 | 	keymap("n", "<leader>qf", function(_) vim.lsp.buf.code_action({only="quickfix"}) end, opts)
102 | 	keymap("n", "[d", function(_) vim.diagnostic.jump({ count=-1, float = true }) end, opts)
103 | 	keymap("n", "<leader>ih", function(_) vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled()) end, opts)
104 | 	keymap("n", "gl", function(_) vim.diagnostic.open_float(nil, {focus=false}) end, opts)
105 | 	keymap("n", "]d", function(_) vim.diagnostic.jump({ count=1, float = true }) end, opts)
106 | 	keymap("n", "<M-d>", vim.diagnostic.setloclist, opts)
107 | 	-- vim.cmd [[ command! Format execute 'lua vim.lsp.buf.format({ async = true })' ]]
108 | 	--[[ vim.api.nvim_buf_set_keymap(bufnr, "n", "<leader>fo", "<cmd>Format<CR>", opts) ]]
109 | end
110 | 
111 | function M.reload_buf_lsp_servers()
112 | 	local bufnr = vim.api.nvim_get_current_buf()
113 | 	local clients = vim.lsp.get_clients({ bufnr = bufnr })
114 | 	local client_names = {}
115 | 
116 | 	for _, client in pairs(clients) do
117 | 		table.insert(client_names, client.config.name)
118 | 		client:stop()
119 | 	end
120 | 
121 | 	vim.defer_fn(function()
122 | 		for _, name in pairs(client_names) do
123 | 			local config = vim.lsp.config[name]
124 | 			if not config then
125 | 				goto continue
126 | 			end
127 | 
128 | 			vim.lsp.start(config)
129 | 			::continue::
130 | 		end
131 | 	end, 200)
132 | end
133 | 
134 | function M.on_attach(client, bufnr)
135 | 	if client.name == "tsserver" then -- or client.name == "jdt.ls" then
136 | 		client.server_capabilities.document_formatting = false
137 | 	end
138 | 	if client.name == "clangd" then
139 | 		client.server_capabilities.document_formatting = false
140 | 	end
141 | 
142 | 	vim.api.nvim_create_user_command("LspBufReload", M.reload_buf_lsp_servers, { desc = "Reload LSP servers for current buffer" })
143 | 
144 | 	-- if client.name == "jdt.ls" then
145 | 	--	require("jdtls").setup_dap { hotcoderpalce = "auto" }
146 | 	--	require("jdtls.dap").setup_dap_main_class_configs();
147 | 	-- end
148 | 	-- vim.print("LSP client attached: " .. client.name)
149 | 	lsp_keymaps(bufnr)
150 | 	lsp_highlight_document(client)
151 | end
152 | 
153 | local capabilities = vim.lsp.protocol.make_client_capabilities()
154 | capabilities.textDocument.completion.completionItem.snippetSupport = true;
155 | 
156 | local cmp_nvim_lsp = require("cmp_nvim_lsp")
157 | 
158 | M.capabilities = cmp_nvim_lsp.default_capabilities(capabilities)
159 | 
160 | return M
161 | 
162 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/settings/jsonls.lua:
--------------------------------------------------------------------------------
  1 | -- Find more schemas here: https://www.schemastore.org/json/
  2 | local schemas = {
  3 | 	{
  4 | 	description = "TypeScript compiler configuration file",
  5 | 	fileMatch = {
  6 | 		"tsconfig.json",
  7 | 		"tsconfig.*.json",
  8 | 	},
  9 | 	url = "https://json.schemastore.org/tsconfig.json",
 10 | 	},
 11 | 	{
 12 | 	description = "Lerna config",
 13 | 	fileMatch = { "lerna.json" },
 14 | 	url = "https://json.schemastore.org/lerna.json",
 15 | 	},
 16 | 	{
 17 | 	description = "Babel configuration",
 18 | 	fileMatch = {
 19 | 		".babelrc.json",
 20 | 		".babelrc",
 21 | 		"babel.config.json",
 22 | 	},
 23 | 	url = "https://json.schemastore.org/babelrc.json",
 24 | 	},
 25 | 	{
 26 | 	description = "ESLint config",
 27 | 	fileMatch = {
 28 | 		".eslintrc.json",
 29 | 		".eslintrc",
 30 | 	},
 31 | 	url = "https://json.schemastore.org/eslintrc.json",
 32 | 	},
 33 | 	{
 34 | 	description = "Bucklescript config",
 35 | 	fileMatch = { "bsconfig.json" },
 36 | 	url = "https://raw.githubusercontent.com/rescript-lang/rescript-compiler/8.2.0/docs/docson/build-schema.json",
 37 | 	},
 38 | 	{
 39 | 	description = "Prettier config",
 40 | 	fileMatch = {
 41 | 		".prettierrc",
 42 | 		".prettierrc.json",
 43 | 		"prettier.config.json",
 44 | 	},
 45 | 	url = "https://json.schemastore.org/prettierrc",
 46 | 	},
 47 | 	{
 48 | 	description = "Vercel Now config",
 49 | 	fileMatch = { "now.json" },
 50 | 	url = "https://json.schemastore.org/now",
 51 | 	},
 52 | 	{
 53 | 	description = "Stylelint config",
 54 | 	fileMatch = {
 55 | 		".stylelintrc",
 56 | 		".stylelintrc.json",
 57 | 		"stylelint.config.json",
 58 | 	},
 59 | 	url = "https://json.schemastore.org/stylelintrc",
 60 | 	},
 61 | 	{
 62 | 	description = "A JSON schema for the ASP.NET LaunchSettings.json files",
 63 | 	fileMatch = { "launchsettings.json" },
 64 | 	url = "https://json.schemastore.org/launchsettings.json",
 65 | 	},
 66 | 	{
 67 | 	description = "Schema for CMake Presets",
 68 | 	fileMatch = {
 69 | 		"CMakePresets.json",
 70 | 		"CMakeUserPresets.json",
 71 | 	},
 72 | 	url = "https://raw.githubusercontent.com/Kitware/CMake/master/Help/manual/presets/schema.json",
 73 | 	},
 74 | 	{
 75 | 	description = "Configuration file as an alternative for configuring your repository in the settings page.",
 76 | 	fileMatch = {
 77 | 		".codeclimate.json",
 78 | 	},
 79 | 	url = "https://json.schemastore.org/codeclimate.json",
 80 | 	},
 81 | 	{
 82 | 	description = "LLVM compilation database",
 83 | 	fileMatch = {
 84 | 		"compile_commands.json",
 85 | 	},
 86 | 	url = "https://json.schemastore.org/compile-commands.json",
 87 | 	},
 88 | 	{
 89 | 	description = "Config file for Command Task Runner",
 90 | 	fileMatch = {
 91 | 		"commands.json",
 92 | 	},
 93 | 	url = "https://json.schemastore.org/commands.json",
 94 | 	},
 95 | 	{
 96 | 	description = "AWS CloudFormation provides a common language for you to describe and provision all the infrastructure resources in your cloud environment.",
 97 | 	fileMatch = {
 98 | 		"*.cf.json",
 99 | 		"cloudformation.json",
100 | 	},
101 | 	url = "https://raw.githubusercontent.com/awslabs/goformation/v5.2.9/schema/cloudformation.schema.json",
102 | 	},
103 | 	{
104 | 	description = "The AWS Serverless Application Model (AWS SAM, previously known as Project Flourish) extends AWS CloudFormation to provide a simplified way of defining the Amazon API Gateway APIs, AWS Lambda functions, and Amazon DynamoDB tables needed by your serverless application.",
105 | 	fileMatch = {
106 | 		"serverless.template",
107 | 		"*.sam.json",
108 | 		"sam.json",
109 | 	},
110 | 	url = "https://raw.githubusercontent.com/awslabs/goformation/v5.2.9/schema/sam.schema.json",
111 | 	},
112 | 	{
113 | 	description = "Json schema for properties json file for a GitHub Workflow template",
114 | 	fileMatch = {
115 | 		".github/workflow-templates/**.properties.json",
116 | 	},
117 | 	url = "https://json.schemastore.org/github-workflow-template-properties.json",
118 | 	},
119 | 	{
120 | 	description = "golangci-lint configuration file",
121 | 	fileMatch = {
122 | 		".golangci.toml",
123 | 		".golangci.json",
124 | 	},
125 | 	url = "https://json.schemastore.org/golangci-lint.json",
126 | 	},
127 | 	{
128 | 	description = "JSON schema for the JSON Feed format",
129 | 	fileMatch = {
130 | 		"feed.json",
131 | 	},
132 | 	url = "https://json.schemastore.org/feed.json",
133 | 	versions = {
134 | 		["1"] = "https://json.schemastore.org/feed-1.json",
135 | 		["1.1"] = "https://json.schemastore.org/feed.json",
136 | 	},
137 | 	},
138 | 	{
139 | 	description = "Packer template JSON configuration",
140 | 	fileMatch = {
141 | 		"packer.json",
142 | 	},
143 | 	url = "https://json.schemastore.org/packer.json",
144 | 	},
145 | 	{
146 | 	description = "NPM configuration file",
147 | 	fileMatch = {
148 | 		"package.json",
149 | 	},
150 | 	url = "https://json.schemastore.org/package.json",
151 | 	},
152 | 	{
153 | 	description = "JSON schema for Visual Studio component configuration files",
154 | 	fileMatch = {
155 | 		"*.vsconfig",
156 | 	},
157 | 	url = "https://json.schemastore.org/vsconfig.json",
158 | 	},
159 | 	{
160 | 	description = "Resume json",
161 | 	fileMatch = { "resume.json" },
162 | 	url = "https://raw.githubusercontent.com/jsonresume/resume-schema/v1.0.0/schema.json",
163 | 	},
164 | }
165 | 
166 | local opts = {
167 | 	settings = {
168 | 	json = {
169 | 		schemas = schemas,
170 | 	},
171 | 	},
172 | 	setup = {
173 | 	commands = {
174 | 		Format = {
175 | 			function()
176 | 				vim.lsp.buf.range_formatting({}, { 0, 0 }, { vim.fn.line "$", 0 })
177 | 			end,
178 | 		},
179 | 	},
180 | 	},
181 | }
182 | 
183 | return opts
184 | 


--------------------------------------------------------------------------------
/lua/usr/navigation/neotree.lua:
--------------------------------------------------------------------------------
  1 | local icons = require("usr.core.icons")
  2 | local ok, neotree = pcall(require, "neo-tree")
  3 | if not ok then
  4 | 	print("Neotree not found")
  5 | 	return
  6 | end
  7 | 
  8 | neotree.setup({
  9 | 	popup_border_style = "rounded",
 10 | 	source_selector = {
 11 | 		winbar = false, -- toggle to show selector on winbar
 12 | 		statusline = false, -- toggle to show selector on statusline
 13 | 		show_scrolled_off_parent_node = false,
 14 | 		sources = {
 15 | 			{
 16 | 				source = "filesystem",
 17 | 				display_name = " 󰉓 Files ",
 18 | 			},
 19 | 			{
 20 | 				source = "buffers",
 21 | 				display_name = " 󰈚 Buffers ",
 22 | 			},
 23 | 			{
 24 | 				source = "git_status",
 25 | 				display_name = " 󰊢 Git ",
 26 | 			},
 27 | 		},
 28 | 		content_layout = "start",
 29 | 		tabs_layout = "equal",
 30 | 		truncation_character = "…",
 31 | 		tabs_min_width = nil,
 32 | 		tabs_max_width = nil,
 33 | 		padding = 0, -- int | { left: int, right: int }
 34 | 		separator = { left = "▏", right= "▕" }, -- string | { left: string, right: string, override: string | nil }
 35 | 		separator_active = nil, -- string | { left: string, right: string, override: string | nil } | nil
 36 | 		show_separator_on_edge = false,
 37 | 		highlight_tab = "NeoTreeTabInactive",
 38 | 		highlight_tab_active = "NeoTreeTabActive",
 39 | 		highlight_background = "NeoTreeTabInactive",
 40 | 		highlight_separator = "NeoTreeTabSeparatorInactive",
 41 | 		highlight_separator_active = "NeoTreeTabSeparatorActive",
 42 | 	},
 43 | 	commands = {
 44 | 		system_open = function(state)
 45 | 			local node = state.tree:get_node()
 46 | 			local path = node:get_id()
 47 | 			vim.ui.open(path)
 48 | 		end,
 49 | 		set_to_middle = function(state)
 50 | 			-- Redraw, line [count] at center of window (default
 51 | 			-- cursor line). Leave the cursor in the same column.
 52 | 			vim.cmd("normal! zz")
 53 | 		end,
 54 | 		execute = function(state)
 55 | 			local node = state.tree:get_node()
 56 | 			local path = node:get_id()
 57 | 			vim.cmd("! " .. path)
 58 | 		end,
 59 | 		copy_name = function(state)
 60 | 			-- NeoTree is based on [NuiTree](https://github.com/MunifTanjim/nui.nvim/tree/main/lua/nui/tree)
 61 | 			-- The node is based on [NuiNode](https://github.com/MunifTanjim/nui.nvim/tree/main/lua/nui/tree#nuitreenode)
 62 | 			local node = state.tree:get_node()
 63 | 			local filepath = node:get_id()
 64 | 			local filename = node.name
 65 | 			local modify = vim.fn.fnamemodify
 66 | 
 67 | 			local results = {
 68 | 				filepath,
 69 | 				modify(filepath, ':.'),
 70 | 				modify(filepath, ':~'),
 71 | 				filename,
 72 | 				modify(filename, ':r'),
 73 | 				modify(filename, ':e'),
 74 | 			}
 75 | 
 76 | 			-- absolute path to clipboard
 77 | 			local i = vim.fn.inputlist({
 78 | 				'Choose to copy to clipboard:',
 79 | 				'1. Absolute path: ' .. results[1],
 80 | 				'2. Path relative to CWD: ' .. results[2],
 81 | 				'3. Path relative to HOME: ' .. results[3],
 82 | 				'4. Filename: ' .. results[4],
 83 | 				'5. Filename without extension: ' .. results[5],
 84 | 				'6. Extension of the filename: ' .. results[6],
 85 | 			})
 86 | 
 87 | 			if i > 0 then
 88 | 				local result = results[i]
 89 | 				if not result then return print('Invalid choice: ' .. i) end
 90 | 				vim.fn.setreg('+', result)
 91 | 			end
 92 | 		end,
 93 | 	},
 94 | 	filesystem ={
 95 | 		hijack_netrw_behavior = "open_current",
 96 | 		group_empty_dirs = true,
 97 | 		window = {
 98 | 			mappings = {
 99 | 				["."] = "set_root",
100 | 				["/"] = "",
101 | 				["E"] = "execute",
102 | 				["Y"] = "copy_name",
103 | 				["h"] = "close_node",
104 | 				["l"] = "open",
105 | 				["m"] = "move",
106 | 				["s"] = "system_open",
107 | 				["x"] = "cut_to_clipboard",
108 | 				["z"] = "set_to_middle",
109 | 			},
110 | 			-- define keymaps for filter popup window in fuzzy_finder_mode
111 | 			fuzzy_finder_mappings = {
112 | 				["<C-j>"] = "move_cursor_down",
113 | 				["<C-k>"] = "move_cursor_up",
114 | 			}
115 | 		},
116 | 	},
117 | 	buffers = {
118 | 		follow_current_file = {
119 | 			-- This will find and focus the file in the active buffer every time
120 | 			-- the current file is changed while the tree is open.
121 | 			enabled = true,
122 | 			-- `false` closes auto expanded dirs, such as with `:Neotree reveal`
123 | 			leave_dirs_open = false,
124 | 		},
125 | 		-- when true, empty folders will be grouped together
126 | 		group_empty_dirs = true,
127 | 		show_unloaded = true,
128 | 		window = {
129 | 			mappings = {
130 | 				["d"] = "buffer_delete",
131 | 				["h"] = "navigate_up",
132 | 				["."] = "set_root",
133 | 				["o"] = { "show_help", nowait=false, config = { title = "Order by", prefix_key = "o" }},
134 | 				["l"] = "open",
135 | 			}
136 | 		},
137 | 	},
138 | 	git_status = {
139 | 		window = {
140 | 			position = "float",
141 | 			mappings = {
142 | 				["l"] = "open",
143 | 				["."] = "set_root",
144 | 			},
145 | 		}
146 | 	},
147 | 	default_component_configs = {
148 | 		diagnostics = {
149 | 			simbols = {
150 | 				hint = icons.diagnostics.Hint,
151 | 				info = icons.diagnostics.Information,
152 | 				warn = icons.diagnostics.Warning,
153 | 				error = icons.diagnostics.Error,
154 | 			},
155 | 		},
156 | 		icon = {
157 | 			folder_closed = icons.documents.FullFolder,
158 | 			folder_open = icons.documents.OpenFolder,
159 | 			folder_empty = icons.documents.EmptyFolder,
160 | 			folder_empty_open = icons.documents.OpenFullFolder,
161 | 		},
162 | 		modified = {
163 | 			symbol = icons.ui.BigCircle
164 | 		},
165 | 		git_status = {
166 | 			symbols = {
167 | 				added = icons.git.Add,
168 | 				deleted = icons.git.Deleted,
169 | 				modified = icons.git.Mod,
170 | 				renamed = icons.git.Renamed,
171 | 				untracked = icons.git.Untracked,
172 | 				ignored = icons.git.Ignored,
173 | 				unstaged = icons.git.Unstaged,
174 | 				conflict = icons.git.Diff,
175 | 			},
176 | 			align = "left",
177 | 		},
178 | 	},
179 | 	window = {
180 | 		popup = {
181 | 			popup_border_style = "rounded",
182 | 		}
183 | 	},
184 | })
185 | 
186 | 


--------------------------------------------------------------------------------
/ftplugin/cpp.lua:
--------------------------------------------------------------------------------
  1 | local status_ok, ts_utils = pcall(require, "nvim-treesitter.ts_utils")
  2 | if not status_ok then
  3 | 	return
  4 | end
  5 | ----------------------
  6 | -- HELPER FUNCTIONS --
  7 | ----------------------
  8 | 
  9 | --- Checks if the file with name 'name' exists.
 10 | ---@param name string File name.
 11 | ---@return boolean Wether the file exists.
 12 | local function fileExists(name)
 13 | 	local f=io.open(name,"r")
 14 | 	if f~=nil then io.close(f) return true else return false end
 15 | end
 16 | 
 17 | 
 18 | 
 19 | 
 20 | 
 21 | 
 22 | 
 23 | 
 24 | -----------------------------------
 25 | -- CORE FUNCTION FOR DEFINITIONS --
 26 | -----------------------------------
 27 | 
 28 | -- Creates definition in the source file. Takes care of class scope (if it is a function no scope),
 29 | -- default parameters and catches the method / function on multiple lines.
 30 | --
 31 | ---@param promptForSourceFile	boolean Wether to prompt the user for source file.
 32 | local function createDefinition(promptForSourceFile)
 33 | 	local headerFile = vim.api.nvim_buf_get_name(0)
 34 | 	local sourceFile = ""
 35 | 
 36 | 	if string.sub(headerFile, -1) == "h" then
 37 | 		sourceFile = string.gsub(headerFile, "[.]%w$","")
 38 | 	else
 39 | 		sourceFile = string.gsub(headerFile, "[.]%w%w%w$", "")
 40 | 	end
 41 | 	sourceFile = sourceFile .. ".cpp"
 42 | 
 43 | 	if promptForSourceFile then
 44 | 		sourceFile = vim.fn.input("Source file", headerFile)
 45 | 	end
 46 | 
 47 | 	local current_node = ts_utils.get_node_at_cursor()
 48 | 
 49 | 	local function_info = nil
 50 | 	local parts = {}
 51 | 
 52 | 	while current_node ~= nil do
 53 | 		local type = current_node:type()
 54 | 		if (type == 'field_declaration' or type == 'function_definition' or type == 'declaration') and not function_info then
 55 | 			function_info = { return_type = '', declaration = nil }
 56 | 			for node, name in current_node:iter_children() do
 57 | 				if node:named() then
 58 | 					if name == 'type' then
 59 | 						function_info.return_type = vim.treesitter.get_node_text(node, 0)
 60 | 					elseif name == 'declarator' then
 61 | 						function_info.declaration = vim.treesitter.get_node_text(node, 0)
 62 | 					end
 63 | 				end
 64 | 			end
 65 | 		elseif type == 'struct_specifier' or type == 'class_specifier' or type == 'namespace_definition' then
 66 | 			if not function_info then
 67 | 				-- no function found
 68 | 				return ''
 69 | 			end
 70 | 			for node, name in current_node:iter_children() do
 71 | 				if node:named() then
 72 | 					if name == 'name' then
 73 | 						table.insert(parts, 1, vim.treesitter.get_node_text(node, 0))
 74 | 					end
 75 | 				end
 76 | 			end
 77 | 		end
 78 | 		current_node = current_node:parent()
 79 | 	end
 80 | 
 81 | 	if not function_info then
 82 | 		return ''
 83 | 	end
 84 | 	-- is not the destructor and the return type is a pointer of a reference
 85 | 	local found, _, prefix, name = function_info.declaration:find('^(%W+)%s*(%w.*)')
 86 | 	if found and prefix ~= '~' then
 87 | 		function_info.return_type = function_info.return_type .. prefix
 88 | 		function_info.declaration = name
 89 | 	end
 90 | 
 91 | 	local specifier = table.concat(parts, '::')
 92 | 
 93 | 	if specifier:len() > 0 then
 94 | 		specifier = specifier .. '::' .. function_info.declaration
 95 | 	else
 96 | 		specifier = function_info.declaration
 97 | 	end
 98 | 
 99 | 	if function_info.return_type:len() > 0 then
100 | 		function_info.return_type = function_info.return_type .. ' '
101 | 	end
102 | 
103 | 	local def = string.format("%s%s", function_info.return_type, specifier)
104 | 
105 | 	if def:find(" = (.+),") then
106 | 		def = def:gsub(" = (.+),", ",")
107 | 	end
108 | 
109 | 	if def:find(" = (.+)[)]") then
110 | 		def = def:gsub(" = (.+)[)]", ")")
111 | 	end
112 | 
113 | 	-- remove override and multiple spaces
114 | 	def = def:gsub("^(.+)%)(.*)override(.*)", "%1)%2 %3"):gsub("%s+", " ")
115 | 
116 | 	local definition = { "", def, "{", "", "}" }
117 | 	local source_buf_nr = vim.fn.bufnr(sourceFile)
118 | 	if source_buf_nr == -1 then
119 | 		vim.cmd("edit " .. sourceFile)
120 | 		source_buf_nr = vim.fn.bufnr(sourceFile)
121 | 	end
122 | 
123 | 	vim.fn.bufload(source_buf_nr)
124 | 	vim.fn.appendbufline(source_buf_nr, "$", definition)
125 | end
126 | 
127 | 
128 | 
129 | 
130 | 
131 | 
132 | 
133 | ----------------------
134 | -- MAPPED FUNCTIONS --
135 | ----------------------
136 | 
137 | --- Open qt-5 documentation about the word under cursor.
138 | function QtQuerryFinder()
139 | 	local address = "https://doc.qt.io/qt-5/" .. vim.fn.expand("<cword>"):lower() .. ".html"
140 | 	vim.cmd(":!open " .. address .. " 2> /dev/null &")
141 | end
142 | 
143 | --- Create Method declaration in source file. Class name is deduced from treesitter.
144 | -- The method or function can be declared on multiple lines.
145 | -- Default parameters are removed.
146 | --
147 | ---@param sourceFilePrompt boolean Wether to ask for a source file name.
148 | function CreateClassMethodDefinition(sourceFilePrompt)
149 | 	createDefinition(sourceFilePrompt)
150 | end
151 | 
152 | local function switch_source_header(bufnr)
153 | 	local method_name = 'textDocument/switchSourceHeader'
154 | 	local client = vim.lsp.get_clients({ bufnr = bufnr, name = 'clangd' })[1]
155 | 	if not client then
156 | 		return vim.notify(('method %s is not supported by any servers active on the current buffer'):format(method_name))
157 | 	end
158 | 	local params = vim.lsp.util.make_text_document_params(bufnr)
159 | 	client:request(method_name, params, function(err, result)
160 | 		if err then
161 | 			error(tostring(err))
162 | 		end
163 | 		if not result then
164 | 			vim.notify('corresponding file cannot be determined')
165 | 			return
166 | 		end
167 | 		vim.cmd.edit(vim.uri_to_fname(result))
168 | 	end, bufnr)
169 | end
170 | 
171 | vim.api.nvim_buf_create_user_command(0, 'LspClangdSwitchSourceHeader', function()
172 | 	switch_source_header(0)
173 | end, { desc = 'Switch between source/header' })
174 | 
175 | ------------------------------
176 | -- OPTIONS FOR KEY MAPPINGS --
177 | ------------------------------
178 | 
179 | local opts = { noremap = true, silent = true }
180 | -- local term_opts = { silent = true }
181 | 
182 | local keymap = vim.keymap.set
183 | 
184 | keymap("n", "<leader>sh", "<cmd>LspClangdSwitchSourceHeader<CR>", opts)
185 | keymap("n", "<F2>", QtQuerryFinder, opts)
186 | keymap("n", "<leader>md", ":lua CreateClassMethodDefinition()<CR>", opts)
187 | keymap("n", "<leader>fo", ":! clang-format -i --style=file:.clang-format %<CR>", opts)
188 | keymap('n', "<leader>cc", require("clang_reloader").reload, opts)
189 | 
190 | 


--------------------------------------------------------------------------------
/lua/usr/core/keymaps.lua:
--------------------------------------------------------------------------------
  1 | local opts = { noremap = true, silent = true }
  2 | 
  3 | local term_opts = { silent = true }
  4 | 
  5 | local keymap = vim.keymap.set
  6 | 
  7 | -- MODES
  8 | --			normal - n
  9 | --			insert - i
 10 | --			visual - v
 11 | --			visual_block - x
 12 | --			terminal - t
 13 | --			command - c
 14 | 
 15 | --	NORMAL	--
 16 | 
 17 | -- Reload init.lua
 18 | vim.keymap.set("n", "<leader><cr>", function ()
 19 | 	for name,_ in pairs(package.loaded) do
 20 | 		if name:match('^usr') then
 21 | 			package.loaded[name] = nil
 22 | 		end
 23 | 	end
 24 | 
 25 | 	dofile(vim.env.MYVIMRC)
 26 | 	vim.notify("Nvim configuration reloaded!", vim.log.levels.INFO)
 27 | end)
 28 | 
 29 | local function run_searchable_command()
 30 | 	vim.ui.input({prompt = "Command: "}, function(input)
 31 | 		if input then
 32 | 			local cmd = "enew|pu=execute('" .. input .. "')"
 33 | 			vim.print(cmd)
 34 | 			vim.cmd(cmd)
 35 | 		end
 36 | 	end)
 37 | end
 38 | 
 39 | -- init.lua edditink
 40 | keymap("n", "<leader>sc", ":e ~/.config/nvim/init.lua<CR>", opts)
 41 | keymap("n", "<leader>m", ":new<CR>:put =execute('messages')<CR>", opts)
 42 | keymap("n", "<leader>mc", run_searchable_command, opts)
 43 | 
 44 | -- buildProject CUSTOMS --
 45 | keymap("n", "<F2>", ":term cmake -S . -B ./build && mv ./build/compile_commands.json .<CR>", opts)
 46 | keymap("n", "<leader>s", ":set spell!<CR>", term_opts)
 47 | keymap("n", "<F5>", ":term ./compile<CR>", term_opts)
 48 | keymap("n", "<F6>", ":term ./run<CR>", term_opts)
 49 | keymap("n", "<C-F8>", ":split <bar> term ./build.sh<CR>", term_opts)
 50 | 
 51 | keymap("n", "<leader>vs", ":split<CR>", opts)
 52 | keymap("n", "<leader>hs", ":vsplit<CR>", opts)
 53 | 
 54 | -- open new file
 55 | keymap("n", "gf", ":e <cfile><CR>", opts)
 56 | 
 57 | -- substitute spaces for tabs
 58 | keymap("n", "<leader>4s", ":%s/    /<TAB>/g<CR>:set shiftwidth=4<CR>:set tabstop=4<CR>:set noexpandtab<CR>/asdfsaf<CR>/<CR>", opts)
 59 | keymap("n", "<leader>2s", ":%s/  /<TAB>/g<CR>:set shiftwidth=4<CR>:set tabstop=4<CR>:set noexpandtab<CR>/asdfsaf<CR>/<CR>", opts)
 60 | 
 61 | keymap("n", "<leader>lg", require("usr.toggleterm").lazygit, opts)
 62 | keymap({"n", "t"}, "<C-p>y", require("usr.toggleterm").python, opts)
 63 | keymap({"n", "t"}, "<C-M-h>", require("usr.toggleterm").htop, opts)
 64 | 
 65 | -- TELESCOPE --
 66 | keymap("n", "<leader>fb", require("telescope.builtin").buffers, opts)
 67 | keymap("n", "<leader>fc", require("telescope.builtin").current_buffer_fuzzy_find, opts)
 68 | keymap("n", "<leader>fd", require("telescope.builtin").diagnostics, opts)
 69 | keymap("n", "<leader>ff", require("telescope.builtin").find_files, opts)
 70 | keymap("n", "<leader>fg", require("telescope.builtin").live_grep, opts)
 71 | keymap("n", "<leader>fh", require("telescope.builtin").help_tags, opts)
 72 | keymap("n", "<leader>fr", require("telescope.builtin").lsp_references, opts)
 73 | keymap("n", "<leader>fs", require("telescope.builtin").grep_string, opts)
 74 | keymap("n", "<leader>of", require("telescope.builtin").oldfiles, opts)
 75 | keymap("n", "<leader>re", require("telescope.builtin").resume, opts)
 76 | keymap("n", "<leader>pr", require("telescope").extensions.projects.projects, opts)
 77 | 
 78 | -- telescope git commands
 79 | keymap("n", "<leader>gb", require("telescope.builtin").git_branches, opts)
 80 | keymap("n", "<leader>gc", require("telescope.builtin").git_commits, opts)
 81 | keymap("n", "<leader>gs", require("telescope.builtin").git_status, opts)
 82 | 
 83 | -- SAVING --
 84 | keymap("n", "<leader>w", ":w<CR>", opts)
 85 | keymap("n", "<leader>wq", ":wq<CR>", opts)
 86 | keymap("n", "<leader>qq", ":q<CR>", opts)
 87 | keymap("n", "<leader>bw", ":w <bar> :Bdelete! %d <CR>", opts) -- buffer writing
 88 | keymap("n", "<leader>bd", ":bd<CR>", opts) -- buffer delete force
 89 | keymap("n", "<leader>bD", ":Bdelete!<CR>", opts) -- buffer delete force
 90 | keymap("n", "<leader>lf", require('revolver').OpenSavedFiles, opts)
 91 | 
 92 | -- Resize with arrows
 93 | keymap("n", "<M-UP>", ":resize -2<CR>", opts)
 94 | keymap("n", "<M-DOWN>", ":resize +2<CR>", opts)
 95 | keymap("n", "<M-LEFT>", ":vertical resize -2<CR>", opts)
 96 | keymap("n", "<M-RIGHT>", ":vertical resize +2<CR>", opts)
 97 | 
 98 | --	NAVIGATE WINDOWS	--
 99 | keymap("n", "<C-k>", "<C-w>k", opts)
100 | keymap("n", "<C-j>", "<C-w>j", opts)
101 | keymap("n", "<C-h>", "<C-w>h", opts)
102 | keymap("n", "<C-l>", "<C-w>l", opts)
103 | keymap("n", "<leader>db", require('dropbar.api').pick, opts)
104 | 
105 | -- MARKDOWN PREVIEW
106 | keymap("n", "mpn", ":MarkdownPreview<CR>", opts)
107 | keymap("n", "mpf", ":MarkdownPreviewStop<CR>", opts)
108 | 
109 | -- NAVIGATE BUFFERS --
110 | keymap("n", "<S-h>", ":BufferLineCyclePrev<CR>", opts)
111 | keymap("n", "<S-l>", ":BufferLineCycleNext<CR>", opts)
112 | keymap("n", "<C-[>", ":BufferLineMovePrev<CR>", opts)
113 | keymap("n", "<C-]>", ":BufferLineMoveNext<CR>", opts)
114 | 
115 | -- MOVE TEXT UP & DOWN
116 | keymap("n", "<C-S-j>", ":move '<-2<CR>", opts)
117 | keymap("n", "<C-S-k>", ":move '>+1<CR>", opts)
118 | 
119 | -- NEOGEN
120 | keymap("n", "<leader>nc", function () require('neogen').generate({ type = 'class'}) end, opts)
121 | keymap("n", "<leader>nf", function () require('neogen').generate({ type = 'func'}) end, opts)
122 | keymap("n", "<leader>nt", function () require('neogen').generate({ type = 'type'}) end, opts)
123 | keymap("n", "<leader>ni", function () require('neogen').generate({ type = 'file'}) end, opts)
124 | 
125 | keymap("n", "<leader>tr", "<cmd>Trouble<cr>", opts)
126 | keymap("n", "<leader>twd", "<cmd>Trouble workspace_diagnostics<cr>", opts)
127 | keymap("n", "<leader>tdd", "<cmd>Trouble document_diagnostics<cr>", opts)
128 | keymap("n", "<leader>tl", "<cmd>Trouble loclist<cr>", opts)
129 | keymap("n", "<leader>tq", "<cmd>Trouble quickfix<cr>", opts)
130 | keymap("n", "gR", "<cmd>Trouble lsp_references<cr>", opts)
131 | 
132 | -- fold methods
133 | keymap("n", "<leader>fm", "v%zf", opts)
134 | 
135 | -- Press jk fast to enter
136 | keymap("i", "jj", "<ESC>:w<CR>", opts)
137 | keymap("i", "jk", "<ESC>", opts)
138 | 
139 | -- Visual --
140 | local visual_opts = {noremap = true, silent = true, expr = false}
141 | keymap("v", "<leader>y", '"+y', visual_opts)
142 | 
143 | -- Stay in indent mode
144 | keymap("v", "<", "<gv", opts)
145 | keymap("v", ">", ">gv", opts)
146 | 
147 | -- Visual Block --
148 | keymap("v", "p", '"_dP', opts)
149 | keymap("v", "P", '"_dp', opts)
150 | 
151 | -- Move text up and down
152 | keymap("x", "J", ":move '>+1<CR>gv-gv", opts)
153 | keymap("x", "K", ":move '<-2<CR>gv-gv", opts)
154 | 
155 | -- NeoTree
156 | keymap("n", "<leader>e", ":Neotree position=left filesystem reveal toggle<cr>", opts)
157 | -- keymap("n", "<leader>e", ":Lex 15<CR>", opts)
158 | 
159 | keymap({"n", "v"}, "<leader>co", ":CopilotChat<CR>", opts)
160 | keymap("n", "<leader>cp", ":CccPick<CR>", opts)
161 | 
162 | vim.cmd[[
163 | 	augroup twig_ft
164 | 		au!
165 | 		autocmd BufNewFile,BufRead *.bbappend   set syntax=bitbake
166 | 		autocmd BufNewFile,BufRead *.bb   set syntax=bitbake
167 | 	augroup END
168 | ]]
169 | 
170 | keymap("n", "<ESC>", "", opts)
171 | 


--------------------------------------------------------------------------------
/lua/usr/plugins/init.lua:
--------------------------------------------------------------------------------
  1 | -- TODO: https://github.com/nosduco/remote-sshfs.nvim
  2 | return {
  3 | 	{
  4 | 		"jbyuki/one-small-step-for-vimkind",
  5 | 		lazy = true,
  6 | 	},
  7 | 	-- NVIM DOCS
  8 | 	{
  9 | 		"folke/lazydev.nvim",
 10 | 		ft = "lua", -- only load on lua files
 11 | 		opts = {
 12 | 			library = {
 13 | 					 -- Library paths can be absolute
 14 | 				"~/projects/my-awesome-lib",
 15 | 				-- Or relative, which means they will be resolved from the plugin dir.
 16 | 				"lazy.nvim",
 17 | 				-- It can also be a table with trigger words / mods
 18 | 				-- Only load luvit types when the `vim.uv` word is found
 19 | 				{ path = "${3rd}/luv/library", words = { "vim%.uv" } },
 20 | 				-- always load the LazyVim library
 21 | 				"LazyVim",
 22 | 				-- Only load the lazyvim library when the `LazyVim` global is found
 23 | 				{ path = "LazyVim", words = { "LazyVim" } },
 24 | 				-- Load the wezterm types when the `wezterm` module is required
 25 | 				-- Needs `justinsgithub/wezterm-types` to be installed
 26 | 				{ path = "wezterm-types", mods = { "wezterm" } },
 27 | 				-- Load the xmake types when opening file named `xmake.lua`
 28 | 				-- Needs `LelouchHe/xmake-luals-addon` to be installed
 29 | 				{ path = "xmake-luals-addon/library", files = { "xmake.lua" } },
 30 | 			},
 31 | 			-- always enable unless `vim.g.lazydev_enabled = false`
 32 | 			-- This is the default
 33 | 			---@type boolean|(fun(root:string):boolean?)
 34 | 			enabled = function(root_dir)
 35 | 				return vim.g.lazydev_enabled == nil and true or vim.g.lazydev_enabled
 36 | 			end,
 37 | 		},
 38 | 		lazy = true,
 39 | 	},
 40 | 	"loichyan/nerdfix",
 41 | 
 42 | 	-- SPEEDUP
 43 | 	"lewis6991/impatient.nvim",
 44 | 
 45 | 	{
 46 | 		"folke/snacks.nvim",
 47 | 		priority = 1000,
 48 | 		lazy = false,
 49 | 		---@type snacks.Config
 50 | 		opts = {
 51 | 			-- your configuration comes here
 52 | 			-- or leave it empty to use the default settings
 53 | 			-- refer to the configuration section below
 54 | 			bigfile = { enabled = true },
 55 | 			dashboard = require("usr.snacks.dashboard"),
 56 | 			indent = { enabled = false },
 57 | 			input = { enabled = false },
 58 | 			notifier = { enabled = false },
 59 | 			quickfile = { enabled = true },
 60 | 			scroll = { enabled = false },
 61 | 			statuscolumn = { enabled = false },
 62 | 			words = { enabled = false },
 63 | 		},
 64 | 	},
 65 | 
 66 | 	-- PROJECTS
 67 | 	{
 68 | 		"DrKJeff16/project.nvim", -- switch between projects on the system
 69 | 		dependencies = { -- OPTIONAL
 70 | 			'nvim-lua/plenary.nvim',
 71 | 			'nvim-telescope/telescope.nvim',
 72 | 		},
 73 | 
 74 | 		opts = { },
 75 | 		cond = vim.fn.has('nvim-0.11') == 1, -- RECOMMENDED
 76 | 	},
 77 | 
 78 | 	-- dependencies
 79 | 	"nvim-lua/popup.nvim", -- An implementation of the Popup API from vim in Neovim
 80 | 	"nvim-lua/plenary.nvim", -- Useful lua functions used ny lots of plugins
 81 | 	{
 82 | 		"Fildo7525/reloader.nvim",
 83 | 		event = "LspAttach",
 84 | 		ft = { "cpp", "c", },
 85 | 		opts = {
 86 | 			autocomand = {
 87 | 				enabled = false,
 88 | 			},
 89 | 			shorten_paths = true,
 90 | 		},
 91 | 	},
 92 | 
 93 | 	-- colour scheme
 94 | 	"sheerun/vim-polyglot",
 95 | 	{
 96 | 		"catppuccin/nvim",
 97 | 		name = "catppuccin",
 98 | 	},
 99 | 
100 | 	-- SCROLLING --
101 | 	"lewis6991/satellite.nvim",
102 | 	"karb94/neoscroll.nvim",
103 | 
104 | 	-- snippets
105 | 	{
106 | 		"L3MON4D3/LuaSnip",
107 | 		-- follow latest release.
108 | 		version = "v2.*", -- Replace <CurrentMajor> by the latest released major (first number of latest release)
109 | 		-- install jsregexp (optional!).
110 | 		build = "make install_jsregexp",
111 | 		lazy = true,
112 | 	},
113 | 	"rafamadriz/friendly-snippets", -- a bunch of snippets to use
114 | 
115 | 	-- cmp plugins
116 | 	{
117 | 		"hrsh7th/nvim-cmp", -- The completion plugin
118 | 		lazy = true,
119 | 	},
120 | 	{
121 | 		"hrsh7th/cmp-nvim-lsp",
122 | 		lazy = true,
123 | 	},
124 | 	{
125 | 		'saghen/blink.cmp',
126 | 		-- optional: provides snippets for the snippet source
127 | 		dependencies = 'rafamadriz/friendly-snippets',
128 | 
129 | 		-- use a release tag to download pre-built binaries
130 | 		version = '*',
131 | 		-- AND/OR build from source, requires nightly: https://rust-lang.github.io/rustup/concepts/channels.html#working-with-nightly-rust
132 | 		-- build = 'cargo build --release',
133 | 		-- If you use nix, you can build from source using latest nightly rust with:
134 | 		-- build = 'nix run .#build-plugin',
135 | 
136 | 		opts = require("usr.lsp.blink"),
137 | 		config = function(_, opts)
138 | 			local original = require("blink.cmp.completion.list").show
139 | 
140 | 			---@diagnostic disable-next-line: duplicate-set-field
141 | 			require("blink.cmp.completion.list").show = function(ctx, items_by_source)
142 | 				local seen = {}
143 | 				local function filter(item)
144 | 					if seen[item.label] then return false end
145 | 					seen[item.label] = true
146 | 					return true
147 | 				end
148 | 				for id in vim.iter(opts.sources.priority) do
149 | 					items_by_source[id] = items_by_source[id] and vim.iter(items_by_source[id]):filter(filter):totable()
150 | 				end
151 | 				return original(ctx, items_by_source)
152 | 			end
153 | 			require("blink.cmp").setup(opts)
154 | 		end,
155 | 		opts_extend = { "sources.default" },
156 | 	},
157 | 	{
158 | 		"saadparwaiz1/cmp_luasnip", -- snippet completions
159 | 		event = "LspAttach",
160 | 	},
161 | 	"windwp/nvim-autopairs",
162 | 
163 | 	--	LSP
164 | 	"mason-org/mason.nvim",
165 | 	"mason-org/mason-lspconfig.nvim",
166 | 	"neovim/nvim-lspconfig", -- enable LSP
167 | 	{
168 | 		"nvimtools/none-ls.nvim",
169 | 		lazy = true,
170 | 	},
171 | 	{
172 | 		"lervag/vimtex",
173 | 		ft = { "tex", "latex" },
174 | 		config = function() require("usr.lsp.settings.vimlatex") end,
175 | 		lazy = true,
176 | 	},
177 | 
178 | 	-- LUALINE & BUFFLINE
179 | 	"nvim-lualine/lualine.nvim",
180 | 	'akinsho/bufferline.nvim',
181 | 	"famiu/bufdelete.nvim",
182 | 
183 | 	-- DEVICONS and NEO-TREE
184 | 	"ryanoasis/vim-devicons",
185 | 	{
186 | 		"kyazdani42/nvim-web-devicons",
187 | 		tag = "nerd-v2-compat",
188 | 	},
189 | 	{
190 | 		"nvim-neo-tree/neo-tree.nvim",
191 | 		branch = "v3.x",
192 | 		dependencies = {
193 | 			"nvim-lua/plenary.nvim",
194 | 			"kyazdani42/nvim-web-devicons", -- not strictly required, but recommended
195 | 			"MunifTanjim/nui.nvim",
196 | 		}
197 | 	},
198 | 
199 | 	-- TELESCOPE
200 | 	{
201 | 		'nvim-telescope/telescope.nvim',
202 | 		dependencies = { 'nvim-lua/plenary.nvim' },
203 | 		tag = '0.1.8',
204 | 		lazy = true,
205 | 	},
206 | 
207 | 	-- TERMINAL POPUP WINDOW
208 | 	"akinsho/toggleterm.nvim",
209 | 	{
210 | 		"ckipp01/stylua-nvim",
211 | 		build = "cargo install stylua",
212 | 		lazy = true,
213 | 	},
214 | 
215 | 	-- TREESITTER
216 | 	{
217 | 		'nvim-treesitter/nvim-treesitter',
218 | 		build = ':TSUpdate',
219 | 		lazy = false,
220 | 	},
221 | 
222 | 	{
223 | 		"HiPhish/rainbow-delimiters.nvim",
224 | 		config = function()
225 | 			---@type rainbow_delimiters.config
226 | 			vim.g.rainbow_delimiters = {
227 | 				strategy = {
228 | 					[''] = 'rainbow-delimiters.strategy.global',
229 | 					vim = 'rainbow-delimiters.strategy.local',
230 | 				},
231 | 				query = {
232 | 					[''] = 'rainbow-delimiters',
233 | 					lua = 'rainbow-blocks',
234 | 				},
235 | 				priority = {
236 | 					[''] = 110,
237 | 					lua = 210,
238 | 				},
239 | 				highlight = {
240 | 					'NeogitGraphGray',
241 | 					'RainbowDelimiterYellow',
242 | 					'RainbowDelimiterBlue',
243 | 					'RainbowDelimiterViolet',
244 | 					'RainbowDelimiterCyan',
245 | 					'RainbowDelimiterOrange',
246 | 					'RainbowDelimiterGreen',
247 | 					'RainbowDelimiterRed',
248 | 				},
249 | 			}
250 | 		end,
251 | 	},
252 | 
253 | 	-- DOXYGEN
254 | 	{
255 | 		"danymat/neogen",
256 | 		opts = {},
257 | 		dependencies = {
258 | 			"nvim-treesitter/nvim-treesitter",
259 | 		},
260 | 		version = "*",
261 | 		lazy = true,
262 | 	},
263 | 	{
264 | 		"folke/todo-comments.nvim", -- highlight comments like TODO:
265 | 		lazy = true,
266 | 	},
267 | 
268 | 	"RRethy/vim-illuminate", -- highlight all occurances of a word under cursor
269 | 
270 | 	-- COMMENTING
271 | 	"numToStr/Comment.nvim",
272 | 
273 | 	-- GIT
274 | 	{
275 | 		"lewis6991/gitsigns.nvim",
276 | 		lazy = true,
277 | 	},
278 | 
279 | 	-- DAP
280 | 	{
281 | 		"mfussenegger/nvim-dap",
282 | 		lazy = true,
283 | 	},
284 | 	{
285 | 		"rcarriga/nvim-dap-ui",
286 | 		lazy = true,
287 | 	},
288 | 	{
289 | 		"theHamsta/nvim-dap-virtual-text",
290 | 		lazy = true,
291 | 		opts = require("usr.DAP.virtual_text"),
292 | 	},
293 | 	{
294 | 		"nvim-neotest/nvim-nio",
295 | 		lazy = true,
296 | 	},
297 | 
298 | 	-- WINBAR
299 | 	{
300 | 		"Bekaboo/dropbar.nvim",
301 | 		lazy = true,
302 | 	},
303 | 
304 | 	{
305 | 		"github/copilot.vim",
306 | 		init = function()
307 | 			require("usr.copilot");
308 | 		end,
309 | 		event = "LspAttach",
310 | 	},
311 | 	{
312 | 		"Fildo7525/Revolver",
313 | 		event = "LspAttach",
314 | 	},
315 | 	{
316 | 		"Fildo7525/pretty_hover",
317 | 		event = "LspAttach",
318 | 		opts = {	},
319 | 	},
320 | 
321 | 	-- HLS
322 | 	{
323 | 		"asiryk/auto-hlsearch.nvim",
324 | 		opts = {},
325 | 	},
326 | 
327 | 	{
328 | 		"uga-rosa/ccc.nvim",
329 | 		lazy = true,
330 | 		opts = function(ccc, opts)
331 | 			local M_ccc = require("usr.ccc")
332 | 			opts = vim.tbl_deep_extend("force", opts, M_ccc.config())
333 | 			return opts
334 | 		end,
335 | 	},
336 | 	{
337 | 		"CopilotC-Nvim/CopilotChat.nvim",
338 | 		dependencies = {
339 | 			{ "github/copilot.vim" }, -- or zbirenbaum/copilot.lua
340 | 			{ "nvim-lua/plenary.nvim", branch = "master" }, -- for curl, log and async functions
341 | 		},
342 | 		build = "make tiktoken", -- Only on MacOS or Linux
343 | 		opts = {
344 | 			-- See Configuration section for options
345 | 		},
346 | 		-- See Commands section for default commands if you want to lazy load on them
347 | 	},
348 | 	{
349 | 		"MeanderingProgrammer/render-markdown.nvim",
350 | 		dependencies = { 'nvim-treesitter/nvim-treesitter', 'nvim-tree/nvim-web-devicons' }, -- if you prefer nvim-web-devicons
351 | 		---@module 'render-markdown'
352 | 		---@type render.md.UserConfig
353 | 		ft = { "markdown", "mdx" },
354 | 		opts = {
355 | 			completions = {
356 | 				blink = {
357 | 					enabled = true,
358 | 				},
359 | 			},
360 | 			latex = {
361 | 				-- Turn on / off latex rendering.
362 | 				enabled = true,
363 | 				-- Additional modes to render latex.
364 | 				render_modes = false,
365 | 				-- Executable used to convert latex formula to rendered unicode.
366 | 				-- If a list is provided the first command available on the system is used.
367 | 				converter = { 'utftex', 'latex2text' },
368 | 				-- Highlight for latex blocks.
369 | 				highlight = 'RenderMarkdownMath',
370 | 				-- Determines where latex formula is rendered relative to block.
371 | 				-- | above	| above latex block															 |
372 | 				-- | below	| below latex block															 |
373 | 				-- | center | centered with latex block (must be single line) |
374 | 				position = 'center',
375 | 				-- Number of empty lines above latex blocks.
376 | 				top_pad = 0,
377 | 				-- Number of empty lines below latex blocks.
378 | 				bottom_pad = 0,
379 | 			},
380 | 			render_modes = true,
381 | 		},
382 | 	},
383 | 	{
384 | 		"alec-gibson/nvim-tetris",
385 | 	},
386 | 	{
387 | 		"lukas-reineke/indent-blankline.nvim",
388 | 		main = "ibl",
389 | 		opts = {
390 | 			scope = {
391 | 				show_start = false,
392 | 				show_end = false
393 | 			},
394 | 			exclude = {
395 | 				filetypes = {
396 | 					"lua",
397 | 					"cpp",
398 | 				},
399 | 			},
400 | 		},
401 | 		lazy=false,
402 | 	},
403 | }
404 | 


--------------------------------------------------------------------------------
/lua/usr/lsp/util.lua:
--------------------------------------------------------------------------------
  1 | local validate = vim.validate
  2 | local api = vim.api
  3 | local lsp = vim.lsp
  4 | local nvim_eleven = vim.fn.has 'nvim-0.11' == 1
  5 | 
  6 | local iswin = vim.uv.os_uname().version:match 'Windows'
  7 | 
  8 | local M = { path = {} }
  9 | 
 10 | M.default_config = {
 11 |   log_level = lsp.protocol.MessageType.Warning,
 12 |   message_level = lsp.protocol.MessageType.Warning,
 13 |   settings = vim.empty_dict(),
 14 |   init_options = vim.empty_dict(),
 15 |   handlers = {},
 16 |   autostart = true,
 17 |   capabilities = lsp.protocol.make_client_capabilities(),
 18 | }
 19 | 
 20 | -- global on_setup hook
 21 | M.on_setup = nil
 22 | 
 23 | local function escape_wildcards(path)
 24 |   return path:gsub('([%[%]%?%*])', '\\%1')
 25 | end
 26 | 
 27 | --- Returns a function which matches a filepath against the given glob/wildcard patterns.
 28 | ---
 29 | --- Also works with zipfile:/tarfile: buffers (via `strip_archive_subpath`).
 30 | function M.root_pattern(...)
 31 |   local patterns = M.tbl_flatten { ... }
 32 |   return function(startpath)
 33 |     startpath = M.strip_archive_subpath(startpath)
 34 |     for _, pattern in ipairs(patterns) do
 35 |       local match = M.search_ancestors(startpath, function(path)
 36 |         for _, p in ipairs(vim.fn.glob(table.concat({ escape_wildcards(path), pattern }, '/'), true, true)) do
 37 |           if vim.uv.fs_stat(p) then
 38 |             return path
 39 |           end
 40 |         end
 41 |       end)
 42 | 
 43 |       if match ~= nil then
 44 |         return match
 45 |       end
 46 |     end
 47 |   end
 48 | end
 49 | 
 50 | --- Appends `new_names` to `root_files` if `field` is found in any such file in any ancestor of `fname`.
 51 | ---
 52 | --- NOTE: this does a "breadth-first" search, so is broken for multi-project workspaces:
 53 | --- https://github.com/neovim/nvim-lspconfig/issues/3818#issuecomment-2848836794
 54 | ---
 55 | --- @param root_files string[] List of root-marker files to append to.
 56 | --- @param new_names string[] Potential root-marker filenames (e.g. `{ 'package.json', 'package.json5' }`) to inspect for the given `field`.
 57 | --- @param field string Field to search for in the given `new_names` files.
 58 | --- @param fname string Full path of the current buffer name to start searching upwards from.
 59 | function M.root_markers_with_field(root_files, new_names, field, fname)
 60 |   local path = vim.fn.fnamemodify(fname, ':h')
 61 |   local found = vim.fs.find(new_names, { path = path, upward = true })
 62 | 
 63 |   for _, f in ipairs(found or {}) do
 64 |     -- Match the given `field`.
 65 |     for line in io.lines(f) do
 66 |       if line:find(field) then
 67 |         root_files[#root_files + 1] = vim.fs.basename(f)
 68 |         break
 69 |       end
 70 |     end
 71 |   end
 72 | 
 73 |   return root_files
 74 | end
 75 | 
 76 | function M.insert_package_json(root_files, field, fname)
 77 |   return M.root_markers_with_field(root_files, { 'package.json', 'package.json5' }, field, fname)
 78 | end
 79 | 
 80 | -- For zipfile: or tarfile: virtual paths, returns the path to the archive.
 81 | -- Other paths are returned unaltered.
 82 | function M.strip_archive_subpath(path)
 83 |   -- Matches regex from zip.vim / tar.vim
 84 |   path = vim.fn.substitute(path, 'zipfile://\\(.\\{-}\\)::[^\\\\].*$', '\\1', '')
 85 |   path = vim.fn.substitute(path, 'tarfile:\\(.\\{-}\\)::.*$', '\\1', '')
 86 |   return path
 87 | end
 88 | 
 89 | function M.get_typescript_server_path(root_dir)
 90 |   local project_roots = vim.fs.find('node_modules', { path = root_dir, upward = true, limit = math.huge })
 91 |   for _, project_root in ipairs(project_roots) do
 92 |     local typescript_path = project_root .. '/typescript'
 93 |     local stat = vim.loop.fs_stat(typescript_path)
 94 |     if stat and stat.type == 'directory' then
 95 |       return typescript_path .. '/lib'
 96 |     end
 97 |   end
 98 |   return ''
 99 | end
100 | 
101 | ---
102 | ---
103 | ---
104 | --- Deprecated: Remove these functions when we drop support for legacy configs:
105 | ---
106 | ---
107 | ---
108 | 
109 | --- Deprecated in Nvim 0.11
110 | function M.search_ancestors(startpath, func)
111 |   if nvim_eleven then
112 |     validate('func', func, 'function')
113 |   end
114 |   if func(startpath) then
115 |     return startpath
116 |   end
117 |   local guard = 100
118 |   for path in vim.fs.parents(startpath) do
119 |     -- Prevent infinite recursion if our algorithm breaks
120 |     guard = guard - 1
121 |     if guard == 0 then
122 |       return
123 |     end
124 | 
125 |     if func(path) then
126 |       return path
127 |     end
128 |   end
129 | end
130 | 
131 | --- Deprecated in Nvim 0.11
132 | local function is_fs_root(path)
133 |   if iswin then
134 |     return path:match '^%a:$'
135 |   else
136 |     return path == '/'
137 |   end
138 | end
139 | 
140 | --- Deprecated in Nvim 0.11
141 | local function traverse_parents(path, cb)
142 |   path = vim.uv.fs_realpath(path)
143 |   local dir = path
144 |   -- Just in case our algo is buggy, don't infinite loop.
145 |   for _ = 1, 100 do
146 |     dir = vim.fs.dirname(dir)
147 |     if not dir then
148 |       return
149 |     end
150 |     -- If we can't ascend further, then stop looking.
151 |     if cb(dir, path) then
152 |       return dir, path
153 |     end
154 |     if is_fs_root(dir) then
155 |       break
156 |     end
157 |   end
158 | end
159 | 
160 | --- Deprecated in Nvim 0.11
161 | function M.path.is_descendant(root, path)
162 |   if not path then
163 |     return false
164 |   end
165 | 
166 |   local function cb(dir, _)
167 |     return dir == root
168 |   end
169 | 
170 |   local dir, _ = traverse_parents(path, cb)
171 | 
172 |   return dir == root
173 | end
174 | 
175 | function M.tbl_flatten(t)
176 |   --- @diagnostic disable-next-line:deprecated
177 |   return nvim_eleven and vim.iter(t):flatten(math.huge):totable() or vim.tbl_flatten(t)
178 | end
179 | 
180 | --- @deprecated
181 | function M.get_config_by_ft(filetype)
182 |   local configs = require 'lspconfig.configs'
183 |   local matching_configs = {}
184 |   for _, config in pairs(configs) do
185 |     local filetypes = config.filetypes or {}
186 |     for _, ft in pairs(filetypes) do
187 |       if ft == filetype then
188 |         table.insert(matching_configs, config)
189 |       end
190 |     end
191 |   end
192 |   return matching_configs
193 | end
194 | 
195 | --- @deprecated use `vim.lsp.config` in Nvim 0.11+ instead.
196 | function M.available_servers()
197 |   local servers = {}
198 |   local configs = require 'lspconfig.configs'
199 |   for server, config in pairs(configs) do
200 |     if config.manager ~= nil then
201 |       table.insert(servers, server)
202 |     end
203 |   end
204 |   return servers
205 | end
206 | 
207 | --- @deprecated use `vim.fn.isdirectory(path) == 1` instead
208 | --- @param filename string
209 | --- @return boolean
210 | function M.path.is_dir(filename)
211 |   return vim.fn.isdirectory(filename) == 1
212 | end
213 | 
214 | --- @deprecated use `(vim.uv.fs_stat(path) or {}).type == 'file'` instead
215 | --- @param path string
216 | --- @return boolean
217 | function M.path.is_file(path)
218 |   return (vim.uv.fs_stat(path) or {}).type == 'file'
219 | end
220 | 
221 | --- @deprecated use `vim.fs.dirname` instead
222 | M.path.dirname = vim.fs.dirname
223 | 
224 | --- @deprecated use `vim.fs.normalize` instead
225 | M.path.sanitize = vim.fs.normalize
226 | 
227 | --- @deprecated use `vim.uv.fs_stat` instead
228 | --- @param filename string
229 | --- @return string|false
230 | function M.path.exists(filename)
231 |   local stat = vim.uv.fs_stat(filename)
232 |   return stat and stat.type or false
233 | end
234 | 
235 | --- @deprecated use `table.concat({"path1", "path2"})` or regular string concatenation instead
236 | function M.path.join(...)
237 |   return table.concat({ ... }, '/')
238 | end
239 | 
240 | --- @deprecated use `vim.fn.has('win32') == 1 and ';' or ':'` instead
241 | M.path.path_separator = vim.fn.has('win32') == 1 and ';' or ':'
242 | 
243 | --- @deprecated use `vim.fs.parents(path)` instead
244 | M.path.iterate_parents = vim.fs.parents
245 | 
246 | --- @deprecated use `vim.fs.dirname(vim.fs.find('.hg', { path = startpath, upward = true })[1])` instead
247 | function M.find_mercurial_ancestor(startpath)
248 |   return vim.fs.dirname(vim.fs.find('.hg', { path = startpath, upward = true })[1])
249 | end
250 | 
251 | --- @deprecated use `vim.fs.dirname(vim.fs.find('node_modules', { path = startpath, upward = true })[1])` instead
252 | function M.find_node_modules_ancestor(startpath)
253 |   return vim.fs.dirname(vim.fs.find('node_modules', { path = startpath, upward = true })[1])
254 | end
255 | 
256 | --- @deprecated use `vim.fs.dirname(vim.fs.find('package.json', { path = startpath, upward = true })[1])` instead
257 | function M.find_package_json_ancestor(startpath)
258 |   return vim.fs.dirname(vim.fs.find('package.json', { path = startpath, upward = true })[1])
259 | end
260 | 
261 | --- @deprecated use `vim.fs.dirname(vim.fs.find('.git', { path = startpath, upward = true })[1])` instead
262 | function M.find_git_ancestor(startpath)
263 |   return vim.fs.dirname(vim.fs.find('.git', { path = startpath, upward = true })[1])
264 | end
265 | 
266 | --- @deprecated Will be removed. Do not use.
267 | function M.get_active_clients_list_by_ft(filetype)
268 |   local clients = vim.lsp.get_clients()
269 |   local clients_list = {}
270 |   for _, client in pairs(clients) do
271 |     --- @diagnostic disable-next-line:undefined-field
272 |     local filetypes = client.config.filetypes or {}
273 |     for _, ft in pairs(filetypes) do
274 |       if ft == filetype then
275 |         table.insert(clients_list, client.name)
276 |       end
277 |     end
278 |   end
279 |   return clients_list
280 | end
281 | 
282 | --- @deprecated Will be removed. Do not use.
283 | function M.get_other_matching_providers(filetype)
284 |   local configs = require 'lspconfig.configs'
285 |   local active_clients_list = M.get_active_clients_list_by_ft(filetype)
286 |   local other_matching_configs = {}
287 |   for _, config in pairs(configs) do
288 |     if not vim.tbl_contains(active_clients_list, config.name) then
289 |       local filetypes = config.filetypes or {}
290 |       for _, ft in pairs(filetypes) do
291 |         if ft == filetype then
292 |           table.insert(other_matching_configs, config)
293 |         end
294 |       end
295 |     end
296 |   end
297 |   return other_matching_configs
298 | end
299 | 
300 | --- @deprecated Use vim.lsp.get_clients instead.
301 | function M.get_lsp_clients(filter)
302 |   --- @diagnostic disable-next-line:deprecated
303 |   return nvim_eleven and lsp.get_clients(filter) or lsp.get_active_clients(filter)
304 | end
305 | 
306 | --- @deprecated Will be removed. Do not use.
307 | function M.add_hook_before(func, new_fn)
308 |   if func then
309 |     return function(...)
310 |       -- TODO which result?
311 |       new_fn(...)
312 |       return func(...)
313 |     end
314 |   else
315 |     return new_fn
316 |   end
317 | end
318 | 
319 | --- @deprecated Will be removed. Do not use.
320 | function M.add_hook_after(func, new_fn)
321 |   if func then
322 |     return function(...)
323 |       -- TODO which result?
324 |       func(...)
325 |       return new_fn(...)
326 |     end
327 |   else
328 |     return new_fn
329 |   end
330 | end
331 | 
332 | --- @deprecated Will be removed. Do not use.
333 | function M.get_active_client_by_name(bufnr, servername)
334 |   return vim.lsp.get_clients({ bufnr = bufnr, name = servername })[1]
335 | end
336 | 
337 | -- Maps lspconfig-style command options to nvim_create_user_command (i.e. |command-attributes|) option names.
338 | local opts_aliases = {
339 |   ['description'] = 'desc',
340 | }
341 | 
342 | --- @deprecated Will be removed. Do not use.
343 | ---@param command_definition table<string | integer, any>
344 | function M._parse_user_command_options(command_definition)
345 |   ---@type table<string, string | boolean | number>
346 |   local opts = {}
347 |   for k, v in pairs(command_definition) do
348 |     if type(k) == 'string' then
349 |       local attribute = k.gsub(k, '^%-+', '')
350 |       opts[opts_aliases[attribute] or attribute] = v
351 |     elseif type(k) == 'number' and type(v) == 'string' and v:match '^%-' then
352 |       -- Splits strings like "-nargs=* -complete=customlist,v:lua.something" into { "-nargs=*", "-complete=customlist,v:lua.something" }
353 |       for _, command_attribute in ipairs(vim.split(v, '%s')) do
354 |         -- Splits attribute into a key-value pair, like "-nargs=*" to { "-nargs", "*" }
355 |         local attribute, value = unpack(vim.split(command_attribute, '=', { plain = true }))
356 |         attribute = attribute.gsub(attribute, '^%-+', '')
357 |         opts[opts_aliases[attribute] or attribute] = value or true
358 |       end
359 |     end
360 |   end
361 |   return opts
362 | end
363 | 
364 | --- @deprecated Will be removed. Do not use.
365 | function M.create_module_commands(module_name, commands)
366 |   for command_name, def in pairs(commands) do
367 |     if type(def) ~= 'function' then
368 |       local opts = M._parse_user_command_options(def)
369 |       api.nvim_create_user_command(command_name, function(info)
370 |         require('lspconfig')[module_name].commands[command_name][1](unpack(info.fargs))
371 |       end, opts)
372 |     end
373 |   end
374 | end
375 | 
376 | --- Note: In Nvim 0.11+ this currently has no public interface, the healthcheck uses the private
377 | --- `vim.lsp._enabled_configs`:
378 | --- https://github.com/neovim/neovim/blob/28e819018520a2300eaeeec6794ffcd614b25dd2/runtime/lua/vim/lsp/health.lua#L186
379 | --- @deprecated Will be removed. Do not use.
380 | function M.get_managed_clients()
381 |   local configs = require 'lspconfig.configs'
382 |   local clients = {}
383 |   for _, config in pairs(configs) do
384 |     if config.manager then
385 |       vim.list_extend(clients, config.manager:clients())
386 |     end
387 |   end
388 |   return clients
389 | end
390 | 
391 | --- @deprecated Will be removed. Do not use.
392 | function M.bufname_valid(bufname)
393 |   if bufname:match '^/' or bufname:match '^[a-zA-Z]:' or bufname:match '^zipfile://' or bufname:match '^tarfile:' then
394 |     return true
395 |   end
396 |   return false
397 | end
398 | 
399 | --- @deprecated Will be removed. Do not use.
400 | function M.validate_bufnr(bufnr)
401 |   if nvim_eleven then
402 |     validate('bufnr', bufnr, 'number')
403 |   end
404 |   return bufnr == 0 and api.nvim_get_current_buf() or bufnr
405 | end
406 | 
407 | return M
408 | 


--------------------------------------------------------------------------------