Last active
March 17, 2023 04:01
-
-
Save socool/44f99e2798440fc6ac8d93ced7930005 to your computer and use it in GitHub Desktop.
init.lua
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
-- Install packer | |
local install_path = vim.fn.stdpath 'data' .. '/site/pack/packer/start/packer.nvim' | |
local is_bootstrap = false | |
if vim.fn.empty(vim.fn.glob(install_path)) > 0 then | |
is_bootstrap = true | |
vim.fn.system { 'git', 'clone', '--depth', '1', 'https://github.com/wbthomason/packer.nvim', install_path } | |
vim.cmd [[packadd packer.nvim]] | |
end | |
require('packer').startup(function(use) | |
-- Package manager | |
use 'wbthomason/packer.nvim' | |
use { -- LSP Configuration & Plugins | |
'neovim/nvim-lspconfig', | |
requires = { | |
-- Automatically install LSPs to stdpath for neovim | |
'williamboman/mason.nvim', | |
'williamboman/mason-lspconfig.nvim', | |
-- Useful status updates for LSP | |
'j-hui/fidget.nvim', | |
-- Additional lua configuration, makes nvim stuff amazing | |
'folke/neodev.nvim', | |
}, | |
} | |
use { -- Autocompletion | |
'hrsh7th/nvim-cmp', | |
requires = { 'hrsh7th/cmp-nvim-lsp', 'L3MON4D3/LuaSnip', 'saadparwaiz1/cmp_luasnip' }, | |
} | |
use { -- Highlight, edit, and navigate code | |
'nvim-treesitter/nvim-treesitter', | |
run = function() | |
pcall(require('nvim-treesitter.install').update { with_sync = true }) | |
end, | |
} | |
use { -- Additional text objects via treesitter | |
'nvim-treesitter/nvim-treesitter-textobjects', | |
after = 'nvim-treesitter', | |
} | |
-- Git related plugins | |
use 'tpope/vim-fugitive' | |
use 'tpope/vim-rhubarb' | |
use 'lewis6991/gitsigns.nvim' | |
use 'dracula/vim' | |
--use 'navarasu/onedark.nvim' -- Theme inspired by Atom | |
use 'nvim-lualine/lualine.nvim' -- Fancier statusline | |
use 'lukas-reineke/indent-blankline.nvim' -- Add indentation guides even on blank lines | |
use 'numToStr/Comment.nvim' -- "gc" to comment visual regions/lines | |
use 'tpope/vim-sleuth' -- Detect tabstop and shiftwidth automatically | |
-- Fuzzy Finder (files, lsp, etc) | |
use { 'nvim-telescope/telescope.nvim', branch = '0.1.x', requires = { 'nvim-lua/plenary.nvim' } } | |
-- Fuzzy Finder Algorithm which requires local dependencies to be built. Only load if `make` is available | |
use { 'nvim-telescope/telescope-fzf-native.nvim', run = 'make', cond = vim.fn.executable 'make' == 1 } | |
-- My custom neovim | |
use 'nvim-tree/nvim-tree.lua' | |
use 'nvim-tree/nvim-web-devicons' | |
use 'preservim/vimux' | |
use 'christoomey/vim-tmux-navigator' | |
use 'bluz71/vim-nightfly-colors' | |
use 'vim-test/vim-test' | |
use "rafamadriz/friendly-snippets" | |
use "HallerPatrick/py_lsp.nvim" | |
use {'hkupty/iron.nvim'} | |
-- Add custom plugins to packer from ~/.config/nvim/lua/custom/plugins.lua | |
local has_plugins, plugins = pcall(require, 'custom.plugins') | |
if has_plugins then | |
plugins(use) | |
end | |
if is_bootstrap then | |
require('packer').sync() | |
end | |
end) | |
-- When we are bootstrapping a configuration, it doesn't | |
-- make sense to execute the rest of the init.lua. | |
-- | |
-- You'll need to restart nvim, and then it will work. | |
if is_bootstrap then | |
print '==================================' | |
print ' Plugins are being installed' | |
print ' Wait until Packer completes,' | |
print ' then restart nvim' | |
print '==================================' | |
return | |
end | |
-- Automatically source and re-compile packer whenever you save this init.lua | |
local packer_group = vim.api.nvim_create_augroup('Packer', { clear = true }) | |
vim.api.nvim_create_autocmd('BufWritePost', { | |
command = 'source <afile> | silent! LspStop | silent! LspStart | PackerCompile', | |
group = packer_group, | |
pattern = vim.fn.expand '$MYVIMRC', | |
}) | |
-- [[ Setting options ]] | |
-- See `:help vim.o` | |
vim.g.mapleader = ' ' | |
vim.g.maplocalleader = ' ' | |
vim.opt.backspace = '2' | |
vim.opt.showcmd = true | |
vim.opt.laststatus = 2 | |
vim.opt.autowrite = true | |
vim.opt.cursorline = true | |
vim.opt.autoread = true | |
-- use spaces for tabs and whatnot | |
vim.opt.tabstop = 2 | |
vim.opt.shiftwidth = 2 | |
vim.opt.shiftround = true | |
vim.opt.expandtab = true | |
vim.cmd [[ set noswapfile ]] | |
--Line numbers | |
vim.wo.number = true | |
vim.wo.relativenumber = true | |
-- Enable mouse mode | |
vim.o.mouse = 'a' | |
-- Colorscheme | |
vim.o.termguicolors = true | |
vim.cmd [[ colorscheme dracula ]] | |
-- [[ Basic Keymaps ]] | |
-- Set <space> as the leader key | |
-- See `:help mapleader` | |
-- NOTE: Must happen before plugins are required (otherwise wrong leader will be used) | |
-- Navigate vim panes better | |
vim.keymap.set('n', '<c-k>', ':wincmd k<CR>') | |
vim.keymap.set('n', '<c-j>', ':wincmd j<CR>') | |
vim.keymap.set('n', '<c-h>', ':wincmd h<CR>') | |
vim.keymap.set('n', '<c-l>', ':wincmd l<CR>') | |
vim.keymap.set('i', '`', '<Esc>') | |
vim.keymap.set('n', '<leader>h', ':nohlsearch<CR>') | |
-- [[ Highlight on yank ]] | |
-- See `:help vim.highlight.on_yank()` | |
local highlight_group = vim.api.nvim_create_augroup('YankHighlight', { clear = true }) | |
vim.api.nvim_create_autocmd('TextYankPost', { | |
callback = function() | |
vim.highlight.on_yank() | |
end, | |
group = highlight_group, | |
pattern = '*', | |
}) | |
-- Set lualine as statusline | |
-- See `:help lualine.txt` | |
require('lualine').setup { | |
options = { | |
icons_enabled = true, | |
theme = 'dracula', | |
}, | |
sections = { | |
lualine_a = { | |
{ | |
'filename', | |
path = 1, | |
} | |
} | |
} | |
} | |
-- Enable Comment.nvim | |
require('Comment').setup() | |
-- Enable `lukas-reineke/indent-blankline.nvim` | |
-- See `:help indent_blankline.txt` | |
require('indent_blankline').setup { | |
char = '┊', | |
show_trailing_blankline_indent = false, | |
} | |
-- Gitsigns | |
-- See `:help gitsigns.txt` | |
require('gitsigns').setup { | |
signs = { | |
add = { text = '+' }, | |
change = { text = '~' }, | |
delete = { text = '_' }, | |
topdelete = { text = '‾' }, | |
changedelete = { text = '~' }, | |
}, | |
} | |
-- [[ Configure Telescope ]] | |
-- See `:help telescope` and `:help telescope.setup()` | |
require('telescope').setup() | |
local builtin = require('telescope.builtin') | |
vim.keymap.set('n', '<c-p>', builtin.find_files, {}) | |
vim.keymap.set('n', '<Space><Space>', builtin.oldfiles, {}) | |
vim.keymap.set('n', '<Space>fg', builtin.live_grep, {}) | |
vim.keymap.set('n', '<Space>fh', builtin.help_tags, {}) | |
vim.keymap.set('n', 'K', builtin.lsp_definitions, {}) | |
vim.keymap.set('n', '<Space>p', builtin.builtin, {}) | |
vim.keymap.set('n', '<Space>k', builtin.lsp_type_definitions, {}) | |
-- [[ Configure Treesitter ]] | |
-- See `:help nvim-treesitter` | |
require('nvim-treesitter.configs').setup { | |
-- Add languages to be installed here that you want installed for treesitter | |
ensure_installed = { 'c', 'python', 'rust', 'help', 'vim' }, | |
highlight = { enable = true }, | |
indent = { enable = true, disable = { 'python' } }, | |
incremental_selection = { | |
enable = true, | |
keymaps = { | |
init_selection = '<c-space>', | |
node_incremental = '<c-space>', | |
scope_incremental = '<c-s>', | |
node_decremental = '<c-backspace>', | |
}, | |
}, | |
textobjects = { | |
select = { | |
enable = true, | |
lookahead = true, -- Automatically jump forward to textobj, similar to targets.vim | |
keymaps = { | |
-- You can use the capture groups defined in textobjects.scm | |
['aa'] = '@parameter.outer', | |
['ia'] = '@parameter.inner', | |
['af'] = '@function.outer', | |
['if'] = '@function.inner', | |
['ac'] = '@class.outer', | |
['ic'] = '@class.inner', | |
}, | |
}, | |
move = { | |
enable = true, | |
set_jumps = true, -- whether to set jumps in the jumplist | |
goto_next_start = { | |
[']m'] = '@function.outer', | |
[']]'] = '@class.outer', | |
}, | |
goto_next_end = { | |
[']M'] = '@function.outer', | |
[']['] = '@class.outer', | |
}, | |
goto_previous_start = { | |
['[m'] = '@function.outer', | |
['[['] = '@class.outer', | |
}, | |
goto_previous_end = { | |
['[M'] = '@function.outer', | |
['[]'] = '@class.outer', | |
}, | |
}, | |
swap = { | |
enable = true, | |
swap_next = { | |
['<leader>a'] = '@parameter.inner', | |
}, | |
swap_previous = { | |
['<leader>A'] = '@parameter.inner', | |
}, | |
}, | |
}, | |
} | |
-- Diagnostic keymaps | |
vim.keymap.set('n', '[d', vim.diagnostic.goto_prev) | |
vim.keymap.set('n', ']d', vim.diagnostic.goto_next) | |
vim.keymap.set('n', '<leader>e', vim.diagnostic.open_float) | |
vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist) | |
-- LSP settings. | |
-- This function gets run when an LSP connects to a particular buffer. | |
local on_attach = function(_, bufnr) | |
-- NOTE: Remember that lua is a real programming language, and as such it is possible | |
-- to define small helper and utility functions so you don't have to repeat yourself | |
-- many times. | |
-- | |
-- In this case, we create a function that lets us more easily define mappings specific | |
-- for LSP related items. It sets the mode, buffer and description for us each time. | |
local nmap = function(keys, func, desc) | |
if desc then | |
desc = 'LSP: ' .. desc | |
end | |
vim.keymap.set('n', keys, func, { buffer = bufnr, desc = desc }) | |
end | |
nmap('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame') | |
nmap('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction') | |
nmap('gd', vim.lsp.buf.definition, '[G]oto [D]efinition') | |
nmap('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences') | |
nmap('gI', vim.lsp.buf.implementation, '[G]oto [I]mplementation') | |
nmap('<leader>D', vim.lsp.buf.type_definition, 'Type [D]efinition') | |
nmap('<leader>ds', require('telescope.builtin').lsp_document_symbols, '[D]ocument [S]ymbols') | |
nmap('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols') | |
-- See `:help K` for why this keymap | |
nmap('K', vim.lsp.buf.hover, 'Hover Documentation') | |
nmap('<C-k>', vim.lsp.buf.signature_help, 'Signature Documentation') | |
-- Lesser used LSP functionality | |
nmap('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration') | |
nmap('<leader>wa', vim.lsp.buf.add_workspace_folder, '[W]orkspace [A]dd Folder') | |
nmap('<leader>wr', vim.lsp.buf.remove_workspace_folder, '[W]orkspace [R]emove Folder') | |
nmap('<leader>wl', function() | |
print(vim.inspect(vim.lsp.buf.list_workspace_folders())) | |
end, '[W]orkspace [L]ist Folders') | |
-- Create a command `:Format` local to the LSP buffer | |
vim.api.nvim_buf_create_user_command(bufnr, 'Format', function(_) | |
vim.lsp.buf.format() | |
end, { desc = 'Format current buffer with LSP' }) | |
end | |
-- Enable the following language servers | |
-- Feel free to add/remove any LSPs that you want here. They will automatically be installed. | |
-- | |
-- Add any additional override configuration in the following tables. They will be passed to | |
-- the `settings` field of the server config. You must look up that documentation yourself. | |
local servers = { | |
-- clangd = {}, | |
-- gopls = {}, | |
-- pyright = {}, | |
-- rust_analyzer = {}, | |
-- tsserver = {}, | |
sumneko_lua = { | |
Lua = { | |
workspace = { checkThirdParty = false }, | |
telemetry = { enable = false }, | |
}, | |
}, | |
} | |
-- Setup neovim lua configuration | |
require('neodev').setup() | |
-- | |
-- nvim-cmp supports additional completion capabilities, so broadcast that to servers | |
local capabilities = vim.lsp.protocol.make_client_capabilities() | |
capabilities = require('cmp_nvim_lsp').default_capabilities(capabilities) | |
-- Setup mason so it can manage external tooling | |
require('mason').setup() | |
-- Ensure the servers above are installed | |
local mason_lspconfig = require 'mason-lspconfig' | |
require("mason-lspconfig").setup { | |
ensure_installed = { "pylsp"}, | |
} | |
mason_lspconfig.setup_handlers { | |
function(server_name) | |
require('lspconfig')[server_name].setup { | |
capabilities = capabilities, | |
on_attach = on_attach, | |
settings = servers[server_name], | |
} | |
end, | |
} | |
-- Turn on lsp status information | |
require('fidget').setup() | |
-- nvim-cmp setup | |
require("luasnip.loaders.from_vscode").lazy_load() | |
local cmp = require 'cmp' | |
local luasnip = require 'luasnip' | |
cmp.setup { | |
snippet = { | |
expand = function(args) | |
luasnip.lsp_expand(args.body) | |
end, | |
}, | |
mapping = cmp.mapping.preset.insert { | |
['<C-d>'] = cmp.mapping.scroll_docs(-4), | |
['<C-f>'] = cmp.mapping.scroll_docs(4), | |
['<C-Space>'] = cmp.mapping.complete(), | |
['<CR>'] = cmp.mapping.confirm { | |
behavior = cmp.ConfirmBehavior.Replace, | |
select = true, | |
}, | |
['<Tab>'] = cmp.mapping(function(fallback) | |
if cmp.visible() then | |
cmp.select_next_item() | |
elseif luasnip.expand_or_jumpable() then | |
luasnip.expand_or_jump() | |
else | |
fallback() | |
end | |
end, { 'i', 's' }), | |
['<S-Tab>'] = cmp.mapping(function(fallback) | |
if cmp.visible() then | |
cmp.select_prev_item() | |
elseif luasnip.jumpable(-1) then | |
luasnip.jump(-1) | |
else | |
fallback() | |
end | |
end, { 'i', 's' }), | |
}, | |
sources = { | |
{ name = 'nvim_lsp' }, | |
{ name = 'luasnip' }, | |
}, | |
} | |
-- Nvim-tree | |
vim.g.loaded_netrw = 1 | |
vim.g.loaded_netrwPlugin = 1 | |
require("nvim-tree").setup({ | |
view = { | |
adaptive_size = true | |
} | |
}) | |
vim.keymap.set('n', '<c-n>', ':NvimTreeFindFileToggle<CR>') | |
-- Vim-test | |
vim.cmd [[ | |
let test#strategy = "vimux" | |
]] | |
vim.keymap.set('n', '<leader>t', ':TestNearest<CR>') | |
vim.keymap.set('n', '<leader>T', ':TestFile<CR>') | |
-- The line beneath this is called `modeline`. See `:help modeline` | |
-- vim: ts=2 sts=2 sw=2 et | |
-- PY_LSP | |
require("py_lsp").setup { | |
-- This is optional, but allows to create virtual envs from nvim | |
host_python = "/usr/bin/python3", | |
default_venv_name = ".venv" | |
} | |
local iron = require("iron.core") | |
iron.setup { | |
config = { | |
-- Whether a repl should be discarded or not | |
scratch_repl = true, | |
-- Your repl definitions come here | |
repl_definition = { | |
sh = { | |
-- Can be a table or a function that | |
-- returns a table (see below) | |
command = {"zsh"} | |
}, | |
python = { | |
command = {"python3"} | |
} | |
}, | |
-- How the repl window will be displayed | |
-- See below for more information | |
repl_open_cmd = "rightbelow 10 split" | |
--vertical botright 50 split | |
}, | |
-- Iron doesn't set keymaps by default anymore. | |
-- You can set them here or manually add keymaps to the functions in iron.core | |
keymaps = { | |
send_motion = "<space>sc", | |
visual_send = "<space>sc", | |
send_file = "<space>sf", | |
send_line = "<space>sl", | |
send_mark = "<space>sm", | |
mark_motion = "<space>mc", | |
mark_visual = "<space>mc", | |
remove_mark = "<space>md", | |
cr = "<space>s<Enter>", | |
interrupt = "<space>s<space>", | |
exit = "<space>sq", | |
clear = "<space>cl", | |
}, | |
-- If the highlight is on, you can change how it looks | |
-- For the available options, check nvim_set_hl | |
highlight = { | |
italic = true | |
}, | |
ignore_blank_lines = true, -- ignore blank lines when sending visual select lines | |
} | |
-- iron also has a list of commands, see :h iron-commands for all available commands | |
vim.keymap.set('n', '<space>rs', '<cmd>IronRepl<cr>') | |
vim.keymap.set('n', '<space>rr', '<cmd>IronRestart<cr>') | |
vim.keymap.set('n', '<space>rf', '<cmd>IronFocus<cr>') | |
vim.keymap.set('n', '<space>rh', '<cmd>IronHide<cr>') | |
-- set copy clipboard | |
vim.o.clipboard = "unnamedplus" |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment