Study Tips on how to Use NeoVim as an IDE | by Percy Bolmér | Dec, 2022

A step-by-step tutorial on the way to arrange and use NeoVim, for full newbies

A few years in the past I attempted NeoVim, I used to be horrified by the quantity of setup wanted and I ran.

I ran to the consolation of my common VS Code. An IDE that labored, appeared good and had essentially the most options I wished.

I assumed I used to be efficient in VS Code, however then I made a decision to offer NeoVim a strive once more.

Some may ask, why spend a couple of hours organising an IDE when you’ll be able to have a whole working one in a minute, I agree. However let’s face it if we’re going to work each day in our IDE, a couple of hours to configure is just not actually a nasty factor.

The rationale to make use of NeoVim is that it’s tremendous customizable, you’ll be able to actually make this editor look the best way you need, and make it behave the best way you need.

The con of NeoVim can also be the customization skills, it requires a while to arrange and modify sooner or later. However as soon as you understand how to it isn’t that arduous or time-consuming, for the flexibility so as to add ANY function that you really want.

This tutorial will not hand you an ideal IDE configuration for NeoVim, for that you would be able to google after folks’s dotfiles. This tutorial goals that will help you perceive NeoVim and learn to handle it, permitting you to construct no matter you need after. I received’t anticipate any earlier information in both Vi or NeoVim.

You already know what they are saying

Hand a developer an IDE, and he/she is going to code.

Hand a developer the flexibility to customise his IDE, and he/she shall be a developer god.

Putting in NeoVim And Packer The Plugin Supervisor

Start by putting in NeoVim by following the directions on GitHub. I don’t advocate utilizing apt-get set up in case you are utilizing ubuntu as it’s an previous model.

curl https://github.com/neovim/neovim/releases/obtain/steady/nvim-linux64.tar.gz
tar -xvf nvim-linux64.tar.gz

Transfer the unpacked folder someplace the place you retailer your software program, or add the binary discovered at ./nvim-linx64/bin/nvim to your $PATH.

You’ll be able to then open it up by operating nvim

nvim

Doing this may open up NeoVim and a splash display screen. Keep in mind, NeoVim is extra of a terminal as a substitute of a daily editor with a elaborate UI.

You’re terminal ought to appear like the next

NeoVim Is nothing particular in any respect if we do not begin including a couple of plugins. That is the half that scares most individuals away after they first begin utilizing NeoVim. So Let’s attempt to make it straightforward.

Now you can shut NeoVim by urgent SHIFT+: which opens the command immediate after which write q within the tab that seems on the backside, and press enter.

Urgent SHIFT+: will open up the command tab, which permits us to move in instructions.

We’d like a Plugin Supervisor, a well-liked one that we’ll use is Packer.

We are able to set up it utilizing a one-liner in bash, it’ll fetch the repository and place it on the ~/.native/share/nvim path that’s the second parameter. Do not modify that path except you already know what you’re doing, it’s utilizing a default path to one thing named PackPath in Vim/NeoVim.

git clone --depth 1 https://github.com/wbthomason/packer.nvim
~/.native/share/nvim/web site/pack/packer/begin/packer.nvim

Now that we’ve Packer put in we have to make a primary go to to the Plugin configuration file.

All configurations go into an LUA file which is by default saved at ~/.config/nvim/lua/. At that location, we will specify configuration recordsdata.

Writing The First Configuration & Importing Plugins & Navigating

All the things in NeoVim is nearly dealt with by a Plugin, as an illustration, if we’re going to use NeoVim as an IDE we are going to want Language Servers to grasp code.

We are going to go forward and create the primary configuration file, which shall be ~/.config/nvim/lua/plugins.lua.

If the folder doesn’t exist then create it and create the file by opening it up with NeoVim.

mkdir -p ~/.config/nvim/lua
nvim ~/.config/nvim/lua/plugins.lua

Packer might be imported within the Lua file by passing the identify to the require operate. We are going to then run a operate on that referred to as startup which shall be carried out on startup on NeoVim, which suggests we add the plugins and capabilities at any time when NeoVim is began.

Enter Insert Mode by urgent Insert or i after which add the next

return require('packer').startup(operate(use)
-- Configurations will go right here quickly
use 'wbthomason/packer.nvim'
finish)

What we do is that we’re making Packer run on begin, we then import all of the plugins we wish to use, and we embrace the packer plugin additionally. This permits Packer to self-manage itself and replace and many others.

Press ESC to go away Insert Mode, Save the file by opening the command tab SHIFT+: and passing in w which is brief for write.

In the event you restart NeoVim now, nothing may have modified, bummer huh?

We have to additionally inform NeoVim to seek out this configuration file and cargo it.

This may be completed inside ~/.config/nvim/init.lua which is a second configuration file, this file is executed by NeoVim when began up, we would require our configuration scripts inside Lua from right here.

Open the plugins.lua file once more, and allow us to learn to navigate (for now) inside NeoVim so we don’t want to leap out on a regular basis.

As soon as NeoVim is opened, sort within the command Discover which can open up a text-based explorer for us. It’s referred to as Netrw, and I received’t go into particulars, however it will probably even fetch distant recordsdata, and many others.

From right here, you’ll be able to see the recordsdata within the present listing, and likewise the default Linux path indicators ./ and ../. A single dot is a present listing, two dots is the guardian listing.

We wish to create the init.lua file within the guardian listing, so press enter as soon as you choose the ../ after which press SHIFT+%. Shift+% will open an enter bar on the backside asking for a file identify, enter init.lua. It would open the file after creating it.

We are going to add a single line to it, or create the file if it doesn’t exist. That line will ensure plugins are added.

require('plugins')

Save utilizing the w command and restart NeoVim and we should always have Packer put in, which we will management by operating instructions.

If Packer was put in appropriately we should always have the ability to use its instructions, one in all them is PackerStatus which prints a listing of all used Plugins.

You’ll be able to print the standing bar down by urgent q.

In Quick what we’ve completed to date.

1. Realized how we will use Packer for importing Plugins, ~/.config/nvim/lua/plugins.lua which is said to that.
2. ~/.config/nvim/init.lua allowed us to inform NeoVim to respect our Packer file upon startup.
3. Working instructions utilizing SHIFT+: corresponding to PackerStatus.
4. Realized the way to navigate utilizing the Discover command.

Now it won’t appear very spectacular to date, and I agree. Allow us to add extra plugins.

We’re going to code, so we are going to want plugins for language servers and debuggers, and many others. There’s a nice plugin referred to as Mason that can be utilized for this, allow us to replace the Packer configuration, you already know which file by now! We may also fetch the neovim/nvim-lspconfig which allows us to fetch completely different configurations for various LSPs, try the docs for a full listing.

Replace the plugin configuration to the next.

return require('packer').startup(operate(use)
-- Configurations will go right here
use 'wbthomason/packer.nvim'
use 'williamboman/mason.nvim'   
use 'williamboman/mason-lspconfig.nvim'
use 'neovim/nvim-lspconfig'  
finish)

As soon as that’s completed, save the file by opening the command barSHIFT+: after which run the command w which can write down any adjustments you’ve made.

Now we have saved the file, however we have to reload it for these adjustments to be noticeable by Packer, so open the command bar and sort within the following command which can reload the at the moment opened lua file.

:luafile %

Then execute the PackerInstall command to obtain the brand new plugins.

:PackerInstall

Please observe that the plugins we put in now solely assist us arrange and configure the LSP. It doesn’t obtain them for us if we would like GOPLS as an illustration we nonetheless want to put in that individually.

Enabling Language Server Protocol Assist

Utilizing the nvim-lspconfig requires us to put in a third-party language server that may then be linked to NeoVim. That is how I allow GOPLS as an illustration with the assistance of Mason.

We start by enabling Mason, that is completed in the identical means Packer was completed, we create a lua script to allow it, then require that script within the init.lua.

Let’s start by creating the lua file to handle mason.

contact ~/.config/nvim/lua/mason-config.lua

Then open the file and fill within the code under to require the plugins and name their setup operate.

require("mason").setup()
require("mason-lspconfig").setup()

Save the file utilizing w.

Then we replace init.lua to require that script, by utilizing the prefix of the identify mason-config. Keep in mind to make use of Discover while you swap between the recordsdata.

require('plugins')
require('mason-config')

As soon as that’s completed, opening NeoVim ought to have the brand new Mason command which can open a setup supervisor for us.

If you’re utilizing a NeoVim model older than 0.7 you may get an error when opening NeoVim, press enter and run the command

:checkhealth

This can be a tremendous helpful command to check issues out and detect something that’s incorrect.

Working :Mason will convey up all of the accessible LSPs, find the one you will have, and keep in mind the identify. I’ll set up gopls.

To put in it, run the command, add any packages you need, and if you happen to add many then separate them by house.

MasonInstall gopls

Observe that every set up may require you to have software program put in like gopls set up requires go.

Now that gopls is put in we have to make NeoVim connect it.

That is actually easy, and the method ought to now really feel acquainted, we’re going to create a gopls.lua file contained in the lua folder, after which we’re going to require that script within the init.lua.

The gopls.lua will import the lspconfig bundle, which permits us to connect gopls to neovim.

You’ll be able to configure gopls to do many issues, we are going to use the easy instance from the gopls documentation, every server has its personal set of configurations that it’s essential to examine on their documentation on what to specify.

 -- Require LSP config which we will use to connect gopls
lspconfig = require "lspconfig"
util = require "lspconfig/util"
-- Since we put in lspconfig and imported it, we will attain
-- gopls by lspconfig.gopls
-- we will then set it up utilizing the setup and insert the wanted configurations
lspconfig.gopls.setup {
cmd = {"gopls", "serve"},
filetypes = {"go", "gomod"},
root_dir = util.root_pattern("go.work", "go.mod", ".git"),
settings = {
gopls = {
analyses = {
unusedparams = true,
},
staticcheck = true,
},
},
}

If you’re utilizing go you’ll want to add extra evaluation and many others, however we’re right here the way to learn to set issues up, after which customization is as much as you.

I do advocate ray-x for go, which needs to be straightforward to put in after following this tutorial.

Be sure that to require the brand new lua script within the init.lua.

require('plugins')
require('mason-config')
require('gopls')

Now create a essential.go and see if it will probably detect errors, right here is a picture exhibiting my errors.

Code Completion & Ideas

We’re on a step in the proper path, we’re seeing errors. I don’t know if you happen to seen that there was no code completion or options.

That may be a tremendous must-have in an Editor, so let’s add it.

So as to add that, we’d like, a….. drum roll, anticipate it, a PLUGIN!

We shall be leveraging hrsh7th plugin for this or plugins.

He has a complete suite of plugins, I’ll put hyperlinks right here to those used, however I will not cowl all of them intimately

• nvim-cmp — A completion engine plugin for Neovim
• cmp-nvim-lsp — nvim-cmp supply for neovim’s built-in language server shopper.
• cmp-nvim-lsp-signature-help — nvim-cmp supply for displaying operate signatures with the present parameter emphasised:
• cmp-nvim-lua — nvim-cmp supply for neovim Lua API.
• vim-vsnip — Means to Create and Use VSCode Snippets.
• cmp-path — nvim-cmp supply for filesystem paths.
• cmp-buffer — nvim-cmp supply for buffer phrases.

We are able to add all these plugins to the lua/plugins.lua file.

-- Hrsh7th Code Completion Suite
use 'hrsh7th/nvim-cmp' 
use 'hrsh7th/cmp-nvim-lsp'
use 'hrsh7th/cmp-nvim-lua'
use 'hrsh7th/cmp-nvim-lsp-signature-help'
use 'hrsh7th/cmp-vsnip'                             
use 'hrsh7th/cmp-path'                              
use 'hrsh7th/cmp-buffer'                            
use 'hrsh7th/vim-vsnip'

Then save the file by operating the :w command, reload the lua file with :luafile % , then sync the packages with :PackerSync which can delete any unused plugins, and set up new ones.

As soon as that is completed, we have to write a brand new configuration file in lua/code-completion.lua that we use to handle the plugins and configure them to behave as we would like.

We are going to need a small popup dialog to look with code options, this may be completed utilizing one of many many configurations accessible in NeoVim, all the configs are discovered right here.

The one we’re after is vim.decide.completeopt which is used to make a menu seem with options. All of the accessible configurations are within the docs, I’ll solely go away feedback above each to clarify it.

After that, we would require cmp which permits us to configure the plugin. We are going to name the setup operate to have a couple of settings utilized when it’s arrange.

The file will appear like this firstly

-- completeopt is used to handle code options
-- menuone: present popup even when there is just one suggestion
-- noinsert: Solely insert textual content when choice is confirmed
-- noselect: pressure us to pick one from the options
vim.decide.completeopt = {'menuone', 'noselect', 'noinsert', 'preview'}
-- shortmess is used to keep away from extreme messages
vim.decide.shortmess = vim.decide.shortmess + { c = true}
native cmp = require'cmp'
cmp.setup({ 
-- Configurations will go right here
})

The very first thing we have to configure is sources, what we do right here is that we set the put in plugins as sources for code options.

-- sources are the put in sources that can be utilized for code options
sources = {
{ identify = 'path' },
{ identify = 'nvim_lsp', keyword_length = 3 },
{ identify = 'nvim_lsp_signature_help'}, 
{ identify = 'nvim_lua', keyword_length = 2},
{ identify = 'buffer', keyword_length = 2 },
{ identify = 'vsnip', keyword_length = 2 },
}

After that, we are going to wish to add mappings!

Mappings are all of the enjoyable, it signifies that we will create keyboard shortcuts for executing sure instructions. In case the Code suggestion dialog presents choices, how can we choose the one we would like, how can we verify, and what ought to occur once we do?

Mappings are straightforward to arrange, the very first thing we do is declare the Keys to activate the motion. The syntax is <Key-Key2-Key3> , it will probably take some time to study what keys can be found, however the docs bought us lined.

I would like the have the identical mappings that I exploit in VS Code, however you’ll be able to set it up nevertheless you need! I shall be utilizing CTRL which is shortened as C. An instance of the way to set off the code completion dialog upon urgent CTRL+SPACE would appear like this.

 ['<C-Space>'] = cmp.mapping.full(),

The cmp bundle we use has a couple of accessible capabilities that may be referred to as and they’re all current right here.

I’ll put feedback above every Mapping, right here is how my code-completion.lua takes care of the mappings.

-- completeopt is used to handle code options
-- menuone: present popup even when there is just one suggestion
-- noinsert: Solely insert textual content when choice is confirmed
-- noselect: pressure us to pick one from the options
vim.decide.completeopt = {'menuone', 'noselect', 'noinsert', 'preview'}
-- shortmess is used to keep away from extreme messages
vim.decide.shortmess = vim.decide.shortmess + { c = true}
native cmp = require'cmp'
cmp.setup({ 
mapping = {
-- Shift+TAB to go to the Earlier Advised merchandise
['<S-Tab>'] = cmp.mapping.select_prev_item(),
-- Tab to go to the following suggestion
['<Tab>'] = cmp.mapping.select_next_item(),
-- CTRL+SHIFT+f to scroll backwards in description
['<C-S-f>'] = cmp.mapping.scroll_docs(-4),
-- CTRL+F to scroll forwards within the description
['<C-f>'] = cmp.mapping.scroll_docs(4),
-- CTRL+SPACE to convey up completion at present Cursor location
['<C-Space>'] = cmp.mapping.full(),
-- CTRL+e to exit suggestion and shut it
['<C-e>'] = cmp.mapping.shut(),
-- CR (enter or return) to CONFIRM the at the moment choice suggestion
-- We set the ConfirmBehavior to insert the Chosen suggestion
['<CR>'] = cmp.mapping.verify({
conduct = cmp.ConfirmBehavior.Insert,
choose = true,
})
},
-- sources are the put in sources that can be utilized for code options
sources = {
{ identify = 'path' },
{ identify = 'nvim_lsp', keyword_length = 3 },
{ identify = 'nvim_lsp_signature_help'}, 
{ identify = 'nvim_lua', keyword_length = 2},
{ identify = 'buffer', keyword_length = 2 },
{ identify = 'vsnip', keyword_length = 2 },
}
})

Open up init.lua and add code-completion.lua to the file.

require('plugins')
require('mason-config')
require('gopls')

As soon as that’s within the configuration, reserve it and open a brand new .go file and take a look at it out! It is best to see code options and have the ability to use the important thing mappings to navigate the options.

If you wish to allow vsnip plugin we additionally want so as to add the next code to the code-completion.lua.

  snippet = {
develop = operate(args)
vim.fn["vsnip#anonymous"](args.physique)
finish,
},

We are able to make it look a bit of bit higher by including some borders to the home windows.

  window = {
completion = cmp.config.window.bordered(),
documentation = cmp.config.window.bordered(),
},

If we add that it’ll as a substitute appear like the next.

Generally it would make sense to edit the formatting, we will as an illustration add icons relying on the supply that the suggestion comes from. The next snippet provides formatting relying on the identify of the supply.

-- completeopt is used to handle code options
-- menuone: present popup even when there is just one suggestion
-- noinsert: Solely insert textual content when choice is confirmed
-- noselect: pressure us to pick one from the options
vim.decide.completeopt = {'menuone', 'noselect', 'noinsert', 'preview'}
-- shortmess is used to keep away from extreme messages
vim.decide.shortmess = vim.decide.shortmess + { c = true}
native cmp = require'cmp'
cmp.setup({ 
-- Required by vsnip
snippet = {
develop = operate(args)
vim.fn["vsnip#anonymous"](args.physique)
finish,
},
-- Add Mappings to manage the code options
mapping = {
-- Shift+TAB to go to the Earlier Advised merchandise
['<S-Tab>'] = cmp.mapping.select_prev_item(),
-- Tab to go to the following suggestion
['<Tab>'] = cmp.mapping.select_next_item(),
-- CTRL+SHIFT+f to scroll backwards in description
['<C-S-f>'] = cmp.mapping.scroll_docs(-4),
-- CTRL+F to scroll forwards within the description
['<C-f>'] = cmp.mapping.scroll_docs(4),
-- CTRL+SPACE to convey up completion at present Cursor location
['<C-Space>'] = cmp.mapping.full(),
-- CTRL+e to exit suggestion and shut it
['<C-e>'] = cmp.mapping.shut(),
-- CR (enter or return) to CONFIRM the at the moment choice suggestion
-- We set the ConfirmBehavior to insert the Chosen suggestion
['<CR>'] = cmp.mapping.verify({
conduct = cmp.ConfirmBehavior.Insert,
choose = true,
})
},
-- sources are the put in sources that can be utilized for code options
sources = {
{ identify = 'path' },
{ identify = 'nvim_lsp', keyword_length = 3 },
{ identify = 'nvim_lsp_signature_help'}, 
{ identify = 'nvim_lua', keyword_length = 2},
{ identify = 'buffer', keyword_length = 2 },
{ identify = 'vsnip', keyword_length = 2 },
},
-- Add borders to the home windows
window = {
completion = cmp.config.window.bordered(),
documentation = cmp.config.window.bordered(),
},
-- add formating of the completely different sources
formatting = {
fields = {'menu', 'abbr', 'sort'},
format = operate(entry, merchandise)
native menu_icon ={
nvim_lsp = 'λ',
vsnip = '⋗',
buffer = 'b',
path = 'p'
}
merchandise.menu = menu_icon[entry.source.name]
return merchandise
finish,
},
})

After making use of that you must see small Icons or textual content relying on the supply.

We now have Code completion in place, however we will do extra!

FileTree & Simple Traversal & First Customized Key Mapping

Up till now, we’ve used the Discover command to modify recordsdata. I can’t advocate that in a dev surroundings if you wish to hold your sanity.

Fortunately there may be a straightforward answer in NeoVim. There’s a very talked-about plugin referred to as nvim-tree which might be discovered on GitHub.

Putting in it by now needs to be a breeze.

Open up the Packer configuration file plugins.lua and add the Nvim plugin. We are going to add nvim-web-devicons it to make the brand new file explorer a bit of nicer.

This time, you will notice a brand new syntax within the Packer configuration, we received’t import the plugin utilizing a string, however reasonably an object with a requirement inside it.

What this implies is that we’ll require the nvim-tree plugin, but in addition require the devicons. This can be utilized to verify we’ve all of the wanted plugins and never just one.

return require('packer').startup(operate(use)
-- Configurations will go right here
use 'wbthomason/packer.nvim'
use 'williamboman/mason.nvim'
use 'williamboman/mason-lspconfig.nvim'
use 'neovim/nvim-lspconfig'
-- Hrsh7th Code Completion Suite
use 'hrsh7th/nvim-cmp' 
use 'hrsh7th/cmp-nvim-lsp'
use 'hrsh7th/cmp-nvim-lua'
use 'hrsh7th/cmp-nvim-lsp-signature-help'
use 'hrsh7th/cmp-vsnip'                             
use 'hrsh7th/cmp-path'                              
use 'hrsh7th/cmp-buffer'                            
use 'hrsh7th/vim-vsnip'
-- File explorer tree
use {
'nvim-tree/nvim-tree.lua',
requires = {
'nvim-tree/nvim-web-devicons', -- non-compulsory, for file icons
},
}
finish)

Observe, for the devicons to work you want Nerd Fonts put in, Merely skip the requirement if you happen to don’t need them. Nerd Fonts are simply put in by scrolling to the underside of that webpage and putting in their patcher software program.

Obtain a font, I exploit the Go-Mono after which add it as a font, I like to recommend utilizing font-manager, see the way to use it right here.

As soon as that’s completed, save the file :w after which reload luafile % after which replace the plugins with PackerSync.

We wish to configure NvimTree at startup, and we are going to seize the configuration from their docs, however add it in order that the tree is opened on begin.

Create a brand new lua script and identify it appropriately, I’ll identify mine file-explorer.lua.

-- disable netrw on the very begin of your init.lua (strongly suggested)
vim.g.loaded_netrw = 1
vim.g.loaded_netrwPlugin = 1
-- set termguicolors to allow spotlight teams
vim.decide.termguicolors = true
-- empty setup utilizing defaults
require("nvim-tree").setup({
open_on_setup = true,
ignore_buffer_on_setup = true,
})

And let’s require that script inside init.lua

require('plugins')
require('file-explorer')
require('mason-config')
require('gopls')
require('code-completion')

Restarting NeoVim will now present us a brand new good tree with the recordsdata so we will navigate.

Navigating within the tree is simple both utilizing the mouse or most of the default mappings it comes with. I like to recommend this information which is good for studying.

You should utilize the shortcuts CTRL+w to enter navigation mode which lets you soar between opened panels, Press both the left or proper key to leap in that path. You can too use CTRL+w+w to leap to the following panel quick.

There are a couple of good instructions you’ll most likely have to know. As soon as you’re contained in the NvimTree, urgent a will will let you create a file, d will delete a file.

Urgent q will shut the tree, and to open it we will run the command :NvimTreeToggle which is lengthy and pointless.

I like having the tree open after I press ctrl+n so I’ll add that mapping.

Utilizing NvimTree I’ll go to the lua listing and create a custom-keys.lua file the place I’ll retailer my private key mappings. I can create the file by urgent a.

-- fetch keymap
native map = vim.api.nvim_set_keymap
-- map the important thing n to run the command :NvimTreeToggle
map('n', 'n', [[:NvimTreeToggle<CR>]], {})

Within the script, we use vim.api.nvim_set_keymap which is a part of the nvim api to create {custom} key mappings. See their docs for all accessible settings and modes.

The primary parameter specifies the mode to allow the important thing mapping, I would like it in regular mode. You can too have it in different modes, such because the Insert mode.

We then set that urgent n will set off the :NvimTreeToggle command, and we append <CR> to auto-trigger the command, we do not wish to press enter every time.

Then, in fact, we have to replace init.lua to incorporate the custom-keys file.

require('plugins')
require('file-explorer')
require('mason-config')
require('gopls')
require('code-completion')
require('custom-keys')

Reopen NeoVim and urgent n will now open the NvimTree, you must set it to the important thing that you just really feel snug with.

Debugging utilizing DAP & DapUI

We now have a file tree, we’ve code completion, and a language server that tells us when one thing is incorrect.

One necessary factor when growing is testing and debugging code, so we have to add that.

We are able to once more use the Mason Plugin, we wish to set up a DAP, and since I give attention to Go, I would like Delve.

Run the command

:MasonInstall delve

After that, we have to set up a plugin referred to as nvim-dap which is used to handle DAPs for a number of languages.

Add it to the plugins.lua, save the file and reload it, you keep in mind the way to proper? Then execute PackerSync.

return require('packer').startup(operate(use)
-- Configurations will go right here
use 'wbthomason/packer.nvim'
use 'williamboman/mason.nvim'
use 'williamboman/mason-lspconfig.nvim'
use 'neovim/nvim-lspconfig'
-- Hrsh7th Code Completion Suite
use 'hrsh7th/nvim-cmp' 
use 'hrsh7th/cmp-nvim-lsp'
use 'hrsh7th/cmp-nvim-lua'
use 'hrsh7th/cmp-nvim-lsp-signature-help'
use 'hrsh7th/cmp-vsnip'                             
use 'hrsh7th/cmp-path'                              
use 'hrsh7th/cmp-buffer'                            
use 'hrsh7th/vim-vsnip'
-- File explorer tree
use 'nvim-tree/nvim-web-devicons' -- non-compulsory, for file icons
use 'nvim-tree/nvim-tree.lua'
-- DAP for debugging
use 'mfussenegger/nvim-dap'
finish)

Relying on the language you wish to debug, we have to configure it. You’ll find a full listing of examples for various languages within the docs.

We start by requiring dap, after which you’ll be able to goal the DAP utilizing the dap.adapters adopted by the adapter identify. In my instance, I’ll goal delve will probably be dap.adapters.delve. The configurations to set needs to be checked for every adapter, I’ll merely make delve run the at the moment opened file.

I’ll create a brand new configuration script, shock!

This one shall be named debugging.lua.

-- fetch the dap plugin
native dap = require('dap')
-- Add adapter to delve
dap.adapters.delve = {
sort = 'server',
port = '${port}',
executable = {
command = 'dlv',
args = {'dap', '-l', '127.0.0.1:${port}'},
}
}
-- https://github.com/go-delve/delve/blob/grasp/Documentation/utilization/dlv_dap.md
dap.configurations.go = {
{
sort = "delve",
identify = "Debug",
request = "launch",
program = "${file}"
},
{
sort = "delve",
identify = "Debug check", -- configuration for debugging check recordsdata
request = "launch",
mode = "check",
program = "${file}"
},
-- works with go.mod packages and sub packages 
{
sort = "delve",
identify = "Debug check (go.mod)",
request = "launch",
mode = "check",
program = "./${relativeFileDirname}"
} 
}

And as at all times, replace init.lua to incorporate the script

require('plugins')
require('file-explorer')
require('mason-config')
require('gopls')
require('code-completion')
require('custom-keys')
require('debugging')

nvim-dap doesn’t include any preset mappings. And utilizing it’s a ache with out mappings.

To set a breakpoint we have to execute the command :lua require'dap'.toggle_breakpoint().

Or to begin debugging the present file we’d like :lua require'dap'.proceed().

As you may perceive, this can be a bit an excessive amount of. Allow us to repair the important thing mappings, as we already know the way to!

I’m going so as to add two mappings first, the primary one is to begin the debugger after I press F5, and the second is to toggle breakpoints utilizing CTRL+b.

Inside custom-keys.lua add the next

-- nvim-dap keymappings
-- Press f5 to debug
map('n', '<F5>', [[:lua require'dap'.continue()<CR>]], {})
-- Press CTRL + b to toggle common breakpoint
map('n', '<C-b>', [[:lua require'dap'.toggle_breakpoint()<CR>]], {})

Restarting NeoVim and urgent CTRL+B in a file will now set the breakpoint, as indicated by the B on the left facet.

Urgent F5 ought to convey up the configuration choice and present all of the completely different configurations we created. You’ll be able to add many various configurations, corresponding to a launch.json. If in case you have one from VS Code.

If you choose 1 the debugger will run, and it’ll cease on the breakpoint. Indicated by an arrow.

As you most likely perceive by now, we will configure the icons and extra. See the plugin docs

We are able to then open a REPL window to make use of delve to seek out values and many others.

Run the next command to discover REPL

:lua require'dap'.repl.open()

It is best to see a brand new window seem

Navigate to it utilizing CTRL+w+arrowdown. Then it’s essential to activate Insert mode by urgent i and take a look at executing a command. I will use the .scopes to see the native scope variables.

You’ll be able to shut the debug window with :q.

Now that we all know the way to use the debugger, allow us to add a couple of extra handy mappings. I’ve added an evidence to every command, you’ll be able to change the buttons to what fits you.

-- nvim-dap keymappings
-- Press f5 to debug
map('n', '<F5>', [[:lua require'dap'.continue()<CR>]], {})
-- Press CTRL + b to toggle common breakpoint
map('n', '<C-b>', [[:lua require'dap'.toggle_breakpoint()<CR>]], {})
-- Press CTRL + c to toggle Breakpoint with Situation
map('n', '<C-c>', [[:lua require'dap'.set_breakpoint(vim.fn.input('Breakpoint Condition: '))<CR>]], {})
-- Press CTRL + l to toggle Logpoint
map('n', '<C-l>', [[:lua require'dap'.set_breakpoint(nil, nil, vim.fn.input('Log Point Msg: '))<CR>]], {})
-- Urgent F10 to step over
map('n', '<F10>', [[:lua require'dap'.step_over()<CR>]], {})
-- Urgent F11 to step into
map('n', '<F11>', [[:lua require'dap'.step_into()<CR>]], {})
-- Urgent F12 to step out
map('n', '<F12>', [[:lua require'dap'.step_out()<CR>]], {})
-- Press F6 to open REPL
map('n', '<F6>', [[:lua require'dap'.repl.open()<CR>]], {})
-- Press dl to run final ran configuration (if you happen to used f5 earlier than it'll re run it and many others)
map('n', 'dl', [[:lua require'dap'.run_last()<CR>]], {})

Now, operating a debugger is wonderful, however generally it may be good to have a UI to assist us.

I like to recommend nvim-dap-ui which makes every little thing look a bit of bit cleaner.

By now, including a plugin needs to be a breeze. Replace plugins.lua.

return require('packer').startup(operate(use)
-- Configurations will go right here
use 'wbthomason/packer.nvim'
use 'williamboman/mason.nvim'
use 'williamboman/mason-lspconfig.nvim'
use 'neovim/nvim-lspconfig'
-- Hrsh7th Code Completion Suite
use 'hrsh7th/nvim-cmp' 
use 'hrsh7th/cmp-nvim-lsp'
use 'hrsh7th/cmp-nvim-lua'
use 'hrsh7th/cmp-nvim-lsp-signature-help'
use 'hrsh7th/cmp-vsnip'                             
use 'hrsh7th/cmp-path'                              
use 'hrsh7th/cmp-buffer'                            
use 'hrsh7th/vim-vsnip'
-- File explorer tree
use 'nvim-tree/nvim-web-devicons' -- non-compulsory, for file icons
use 'nvim-tree/nvim-tree.lua'
-- DAP for debugging
use 'mfussenegger/nvim-dap'
-- UI for DAP
use { "rcarriga/nvim-dap-ui", requires = {"mfussenegger/nvim-dap"} }
finish)

Save, Reload (luafile %) and PackerSync.

After putting in, we have to additionally set it up. Since that is a part of the debugging I’ll retailer it contained in the debugging.lua the place we configure dap. Add a requirement for dapui and execute the setup() operate.

-- fetch the dap plugin
native dap = require('dap')
-- Setup DapUI
native dapui = require('dapui')
-- set it up see extra configs of their repo
dapui.setup()

As with most plugins, this provides a couple of instructions, and we are going to replace custom-keys.lua to set off the DapUi.

DapUI has a toggle operate that brings it up, and we are going to wish to take away the Nvim Tree to make it look a bit of higher.

That is when NeoVim is beginning to grow to be cool, see how we will chain these capabilities collectively simply. Infinite potentialities.

-- Press Ctrl+d to toggle debug mode, will take away NvimTree additionally
map('n', '<C-d>', [[:NvimTreeToggle<CR> :lua require'dapui'.toggle()<CR>]], {})

In the event you execute the identical essential.go that we used earlier, set a breakpoint and begin the debugger (F5). As soon as it halts, press d to convey up the DapUI which reveals the threads, values of variables, REPL with Play/Repeat/Cease buttons.

Press CTRL+d to convey again nvimtree and take away debug bars.

Make NeoVim Reactive Utilizing Occasion Listeners

That is good, we will debug the code that we write.

As you traverse the NeoVim bottomless pit of belongings you wish to do, one great point to know is the way to use Occasions. NeoVim triggers occasions and plugins can even set off occasions.

Simply as in JavaScript, and many others, we will pay attention to those occasions and apply instructions to set off them.

A straightforward solution to study that is to make DapUI seem at any time when we set off a Debug session.

The Nvim DAP will set off two occasions, earlier than and after which might be discovered of their docs.

Inside debugging.lua I’ll add a listener on these occasions, and set off dapui.open after DAP has been initialized. And as soon as DAP is terminated or exited, we are going to shut utilizing dapui.shut.

-- fetch the dap plugin
native dap = require('dap')
-- Setup DapUI
native dapui = require('dapui')
-- set it up see extra configs of their repo
dapui.setup()
-- dap fires occasions, we will pay attention on them to open UI on sure occasions
dap.listeners.after.event_initialized["dapui_config"] = operate()
dapui.open()
finish
dap.listeners.earlier than.event_terminated["dapui_config"] = operate()
dapui.shut()
finish
dap.listeners.earlier than.event_exited["dapui_config"] = operate()
dapui.shut()
finish

Restart the debugger inside essential.go and see the way it now opens robotically and closes.

With listeners, you’ll be able to add formatting, and many others, or something you need.

Styling & Including Growth Utilities

Let’s greatest sincere, what we’ve completed to date is highly effective and versatile as hell, but it surely appears like crap.

To make NeoVim look a bit of bit higher we will begin modifying the colour scheme. Altering the colour schema will apply completely different colours and make issues look higher.

One actually widespread theme is the Dracula theme. It’s most likely widespread as a result of it appears nice and helps many widespread plugins.

It’s tremendous easy to put in, the identical as all different plugins.

The mighty three-step rocket, replace plugger, add a configuration file, add require in init.lua.

Add to plugins.lua

 -- Dracula theme for styling
use 'Mofiqul/dracula.nvim'

Save the file :w, reload the file :luafile %, execute :PackerSync

Create a brand new file named styling.lua by urgent a within the NvimTree.

Inside styling.lua, apply the dracula colorscheme.

vim.cmd[[colorscheme dracula]]

Save the file and replace init.lua to incorporate styling

require('plugins')
require('file-explorer')
require('mason-config')
require('gopls')
require('code-completion')
require('custom-keys')
require('debugging')
require('styling')

Reload NeoVim and it ought to look a lot cooler!

To make it much more highly effective, allow us to add nvim-treesitter. Treesitter is a means to offer a lot better highlighting within the code.

At this level, you’re greater than accustomed to the way to set up a plugin, So I received’t clarify every step, solely present the recordsdata. It is best to have the ability to handle to configure it on you’re personal.

return require('packer').startup(operate(use)
-- Configurations will go right here
use 'wbthomason/packer.nvim'
use 'williamboman/mason.nvim'
use 'williamboman/mason-lspconfig.nvim'
use 'neovim/nvim-lspconfig'
-- Hrsh7th Code Completion Suite
use 'hrsh7th/nvim-cmp' 
use 'hrsh7th/cmp-nvim-lsp'
use 'hrsh7th/cmp-nvim-lua'
use 'hrsh7th/cmp-nvim-lsp-signature-help'
use 'hrsh7th/cmp-vsnip'                             
use 'hrsh7th/cmp-path'                              
use 'hrsh7th/cmp-buffer'                            
use 'hrsh7th/vim-vsnip'
-- File explorer tree
use 'nvim-tree/nvim-web-devicons' -- non-compulsory, for file icons
use 'nvim-tree/nvim-tree.lua'
-- DAP for debugging
use 'mfussenegger/nvim-dap'
-- UI for DAP
use { "rcarriga/nvim-dap-ui", requires = {"mfussenegger/nvim-dap"} }
-- Dracula theme for styling
use 'Mofiqul/dracula.nvim'
-- Treesitter
use {
-- advisable packer means of putting in it's to run this operate, copied from documentation
'nvim-treesitter/nvim-treesitter',
run = operate()
native ts_update = require('nvim-treesitter.set up').replace({ with_sync = true })
ts_update()
finish,
}
finish)

Then a syntax-highlight.lua file to deal with configurations

require'nvim-treesitter.configs'.setup {
-- A listing of parser names, or "all"
ensure_installed = { "go", "lua", "rust" },
-- Set up parsers synchronously (solely utilized to `ensure_installed`)
sync_install = false,
-- Routinely set up lacking parsers when getting into buffer
-- Suggestion: set to false if you do not have `tree-sitter` CLI put in regionally
auto_install = true,
spotlight = {
-- `false` will disable the entire extension
allow = true,
},
}

And init.lua

require('plugins')
require('file-explorer')
require('mason-config')
require('gopls')
require('code-completion')
require('custom-keys')
require('debugging')
require('styling')
require('syntax-highlight')

Restart and the code ought to even spotlight operate names now.

The subsequent plugin we would like is Fuzzy Search recordsdata, it’s referred to as Telescope.

For full capabilities you want RipGrep put in

Let’s add it to Packer.

 -- Telescope used to fuzzy search recordsdata
use {
'nvim-telescope/telescope.nvim', tag = '0.1.0',
requires = { {'nvim-lua/plenary.nvim'} }
}

Then add a file-finder.lua and fill within the configurations, on this case, a key mapping to convey up completely different search bars.

-- search recordsdata, even hidden ones
vim.keymap.set('n', '<chief>ff', ':lua require"telescope.builtin".find_files({no_ignore=true, hidden=true})<CR>', {})
-- ripgrep recordsdata, respects gitignore
vim.keymap.set('n', '<chief>fg', ':lua require"telescope.builtin".live_grep()<CR>', {})

Observe that Stay Grep respects any .gitignore recordsdata and excludes outcomes from them. Until configured to incorporate them.

Then additionally add it to init.lua

require('plugins')
require('file-explorer')
require('mason-config')
require('gopls')
require('code-completion')
require('custom-keys')
require('debugging')
require('styling')
require('file-finder')
require('syntax-highlight')

Now you may discover that the mapping is utilizing Chief which is default by default the backslash key. That is actually messy on my laptop computer, so I’ll remap it into , inside custom-keys.lua by including the next line.

-- replace chief key to ,
vim.g.mapleader = ","

Now, restart NeoVim and luxuriate in an unbelievable fuzzy search

I significantly just like the live-grep search utilizing <Chief>fg that additionally searches for the key phrases contained in the recordsdata.

One remaining piece so as to add, I like having a standing bar that shows a bit of bit of knowledge corresponding to git department and extra.

We are able to add this by including the nvim-lualine plugin.

 -- Lualine info / Standing bar
use {
'nvim-lualine/lualine.nvim',
requires = { 'kyazdani42/nvim-web-devicons', decide = true }
}

After putting in, configure it as you see match, I’ll use the defaults in a brand new file statusbar.lua.

require('lualine').setup()

Then additionally replace init.lua to incorporate the standing bar.

require('plugins')
require('file-explorer')
require('mason-config')
require('gopls')
require('code-completion')
require('custom-keys')
require('debugging')
require('styling')
require('file-finder')
require('syntax-highlight')
require('statusbar')

Restart Neovim and you must see a pleasant little standing bar.

Beneficial Plugins

Here’s a listing of plugins I like to recommend that will provide you with some coaching when putting in.

Autopairs — Generate brackets, and parenthesis pairs while you create them.

Bufferline — Add a header exhibiting opened buffers (recordsdata)

LSPSaga — Code Actions, Floating Hover docs, and many others.

IndentBlankline — Information for indention

FloatTerm — Open floating terminals, good for corresponding to opening LazyGit.

nvim-lint — Linter! A lot wanted.

Bother — Suppose VS Code Buttom Error tab

TODO-Highlights — I like to jot down TODO feedback as reminders, and this plugin makes them searchable with Telescope, and highlights them.

tagbar — To get an outline of the construction, capabilities, and many others in a file.

Conclusion

Now we have realized the way to use NeoVim, there may be in fact extra to study however I believe that can come naturally if you happen to begin utilizing it each day.

To this point we’ve lined essentially the most wanted fundamentals, and the wanted information to begin utilizing NeoVim effectively. It is best to and not using a downside have the ability to use NeoVim after studying this.

You need to be accustomed to the next

• Navigating NeoVim utilizing Regular Mode and Insert Mode
• Executing Instructions in Vim
• Including Plugins & Configuring NeoVim
• Deal with Plugins and their Configurations

Now, I do advocate trying up Linters and Formatters (trace: mason may help you).

It would come as nice follow so that you can set up a plugin on you’re personal to essentially study and make it stick.

Do not forget that there are sometimes Plugins that enable you customise a full improvement surroundings, corresponding to x-ray/go. The cons of them are that they typically include a lot that it’s onerous to essentially study the default mappings and the way to use them.

You’ll find my dotfiles and present NeoVim config on Github.

I hope you loved this text, now go construct your self a dream editor.