Mirrors/LunarVim
Mirrors/LunarVim
1
0
Fork 0
mirror of https://github.com/LunarVim/LunarVim.git synced 2024-09-20 10:35:08 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Wiki purged. Documentation moved to LunarVim.org

rebuilt 2021-08-01 03:05:22 +02:00
parent 23c53c73fb
commit 8edb0c20f9
21 changed files with 1 additions and 1569 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
Breaking-changes-in-rolling-and-master-branches.md

@ -1,33 +0,0 @@
## Changes
* The latest changes to LunarVim require you to [remove it completely](https://github.com/ChristianChiarulli/LunarVim/wiki/Uninstalling-LunarVim) before upgrading
* Going forward LunarVim will no longer reside in the nvim configuration folder. LunarVim has been moved to `~/.local/share/lunarvim`.
* To launch Lunarvim use the new `lvim` command. `nvim` will only launch standard neovim.
* Your personal configuration file (`lv-config.lua`) can now be found in `~/.config/lvim`. You can initialize this folder as a git repository to track changes to your configuration files.
* If you want to keep launching LunarVim with the `nvim` command, add an alias entry to your shell's config file: `alias nvim=lvim`. To temporarily revert to the default `nvim` prefix it with a backslash `\nvim`.
## Options in `lv-config.lua` have been renamed
| Old Option | New Option |
| -------- | :----------: |
| O | lvim |
| O.plugin | lvim.builtin |
| O.treesitter | lvim.builtin.treesitter |
| O.keys.leader_key | lvim.leader |
| O.user_plugins | lvim.plugins |
| O.user_which_key | lvim.builtin.which_key |
| O.user_autocommands | lvim.autocommands |
| O.lang | lvim.lang |
| (Did not previously exist) | lvim.lsp.override |
| O.default_options.\<option\> | (removed) Now set options with the form `vim.cmd("set relativenumber")`|
| O.default_options.on_attach_callback | lvim.lsp.on_attach_callback |
| O.disabled_built_ins | (removed) |
| O.formatters.filetype | lvim.lang.c.formatter.exe |
| O.completion.autocomplete | lvim.builtin.compe.autocomplete|
## Listing available settings
In case you want to see all the settings inside LunarVim, run the following command from `~/.local/share/lunarvim/lvim`:
```bash
lvim --headless +'lua require("utils").generate_settings()' +qa && sort -o lv-settings.lua{,}
```
and then inspect `lv-settings.lua` file

24
Clipboard-Support.md

@ -1,24 +0,0 @@
- On Mac `pbcopy` should be built-in
- Ubuntu
```bash
sudo apt install xclip
```
- Arch
```bash
sudo pacman -S xclip
```
- WSL2
Make sure ~/bin is in your path in this case.
```bash
curl -sLo/tmp/win32yank.zip https://github.com/equalsraf/win32yank/releases/download/v0.0.4/win32yank-x64.zip
unzip -p /tmp/win32yank.zip win32yank.exe > /tmp/win32yank.exe
chmod +x /tmp/win32yank.exe
mv /tmp/win32yank.exe ~/bin
```

36
Colorschemes.md

@ -1,36 +0,0 @@
Color schemes are provided by [nvcode-color-schemes.vim](https://github.com/ChristianChiarulli/nvcode-color-schemes.vim).
Follow that link for information about editing specific colors for a
color scheme. The provided color schemes are compatible with tree-sitter
highlight groups. Color schemes are installed to
\~/.local/share/nvim/site/pack/packer/opt/nvcode-color-schemes.vim. If
you edit files in that directory, they will be overwritten the next time
Packer compiles your plugins.
## Available colorschemes:
``` bash
lunar
spacegray
nvcode (basically just dark+)
onedark
nord
aurora (more colorful nord)
gruvbox
palenight
snazzy (Based on hyper-snazzy by Sindre Sorhus)
```
## Switching colors
To switch color schemes on the fly, type the following command:
``` vim
:Telescope colorscheme
```
To change the color scheme permanently, modify
\~/.config/nvim/lv-config.lua
``` lua
O.colorscheme = 'lunar'
```

16
Community-Links.md

@ -1,16 +0,0 @@
🕸️ Website: https://www.chrisatmachine.com
🐦 Twitter: https://twitter.com/chrisatmachine
💻 Github: https://github.com/ChristianChiarulli
📺 YouTube: https://www.youtube.com/channel/UCS97tchJDq17Qms3cux8wcA
📺 Odysee: https://odysee.com/@chrisatmachine:f
📺 Twitch: https://www.twitch.tv/chrisatmachine
🗨️ Matrix: https://matrix.to/#/+atmachine:matrix
🗨️ Discord: https://discord.gg/Xb9B4Ny

2
Debugging.md

@ -1,2 +0,0 @@
LunarVim uses nvim-dap for debugging. To set up your particular debugger, look here:
[link](https://github.com/mfussenegger/nvim-dap/wiki/Debug-Adapter-installation)

126
Enabling-a-language-server.md

@ -1,126 +0,0 @@
Neovim comes bundled with a language client but not a language server.
To install a supported language server:
``` md
:LspInstall <your_language_server>
```
See [LspInstall](https://github.com/kabouzeid/nvim-lspinstall) for more
info.
In order for Java LSP to work, edit `~/.local/share/nvim/lspinstall/java/jdtls.sh` and replace `WORKSPACE="$1"` with `WORKSPACE="$HOME/workspace"`
Most common languages should be supported out of the box, if yours is
not I would welcome a PR
### Julia support
Julia support has been added to LunarVim but the LspInstall project does not yet have an installer for it. You cannot ':LspInstall julia'
To install the Julia language server:
* Create a file with the following code (install.jl):
```
using Pkg;
Pkg.add("LanguageServer")
Pkg.add("SymbolServer")
Pkg.instantiate()
```
* Run the file you created
```
julia install.jl
```
## LSP errors
LunarVim lists the attached lsp server in the bottom status bar. If it
says ‘No client connected’ use :LspInfo to troubleshoot.
### Understanding LspInfo
1. Make sure there is a client attached to the buffer. 0 attached
clients means lsp is not running
2. Active clients are clients in other files you have open
3. Clients that match the filetype will be listed. If installed with
:LspInstall <servername> the language servers will be installed.
4. ‘cmd’ must be populated. This is the language server executable. If
the ‘cmd’ isn’t set or if it’s not executable you won’t be able to
run the language server.
* In the example below ‘efm-langserver’ is the name of the binary
that acts as the langserver. If we run ‘which efm-langserver’ and we
get a location to the executable, it means the langauge server is
installed and available globally.
* If you know the command is installed AND you don’t want to install
it globally you’ll need to manually set 'cmd' in the language server
settings.
* Configurations are stored in ~/.config/nvim/lua/lsp/
The settings will be stored in a file that matches the name of the language.
e.g. python-ls.lua
* ‘identified root’ must also be populated. Most
language servers require you be inside a git repository for the root
to be detected. If you don’t want to initialize the directory as a
git repository, an empty .git/ folder will also work.
5. Some language servers get set up on a per project basis so you may
have to reinstall the language server when you move to a different
project.
### Example configurations
[ ======== LSP NOT running ======== ]
``` md
0 client(s) attached to this buffer:
0 active client(s):
Clients that match the filetype python:
Config: efm
cmd: /Users/my-user/.local/share/nvim/lspinstall/efm/efm-langserver
cmd is executable: True
identified root: None
custom handlers:
Config: pyright
cmd: /Users/my-user/.local/share/nvim/lspinstall/python/node_modules/.bin/pyright-langserver --stdio
cmd is executable: True
identified root: None
custom handlers: textDocument/publishDiagnostics
```
---
[ ======== LSP IS running ======== ]
``` md
2 client(s) attached to this buffer: pyright, efm
Client: pyright (id 1)
root: /home/my-user/workspace/canary
filetypes: python
cmd: /home/my-user/.local/share/nvim/lspinstall/python/node_modules/.bin/pyright-langserver --stdio
Client: efm (id 2)
root: /home/my-user/workspace/canary
filetypes: lua, python, javascriptreact, javascript, typescript, typescriptreact, sh, html, css, json, yaml, markdown, vue
cmd: /home/my-user/.local/share/nvim/lspinstall/efm/efm-langserver
```
### Last resort
If you still have problems after implementing the above measures, rule
out plugin problems with the following. This reinstalls your plugins and
language servers.
``` md
rm -rf ~/.local/share/nvim/site
:PackerCompile
:PackerInstall
:LspInstall python <-- REPLACE WITH YOUR OWN LANGUAGE
:LspInstall efm <-- REPLACE WITH YOUR OWN LANGUAGE
```
For a more in depth LSP support:
[link](https://github.com/neovim/nvim-lspconfig/blob/master/CONFIG.md)

248
Example-plugin-configurations.md

@ -1,248 +0,0 @@
# Table of contents
- [Usage](#usage)
- [TrueZen](#truezen)
- [Hop](#hop)
- [Nvim-lastplace](#nvim-lastplace)
- [Lightspeed](#lightspeed)
- [Goto-preview](#goto-preview)
- [Persistence](#persistence)
## Usage
These example configurations are meant to be placed inside lv-config.lua using the user_plugins table.
```bash
# lv-config.lua
# Other, user-defined plugins will be entries in the user_plugins table
O.user_plugins = {{<Git Repository>}, {<Another Git Repository>}, {<...etc>}}
O.user_plugins = {{"folke/tokyonight.nvim"}}
```
## [TrueZen](https://github.com/Pocco81/TrueZen.nvim)
### TrueZen Packer declaration
```lua
-- ~/.config/nvim/lv-config.lua
{
"Pocco81/TrueZen.nvim",
cmd = {"TZAtaraxis","TZMinimalist", "TZFocus"},
config = function()
require("lv-zen").config() -- ~/.config/nvim/lua/lv-zen/init.lua
end
}
```
### TrueZen configuration
```lua
-- ~/.config/nvim/lua/lv-zen/init.lua
local M = {}
M.config = function()
require("true-zen").setup({
ui = {
bottom = {
laststatus = 0,
ruler = false,
showmode = false,
showcmd = false,
cmdheight = 1,
},
top = {
showtabline = 0,
},
left = {
number = false,
relativenumber = false,
signcolumn = "no",
},
},
modes = {
ataraxis = {
left_padding = 5,
right_padding = 5,
top_padding = 1,
bottom_padding = 1,
ideal_writing_area_width = 0,
just_do_it_for_me = false,
keep_default_fold_fillchars = true,
custome_bg = "",
bg_configuration = true,
affected_higroups = {
NonText = {},
FoldColumn = {},
ColorColumn = {},
VertSplit = {},
StatusLine = {},
StatusLineNC = {},
SignColumn = {},
},
},
focus = {
margin_of_error = 5,
focus_method = "experimental",
},
},
integrations = {
vim_gitgutter = false,
galaxyline = true,
tmux = false,
gitsigns = false,
nvim_bufferline = false,
limelight = false,
vim_airline = false,
vim_powerline = false,
vim_signify = false,
express_line = false,
},
misc = {
on_off_commands = false,
ui_elements_commands = false,
cursor_by_mode = false,
},
})
end
return M
```
## [Hop](https://github.com/phaazon/hop.nvim)
Allows you to jump anywhere in the window with as few keystrokes as possible.
### Hop Packer declaration
```lua
-- ~/.config/nvim/lv-config.lua
{
"phaazon/hop.nvim",
event = "BufRead",
config = function()
require("lv-hop").config()
end,
}
```
### Hop configuration
```lua
-- ~/.config/nvim/lua/lv-hop/init.lua
local M = {}
M.config = function()
require("hop").setup()
vim.api.nvim_set_keymap("n", "s", ":HopChar2<cr>", { silent = true })
vim.api.nvim_set_keymap("n", "S", ":HopWord<cr>", { silent = true })
end
return M
```
## [Nvim-lastplace](https://github.com/ethanholz/nvim-lastplace)
Intelligently reopen files at your last edit position.
### Nvim-lastplace declaration and configs
```lua
{
"ethanholz/nvim-lastplace",
event = "BufRead"
config = function()
require'nvim-lastplace'.setup {
lastplace_ignore_buftype = {"quickfix", "nofile", "help"},
lastplace_ignore_filetype = {
"gitcommit", "gitrebase", "svn", "hgcommit"
},
lastplace_open_folds = true
}
end,
}
```
## [Lightspeed](https://github.com/ggandor/lightspeed.nvim)
Quick and efficient on-screen navigation
### Lightspeed declaration and configs
```lua
{
"ggandor/lightspeed.nvim",
event = "BufRead",
}
```
## [Goto-preview](https://github.com/rmagatti/goto-preview)
A small Neovim plugin for previewing native LSP's goto definition calls in floating windows.
### Goto-preview declaration and configs
```lua
-- ~/.config/nvim/lua/lv-goto-preview/init.lua
local M = {}
M.config = function ()
require('goto-preview').setup {
width = 120; -- Width of the floating window
height = 25; -- Height of the floating window
default_mappings = false; -- Bind default mappings
debug = false; -- Print debug information
opacity = nil; -- 0-100 opacity level of the floating window where 100 is fully transparent.
post_open_hook = nil -- A function taking two arguments, a buffer and a window to be ran as a hook.
}
end
-- could have just used "default_mappings = true" setup option
-- but this way we can explicitly see mappings
vim.cmd("nnoremap gpd <cmd>lua require('goto-preview').goto_preview_definition()<CR>")
vim.cmd("nnoremap gpi <cmd>lua require('goto-preview').goto_preview_implementation()<CR>")
vim.cmd("nnoremap gP <cmd>lua require('goto-preview').close_all_win()<CR>")
return M
```
```lua
-- ~/.config/nvim/lv-config.lua
{
"rmagatti/goto-preview",
config = function()
require('lv-goto-preview').config()
end
}
```
## [Persistence](https://github.com/folke/persistence.nvim)
Persistence is a simple lua plugin for automated session management.
### Persistence.nvim declaration and configs
```lua
-- ~/.config/nvim/lv-config.lua
O.user_plugins = {
{
"folke/persistence.nvim",
event = "VimEnter",
module = "persistence",
config = function()
require("persistence").setup {
dir = vim.fn.expand(vim.fn.stdpath "config" .. "/session/"),
options = { "buffers", "curdir", "tabpages", "winsize" },
}
end,
},
}
O.user_which_key = {
Q = {
name = "+Quit",
s = { "<cmd>lua require('persistence').load()<cr>", "Restore for current dir" },
l = { "<cmd>lua require('persistence').load(last=true)<cr>", "Restore last session" },
d = { "<cmd>lua require('persistence').stop()<cr>", "Quit without saving session" },
},
}
```
```

79
Extending-Configurations-for-Core-Plugins.md

@ -1,79 +0,0 @@
## Extending Configurations for Core Plugins
The core plugins come pre-configured. Sometimes you may want to extend the configuration of these plugins to enable additional functionality. For example, if you want have autopairs automatically close your function definitions, you need to specify endwise rules.
LunarVim provides a way to extend the default configurations by adding the following to your configuration file. This specifies code to run after the configuration for autopairs has completed.
```lua
lvim.builtin.autopairs.on_config_done = function(module)
-- YOUR_VALID_CONFIG_HERE
end
```
To complete our example. This is what our endwise rule might look like. When the trigger is typed `def`, autopairs will add a corresponding `end`.
``` lua
lvim.builtin.autopairs.on_config_done = function()
local autopairs = require('nvim-autopairs')
local endwise = require('nvim-autopairs.ts-rule').endwise
autopairs.add_rules(
{
endwise('def', 'end',nil, nil)
})
end
```
## Configuring debug adapters
Here is a sample configuration for setting up a debugger for cpp
``` lua
lvim.builtin.dap.on_config_done = function()
local dap = require('dap')
dap.adapters.lldb = {
type = 'executable',
command = '/usr/bin/lldb-vscode',
name = "lldb"
}
dap.configurations.cpp = {
{
name = "Launch",
type = "lldb",
request = "launch",
program = "${workspaceFolder}/build/binary_name",
cwd = "${workspaceFolder}/build",
stopOnEntry = false,
args = {},
runInTerminal = false,
},
}
dap.configurations.c = dap.configurations.cpp
end
```
## Modifying Galaxyline
If you don't want to see all the elements of the galaxyline, you can remove portions like so:
``` lua
lvim.builtin.galaxyline.on_config_done = function(module)
local section = module.section
-- print the entire table
-- print(vim.inspect(gls.right))
-- type :messages to read the printed output
-- print an element at a given index. Lua table indexes start at 1
-- print(vim.inspect(gls.right[1]))
-- remove the sections you don't want. The remove function takes an index. Leaving off the index will remove the last item from the table.
table.remove(section.right, 1)
table.remove(section.right, 1)
table.remove(section.right, 1)
table.remove(section.right, 1)
-- This will remove the entire right side. You can add in the sections you want
-- gls.right = {}
end
```

38
Formatters-and-Linters.md

@ -1,38 +0,0 @@
# EFM server
In order for linters and formatters to work you will need to install
`efm-langserver`
``` vim
:LspInstall efm
```
# Formatters and Linters
**Python**
``` bash
pip3 install --user flake8
pip3 install --user yapf
```
**Lua**
``` bash
luarocks install --server=https://luarocks.org/dev luaformatter
cargo install stylua # (this is the one we use for LunarVim)
```
**Yaml, Json, Javascript, HTML, CSS**
``` bash
npm install -g prettier
```
**Markdown**
``` bash
pandoc
```

46
Getting-Started.md

@ -1,46 +0,0 @@
## Leader and Whichkey
The default leader key is set to &lt;Space&gt;. Pressing space will also
open up [Whichkey](https://github.com/folke/which-key.nvim). Whichkey
will help you easily access many of the default keybindings. Whichkey
defines keymappings in this file:
\~/.config/nvim/lua/lv-which-key/init.lua .
The speed the Whichkey window opens is determined by the 'timeoutlen' setting. 'timeoutlen' also defines the timeout length for any key combination. Change this value in ~/.config/nvim/lua/settings.lua. Or add an entry
for it in your personal configuration file ~/.config/nvim/lv-config.lua so it
won't be changed the next time you update LunarVim.
```
-- ~/.config/nvim/lv-config.lua
O.timeoutlen = 400 -- Timeout value in milliseconds
```
## Other key bindings
Other key bindings can be found in \~/.config/nvim/lua/keymappings.lua. This file is for the set of keybindings that aren't mapped to the Leader key.
If you already have a set of keybindings you prefer, the best place to put these bindingsis the ~/.config/nvim/lv-config.lua file. This way, they won't be overwritten when you updateLunarVim.
If you mappings are in vimscript you can translate your old bindings to lua by following the lua guide available
[here](https://github.com/nanotee/nvim-lua-guide)
Or if you prefer to keep your mappings in vimscript, wrap them in the vim.cmd function
```
-- ~/.config/nvim/lv-config.lua
vim.cmd([[
PLACE_YOUR_VIMSCRIPT_HERE
]])
```
## Configuration files in the order they are loaded
| Path | Description |
|-------------------------------------|----------------------------|
| \~/.config/nvim/lua/default-config.lua | This is where the global variable 'O' is defined. |
| \~/.config/nvim/lv-config.lua | Your personal settings file |
| \~/.config/nvim/settings.lua | Sane defaults for neovim. This file sets neovim editor related configurations like wrapping line and tab spacing, etc |
| \~/.config/nvim/lua/plugins.lua | Plugins are defined here |
| \~/.config/nvim/lua/lv-utils | LunarVim utility functions |
| \~/.config/nvim/lua/keymappings.lua | Key bindings that don't contain the leader key |
| \~/.config/nvim/lua/lv-which-key.lua | Key bindings that start with the leader key |

26
Home.md

@ -1,26 +1,2 @@
# Notice
Much of the documentation here is outdated and will be purged soon. Updated documentation [resides here](https://www.lunarvim.org)
# Table of contents
- [What’s included?](https://github.com/ChristianChiarulli/LunarVim/wiki/What's-Included%3F)
- [Project Goals](https://github.com/ChristianChiarulli/LunarVim/wiki/Project-Goals)
- [Installation](https://github.com/ChristianChiarulli/LunarVim/wiki/Installation)
- [Getting started](https://github.com/ChristianChiarulli/LunarVim/wiki/Getting-Started)
- [Installing Plugins](https://github.com/ChristianChiarulli/LunarVim/wiki/Installing-Plugins)
- [Extending Configurations for Core Plugins](https://github.com/ChristianChiarulli/LunarVim/wiki/Extending-Configurations-for-Core-Plugins)
- [Removing Plugins](https://github.com/ChristianChiarulli/LunarVim/wiki/Removing-Plugins)
- [Example plugin configuration](https://github.com/ChristianChiarulli/LunarVim/wiki/Example-plugin-configurations)
- [Using Packer](https://github.com/ChristianChiarulli/LunarVim/wiki/Using-Packer)
- [Clipboard Support](https://github.com/ChristianChiarulli/LunarVim/wiki/Clipboard-Support)
- [Enabling a language server](https://github.com/ChristianChiarulli/LunarVim/wiki/Enabling-a-language-server)
- [Formatters and Linters](https://github.com/ChristianChiarulli/LunarVim/wiki/Formatters-and-Linters)
- [Debugging](#debugging)
- [VSCodium](https://github.com/ChristianChiarulli/LunarVim/wiki/Setting-up-VSCodium)
- [Colorschemes](https://github.com/ChristianChiarulli/LunarVim/wiki/Colorschemes)
- [Useful commands for
troubleshooting](https://github.com/ChristianChiarulli/LunarVim/wiki/Useful-command-for-troubleshooting)
- [Uninstalling LunarVim](https://github.com/ChristianChiarulli/LunarVim/wiki/Uninstalling-LunarVim)
- [Community links](https://github.com/ChristianChiarulli/LunarVim/wiki/Community-Links)
Documentation has been moved to [the LunarVim Documentation site](https://www.lunarvim.org)

131
Installation.md

@ -1,131 +0,0 @@
Make sure you have the newest version of Neovim (0.5).
``` bash
bash <(curl -s https://raw.githubusercontent.com/ChristianChiarulli/lunarvim/master/utils/installer/install.sh)
```
After installation run `nvim` and then `:PackerInstall`
## Get the latest version of Neovim
Some operating systems package versions of Neovim 0.5. You can install
those or you can follow the steps below to compile from source.
Compiling from source is the recommended method.
First, get the dependencies. For distributions other than Ubuntu or Arch
go
[here](https://github.com/neovim/neovim/wiki/Building-Neovim#build-prerequisites)
``` bash
#Ubuntu
sudo apt-get install gettext libtool libtool-bin autoconf automake cmake g++ pkg-config unzip build-essential
#Arch
sudo pacman -S base-devel cmake unzip ninja tree-sitter
```
Download and compile Neovim
``` bash
cd $(mktemp -d)
git clone https://github.com/neovim/neovim
cd neovim
sudo make CMAKE_BUILD_TYPE=Release install
cd ..
sudo rm -r neovim
```
or if you are on Arch you can get it from the AUR
``` bash
yay -S neovim-git
```
If you are on Gentoo you have to emerge the 9999 neovim version with luajit as the lua single target
## Manual install
First make sure you have version [0.5 of
neovim](#get-the-latest-version-of-neovim).
Back up your current configuration files
```bash
mv ~/.config/nvim ~/.config/nvim.bak
```
Install xclip, python3, ripgrep, fzf, npm, nodejs, pip, and ranger with the package manager for your distribution.
```bash
# Ubuntu
sudo apt install xclip python3-pip nodejs npm ripgrep fzf ranger libjpeg8-dev zlib1g-dev python-dev python3-dev libxtst-dev python3-pip
# Arch
sudo pacman -S xclip python python-pip nodejs npm ripgrep fzf ranger
# Fedora
sudo dnf groupinstall "X Software Development"
sudo dnf install -y xclip python3-devel pip nodejs npm ripgrep fzf ranger
pip3 install wheel ueberzug
# Gentoo
sudo emerge -avn sys-apps/ripgrep app-shells/fzf app-misc/ranger dev-python/neovim-remote virtual/jpeg sys-libs/zlib
sudo emerge -avn dev-python/pip
# Optional. Enable npm USE flag with flaggie
sudo flaggie net-libs/nodejs +npm
sudo emerge -avnN net-libs/nodejs
# Mac
brew install lua node yarn ripgrep fzf ranger
sudo curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
python3 get-pip.py
rm get-pip.py
```
Install tree-sitter. To globally install packages without the need for sudo
follow [this guide](https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally)
```bash
npm install -g tree-sitter-cli
```
Install ueberzug, neovim-remote, and pynvim with pip3
```bash
pip3 install ueberzug neovim neovim-remote pynvim --user
```
Clone Packer
```bash
git clone https://github.com/wbthomason/packer.nvim ~/.local/share/nvim/site/pack/packer/start/packer.nvim
```
Clone LunarVim
```bash
#Master Branch
git clone https://github.com/ChristianChiarulli/lunarvim.git ~/.config/nvim
```
Copy the default configuration
```
cp /home/$USER/.config/nvim/utils/installer/lv-config.example.lua /home/$USER/.config/nvim/lv-config.lua
```
Install plugins
```
nvim -u $HOME/.config/nvim/init.lua +PackerInstall
```
## Troubleshooting installation problems
If you encounter problems with the installation check the following:
1. Make sure you have at least version 0.5 of neovim. There were some breaking changes in the development of 0.5 so upgrade to the newest available version to rule out incompatibilities.
2. Make sure neovim was compiled with luajit.
```bash
# The output of version information should include a line for: LuaJIT
nvim -v
```
3. If you ran the [quick-install script](#install-in-one-command) using sudo, follow the steps to [uninstall](#uninstalling) and try again without sudo.
4. Make sure the [dependencies](#useful-programs) were installed.
5. Make sure your plugins are installed and updated. Run :PackerSync

31
Installing-Plugins.md

@ -1,31 +0,0 @@
## Core plugins
LunarVim comes bundled with a small set of default plugins. To enable a plugin, add an entry for it in your personal configuration file.
```lua
-- Master branch ~/.config/nvim/lv-config.lua
O.plugin.galaxyline.active = true
-- Master branch ~/.config/nvim/lv-config.lua
lvim.builtin.galaxyline.active = true
```
To learn how to extend the configuration of these core plugins go [here](https://github.com/ChristianChiarulli/LunarVim/wiki/Extending-Configurations-for-Core-Plugins)
## User-defined plugins
If you'd like to install plugins that aren't bundled with LunarVim, define them in your personal configuration file. Any plugins you want to use should be defined in `lv-config.lua` using the user_plugins table.
```lua
-- lv-config.lua
-- Other, user-defined plugins will be another entry in this table
O.user_plugins = {
{"folke/tokyonight.nvim"}, {
"ray-x/lsp_signature.nvim",
config = function() require"lsp_signature".on_attach() end,
event = "InsertEnter"
}
}
```
## Example plugins
We've provided some example configuration of plugins [here](https://github.com/ChristianChiarulli/LunarVim/wiki/Example-plugin-configurations)

11
Project-Goals.md

@ -1,11 +0,0 @@
- This project aims to help one transition away from VSCode, and into a
superior text editing experience. (Just making this clear)
- This is also a community project, if you would like to see support for
a feature or
[language](https://github.com/neovim/nvim-lspconfig/blob/master/CONFIG.md)
consider making a PR.
- This project will do it’s best to include core features you would
expect from a modern IDE, while making it easy to add or remove what
the user wants.

11
Removing-Plugins.md

@ -1,11 +0,0 @@
## Removing plugins
To disable a plugin set it's active state to 'false'.
```
-- ~/.config/nvim/lv-config.lua
O.plugin.hop.active = false
-- Or remove the entry from user_plugins
O.user_plugins = {}
```
Then run :PackerClean to delete the plugin files.

23
Setting-up-VSCodium.md

@ -1,23 +0,0 @@
I recommend you support Free/Libre versions if you plan to use VSCode:
- [VSCodium](https://vscodium.com/)
- Article to get you set up with VSCodium:
[link](https://www.chrisatmachine.com/Neovim/22-vscodium-neovim/)
After installing the [Neovim
extension](https://github.com/asvetliakov/vscode-neovim) in VSCode
I recommend using this alongside the VSCode
[which-key](https://github.com/VSpaceCode/vscode-which-key) extension
You will also need `settings.json` and `keybindings.json` which can be
found in utils/vscode\_config
Point the nvim path to your `nvim` binary
Point your `init.vim` path to:
``` vim
$HOME/.config/nvim/vimscript/lv-vscode/init.vim
```

12
Uninstalling-LunarVim.md

@ -1,12 +0,0 @@
Changed your mind about LunarVim? To remove it entirely:
``` lua
# Delete the configuration files
rm -rf ~/.config/nvim
# Delete the plugins
rm -rf ~/.local/share/nvim/site/pack/packer
# Delete the logs
rm -rf ~/.cache/nvim
```

29
Useful-command-for-troubleshooting.md

@ -1,29 +0,0 @@
Whether you plan on using LunarVim as is or as a base to configure your
own neovim, the following commands may be useful. Any command that
includes the symbol ‘:’ is meant to be typed as a command in neovim.
Make sure you’re in normal mode not insert mode.
| Command | Description |
|----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| :checkhealth | Check the health of your neovim install |
| :checkhealth &lt;pluginname&gt; | Check the health of a plugin |
| nvim -v | checks your neovim version |
| nvim -V | vebose output when running neovim. Prints out every event |
| :PackerCompile | Must be run when you make plugin changes. (or, alternately run :PackerSync) |
| :PackerInstall | Only install missing plugins |
| :PackerUpdate | Update and install plugins |
| :PackerClean | Remove any disabled or unused plugins |
| :PackerSync | Performs ‘PackerClean’ then ‘PackerUpdate’ |
| :PackerStatus | List the status of your plugins |
| :LspInstall &lt;language&gt; | Install a language server for a specific programming language |
| :LspInfo | List the status of active and configured language servers |
| :LspStart &lt;language&gt; | Start the requested server name. Will only succesfully start if the command detects a root directory matching the current config. Pass autostart = false to your .setup{} call for a language server if you would like to launch clients solely with this command. Defaults to all servers matching current buffer filetype. |
| :LspStop | Stops all buffer clients |
| :LspRestart | Restarts all buffer clients |
| :map | List keybindings |
| :nmap | List normal mode keybindings |
| :vmap | List visual mode keybindings |
| :imap | List insert mode keybindings |
| :verbose map &lt;keybinding&gt; | Print out what a particular keybinding is mapped to |
| :messages | Print error messages. Useful when messages get cut off |
| :scriptnames | List all sourced files |

35
Using-Packer.md

@ -1,35 +0,0 @@
[Packer](https://github.com/wbthomason/packer.nvim) manages your
installed plugins. Any time you make changes to your list of plugins in
\~/.config/nvim/lua/plugins.lua you must first run the command
:PackerCompile then :PackerInstall. \#\# Packer commands
``` bash
-- You must run this or `PackerSync` whenever you make changes to your plugin configuration
:PackerCompile
-- Only install missing plugins
:PackerInstall
-- Update and install plugins
:PackerUpdate
-- Remove any disabled or unused plugins
:PackerClean
-- Performs `PackerClean` and then `PackerUpdate`
:PackerSync
-- View the status of your plugins
:PackerStatus
```
## Packer reports missing plugins
If you get an error message about missing plugins and the above commands
do not work, remove the plugin directory and reinstall from scratch.
``` bash
rm -rf ~/.local/share/nvim/site
:PackerCompile
:PackerInstall
```

593
WIP:-Lunar-Modules.md

@ -1,593 +0,0 @@
## Octo
```lua
{
"pwntester/octo.nvim",
event = "BufRead",
}
```
## Gitlinker
```lua
{
"ruifm/gitlinker.nvim",
event = "BufRead",
config = function()
require("gitlinker").setup {
opts = {
-- remote = 'github', -- force the use of a specific remote
-- adds current line nr in the url for normal mode
add_current_line_on_normal_mode = true,
-- callback for what to do with the url
action_callback = require("gitlinker.actions").open_in_browser,
-- print the url after performing the action
print_url = false,
-- mapping to call url generation
mappings = "<leader>gy",
},
}
end,
requires = "nvim-lua/plenary.nvim",
}
```
## Hop
```lua
{
"phaazon/hop.nvim",
event = "BufRead",
config = function()
require("hop").setup()
vim.api.nvim_set_keymap("n", "s", ":HopChar2<cr>", { silent = true })
vim.api.nvim_set_keymap("n", "S", ":HopWord<cr>", { silent = true })
end,
}
```
## Better Todo Comments
```lua
{
"folke/todo-comments.nvim",
event = "BufRead",
}
```
## Easily Create Gists
```lua
{
"mattn/vim-gist",
event = "BufRead",
requires = "mattn/webapi-vim",
}
```
## Git Blame
```lua
{
"f-person/git-blame.nvim",
event = "BufRead",
}
vim.cmd "highlight default link gitblame SpecialComment"
vim.g.gitblame_enabled = 0
```
## LSP Colors
```lua
{
"folke/lsp-colors.nvim",
event = "BufRead",
}
```
## Ranger
```lua
{
"kevinhwang91/rnvimr",
cmd = "Rnvimr",
config = function()
require("lv-rnvimr").config()
end,
}
-- Make Ranger replace netrw and be the file explorer
-- vim.g.rnvimr_ex_enable = 1
vim.g.rnvimr_draw_border = 1
vim.g.rnvimr_pick_enable = 1
vim.g.rnvimr_bw_enable = 1
vim.api.nvim_set_keymap("n", "-", ":RnvimrToggle<CR>", { noremap = true, silent = true })
```
## Dial :Enhanced increment/decrement
```lua
{
"monaqa/dial.nvim",
event = "BufRead",
config = function()
require("lv-dial").config()
end,
}
local M = {}
M.config = function()
vim.cmd [[
nmap <C-a> <Plug>(dial-increment)
nmap <C-x> <Plug>(dial-decrement)
vmap <C-a> <Plug>(dial-increment)
vmap <C-x> <Plug>(dial-decrement)
vmap g<C-a> <Plug>(dial-increment-additional)
vmap g<C-x> <Plug>(dial-decrement-additional)
]]
local dial = require "dial"
dial.augends["custom#boolean"] = dial.common.enum_cyclic {
name = "boolean",
strlist = { "true", "false" },
}
table.insert(dial.config.searchlist.normal, "custom#boolean")
-- For Languages which prefer True/False, e.g. python.
dial.augends["custom#Boolean"] = dial.common.enum_cyclic {
name = "Boolean",
strlist = { "True", "False" },
}
table.insert(dial.config.searchlist.normal, "custom#Boolean")
end
return M
```
## matchup
```lua
{
"andymass/vim-matchup",
event = "CursorMoved",
config = function()
require("lv-matchup").config()
end,
}
local M = {}
M.config = function()
vim.g.matchup_matchparen_offscreen = { method = "popup" }
end
return M
```
## numb
```lua
{
"nacro90/numb.nvim",
event = "BufRead",
config = function()
require("numb").setup {
show_numbers = true, -- Enable 'number' for the window while peeking
show_cursorline = true, -- Enable 'cursorline' for the window while peeking
}
end,
}
```
## Better quickfix
```lua
{
"kevinhwang91/nvim-bqf",
event = "QuickFixCmdPre",
}
```
## Search & Replace
```lua
{
"windwp/nvim-spectre",
event = "BufRead",
config = function()
require("spectre").setup()
end,
}
```
## lsp root with this nvim-tree will follow you
```lua
{
"ahmedkhalf/lsp-rooter.nvim",
event = "BufRead",
config = function()
require("lsp-rooter").setup()
end,
}
```
## Markdown preview
```lua
{
"iamcco/markdown-preview.nvim",
run = "cd app && npm install",
ft = "markdown",
}
```
## HTML preview
```lua
{
"turbio/bracey.vim",
cmd = {"Bracey", "BracyStop", "BraceyReload", "BraceyEval"},
run = "npm install --prefix server",
}
```
## Code: Interactive scratchpad
```lua
{
"metakirby5/codi.vim",
cmd = "Codi",
}
```
## Snap
```lua
{
"camspiers/snap",
rocks = "fzy",
config = function()
require("lv-snap").config()
end,
}
local M = {}
M.config = function()
local snap = require "snap"
local layout = snap.get("layout").bottom
local file = snap.config.file:with { consumer = "fzy", layout = layout }
local vimgrep = snap.config.vimgrep:with { layout = layout }
snap.register.command("find_files", file { producer = "ripgrep.file" })
snap.register.command("buffers", file { producer = "vim.buffer" })
snap.register.command("oldfiles", file { producer = "vim.oldfile" })
snap.register.command("live_grep", vimgrep {})
end
return M
```
## Tabnine
```lua
{
"tzachar/compe-tabnine",
run = "./install.sh",
requires = "hrsh7th/nvim-compe",
event = "InsertEnter",
}
```
## Colorizer
```lua
{
"norcalli/nvim-colorizer.lua",
config = function()
require("colorizer").setup({ "*" }, {
RGB = true, -- #RGB hex codes
RRGGBB = true, -- #RRGGBB hex codes
RRGGBBAA = true, -- #RRGGBBAA hex codes
rgb_fn = true, -- CSS rgb() and rgba() functions
hsl_fn = true, -- CSS hsl() and hsla() functions
css = true, -- Enable all CSS features: rgb_fn, hsl_fn, names, RGB, RRGGBB
css_fn = true, -- Enable all CSS *functions*: rgb_fn, hsl_fn
})
end,
},
```
## Symbol Outline
```lua
{
"simrat39/symbols-outline.nvim",
cmd = "SymbolsOutline",
}
```
## Trouble
```lua
{
"folke/trouble.nvim",
cmd = "TroubleToggle",
}
if O.plugin.trouble.active then
mappings["D"] = {
name = "Diagnostics",
t = { "<cmd>TroubleToggle<cr>", "trouble" },
w = { "<cmd>TroubleToggle lsp_workspace_diagnostics<cr>", "workspace" },
d = { "<cmd>TroubleToggle lsp_document_diagnostics<cr>", "document" },
q = { "<cmd>TroubleToggle quickfix<cr>", "quickfix" },
l = { "<cmd>TroubleToggle loclist<cr>", "loclist" },
r = { "<cmd>TroubleToggle lsp_references<cr>", "references" },
}
end
```
## Sane gx for netrw_gx bug
```lua
{
"felipec/vim-sanegx",
event = "BufRead",
}
```
## Colorschemes
```lua
{ "christianchiarulli/nvcode-color-schemes.vim", opt = true }
```
## Treesitter playground
```lua
{
"nvim-treesitter/playground",
event = "BufRead",
}
```
## Rainbow parentheses
```lua
{
"p00f/nvim-ts-rainbow",
}
```
## Autotags <div>|</div>
```lua
{
"windwp/nvim-ts-autotag",
event = "InsertEnter",
},
```
## Use fzy for telescope
```lua
{
"nvim-telescope/telescope-fzy-native.nvim",
run = "make",
event = "BufRead",
}
```
## comments in context
```lua
{
"JoosepAlviste/nvim-ts-context-commentstring",
event = "BufRead",
},
```
## Diffview
```lua
{
"sindrets/diffview.nvim",
event = "BufRead",
},
```
## Use project for telescope
```lua
{
"nvim-telescope/telescope-project.nvim",
event = "BufWinEnter",
setup = function()
vim.cmd [[packadd telescope.nvim]]
end,
},
```
## Lush Create Color Schemes
```lua
{
"rktjmp/lush.nvim",
}
```
## Cursorword
```lua
{
"itchyny/vim-cursorword",
event = {"BufEnter", "BufNewFile"},
config = function()
vim.api.nvim_command("augroup user_plugin_cursorword")
vim.api.nvim_command("autocmd!")
vim.api.nvim_command("autocmd FileType NvimTree,lspsagafinder,dashboard,vista let b:cursorword = 0")
vim.api.nvim_command("autocmd WinEnter * if &diff || &pvw | let b:cursorword = 0 | endif")
vim.api.nvim_command("autocmd InsertEnter * let b:cursorword = 0")
vim.api.nvim_command("autocmd InsertLeave * let b:cursorword = 1")
vim.api.nvim_command("augroup END")
end
},
```
## Vim-surround
```lua
{
"tpope/vim-surround",
keys = {"c", "d", "y"}
},
```
## Vim-repeat
```lua
{
"tpope/vim-repeat",
keys = {"."}
},
```
## Lsp signature
```lua
{
"ray-x/lsp_signature.nvim",
event = {"InsertEnter"},
config = function()
require "lsp_signature".setup()
end
},
```
## Vim fugitive
```lua
{
"tpope/vim-fugitive",
cmd = {
"G",
"Git",
"Gdiffsplit",
"Gread",
"Gwrite",
"Ggrep",
"GMove",
"GDelete",
"GBrowse",
"GRemove",
"GRename",
"Glgrep",
"Gedit"
},
ft = {"fugitive"}
},
```
## Vim rails
```lua
{
"tpope/vim-rails",
cmd = {
"Eview",
"Econtroller",
"Emodel",
"Smodel",
"Sview",
"Scontroller",
"Vmodel",
"Vview",
"Vcontroller",
"Tmodel",
"Tview",
"Tcontroller",
"Rails",
"Generate",
"Runner",
"Extract"
}
},
```
## Vim Bundler
```lua
{
"tpope/vim-bundler",
cmd = {"Bundler", "Bopen", "Bsplit", "Btabedit"}
},
```
## Glow
```lua
-- yay -S glow
{
"npxbr/glow.nvim",
ft = {"markdown"}
-- run = "yay -S glow"
},
```
## Markdown preview
```lua
{
"iamcco/markdown-preview.nvim",
ft = "markdown",
run = ":call mkdp#util#install()",
config = function()
vim.g.mkdp_auto_start = 1
end
},
```
## vim-matchup
```lua
{
"andymass/vim-matchup",
event = "CursorMoved"
}
```
## Autosave
```lua
{
"Pocco81/AutoSave.nvim",
config = function()
require("plugins.zenmode").autoSave()
end,
}
```
## Smooth scrolling
```lua
{
"karb94/neoscroll.nvim",
event = "WinScrolled",
config = function()
require('neoscroll').setup({
-- All these keys will be mapped to their corresponding default scrolling animation
mappings = {'<C-u>', '<C-d>', '<C-b>', '<C-f>',
'<C-y>', '<C-e>', 'zt', 'zz', 'zb'},
hide_cursor = true, -- Hide cursor while scrolling
stop_eof = true, -- Stop at <EOF> when scrolling downwards
use_local_scrolloff = false, -- Use the local scope of scrolloff instead of the global scope
respect_scrolloff = false, -- Stop scrolling when the cursor reaches the scrolloff margin of the file
cursor_scrolls_alone = true, -- The cursor will keep on scrolling even if the window cannot scroll further
easing_function = nil, -- Default easing function
pre_hook = nil, -- Function to run before the scrolling animation starts
post_hook = nil, -- Function to run after the scrolling animation ends
})
end
}
```
## Indent blankline
```lua
{
"lukas-reineke/indent-blankline.nvim",
event = "BufRead",
setup = function()
vim.g.indentLine_enabled = 1
vim.g.indent_blankline_char = "▏"
vim.g.indent_blankline_filetype_exclude = {"help", "terminal", "dashboard"}
vim.g.indent_blankline_buftype_exclude = {"terminal"}
vim.g.indent_blankline_show_trailing_blankline_indent = false
vim.g.indent_blankline_show_first_indent_level = false
end
}
```
## Minimap
```lua
{
'wfxr/minimap.vim',
run = "cargo install --locked code-minimap",
-- cmd = {"Minimap", "MinimapClose", "MinimapToggle", "MinimapRefresh", "MinimapUpdateHighlight"},
config = function ()
vim.cmd ("let g:minimap_width = 10")
vim.cmd ("let g:minimap_auto_start = 1")
vim.cmd ("let g:minimap_auto_start_win_enter = 1")
end
}
```
## LazyGit
```lua
{
'kdheepak/lazygit.nvim',
cmd = {"LazyGit"},
requires = { 'nvim-lua/plenary.nvim' },
}
```

20
What's-Included?.md

@ -1,20 +0,0 @@
LunarVim provides neovim configuration files that take advantage of
tree-sitter and language server protocol. The configuration is written
in lua.
## Why do I want tree-sitter and LSP?
- Normally, an editor uses regular expression parsing for things like
highlighting and checking the syntax of your file. Each time you make
a change, the editor must re-parse the entire file. Tree-sitter, on
the other hand, transforms text into a syntax tree. Each time you make
a change, only the parts of the code that change need to be parsed.
This greatly improves the speed of parsing. This can make a huge
difference when editing large files.
- Neovim 0.5 including language server protocol means your editor can
provide: code actions, completions, formatting, navigating to
definitions, renaming, etc. The language server only has to be written
once and will work on any editor that supports LSP. Any improvements
made to the language server will immediately be used by all editors
that support LSP.