The goal of this project is to have a fast Neovim startup, provide mappings that can be easily memorised, interact with the Lua API, and make programming fun.

This setup is mostly customised to for Go (Golang) and Rust development. There is also a few other LSP servers setup for other LSP servers to work with various file types.

This project supports Neovim version 0.10.0 and newer.

• Besides in a few places that Neovim doesn't provide an API in Lua, most configuration is done in Lua.
• LSP, Treesitter, and FZF are setup to work together.
• Seamless navigation with tmux.
• Completion with nvim-cmp plugin is setup.
• It is optimised to handle very large files.
• There are some handy textobjects such as backticks and indents.
• You can add the current location of the cursor or make notes on the current location in the quickfix/local lists with repeatable mappings.
• You can manipulate quickfix/local lists.
• It comes with integration with git and gist.
• Has a lot of useful feedback in the gutter.
• Statusline is configures with feline.
• It is set to give a lot of useful information about the buffer.
• Prettier quickfix buffer and quickfix tools.
• The theme is setup with Lua to take advantage of its performance.

1. Setup
2. Functionality
   • Plugins
   • Core Mappings
   • Text Objects
   • Lists
   • Highlight Matching
   • FZF
   • LSP
   • Snippets
   • Utilities
3. Plugin Licence List

Just clone this project:

$ git clone https://github.com/arsham/shark.git ~/.config/nvim

Once you start Neovim, it will install the package manager and installs the listed plugins.

Some default mappings/commands are augmented to centre the buffer after the execution.

Some mappings/commands are obvious, but I've left them here as a reminder. Some are left out either because they are not used too often, or they are defined after writing this document and I've forgot to document.

I would recommend you have a look at the code to see what is available to you.

This list might change at any time depending on if there is a better replacement or the requirement changes.

In most mappings we are following this theme, unless there is an uncomfortable situation or messes with a community-driven or Vim's very well known mapping:

The leader key is space!

There are more specialised mappings provided, keep reading please!

There are a few tools for interacting with quickfix and local lists. Following mappings can be used for either cases, all you need to do it to substitute w for q or vice versa. Generally q is for quickfix list and w is for local list. I chose w because it's beside q and it makes it easy to think about these two types of lists.

<leader>qq, <leader>ww, <leader>qn and <leader>wn are repeatable with .!

After adding an item to the list, an indicator in the statusline will show you how many items you have in a list.

Additional to nvim-bqf bindings, you can do <count>dd in the quickfix/local list buffers to delete <count> rows from quickfix/local list buffer.

You can highlight words with random colours.

<leader>ma and <leader>me are repeatable with .!

There are a few added commands to what fzf provides.

When a LSP server is attached to a buffer, a series of mappings will be defined for that buffer based on the server's capabilities. When possible, fzf will take over the results of the LSP mappings results.

LSP defines its own set of commands, however I have added a few interesting additions.

The RestartLsp fixes an issue when the LspRestart does not have any effects.

The following list of commands do not fit into any specific categories.

I never was a fan of snippets, until I discovered the LuaSnip plugin and it changed my mind. Here is a demo of a couple of snippets shipped with this setup:

These are commands you can use in Lua land. Assign the required module to a variable and re-use.

local quick = require("arshlib.quick")

Executes a normal command. For example:

quick.normal("n", "y2k")

See :h feedkeys() for values of the mode.

Create highlight groups:

quick.highlight("LspReferenceRead", { ctermbg = 180, guibg = "#43464F", style = "bold" })

These functions will call your function/command and then centres the buffer:

quick.call_and_centre(function()
  print("Yolo!")
end)
quick.cmd_and_centre("SomeCommand")