Compare commits
No commits in common. "master" and "minimal" have entirely different histories.
47 changed files with 2488 additions and 3795 deletions
22
.github/workflows/stale.yml
vendored
22
.github/workflows/stale.yml
vendored
|
@ -1,22 +0,0 @@
|
|||
name: 'Close stale issues and PRs'
|
||||
on:
|
||||
schedule:
|
||||
- cron: '30 1 * * *'
|
||||
|
||||
jobs:
|
||||
stale:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/stale@v3
|
||||
with:
|
||||
repo-token: ${{ secrets.GITHUB_TOKEN }}
|
||||
stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
|
||||
stale-pr-message: 'This PR is stale because it has been open 45 days with no activity. Remove stale label or comment or this will be closed in 10 days.'
|
||||
close-issue-message: 'This issue was closed because it has been stalled for 5 days with no activity.'
|
||||
exempt-all-issue-assignees: true # doesn't close an issue if someone was assigned to it.
|
||||
close-pr-message: 'This PR was closed because it has been stalled for 10 days with no activity.'
|
||||
exempt-all-pr-assignees: true # doesn't close a pr if someone was assigned to it.
|
||||
days-before-issue-stale: 30
|
||||
days-before-pr-stale: 45
|
||||
days-before-issue-close: 5
|
||||
days-before-pr-close: 10
|
21
.github/workflows/stylua.yml
vendored
21
.github/workflows/stylua.yml
vendored
|
@ -1,21 +0,0 @@
|
|||
# Check Lua Formatting
|
||||
name: Check Lua Formatting
|
||||
on: pull_request_target
|
||||
|
||||
jobs:
|
||||
stylua-check:
|
||||
if: github.repository == 'nvim-lua/kickstart.nvim'
|
||||
name: Stylua Check
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout Code
|
||||
uses: actions/checkout@v2
|
||||
with:
|
||||
ref: ${{ github.event.pull_request.head.sha }}
|
||||
- name: Stylua Check
|
||||
uses: JohnnyMorganz/stylua-action@v3
|
||||
with:
|
||||
token: ${{ secrets.GITHUB_TOKEN }}
|
||||
version: latest
|
||||
args: --check .
|
||||
|
10
.gitignore
vendored
10
.gitignore
vendored
|
@ -1,11 +1 @@
|
|||
plugin
|
||||
ftplugin
|
||||
syntax
|
||||
coc-settings.json
|
||||
.luarc.json
|
||||
lazy-lock.json
|
||||
after
|
||||
**/.DS_Store
|
||||
lua/custom/secret
|
||||
lua/custom/configs/secret
|
||||
spell/en.utf-8.add.spl
|
||||
|
|
|
@ -1,6 +0,0 @@
|
|||
column_width = 160
|
||||
line_endings = "Unix"
|
||||
indent_type = "Spaces"
|
||||
indent_width = 2
|
||||
quote_style = "AutoPreferSingle"
|
||||
call_parentheses = "None"
|
19
LICENSE.md
19
LICENSE.md
|
@ -1,19 +0,0 @@
|
|||
MIT License
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
229
README.md
229
README.md
|
@ -1,229 +0,0 @@
|
|||
# kickstart.nvim
|
||||
|
||||
## Introduction
|
||||
|
||||
A starting point for Neovim that is:
|
||||
|
||||
* Small
|
||||
* Single-file
|
||||
* Completely Documented
|
||||
|
||||
**NOT** a Neovim distribution, but instead a starting point for your configuration.
|
||||
|
||||
## Installation
|
||||
|
||||
### Install Neovim
|
||||
|
||||
Kickstart.nvim targets *only* the latest
|
||||
['stable'](https://github.com/neovim/neovim/releases/tag/stable) and latest
|
||||
['nightly'](https://github.com/neovim/neovim/releases/tag/nightly) of Neovim.
|
||||
If you are experiencing issues, please make sure you have the latest versions.
|
||||
|
||||
### Install External Dependencies
|
||||
|
||||
External Requirements:
|
||||
- Basic utils: `git`, `make`, `unzip`, C Compiler (`gcc`)
|
||||
- [ripgrep](https://github.com/BurntSushi/ripgrep#installation)
|
||||
- Clipboard tool (xclip/xsel/win32yank or other depending on platform)
|
||||
- A [Nerd Font](https://www.nerdfonts.com/): optional, provides various icons
|
||||
- if you have it set `vim.g.have_nerd_font` in `init.lua` to true
|
||||
- Language Setup:
|
||||
- If want to write Typescript, you need `npm`
|
||||
- If want to write Golang, you will need `go`
|
||||
- etc.
|
||||
|
||||
> **NOTE**
|
||||
> See [Install Recipes](#Install-Recipes) for additional Windows and Linux specific notes
|
||||
> and quick install snippets
|
||||
|
||||
### Install Kickstart
|
||||
|
||||
> **NOTE**
|
||||
> [Backup](#FAQ) your previous configuration (if any exists)
|
||||
|
||||
Neovim's configurations are located under the following paths, depending on your OS:
|
||||
|
||||
| OS | PATH |
|
||||
| :- | :--- |
|
||||
| Linux, MacOS | `$XDG_CONFIG_HOME/nvim`, `~/.config/nvim` |
|
||||
| Windows (cmd)| `%userprofile%\AppData\Local\nvim\` |
|
||||
| Windows (powershell)| `$env:USERPROFILE\AppData\Local\nvim\` |
|
||||
|
||||
#### Recommended Step
|
||||
|
||||
[Fork](https://docs.github.com/en/get-started/quickstart/fork-a-repo) this repo
|
||||
so that you have your own copy that you can modify, then install by cloning the
|
||||
fork to your machine using one of the commands below, depending on your OS.
|
||||
|
||||
> **NOTE**
|
||||
> Your fork's url will be something like this:
|
||||
> `https://github.com/<your_github_username>/kickstart.nvim.git`
|
||||
|
||||
#### Clone kickstart.nvim
|
||||
> **NOTE**
|
||||
> If following the recommended step above (i.e., forking the repo), replace
|
||||
> `nvim-lua` with `<your_github_username>` in the commands below
|
||||
|
||||
<details><summary> Linux and Mac </summary>
|
||||
|
||||
```sh
|
||||
git clone https://github.com/nvim-lua/kickstart.nvim.git "${XDG_CONFIG_HOME:-$HOME/.config}"/nvim
|
||||
```
|
||||
|
||||
</details>
|
||||
|
||||
<details><summary> Windows </summary>
|
||||
|
||||
If you're using `cmd.exe`:
|
||||
|
||||
```
|
||||
git clone https://github.com/nvim-lua/kickstart.nvim.git %userprofile%\AppData\Local\nvim\
|
||||
```
|
||||
|
||||
If you're using `powershell.exe`
|
||||
|
||||
```
|
||||
git clone https://github.com/nvim-lua/kickstart.nvim.git $env:USERPROFILE\AppData\Local\nvim\
|
||||
```
|
||||
|
||||
</details>
|
||||
|
||||
### Post Installation
|
||||
|
||||
Start Neovim
|
||||
|
||||
```sh
|
||||
nvim
|
||||
```
|
||||
|
||||
That's it! Lazy will install all the plugins you have. Use `:Lazy` to view
|
||||
current plugin status. Hit `q` to close the window.
|
||||
|
||||
Read through the `init.lua` file in your configuration folder for more
|
||||
information about extending and exploring Neovim. That also includes
|
||||
examples of adding popularly requested plugins.
|
||||
|
||||
|
||||
### Getting Started
|
||||
|
||||
[The Only Video You Need to Get Started with Neovim](https://youtu.be/m8C0Cq9Uv9o)
|
||||
|
||||
### FAQ
|
||||
|
||||
* What should I do if I already have a pre-existing neovim configuration?
|
||||
* You should back it up and then delete all associated files.
|
||||
* This includes your existing init.lua and the neovim files in `~/.local`
|
||||
which can be deleted with `rm -rf ~/.local/share/nvim/`
|
||||
* Can I keep my existing configuration in parallel to kickstart?
|
||||
* Yes! You can use [NVIM_APPNAME](https://neovim.io/doc/user/starting.html#%24NVIM_APPNAME)`=nvim-NAME`
|
||||
to maintain multiple configurations. For example, you can install the kickstart
|
||||
configuration in `~/.config/nvim-kickstart` and create an alias:
|
||||
```
|
||||
alias nvim-kickstart='NVIM_APPNAME="nvim-kickstart" nvim'
|
||||
```
|
||||
When you run Neovim using `nvim-kickstart` alias it will use the alternative
|
||||
config directory and the matching local directory
|
||||
`~/.local/share/nvim-kickstart`. You can apply this approach to any Neovim
|
||||
distribution that you would like to try out.
|
||||
* What if I want to "uninstall" this configuration:
|
||||
* See [lazy.nvim uninstall](https://github.com/folke/lazy.nvim#-uninstalling) information
|
||||
* Why is the kickstart `init.lua` a single file? Wouldn't it make sense to split it into multiple files?
|
||||
* The main purpose of kickstart is to serve as a teaching tool and a reference
|
||||
configuration that someone can easily use to `git clone` as a basis for their own.
|
||||
As you progress in learning Neovim and Lua, you might consider splitting `init.lua`
|
||||
into smaller parts. A fork of kickstart that does this while maintaining the
|
||||
same functionality is available here:
|
||||
* [kickstart-modular.nvim](https://github.com/dam9000/kickstart-modular.nvim)
|
||||
* Discussions on this topic can be found here:
|
||||
* [Restructure the configuration](https://github.com/nvim-lua/kickstart.nvim/issues/218)
|
||||
* [Reorganize init.lua into a multi-file setup](https://github.com/nvim-lua/kickstart.nvim/pull/473)
|
||||
|
||||
### Install Recipes
|
||||
|
||||
Below you can find OS specific install instructions for Neovim and dependencies.
|
||||
|
||||
After installing all the dependencies continue with the [Install Kickstart](#Install-Kickstart) step.
|
||||
|
||||
#### Windows Installation
|
||||
|
||||
<details><summary>Windows with Microsoft C++ Build Tools and CMake</summary>
|
||||
Installation may require installing build tools and updating the run command for `telescope-fzf-native`
|
||||
|
||||
See `telescope-fzf-native` documentation for [more details](https://github.com/nvim-telescope/telescope-fzf-native.nvim#installation)
|
||||
|
||||
This requires:
|
||||
|
||||
- Install CMake and the Microsoft C++ Build Tools on Windows
|
||||
|
||||
```lua
|
||||
{'nvim-telescope/telescope-fzf-native.nvim', build = 'cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release && cmake --build build --config Release && cmake --install build --prefix build' }
|
||||
```
|
||||
</details>
|
||||
<details><summary>Windows with gcc/make using chocolatey</summary>
|
||||
Alternatively, one can install gcc and make which don't require changing the config,
|
||||
the easiest way is to use choco:
|
||||
|
||||
1. install [chocolatey](https://chocolatey.org/install)
|
||||
either follow the instructions on the page or use winget,
|
||||
run in cmd as **admin**:
|
||||
```
|
||||
winget install --accept-source-agreements chocolatey.chocolatey
|
||||
```
|
||||
|
||||
2. install all requirements using choco, exit previous cmd and
|
||||
open a new one so that choco path is set, and run in cmd as **admin**:
|
||||
```
|
||||
choco install -y neovim git ripgrep wget fd unzip gzip mingw make
|
||||
```
|
||||
</details>
|
||||
<details><summary>WSL (Windows Subsystem for Linux)</summary>
|
||||
|
||||
```
|
||||
wsl --install
|
||||
wsl
|
||||
sudo add-apt-repository ppa:neovim-ppa/unstable -y
|
||||
sudo apt update
|
||||
sudo apt install make gcc ripgrep unzip git xclip neovim
|
||||
```
|
||||
</details>
|
||||
|
||||
#### Linux Install
|
||||
<details><summary>Ubuntu Install Steps</summary>
|
||||
|
||||
```
|
||||
sudo add-apt-repository ppa:neovim-ppa/unstable -y
|
||||
sudo apt update
|
||||
sudo apt install make gcc ripgrep unzip git xclip neovim
|
||||
```
|
||||
</details>
|
||||
<details><summary>Debian Install Steps</summary>
|
||||
|
||||
```
|
||||
sudo apt update
|
||||
sudo apt install make gcc ripgrep unzip git xclip curl
|
||||
|
||||
# Now we install nvim
|
||||
curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim-linux64.tar.gz
|
||||
sudo rm -rf /opt/nvim-linux64
|
||||
sudo mkdir -p /opt/nvim-linux64
|
||||
sudo chmod a+rX /opt/nvim-linux64
|
||||
sudo tar -C /opt -xzf nvim-linux64.tar.gz
|
||||
|
||||
# make it available in /usr/local/bin, distro installs to /usr/bin
|
||||
sudo ln -sf /opt/nvim-linux64/bin/nvim /usr/local/bin/
|
||||
```
|
||||
</details>
|
||||
<details><summary>Fedora Install Steps</summary>
|
||||
|
||||
```
|
||||
sudo dnf install -y gcc make git ripgrep fd-find unzip neovim
|
||||
```
|
||||
</details>
|
||||
|
||||
<details><summary>Arch Install Steps</summary>
|
||||
|
||||
```
|
||||
sudo pacman -S --noconfirm --needed gcc make git ripgrep fd unzip neovim
|
||||
```
|
||||
</details>
|
||||
|
261
init.lua
261
init.lua
|
@ -1,238 +1,31 @@
|
|||
vim.g.mapleader = ' '
|
||||
vim.g.maplocalleader = ';'
|
||||
-- vim.g.python3_host_prog = '/usr/bin/python3'
|
||||
-- rafi Neovim entry-point
|
||||
-- https://git.cscherr.de/PlexSheep/neovim-conf
|
||||
|
||||
vim.opt.mouse = 'a' -- mouse does annoying things for me if it's not 'a'
|
||||
vim.opt.signcolumn = 'yes'
|
||||
vim.opt.clipboard = '' -- don't just use the system clipboard
|
||||
vim.opt.wrap = false
|
||||
vim.opt.breakindent = false
|
||||
vim.opt.conceallevel = 2
|
||||
vim.opt.concealcursor = 'c'
|
||||
vim.opt.undofile = true
|
||||
vim.opt.undolevels = 10000
|
||||
vim.opt.writebackup = false
|
||||
vim.opt.history = 5000
|
||||
vim.opt.shada = { "'1000", '<50', 's10', 'h' }
|
||||
vim.g.syntax = true
|
||||
vim.o.exrc = true -- load local configs in plugin dir
|
||||
local config = require('plex.config')
|
||||
config.ensure_lazy()
|
||||
|
||||
-- Tabs and Indents
|
||||
-- ===
|
||||
vim.opt.textwidth = 80 -- Text width maximum chars before wrapping
|
||||
vim.opt.tabstop = 4 -- The number of spaces a tab is
|
||||
vim.opt.shiftwidth = 4 -- Number of spaces to use in auto(indent)
|
||||
vim.opt.smarttab = true -- Tab insert blanks according to 'shiftwidth'
|
||||
vim.opt.autoindent = true -- Use same indenting on new lines
|
||||
vim.opt.smartindent = true -- Smart autoindenting on new lines
|
||||
vim.opt.shiftround = true -- Round indent to multiple of 'shiftwidth'
|
||||
-- Start lazy.nvim plugin manager.
|
||||
require('lazy').setup(vim.tbl_extend('keep', config.user_lazy_opts(), {
|
||||
spec = {
|
||||
{ import = 'plex.plugins' },
|
||||
|
||||
-- Timing
|
||||
-- ===
|
||||
vim.opt.ttimeout = true
|
||||
vim.opt.timeoutlen = 500 -- Time out on mappings
|
||||
vim.opt.ttimeoutlen = 10 -- Time out on key codes
|
||||
vim.opt.updatetime = 250 -- Idle time to write swap and trigger CursorHold
|
||||
-- This will load a custom user lua/plugins.lua or lua/plugins/*
|
||||
config.has_user_plugins() and { import = 'plugins' } or nil,
|
||||
},
|
||||
concurrency = vim.loop.available_parallelism() * 2,
|
||||
defaults = { lazy = true, version = false },
|
||||
dev = { path = config.path_join(vim.fn.stdpath('config'), 'dev') },
|
||||
install = { missing = true, colorscheme = {} },
|
||||
checker = { enabled = true, notify = false },
|
||||
change_detection = { notify = false },
|
||||
ui = { border = 'rounded' },
|
||||
diff = { cmd = 'terminal_git' },
|
||||
performance = {
|
||||
rtp = {
|
||||
disabled_plugins = {
|
||||
},
|
||||
},
|
||||
},
|
||||
}))
|
||||
|
||||
-- Searching
|
||||
-- ===
|
||||
vim.opt.ignorecase = true -- Search ignoring case
|
||||
vim.opt.smartcase = true -- Keep case when searching with *
|
||||
vim.opt.infercase = true -- Adjust case in insert completion mode
|
||||
vim.opt.incsearch = true -- Incremental search
|
||||
vim.opt.hlsearch = true -- highlight searched stuff
|
||||
|
||||
-- Formatting
|
||||
-- ===
|
||||
|
||||
vim.opt.wrap = false -- No wrap by default
|
||||
vim.opt.linebreak = true -- Break long lines at 'breakat'
|
||||
vim.opt.breakat = '\\ \\ ;:,!?' -- Long lines break chars
|
||||
vim.opt.startofline = false -- Cursor in same column for few commands
|
||||
vim.opt.splitbelow = true -- Splits open bottom right
|
||||
vim.opt.splitright = true
|
||||
vim.opt.breakindentopt = { shift = 2, min = 20 }
|
||||
vim.opt.formatoptions = 'trowcnlm1jp' -- see :h fo-table & :h formatoptions
|
||||
vim.opt.breakindent = true
|
||||
|
||||
-- Diff
|
||||
-- ===
|
||||
|
||||
vim.opt.diffopt:append { 'iwhite', 'indent-heuristic', 'algorithm:patience' }
|
||||
vim.opt.wildmode = 'longest:full,full' -- Command-line completion mode
|
||||
|
||||
-- Folds
|
||||
-- ===
|
||||
|
||||
vim.opt.foldlevelstart = 60
|
||||
vim.opt.foldlevel = 60
|
||||
vim.opt.foldminlines = 5
|
||||
|
||||
-- Editor UI
|
||||
-- ===
|
||||
|
||||
vim.o.guifont = 'FiraCode Nerd Font:h15'
|
||||
vim.opt.termguicolors = true
|
||||
vim.opt.shortmess = 'xsTOInfFitloCaAs'
|
||||
vim.opt.showmode = true -- Show mode in cmd window
|
||||
vim.opt.scrolloff = 6 -- Keep at least n lines above/below
|
||||
vim.opt.sidescrolloff = 10 -- Keep at least n lines left/right
|
||||
vim.opt.numberwidth = 2 -- Minimum number of columns to use for the line number
|
||||
vim.opt.number = true -- Show line numbers
|
||||
vim.opt.relativenumber = false -- Show relative line numbers
|
||||
vim.opt.ruler = true -- Default status ruler
|
||||
vim.opt.showtabline = 1 -- Don't change this, goes back to a vanilla vim default
|
||||
vim.opt.laststatus = 3 -- Always show laststatus
|
||||
|
||||
-- Sets how neovim will display certain whitespace characters in the editor.
|
||||
-- See `:help 'list'`
|
||||
-- and `:help 'listchars'`
|
||||
vim.opt.list = true
|
||||
vim.opt.listchars = { tab = '» ', trail = '·', nbsp = '␣' }
|
||||
|
||||
if vim.g.started_by_firenvim == true then
|
||||
opt.showtabline = 1 -- Don't show tabline in firenvim, unless multitab
|
||||
opt.laststatus = 1 -- Don't show laststatus in firenvim
|
||||
opt.wrap = true
|
||||
end
|
||||
|
||||
-- Preview substitutions live, as you type!
|
||||
vim.opt.inccommand = 'split'
|
||||
|
||||
if vim.g.neovide == true then
|
||||
-- fulscreen with F11
|
||||
vim.api.nvim_set_keymap('n', '<F11>', ':let g:neovide_fullscreen = !g:neovide_fullscreen<CR>', {})
|
||||
|
||||
vim.g.neovide_underline_automatic_scaling = true
|
||||
|
||||
-- vim.g.neovide_floating_blur_amount_x = 2.0
|
||||
-- vim.g.neovide_floating_blur_amount_y = 2.0
|
||||
|
||||
vim.g.neovide_scroll_animation_length = 0.1
|
||||
-- vim.g.neovide_cursor_animation_length = 0
|
||||
-- vim.g.neovide_cursor_trail_size = 0
|
||||
vim.g.neovide_hide_mouse_when_typing = true
|
||||
|
||||
vim.g.neovide_fullscreen = true
|
||||
end
|
||||
|
||||
vim.opt.helpheight = 0 -- Disable help window resizing
|
||||
vim.opt.winwidth = 30 -- Minimum width for active window
|
||||
vim.opt.winminwidth = 1 -- Minimum width for inactive windows
|
||||
vim.opt.winheight = 1 -- Minimum height for active window
|
||||
vim.opt.winminheight = 1 -- Minimum height for inactive window
|
||||
|
||||
vim.opt.showcmd = false -- show command in status line
|
||||
vim.opt.cmdheight = 0
|
||||
vim.opt.cmdwinheight = 5 -- Command-line lines
|
||||
vim.opt.equalalways = true -- Resize windows on split or close
|
||||
vim.opt.colorcolumn = '80' -- Column highlight at textwidth's max character-limit
|
||||
|
||||
vim.opt.cursorline = true
|
||||
vim.opt.cursorlineopt = { 'number', 'screenline' }
|
||||
|
||||
vim.opt.pumheight = 10 -- Maximum number of items to show in the popup menu
|
||||
vim.opt.pumwidth = 10 -- Minimum width for the popup menu
|
||||
vim.opt.pumblend = 10 -- Popup blend
|
||||
|
||||
-- Spelling correction
|
||||
-- ===
|
||||
|
||||
vim.opt.spell = true -- manually enable spell with `set spell` or `<leader>ts`
|
||||
vim.opt.spelllang = 'en,de_de'
|
||||
vim.opt.spellsuggest = 'double,50,timeout:5000'
|
||||
|
||||
-- user commands
|
||||
vim.api.nvim_create_user_command('Env', function(opts)
|
||||
vim.cmd(string.format('r!echo $%s', opts.fargs[1]))
|
||||
end, { nargs = 1 })
|
||||
vim.api.nvim_create_user_command('FormatDisable', function(args)
|
||||
if args.bang then
|
||||
-- FormatDisable! will disable formatting globally
|
||||
print 'disable autoformat globally'
|
||||
vim.g.disable_autoformat = true
|
||||
else
|
||||
print 'disable autoformat locally'
|
||||
vim.b.disable_autoformat = true
|
||||
end
|
||||
end, {
|
||||
desc = 'Disable autoformat',
|
||||
bang = true,
|
||||
})
|
||||
vim.api.nvim_create_user_command('FormatEnable', function(args)
|
||||
if args.bang then
|
||||
-- FormatDisable! will enable formatting globally
|
||||
print 'enable autoformat globally'
|
||||
vim.g.disable_autoformat = false
|
||||
else
|
||||
print 'enable autoformat locally'
|
||||
vim.b.disable_autoformat = false
|
||||
end
|
||||
end, {
|
||||
desc = 'Enable autoformat',
|
||||
bang = true,
|
||||
})
|
||||
|
||||
-- autocommands
|
||||
-- ===
|
||||
local function augroup(name)
|
||||
return vim.api.nvim_create_augroup('plex_' .. name, {})
|
||||
end
|
||||
|
||||
-- [[ Basic Keymaps ]]
|
||||
-- See `:help vim.keymap.set()`
|
||||
|
||||
-- [[ Basic Autocommands ]]
|
||||
-- See `:help lua-guide-autocommands`
|
||||
|
||||
-- Highlight when yanking (copying) text
|
||||
-- Try it with `yap` in normal mode
|
||||
-- See `:help vim.highlight.on_yank()`
|
||||
vim.api.nvim_create_autocmd('TextYankPost', {
|
||||
desc = 'Highlight when yanking (copying) text',
|
||||
group = vim.api.nvim_create_augroup('kickstart-highlight-yank', { clear = true }),
|
||||
callback = function()
|
||||
vim.highlight.on_yank()
|
||||
end,
|
||||
})
|
||||
|
||||
-- [[ Install `lazy.nvim` plugin manager ]]
|
||||
-- See `:help lazy.nvim.txt` or https://github.com/folke/lazy.nvim for more info
|
||||
local lazypath = vim.fn.stdpath 'data' .. '/lazy/lazy.nvim'
|
||||
if not vim.loop.fs_stat(lazypath) then
|
||||
local lazyrepo = 'https://github.com/folke/lazy.nvim.git'
|
||||
vim.fn.system { 'git', 'clone', '--filter=blob:none', '--branch=stable', lazyrepo, lazypath }
|
||||
end ---@diagnostic disable-next-line: undefined-field
|
||||
vim.opt.rtp:prepend(lazypath)
|
||||
|
||||
require 'custom.maps'
|
||||
require 'custom.autocmds'
|
||||
require('lazy').setup({
|
||||
{ import = 'custom.plugins' },
|
||||
{ import = 'kickstart.plugins.debug' },
|
||||
}, {
|
||||
ui = {
|
||||
-- If you are using a Nerd Font: set icons to an empty table which will use the
|
||||
-- default lazy.nvim defined Nerd Font icons, otherwise define a unicode icons table
|
||||
icons = vim.g.have_nerd_font and {} or {
|
||||
cmd = '⌘',
|
||||
config = '🛠',
|
||||
event = '📅',
|
||||
ft = '📂',
|
||||
init = '⚙',
|
||||
keys = '🗝',
|
||||
plugin = '🔌',
|
||||
runtime = '💻',
|
||||
require = '🌙',
|
||||
source = '📄',
|
||||
start = '🚀',
|
||||
task = '📌',
|
||||
lazy = '💤 ',
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
require 'kickstart.health'
|
||||
|
||||
-- The line beneath this is called `modeline`. See `:help modeline`
|
||||
-- vim: ts=2 sts=2 sw=2 et
|
||||
config.setup()
|
||||
|
|
|
@ -1,92 +0,0 @@
|
|||
local augroup = vim.api.nvim_create_augroup('plex_generic_autocmds', {})
|
||||
|
||||
-- enable text wrapping for text filetypes
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup,
|
||||
pattern = {
|
||||
'tex',
|
||||
'text',
|
||||
'markdown',
|
||||
'help',
|
||||
'typst',
|
||||
},
|
||||
callback = function()
|
||||
vim.opt_local.wrap = true
|
||||
end,
|
||||
})
|
||||
|
||||
-- use html for htmldjango
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup,
|
||||
pattern = {
|
||||
'html',
|
||||
},
|
||||
callback = function()
|
||||
vim.bo.filetype = 'html'
|
||||
end,
|
||||
})
|
||||
|
||||
-- always use the tex filetype for latex things, as those are most supported by
|
||||
-- latex language servers.
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup,
|
||||
pattern = {
|
||||
'latex',
|
||||
'plaintex',
|
||||
},
|
||||
callback = function()
|
||||
vim.bo.filetype = 'tex'
|
||||
end,
|
||||
})
|
||||
|
||||
-- conceallevel is what converts things like **bold** to be displayed as bold
|
||||
-- without the stars. This is useful, but we might not want it for some
|
||||
-- filetypes.
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup,
|
||||
pattern = {
|
||||
'latex',
|
||||
'markdown',
|
||||
'plaintex',
|
||||
'tex',
|
||||
'typst',
|
||||
},
|
||||
callback = function()
|
||||
vim.opt_local.conceallevel = 0
|
||||
vim.opt_local.concealcursor = ''
|
||||
end,
|
||||
})
|
||||
|
||||
-- Enable spellcheck for some types
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup,
|
||||
pattern = {
|
||||
'latex',
|
||||
'markdown',
|
||||
'typst',
|
||||
'plaintex',
|
||||
'tex',
|
||||
},
|
||||
callback = function()
|
||||
vim.cmd [[set spell]]
|
||||
end,
|
||||
})
|
||||
|
||||
-- disable auto formatting for some filetypes
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup,
|
||||
pattern = {
|
||||
'TelescopePrompt',
|
||||
},
|
||||
callback = function()
|
||||
vim.opt_local.formatoptions = ''
|
||||
end,
|
||||
})
|
||||
|
||||
-- tweak colorschemes and highlights after loading a new colorscheme
|
||||
vim.api.nvim_create_autocmd('ColorScheme', {
|
||||
group = augroup,
|
||||
callback = function()
|
||||
vim.cmd [[highlight Comment gui=NONE]] -- no italics for comments
|
||||
end,
|
||||
})
|
|
@ -1,156 +0,0 @@
|
|||
--------------------------------------------------------------------------------
|
||||
-- Toggles
|
||||
--------------------------------------------------------------------------------
|
||||
-- Clear highlighted searched on pressing <Esc> in normal mode
|
||||
vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>', { desc = 'Hide search results' })
|
||||
|
||||
vim.keymap.set('n', '<leader>tn', '<cmd> set nu! <cr>', { desc = '[T]oggle line [N]umbers' })
|
||||
vim.keymap.set('n', '<leader>trn', '<cmd> set rnu! <cr>', { desc = '[T]oggle [R]elative line [N]umbers' })
|
||||
vim.keymap.set('n', '<leader>tw', '<cmd> set wrap! <cr>', { desc = '[T]oggle [W]rap' })
|
||||
vim.keymap.set('n', '<leader>ts', '<cmd> set spell! <cr>', { desc = '[T]oggle [S]pellcheck' })
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Movements
|
||||
--------------------------------------------------------------------------------
|
||||
-- make big movements up and down
|
||||
vim.keymap.set({ 't', 'i', 'v', 'n' }, '<A-j>', '<C-d>', { desc = 'move a many lines up' })
|
||||
vim.keymap.set({ 't', 'i', 'v', 'n' }, '<A-k>', '<C-u>', { desc = 'move a many lines down' })
|
||||
|
||||
-- move to end and start of lines with H and L
|
||||
vim.keymap.set({ 'v', 'n' }, 'H', '<Home>', { desc = 'move to start of line' })
|
||||
vim.keymap.set({ 'v', 'n' }, 'L', '<End>', { desc = 'move to end of line' })
|
||||
|
||||
-- make j and k move by visual lines, not actual lines
|
||||
vim.keymap.set({ 'v', 'n' }, 'j', 'gj', { desc = 'move up' })
|
||||
vim.keymap.set({ 'v', 'n' }, 'k', 'gk', { desc = 'move down' })
|
||||
|
||||
-- move+scroll
|
||||
vim.keymap.set({ 'v', 'n' }, 'zk', '<C-e>', { desc = 'move and scroll up' })
|
||||
vim.keymap.set({ 'v', 'n' }, 'zj', '<C-y>', { desc = 'move and scroll down' })
|
||||
|
||||
-- go to beginning and end in insert mode
|
||||
vim.keymap.set('i', '<C-S-h>', '<esc>^i', { desc = 'Go to the start of the line' })
|
||||
vim.keymap.set('i', '<C-S-l>', '<End>', { desc = 'Go to the end of the line' })
|
||||
vim.keymap.set('i', '<C-w>', '<esc>lwi', { desc = 'Go a word further' })
|
||||
vim.keymap.set('i', '<C-b>', '<esc>lbi', { desc = 'Go a word backward' })
|
||||
vim.keymap.set('i', '<C-e>', '<esc>lea', { desc = 'Go a to next word end' })
|
||||
|
||||
-- navigate hjkl in insert mode
|
||||
vim.keymap.set('i', '<C-h>', '<Left>', { desc = 'Move left' })
|
||||
vim.keymap.set('i', '<C-j>', '<Down>', { desc = 'Move down' })
|
||||
vim.keymap.set('i', '<C-k>', '<Up>', { desc = 'Move up' })
|
||||
vim.keymap.set('i', '<C-l>', '<Right>', { desc = 'Move right' })
|
||||
|
||||
-- move to window
|
||||
-- See `:help wincmd` for a list of all window commands
|
||||
vim.keymap.set('n', '<C-h>', '<C-w><C-h>', { desc = 'Move focus to the left window' })
|
||||
vim.keymap.set('n', '<C-l>', '<C-w><C-l>', { desc = 'Move focus to the right window' })
|
||||
vim.keymap.set('n', '<C-j>', '<C-w><C-j>', { desc = 'Move focus to the lower window' })
|
||||
vim.keymap.set('n', '<C-k>', '<C-w><C-k>', { desc = 'Move focus to the upper window' })
|
||||
|
||||
-- diagnostics
|
||||
vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, { desc = 'Go to previous [D]iagnostic message' })
|
||||
vim.keymap.set('n', ']d', vim.diagnostic.goto_next, { desc = 'Go to next [D]iagnostic message' })
|
||||
|
||||
-- let me out!!!
|
||||
vim.keymap.set({ 'n', 'v' }, 'qqq', '<cmd>bnext<cr><cmd>bd #<cr>', { desc = '[Q]uit the current window' })
|
||||
vim.keymap.set({ 'n', 'v' }, '<A-c>', '<cmd>bnext<cr><cmd>bd #<cr>', { desc = '[C]lose the current buffer' })
|
||||
|
||||
vim.keymap.set({ 'n' }, '#', "'", { desc = '[Q]uit the current window' })
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Workspace, buffer and window manipulation
|
||||
--------------------------------------------------------------------------------
|
||||
-- split windows
|
||||
vim.keymap.set('n', '<leader>"', '<cmd>vsplit<cr>', { desc = 'Split the window vertically' })
|
||||
vim.keymap.set('n', '<leader>%', '<cmd>split<cr>', { desc = 'Split the window horizontally' })
|
||||
vim.keymap.set('n', '<leader>w"', '<cmd>vnew<cr>', { desc = 'Split the window vertically (new buffer)' })
|
||||
vim.keymap.set('n', '<leader>w%', '<cmd>new<cr>', { desc = 'Split the window horizontally (new buffer)' })
|
||||
|
||||
-- window actions
|
||||
vim.keymap.set('n', '<leader>wbn', '<cmd>enew<cr>', { desc = 'Open a [N]ew buffer' })
|
||||
vim.keymap.set('n', '<leader>wbc', '<cmd>bw<cr>', { desc = '[C]lose current buffer' }) -- :bd would keep in background
|
||||
vim.keymap.set('n', '<C-Up>', '<cmd>resize +1<cr>', { desc = 'Resize window' })
|
||||
vim.keymap.set('n', '<C-Down>', '<cmd>resize -1<cr>', { desc = 'Resize window' })
|
||||
vim.keymap.set('n', '<C-Left>', '<cmd>vertical resize +1<cr>', { desc = 'Resize window vertically' })
|
||||
vim.keymap.set('n', '<C-Right>', '<cmd>vertical resize -1<cr>', { desc = 'Resize window vertically' })
|
||||
|
||||
-- tabs/workspaces
|
||||
vim.keymap.set('n', '<Tab>', '<cmd>bnext<cr>', { desc = 'Next Buffer' })
|
||||
vim.keymap.set('n', '<S-Tab>', '<cmd>bprev<cr>', { desc = 'Last Buffer' })
|
||||
vim.keymap.set('n', '<leader>wn', '<cmd>tabnew<cr>', { desc = 'Open a [N]ew [W]orkspace/Tab' })
|
||||
vim.keymap.set('n', '<leader>wc', '<cmd>tabclose<cr>', { desc = '[C]lose a [W]orkspace/Tab' })
|
||||
vim.keymap.set('n', '<leader>wk', '<cmd>tabnext<cr>', { desc = 'Next [W]orkspace/Tab' })
|
||||
vim.keymap.set('n', '<leader>wj', '<cmd>tabprevious<cr>', { desc = 'Last [W]orkspace/Tab' })
|
||||
vim.keymap.set('n', '<leader>n', '<cmd>enew<cr>', { desc = '[N]ew Buffer' })
|
||||
|
||||
vim.keymap.set('t', '<C-w>', vim.api.nvim_replace_termcodes('<C-\\><C-N>', true, true, true), { desc = 'Leave terminal mode' })
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Editing
|
||||
--------------------------------------------------------------------------------
|
||||
-- copy to system clipboard
|
||||
vim.keymap.set({ 'n', 'v' }, '<leader>y', '"+y', { desc = '[Y]ank to system' })
|
||||
vim.keymap.set({ 'n', 'v' }, '<leader>Y', '"+Y', { desc = '[Y]ank to system' })
|
||||
vim.keymap.set({ 'n', 'v' }, '<leader>yy', '"+yy', { desc = '[Y]ank to system' })
|
||||
|
||||
-- paste from system clipboard
|
||||
vim.keymap.set({ 'n', 'v' }, '<leader>p', '"+p', { desc = '[P]aste from system' })
|
||||
vim.keymap.set({ 't', 'n', 'v' }, '<C-S-v>', '<C-w>"+pi', { desc = 'Paste the system clipboard' })
|
||||
|
||||
-- do not overwrite the register when pasting (kept defaults)
|
||||
vim.keymap.set({ 'v' }, 'P', 'P', { desc = '[P]aste to selected' })
|
||||
vim.keymap.set({ 'v' }, 'p', 'p', { desc = '[p]aste to selected and copy to register' })
|
||||
|
||||
-- add lines from normal and visual, without insert mode
|
||||
vim.keymap.set({ 'n', 'v' }, 'OO', 'O<Esc>', { desc = 'Insert a line above' })
|
||||
vim.keymap.set({ 'n', 'v' }, 'oo', 'o<Esc>', { desc = 'Insert a line below' })
|
||||
|
||||
-- add lines from normal and visual, with insert mode
|
||||
vim.keymap.set({ 'n', 'v' }, 'O', 'O', { desc = 'Insert a line above and insert' })
|
||||
vim.keymap.set({ 'n', 'v' }, 'o', 'o', { desc = 'Insert a line below and insert' })
|
||||
vim.keymap.set({ 'n', 'v' }, 'Oi', 'O', { desc = 'Insert a line above and insert' })
|
||||
vim.keymap.set({ 'n', 'v' }, 'oi', 'o', { desc = 'Insert a line below and insert' })
|
||||
|
||||
-- make current line a blank line
|
||||
vim.keymap.set({ 'n', 'v' }, 'do', 'Vc<Esc>', { desc = '[D]o [O]ver / Rewrite line' })
|
||||
|
||||
-- substitute, normally on 's', but the leap plugin is more useful on 's'
|
||||
vim.keymap.set({ 'n' }, '<leader>s', 's', { desc = '[S]ubstitute hovered text' })
|
||||
|
||||
-- do something useful with the arrow keys:
|
||||
-- move lines up/down and change indentation
|
||||
vim.keymap.set({ 'n', 'v' }, '<Up>', '<cmd> move-2<cr>', { desc = 'Move line up' })
|
||||
vim.keymap.set({ 'n', 'v' }, '<Down>', '<cmd> move+1<cr>', { desc = 'Move line down' })
|
||||
vim.keymap.set({ 'n', 'v' }, '<Left>', '<<', { desc = 'Less indentation' })
|
||||
vim.keymap.set({ 'n', 'v' }, '<Right>', '>>', { desc = 'More indentation' })
|
||||
|
||||
-- format a long line into multiple with length 80
|
||||
vim.keymap.set({ 'v' }, '<leader>fl', ':!fmt -w80<CR>', { desc = '[F]ormat long [L]ines into smaller ones' })
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Formating
|
||||
--------------------------------------------------------------------------------
|
||||
-- format the current buffer
|
||||
vim.keymap.set('n', '<leader>ff', function()
|
||||
require('conform').format()
|
||||
end, { desc = '[F]ormat buffer' })
|
||||
vim.keymap.set('n', '<leader>fF', function()
|
||||
vim.lsp.buf.format()
|
||||
end, { desc = '[F]ormat buffer (no plugin)' })
|
||||
vim.keymap.set('n', '<leader>fw', function()
|
||||
require('mini.trailspace').trim()
|
||||
end, { desc = '[F]ormat remove [W]hitespace' })
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Formating
|
||||
--------------------------------------------------------------------------------
|
||||
-- discard F15
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<F15>', '<Nop>')
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<S-F15>', '<Nop>')
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<A-F15>', '<Nop>')
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<C-F15>', '<Nop>')
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<C-S-F15>', '<Nop>')
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<C-A-F15>', '<Nop>')
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<A-S-F15>', '<Nop>')
|
||||
vim.keymap.set({ 'i', 't', 'x', 'n', 'v' }, '<C-A-S-F15>', '<Nop>')
|
|
@ -1,237 +0,0 @@
|
|||
local completion = require 'null-ls.builtins._meta.completion'
|
||||
-- Brief aside: **What is LSP?**
|
||||
--
|
||||
-- LSP is an initialism you've probably heard, but might not understand what it is.
|
||||
--
|
||||
-- LSP stands for Language Server Protocol. It's a protocol that helps editors
|
||||
-- and language tooling communicate in a standardized fashion.
|
||||
--
|
||||
-- In general, you have a "server" which is some tool built to understand a particular
|
||||
-- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers
|
||||
-- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone
|
||||
-- processes that communicate with some "client" - in this case, Neovim!
|
||||
--
|
||||
-- LSP provides Neovim with features like:
|
||||
-- - Go to definition
|
||||
-- - Find references
|
||||
-- - Autocompletion
|
||||
-- - Symbol Search
|
||||
-- - and more!
|
||||
--
|
||||
-- Thus, Language Servers are external tools that must be installed separately from
|
||||
-- Neovim. This is where `mason` and related plugins come into play.
|
||||
--
|
||||
-- If you're wondering about lsp vs treesitter, you can check out the wonderfully
|
||||
-- and elegantly composed help section, `:help lsp-vs-treesitter`
|
||||
|
||||
-- This function gets run when an LSP attaches to a particular buffer.
|
||||
-- That is to say, every time a new file is opened that is associated with
|
||||
-- an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this
|
||||
-- function will be executed to configure the current buffer
|
||||
vim.api.nvim_create_autocmd('LspAttach', {
|
||||
group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),
|
||||
callback = function(event)
|
||||
-- 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.
|
||||
--
|
||||
-- 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 map = function(keys, func, desc)
|
||||
vim.keymap.set('n', keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
|
||||
end
|
||||
|
||||
-- Jump to the definition of the word under your cursor.
|
||||
-- This is where a variable was first declared, or where a function is defined, etc.
|
||||
-- To jump back, press <C-t>.
|
||||
map('gd', require('telescope.builtin').lsp_definitions, '[G]oto [D]efinition')
|
||||
|
||||
-- Find references for the word under your cursor.
|
||||
map('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')
|
||||
|
||||
-- Jump to the implementation of the word under your cursor.
|
||||
-- Useful when your language has ways of declaring types without an actual implementation.
|
||||
map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')
|
||||
|
||||
-- Rename the variable under your cursor.
|
||||
-- Most Language Servers support renaming across files, etc.
|
||||
map('<leader>cr', vim.lsp.buf.rename, '[R]ename')
|
||||
|
||||
-- Execute a code action, usually your cursor needs to be on top of an error
|
||||
-- or a suggestion from your LSP for this to activate.
|
||||
map('<leader>ca', vim.lsp.buf.code_action, '[A]ction')
|
||||
|
||||
-- Opens a popup that displays documentation about the word under your cursor
|
||||
-- See `:help K` for why this keymap.
|
||||
map('K', vim.lsp.buf.hover, 'Hover Documentation')
|
||||
|
||||
-- WARN: This is not Goto Definition, this is Goto Declaration.
|
||||
-- For example, in C this would take you to the header.
|
||||
map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
|
||||
|
||||
map('gl', vim.diagnostic.open_float, 'Make the diagnostic big')
|
||||
|
||||
-- The following two autocommands are used to highlight references of the
|
||||
-- word under your cursor when your cursor rests there for a little while.
|
||||
-- See `:help CursorHold` for information about when this is executed
|
||||
--
|
||||
-- When you move your cursor, the highlights will be cleared (the second autocommand).
|
||||
local client = vim.lsp.get_client_by_id(event.data.client_id)
|
||||
if client and client.server_capabilities.documentHighlightProvider then
|
||||
local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })
|
||||
vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
|
||||
buffer = event.buf,
|
||||
group = highlight_augroup,
|
||||
callback = vim.lsp.buf.document_highlight,
|
||||
})
|
||||
|
||||
vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
|
||||
buffer = event.buf,
|
||||
group = highlight_augroup,
|
||||
callback = vim.lsp.buf.clear_references,
|
||||
})
|
||||
|
||||
vim.api.nvim_create_autocmd('LspDetach', {
|
||||
group = vim.api.nvim_create_augroup('kickstart-lsp-detach', { clear = true }),
|
||||
callback = function(event2)
|
||||
vim.lsp.buf.clear_references()
|
||||
vim.api.nvim_clear_autocmds { group = 'kickstart-lsp-highlight', buffer = event2.buf }
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
-- The following autocommand is used to enable inlay hints in your
|
||||
-- code, if the language server you are using supports them
|
||||
--
|
||||
-- This may be unwanted, since they displace some of your code
|
||||
if client and client.server_capabilities.inlayHintProvider and vim.lsp.inlay_hint then
|
||||
map('<leader>th', function()
|
||||
vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled())
|
||||
end, '[T]oggle Inlay [H]ints')
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
-- LSP servers and clients are able to communicate to each other what features they support.
|
||||
-- By default, Neovim doesn't support everything that is in the LSP specification.
|
||||
-- When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.
|
||||
-- So, we create new capabilities with nvim cmp, and then broadcast that to the servers.
|
||||
CAPABILITIES = vim.lsp.protocol.make_client_capabilities()
|
||||
CAPABILITIES = vim.tbl_deep_extend('force', CAPABILITIES, require('cmp_nvim_lsp').default_capabilities())
|
||||
|
||||
DEFAULT_ON_ATTACH = function(client, bufnr)
|
||||
vim.keymap.set('n', '<leader>tp', function()
|
||||
print('pinning this file: ', vim.api.nvim_buf_get_name(0), 'bufnr: ', bufnr)
|
||||
client:exec_cmd({
|
||||
title = 'pin',
|
||||
command = 'tinymist.pinMain',
|
||||
arguments = { vim.api.nvim_buf_get_name(0) },
|
||||
}, { bufnr = bufnr })
|
||||
vim.cmd "TypstPreview"
|
||||
end, { desc = '[T]oggle [P]review (pin this file as main file and open preview)', noremap = true })
|
||||
|
||||
vim.keymap.set('n', '<leader>tu', function()
|
||||
client:exec_cmd({
|
||||
title = 'unpin',
|
||||
command = 'tinymist.pinMain',
|
||||
arguments = { vim.v.null },
|
||||
}, { bufnr = bufnr })
|
||||
end, { desc = '[T]oggle [U]npin (unpin this file as main file)', noremap = true })
|
||||
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. Available keys are:
|
||||
-- - cmd (table): Override the default command used to start the server
|
||||
-- - filetypes (table): Override the default list of associated filetypes for the server
|
||||
-- - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.
|
||||
-- - settings (table): Override the default settings passed when initializing the server.
|
||||
-- For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/
|
||||
local servers = {
|
||||
tinymist = {
|
||||
settings = {
|
||||
formatterMode = 'typstyle',
|
||||
exportPdf = 'never',
|
||||
semanticTokens = 'disable',
|
||||
},
|
||||
on_attach = DEFAULT_ON_ATTACH,
|
||||
},
|
||||
html = {},
|
||||
taplo = {},
|
||||
cssls = {},
|
||||
ts_ls = {},
|
||||
clangd = {},
|
||||
pyright = {},
|
||||
bashls = {},
|
||||
yamlls = {},
|
||||
rust_analyzer = {
|
||||
settings = {
|
||||
['rust-analyzer'] = {
|
||||
check = {
|
||||
command = 'clippy',
|
||||
allTargets = false
|
||||
},
|
||||
imports = {
|
||||
preferPrelude = true,
|
||||
},
|
||||
cargo = {
|
||||
features = 'all',
|
||||
buildScripts = {
|
||||
enable = true,
|
||||
},
|
||||
allTargets = false
|
||||
},
|
||||
procMacro = {
|
||||
enable = true,
|
||||
},
|
||||
assist = {
|
||||
emitMustUse = true,
|
||||
expressionFillDefault = true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
lua_ls = {
|
||||
settings = {
|
||||
Lua = {
|
||||
completion = {
|
||||
callSnippet = 'Replace',
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
-- Ensure the servers and tools above are installed
|
||||
-- To check the current status of installed tools and/or manually install
|
||||
-- other tools, you can run
|
||||
-- :Mason
|
||||
--
|
||||
-- You can press `g?` for help in this menu.
|
||||
require('mason').setup()
|
||||
|
||||
-- You can add other tools here that you want Mason to install
|
||||
-- for you, so that they are available from within Neovim.
|
||||
local ensure_installed = vim.tbl_keys(servers or {})
|
||||
vim.list_extend(ensure_installed, {})
|
||||
|
||||
require('mason-lspconfig').setup {
|
||||
ensure_installed = ensure_installed,
|
||||
automatic_installation = true,
|
||||
automatic_enable = false,
|
||||
}
|
||||
|
||||
-- some things work weird
|
||||
local lspconfig = require 'lspconfig'
|
||||
|
||||
for server_name, server in pairs(servers) do
|
||||
-- This handles overriding only values explicitly passed
|
||||
-- by the server configuration above. Useful when disabling
|
||||
-- certain features of an LSP (for example, turning off formatting for tsserver)
|
||||
server.capabilities = vim.tbl_deep_extend('force', {}, CAPABILITIES, server.capabilities or {})
|
||||
require('lspconfig')[server_name].setup(server)
|
||||
end
|
||||
|
||||
lspconfig.gdscript.setup {}
|
||||
|
||||
return servers
|
|
@ -1,95 +0,0 @@
|
|||
return {
|
||||
{
|
||||
'numToStr/Comment.nvim',
|
||||
keys = {
|
||||
{ 'gcc', mode = 'n', desc = 'Comment toggle current line' },
|
||||
{ 'gc', mode = { 'n', 'o' }, desc = 'Comment toggle linewise' },
|
||||
{ 'gc', mode = 'x', desc = 'Comment toggle linewise (visual)' },
|
||||
{ 'gbc', mode = 'n', desc = 'Comment toggle current block' },
|
||||
{ 'gb', mode = { 'n', 'o' }, desc = 'Comment toggle blockwise' },
|
||||
{ 'gb', mode = 'x', desc = 'Comment toggle blockwise (visual)' },
|
||||
{
|
||||
'<leader>v',
|
||||
function()
|
||||
require('Comment.api').toggle.linewise.current()
|
||||
end,
|
||||
mode = { 'n' },
|
||||
desc = 'Comment toggle current line',
|
||||
},
|
||||
{
|
||||
'<leader>v',
|
||||
function()
|
||||
local esc = vim.api.nvim_replace_termcodes('<ESC>', true, false, true)
|
||||
vim.api.nvim_feedkeys(esc, 'nx', false)
|
||||
require('Comment.api').toggle.linewise(vim.fn.visualmode())
|
||||
end,
|
||||
mode = { 'x' },
|
||||
desc = 'Comment toggle selected lines',
|
||||
},
|
||||
},
|
||||
config = function(_, opts)
|
||||
vim.keymap.set('n', '<leader>c', function()
|
||||
require('Comment.api').toggle.linewise.current()
|
||||
end, { desc = '[T]oggle [C]omment' })
|
||||
vim.keymap.set('v', '<leader>c', function()
|
||||
require('Comment.api').toggle.linewise.current()
|
||||
end, { desc = '[T]oggle [C]omment' })
|
||||
|
||||
require('Comment').setup(opts)
|
||||
end,
|
||||
},
|
||||
{
|
||||
'uga-rosa/ccc.nvim',
|
||||
lazy = false,
|
||||
event = 'FileType',
|
||||
keys = {
|
||||
{ '<Leader>cp', '<cmd>CccPick<CR>', desc = 'Color-picker' },
|
||||
},
|
||||
opts = {
|
||||
highlighter = {
|
||||
auto_enable = true,
|
||||
lsp = true,
|
||||
excludes = { 'lazy', 'mason', 'help', 'neo-tree' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
'dhruvasagar/vim-table-mode',
|
||||
lazy = false,
|
||||
-- <Leader>tm is automatically set for toggle
|
||||
-- see <Leader>t menu
|
||||
},
|
||||
{
|
||||
'ziontee113/icon-picker.nvim',
|
||||
keys = {
|
||||
{ '<localleader>fi', '<cmd>IconPickerNormal<CR>', desc = 'pick icon' },
|
||||
},
|
||||
cmd = { 'IconPickerInsert', 'IconPickerYank', 'IconPickerNormal' },
|
||||
config = function()
|
||||
require('icon-picker').setup { disable_legacy_commands = true }
|
||||
end,
|
||||
},
|
||||
{
|
||||
'windwp/nvim-autopairs',
|
||||
event = 'InsertEnter',
|
||||
-- Optional dependency
|
||||
dependencies = { 'hrsh7th/nvim-cmp' },
|
||||
config = function()
|
||||
require('nvim-autopairs').setup {}
|
||||
-- WARN: this is kind of anoying with rust, so I have disabeld it
|
||||
-- -- If you want to automatically add `(` after selecting a function or method
|
||||
-- local cmp_autopairs = require 'nvim-autopairs.completion.cmp'
|
||||
-- local cmp = require 'cmp'
|
||||
-- cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done())
|
||||
end,
|
||||
},
|
||||
{
|
||||
'mbbill/undotree',
|
||||
config = function()
|
||||
vim.keymap.set({ 'n', 'v' }, '<leader>u', vim.cmd.UndotreeToggle, { desc = '[U]ndo menu' })
|
||||
vim.g.undotree_WindowLayout = 3
|
||||
vim.g.undotree_SplitWidth = 32
|
||||
vim.g.undotree_DiffAutoOpen = false
|
||||
end,
|
||||
},
|
||||
}
|
|
@ -1,103 +0,0 @@
|
|||
return {
|
||||
-- NOTE: Plugins can specify dependencies.
|
||||
--
|
||||
-- The dependencies are proper plugin specifications as well - anything
|
||||
-- you do for a plugin at the top level, you can do for a dependency.
|
||||
--
|
||||
-- Use the `dependencies` key to specify the dependencies of a particular plugin
|
||||
|
||||
{ -- Autoformat
|
||||
'stevearc/conform.nvim',
|
||||
lazy = false,
|
||||
keys = {
|
||||
{
|
||||
'<leader>f',
|
||||
function()
|
||||
require('conform').format { async = true, lsp_fallback = true }
|
||||
end,
|
||||
mode = '',
|
||||
desc = '[F]ormat buffer',
|
||||
},
|
||||
},
|
||||
opts = {
|
||||
notify_on_error = false,
|
||||
format_on_save = function(bufnr)
|
||||
if vim.g.disable_autoformat or vim.b[bufnr].disable_autoformat then
|
||||
return
|
||||
end
|
||||
-- Disable "format_on_save lsp_fallback" for languages that don't
|
||||
-- have a well standardized coding style. You can add additional
|
||||
-- languages here or re-enable it for the disabled ones.
|
||||
local disable_filetypes = { c = false, cpp = false, json = true, bib = true, markdown = false }
|
||||
return {
|
||||
timeout_ms = 500,
|
||||
lsp_fallback = not disable_filetypes[vim.bo[bufnr].filetype],
|
||||
}
|
||||
end,
|
||||
formatters_by_ft = {
|
||||
['_'] = { 'prettier' },
|
||||
rust = { 'rust-analyzer' },
|
||||
lua = { 'stylua' },
|
||||
typst = { 'typstyle' },
|
||||
json = { 'jq' },
|
||||
-- rust = { 'rustfmt' }, -- does not need one with the lsp there
|
||||
c = { 'clang-format' },
|
||||
cpp = { 'clang-format' },
|
||||
python = { 'autopep8' },
|
||||
-- Conform can also run multiple formatters sequentially
|
||||
-- python = { "isort", "black" },
|
||||
--
|
||||
-- You can use a sub-list to tell conform to run *until* a formatter
|
||||
-- is found.
|
||||
javascript = { 'prettier' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
'glacambre/firenvim',
|
||||
enabled = vim.g.started_by_firenvim,
|
||||
lazy = false,
|
||||
build = function()
|
||||
vim.fn['firenvim#install'](0)
|
||||
end,
|
||||
config = function()
|
||||
vim.g.firenvim_config = {
|
||||
localSettings = {
|
||||
['.*'] = {
|
||||
filename = '/tmp/{hostname}_{pathname%10}.{extension%5}',
|
||||
cmdline = 'firenvim',
|
||||
takeover = 'never', -- can't open it with never at all?
|
||||
},
|
||||
},
|
||||
}
|
||||
end,
|
||||
},
|
||||
{
|
||||
-- enables UNIX specific stuff in vim,
|
||||
-- specifically:
|
||||
-- :SudoWrite
|
||||
-- :SudoRead
|
||||
-- :Chmod
|
||||
-- and also some more, but those are easy done with shell
|
||||
'tpope/vim-eunuch',
|
||||
lazy = false,
|
||||
},
|
||||
{
|
||||
'mikesmithgh/kitty-scrollback.nvim',
|
||||
enabled = true,
|
||||
lazy = true,
|
||||
cmd = { 'KittyScrollbackGenerateKittens', 'KittyScrollbackCheckHealth' },
|
||||
event = { 'User KittyScrollbackLaunch' },
|
||||
-- version = '*', -- latest stable version, may have breaking changes if major version changed
|
||||
-- version = '^3.0.0', -- pin major version, include fixes and features that do not have breaking changes
|
||||
config = function()
|
||||
require('kitty-scrollback').setup {
|
||||
myconfig = function()
|
||||
return { keymaps_enabled = false }
|
||||
end,
|
||||
}
|
||||
end,
|
||||
},
|
||||
|
||||
{ import = 'custom.plugins' },
|
||||
}
|
|
@ -1,359 +0,0 @@
|
|||
return {
|
||||
{
|
||||
'neovim/nvim-lspconfig',
|
||||
dependencies = {
|
||||
-- Automatically install LSPs and related tools to stdpath for Neovim
|
||||
{ 'williamboman/mason.nvim', config = true }, -- NOTE: Must be loaded before dependants
|
||||
'williamboman/mason-lspconfig.nvim',
|
||||
'WhoIsSethDaniel/mason-tool-installer.nvim',
|
||||
|
||||
-- Useful status updates for LSP.
|
||||
-- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
|
||||
{ 'j-hui/fidget.nvim', opts = {} },
|
||||
|
||||
-- `lazydev` configures Lua LSP for your Neovim config, runtime and plugins
|
||||
-- used for completion, annotations and signatures of Neovim apis
|
||||
{ 'folke/lazydev.nvim' },
|
||||
},
|
||||
config = function()
|
||||
require 'custom.plugins.configs.lsp'
|
||||
end,
|
||||
},
|
||||
-- See `:help gitsigns` to understand what the configuration keys do
|
||||
{ -- Adds git related signs to the gutter, as well as utilities for managing changes
|
||||
'lewis6991/gitsigns.nvim',
|
||||
opts = {
|
||||
signs = {
|
||||
add = { text = '+' },
|
||||
change = { text = '~' },
|
||||
delete = { text = '_' },
|
||||
topdelete = { text = '‾' },
|
||||
changedelete = { text = '~' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
'folke/trouble.nvim',
|
||||
cmd = 'Trouble',
|
||||
opts = { use_diagnostic_signs = true },
|
||||
keys = {
|
||||
{ '<leader>ctb', '<cmd>Trouble diagnostics toggle filter.buf=0<cr>', desc = 'Document Diagnostics (Trouble)' },
|
||||
{ '<leader>ctr', '<cmd>Trouble diagnostics toggle<cr>', desc = 'Workspace Diagnostics (Trouble)' },
|
||||
{ '<leader>ctq', '<cmd>Trouble qflist toggle<cr>', desc = 'Quickfix List (Trouble)' },
|
||||
{ '<leader>ctl', '<cmd>Trouble loclist toggle<cr>', desc = 'Location List (Trouble)' },
|
||||
{ '<leader>ctd', '<cmd>Trouble symbols<cr>', desc = 'LSP symbols (Trouble)' },
|
||||
{ '<leader>ctt', '<cmd>Trouble todo<cr>', desc = 'Todos (Trouble)' },
|
||||
{ '<leader>cts', '<cmd>Trouble lsp_document_symbols toggle win.position=right<cr>', desc = 'Document [S]ymbols side (Trouble)' },
|
||||
{
|
||||
'[q',
|
||||
function()
|
||||
if require('trouble').is_open() then
|
||||
require('trouble').previous { skip_groups = true, jump = true }
|
||||
else
|
||||
vim.cmd.cprev()
|
||||
end
|
||||
end,
|
||||
desc = 'Previous trouble/quickfix item',
|
||||
},
|
||||
{
|
||||
']q',
|
||||
function()
|
||||
if require('trouble').is_open() then
|
||||
require('trouble').next { skip_groups = true, jump = true }
|
||||
else
|
||||
vim.cmd.cnext()
|
||||
end
|
||||
end,
|
||||
desc = 'Next trouble/quickfix item',
|
||||
},
|
||||
},
|
||||
},
|
||||
{ -- Autocompletion
|
||||
'hrsh7th/nvim-cmp',
|
||||
enabled = not vim.g.started_by_firenvim,
|
||||
event = 'InsertEnter',
|
||||
dependencies = {
|
||||
-- Snippet Engine & its associated nvim-cmp source
|
||||
{
|
||||
'L3MON4D3/LuaSnip',
|
||||
build = (function()
|
||||
-- Build Step is needed for regex support in snippets.
|
||||
-- This step is not supported in many windows environments.
|
||||
-- Remove the below condition to re-enable on windows.
|
||||
if vim.fn.has 'win32' == 1 or vim.fn.executable 'make' == 0 then
|
||||
return
|
||||
end
|
||||
return 'make install_jsregexp'
|
||||
end)(),
|
||||
dependencies = {
|
||||
-- `friendly-snippets` contains a variety of premade snippets.
|
||||
-- See the README about individual language/framework/plugin snippets:
|
||||
-- https://github.com/rafamadriz/friendly-snippets
|
||||
{
|
||||
'rafamadriz/friendly-snippets',
|
||||
config = function()
|
||||
require('luasnip.loaders.from_vscode').lazy_load()
|
||||
end,
|
||||
},
|
||||
},
|
||||
},
|
||||
'saadparwaiz1/cmp_luasnip',
|
||||
|
||||
-- Adds other completion capabilities.
|
||||
-- nvim-cmp does not ship with all sources by default. They are split
|
||||
-- into multiple repos for maintenance purposes.
|
||||
'hrsh7th/cmp-nvim-lsp',
|
||||
'hrsh7th/cmp-path',
|
||||
},
|
||||
config = function()
|
||||
-- See `:help cmp`
|
||||
local cmp = require 'cmp'
|
||||
local luasnip = require 'luasnip'
|
||||
luasnip.config.setup {}
|
||||
|
||||
cmp.setup {
|
||||
snippet = {
|
||||
expand = function(args)
|
||||
luasnip.lsp_expand(args.body)
|
||||
end,
|
||||
},
|
||||
completion = { completeopt = 'menu,menuone,noinsert' },
|
||||
|
||||
-- For an understanding of why these mappings were
|
||||
-- chosen, you will need to read `:help ins-completion`
|
||||
--
|
||||
-- No, but seriously. Please read `:help ins-completion`, it is really good!
|
||||
mapping = cmp.mapping.preset.insert {
|
||||
-- Select the [n]ext item
|
||||
['<C-n>'] = cmp.mapping.select_next_item(),
|
||||
-- Select the [p]revious item
|
||||
['<C-p>'] = cmp.mapping.select_prev_item(),
|
||||
|
||||
-- Scroll the documentation window [b]ack / [f]orward
|
||||
['<C-b>'] = cmp.mapping.scroll_docs(-4),
|
||||
['<C-f>'] = cmp.mapping.scroll_docs(4),
|
||||
|
||||
-- Accept ([y]es) the completion.
|
||||
-- This will auto-import if your LSP supports it.
|
||||
-- This will expand snippets if the LSP sent a snippet.
|
||||
-- ['<C-y>'] = cmp.mapping.confirm { select = true },
|
||||
|
||||
-- If you prefer more traditional completion keymaps,
|
||||
-- you can uncomment the following lines
|
||||
['<CR>'] = cmp.mapping.confirm { select = true },
|
||||
['<Tab>'] = cmp.mapping.select_next_item(),
|
||||
['<S-Tab>'] = cmp.mapping.select_prev_item(),
|
||||
|
||||
-- Manually trigger a completion from nvim-cmp.
|
||||
-- Generally you don't need this, because nvim-cmp will display
|
||||
-- completions whenever it has completion options available.
|
||||
['<C-Space>'] = cmp.mapping.complete {},
|
||||
|
||||
-- Think of <c-l> as moving to the right of your snippet expansion.
|
||||
-- So if you have a snippet that's like:
|
||||
-- function $name($args)
|
||||
-- $body
|
||||
-- end
|
||||
--
|
||||
-- <c-l> will move you to the right of each of the expansion locations.
|
||||
-- <c-h> is similar, except moving you backwards.
|
||||
--['<C-l>'] = cmp.mapping(function()
|
||||
-- if luasnip.expand_or_locally_jumpable() then
|
||||
-- luasnip.expand_or_jump()
|
||||
-- end
|
||||
--end, { 'i', 's' }),
|
||||
--['<C-h>'] = cmp.mapping(function()
|
||||
-- if luasnip.locally_jumpable(-1) then
|
||||
-- luasnip.jump(-1)
|
||||
-- end
|
||||
--end, { 'i', 's' }),
|
||||
|
||||
-- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:
|
||||
-- https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps
|
||||
},
|
||||
sources = {
|
||||
{ name = 'nvim_lsp' },
|
||||
{ name = 'luasnip' },
|
||||
{ name = 'path' },
|
||||
},
|
||||
}
|
||||
end,
|
||||
},
|
||||
{ -- Highlight, edit, and navigate code
|
||||
'nvim-treesitter/nvim-treesitter',
|
||||
build = ':TSUpdate',
|
||||
opts = {
|
||||
ensure_installed = { 'bash', 'c', 'diff', 'html', 'lua', 'luadoc', 'markdown', 'vim', 'vimdoc' },
|
||||
-- Autoinstall languages that are not installed
|
||||
auto_install = true,
|
||||
highlight = {
|
||||
enable = true,
|
||||
-- Some languages depend on vim's regex highlighting system (such as Ruby) for indent rules.
|
||||
-- If you are experiencing weird indenting issues, add the language to
|
||||
-- the list of additional_vim_regex_highlighting and disabled languages for indent.
|
||||
additional_vim_regex_highlighting = { 'ruby' },
|
||||
},
|
||||
indent = { enable = true, disable = { 'ruby' } },
|
||||
},
|
||||
config = function(_, opts)
|
||||
-- [[ Configure Treesitter ]] See `:help nvim-treesitter`
|
||||
|
||||
-- Prefer git instead of curl in order to improve connectivity in some environments
|
||||
require('nvim-treesitter.install').prefer_git = true
|
||||
---@diagnostic disable-next-line: missing-fields
|
||||
require('nvim-treesitter.configs').setup(opts)
|
||||
|
||||
-- There are additional nvim-treesitter modules that you can use to interact
|
||||
-- with nvim-treesitter. You should go explore a few and see what interests you:
|
||||
--
|
||||
-- - Incremental selection: Included, see `:help nvim-treesitter-incremental-selection-mod`
|
||||
-- - Show your current context: https://github.com/nvim-treesitter/nvim-treesitter-context
|
||||
-- - Treesitter + textobjects: https://github.com/nvim-treesitter/nvim-treesitter-textobjects
|
||||
end,
|
||||
},
|
||||
{
|
||||
'kevinhwang91/nvim-bqf',
|
||||
ft = 'qf',
|
||||
cmd = 'BqfAutoToggle',
|
||||
event = 'QuickFixCmdPost',
|
||||
opts = {
|
||||
auto_resize_height = false,
|
||||
func_map = {
|
||||
tab = 'st',
|
||||
split = 'sv',
|
||||
vsplit = 'sg',
|
||||
|
||||
stoggleup = 'K',
|
||||
stoggledown = 'J',
|
||||
stogglevm = '<Space>',
|
||||
|
||||
ptoggleitem = 'p',
|
||||
ptoggleauto = 'P',
|
||||
ptogglemode = 'zp',
|
||||
|
||||
pscrollup = '<C-b>',
|
||||
pscrolldown = '<C-f>',
|
||||
|
||||
prevfile = 'gk',
|
||||
nextfile = 'gj',
|
||||
|
||||
prevhist = '<S-Tab>',
|
||||
nexthist = '<Tab>',
|
||||
},
|
||||
preview = {
|
||||
auto_preview = true,
|
||||
should_preview_cb = function(bufnr)
|
||||
-- file size greater than 100kb can't be previewed automatically
|
||||
local filename = vim.api.nvim_buf_get_name(bufnr)
|
||||
local fsize = vim.fn.getfsize(filename)
|
||||
if fsize > 100 * 1024 then
|
||||
return false
|
||||
end
|
||||
return true
|
||||
end,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
'rmagatti/goto-preview',
|
||||
event = 'FileType',
|
||||
keys = {
|
||||
{
|
||||
'gpd',
|
||||
function()
|
||||
require('goto-preview').goto_preview_definition()
|
||||
end,
|
||||
desc = 'Go to definition preview',
|
||||
},
|
||||
{
|
||||
'gpD',
|
||||
function()
|
||||
require('goto-preview').goto_preview_declaration()
|
||||
end,
|
||||
desc = 'Go to declaration preview',
|
||||
},
|
||||
{
|
||||
'gpi',
|
||||
function()
|
||||
require('goto-preview').goto_preview_implementation()
|
||||
end,
|
||||
desc = 'Go to implementaion preview',
|
||||
},
|
||||
{
|
||||
'gpt',
|
||||
function()
|
||||
require('goto-preview').goto_preview_type_definition()
|
||||
end,
|
||||
desc = 'Go to type preview',
|
||||
},
|
||||
{
|
||||
'gpt',
|
||||
function()
|
||||
require('goto-preview').goto_preview_type_references()
|
||||
end,
|
||||
desc = 'Preview references',
|
||||
},
|
||||
{
|
||||
'gpc',
|
||||
function()
|
||||
require('goto-preview').close_all_win()
|
||||
end,
|
||||
desc = 'Close all preview windows',
|
||||
},
|
||||
},
|
||||
config = function()
|
||||
require('goto-preview').setup {}
|
||||
end,
|
||||
dependencies = 'nvim-telescope/telescope.nvim',
|
||||
opts = {
|
||||
width = 78,
|
||||
height = 15,
|
||||
default_mappings = false,
|
||||
opacity = 10,
|
||||
},
|
||||
},
|
||||
{ 'kosayoda/nvim-lightbulb', event = { 'BufReadPre', 'BufNewFile' } },
|
||||
{
|
||||
'folke/lazydev.nvim',
|
||||
ft = 'lua', -- only load on lua files
|
||||
opts = {
|
||||
library = {
|
||||
-- See the configuration section for more details
|
||||
-- Load luvit types when the `vim.uv` word is found
|
||||
{ path = 'luvit-meta/library', words = { 'vim%.uv' } },
|
||||
},
|
||||
},
|
||||
},
|
||||
{ 'Bilal2453/luvit-meta', lazy = true }, -- optional `vim.uv` typings
|
||||
{
|
||||
'nvimtools/none-ls.nvim',
|
||||
config = function()
|
||||
local null_ls = require 'null-ls'
|
||||
|
||||
null_ls.setup {
|
||||
sources = {
|
||||
null_ls.builtins.formatting.stylua,
|
||||
null_ls.builtins.formatting.gdformat,
|
||||
null_ls.builtins.diagnostics.gdlint,
|
||||
},
|
||||
}
|
||||
end,
|
||||
},
|
||||
{
|
||||
'chomosuke/typst-preview.nvim',
|
||||
ft = 'typst',
|
||||
version = '1.*',
|
||||
opts = {
|
||||
dependencies_bin = { ['tinymist'] = 'tinymist' }, -- use mason
|
||||
}, -- lazy.nvim will implicitly calls `setup {}`
|
||||
},
|
||||
{
|
||||
'hedyhli/outline.nvim',
|
||||
lazy = true,
|
||||
cmd = { 'Outline', 'OutlineOpen' },
|
||||
keys = { -- Example mapping to toggle outline
|
||||
{ '<leader>to', '<cmd>Outline<CR>', desc = 'Toggle outline' },
|
||||
},
|
||||
opts = {},
|
||||
},
|
||||
}
|
|
@ -1,100 +0,0 @@
|
|||
local utils = require 'custom.utils'
|
||||
|
||||
local ltex_fts = {
|
||||
'bibtex',
|
||||
'bib',
|
||||
'tex',
|
||||
'typst',
|
||||
'latex',
|
||||
'gitcommit',
|
||||
'markdown',
|
||||
'org',
|
||||
'restructuredtext',
|
||||
'rsweave',
|
||||
'quarto',
|
||||
'rmd',
|
||||
'context',
|
||||
'text',
|
||||
'html',
|
||||
'pandoc',
|
||||
'xhtml',
|
||||
'plaintex',
|
||||
'quarto',
|
||||
'mail',
|
||||
'mdx',
|
||||
'rmd',
|
||||
'rnoweb',
|
||||
'rst',
|
||||
}
|
||||
|
||||
local map = function(keys, func, desc)
|
||||
vim.keymap.set('n', keys, func, { buffer = vim.buf, desc = 'LSP[LTEX]: ' .. desc })
|
||||
end
|
||||
|
||||
LTEX_SETTINGS = {
|
||||
capabilities = CAPABILITIES,
|
||||
on_attach = function(client, bufnr)
|
||||
DEFAULT_ON_ATTACH(client, bufnr)
|
||||
end,
|
||||
autostart = false,
|
||||
filetypes = ltex_fts,
|
||||
settings = {
|
||||
ltex = {
|
||||
checkFrequency = 'save', -- shut up while i'm just editing, see <https://github.com/folke/noice.nvim/issues/166>
|
||||
-- specific language (such as en-GB or de-DE is recommended, but I
|
||||
-- want multilingual)
|
||||
language = 'auto',
|
||||
enabled = ltex_fts,
|
||||
additionalRules = {
|
||||
enablePickyRules = true,
|
||||
-- thats cool, but often adds diagnostics in
|
||||
-- places where a german might confuse words that are similar
|
||||
-- between english and german REGARDLESS of context. I seem to use the
|
||||
-- english words only in the proper contexts, so leaving this on
|
||||
-- just adds annoying hints like 'Hinweis: "list/NN.*" (English) bedeutet "Liste",
|
||||
-- "Verzeichnis" (German). Meinten Sie vielleicht 'cunning', 'trick'?'
|
||||
-- everytime I use the word "list". I liked that this makes the hints be
|
||||
-- in german regardless of the language I'm working in through...
|
||||
motherTongue = 'de',
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
-- load token and additional languagetool items later if specified
|
||||
local do_not_use_api_key = true
|
||||
local has_api_key, apiKey = utils.try_require 'custom.secret.languagetool'
|
||||
if not do_not_use_api_key and has_api_key and apiKey ~= '' then
|
||||
LTEX_SETTINGS = vim.tbl_deep_extend('keep', LTEX_SETTINGS, {
|
||||
settings = {
|
||||
languageToolOrg = {
|
||||
apiKey = apiKey,
|
||||
username = 'accounts@cscherr.de',
|
||||
},
|
||||
languageToolHttpServerUrl = 'https://api.languagetoolplus.com/',
|
||||
},
|
||||
})
|
||||
else
|
||||
if not do_not_use_api_key then
|
||||
print 'apiKey for ltex/languagetool is not specified'
|
||||
end
|
||||
end
|
||||
|
||||
return {
|
||||
'barreiroleo/ltex_extra.nvim',
|
||||
ft = ltex_fts,
|
||||
dependencies = { 'neovim/nvim-lspconfig' },
|
||||
config = function()
|
||||
require('ltex_extra').setup {
|
||||
load_langs = { 'en-US', 'de-DE' },
|
||||
init_check = true,
|
||||
server_opts = LTEX_SETTINGS, -- or use lspconfig regularly
|
||||
}
|
||||
map('<leader>tS', function()
|
||||
vim.cmd 'set spell'
|
||||
vim.opt.spelllang = 'en,de_de'
|
||||
vim.opt.spellsuggest = 'double,50,timeout:5000'
|
||||
vim.cmd 'LspStart ltex'
|
||||
end, 'Enable spell checking with languagetool')
|
||||
end,
|
||||
}
|
|
@ -1,164 +0,0 @@
|
|||
return {
|
||||
{ -- Fuzzy Finder (files, lsp, etc)
|
||||
'nvim-telescope/telescope.nvim',
|
||||
cmd = 'Telescope',
|
||||
dependencies = {
|
||||
'nvim-lua/plenary.nvim',
|
||||
'nvim-treesitter/nvim-treesitter',
|
||||
{ -- If encountering errors, see telescope-fzf-native README for installation instructions
|
||||
'nvim-telescope/telescope-fzf-native.nvim',
|
||||
|
||||
-- `build` is used to run some command when the plugin is installed/updated.
|
||||
-- This is only run then, not every time Neovim starts up.
|
||||
build = 'make',
|
||||
|
||||
-- `cond` is a condition used to determine whether this plugin should be
|
||||
-- installed and loaded.
|
||||
cond = function()
|
||||
return vim.fn.executable 'make' == 1
|
||||
end,
|
||||
},
|
||||
{ 'nvim-telescope/telescope-ui-select.nvim' },
|
||||
|
||||
-- Useful for getting pretty icons, but requires a Nerd Font.
|
||||
{ 'nvim-tree/nvim-web-devicons', enabled = vim.g.have_nerd_font },
|
||||
{ 'echasnovski/mini.icons', version = '*' },
|
||||
},
|
||||
config = function()
|
||||
-- Telescope is a fuzzy finder that comes with a lot of different things that
|
||||
-- it can fuzzy find! It's more than just a "file finder", it can search
|
||||
-- many different aspects of Neovim, your workspace, LSP, and more!
|
||||
--
|
||||
-- The easiest way to use Telescope, is to start by doing something like:
|
||||
-- :Telescope help_tags
|
||||
--
|
||||
-- After running this command, a window will open up and you're able to
|
||||
-- type in the prompt window. You'll see a list of `help_tags` options and
|
||||
-- a corresponding preview of the help.
|
||||
--
|
||||
-- Two important keymaps to use while in Telescope are:
|
||||
-- - Insert mode: <c-/>
|
||||
-- - Normal mode: ?
|
||||
--
|
||||
-- This opens a window that shows you all of the keymaps for the current
|
||||
-- Telescope picker. This is really useful to discover what Telescope can
|
||||
-- do as well as how to actually do it!
|
||||
|
||||
-- [[ Configure Telescope ]]
|
||||
-- See `:help telescope` and `:help telescope.setup()`
|
||||
require('telescope').setup {
|
||||
-- You can put your default mappings / updates / etc. in here
|
||||
-- All the info you're looking for is in `:help telescope.setup()`
|
||||
--
|
||||
-- pickers = {}
|
||||
extensions = {
|
||||
['ui-select'] = {
|
||||
require('telescope.themes').get_dropdown(),
|
||||
},
|
||||
},
|
||||
defaults = {
|
||||
mappings = {
|
||||
i = { ['<c-enter>'] = 'to_fuzzy_refine' },
|
||||
n = { ['q'] = require('telescope.actions').close },
|
||||
},
|
||||
vimgrep_arguments = {
|
||||
'rg',
|
||||
'-L',
|
||||
'--color=never',
|
||||
'--no-heading',
|
||||
'--with-filename',
|
||||
'--line-number',
|
||||
'--column',
|
||||
'--smart-case',
|
||||
},
|
||||
prompt_prefix = ' ',
|
||||
},
|
||||
}
|
||||
|
||||
-- Enable Telescope extensions if they are installed
|
||||
pcall(require('telescope').load_extension, 'fzf')
|
||||
pcall(require('telescope').load_extension, 'ui-select')
|
||||
|
||||
-- See `:help telescope.builtin`
|
||||
local builtin = require 'telescope.builtin'
|
||||
vim.keymap.set('n', '<localleader>fh', builtin.help_tags, { desc = '[H]elp' })
|
||||
vim.keymap.set('n', '<localleader>fk', builtin.keymaps, { desc = '[K]eymaps' })
|
||||
vim.keymap.set('n', '<localleader>ff', builtin.find_files, { desc = '[F]iles' })
|
||||
vim.keymap.set('n', '<localleader>fgf', builtin.git_files, { desc = '[G]it [F]iles' })
|
||||
vim.keymap.set('n', '<localleader>fe', builtin.builtin, { desc = 't[E]lescope' })
|
||||
vim.keymap.set('n', '<localleader>fw', builtin.live_grep, { desc = 'a [W]ord interactively' })
|
||||
vim.keymap.set('n', '<localleader>fcw', builtin.grep_string, { desc = '[C]urrent [W]ord' })
|
||||
vim.keymap.set('n', '<localleader>fr', builtin.resume, { desc = '[R]esume' })
|
||||
vim.keymap.set('n', '<localleader>fo', builtin.oldfiles, { desc = '[O]ld Files ("." for repeat)' })
|
||||
vim.keymap.set('n', '<localleader><leader>', builtin.buffers, { desc = '[ ] Find existing buffers' })
|
||||
vim.keymap.set('n', '<localleader>fb', builtin.buffers, { desc = 'existing [B]uffers' })
|
||||
vim.keymap.set('n', '<localleader>fm', builtin.marks, { desc = 'book[M]arks' })
|
||||
vim.keymap.set('n', '<localleader>fd', builtin.diagnostics, { desc = '[D]iagnostigs' })
|
||||
vim.keymap.set('n', '<localleader>fs', builtin.lsp_dynamic_workspace_symbols, { desc = 'LSP [S]ymbols' })
|
||||
|
||||
-- spelling
|
||||
vim.keymap.set('n', 'z<space>', builtin.spell_suggest, { desc = '[F]ind spelling' })
|
||||
vim.keymap.set('n', 'z=', builtin.spell_suggest, { desc = '[F]ind spelling' })
|
||||
|
||||
-- Slightly advanced example of overriding default behavior and theme
|
||||
vim.keymap.set('n', '<localleader>/', function()
|
||||
-- You can pass additional configuration to Telescope to change the theme, layout, etc.
|
||||
builtin.current_buffer_fuzzy_find(require('telescope.themes').get_dropdown {
|
||||
winblend = 10,
|
||||
previewer = false,
|
||||
})
|
||||
end, { desc = '[/] Fuzzily search in current buffer' })
|
||||
|
||||
-- It's also possible to pass additional configuration options.
|
||||
-- See `:help telescope.builtin.live_grep()` for information about particular keys
|
||||
vim.keymap.set('n', '<localleader>f/', function()
|
||||
builtin.live_grep {
|
||||
grep_open_files = true,
|
||||
prompt_title = 'Live Grep in Open Files',
|
||||
}
|
||||
end, { desc = '[F]ind [/] in Open Files' })
|
||||
|
||||
-- Shortcut for searching your Neovim configuration files
|
||||
vim.keymap.set('n', '<localleader>fnf', function()
|
||||
builtin.find_files { cwd = vim.fn.stdpath 'config' }
|
||||
end, { desc = '[F]ind [N]eovim [F]iles' })
|
||||
end,
|
||||
},
|
||||
{
|
||||
'jvgrootveld/telescope-zoxide',
|
||||
dependencies = 'nvim-telescope/telescope.nvim',
|
||||
config = function()
|
||||
vim.keymap.set('n', '<localleader>cd', '<cmd> Telescope zoxide list<cr>', { desc = '[C]hange [D]irectory' })
|
||||
-- Useful for easily creating commands
|
||||
local z_utils = require 'telescope._extensions.zoxide.utils'
|
||||
|
||||
require('telescope').setup {
|
||||
-- (other Telescope configuration...)
|
||||
extensions = {
|
||||
zoxide = {
|
||||
prompt_title = '[ Recently visited directories (zoxide) ]',
|
||||
mappings = {
|
||||
default = {
|
||||
after_action = function(selection)
|
||||
print('Update to (' .. selection.z_score .. ') ' .. selection.path)
|
||||
end,
|
||||
},
|
||||
['<C-s>'] = {
|
||||
before_action = function(selection)
|
||||
print 'before C-s'
|
||||
end,
|
||||
action = function(selection)
|
||||
vim.cmd.edit(selection.path)
|
||||
end,
|
||||
},
|
||||
-- Opens the selected entry in a new split
|
||||
['<C-q>'] = { action = z_utils.create_basic_command 'split' },
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
require('telescope').load_extension 'zoxide'
|
||||
end,
|
||||
},
|
||||
{ 'nanotee/zoxide.vim', lazy = false, enabled = false },
|
||||
}
|
|
@ -1,151 +0,0 @@
|
|||
the_themes = {
|
||||
-- Dark Themes
|
||||
{
|
||||
name = '==========Dark Themes==========',
|
||||
colorscheme = '', -- this actually keeps the selected theme, but it wont work with persistence
|
||||
},
|
||||
{
|
||||
name = 'nvim default',
|
||||
colorscheme = 'default',
|
||||
},
|
||||
{
|
||||
name = 'nvim lunaperche',
|
||||
colorscheme = 'lunaperche',
|
||||
},
|
||||
{
|
||||
name = 'nvim quiet',
|
||||
colorscheme = 'quiet',
|
||||
},
|
||||
{
|
||||
name = 'nvim retrobox',
|
||||
colorscheme = 'retrobox',
|
||||
},
|
||||
{
|
||||
name = 'nvim slate',
|
||||
colorscheme = 'slate',
|
||||
},
|
||||
{
|
||||
name = 'nvim vim',
|
||||
colorscheme = 'vim',
|
||||
},
|
||||
{
|
||||
name = 'tokyonight',
|
||||
colorscheme = 'tokyonight',
|
||||
},
|
||||
{
|
||||
name = 'tokyonight-moon',
|
||||
colorscheme = 'tokyonight-moon',
|
||||
},
|
||||
{
|
||||
name = 'tokyonight-storm',
|
||||
colorscheme = 'tokyonight-storm',
|
||||
},
|
||||
{
|
||||
name = 'kanagawa',
|
||||
colorscheme = 'kanagawa',
|
||||
},
|
||||
{
|
||||
name = 'kanagawa-dragon',
|
||||
colorscheme = 'kanagawa-dragon',
|
||||
},
|
||||
{
|
||||
name = 'kanagawa-wave',
|
||||
colorscheme = 'kanagawa-wave',
|
||||
},
|
||||
{
|
||||
name = 'zenbones',
|
||||
colorscheme = 'zenbones',
|
||||
before = [[
|
||||
-- It's a major hack from the themery guys that this is a string
|
||||
vim.opt.background = "dark"
|
||||
]],
|
||||
},
|
||||
{
|
||||
name = 'tokyobones',
|
||||
colorscheme = 'tokyobones',
|
||||
before = [[
|
||||
-- It's a major hack from the themery guys that this is a string
|
||||
vim.opt.background = "dark"
|
||||
]],
|
||||
},
|
||||
{
|
||||
name = 'kanagawabones',
|
||||
colorscheme = 'kanagawabones',
|
||||
before = [[
|
||||
-- It's a major hack from the themery guys that this is a string
|
||||
vim.opt.background = "dark"
|
||||
]],
|
||||
},
|
||||
'catppuccin-frappe',
|
||||
'catppuccin-macchiato',
|
||||
'catppuccin-mocha',
|
||||
'rose-pine-main',
|
||||
'rose-pine-moon',
|
||||
'cyberdream',
|
||||
-- Light themes
|
||||
{
|
||||
name = '==========Light Themes==========',
|
||||
colorscheme = '', -- this actually keeps the selected theme, but it wont work with persistence
|
||||
},
|
||||
{
|
||||
name = 'tokyonight-day',
|
||||
colorscheme = 'tokyonight-day',
|
||||
},
|
||||
{
|
||||
name = 'kanagawa-lotus',
|
||||
colorscheme = 'kanagawa-lotus',
|
||||
},
|
||||
{
|
||||
name = 'zenbones',
|
||||
colorscheme = 'zenbones',
|
||||
before = [[
|
||||
-- It's a major hack from the themery guys that this is a string
|
||||
vim.opt.background = "light"
|
||||
]],
|
||||
},
|
||||
'catppuccin-latte',
|
||||
'rose-pine-dawn',
|
||||
'cyberdream-light',
|
||||
}
|
||||
|
||||
return {
|
||||
{
|
||||
'zaldih/themery.nvim',
|
||||
lazy = false,
|
||||
cmd = 'Themery',
|
||||
keys = {
|
||||
{ ';ft', '<cmd> Themery <cr>', desc = '[F]ind [T]heme' },
|
||||
},
|
||||
config = function()
|
||||
require('themery').setup {
|
||||
themes = the_themes,
|
||||
livePreview = true, -- Apply theme while browsing. Default to true.
|
||||
}
|
||||
end,
|
||||
},
|
||||
'folke/tokyonight.nvim',
|
||||
'rebelot/kanagawa.nvim',
|
||||
{ 'zenbones-theme/zenbones.nvim', dependencies = { 'rktjmp/lush.nvim' } },
|
||||
{ 'catppuccin/nvim', name = 'catppuccin', priority = 1000 },
|
||||
{ 'rose-pine/neovim', name = 'rose-pine' },
|
||||
{
|
||||
'scottmckendry/cyberdream.nvim',
|
||||
setup = function()
|
||||
require('cyberdream').setup {
|
||||
-- Enable transparent background
|
||||
transparent = true,
|
||||
italic_comments = false,
|
||||
-- Replace all fillchars with ' ' for the ultimate clean look
|
||||
hide_fillchars = false,
|
||||
borderless_pickers = true,
|
||||
terminal_colors = true,
|
||||
cache = true,
|
||||
extensions = {
|
||||
telescope = true,
|
||||
notify = true,
|
||||
mini = true,
|
||||
},
|
||||
}
|
||||
end,
|
||||
},
|
||||
}
|
|
@ -1,31 +0,0 @@
|
|||
return {
|
||||
{
|
||||
'kdheepak/lazygit.nvim',
|
||||
keys = {
|
||||
{ '<leader>gg', '<cmd>LazyGit<cr>', desc = 'Open LazyGit' },
|
||||
},
|
||||
cmd = 'LazyGit',
|
||||
-- optional for floating window border decoration
|
||||
dependencies = {
|
||||
'nvim-lua/plenary.nvim',
|
||||
},
|
||||
},
|
||||
-- This was made by a frontend dev
|
||||
-- I need to manually:
|
||||
-- ```bash
|
||||
-- cd ~/.local/share/nvim/lazy/markdown-preview.nvim
|
||||
-- npm install
|
||||
-- ```
|
||||
-- See https://github.com/iamcco/markdown-preview.nvim/issues/695
|
||||
--
|
||||
-- Code smell but it works
|
||||
{
|
||||
'iamcco/markdown-preview.nvim',
|
||||
cmd = { 'MarkdownPreviewToggle', 'MarkdownPreview', 'MarkdownPreviewStop' },
|
||||
build = 'cd ~/.local/share/nvim/lazy/markdown-preview.nvim && npm install',
|
||||
init = function()
|
||||
vim.g.mkdp_filetypes = { 'markdown' }
|
||||
end,
|
||||
ft = { 'markdown' },
|
||||
},
|
||||
}
|
|
@ -1,696 +0,0 @@
|
|||
local custom_headers = {
|
||||
sharp = {
|
||||
[[ ]],
|
||||
[[ █ ████████ █████ ███████ ████ ]],
|
||||
[[ ███ ██████ █████ █████████ ██████ ]],
|
||||
[[ █████ ██████████████████████ ████ ███████████████ ]],
|
||||
[[ ██ ██ █████ █████████████ ████ ████████████████ ]],
|
||||
[[ ████ ███████████████ █████████ ████ █████ ██████ ████ ]],
|
||||
[[ ██████ ██████ ███ █████████ ████ █████ █████ ████ ]],
|
||||
[[ ████████ ███████████████████ ████ ████ █████ ████ ████ ]],
|
||||
[[ ]],
|
||||
[[ 🛠️ Sharp tools make good work 🖥️ ]],
|
||||
[[ ]],
|
||||
},
|
||||
}
|
||||
|
||||
return {
|
||||
{
|
||||
'nvim-tree/nvim-tree.lua',
|
||||
cmd = { 'NvimTreeToggle', 'NvimTreeFocus' },
|
||||
|
||||
opts = {
|
||||
filters = {
|
||||
dotfiles = false,
|
||||
exclude = { vim.fn.stdpath 'config' .. '/lua/custom' },
|
||||
},
|
||||
disable_netrw = true,
|
||||
hijack_netrw = true,
|
||||
hijack_cursor = true,
|
||||
hijack_unnamed_buffer_when_opening = false,
|
||||
sync_root_with_cwd = true,
|
||||
update_focused_file = {
|
||||
enable = true,
|
||||
update_root = false,
|
||||
},
|
||||
view = {
|
||||
adaptive_size = false,
|
||||
side = 'left',
|
||||
width = 30,
|
||||
preserve_window_proportions = true,
|
||||
},
|
||||
git = {
|
||||
enable = false,
|
||||
ignore = true,
|
||||
},
|
||||
filesystem_watchers = {
|
||||
enable = true,
|
||||
},
|
||||
actions = {
|
||||
open_file = {
|
||||
resize_window = true,
|
||||
},
|
||||
},
|
||||
renderer = {
|
||||
root_folder_label = false,
|
||||
highlight_git = false,
|
||||
highlight_opened_files = 'none',
|
||||
|
||||
indent_markers = {
|
||||
enable = false,
|
||||
},
|
||||
|
||||
icons = {
|
||||
show = {
|
||||
file = true,
|
||||
folder = true,
|
||||
folder_arrow = true,
|
||||
git = false,
|
||||
},
|
||||
|
||||
glyphs = {
|
||||
default = '',
|
||||
symlink = '',
|
||||
folder = {
|
||||
default = '',
|
||||
empty = '',
|
||||
empty_open = '',
|
||||
open = '',
|
||||
symlink = '',
|
||||
symlink_open = '',
|
||||
arrow_open = '',
|
||||
arrow_closed = '',
|
||||
},
|
||||
git = {
|
||||
unstaged = '✗',
|
||||
staged = '✓',
|
||||
unmerged = '',
|
||||
renamed = '➜',
|
||||
untracked = '★',
|
||||
deleted = '',
|
||||
ignored = '◌',
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
config = function(_, opts)
|
||||
require('nvim-tree').setup(opts)
|
||||
end,
|
||||
keys = {
|
||||
{ '<F5>', '<cmd> NvimTreeToggle <cr>', desc = '[T]oggle [F]ile explorer' },
|
||||
{ '<leader>tf', '<cmd> NvimTreeToggle <cr>', desc = '[T]oggle [F]ile explorer' },
|
||||
{ '<leader>fr', '<cmd> NvimTreeRefresh <cr>', desc = '[F]iles [R]efresh' },
|
||||
-- TODO: better map for cd
|
||||
},
|
||||
},
|
||||
{
|
||||
'ggandor/leap.nvim',
|
||||
lazy = false,
|
||||
opts = {},
|
||||
keys = {
|
||||
{ 's', '<plug>(leap-forward)', desc = 'leap forward' },
|
||||
{ 'S', '<plug>(leap-backward)', desc = 'leap backward' },
|
||||
{ 'gs', '<plug>(leap-from-window)', desc = 'leap from window' },
|
||||
},
|
||||
config = function()
|
||||
-- idk why it doesn't work when I just define an opts table, but that is
|
||||
-- so
|
||||
|
||||
local leap = require 'leap'
|
||||
|
||||
leap.opts.safe_labels = 'asfghjkliztrewb'
|
||||
leap.opts.labels = 'sfnjklhodweimbuyvrgtaqpcxz'
|
||||
leap.opts.special_keys = {
|
||||
next_target = '<enter>',
|
||||
prev_target = '<tab>',
|
||||
next_group = '<space>',
|
||||
prev_group = '<tab>',
|
||||
}
|
||||
end,
|
||||
},
|
||||
{
|
||||
'ggandor/flit.nvim',
|
||||
lazy = false,
|
||||
config = function()
|
||||
require('flit').setup {
|
||||
keys = { f = 'f', F = 'F', t = 't', T = 'T' },
|
||||
-- A string like "nv", "nvo", "o", etc.
|
||||
labeled_modes = 'v',
|
||||
multiline = true,
|
||||
-- Like `leap`s similar argument (call-specific overrides).
|
||||
-- E.g.: opts = { equivalence_classes = {} }
|
||||
opts = {},
|
||||
}
|
||||
end,
|
||||
},
|
||||
{ 'echasnovski/mini.trailspace', lazy = false, version = false, opts = { only_in_normal_buffers = true } },
|
||||
{
|
||||
'folke/which-key.nvim',
|
||||
event = 'VimEnter', -- Sets the loading event to 'VimEnter'
|
||||
opts = {
|
||||
triggers_nowait = {
|
||||
-- marks
|
||||
'`',
|
||||
"'",
|
||||
'g`',
|
||||
"g'",
|
||||
-- registers
|
||||
'"',
|
||||
'<c-r>',
|
||||
-- spelling
|
||||
'z=',
|
||||
'o',
|
||||
'O',
|
||||
},
|
||||
triggers_blacklist = {
|
||||
-- list of mode / prefixes that should never be hooked by WhichKey
|
||||
-- this is mostly relevant for keymaps that start with a native binding
|
||||
i = { 'j', 'k' },
|
||||
v = { 'j', 'k' },
|
||||
n = { 'o', 'O' },
|
||||
},
|
||||
-- plugins = {
|
||||
-- marks = true, -- shows a list of your marks on ' and `
|
||||
-- registers = true, -- shows your registers on " in NORMAL or <C-r> in INSERT mode
|
||||
-- -- the presets plugin, adds help for a bunch of default keybindings in Neovim
|
||||
-- -- No actual key bindings are created
|
||||
-- spelling = {
|
||||
-- enabled = true, -- enabling this will show WhichKey when pressing z= to select spelling suggestions
|
||||
-- suggestions = 20, -- how many suggestions should be shown in the list?
|
||||
-- },
|
||||
-- presets = {
|
||||
-- operators = true, -- adds help for operators like d, y, ...
|
||||
-- motions = true, -- adds help for motions
|
||||
-- text_objects = true, -- help for text objects triggered after entering an operator
|
||||
-- windows = true, -- default bindings on <c-w>
|
||||
-- nav = true, -- misc bindings to work with windows
|
||||
-- z = true, -- bindings for folds, spelling and others prefixed with z
|
||||
-- g = true, -- bindings for prefixed with g
|
||||
-- },
|
||||
-- },
|
||||
icons = {
|
||||
breadcrumb = '»', -- symbol used in the command line area that shows your active key combo
|
||||
separator = '➜', -- symbol used between a key and it's label
|
||||
group = '+', -- symbol prepended to a group
|
||||
},
|
||||
},
|
||||
config = function(opts)
|
||||
local wk = require 'which-key'
|
||||
local defaults = {
|
||||
mode = { 'n', 'v' },
|
||||
{ '<leader>c', group = '[C]ode/[C]olor' },
|
||||
{ '<leader>ct', group = '[T]rouble' },
|
||||
{ '<leader>d', group = '[D]ebug' },
|
||||
{ '<leader>dc', group = '[C]hange' },
|
||||
{ '<leader>dw', group = '[W]indow' },
|
||||
{ '<leader>f', group = '[F]ormatting' },
|
||||
{ '<leader>g', group = '[G]ood tools' },
|
||||
{ '<leader>r', group = '[R]ename' },
|
||||
{ '<leader>t', group = '[T]oggle' },
|
||||
{ '<leader>w', group = '[W]orkspace' },
|
||||
{ '<leader>wb', group = 'buffer' },
|
||||
{ '<localleader>', group = 'select' },
|
||||
{ '<localleader>f', group = '[F]ind' },
|
||||
{ '[', group = 'prev' },
|
||||
{ ']', group = 'next' },
|
||||
{ 'g', group = 'goto' },
|
||||
}
|
||||
wk.add(defaults, opts)
|
||||
end,
|
||||
},
|
||||
{
|
||||
'echasnovski/mini.trailspace',
|
||||
lazy = false,
|
||||
event = { 'BufReadPost', 'BufNewFile' },
|
||||
opts = {
|
||||
only_in_normal_buffers = true,
|
||||
},
|
||||
},
|
||||
{
|
||||
'itchyny/vim-cursorword',
|
||||
event = 'FileType',
|
||||
init = function()
|
||||
vim.g.cursorword = 0
|
||||
end,
|
||||
config = function()
|
||||
local augroup = vim.api.nvim_create_augroup('plex_cursorword', {})
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup,
|
||||
pattern = {
|
||||
'conf',
|
||||
'dosini',
|
||||
'json',
|
||||
'markdown',
|
||||
'nginx',
|
||||
'text',
|
||||
'yaml',
|
||||
},
|
||||
callback = function()
|
||||
if vim.wo.diff or vim.wo.previewwindow then
|
||||
vim.b.cursorword = 0
|
||||
else
|
||||
vim.b.cursorword = 1
|
||||
end
|
||||
end,
|
||||
})
|
||||
vim.api.nvim_create_autocmd('InsertEnter', {
|
||||
group = augroup,
|
||||
callback = function()
|
||||
if vim.b['cursorword'] == 1 then
|
||||
vim.b['cursorword'] = 0
|
||||
end
|
||||
end,
|
||||
})
|
||||
vim.api.nvim_create_autocmd('InsertLeave', {
|
||||
group = augroup,
|
||||
callback = function()
|
||||
if vim.b['cursorword'] == 0 then
|
||||
vim.b['cursorword'] = 1
|
||||
end
|
||||
end,
|
||||
})
|
||||
end,
|
||||
},
|
||||
{
|
||||
'RRethy/vim-illuminate',
|
||||
lazy = false,
|
||||
event = { 'BufReadPost', 'BufNewFile' },
|
||||
opts = {
|
||||
-- providers: provider used to get references in the buffer, ordered by priority
|
||||
providers = {
|
||||
'lsp', -- useless for tex but still used
|
||||
'treesitter',
|
||||
'regex',
|
||||
},
|
||||
large_file_cutoff = 50000,
|
||||
delay = 200,
|
||||
under_cursor = true,
|
||||
modes_allowlist = { 'n', 'no', 'nt' },
|
||||
filetypes_denylist = {
|
||||
'DiffviewFileHistory',
|
||||
'DiffviewFiles',
|
||||
'SidebarNvim',
|
||||
'fugitive',
|
||||
'git',
|
||||
'minifiles',
|
||||
'neo-tree',
|
||||
'NvimTree_1',
|
||||
'dashboard',
|
||||
},
|
||||
},
|
||||
-- looks weird but is useful: put your cursor on a word and other occurences
|
||||
-- of the word in your buffer will be highlighted. You can then use
|
||||
-- '[[' and ']]' to go to the next or previous occurence.
|
||||
--
|
||||
-- Try it:
|
||||
--
|
||||
-- word #### word ###########
|
||||
-- ############## word ######
|
||||
-- #### word #### word word #
|
||||
--
|
||||
-- (Does only work if the regex source is currently active, otherwise the
|
||||
-- references are those your language server or treesitter gives out, so
|
||||
-- syntax aware)
|
||||
keys = {
|
||||
{ ']]', desc = 'Next Reference' },
|
||||
{ '[[', desc = 'Prev Reference' },
|
||||
},
|
||||
config = function(_, opts)
|
||||
local illuminate = require 'illuminate'
|
||||
illuminate.configure(opts)
|
||||
vim.keymap.set('n', '[[', function()
|
||||
illuminate.goto_prev_reference() -- try putting your cursor on `illuminate`
|
||||
end, { desc = 'Goto last occurence of current word' })
|
||||
vim.keymap.set('n', ']]', function()
|
||||
illuminate.goto_next_reference()
|
||||
end, { desc = 'Goto next occurence of current word' })
|
||||
end,
|
||||
},
|
||||
{
|
||||
'folke/todo-comments.nvim',
|
||||
lazy = false,
|
||||
dependencies = 'nvim-telescope/telescope.nvim',
|
||||
-- stylua: ignore
|
||||
keys = {
|
||||
{ ']t', function() require('todo-comments').jump_next() end, desc = 'Next todo comment' },
|
||||
{ '[t', function() require('todo-comments').jump_prev() end, desc = 'Previous todo comment' },
|
||||
{ '<LocalLeader>fT', '<cmd>TodoTelescope<CR>', desc = 'todo' },
|
||||
},
|
||||
opts = {
|
||||
signs = true,
|
||||
keywords = {
|
||||
FIX = {
|
||||
icon = ' ', -- icon used for the sign, and in search results
|
||||
color = 'error', -- can be a hex color, or a named color (see below)
|
||||
alt = { 'FIXME', 'BUG', 'FIXIT', 'ISSUE' }, -- a set of other keywords that all map to this FIX keywords
|
||||
},
|
||||
TODO = { icon = ' ', color = 'todo' },
|
||||
HACK = { icon = ' ', color = 'hack' },
|
||||
SECURITY = { icon = ' ', color = 'security' },
|
||||
WARN = { icon = ' ', color = 'warning', alt = { 'WARNING', 'XXX' } },
|
||||
PERF = { icon = ' ', color = 'perf', alt = { 'OPTIM', 'PERFORMANCE', 'OPTIMIZE' } },
|
||||
NOTE = { icon = ' ', color = 'hint', alt = { 'INFO', 'IDEA' } },
|
||||
TEST = { icon = '⏲ ', color = 'test', alt = { 'TESTING', 'PASSED', 'FAILED' } },
|
||||
},
|
||||
colors = {
|
||||
error = { 'DiagnosticError', 'ErrorMsg', '#DC2626' },
|
||||
warning = { 'DiagnosticWarn', 'WarningMsg', '#FBBF24' },
|
||||
todo = { 'DiagnosticTodo', '#80e64d' },
|
||||
hint = { 'DiagnosticHint', '#10B981' },
|
||||
hack = { 'DiagnosticHack', '#FF33FF' },
|
||||
security = { 'DiagnosticSecurity', '#FF6600' },
|
||||
default = { 'Identifier', '#7C3AED' },
|
||||
test = { 'DiagnosticTest', '#E6E600' },
|
||||
perf = { 'DiagnosticPerf', '#9999ff' },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
'akinsho/toggleterm.nvim',
|
||||
keys = {
|
||||
{ '<F12>', mode = { 't', 'n', 'v' }, '<cmd>exe v:count1 "ToggleTerm direction=float"<cr>', desc = 'Toggle a big floating terminal' },
|
||||
{ '<A-i>', mode = { 't', 'n', 'v' }, '<cmd>exe v:count1 "ToggleTerm direction=float"<cr>', desc = 'Toggle a big floating terminal' },
|
||||
{ '<A-t>', mode = { 't', 'n', 'v' }, '<cmd>exe v:count1 "ToggleTerm direction=tab"<cr>', desc = 'Toggle a terminal in a new tab' },
|
||||
{ '<A-h>', mode = { 't', 'n', 'v' }, '<cmd>exe v:count1 "ToggleTerm direction=horizontal"<cr>', desc = 'Toggle a horizontal terminal' },
|
||||
{ '<A-v>', mode = { 't', 'n', 'v' }, '<cmd>exe v:count1 "ToggleTerm direction=vertical"<cr>', desc = 'Toggle a vertical terminal' },
|
||||
},
|
||||
cmd = 'ToggleTerm',
|
||||
opts = {
|
||||
size = function(term)
|
||||
if term.direction == 'horizontal' then
|
||||
return vim.o.lines * 0.35
|
||||
elseif term.direction == 'vertical' then
|
||||
return vim.o.columns * 0.35
|
||||
else
|
||||
return 20
|
||||
end
|
||||
end,
|
||||
open_mapping = false,
|
||||
float_opts = {
|
||||
border = 'curved',
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
'folke/noice.nvim',
|
||||
enabled = not vim.g.started_by_firenvim,
|
||||
event = 'VeryLazy',
|
||||
-- config.lsp.signature.enabled = false
|
||||
dependencies = {
|
||||
-- if you lazy-load any plugin below, make sure to add proper `module="..."` entries
|
||||
'MunifTanjim/nui.nvim',
|
||||
-- OPTIONAL:
|
||||
-- `nvim-notify` is only needed, if you want to use the notification view.
|
||||
-- If not available, we use `mini` as the fallback
|
||||
'rcarriga/nvim-notify',
|
||||
},
|
||||
config = function()
|
||||
require('notify').setup {
|
||||
top_down = false,
|
||||
}
|
||||
require('noice').setup {
|
||||
lsp = {
|
||||
override = {
|
||||
['vim.lsp.util.convert_input_to_markdown_lines'] = true,
|
||||
['vim.lsp.util.stylize_markdown'] = true,
|
||||
['cmp.entry.get_documentation'] = true,
|
||||
},
|
||||
-- IDK how to disable the nvchad builtins for this, which would
|
||||
-- produce a conflict
|
||||
signature = { enabled = false },
|
||||
hover = { enabled = false },
|
||||
progress = {
|
||||
enabled = true,
|
||||
-- Lsp Progress is formatted using the builtins for lsp_progress. See config.format.builtin
|
||||
-- See the section on formatting for more details on how to customize.
|
||||
--- @type NoiceFormat|string
|
||||
format = 'lsp_progress',
|
||||
--- @type NoiceFormat|string
|
||||
format_done = 'lsp_progress_done',
|
||||
throttle = 1000 / 30, -- frequency to update lsp progress message
|
||||
view = 'mini', -- default: mini
|
||||
},
|
||||
},
|
||||
-- you can enable a preset for easier configuration
|
||||
presets = {
|
||||
bottom_search = true, -- use a classic bottom cmdline for search
|
||||
command_palette = true, -- position the cmdline and popupmenu together
|
||||
long_message_to_split = true, -- long messages will be sent to a split
|
||||
inc_rename = true, -- enables an input dialog for inc-rename.nvim
|
||||
lsp_doc_border = true, -- add a border to hover docs and signature help
|
||||
},
|
||||
messages = {
|
||||
enabled = true,
|
||||
-- NOTE: we keep it with notify,
|
||||
-- change this to something else if you want
|
||||
view_error = 'notify',
|
||||
},
|
||||
popupmenu = {
|
||||
enabled = true,
|
||||
},
|
||||
notify = {
|
||||
enabled = true,
|
||||
},
|
||||
}
|
||||
end,
|
||||
},
|
||||
{
|
||||
'stevearc/dressing.nvim',
|
||||
init = function()
|
||||
---@diagnostic disable-next-line: duplicate-set-field
|
||||
vim.ui.select = function(...)
|
||||
require('lazy').load { plugins = { 'dressing.nvim' } }
|
||||
return vim.ui.select(...)
|
||||
end
|
||||
---@diagnostic disable-next-line: duplicate-set-field
|
||||
vim.ui.input = function(...)
|
||||
require('lazy').load { plugins = { 'dressing.nvim' } }
|
||||
return vim.ui.input(...)
|
||||
end
|
||||
end,
|
||||
},
|
||||
{
|
||||
'chentoast/marks.nvim',
|
||||
lazy = false,
|
||||
dependencies = 'lewis6991/gitsigns.nvim',
|
||||
event = 'FileType',
|
||||
opts = {
|
||||
sign_priority = { lower = 10, upper = 15, builtin = 8, bookmark = 20 },
|
||||
bookmark_1 = { sign = '' }, -- ⚐ ⚑
|
||||
},
|
||||
},
|
||||
{
|
||||
'Bekaboo/deadcolumn.nvim',
|
||||
event = { 'BufReadPre', 'BufNewFile' },
|
||||
},
|
||||
{
|
||||
'kevinhwang91/nvim-ufo',
|
||||
event = { 'BufReadPost', 'BufNewFile' },
|
||||
-- stylua: ignore
|
||||
keys = {
|
||||
{ 'zR', function() require('ufo').openAllFolds() end },
|
||||
{ 'zM', function() require('ufo').closeAllFolds() end },
|
||||
},
|
||||
dependencies = {
|
||||
'kevinhwang91/promise-async',
|
||||
'nvim-treesitter/nvim-treesitter',
|
||||
'neovim/nvim-lspconfig',
|
||||
},
|
||||
opts = function()
|
||||
-- fancy display function for folds (stolen from nvim-ufo readme)
|
||||
local handler = function(virtText, lnum, endLnum, width, truncate)
|
||||
local newVirtText = {}
|
||||
local suffix = (' %d '):format(endLnum - lnum)
|
||||
local sufWidth = vim.fn.strdisplaywidth(suffix)
|
||||
local targetWidth = width - sufWidth
|
||||
local curWidth = 0
|
||||
for _, chunk in ipairs(virtText) do
|
||||
local chunkText = chunk[1]
|
||||
local chunkWidth = vim.fn.strdisplaywidth(chunkText)
|
||||
if targetWidth > curWidth + chunkWidth then
|
||||
table.insert(newVirtText, chunk)
|
||||
else
|
||||
chunkText = truncate(chunkText, targetWidth - curWidth)
|
||||
local hlGroup = chunk[2]
|
||||
table.insert(newVirtText, { chunkText, hlGroup })
|
||||
chunkWidth = vim.fn.strdisplaywidth(chunkText)
|
||||
-- str width returned from truncate() may less than 2nd argument, need padding
|
||||
if curWidth + chunkWidth < targetWidth then
|
||||
suffix = suffix .. (' '):rep(targetWidth - curWidth - chunkWidth)
|
||||
end
|
||||
break
|
||||
end
|
||||
curWidth = curWidth + chunkWidth
|
||||
end
|
||||
table.insert(newVirtText, { suffix, 'MoreMsg' })
|
||||
return newVirtText
|
||||
end
|
||||
require('ufo').setup {
|
||||
-- use treesitter to get the folds
|
||||
provider_selector = function(bufnr, filetype, buftype)
|
||||
return { 'treesitter', 'indent' }
|
||||
end,
|
||||
-- apply out fancy fold display
|
||||
fold_virt_text_handler = handler,
|
||||
}
|
||||
end,
|
||||
},
|
||||
{
|
||||
'b0o/incline.nvim',
|
||||
event = 'FileType',
|
||||
config = function()
|
||||
local function get_diagnostic_label(props)
|
||||
local icons = { error = '', warn = '', info = '', hint = '' }
|
||||
local label = {}
|
||||
|
||||
for severity, icon in pairs(icons) do
|
||||
local n = #vim.diagnostic.get(props.buf,
|
||||
{ severity = vim.diagnostic.severity[string.upper(severity)] })
|
||||
if n > 0 then
|
||||
table.insert(label, { icon .. ' ' .. n .. ' ', group = 'DiagnosticSign' .. severity })
|
||||
end
|
||||
end
|
||||
if #label > 0 then
|
||||
table.insert(label, { '| ' })
|
||||
end
|
||||
return label
|
||||
end
|
||||
local function get_git_diff(props)
|
||||
local icons = { removed = '', changed = '', added = '' }
|
||||
local labels = {}
|
||||
-- local signs = vim.api.nvim_buf_get_var(props.buf, "gitsigns_status_dict")
|
||||
-- local signs = vim.b.gitsigns_status_dict
|
||||
-- for name, icon in pairs(icons) do
|
||||
-- if tonumber(signs[name]) and signs[name] > 0 then
|
||||
-- table.insert(labels, { icon .. " " .. signs[name] .. " ", group = "Diff" .. name })
|
||||
-- end
|
||||
-- end
|
||||
if #labels > 0 then
|
||||
table.insert(labels, { '| ' })
|
||||
end
|
||||
return labels
|
||||
end
|
||||
|
||||
require('incline').setup {
|
||||
render = function(props)
|
||||
local filename = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(props.buf), ':t')
|
||||
local ft_icon, ft_color = require('nvim-web-devicons').get_icon_color(filename)
|
||||
local modified = vim.api.nvim_buf_get_option(props.buf, 'modified') and 'bold,italic' or 'bold'
|
||||
|
||||
local buffer = {
|
||||
{ get_diagnostic_label(props) },
|
||||
{ get_git_diff(props) },
|
||||
{ ft_icon, guifg = ft_color },
|
||||
{ ' ' },
|
||||
{ filename, gui = modified },
|
||||
}
|
||||
return buffer
|
||||
end,
|
||||
}
|
||||
end,
|
||||
},
|
||||
{
|
||||
'nvim-lualine/lualine.nvim',
|
||||
lazy = false,
|
||||
dependencies = {
|
||||
'nvim-tree/nvim-web-devicons',
|
||||
'yavorski/lualine-macro-recording.nvim',
|
||||
},
|
||||
config = function()
|
||||
require('lualine').setup {
|
||||
options = {
|
||||
theme = 'horizon',
|
||||
},
|
||||
sections = {
|
||||
lualine_a = { 'mode' },
|
||||
lualine_b = { 'branch', 'diff', 'diagnostics' },
|
||||
lualine_c = { { 'macro_recording', color = { fg = '#ff9e3b' } }, 'filename', 'locatoin' },
|
||||
lualine_x = { 'encoding', 'fileformat', 'filetype' },
|
||||
lualine_y = { 'progress' },
|
||||
lualine_z = { 'location' },
|
||||
},
|
||||
}
|
||||
end,
|
||||
},
|
||||
{
|
||||
'akinsho/bufferline.nvim',
|
||||
dependencies = {
|
||||
'nvim-tree/nvim-web-devicons',
|
||||
{
|
||||
'tiagovla/scope.nvim',
|
||||
config = function()
|
||||
require('scope').setup {}
|
||||
require('telescope').load_extension 'scope'
|
||||
end,
|
||||
},
|
||||
},
|
||||
config = function()
|
||||
vim.opt.termguicolors = true
|
||||
require('bufferline').setup {}
|
||||
end,
|
||||
},
|
||||
'sindrets/diffview.nvim',
|
||||
{
|
||||
'MeanderingProgrammer/dashboard.nvim',
|
||||
enable = true,
|
||||
event = 'VimEnter',
|
||||
dependencies = {
|
||||
'MaximilianLloyd/ascii.nvim',
|
||||
},
|
||||
init = function()
|
||||
vim.api.nvim_create_autocmd({ 'BufWinEnter', 'VimEnter' }, {
|
||||
pattern = { 'dashboard', 'text', 'help', '*' },
|
||||
callback = function()
|
||||
vim.b.minitrailspace_disable = true
|
||||
vim.opt_local.list = false
|
||||
vim.opt_local.spell = false
|
||||
vim.opt_local.colorcolumn = '0'
|
||||
end,
|
||||
})
|
||||
end,
|
||||
config = function()
|
||||
-- Do not show trailing space in unmodifiable types
|
||||
require('dashboard').setup {
|
||||
-- Dashboard header
|
||||
header = custom_headers.sharp,
|
||||
-- List of directory paths, or functions that return paths
|
||||
directories = {
|
||||
'~/.config/nvim',
|
||||
'~/Documents/code',
|
||||
'~/Documents/novel',
|
||||
},
|
||||
-- Format to display date in
|
||||
date_format = '%Y-%m-%d %H:%M:%S',
|
||||
-- Sections to add at bottom, these can be string references to
|
||||
-- functions in sections.lua, custom strings, or custom functions
|
||||
footer = {
|
||||
[[ ]],
|
||||
[[ Theme ;ft ]],
|
||||
[[ Git ␣gg ]],
|
||||
[[ Find File ;ff ]],
|
||||
[[ Recent Files ;fo ]],
|
||||
[[ Find Word ;fw ]],
|
||||
[[ Bookmarks ;fm ]],
|
||||
[[ ]],
|
||||
[[ Change Directory ;cd ]],
|
||||
[[ Files F5 ]],
|
||||
[[ Terminal F12 ]],
|
||||
},
|
||||
|
||||
-- Gets called after directory is changed and is provided with the
|
||||
-- directory path as an argument
|
||||
on_load = function(path)
|
||||
-- Do nothing
|
||||
end,
|
||||
-- Highlight groups to use for various components
|
||||
highlight_groups = {
|
||||
header = 'Constant',
|
||||
icon = 'Type',
|
||||
directory = 'Delimiter',
|
||||
hotkey = 'Statement',
|
||||
},
|
||||
}
|
||||
end,
|
||||
},
|
||||
}
|
|
@ -1,83 +0,0 @@
|
|||
local M = {}
|
||||
--- this function will split a string into a table of tokens, like it would
|
||||
--- be passed into the `argv` of a program that was executed from the commandline
|
||||
---
|
||||
--- @param raw string string of cli args that should be split
|
||||
--- @return table tokens args as a table
|
||||
M.tokenize_args = function(raw)
|
||||
-- NOTE: string.gmatch is does not use regex, but a smaller pattern matcher!
|
||||
-- A complete regex parser would be larger than lua itself. See
|
||||
-- [Programming in Lua 20.2](https://www.lua.org/pil/20.2.html).
|
||||
--
|
||||
-- Notable differences:
|
||||
-- '-' is ungreedy wildcard
|
||||
-- '*?' does not work
|
||||
-- '|' is not or
|
||||
--
|
||||
-- This means we're better of implementing the lexer with an algorithm.
|
||||
local t = {}
|
||||
local current = ''
|
||||
local in_str = false
|
||||
local str_seek
|
||||
for c in string.gmatch(raw, '.') do -- iterate through all chars
|
||||
if c == ' ' and not in_str then
|
||||
if string.len(current) > 0 then
|
||||
table.insert(t, current)
|
||||
current = ''
|
||||
end
|
||||
elseif c == '"' and not in_str then
|
||||
in_str = true
|
||||
str_seek = '"'
|
||||
elseif c == "'" and not in_str then
|
||||
in_str = true
|
||||
str_seek = "'"
|
||||
elseif c == str_seek and in_str then
|
||||
in_str = false
|
||||
table.insert(t, current)
|
||||
current = ''
|
||||
else
|
||||
current = current .. c
|
||||
end
|
||||
end
|
||||
if string.len(current) > 0 then
|
||||
table.insert(t, current)
|
||||
end
|
||||
return t
|
||||
end
|
||||
|
||||
--- dumps a variable into a string, so it can be printed. This is meant for
|
||||
--- debug prints
|
||||
--- @param t any variable
|
||||
--- @return string t_dumped t dumped to string
|
||||
M.dump = function(t)
|
||||
if type(t) == 'table' then
|
||||
local s = '{ '
|
||||
for k, v in pairs(t) do
|
||||
if type(k) ~= 'number' then
|
||||
k = '"' .. k .. '"'
|
||||
end
|
||||
if k ~= 1 then
|
||||
s = s .. ', '
|
||||
end
|
||||
s = s .. '[' .. k .. "] = '" .. M.dump(v) .. "'\n"
|
||||
end
|
||||
return s .. ' }'
|
||||
else
|
||||
return tostring(t)
|
||||
end
|
||||
end
|
||||
|
||||
--- Try to require a module
|
||||
--- @param module string module name
|
||||
--- @return boolean available is the module available?
|
||||
--- @return any loaded_module the loaded module if it is available
|
||||
M.try_require = function(module)
|
||||
local available, loaded_module = pcall(require, module)
|
||||
if not available then
|
||||
return available, nil
|
||||
else
|
||||
return available, loaded_module
|
||||
end
|
||||
end
|
||||
|
||||
return M
|
|
@ -1,52 +0,0 @@
|
|||
--[[
|
||||
--
|
||||
-- This file is not required for your own configuration,
|
||||
-- but helps people determine if their system is setup correctly.
|
||||
--
|
||||
--]]
|
||||
|
||||
local check_version = function()
|
||||
local verstr = string.format('%s.%s.%s', vim.version().major, vim.version().minor, vim.version().patch)
|
||||
if not vim.version.cmp then
|
||||
vim.health.error(string.format("Neovim out of date: '%s'. Upgrade to latest stable or nightly", verstr))
|
||||
return
|
||||
end
|
||||
|
||||
if vim.version.cmp(vim.version(), { 0, 9, 4 }) >= 0 then
|
||||
vim.health.ok(string.format("Neovim version is: '%s'", verstr))
|
||||
else
|
||||
vim.health.error(string.format("Neovim out of date: '%s'. Upgrade to latest stable or nightly", verstr))
|
||||
end
|
||||
end
|
||||
|
||||
local check_external_reqs = function()
|
||||
-- Basic utils: `git`, `make`, `unzip`
|
||||
for _, exe in ipairs { 'git', 'make', 'unzip', 'rg' } do
|
||||
local is_executable = vim.fn.executable(exe) == 1
|
||||
if is_executable then
|
||||
vim.health.ok(string.format("Found executable: '%s'", exe))
|
||||
else
|
||||
vim.health.warn(string.format("Could not find executable: '%s'", exe))
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
return {
|
||||
check = function()
|
||||
vim.health.start 'kickstart.nvim'
|
||||
|
||||
vim.health.info [[NOTE: Not every warning is a 'must-fix' in `:checkhealth`
|
||||
|
||||
Fix only warnings for plugins and languages you intend to use.
|
||||
Mason will give warnings for languages that are not installed.
|
||||
You do not need to install, unless you want to use those languages!]]
|
||||
|
||||
local uv = vim.uv or vim.loop
|
||||
vim.health.info('System Information: ' .. vim.inspect(uv.os_uname()))
|
||||
|
||||
check_version()
|
||||
check_external_reqs()
|
||||
end,
|
||||
}
|
|
@ -1,16 +0,0 @@
|
|||
-- autopairs
|
||||
-- https://github.com/windwp/nvim-autopairs
|
||||
|
||||
return {
|
||||
'windwp/nvim-autopairs',
|
||||
event = 'InsertEnter',
|
||||
-- Optional dependency
|
||||
dependencies = { 'hrsh7th/nvim-cmp' },
|
||||
config = function()
|
||||
require('nvim-autopairs').setup {}
|
||||
-- If you want to automatically add `(` after selecting a function or method
|
||||
local cmp_autopairs = require 'nvim-autopairs.completion.cmp'
|
||||
local cmp = require 'cmp'
|
||||
cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done())
|
||||
end,
|
||||
}
|
|
@ -1,212 +0,0 @@
|
|||
-- debug.lua
|
||||
--
|
||||
-- Shows how to use the DAP plugin to debug your code.
|
||||
--
|
||||
-- Primarily focused on configuring the debugger for Go, but can
|
||||
-- be extended to other languages as well. That's why it's called
|
||||
-- kickstart.nvim and not kitchen-sink.nvim ;)
|
||||
|
||||
return {
|
||||
{
|
||||
-- NOTE: Yes, you can install new plugins here!
|
||||
'mfussenegger/nvim-dap',
|
||||
-- NOTE: And you can specify dependencies as well
|
||||
dependencies = {
|
||||
-- Creates a beautiful debugger UI
|
||||
|
||||
-- Required dependency for nvim-dap-ui
|
||||
'nvim-neotest/nvim-nio',
|
||||
|
||||
-- Installs the debug adapters for you
|
||||
'williamboman/mason.nvim',
|
||||
'jay-babu/mason-nvim-dap.nvim',
|
||||
|
||||
'theHamsta/nvim-dap-virtual-text',
|
||||
},
|
||||
config = function()
|
||||
local dap = require 'dap'
|
||||
local dapui = require 'dapui'
|
||||
|
||||
require('mason-nvim-dap').setup {
|
||||
-- Makes a best effort to setup the various debuggers with
|
||||
-- reasonable debug configurations
|
||||
automatic_installation = true,
|
||||
|
||||
-- You can provide additional configuration to the handlers,
|
||||
-- see mason-nvim-dap README for more information
|
||||
handlers = {},
|
||||
|
||||
-- You'll need to check that you have the required things installed
|
||||
-- online, please don't ask me how to install them :)
|
||||
ensure_installed = {
|
||||
-- Update this to ensure that you have the debuggers for the langs you want
|
||||
'codelldb',
|
||||
'debugpy',
|
||||
},
|
||||
}
|
||||
|
||||
-- Basic debugging keymaps, feel free to change to your liking!
|
||||
vim.keymap.set('n', '<leader>dB', function() end, { desc = 'Debug: Set Breakpoint' })
|
||||
|
||||
-- Dap UI setup
|
||||
-- For more information, see |:help nvim-dap-ui|
|
||||
dapui.setup {
|
||||
-- Set icons to characters that are more likely to work in every terminal.
|
||||
-- Feel free to remove or use ones that you like more! :)
|
||||
-- Don't feel like these are good choices.
|
||||
icons = { expanded = '▾', collapsed = '▸', current_frame = '*' },
|
||||
controls = {
|
||||
icons = {
|
||||
pause = '⏸',
|
||||
play = '▶',
|
||||
step_into = '⏎',
|
||||
step_over = '⏭',
|
||||
step_out = '⏮',
|
||||
step_back = 'b',
|
||||
run_last = '▶▶',
|
||||
terminate = '⏹',
|
||||
disconnect = '⏏',
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
dap.listeners.after.event_initialized['dapui_config'] = dapui.open
|
||||
dap.listeners.before.event_terminated['dapui_config'] = dapui.close
|
||||
dap.listeners.before.event_exited['dapui_config'] = dapui.close
|
||||
end,
|
||||
},
|
||||
{
|
||||
'rcarriga/nvim-dap-ui',
|
||||
keys = {
|
||||
{
|
||||
'<leader>du',
|
||||
function()
|
||||
require('dapui').toggle()
|
||||
end,
|
||||
|
||||
desc = 'Open [D]ebug [U]i',
|
||||
},
|
||||
{
|
||||
'<leader>dso',
|
||||
function()
|
||||
require('dap').step_over()
|
||||
end,
|
||||
|
||||
desc = 'Toggle [D]ebug [S]tep [O]ver',
|
||||
},
|
||||
{
|
||||
'<leader>dsi',
|
||||
function()
|
||||
require('dap').step_into()
|
||||
end,
|
||||
|
||||
desc = 'Toggle [D]ebug [S]tep [I]nto',
|
||||
},
|
||||
{
|
||||
'<leader>dc',
|
||||
function()
|
||||
require('dap').continue()
|
||||
end,
|
||||
|
||||
desc = 'Toggle [D]ebug [C]ontinue / Start',
|
||||
},
|
||||
{
|
||||
'<leader>db',
|
||||
function()
|
||||
require('dap').toggle_breakpoint()
|
||||
end,
|
||||
|
||||
desc = 'Toggle [D]ebug [B]reakpoint',
|
||||
},
|
||||
{
|
||||
'<leader>dB',
|
||||
function()
|
||||
require('dap').set_breakpoint(vim.fn.input 'Breakpoint condition: ')
|
||||
end,
|
||||
|
||||
desc = 'Toggle [D]ebug [B]reakpoint condition',
|
||||
},
|
||||
{
|
||||
'<leader>dK',
|
||||
function()
|
||||
require('dap.ui.widgets').hover()
|
||||
end,
|
||||
|
||||
desc = 'Open [D]ebug [K] hover',
|
||||
},
|
||||
{
|
||||
'<leader>dws',
|
||||
function()
|
||||
local widgets = require 'dap.ui.widgets'
|
||||
local my_sidebar = widgets.sidebar(widgets.scopes)
|
||||
my_sidebar.open()
|
||||
end,
|
||||
desc = 'Open [D]ebug [W]indow [S]copes',
|
||||
},
|
||||
{
|
||||
'<leader>dwr',
|
||||
function()
|
||||
require('dap').repl.toggle()
|
||||
end,
|
||||
|
||||
desc = 'Open [D]ebug [W]indow [R]epl',
|
||||
},
|
||||
{
|
||||
'<leader>dwf',
|
||||
function()
|
||||
local widgets = require 'dap.ui.widgets'
|
||||
local my_sidebar = widgets.sidebar(widgets.frames)
|
||||
my_sidebar.open()
|
||||
end,
|
||||
|
||||
desc = 'Open [D]ebug [W]indow [F]rames',
|
||||
},
|
||||
{
|
||||
'<leader>dwi',
|
||||
function()
|
||||
local widgets = require 'dap.ui.widgets'
|
||||
local my_sidebar = widgets.sidebar(widgets.sessions)
|
||||
my_sidebar.open()
|
||||
end,
|
||||
desc = 'Open [D]ebug [W]indow sess[I]ons',
|
||||
},
|
||||
{
|
||||
'<leader>dwt',
|
||||
function()
|
||||
local widgets = require 'dap.ui.widgets'
|
||||
local my_sidebar = widgets.sidebar(widgets.threads)
|
||||
my_sidebar.open()
|
||||
end,
|
||||
desc = 'Open [D]ebug [W]indow [T]hreads',
|
||||
},
|
||||
{
|
||||
'<leader>dwe',
|
||||
function()
|
||||
local widgets = require 'dap.ui.widgets'
|
||||
local my_sidebar = widgets.sidebar(widgets.expression)
|
||||
my_sidebar.open()
|
||||
end,
|
||||
|
||||
desc = 'Open [D]ebug [W]indow [E]xpression',
|
||||
},
|
||||
},
|
||||
dependencies = {
|
||||
'mfussenegger/nvim-dap',
|
||||
'nvim-neotest/nvim-nio',
|
||||
},
|
||||
config = function(_, opts)
|
||||
local dap = require 'dap'
|
||||
local dapui = require 'dapui'
|
||||
dapui.setup(opts)
|
||||
dap.listeners.after.event_initialized['dapui_config'] = function()
|
||||
dapui.open {}
|
||||
end
|
||||
dap.listeners.before.event_terminated['dapui_config'] = function()
|
||||
-- dapui.close {}
|
||||
end
|
||||
dap.listeners.before.event_exited['dapui_config'] = function()
|
||||
-- dapui.close {}
|
||||
end
|
||||
end,
|
||||
},
|
||||
}
|
|
@ -1,61 +0,0 @@
|
|||
-- Adds git related signs to the gutter, as well as utilities for managing changes
|
||||
-- NOTE: gitsigns is already included in init.lua but contains only the base
|
||||
-- config. This will add also the recommended keymaps.
|
||||
|
||||
return {
|
||||
{
|
||||
'lewis6991/gitsigns.nvim',
|
||||
opts = {
|
||||
on_attach = function(bufnr)
|
||||
local gitsigns = require 'gitsigns'
|
||||
|
||||
local function map(mode, l, r, opts)
|
||||
opts = opts or {}
|
||||
opts.buffer = bufnr
|
||||
vim.keymap.set(mode, l, r, opts)
|
||||
end
|
||||
|
||||
-- Navigation
|
||||
map('n', ']c', function()
|
||||
if vim.wo.diff then
|
||||
vim.cmd.normal { ']c', bang = true }
|
||||
else
|
||||
gitsigns.nav_hunk 'next'
|
||||
end
|
||||
end, { desc = 'Jump to next git [c]hange' })
|
||||
|
||||
map('n', '[c', function()
|
||||
if vim.wo.diff then
|
||||
vim.cmd.normal { '[c', bang = true }
|
||||
else
|
||||
gitsigns.nav_hunk 'prev'
|
||||
end
|
||||
end, { desc = 'Jump to previous git [c]hange' })
|
||||
|
||||
-- Actions
|
||||
-- visual mode
|
||||
map('v', '<leader>hs', function()
|
||||
gitsigns.stage_hunk { vim.fn.line '.', vim.fn.line 'v' }
|
||||
end, { desc = 'stage git hunk' })
|
||||
map('v', '<leader>hr', function()
|
||||
gitsigns.reset_hunk { vim.fn.line '.', vim.fn.line 'v' }
|
||||
end, { desc = 'reset git hunk' })
|
||||
-- normal mode
|
||||
map('n', '<leader>hs', gitsigns.stage_hunk, { desc = 'git [s]tage hunk' })
|
||||
map('n', '<leader>hr', gitsigns.reset_hunk, { desc = 'git [r]eset hunk' })
|
||||
map('n', '<leader>hS', gitsigns.stage_buffer, { desc = 'git [S]tage buffer' })
|
||||
map('n', '<leader>hu', gitsigns.undo_stage_hunk, { desc = 'git [u]ndo stage hunk' })
|
||||
map('n', '<leader>hR', gitsigns.reset_buffer, { desc = 'git [R]eset buffer' })
|
||||
map('n', '<leader>hp', gitsigns.preview_hunk, { desc = 'git [p]review hunk' })
|
||||
map('n', '<leader>hb', gitsigns.blame_line, { desc = 'git [b]lame line' })
|
||||
map('n', '<leader>hd', gitsigns.diffthis, { desc = 'git [d]iff against index' })
|
||||
map('n', '<leader>hD', function()
|
||||
gitsigns.diffthis '@'
|
||||
end, { desc = 'git [D]iff against last commit' })
|
||||
-- Toggles
|
||||
map('n', '<leader>tb', gitsigns.toggle_current_line_blame, { desc = '[T]oggle git show [b]lame line' })
|
||||
map('n', '<leader>tD', gitsigns.toggle_deleted, { desc = '[T]oggle git show [D]eleted' })
|
||||
end,
|
||||
},
|
||||
},
|
||||
}
|
|
@ -1,27 +0,0 @@
|
|||
return {
|
||||
{ -- Add indentation guides even on blank lines
|
||||
'lukas-reineke/indent-blankline.nvim',
|
||||
-- Enable `lukas-reineke/indent-blankline.nvim`
|
||||
-- See `:help ibl`
|
||||
main = 'ibl',
|
||||
opts = {
|
||||
indentLine_enabled = 1,
|
||||
filetype_exclude = {
|
||||
'help',
|
||||
'terminal',
|
||||
'lazy',
|
||||
'lspinfo',
|
||||
'TelescopePrompt',
|
||||
'TelescopeResults',
|
||||
'mason',
|
||||
'dashboard',
|
||||
'',
|
||||
},
|
||||
buftype_exclude = { 'terminal' },
|
||||
show_trailing_blankline_indent = false,
|
||||
show_first_indent_level = false,
|
||||
show_current_context = true,
|
||||
show_current_context_start = true,
|
||||
},
|
||||
},
|
||||
}
|
|
@ -1,55 +0,0 @@
|
|||
return {
|
||||
|
||||
{ -- Linting
|
||||
'mfussenegger/nvim-lint',
|
||||
event = { 'BufReadPre', 'BufNewFile' },
|
||||
config = function()
|
||||
local lint = require 'lint'
|
||||
lint.linters_by_ft = {
|
||||
markdown = { 'markdownlint' },
|
||||
}
|
||||
|
||||
-- To allow other plugins to add linters to require('lint').linters_by_ft,
|
||||
-- instead set linters_by_ft like this:
|
||||
-- lint.linters_by_ft = lint.linters_by_ft or {}
|
||||
-- lint.linters_by_ft['markdown'] = { 'markdownlint' }
|
||||
--
|
||||
-- However, note that this will enable a set of default linters,
|
||||
-- which will cause errors unless these tools are available:
|
||||
-- {
|
||||
-- clojure = { "clj-kondo" },
|
||||
-- dockerfile = { "hadolint" },
|
||||
-- inko = { "inko" },
|
||||
-- janet = { "janet" },
|
||||
-- json = { "jsonlint" },
|
||||
-- markdown = { "vale" },
|
||||
-- rst = { "vale" },
|
||||
-- ruby = { "ruby" },
|
||||
-- terraform = { "tflint" },
|
||||
-- text = { "vale" }
|
||||
-- }
|
||||
--
|
||||
-- You can disable the default linters by setting their filetypes to nil:
|
||||
-- lint.linters_by_ft['clojure'] = nil
|
||||
-- lint.linters_by_ft['dockerfile'] = nil
|
||||
-- lint.linters_by_ft['inko'] = nil
|
||||
-- lint.linters_by_ft['janet'] = nil
|
||||
-- lint.linters_by_ft['json'] = nil
|
||||
-- lint.linters_by_ft['markdown'] = nil
|
||||
-- lint.linters_by_ft['rst'] = nil
|
||||
-- lint.linters_by_ft['ruby'] = nil
|
||||
-- lint.linters_by_ft['terraform'] = nil
|
||||
-- lint.linters_by_ft['text'] = nil
|
||||
|
||||
-- Create autocommand which carries out the actual linting
|
||||
-- on the specified events.
|
||||
local lint_augroup = vim.api.nvim_create_augroup('lint', { clear = true })
|
||||
vim.api.nvim_create_autocmd({ 'BufEnter', 'BufWritePost', 'InsertLeave' }, {
|
||||
group = lint_augroup,
|
||||
callback = function()
|
||||
require('lint').try_lint()
|
||||
end,
|
||||
})
|
||||
end,
|
||||
},
|
||||
}
|
|
@ -1,25 +0,0 @@
|
|||
-- Neo-tree is a Neovim plugin to browse the file system
|
||||
-- https://github.com/nvim-neo-tree/neo-tree.nvim
|
||||
|
||||
return {
|
||||
'nvim-neo-tree/neo-tree.nvim',
|
||||
version = '*',
|
||||
dependencies = {
|
||||
'nvim-lua/plenary.nvim',
|
||||
'nvim-tree/nvim-web-devicons', -- not strictly required, but recommended
|
||||
'MunifTanjim/nui.nvim',
|
||||
},
|
||||
cmd = 'Neotree',
|
||||
keys = {
|
||||
{ '\\', ':Neotree reveal<CR>', { desc = 'NeoTree reveal' } },
|
||||
},
|
||||
opts = {
|
||||
filesystem = {
|
||||
window = {
|
||||
mappings = {
|
||||
['\\'] = 'close_window',
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
159
lua/plex/config/autocmds.lua
Normal file
159
lua/plex/config/autocmds.lua
Normal file
|
@ -0,0 +1,159 @@
|
|||
-- Rafi's Neovim autocmds
|
||||
-- github.com/rafi/vim-config
|
||||
-- ===
|
||||
|
||||
-- This file is automatically loaded by rafi.config.init
|
||||
|
||||
local function augroup(name)
|
||||
return vim.api.nvim_create_augroup('plex_' .. name, {})
|
||||
end
|
||||
|
||||
-- Check if we need to reload the file when it changed
|
||||
vim.api.nvim_create_autocmd({ 'FocusGained', 'TermClose', 'TermLeave' }, {
|
||||
group = augroup('checktime'),
|
||||
command = 'checktime',
|
||||
})
|
||||
|
||||
-- Go to last loc when opening a buffer, see ':h last-position-jump'
|
||||
vim.api.nvim_create_autocmd('BufReadPost', {
|
||||
group = augroup('last_loc'),
|
||||
callback = function()
|
||||
local exclude = { 'gitcommit', 'commit', 'gitrebase' }
|
||||
local buf = vim.api.nvim_get_current_buf()
|
||||
if vim.tbl_contains(exclude, vim.bo[buf].filetype) then
|
||||
return
|
||||
end
|
||||
local mark = vim.api.nvim_buf_get_mark(buf, '"')
|
||||
local lcount = vim.api.nvim_buf_line_count(buf)
|
||||
if mark[1] > 0 and mark[1] <= lcount then
|
||||
pcall(vim.api.nvim_win_set_cursor, 0, mark)
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
-- Show cursor line only in active window
|
||||
vim.api.nvim_create_autocmd({ 'InsertLeave', 'WinEnter' }, {
|
||||
group = augroup('auto_cursorline_show'),
|
||||
callback = function(event)
|
||||
if vim.bo[event.buf].buftype == '' then
|
||||
vim.opt_local.cursorline = true
|
||||
end
|
||||
end,
|
||||
})
|
||||
vim.api.nvim_create_autocmd({ 'InsertEnter', 'WinLeave' }, {
|
||||
group = augroup('auto_cursorline_hide'),
|
||||
callback = function(_)
|
||||
vim.opt_local.cursorline = false
|
||||
end,
|
||||
})
|
||||
|
||||
-- Highlight on yank
|
||||
vim.api.nvim_create_autocmd('TextYankPost', {
|
||||
group = augroup('highlight_yank'),
|
||||
callback = function()
|
||||
vim.highlight.on_yank()
|
||||
end,
|
||||
})
|
||||
|
||||
-- Automatically set read-only for files being edited elsewhere
|
||||
-- vim.api.nvim_create_autocmd('SwapExists', {
|
||||
-- group = augroup('open_swap'),
|
||||
-- nested = true,
|
||||
-- callback = function()
|
||||
-- vim.v.swapchoice = 'o'
|
||||
-- end,
|
||||
-- })
|
||||
|
||||
-- Create directories when needed, when saving a file (except for URIs "://").
|
||||
vim.api.nvim_create_autocmd('BufWritePre', {
|
||||
group = augroup('auto_create_dir'),
|
||||
callback = function(event)
|
||||
if event.match:match('^%w%w+://') then
|
||||
return
|
||||
end
|
||||
local file = vim.loop.fs_realpath(event.match) or event.match
|
||||
vim.fn.mkdir(vim.fn.fnamemodify(file, ':p:h'), 'p')
|
||||
end,
|
||||
})
|
||||
|
||||
-- Disable conceallevel for specific file-types.
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup('fix_conceallevel'),
|
||||
pattern = { 'markdown' },
|
||||
callback = function()
|
||||
vim.opt_local.conceallevel = 0
|
||||
end,
|
||||
})
|
||||
|
||||
-- Resize splits if window got resized
|
||||
vim.api.nvim_create_autocmd('VimResized', {
|
||||
group = augroup('resize_splits'),
|
||||
callback = function()
|
||||
vim.cmd('wincmd =')
|
||||
end,
|
||||
})
|
||||
|
||||
-- Wrap and enable spell-checker in text filetypes
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup('spell_conceal'),
|
||||
pattern = { 'gitcommit', 'markdown', 'tex', 'latex', 'norg' },
|
||||
callback = function()
|
||||
vim.opt_local.spell = true
|
||||
vim.opt_local.conceallevel = 0
|
||||
end,
|
||||
})
|
||||
|
||||
-- Close some filetypes with <q>
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup('close_with_q'),
|
||||
pattern = {
|
||||
'blame',
|
||||
'checkhealth',
|
||||
'fugitive',
|
||||
'fugitiveblame',
|
||||
'help',
|
||||
'httpResult',
|
||||
'lspinfo',
|
||||
'notify',
|
||||
'PlenaryTestPopup',
|
||||
'qf',
|
||||
'spectre_panel',
|
||||
'startuptime',
|
||||
'tsplayground',
|
||||
},
|
||||
callback = function(event)
|
||||
vim.bo[event.buf].buflisted = false
|
||||
-- stylua: ignore
|
||||
vim.keymap.set('n', 'q', '<cmd>close<CR>', { buffer = event.buf, silent = true })
|
||||
end,
|
||||
})
|
||||
|
||||
vim.api.nvim_create_autocmd('BufWritePre', {
|
||||
group = augroup('undo_disable'),
|
||||
pattern = { '/tmp/*', '*.tmp', '*.bak', 'COMMIT_EDITMSG', 'MERGE_MSG' },
|
||||
callback = function(event)
|
||||
vim.opt_local.undofile = false
|
||||
if event.file == 'COMMIT_EDITMSG' or event.file == 'MERGE_MSG' then
|
||||
vim.opt_local.swapfile = false
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
-- Disable swap/undo/backup files in temp directories or shm
|
||||
vim.api.nvim_create_autocmd({ 'BufNewFile', 'BufReadPre' }, {
|
||||
group = augroup('secure'),
|
||||
pattern = {
|
||||
'/tmp/*',
|
||||
'$TMPDIR/*',
|
||||
'$TMP/*',
|
||||
'$TEMP/*',
|
||||
'*/shm/*',
|
||||
'/private/var/*',
|
||||
},
|
||||
callback = function()
|
||||
vim.opt_local.undofile = false
|
||||
vim.opt_local.swapfile = false
|
||||
vim.opt_global.backup = false
|
||||
vim.opt_global.writebackup = false
|
||||
end,
|
||||
})
|
318
lua/plex/config/init.lua
Normal file
318
lua/plex/config/init.lua
Normal file
|
@ -0,0 +1,318 @@
|
|||
-- Rafi's Neovim config loader
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
-- This is part of LazyVim's code, with my modifications.
|
||||
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/init.lua
|
||||
|
||||
---@type plexConfig
|
||||
local M = {}
|
||||
|
||||
M.lazy_version = '>=9.1.0'
|
||||
|
||||
---@class plexConfig
|
||||
local defaults = {
|
||||
-- Load the default settings
|
||||
-- stylua: ignore
|
||||
defaults = {
|
||||
autocmds = true, -- plex.config.autocmds
|
||||
keymaps = true, -- plex.config.keymaps
|
||||
-- plex.config.options can't be configured here since it's loaded
|
||||
-- prematurely. You can disable loading options with the following line at
|
||||
-- the top of your lua/config/setup.lua or init.lua:
|
||||
-- `package.loaded['plex.config.options'] = true`
|
||||
},
|
||||
|
||||
-- String like `habamax` or a function that will load the colorscheme.
|
||||
-- Disabled by default to allow theme-loader.nvim to manage the colorscheme.
|
||||
---@type string|fun()
|
||||
colorscheme = '',
|
||||
|
||||
features = {
|
||||
elite_mode = true,
|
||||
window_q_mapping = true,
|
||||
},
|
||||
|
||||
-- stylua: ignore
|
||||
icons = {
|
||||
git = ' ',
|
||||
diagnostics = {
|
||||
Error = '', -- ✘
|
||||
Warn = '', --
|
||||
Info = '', -- ⁱ
|
||||
Hint = '', --
|
||||
},
|
||||
status = {
|
||||
git = {
|
||||
added = '₊', -- ₊
|
||||
modified = '∗', -- ∗
|
||||
removed = '₋', -- ₋
|
||||
},
|
||||
diagnostics = {
|
||||
error = ' ',
|
||||
warn = ' ',
|
||||
info = ' ',
|
||||
hint = ' ',
|
||||
},
|
||||
filename = {
|
||||
modified = '+',
|
||||
readonly = '🔒',
|
||||
zoomed = '🔎',
|
||||
},
|
||||
},
|
||||
-- Default completion kind symbols.
|
||||
kinds = {
|
||||
Array = ' ', --
|
||||
Boolean = '◩ ', -- ◩
|
||||
Class = ' ', -- 𝓒
|
||||
Color = ' ', --
|
||||
Constant = ' ', --
|
||||
Constructor = ' ', --
|
||||
Copilot = ' ', --
|
||||
Enum = ' ', -- ℰ
|
||||
EnumMember = ' ', --
|
||||
Event = ' ', --
|
||||
Field = ' ', --
|
||||
File = ' ', --
|
||||
Folder = ' ', --
|
||||
Function = ' ', --
|
||||
Interface = ' ', --
|
||||
Key = ' ', --
|
||||
Keyword = ' ', --
|
||||
Method = ' ', -- ƒ
|
||||
Module = ' ', --
|
||||
Namespace = ' ', --
|
||||
Null = ' ', --
|
||||
Number = ' ', --
|
||||
Object = ' ', --
|
||||
Operator = ' ', -- +
|
||||
Package = ' ', --
|
||||
Property = ' ', --
|
||||
Reference = ' ', --
|
||||
Snippet = ' ', -- ⮡
|
||||
String = ' ', --
|
||||
Struct = ' ', -- 𝓢
|
||||
Text = ' ', -- 𝓐
|
||||
TypeParameter = ' ', -- 𝙏
|
||||
Unit = ' ', --
|
||||
Value = ' ', --
|
||||
Variable = ' ', --
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
M.renames = {}
|
||||
|
||||
M.did_init = false
|
||||
function M.init()
|
||||
if not M.did_init then
|
||||
M.did_init = true
|
||||
-- delay notifications till vim.notify was replaced or after 500ms
|
||||
require('plex.config').lazy_notify()
|
||||
|
||||
-- load options here, before lazy init while sourcing plugin modules
|
||||
-- this is needed to make sure options will be correctly applied
|
||||
-- after installing missing plugins
|
||||
require('plex.config').load('options')
|
||||
|
||||
-- carry over plugin options that their name has been changed.
|
||||
local Plugin = require('lazy.core.plugin')
|
||||
local add = Plugin.Spec.add
|
||||
---@diagnostic disable-next-line: duplicate-set-field
|
||||
Plugin.Spec.add = function(self, plugin, ...)
|
||||
if type(plugin) == 'table' and M.renames[plugin[1]] then
|
||||
plugin[1] = M.renames[plugin[1]]
|
||||
end
|
||||
return add(self, plugin, ...)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
---@type plexConfig
|
||||
local options
|
||||
|
||||
-- Load plex and user config files.
|
||||
---@param user_opts table|nil
|
||||
function M.setup(user_opts)
|
||||
if not M.did_init then
|
||||
M.init()
|
||||
end
|
||||
options = vim.tbl_deep_extend('force', defaults, user_opts or {})
|
||||
if not M.has_version() then
|
||||
require('lazy.core.util').error(
|
||||
string.format(
|
||||
'**lazy.nvim** version %s is required.\n Please upgrade **lazy.nvim**',
|
||||
M.lazy_version
|
||||
)
|
||||
)
|
||||
error('Exiting')
|
||||
end
|
||||
|
||||
-- Override config with user config at lua/config/setup.lua
|
||||
local ok, user_setup = pcall(require, 'config.setup')
|
||||
if ok and user_setup.override then
|
||||
options = vim.tbl_deep_extend('force', options, user_setup.override())
|
||||
end
|
||||
for feat_name, feat_val in pairs(options.features) do
|
||||
vim.g['plex_' .. feat_name] = feat_val
|
||||
end
|
||||
|
||||
M.load('autocmds')
|
||||
M.load('keymaps')
|
||||
|
||||
-- Set colorscheme
|
||||
require('lazy.core.util').try(function()
|
||||
if type(M.colorscheme) == 'function' then
|
||||
M.colorscheme()
|
||||
elseif #M.colorscheme > 0 then
|
||||
vim.cmd.colorscheme(M.colorscheme)
|
||||
end
|
||||
end, {
|
||||
msg = 'Could not load your colorscheme',
|
||||
on_error = function(msg)
|
||||
require('lazy.core.util').error(msg)
|
||||
vim.cmd.colorscheme('habamax')
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
---@return table
|
||||
function M.user_lazy_opts()
|
||||
local ok, user_setup = pcall(require, 'config.setup')
|
||||
if ok and user_setup.lazy_opts then
|
||||
return user_setup.lazy_opts()
|
||||
end
|
||||
return {}
|
||||
end
|
||||
|
||||
---@param range? string
|
||||
---@return boolean
|
||||
function M.has_version(range)
|
||||
local Semver = require('lazy.manage.semver')
|
||||
return Semver.range(range or M.lazy_version)
|
||||
:matches(require('lazy.core.config').version or '0.0.0')
|
||||
end
|
||||
|
||||
---@param name "autocmds" | "options" | "keymaps"
|
||||
function M.load(name)
|
||||
local Util = require('lazy.core.util')
|
||||
local function _load(mod)
|
||||
Util.try(function()
|
||||
require(mod)
|
||||
end, {
|
||||
msg = 'Failed loading ' .. mod,
|
||||
on_error = function(msg)
|
||||
local info = require('lazy.core.cache').find(mod)
|
||||
if info == nil or (type(info) == 'table' and #info == 0) then
|
||||
return
|
||||
end
|
||||
Util.error(msg)
|
||||
end,
|
||||
})
|
||||
end
|
||||
-- always load plex's file, then user file
|
||||
if M.defaults[name] or name == 'options' then
|
||||
_load('plex.config.' .. name)
|
||||
end
|
||||
_load('config.' .. name)
|
||||
if vim.bo.filetype == 'lazy' then
|
||||
vim.cmd([[do VimResized]])
|
||||
end
|
||||
end
|
||||
|
||||
-- Ensure package manager (lazy.nvim) exists.
|
||||
function M.ensure_lazy()
|
||||
local lazypath = M.path_join(vim.fn.stdpath('data'), 'lazy', 'lazy.nvim')
|
||||
if not vim.loop.fs_stat(lazypath) then
|
||||
print('Installing lazy.nvim…')
|
||||
vim.fn.system({
|
||||
'git',
|
||||
'clone',
|
||||
'--filter=blob:none',
|
||||
'--branch=stable',
|
||||
'https://github.com/folke/lazy.nvim.git',
|
||||
lazypath,
|
||||
})
|
||||
end
|
||||
vim.opt.rtp:prepend(lazypath)
|
||||
end
|
||||
|
||||
-- Validate if lua/plugins/ or lua/plugins.lua exist.
|
||||
---@return boolean
|
||||
function M.has_user_plugins()
|
||||
local user_path = M.path_join(vim.fn.stdpath('config'), 'lua')
|
||||
return vim.loop.fs_stat(M.path_join(user_path, 'plugins')) ~= nil
|
||||
or vim.loop.fs_stat(M.path_join(user_path, 'plugins.lua')) ~= nil
|
||||
end
|
||||
|
||||
-- Delay notifications till vim.notify was replaced or after 500ms.
|
||||
function M.lazy_notify()
|
||||
local notifs = {}
|
||||
local function temp(...)
|
||||
table.insert(notifs, vim.F.pack_len(...))
|
||||
end
|
||||
|
||||
local orig = vim.notify
|
||||
vim.notify = temp
|
||||
|
||||
local timer = vim.loop.new_timer()
|
||||
local check = vim.loop.new_check()
|
||||
if timer == nil or check == nil then
|
||||
return
|
||||
end
|
||||
|
||||
local replay = function()
|
||||
timer:stop()
|
||||
check:stop()
|
||||
if vim.notify == temp then
|
||||
vim.notify = orig -- put back the original notify if needed
|
||||
end
|
||||
vim.schedule(function()
|
||||
---@diagnostic disable-next-line: no-unknown
|
||||
for _, notif in ipairs(notifs) do
|
||||
vim.notify(vim.F.unpack_len(notif))
|
||||
end
|
||||
end)
|
||||
end
|
||||
|
||||
-- wait till vim.notify has been replaced
|
||||
check:start(function()
|
||||
if vim.notify ~= temp then
|
||||
replay()
|
||||
end
|
||||
end)
|
||||
-- or if it took more than 500ms, then something went wrong
|
||||
timer:start(500, 0, replay)
|
||||
end
|
||||
|
||||
-- Join paths.
|
||||
---@private
|
||||
M.path_join = function(...)
|
||||
return table.concat({ ... }, M.path_sep)
|
||||
end
|
||||
|
||||
-- Variable holds OS directory separator.
|
||||
---@private
|
||||
M.path_sep = (function()
|
||||
if jit then
|
||||
local os = string.lower(jit.os)
|
||||
if os ~= 'windows' then
|
||||
return '/'
|
||||
else
|
||||
return '\\'
|
||||
end
|
||||
else
|
||||
return package.config:sub(1, 1)
|
||||
end
|
||||
end)()
|
||||
|
||||
setmetatable(M, {
|
||||
__index = function(_, key)
|
||||
if options == nil then
|
||||
return vim.deepcopy(defaults)[key]
|
||||
end
|
||||
---@cast options plexConfig
|
||||
return options[key]
|
||||
end,
|
||||
})
|
||||
|
||||
return M
|
360
lua/plex/config/keymaps.lua
Normal file
360
lua/plex/config/keymaps.lua
Normal file
|
@ -0,0 +1,360 @@
|
|||
-- Rafi's Neovim keymaps
|
||||
-- github.com/rafi/vim-config
|
||||
-- ===
|
||||
|
||||
-- This file is automatically loaded by plex.config.init
|
||||
|
||||
local Util = require('plex.lib.utils')
|
||||
local map = vim.keymap.set
|
||||
|
||||
local function augroup(name)
|
||||
return vim.api.nvim_create_augroup('plex_' .. name, {})
|
||||
end
|
||||
|
||||
-- enable elite mode, for people that are more used to vim than non-vim
|
||||
vim.g.plex_elite_mode = true
|
||||
|
||||
-- Elite-mode: ctrl + Arrow-keys resize window
|
||||
if vim.g.plex_elite_mode then
|
||||
map('n', '<C-Up>', '<cmd>resize +1<cr>', { desc = 'Resize Window' })
|
||||
map('n', '<C-Down>', '<cmd>resize -1<cr>', { desc = 'Resize Window' })
|
||||
map('n', '<C-Left>', '<cmd>vertical resize +1<cr>', { desc = 'Resize Window' })
|
||||
map('n', '<C-Right>', '<cmd>vertical resize -1<cr>', { desc = 'Resize Window' })
|
||||
end
|
||||
|
||||
-- Package-manager
|
||||
map('n', '<leader>l', '<cmd>Lazy<cr>', { desc = 'Open Lazy UI' })
|
||||
|
||||
-- stylua: ignore start
|
||||
|
||||
-- Navigation
|
||||
-- ===
|
||||
|
||||
-- Move faster between lines
|
||||
map({ 'n', 'x' }, 'K', "<C-u>")
|
||||
map({ 'n', 'x' }, 'J', "<C-d>")
|
||||
|
||||
-- Easier line-wise movement
|
||||
map({'n', 'v'}, 'H', 'g^')
|
||||
map({'n', 'v'}, 'L', 'g$')
|
||||
|
||||
-- Toggle fold or select option from popup menu
|
||||
---@return string
|
||||
map('n', '<CR>', function()
|
||||
return vim.fn.pumvisible() == 1 and '<CR>' or 'za'
|
||||
end, { expr = true, desc = 'Toggle Fold' })
|
||||
|
||||
-- Focus the current fold by closing all others
|
||||
map('n', '<S-Return>', 'zMzv', { remap = true, desc = 'Focus Fold' })
|
||||
|
||||
-- Location/quickfix list movement
|
||||
if not Util.has('mini.bracketed') and not Util.has('trouble.nvim') then
|
||||
map('n', ']q', '<cmd>cnext<CR>', { desc = 'Next Quickfix Item' })
|
||||
map('n', '[q', '<cmd>cprev<CR>', { desc = 'Previous Quickfix Item' })
|
||||
end
|
||||
map('n', '<A-k>', '<cmd>lnext<CR>', { desc = 'Next Loclist Item' })
|
||||
map('n', '<A-j>', '<cmd>lprev<CR>', { desc = 'Previous Loclist Item' })
|
||||
|
||||
-- go to next diagnostics entry
|
||||
map('n', '<C-j>', function ()
|
||||
vim.diagnostic.goto_next()
|
||||
end, { desc = 'go to next diagnostic'})
|
||||
map('n', '<C-k>', function ()
|
||||
vim.diagnostic.goto_prev()
|
||||
end, { desc = 'go to last diagnostic'})
|
||||
|
||||
-- Whitespace jump (see plugin/whitespace.vim)
|
||||
map('n', ']s', function()
|
||||
require('plex.lib.edit').whitespace_jump(1)
|
||||
end, { desc = 'Next Whitespace' })
|
||||
map('n', '[s', function()
|
||||
require('plex.lib.edit').whitespace_jump(-1)
|
||||
end, { desc = 'Previous Whitespace' })
|
||||
|
||||
-- Navigation in command line
|
||||
map('c', '<C-h>', '<Home>')
|
||||
map('c', '<C-l>', '<End>')
|
||||
|
||||
-- Scroll step sideways
|
||||
map('n', 'zl', 'z4l')
|
||||
map('n', 'zh', 'z4h')
|
||||
|
||||
-- move to spelling mistake
|
||||
map('n', 'zn', ']s')
|
||||
map('n', 'zN', '[s')
|
||||
|
||||
-- Clipboard
|
||||
-- ===
|
||||
|
||||
-- Yank to system clipboard
|
||||
map({'n', 'v', 'x'}, '<leader>y', '"+y"', { desc = "yank to system"})
|
||||
map({'n', 'v', 'x'}, '<leader>yy', '"+yy"', { desc = "yank line to system"})
|
||||
map({'n', 'v', 'x'}, '<leader>Y', '"+Y"', { desc = "yank to system until line end"})
|
||||
|
||||
-- Yank buffer's relative path to clipboard
|
||||
map('n', '<Leader>yp', function()
|
||||
local path = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), ':~:.')
|
||||
vim.fn.setreg('+', path)
|
||||
vim.notify(path, vim.log.levels.INFO, { title = 'Yanked relative path' })
|
||||
end, { silent = true, desc = 'Yank relative path' })
|
||||
|
||||
-- Yank absolute path
|
||||
map('n', '<Leader>Yp', function()
|
||||
local path = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), ':p')
|
||||
vim.fn.setreg('+', path)
|
||||
vim.notify(path, vim.log.levels.INFO, { title = 'Yanked absolute path' })
|
||||
end, { silent = true, desc = 'Yank absolute path' })
|
||||
|
||||
-- Paste in visual-mode without pushing to register
|
||||
map('x', 'p', 'p:let @+=@0<CR>:let @"=@0<CR>', { silent = true, desc = 'Paste' })
|
||||
map('x', 'P', 'P:let @+=@0<CR>:let @"=@0<CR>', { silent = true, desc = 'Paste In-place' })
|
||||
|
||||
-- Edit
|
||||
-- ===
|
||||
|
||||
-- Macros
|
||||
map('n', '<C-q>', 'q', { desc = 'Macro Prefix' })
|
||||
|
||||
-- Insert new lines above and below
|
||||
map('n', 'oo', 'o<ESC>', { desc = 'Insert newline below' })
|
||||
map('n', 'OO', 'O<ESC>', { desc = 'Insert newline below' })
|
||||
|
||||
-- keep regular behavior
|
||||
map('n', 'O', 'O', { desc = 'Insert newline below' })
|
||||
map('n', 'o', 'o', { desc = 'Insert newline below' })
|
||||
|
||||
-- Start new line from any cursor position in insert-mode
|
||||
map('i', '<S-Return>', '<C-o>o', { desc = 'Start Newline' })
|
||||
|
||||
-- Split and join lines
|
||||
map('n', '<leader>jj', ':join<CR>g$', { desc = 'Join lines', silent = true })
|
||||
map('n', '<leader>jJ', 'k:join<CR>j', { desc = 'Join lines', silent = true })
|
||||
map('n', '<leader>ss', 'i<CR><ESC>', { desc = 'Split lines', silent = true })
|
||||
map('n', '<leader>sS', 'i<CR><ESC>kg$', { desc = 'Split lines', silent = true })
|
||||
|
||||
-- Re-select blocks after indenting in visual/select mode
|
||||
map('x', '<', '<gv', { desc = 'Indent Right and Re-select' })
|
||||
map('x', '>', '>gv|', { desc = 'Indent Left and Re-select' })
|
||||
|
||||
-- Arrows to move identation in normal mode
|
||||
map('n', '<LEFT>', '<<', { desc = 'Indent Right and Re-select' })
|
||||
map('n', '<RIGHT>', '>>', { desc = 'Indent Left and Re-select' })
|
||||
map('v', '<LEFT>', '<', { desc = 'Indent Right and Re-select' })
|
||||
map('v', '<RIGHT>', '>', { desc = 'Indent Left and Re-select' })
|
||||
|
||||
-- Use tab for indenting in visual/select mode
|
||||
map('x', '<Tab>', '>gv|', { desc = 'Indent Left' })
|
||||
map('x', '<S-Tab>', '<gv', { desc = 'Indent Right' })
|
||||
|
||||
-- Drag current line/s vertically and auto-indent with Arrow up/down
|
||||
map('n', '<UP>', '<cmd>move-2<CR>==', { desc = 'Move line up' })
|
||||
map('n', '<DOWN>', '<cmd>move+<CR>==', { desc = 'Move line down' })
|
||||
map('x', '<UP>', ":move'<-2<CR>gv=gv", { desc = 'Move selection up' })
|
||||
map('x', '<DOWN>', ":move'>+<CR>gv=gv", { desc = 'Move selection down' })
|
||||
|
||||
-- Remove spaces at the end of lines
|
||||
map('n', '<Leader>fw', '<cmd>lua MiniTrailspace.trim()<CR>', { desc = 'Erase Whitespace' })
|
||||
|
||||
-- Search & Replace
|
||||
-- ===
|
||||
|
||||
-- Make marks with m[some key]
|
||||
-- go to mark with #[some key]
|
||||
map('n', '#', '\'')
|
||||
|
||||
-- Clear search with <Esc>
|
||||
map('n', '<Esc>', '<cmd>noh<CR>', { desc = 'Clear Search Highlight' })
|
||||
|
||||
-- Clear search, diff update and redraw taken from runtime/lua/_editor.lua
|
||||
map(
|
||||
'n',
|
||||
'<leader>ur',
|
||||
'<cmd>nohlsearch<bar>diffupdate<bar>normal! <C-L><CR>',
|
||||
{ desc = 'Redraw / clear hlsearch / diff update' }
|
||||
)
|
||||
|
||||
-- Use backspace key for matching parens
|
||||
map({ 'n', 'x' }, '<BS>', '%', { remap = true, desc = 'Jump to Paren' })
|
||||
|
||||
-- Select last paste
|
||||
map('n', 'gpp', "'`['.strpart(getregtype(), 0, 1).'`]'", { expr = true, desc = 'Select Paste' })
|
||||
|
||||
-- Quick substitute within selected area
|
||||
map('x', '<leader>Sub', ':s//gc<Left><Left><Left>', { desc = 'Substitute Within Selection' })
|
||||
|
||||
-- Command & History
|
||||
-- ===
|
||||
|
||||
-- Start an external command with a single bang
|
||||
map('n', '!', ':!', { desc = 'Execute Shell Command' })
|
||||
|
||||
-- Put vim command output into buffer
|
||||
--map('n', 'g!', ":put=execute('')<Left><Left>", { desc = 'Paste Command' })
|
||||
|
||||
-- Allow misspellings
|
||||
--vim.cmd.cnoreabbrev('qw', 'wq')
|
||||
--vim.cmd.cnoreabbrev('Wq', 'wq')
|
||||
--vim.cmd.cnoreabbrev('WQ', 'wq')
|
||||
--vim.cmd.cnoreabbrev('Qa', 'qa')
|
||||
--vim.cmd.cnoreabbrev('Bd', 'bd')
|
||||
--vim.cmd.cnoreabbrev('bD', 'bd')
|
||||
|
||||
-- File operations
|
||||
-- ===
|
||||
|
||||
-- Switch (window) to the directory of the current opened buffer
|
||||
map('n', '<Leader>cd', function()
|
||||
local bufdir = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), ':p:h')
|
||||
if bufdir ~= nil and vim.loop.fs_stat(bufdir) then
|
||||
vim.cmd.tcd(bufdir)
|
||||
vim.notify(bufdir)
|
||||
end
|
||||
end, { desc = 'Change Local Directory' })
|
||||
|
||||
-- Fast saving from all modes
|
||||
--map('n', '<Leader>w', '<cmd>write<CR>', { desc = 'Save' })
|
||||
--map({ 'n', 'i', 'v' }, '<C-s>', '<cmd>write<CR>', { desc = 'Save' })
|
||||
|
||||
-- Editor UI
|
||||
-- ===
|
||||
|
||||
-- Toggle editor's visual effects
|
||||
map('n', '<Leader>us', '<cmd>setlocal spell!<CR>', { desc = 'Toggle Spellcheck' })
|
||||
map('n', '<Leader>ul', '<cmd>setlocal nonumber!<CR>', { desc = 'Toggle Line Numbers' })
|
||||
map('n', '<Leader>ulr', '<cmd>setlocal nornu!<CR>', { desc = 'Toggle Relative Line Numbers' })
|
||||
map('n', '<Leader>uo', '<cmd>setlocal nolist!<CR>', { desc = 'Toggle Whitespace Symbols' })
|
||||
|
||||
if vim.lsp.inlay_hint then
|
||||
map('n', '<leader>uh', function() vim.lsp.inlay_hint(0, nil) end, { desc = 'Toggle Inlay Hints' })
|
||||
end
|
||||
|
||||
-- Smart wrap toggle (breakindent and colorcolumn toggle as-well)
|
||||
map('n', '<Leader>uw', function()
|
||||
vim.opt_local.wrap = not vim.wo.wrap
|
||||
vim.opt_local.breakindent = not vim.wo.breakindent
|
||||
|
||||
if vim.wo.colorcolumn == '' then
|
||||
vim.opt_local.colorcolumn = tostring(vim.bo.textwidth)
|
||||
else
|
||||
vim.opt_local.colorcolumn = ''
|
||||
end
|
||||
end, { desc = 'Toggle Wrap' })
|
||||
|
||||
-- Tabs: Many ways to navigate them
|
||||
map('n', '<A-j>', '<cmd>tabprevious<CR>', { desc = 'Previous Tab' })
|
||||
map('n', '<A-k>', '<cmd>tabnext<CR>', { desc = 'Next Tab' })
|
||||
|
||||
-- New and Close
|
||||
map('n', '<A-t>', '<cmd>tabnew<CR>', { desc = 'New Tab' })
|
||||
map('n', '<A-c>', '<cmd>tabclose<CR>', { desc = 'Close Tab' })
|
||||
|
||||
-- Moving tabs
|
||||
map('n', '<A-S-j>', '<cmd>-tabmove<CR>', { desc = 'Tab Move Backwards' })
|
||||
map('n', '<A-S-k>', '<cmd>+tabmove<CR>', { desc = 'Tab Move Forwards' })
|
||||
|
||||
-- Custom Tools
|
||||
-- ===
|
||||
|
||||
-- Append mode-line to current buffer
|
||||
map('n', '<Leader>ml', function()
|
||||
require('plex.lib.edit').append_modeline()
|
||||
end, { desc = 'Append Modeline' })
|
||||
|
||||
-- Jump entire buffers throughout jumplist
|
||||
--map('n', 'g<C-i>', function()
|
||||
-- require('plex.lib.edit').jump_buffer(1)
|
||||
--end, { desc = 'Jump to newer buffer' })
|
||||
--map('n', 'g<C-o>', function()
|
||||
-- require('plex.lib.edit').jump_buffer(-1)
|
||||
--end, { desc = 'Jump to older buffer' })
|
||||
|
||||
-- Context aware menu. See lua/lib/contextmenu.lua
|
||||
map('n', '<LocalLeader>c', function()
|
||||
require('plex.lib.contextmenu').show()
|
||||
end, { desc = 'Content-aware menu' })
|
||||
|
||||
-- Lazygit
|
||||
map('n', '<leader>tg', function() Util.float_term({ 'lazygit' }, { cwd = Util.get_root(), esc_esc = false }) end, { desc = 'Lazygit (root dir)' })
|
||||
|
||||
-- Floating terminal
|
||||
map('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Enter Normal Mode' })
|
||||
map('t', '<C-w>', '<C-\\><C-n>', { desc = 'Enter Normal Mode' })
|
||||
map('n', '<F12>', function() Util.float_term(nil, { cwd = Util.get_root() }) end, { desc = 'Terminal (root dir)' })
|
||||
map('t', '<F12>', function() Util.float_term(nil, { cwd = Util.get_root() }) end, { desc = 'Terminal (root dir)' })
|
||||
|
||||
if vim.fn.has('mac') then
|
||||
-- Open the macOS dictionary on current word
|
||||
map('n', '<Leader>?', '<cmd>silent !open dict://<cword><CR>', { desc = 'Dictionary' })
|
||||
|
||||
-- Use Marked for real-time Markdown preview
|
||||
-- See: https://marked2app.com/
|
||||
if vim.fn.executable('/Applications/Marked 2.app') then
|
||||
vim.api.nvim_create_autocmd('FileType', {
|
||||
group = augroup('marked_preview'),
|
||||
pattern = 'markdown',
|
||||
callback = function()
|
||||
local cmd = "<cmd>silent !open -a Marked\\ 2.app '%:p'<CR>"
|
||||
map('n', '<Leader>P', cmd, { desc = 'Markdown Preview' })
|
||||
end,
|
||||
})
|
||||
end
|
||||
end
|
||||
|
||||
-- Windows, buffers and tabs
|
||||
-- ===
|
||||
|
||||
-- Ultimatus Quitos
|
||||
-- Use Q to quit whatever
|
||||
if vim.F.if_nil(vim.g.plex_window_q_mapping, true) then
|
||||
vim.api.nvim_create_autocmd({ 'BufWinEnter', 'VimEnter' }, {
|
||||
group = augroup('quit_mapping'),
|
||||
callback = function(event)
|
||||
if vim.bo.buftype == '' and vim.fn.maparg('Q', 'n') == '' then
|
||||
local args = { buffer = event.buf, desc = 'Quit' }
|
||||
map('n', 'Q', '<cmd>quit<CR>', args)
|
||||
end
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
-- Toggle quickfix window
|
||||
map('n', '<Leader>q', function()
|
||||
require('plex.lib.edit').toggle_list('quickfix')
|
||||
end, { desc = 'Open Quickfix' })
|
||||
|
||||
-- Set locations with diagnostics and open the list.
|
||||
map('n', '<Leader>a', function()
|
||||
if vim.bo.filetype ~= 'qf' then
|
||||
vim.diagnostic.setloclist({ open = false })
|
||||
end
|
||||
require('plex.lib.edit').toggle_list('loclist')
|
||||
end, { desc = 'Open Location List' })
|
||||
|
||||
map('n', '<leader>%', '<cmd>split<CR>', { desc = 'Split window horizontally' })
|
||||
map('n', '<leader>"', '<cmd>vsplit<CR>', { desc = 'Split window vertically' })
|
||||
|
||||
map('n', '<leader>wb', '<cmd>buffer#<CR>', { desc = 'Alternate buffer' })
|
||||
map('n', '<leader>wc', '<cmd>close<CR>', { desc = 'Close window' })
|
||||
map('n', '<leader>wd', '<cmd>bdelete<CR>', { desc = 'Buffer delete' })
|
||||
map('n', '<leader>wv', '<cmd>split<CR>', { desc = 'Split window horizontally' })
|
||||
map('n', '<leader>wg', '<cmd>vsplit<CR>', { desc = 'Split window vertically' })
|
||||
map('n', '<leader>wt', '<cmd>tabnew<CR>', { desc = 'New tab' })
|
||||
map('n', '<leader>wtp', '<cmd>tabprevious<CR>', { desc = 'Previous tab' })
|
||||
map('n', '<leader>wtn', '<cmd>tabnext<CR>', { desc = 'Next tab' })
|
||||
map('n', '<leader>wtc', '<cmd>tabclose<CR>', { desc = 'Close tab' })
|
||||
map('n', '<leader>wo', '<cmd>only<CR>', { desc = 'Close other windows' })
|
||||
map('n', '<leader>wq', '<cmd>quit<CR>', { desc = 'Quit' })
|
||||
map('n', '<leader>wz', '<cmd>vertical resize | resize | normal! ze<CR>', { desc = 'Maximize' })
|
||||
map('n', '<leader>wx', function()
|
||||
require('mini.bufremove').delete(0, false)
|
||||
vim.cmd.enew()
|
||||
end, { desc = 'Delete buffer and open new' })
|
||||
|
||||
-- Background dark/light toggle
|
||||
map('n', '<leader>uh', function()
|
||||
if vim.o.background == 'dark' then
|
||||
vim.o.background = 'light'
|
||||
else
|
||||
vim.o.background = 'dark'
|
||||
end
|
||||
end, { desc = 'Toggle background dark/light' })
|
256
lua/plex/config/options.lua
Normal file
256
lua/plex/config/options.lua
Normal file
|
@ -0,0 +1,256 @@
|
|||
-- Rafi's Neovim options
|
||||
-- github.com/rafi/vim-config
|
||||
-- ===
|
||||
|
||||
-- This file is automatically loaded by config.init or plugins.core
|
||||
-- stylua: ignore start
|
||||
|
||||
-- Keyboard leaders
|
||||
vim.g.mapleader = ' '
|
||||
vim.g.maplocalleader = ';'
|
||||
|
||||
-- General
|
||||
-- ===
|
||||
|
||||
local opt = vim.opt
|
||||
|
||||
opt.mouse = 'nv' -- Disable mouse in command-line mode
|
||||
opt.errorbells = true -- Trigger bell on error
|
||||
opt.virtualedit = 'block' -- Position cursor anywhere in visual blockd
|
||||
opt.confirm = true -- Confirm to save changes before exiting modified bufferd
|
||||
|
||||
-- History and persistence
|
||||
opt.history = 5000
|
||||
opt.shada = { "'1000", "<50", "s10", "h" }
|
||||
|
||||
opt.conceallevel = 0
|
||||
opt.signcolumn = 'yes'
|
||||
opt.spelloptions:append('camel')
|
||||
opt.spelllang = 'en,de'
|
||||
|
||||
-- What to save for views and sessions
|
||||
opt.viewoptions:remove('folds')
|
||||
opt.sessionoptions:remove({ 'buffers', 'folds' })
|
||||
|
||||
-- Sync with system clipboard
|
||||
--opt.clipboard = 'unnamedplus'
|
||||
|
||||
-- Undo
|
||||
opt.undofile = true
|
||||
opt.undolevels = 10000
|
||||
opt.writebackup = false
|
||||
|
||||
-- If sudo, disable vim swap/backup/undo/shada writing
|
||||
local USER = vim.env.USER or ''
|
||||
local SUDO_USER = vim.env.SUDO_USER or ''
|
||||
if
|
||||
SUDO_USER ~= '' and USER ~= SUDO_USER
|
||||
and vim.env.HOME ~= vim.fn.expand('~' .. USER, true)
|
||||
and vim.env.HOME == vim.fn.expand('~' .. SUDO_USER, true)
|
||||
then
|
||||
vim.opt_global.modeline = false
|
||||
vim.opt_global.undofile = false
|
||||
vim.opt_global.swapfile = false
|
||||
vim.opt_global.backup = false
|
||||
vim.opt_global.writebackup = false
|
||||
vim.opt_global.shadafile = 'NONE'
|
||||
end
|
||||
|
||||
-- Tabs and Indents
|
||||
-- ===
|
||||
|
||||
opt.textwidth = 80 -- Text width maximum chars before wrapping
|
||||
opt.tabstop = 2 -- The number of spaces a tab is
|
||||
opt.shiftwidth = 2 -- Number of spaces to use in auto(indent)
|
||||
opt.smarttab = true -- Tab insert blanks according to 'shiftwidth'
|
||||
opt.autoindent = true -- Use same indenting on new lines
|
||||
opt.smartindent = true -- Smart autoindenting on new lines
|
||||
opt.shiftround = true -- Round indent to multiple of 'shiftwidth'
|
||||
|
||||
-- Timing
|
||||
-- ===
|
||||
opt.ttimeout = true
|
||||
opt.timeoutlen = 500 -- Time out on mappings
|
||||
opt.ttimeoutlen = 10 -- Time out on key codes
|
||||
opt.updatetime = 500 -- Idle time to write swap and trigger CursorHold
|
||||
|
||||
-- Searching
|
||||
-- ===
|
||||
opt.ignorecase = true -- Search ignoring case
|
||||
opt.smartcase = true -- Keep case when searching with *
|
||||
opt.infercase = true -- Adjust case in insert completion mode
|
||||
opt.incsearch = true -- Incremental search
|
||||
opt.inccommand = 'nosplit'
|
||||
opt.grepformat = '%f:%l:%c:%m'
|
||||
opt.path:append('**') -- Find recursively
|
||||
|
||||
if vim.fn.executable('rg') then
|
||||
opt.grepprg = 'rg --vimgrep --no-heading'
|
||||
.. (opt.smartcase and ' --smart-case' or '') .. ' --'
|
||||
elseif vim.fn.executable('ag') then
|
||||
opt.grepprg = 'ag --vimgrep'
|
||||
.. (opt.smartcase and ' --smart-case' or '') .. ' --'
|
||||
end
|
||||
|
||||
-- Formatting
|
||||
-- ===
|
||||
|
||||
opt.wrap = false -- No wrap by default
|
||||
opt.linebreak = true -- Break long lines at 'breakat'
|
||||
opt.breakat = '\\ \\ ;:,!?' -- Long lines break chars
|
||||
opt.startofline = false -- Cursor in same column for few commands
|
||||
opt.splitbelow = true -- Splits open bottom right
|
||||
opt.splitright = true
|
||||
opt.breakindentopt = { shift = 2, min = 20 }
|
||||
opt.formatoptions = opt.formatoptions
|
||||
- 'a' -- Auto formatting is BAD.
|
||||
- 't' -- Don't auto format my code. I got linters for that.
|
||||
+ 'c' -- In general, I like it when comments respect textwidth
|
||||
+ 'q' -- Allow formatting comments w/ gq
|
||||
- 'o' -- O and o, don't continue comments
|
||||
+ 'r' -- But do continue when pressing enter.
|
||||
+ 'n' -- Indent past the formatlistpat, not underneath it.
|
||||
+ 'j' -- Auto-remove comments if possible.
|
||||
- '2' -- I'm not in gradeschool anymore
|
||||
|
||||
-- Completion and Diff
|
||||
-- ===
|
||||
|
||||
-- C-n completion
|
||||
opt.complete:append('k')
|
||||
opt.complete:remove('u')
|
||||
opt.complete:remove('t')
|
||||
|
||||
opt.completeopt = 'menu,menuone,noselect'
|
||||
|
||||
opt.diffopt:append({ 'iwhite', 'indent-heuristic', 'algorithm:patience' })
|
||||
|
||||
opt.wildmode = 'longest:full,full' -- Command-line completion mode
|
||||
|
||||
-- Editor UI
|
||||
-- ===
|
||||
|
||||
opt.termguicolors = true
|
||||
opt.shortmess:append({ W = true, I = true, c = true })
|
||||
opt.showmode = true -- Show mode in cmd window
|
||||
opt.scrolloff = 2 -- Keep at least 2 lines above/below
|
||||
opt.sidescrolloff = 5 -- Keep at least 5 lines left/right
|
||||
opt.numberwidth = 2 -- Minimum number of columns to use for the line number
|
||||
opt.number = true -- Show line numbers
|
||||
opt.ruler = true -- Default status ruler
|
||||
opt.list = true -- Show hidden characters
|
||||
|
||||
opt.showtabline = 2 -- Always show the tabs line
|
||||
opt.helpheight = 0 -- Disable help window resizing
|
||||
opt.winwidth = 30 -- Minimum width for active window
|
||||
opt.winminwidth = 1 -- Minimum width for inactive windows
|
||||
opt.winheight = 1 -- Minimum height for active window
|
||||
opt.winminheight = 1 -- Minimum height for inactive window
|
||||
|
||||
opt.showcmd = false -- Don't show command in status line
|
||||
opt.cmdheight = 0
|
||||
opt.cmdwinheight = 5 -- Command-line lines
|
||||
opt.equalalways = true -- Resize windows on split or close
|
||||
opt.colorcolumn = '+0' -- Column highlight at textwidth's max character-limit
|
||||
|
||||
opt.cursorline = true
|
||||
opt.cursorlineopt = { 'number', 'screenline' }
|
||||
|
||||
opt.pumheight = 10 -- Maximum number of items to show in the popup menu
|
||||
opt.pumwidth = 10 -- Minimum width for the popup menu
|
||||
opt.pumblend = 10 -- Popup blend
|
||||
|
||||
if vim.fn.has('nvim-0.9') == 1 then
|
||||
opt.splitkeep = 'screen'
|
||||
opt.shortmess:append({ C = true })
|
||||
end
|
||||
|
||||
-- UI Symbols
|
||||
-- ===
|
||||
-- icons: ▏│ ¦ ╎ ┆ ⋮ ⦙ ┊
|
||||
|
||||
opt.showbreak = '↳ '
|
||||
opt.listchars = {
|
||||
tab = ' ',
|
||||
extends = '⟫',
|
||||
precedes = '⟪',
|
||||
nbsp = '␣',
|
||||
trail = '·'
|
||||
}
|
||||
opt.fillchars = {
|
||||
foldopen = '', --
|
||||
foldclose = '', --
|
||||
fold = ' ',
|
||||
foldsep = ' ',
|
||||
diff = '╱',
|
||||
eob = ' ',
|
||||
horiz = '━',
|
||||
horizup = '┻',
|
||||
horizdown = '┳',
|
||||
vert = '┃',
|
||||
vertleft = '┫',
|
||||
vertright = '┣',
|
||||
verthoriz = '╋',
|
||||
}
|
||||
|
||||
-- Folds
|
||||
-- ===
|
||||
|
||||
opt.foldlevel = 99
|
||||
opt.foldlevelstart = 99
|
||||
opt.foldcolumn = '0'
|
||||
opt.foldenable = true
|
||||
|
||||
-- Misc
|
||||
-- ===
|
||||
|
||||
-- Disable python/perl/ruby/node providers
|
||||
vim.g.loaded_python3_provider = 0
|
||||
vim.g.loaded_perl_provider = 0
|
||||
vim.g.loaded_ruby_provider = 0
|
||||
vim.g.loaded_node_provider = 0
|
||||
|
||||
vim.g.no_gitrebase_maps = 1 -- See share/nvim/runtime/ftplugin/gitrebase.vim
|
||||
vim.g.no_man_maps = 1 -- See share/nvim/runtime/ftplugin/man.vim
|
||||
|
||||
vim.g.suda_smart_edit = 1 -- smart suda open and write
|
||||
|
||||
-- Filetype detection
|
||||
-- ===
|
||||
|
||||
---@diagnostic disable-next-line: missing-fields
|
||||
vim.filetype.add({
|
||||
filename = {
|
||||
Brewfile = 'ruby',
|
||||
justfile = 'just',
|
||||
Justfile = 'just',
|
||||
Tmuxfile = 'tmux',
|
||||
['yarn.lock'] = 'yaml',
|
||||
['.buckconfig'] = 'toml',
|
||||
['.flowconfig'] = 'ini',
|
||||
['.jsbeautifyrc'] = 'json',
|
||||
['.jscsrc'] = 'json',
|
||||
['.watchmanconfig'] = 'json',
|
||||
['dev-requirements.txt'] = 'requirements',
|
||||
},
|
||||
pattern = {
|
||||
['.*%.js%.map'] = 'json',
|
||||
['.*%.postman_collection'] = 'json',
|
||||
['Jenkinsfile.*'] = 'groovy',
|
||||
['%.kube/config'] = 'yaml',
|
||||
['%.config/git/users/.*'] = 'gitconfig',
|
||||
['requirements-.*%.txt'] = 'requirements',
|
||||
['.*/templates/.*%.ya?ml'] = 'helm',
|
||||
['.*/templates/.*%.tpl'] = 'helm',
|
||||
['.*/playbooks/.*%.ya?ml'] = 'yaml.ansible',
|
||||
['.*/roles/.*/tasks/.*%.ya?ml'] = 'yaml.ansible',
|
||||
['.*/roles/.*/handlers/.*%.ya?ml'] = 'yaml.ansible',
|
||||
['.*/inventory/.*%.ini'] = 'ansible_hosts',
|
||||
},
|
||||
})
|
||||
|
||||
-- vim: set ts=2 sw=0 tw=80 noet :
|
||||
|
||||
-- Neorg extra stuff because fonts suck
|
||||
opt.conceallevel = 2 -- btw 0-3
|
||||
opt.concealcursor = "nc"
|
8
lua/plex/init.lua
Normal file
8
lua/plex/init.lua
Normal file
|
@ -0,0 +1,8 @@
|
|||
local M = {}
|
||||
|
||||
---@param opts? RafiConfig
|
||||
function M.setup(opts)
|
||||
require('plex.config').setup(opts)
|
||||
end
|
||||
|
||||
return M
|
210
lua/plex/lib/badge.lua
Normal file
210
lua/plex/lib/badge.lua
Normal file
|
@ -0,0 +1,210 @@
|
|||
-- Badge utilities
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
local plugin_icons = {
|
||||
DiffviewFiles = { '' },
|
||||
fugitive = { ' ' },
|
||||
fugitiveblame = { '', 'Blame' },
|
||||
lazy = { ' ', 'Lazy.nvim' },
|
||||
loclist = { '', 'Location List' },
|
||||
mason = { ' ', 'Mason' },
|
||||
NeogitStatus = { '' },
|
||||
['neo-tree'] = { ' ', 'Neo-tree' },
|
||||
['neo-tree-popup'] = { '', 'Neo-tree' },
|
||||
Outline = { ' ' },
|
||||
quickfix = { ' ', 'Quickfix List' }, --
|
||||
spectre_panel = { ' ', 'Spectre' },
|
||||
TelescopePrompt = { '', 'Telescope' },
|
||||
terminal = { ' ' },
|
||||
toggleterm = { ' ', 'Terminal' },
|
||||
Trouble = { '' }, --
|
||||
undotree = { '' },
|
||||
}
|
||||
|
||||
local cache_keys = {
|
||||
'badge_cache_filepath',
|
||||
'badge_cache_filepath_tab',
|
||||
'badge_cache_icon',
|
||||
}
|
||||
|
||||
local augroup = vim.api.nvim_create_augroup('plex_badge', {})
|
||||
|
||||
-- Clear cached values that relate to buffer filename.
|
||||
vim.api.nvim_create_autocmd(
|
||||
{ 'BufReadPost', 'BufFilePost', 'BufNewFile', 'BufWritePost' },
|
||||
{
|
||||
group = augroup,
|
||||
callback = function()
|
||||
if vim.bo.buftype ~= '' then
|
||||
return
|
||||
end
|
||||
for _, cache_key in ipairs(cache_keys) do
|
||||
pcall(vim.api.nvim_buf_del_var, 0, cache_key)
|
||||
end
|
||||
end,
|
||||
}
|
||||
)
|
||||
-- Clear cached values that relate to buffer content.
|
||||
vim.api.nvim_create_autocmd(
|
||||
{ 'BufWritePre', 'FileChangedShellPost', 'TextChanged', 'InsertLeave' },
|
||||
{
|
||||
group = augroup,
|
||||
callback = function()
|
||||
pcall(vim.api.nvim_buf_del_var, 0, 'badge_cache_trails')
|
||||
end,
|
||||
}
|
||||
)
|
||||
|
||||
local M = {}
|
||||
|
||||
-- Try to guess the project's name
|
||||
---@return string
|
||||
function M.project()
|
||||
return vim.fn.fnamemodify(require('plex.lib.utils').get_root(), ':t') or ''
|
||||
end
|
||||
|
||||
-- Provides relative path with limited characters in each directory name, and
|
||||
-- limits number of total directories. Caches the result for current buffer.
|
||||
---@param bufnr integer buffer number
|
||||
---@param max_dirs integer max dirs to show
|
||||
---@param dir_max_chars integer max chars in dir
|
||||
---@param cache_suffix string? cache suffix
|
||||
---@return string
|
||||
function M.filepath(bufnr, max_dirs, dir_max_chars, cache_suffix)
|
||||
local msg = ''
|
||||
local cache_key = 'badge_cache_filepath' -- _'..ft
|
||||
if cache_suffix then
|
||||
cache_key = cache_key .. cache_suffix
|
||||
end
|
||||
local cache_ok, cache = pcall(vim.api.nvim_buf_get_var, bufnr, cache_key)
|
||||
if cache_ok then
|
||||
return cache
|
||||
end
|
||||
|
||||
local bufname = vim.api.nvim_buf_get_name(bufnr)
|
||||
local buftype = vim.bo[bufnr].buftype
|
||||
local filetype = vim.bo[bufnr].filetype
|
||||
|
||||
-- Normalize bufname
|
||||
if bufname:len() < 1 and buftype:len() < 1 then
|
||||
return 'N/A'
|
||||
end
|
||||
bufname = vim.fn.fnamemodify(bufname, ':~:.') or ''
|
||||
|
||||
-- Reduce directory count according to 'max_dirs' setting.
|
||||
local formatter = string.format('([^%s]+)', M.path_sep)
|
||||
local parts = {}
|
||||
for str in string.gmatch(bufname, formatter) do
|
||||
table.insert(parts, str)
|
||||
end
|
||||
|
||||
local short_parts = {}
|
||||
for i = #parts, 1, -1 do
|
||||
if #short_parts <= max_dirs then
|
||||
table.insert(short_parts, 1, parts[i])
|
||||
end
|
||||
end
|
||||
bufname = table.concat(short_parts, M.path_sep)
|
||||
|
||||
-- Reduce each directory character count according to setting.
|
||||
bufname = vim.fn.pathshorten(bufname, dir_max_chars + 1)
|
||||
|
||||
-- Override with plugin names.
|
||||
local plugin_type = filetype == 'qf' and vim.fn.win_gettype() or filetype
|
||||
if plugin_icons[plugin_type] ~= nil and #plugin_icons[plugin_type] > 1 then
|
||||
msg = msg .. plugin_icons[plugin_type][2]
|
||||
else
|
||||
msg = msg .. bufname
|
||||
end
|
||||
|
||||
vim.api.nvim_buf_set_var(bufnr, cache_key, msg)
|
||||
return msg
|
||||
end
|
||||
|
||||
function M.filemedia(separator)
|
||||
local parts = {}
|
||||
if vim.bo.fileformat ~= '' and vim.bo.fileformat ~= 'unix' then
|
||||
table.insert(parts, vim.bo.fileformat)
|
||||
end
|
||||
if vim.bo.fileencoding ~= '' and vim.bo.fileencoding ~= 'utf-8' then
|
||||
table.insert(parts, vim.bo.fileencoding)
|
||||
end
|
||||
if vim.bo.filetype ~= '' then
|
||||
table.insert(parts, vim.bo.filetype)
|
||||
end
|
||||
return table.concat(parts, separator)
|
||||
end
|
||||
|
||||
function M.icon(bufnr)
|
||||
bufnr = bufnr or 0
|
||||
local cache_key = 'badge_cache_icon'
|
||||
local cache_ok, cache = pcall(vim.api.nvim_buf_get_var, bufnr, cache_key)
|
||||
if cache_ok then
|
||||
return cache
|
||||
end
|
||||
|
||||
local icon = ''
|
||||
local ft = vim.bo[bufnr].filetype
|
||||
local buftype = vim.bo[bufnr].buftype
|
||||
local bufname = vim.api.nvim_buf_get_name(bufnr)
|
||||
|
||||
local plugin_type = ft == 'qf' and vim.fn.win_gettype() or ft
|
||||
if buftype ~= '' and plugin_icons[plugin_type] ~= nil then
|
||||
icon = plugin_icons[plugin_type][1]
|
||||
else
|
||||
-- Try nvim-tree/nvim-web-devicons
|
||||
local ok, devicons = pcall(require, 'nvim-web-devicons')
|
||||
if ok then
|
||||
if buftype == '' and bufname == '' then
|
||||
return devicons.get_default_icon().icon
|
||||
end
|
||||
local f_name = vim.fn.fnamemodify(bufname, ':t')
|
||||
local f_extension = vim.fn.fnamemodify(bufname, ':e')
|
||||
icon, _ = devicons.get_icon(f_name, f_extension)
|
||||
if icon == '' or icon == nil then
|
||||
icon = devicons.get_default_icon().icon
|
||||
end
|
||||
end
|
||||
end
|
||||
vim.api.nvim_buf_set_var(bufnr, cache_key, icon)
|
||||
return icon
|
||||
end
|
||||
|
||||
-- Detect trailing whitespace and cache result per buffer
|
||||
---@param symbol string
|
||||
---@return string
|
||||
function M.trails(symbol)
|
||||
local cache_key = 'badge_cache_trails'
|
||||
local cache_ok, cache = pcall(vim.api.nvim_buf_get_var, 0, cache_key)
|
||||
if cache_ok then
|
||||
return cache
|
||||
end
|
||||
|
||||
local msg = ''
|
||||
if not vim.bo.readonly and vim.bo.modifiable and vim.fn.line('$') < 9000 then
|
||||
local trailing = vim.fn.search('\\s$', 'nw')
|
||||
if trailing > 0 then
|
||||
local label = symbol or 'WS:'
|
||||
msg = msg .. label .. trailing
|
||||
end
|
||||
end
|
||||
vim.api.nvim_buf_set_var(0, cache_key, msg)
|
||||
|
||||
return msg
|
||||
end
|
||||
|
||||
-- Variable holds OS directory separator.
|
||||
M.path_sep = (function()
|
||||
if jit then
|
||||
local os = string.lower(jit.os)
|
||||
if os ~= 'windows' then
|
||||
return '/'
|
||||
else
|
||||
return '\\'
|
||||
end
|
||||
else
|
||||
return package.config:sub(1, 1)
|
||||
end
|
||||
end)()
|
||||
|
||||
return M
|
140
lua/plex/lib/color.lua
Normal file
140
lua/plex/lib/color.lua
Normal file
|
@ -0,0 +1,140 @@
|
|||
-- Source: https://github.com/nvim-lualine/lualine.nvim/blob/master/lua/lualine/themes/auto.lua
|
||||
-- Copyright (c) 2020-2021 shadmansaleh
|
||||
-- MIT license, see LICENSE for more details.
|
||||
local M = {}
|
||||
|
||||
-- Turns #rrggbb -> { red, green, blue }
|
||||
function M.rgb_str2num(rgb_color_str)
|
||||
if rgb_color_str:find('#') == 1 then
|
||||
rgb_color_str = rgb_color_str:sub(2, #rgb_color_str)
|
||||
end
|
||||
local red = tonumber(rgb_color_str:sub(1, 2), 16)
|
||||
local green = tonumber(rgb_color_str:sub(3, 4), 16)
|
||||
local blue = tonumber(rgb_color_str:sub(5, 6), 16)
|
||||
return { red = red, green = green, blue = blue }
|
||||
end
|
||||
|
||||
-- Turns { red, green, blue } -> #rrggbb
|
||||
function M.rgb_num2str(rgb_color_num)
|
||||
local rgb_color_str = string.format(
|
||||
'#%02x%02x%02x',
|
||||
rgb_color_num.red,
|
||||
rgb_color_num.green,
|
||||
rgb_color_num.blue
|
||||
)
|
||||
return rgb_color_str
|
||||
end
|
||||
|
||||
-- Returns brightness level of color in range 0 to 1
|
||||
-- arbitrary value it's basically an weighted average
|
||||
function M.get_color_brightness(rgb_color)
|
||||
local color = M.rgb_str2num(rgb_color)
|
||||
local brightness = (color.red * 2 + color.green * 3 + color.blue) / 6
|
||||
return brightness / 256
|
||||
end
|
||||
|
||||
-- returns average of colors in range 0 to 1
|
||||
-- used to determine contrast level
|
||||
function M.get_color_avg(rgb_color)
|
||||
local color = M.rgb_str2num(rgb_color)
|
||||
return (color.red + color.green + color.blue) / 3 / 256
|
||||
end
|
||||
|
||||
-- Clamps the val between left and right
|
||||
function M.clamp(val, left, right)
|
||||
if val > right then
|
||||
return right
|
||||
end
|
||||
if val < left then
|
||||
return left
|
||||
end
|
||||
return val
|
||||
end
|
||||
|
||||
-- Changes brightness of rgb_color by percentage
|
||||
function M.brightness_modifier(rgb_color, parcentage)
|
||||
local color = M.rgb_str2num(rgb_color)
|
||||
color.red = M.clamp(color.red + (color.red * parcentage / 100), 0, 255)
|
||||
color.green = M.clamp(color.green + (color.green * parcentage / 100), 0, 255)
|
||||
color.blue = M.clamp(color.blue + (color.blue * parcentage / 100), 0, 255)
|
||||
return M.rgb_num2str(color)
|
||||
end
|
||||
|
||||
-- Changes contrast of rgb_color by amount
|
||||
function M.contrast_modifier(rgb_color, amount)
|
||||
local color = M.rgb_str2num(rgb_color)
|
||||
color.red = M.clamp(color.red + amount, 0, 255)
|
||||
color.green = M.clamp(color.green + amount, 0, 255)
|
||||
color.blue = M.clamp(color.blue + amount, 0, 255)
|
||||
return M.rgb_num2str(color)
|
||||
end
|
||||
|
||||
-- Changes brightness of foreground color to achieve contrast
|
||||
-- without changing the color
|
||||
function M.apply_contrast(highlight, threshold)
|
||||
local hightlight_bg_avg = M.get_color_avg(highlight.bg)
|
||||
local contrast_threshold_config = M.clamp(threshold, 0, 0.5)
|
||||
local contranst_change_step = 5
|
||||
if hightlight_bg_avg > 0.5 then
|
||||
contranst_change_step = -contranst_change_step
|
||||
end
|
||||
|
||||
-- Don't waste too much time here max 25 iteration should be more than enough
|
||||
local iteration_count = 1
|
||||
while
|
||||
math.abs(M.get_color_avg(highlight.fg) - hightlight_bg_avg)
|
||||
< contrast_threshold_config
|
||||
and iteration_count < 25
|
||||
do
|
||||
highlight.fg = M.contrast_modifier(highlight.fg, contranst_change_step)
|
||||
iteration_count = iteration_count + 1
|
||||
end
|
||||
end
|
||||
|
||||
-- Change brightness of colors
|
||||
-- Darken if light theme (or) Lighten if dark theme
|
||||
function M.apply_brightness(color, base_color, brightness_modifier_parameter)
|
||||
if base_color ~= nil then
|
||||
if M.get_color_brightness(base_color) > 0.5 then
|
||||
brightness_modifier_parameter = -brightness_modifier_parameter
|
||||
end
|
||||
return M.brightness_modifier(color, brightness_modifier_parameter)
|
||||
end
|
||||
end
|
||||
|
||||
-- Assorted highlight helpers
|
||||
--
|
||||
|
||||
local has_nvim9 = vim.fn.has('nvim-0.9') == 1
|
||||
|
||||
-- Retrieves color value from highlight group names.
|
||||
-- First present highlight is returned
|
||||
---@param scope string
|
||||
---@param highlights table
|
||||
---@param default string?
|
||||
---@return string|nil
|
||||
function M.get_color(scope, highlights, default)
|
||||
for _, hl_name in ipairs(highlights) do
|
||||
local hl
|
||||
if has_nvim9 then
|
||||
hl = vim.api.nvim_get_hl(0, { name = hl_name })
|
||||
else
|
||||
---@diagnostic disable-next-line: deprecated
|
||||
hl = vim.api.nvim_get_hl_by_name(hl_name, true)
|
||||
hl.fg, hl.bg, hl.sp = hl.foreground, hl.background, hl.special
|
||||
end
|
||||
if hl.reverse then
|
||||
if scope == 'bg' then
|
||||
scope = 'fg'
|
||||
elseif scope == 'fg' then
|
||||
scope = 'bg'
|
||||
end
|
||||
end
|
||||
if hl[scope] then
|
||||
return string.format('#%06x', hl[scope])
|
||||
end
|
||||
end
|
||||
return default
|
||||
end
|
||||
|
||||
return M
|
94
lua/plex/lib/contextmenu.lua
Normal file
94
lua/plex/lib/contextmenu.lua
Normal file
|
@ -0,0 +1,94 @@
|
|||
-- Context-aware menu
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
local M = {}
|
||||
|
||||
---@param method string
|
||||
---@param clients lsp.Client[]
|
||||
---@return boolean
|
||||
local function supports_method(method, clients)
|
||||
for _, client in pairs(clients) do
|
||||
if client.supports_method(method) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
M.show = function()
|
||||
if vim.fn.has('nvim-0.8') ~= 1 then
|
||||
vim.notify(
|
||||
'You must be running Neovim ≥8.0',
|
||||
vim.log.levels.WARN,
|
||||
{ title = 'Contextmenu' }
|
||||
)
|
||||
return
|
||||
end
|
||||
|
||||
local cword = vim.fn.expand('<cword>')
|
||||
local bufnr = vim.api.nvim_get_current_buf()
|
||||
local clients
|
||||
if vim.lsp.get_clients ~= nil then
|
||||
clients = vim.lsp.get_clients({ bufnr = bufnr })
|
||||
else
|
||||
---@diagnostic disable-next-line: deprecated
|
||||
clients = vim.lsp.get_active_clients({ bufnr = bufnr })
|
||||
end
|
||||
|
||||
-- Remove all menu options
|
||||
pcall(vim.cmd.aunmenu, 'Context')
|
||||
|
||||
if cword == '' then
|
||||
-- Cursor is on blank character.
|
||||
vim.cmd([[
|
||||
nmenu Context.Select\ All ggVG
|
||||
nmenu Context.-1- <Nop>
|
||||
]])
|
||||
else
|
||||
-- Add LSP methods, only if one of the servers support it.
|
||||
if supports_method('textDocument/declaration', clients) then
|
||||
vim.cmd(
|
||||
'nmenu Context.Declaration <cmd>lua vim.lsp.buf.declaration()<CR>'
|
||||
)
|
||||
end
|
||||
if supports_method('textDocument/definition', clients) then
|
||||
vim.cmd('nmenu Context.&Definition <cmd>lua vim.lsp.buf.definition()<CR>')
|
||||
end
|
||||
|
||||
if supports_method('textDocument/references', clients) then
|
||||
vim.cmd(
|
||||
'nmenu Context.&References… <cmd>lua vim.lsp.buf.references()<CR>'
|
||||
)
|
||||
end
|
||||
if supports_method('textDocument/implementation', clients) then
|
||||
vim.cmd(
|
||||
'nmenu Context.Implementation <cmd>lua vim.lsp.buf.implementation()<CR>'
|
||||
)
|
||||
end
|
||||
|
||||
if #clients > 0 then
|
||||
vim.cmd([[
|
||||
nmenu Context.-1- <Nop>
|
||||
nmenu Context.Find\ symbol… <cmd>lua vim.schedule(function() require'telescope.builtin'.lsp_workspace_symbols({default_text = vim.fn.expand('<cword>')}) end)<CR>
|
||||
]])
|
||||
end
|
||||
|
||||
vim.cmd([[
|
||||
nmenu Context.Grep… <cmd>lua vim.schedule(function() require'telescope.builtin'.live_grep({default_text = vim.fn.expand('<cword>')}) end)<CR>
|
||||
nmenu Context.-2- <Nop>
|
||||
]])
|
||||
end
|
||||
|
||||
vim.cmd([[
|
||||
nmenu Context.Diagnostics <cmd>Trouble<CR>
|
||||
nmenu Context.Bookmark m;
|
||||
nmenu Context.TODOs <cmd>TodoTrouble<CR>
|
||||
nmenu Context.Git\ diff <cmd>Gdiffsplit<CR>
|
||||
nmenu Context.Unsaved\ diff <cmd>DiffOrig<CR>
|
||||
nmenu Context.Open\ in\ browser <cmd>lua require('gitlinker').get_buf_range_url('n')<CR>
|
||||
]])
|
||||
|
||||
pcall(vim.cmd.popup, 'Context')
|
||||
end
|
||||
|
||||
return M
|
141
lua/plex/lib/edit.lua
Normal file
141
lua/plex/lib/edit.lua
Normal file
|
@ -0,0 +1,141 @@
|
|||
-- Edit utilities
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
local M = {}
|
||||
|
||||
-- Get visually selected lines.
|
||||
-- Source: https://github.com/ibhagwan/fzf-lua/blob/main/lua/fzf-lua/utils.lua
|
||||
---@return string
|
||||
function M.get_visual_selection()
|
||||
-- this will exit visual mode
|
||||
-- use 'gv' to reselect the text
|
||||
local _, csrow, cscol, cerow, cecol
|
||||
local mode = vim.fn.mode()
|
||||
if mode == 'v' or mode == 'V' or mode == '' then
|
||||
-- if we are in visual mode use the live position
|
||||
_, csrow, cscol, _ = unpack(vim.fn.getpos('.'))
|
||||
_, cerow, cecol, _ = unpack(vim.fn.getpos('v'))
|
||||
if mode == 'V' then
|
||||
-- visual line doesn't provide columns
|
||||
cscol, cecol = 0, 999
|
||||
end
|
||||
-- exit visual mode
|
||||
vim.api.nvim_feedkeys(
|
||||
vim.api.nvim_replace_termcodes('<Esc>', true, false, true),
|
||||
'n',
|
||||
true
|
||||
)
|
||||
else
|
||||
-- otherwise, use the last known visual position
|
||||
_, csrow, cscol, _ = unpack(vim.fn.getpos("'<"))
|
||||
_, cerow, cecol, _ = unpack(vim.fn.getpos("'>"))
|
||||
end
|
||||
-- swap vars if needed
|
||||
if cerow < csrow then
|
||||
csrow, cerow = cerow, csrow
|
||||
end
|
||||
if cecol < cscol then
|
||||
cscol, cecol = cecol, cscol
|
||||
end
|
||||
local lines = vim.fn.getline(csrow, cerow)
|
||||
-- local n = cerow-csrow+1
|
||||
local n = #lines
|
||||
if n <= 0 or type(lines) ~= 'table' then
|
||||
return ''
|
||||
end
|
||||
lines[n] = string.sub(lines[n], 1, cecol)
|
||||
lines[1] = string.sub(lines[1], cscol)
|
||||
return table.concat(lines, '\n')
|
||||
end
|
||||
|
||||
-- Append modeline at end of file.
|
||||
function M.append_modeline()
|
||||
local modeline = string.format(
|
||||
'vim: set ts=%d sw=%d tw=%d %set :',
|
||||
vim.bo.tabstop,
|
||||
vim.bo.shiftwidth,
|
||||
vim.bo.textwidth,
|
||||
vim.bo.expandtab and '' or 'no'
|
||||
)
|
||||
modeline = string.gsub(vim.bo.commentstring, '%%s', modeline)
|
||||
vim.api.nvim_buf_set_lines(0, -1, -1, false, { modeline })
|
||||
end
|
||||
|
||||
-- Go to newer/older buffer through jumplist.
|
||||
---@param direction 1 | -1
|
||||
function M.jump_buffer(direction)
|
||||
local jumplist, curjump = unpack(vim.fn.getjumplist())
|
||||
if #jumplist == 0 then
|
||||
return
|
||||
end
|
||||
local cur_buf = vim.api.nvim_get_current_buf()
|
||||
local jumpcmd = direction > 0 and '<C-i>' or '<C-o>'
|
||||
local searchrange = {}
|
||||
curjump = curjump + 1
|
||||
if direction > 0 then
|
||||
searchrange = vim.fn.range(curjump + 1, #jumplist)
|
||||
else
|
||||
searchrange = vim.fn.range(curjump - 1, 1, -1)
|
||||
end
|
||||
|
||||
for _, i in ipairs(searchrange) do
|
||||
local nr = jumplist[i]['bufnr']
|
||||
if nr ~= cur_buf and vim.fn.bufname(nr):find('^%w+://') == nil then
|
||||
local n = tostring(math.abs(i - curjump))
|
||||
vim.notify('Executing ' .. jumpcmd .. ' ' .. n .. ' times')
|
||||
jumpcmd = vim.api.nvim_replace_termcodes(jumpcmd, true, true, true)
|
||||
vim.cmd.normal({ n .. jumpcmd, bang = true })
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Jump to next/previous whitespace error.
|
||||
---@param direction 1 | -1
|
||||
function M.whitespace_jump(direction)
|
||||
local opts = 'wz'
|
||||
if direction < 1 then
|
||||
opts = opts .. 'b'
|
||||
end
|
||||
|
||||
-- Whitespace pattern: Trailing whitespace or mixed tabs/spaces.
|
||||
local pat = '\\s\\+$\\| \\+\\ze\\t'
|
||||
vim.fn.search(pat, opts)
|
||||
end
|
||||
|
||||
-- Toggle list window
|
||||
---@param name "quickfix" | "loclist"
|
||||
M.toggle_list = function(name)
|
||||
local win_bufs = M.get_tabpage_win_bufs(0)
|
||||
for win, buf in pairs(win_bufs) do
|
||||
if vim.bo[buf].filetype == 'qf' and vim.fn.win_gettype(win) == name then
|
||||
vim.api.nvim_win_close(win, false)
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
if name == 'loclist' then
|
||||
vim.cmd([[ botright lopen ]])
|
||||
else
|
||||
vim.cmd([[ botright copen ]])
|
||||
end
|
||||
end
|
||||
|
||||
-- Return a table with all window buffers from a tabpage.
|
||||
---@private
|
||||
---@param tabpage integer
|
||||
---@return table
|
||||
M.get_tabpage_win_bufs = function(tabpage)
|
||||
local bufs = {}
|
||||
for _, win in pairs(vim.api.nvim_tabpage_list_wins(tabpage)) do
|
||||
if win ~= nil and vim.api.nvim_win_is_valid(win) then
|
||||
local buf = vim.api.nvim_win_get_buf(win)
|
||||
if buf ~= nil and vim.api.nvim_buf_is_valid(buf) then
|
||||
bufs[win] = buf
|
||||
end
|
||||
end
|
||||
end
|
||||
return bufs
|
||||
end
|
||||
|
||||
return M
|
108
lua/plex/lib/preview.lua
Normal file
108
lua/plex/lib/preview.lua
Normal file
|
@ -0,0 +1,108 @@
|
|||
-- rafi preview functions
|
||||
-- https://github.com/rafi/vim-config
|
||||
-- requires telescope
|
||||
|
||||
local M = {}
|
||||
|
||||
local opts = {}
|
||||
|
||||
local default_opts = {
|
||||
popup = {
|
||||
enter = false,
|
||||
-- moved = 'any', -- doesn't work.
|
||||
focusable = true,
|
||||
noautocmd = true,
|
||||
relative = 'cursor',
|
||||
line = 'cursor-3',
|
||||
col = 'cursor+27',
|
||||
minwidth = math.ceil(vim.o.columns / 2),
|
||||
minheight = math.ceil(vim.o.lines / 1.5),
|
||||
border = true,
|
||||
borderchars = { '─', '│', '─', '│', '╭', '╮', '╯', '╰' },
|
||||
highlight = 'Normal',
|
||||
borderhighlight = 'FloatBorder',
|
||||
titlehighlight = 'Title',
|
||||
zindex = 100,
|
||||
},
|
||||
}
|
||||
|
||||
opts = vim.deepcopy(default_opts)
|
||||
|
||||
---@param popup_state table
|
||||
---@param augroup integer
|
||||
local function close(popup_state, augroup)
|
||||
vim.schedule(function()
|
||||
local utils = require('telescope.utils')
|
||||
pcall(vim.api.nvim_del_augroup_by_id, augroup)
|
||||
utils.win_delete('preview_border_win', popup_state.win_id, true, true)
|
||||
if popup_state.border and popup_state.border.win_id then
|
||||
utils.win_delete(
|
||||
'preview_border_win',
|
||||
popup_state.border.win_id,
|
||||
true,
|
||||
true
|
||||
)
|
||||
end
|
||||
end)
|
||||
end
|
||||
|
||||
---@param user_opts table
|
||||
function M.setup(user_opts)
|
||||
user_opts = vim.F.if_nil(user_opts, {})
|
||||
opts = vim.tbl_deep_extend('keep', user_opts, default_opts)
|
||||
end
|
||||
|
||||
---@param path string
|
||||
function M.open(path)
|
||||
local bufnr = vim.api.nvim_get_current_buf()
|
||||
local popup = require('plenary.popup')
|
||||
opts.popup.title = path
|
||||
local winid, popup_state = popup.create('', opts.popup)
|
||||
local popup_bufnr = vim.api.nvim_win_get_buf(winid)
|
||||
|
||||
-- Ensure best viewing options are toggled.
|
||||
local scope = { scope = 'local', win = winid }
|
||||
vim.api.nvim_set_option_value('number', true, scope)
|
||||
vim.api.nvim_set_option_value('relativenumber', false, scope)
|
||||
vim.api.nvim_set_option_value('wrap', false, scope)
|
||||
vim.api.nvim_set_option_value('spell', false, scope)
|
||||
vim.api.nvim_set_option_value('list', false, scope)
|
||||
vim.api.nvim_set_option_value('foldenable', false, scope)
|
||||
vim.api.nvim_set_option_value('cursorline', false, scope)
|
||||
vim.api.nvim_set_option_value('signcolumn', 'no', scope)
|
||||
vim.api.nvim_set_option_value('colorcolumn', '', scope)
|
||||
vim.api.nvim_set_option_value('winhighlight', 'Normal:NormalFloat', scope)
|
||||
|
||||
-- Run telescope preview.
|
||||
local previewer = require('telescope.config').values.buffer_previewer_maker
|
||||
previewer(path, popup_bufnr, {})
|
||||
|
||||
-- Setup close events
|
||||
local augroup = vim.api.nvim_create_augroup('preview_window_' .. winid, {})
|
||||
|
||||
-- Close the preview window when entered a buffer that is not
|
||||
-- the floating window buffer or the buffer that spawned it.
|
||||
vim.api.nvim_create_autocmd('BufEnter', {
|
||||
group = augroup,
|
||||
callback = function()
|
||||
-- close preview unless we're in original window or popup window
|
||||
local bufnrs = { popup_bufnr, bufnr }
|
||||
if not vim.tbl_contains(bufnrs, vim.api.nvim_get_current_buf()) then
|
||||
close(popup_state, augroup)
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
-- Create autocommands to close a preview window when events happen.
|
||||
local events = { 'CursorMoved', 'BufUnload', 'InsertCharPre', 'ModeChanged' }
|
||||
vim.api.nvim_create_autocmd(events, {
|
||||
group = augroup,
|
||||
buffer = bufnr,
|
||||
once = true,
|
||||
callback = function()
|
||||
close(popup_state, augroup)
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
return M
|
122
lua/plex/lib/utils.lua
Normal file
122
lua/plex/lib/utils.lua
Normal file
|
@ -0,0 +1,122 @@
|
|||
-- General utilities
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
local root_patterns = { '.git', '_darcs', '.hg', '.bzr', '.svn' }
|
||||
|
||||
local M = {}
|
||||
|
||||
local augroup_lsp_attach = vim.api.nvim_create_augroup('plex_lsp_attach', {})
|
||||
|
||||
---@param on_attach fun(client:lsp.Client, buffer:integer)
|
||||
function M.on_attach(on_attach)
|
||||
vim.api.nvim_create_autocmd('LspAttach', {
|
||||
group = augroup_lsp_attach,
|
||||
callback = function(args)
|
||||
local buffer = args.buf
|
||||
local client = vim.lsp.get_client_by_id(args.data.client_id)
|
||||
if client ~= nil then
|
||||
on_attach(client, buffer)
|
||||
end
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
---@param plugin string
|
||||
---@return boolean
|
||||
function M.has(plugin)
|
||||
-- return require('lazy.core.config').plugins[plugin] ~= nil
|
||||
return require('lazy.core.config').spec.plugins[plugin] ~= nil
|
||||
end
|
||||
|
||||
---@param fn fun()
|
||||
function M.on_very_lazy(fn)
|
||||
vim.api.nvim_create_autocmd('User', {
|
||||
pattern = 'VeryLazy',
|
||||
callback = function()
|
||||
fn()
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
---@param name string
|
||||
---@return table
|
||||
function M.opts(name)
|
||||
local plugin = require('lazy.core.config').plugins[name]
|
||||
if not plugin then
|
||||
return {}
|
||||
end
|
||||
local Plugin = require('lazy.core.plugin')
|
||||
return Plugin.values(plugin, 'opts', false)
|
||||
end
|
||||
|
||||
-- Find the root directory by searching for the version-control dir
|
||||
---@return string
|
||||
function M.get_root()
|
||||
local cwd = vim.loop.cwd()
|
||||
if cwd == '' or cwd == nil then
|
||||
return ''
|
||||
end
|
||||
local ok, cache = pcall(vim.api.nvim_buf_get_var, 0, 'project_dir')
|
||||
if ok and cache then
|
||||
local _, last_cwd =
|
||||
pcall(vim.api.nvim_buf_get_var, 0, 'project_dir_last_cwd')
|
||||
if cwd == last_cwd then
|
||||
return cache
|
||||
end
|
||||
end
|
||||
|
||||
local root = vim.fs.find(root_patterns, { path = cwd, upward = true })[1]
|
||||
root = root and vim.fs.dirname(root) or vim.loop.cwd() or ''
|
||||
vim.api.nvim_buf_set_var(0, 'project_dir', root)
|
||||
vim.api.nvim_buf_set_var(0, 'project_dir_last_cwd', cwd)
|
||||
return root
|
||||
end
|
||||
|
||||
---@type table<string,LazyFloat>
|
||||
local terminals = {}
|
||||
|
||||
-- Opens a floating terminal (interactive by default)
|
||||
---@param cmd? string[]|string
|
||||
---@param opts? LazyCmdOptions|{interactive?:boolean, esc_esc?:false, ctrl_hjkl?:false}
|
||||
function M.float_term(cmd, opts)
|
||||
opts = vim.tbl_deep_extend('force', {
|
||||
ft = 'lazyterm',
|
||||
size = { width = 0.9, height = 0.9 },
|
||||
}, opts or {}, { persistent = true })
|
||||
---@cast opts LazyCmdOptions|{interactive?:boolean, esc_esc?:false, ctrl_hjkl?:false}
|
||||
|
||||
local termkey = vim.inspect({
|
||||
cmd = cmd or 'shell',
|
||||
cwd = opts.cwd,
|
||||
env = opts.env,
|
||||
count = vim.v.count1,
|
||||
})
|
||||
|
||||
if terminals[termkey] and terminals[termkey]:buf_valid() then
|
||||
terminals[termkey]:toggle()
|
||||
else
|
||||
terminals[termkey] = require('lazy.util').float_term(cmd, opts)
|
||||
local buf = terminals[termkey].buf
|
||||
vim.b[buf].lazyterm_cmd = cmd
|
||||
if opts.esc_esc == false then
|
||||
vim.keymap.set('t', '<esc>', '<esc>', { buffer = buf, nowait = true })
|
||||
end
|
||||
if opts.ctrl_hjkl == false then
|
||||
vim.keymap.set('t', '<c-h>', '<c-h>', { buffer = buf, nowait = true })
|
||||
vim.keymap.set('t', '<c-j>', '<c-j>', { buffer = buf, nowait = true })
|
||||
vim.keymap.set('t', '<c-k>', '<c-k>', { buffer = buf, nowait = true })
|
||||
vim.keymap.set('t', '<c-l>', '<c-l>', { buffer = buf, nowait = true })
|
||||
end
|
||||
|
||||
vim.api.nvim_create_autocmd('BufEnter', {
|
||||
buffer = buf,
|
||||
callback = function()
|
||||
vim.cmd.startinsert()
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
return terminals[termkey]
|
||||
end
|
||||
|
||||
return M
|
16
lua/plex/plugins/colorscheme.lua
Normal file
16
lua/plex/plugins/colorscheme.lua
Normal file
|
@ -0,0 +1,16 @@
|
|||
-- Plugins: Colorschemes
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
return {
|
||||
|
||||
{
|
||||
'rafi/theme-loader.nvim',
|
||||
lazy = false,
|
||||
priority = 99,
|
||||
opts = { initial_colorscheme = 'zenbones' },
|
||||
},
|
||||
{ 'mcchrish/zenbones.nvim', lazy = false,
|
||||
config = function()
|
||||
vim.g.zenbones_compat = 1
|
||||
end}
|
||||
}
|
6
lua/plex/plugins/core.lua
Normal file
6
lua/plex/plugins/core.lua
Normal file
|
@ -0,0 +1,6 @@
|
|||
require('plex.config').init()
|
||||
|
||||
return {
|
||||
{ 'folke/lazy.nvim', version = '*' },
|
||||
{ 'nvim-lua/plenary.nvim', lazy = false },
|
||||
}
|
64
lua/plex/plugins/editor.lua
Normal file
64
lua/plex/plugins/editor.lua
Normal file
|
@ -0,0 +1,64 @@
|
|||
-- Plugins: Editor
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
local is_windows = vim.loop.os_uname().sysname == 'Windows_NT'
|
||||
|
||||
return {
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
{
|
||||
'ggandor/leap.nvim',
|
||||
-- stylua: ignore
|
||||
keys = {
|
||||
{ 'gl', '<Plug>(leap-forward-to)', mode = { 'n', 'x', 'o' }, desc = 'Leap forward to' },
|
||||
{ 'gL', '<Plug>(leap-backward-to)', mode = { 'n', 'x', 'o' }, desc = 'Leap backward to' },
|
||||
{ '<leader>wl', '<Plug>(leap-from-window)', mode = { 'n', 'x', 'o' }, desc = 'Leap to windows' },
|
||||
},
|
||||
config = function ()
|
||||
local leap = require('leap')
|
||||
leap.opts.case_sensitive = false
|
||||
leap.opts.safe_labels = { 'f', 'n', 'u', 't', 'g', 'ö', 'w', 'b', 'm' }
|
||||
leap.opts.labels = { 'a', 's', 'f', 'n', 'j', 'k', 'r', 'e', 'r', 'm',
|
||||
'ö', 'b', 'v', 'u', 'z', 'w', '2', '3', '4', '5', '6',
|
||||
'7', '8', '9' }
|
||||
end,
|
||||
},
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
-- NOTE: THIS SECTION CONTAINS THE PREFIXES!
|
||||
{
|
||||
'folke/which-key.nvim',
|
||||
event = 'VeryLazy',
|
||||
opts = {
|
||||
icons = { separator = ' ' },
|
||||
window = { winblend = 0 },
|
||||
defaults = {
|
||||
mode = { 'n', 'v' },
|
||||
[';'] = { name = '+telescope' },
|
||||
[';d'] = { name = '+lsp/todo' },
|
||||
['g'] = { name = '+goto' },
|
||||
['gz'] = { name = '+surround' },
|
||||
[']'] = { name = '+next' },
|
||||
['['] = { name = '+prev' },
|
||||
['<leader>b'] = { name = '+buffer' },
|
||||
['<leader>c'] = { name = '+code' },
|
||||
['<leader>g'] = { name = '+git' },
|
||||
['<leader>h'] = { name = '+hunks' },
|
||||
['<leader>S'] = { name = '+search' },
|
||||
['<leader>t'] = { name = '+toggle/tools' },
|
||||
['<leader>u'] = { name = '+ui' },
|
||||
['<leader>x'] = { name = '+diagnostics/quickfix' },
|
||||
['<leader>z'] = { name = '+notes' },
|
||||
['<leader>w'] = { name = '+window' },
|
||||
['<leader>f'] = { name = '+formatting' },
|
||||
['<leader>m'] = { name = '+marks/misc' },
|
||||
['<leader>md'] = { name = '+line-diffs' },
|
||||
},
|
||||
},
|
||||
config = function(_, opts)
|
||||
local wk = require('which-key')
|
||||
wk.setup(opts)
|
||||
wk.register(opts.defaults)
|
||||
end,
|
||||
},
|
||||
}
|
247
lua/plex/plugins/neo-tree.lua
Normal file
247
lua/plex/plugins/neo-tree.lua
Normal file
|
@ -0,0 +1,247 @@
|
|||
-- Plugin: Neo-tree
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
|
||||
local winwidth = 30
|
||||
|
||||
-- Toggle width.
|
||||
local toggle_width = function()
|
||||
local max = winwidth * 2
|
||||
local cur_width = vim.fn.winwidth(0)
|
||||
local half = math.floor((winwidth + (max - winwidth) / 2) + 0.4)
|
||||
local new_width = winwidth
|
||||
if cur_width == winwidth then
|
||||
new_width = half
|
||||
elseif cur_width == half then
|
||||
new_width = max
|
||||
else
|
||||
new_width = winwidth
|
||||
end
|
||||
vim.cmd(new_width .. ' wincmd |')
|
||||
end
|
||||
|
||||
-- Get current opened directory from state.
|
||||
---@param state table
|
||||
---@return string
|
||||
local function get_current_directory(state)
|
||||
local node = state.tree:get_node()
|
||||
local path = node.path
|
||||
if node.type ~= 'directory' or not node:is_expanded() then
|
||||
local path_separator = package.config:sub(1, 1)
|
||||
path = path:match('(.*)' .. path_separator)
|
||||
end
|
||||
return path
|
||||
end
|
||||
|
||||
return {
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
'nvim-neo-tree/neo-tree.nvim',
|
||||
dependencies = {
|
||||
'MunifTanjim/nui.nvim',
|
||||
's1n7ax/nvim-window-picker',
|
||||
},
|
||||
cmd = 'Neotree',
|
||||
keys = {
|
||||
{
|
||||
'<LocalLeader>e',
|
||||
'<cmd>Neotree filesystem left toggle dir=./<CR>',
|
||||
desc = 'Explorer NeoTree Toggle',
|
||||
},
|
||||
{
|
||||
'<F5>',
|
||||
'<cmd>Neotree filesystem left toggle dir=./<CR>',
|
||||
desc = 'Explorer NeoTree Toggle',
|
||||
},
|
||||
},
|
||||
deactivate = function()
|
||||
vim.cmd([[Neotree close]])
|
||||
end,
|
||||
init = function()
|
||||
vim.g.neo_tree_remove_legacy_commands = 1
|
||||
if vim.fn.argc() == 1 then
|
||||
local stat = vim.loop.fs_stat(tostring(vim.fn.argv(0)))
|
||||
if stat and stat.type == 'directory' then
|
||||
require('neo-tree')
|
||||
end
|
||||
end
|
||||
end,
|
||||
-- See: https://github.com/nvim-neo-tree/neo-tree.nvim
|
||||
opts = {
|
||||
close_if_last_window = true,
|
||||
|
||||
source_selector = {
|
||||
winbar = false,
|
||||
show_scrolled_off_parent_node = true,
|
||||
padding = { left = 1, right = 0 },
|
||||
sources = {
|
||||
{ source = 'filesystem', display_name = ' Files' }, --
|
||||
{ source = 'buffers', display_name = ' Buffers' }, --
|
||||
{ source = 'git_status', display_name = ' Git' }, --
|
||||
},
|
||||
},
|
||||
|
||||
-- event_handlers = {
|
||||
-- -- Close neo-tree when opening a file.
|
||||
-- {
|
||||
-- event = 'file_opened',
|
||||
-- handler = function()
|
||||
-- require('neo-tree').close_all()
|
||||
-- end,
|
||||
-- },
|
||||
-- },
|
||||
|
||||
default_component_configs = {
|
||||
indent = {
|
||||
padding = 0,
|
||||
},
|
||||
icon = {
|
||||
folder_closed = '',
|
||||
folder_open = '',
|
||||
folder_empty = '',
|
||||
folder_empty_open = '',
|
||||
default = '',
|
||||
},
|
||||
modified = {
|
||||
symbol = '•',
|
||||
},
|
||||
name = {
|
||||
trailing_slash = true,
|
||||
highlight_opened_files = true, -- NeoTreeFileNameOpened
|
||||
use_git_status_colors = false,
|
||||
},
|
||||
git_status = {
|
||||
symbols = {
|
||||
-- Change type
|
||||
added = 'A',
|
||||
deleted = 'D',
|
||||
modified = 'M',
|
||||
renamed = 'R',
|
||||
-- Status type
|
||||
untracked = 'U',
|
||||
ignored = 'I',
|
||||
unstaged = '',
|
||||
staged = 'S',
|
||||
conflict = 'C',
|
||||
},
|
||||
},
|
||||
},
|
||||
window = {
|
||||
width = winwidth,
|
||||
mappings = {
|
||||
['q'] = 'close_window',
|
||||
['?'] = 'noop',
|
||||
['<Space>'] = 'noop',
|
||||
|
||||
['g?'] = 'show_help',
|
||||
['<2-LeftMouse>'] = 'open',
|
||||
['<CR>'] = 'open_with_window_picker',
|
||||
['l'] = 'open_drop',
|
||||
['h'] = 'close_node',
|
||||
['C'] = 'close_node',
|
||||
['<C-c>'] = 'set_root',
|
||||
['z'] = 'close_all_nodes',
|
||||
['<C-r>'] = 'refresh',
|
||||
|
||||
['o'] = 'noop',
|
||||
['os'] = 'open_split',
|
||||
['ov'] = 'open_vsplit',
|
||||
['ot'] = 'open_tabnew',
|
||||
|
||||
['c'] = { 'copy', config = { show_path = 'relative' } },
|
||||
['m'] = { 'move', config = { show_path = 'relative' } },
|
||||
['a'] = { 'add', nowait = true, config = { show_path = 'relative' } },
|
||||
['N'] = { 'add_directory', config = { show_path = 'relative' } },
|
||||
['d'] = 'noop',
|
||||
['dd'] = 'delete',
|
||||
['r'] = 'rename',
|
||||
-- TODO: <leader>y to copy path name
|
||||
['y'] = 'copy_to_clipboard',
|
||||
['x'] = 'cut_to_clipboard',
|
||||
['P'] = 'paste_from_clipboard',
|
||||
['<S-Tab>'] = 'prev_source',
|
||||
['<Tab>'] = 'next_source',
|
||||
|
||||
['p'] = {
|
||||
'toggle_preview',
|
||||
nowait = true,
|
||||
config = { use_float = true },
|
||||
},
|
||||
|
||||
['w'] = toggle_width,
|
||||
},
|
||||
},
|
||||
filesystem = {
|
||||
follow_current_file = {
|
||||
enabled = true, -- This will find and focus the file in the active buffer every time
|
||||
-- -- the current file is changed while the tree is open.
|
||||
leave_dirs_open = true, -- `false` closes auto expanded dirs, such as with `:Neotree reveal`
|
||||
},
|
||||
window = {
|
||||
mappings = {
|
||||
['H'] = 'toggle_hidden',
|
||||
['/'] = 'noop',
|
||||
['f'] = 'fuzzy_finder',
|
||||
['F'] = 'filter_on_submit',
|
||||
['<C-x>'] = 'clear_filter',
|
||||
['<C-c>'] = 'clear_filter',
|
||||
['<BS>'] = 'navigate_up',
|
||||
['.'] = 'set_root',
|
||||
['[g'] = 'prev_git_modified',
|
||||
[']g'] = 'next_git_modified',
|
||||
|
||||
['gf'] = function(state)
|
||||
require('telescope.builtin').find_files({
|
||||
cwd = get_current_directory(state),
|
||||
})
|
||||
end,
|
||||
|
||||
['gr'] = function(state)
|
||||
require('telescope.builtin').live_grep({
|
||||
cwd = get_current_directory(state),
|
||||
})
|
||||
end,
|
||||
},
|
||||
},
|
||||
group_empty_dirs = false,
|
||||
use_libuv_file_watcher = true,
|
||||
bind_to_cwd = false,
|
||||
cwd_target = {
|
||||
sidebar = 'window',
|
||||
current = 'window',
|
||||
},
|
||||
|
||||
filtered_items = {
|
||||
visible = false,
|
||||
show_hidden_count = true,
|
||||
hide_dotfiles = true,
|
||||
hide_gitignored = false,
|
||||
hide_by_name = {
|
||||
'.git',
|
||||
'.hg',
|
||||
'.svc',
|
||||
'.DS_Store',
|
||||
'thumbs.db',
|
||||
'.sass-cache',
|
||||
'node_modules',
|
||||
'.pytest_cache',
|
||||
'.mypy_cache',
|
||||
'__pycache__',
|
||||
'.stfolder',
|
||||
'.stversions',
|
||||
},
|
||||
never_show = {},
|
||||
},
|
||||
},
|
||||
buffers = {
|
||||
bind_to_cwd = true,
|
||||
window = {
|
||||
mappings = {
|
||||
['<BS>'] = 'navigate_up',
|
||||
['.'] = 'set_root',
|
||||
['dd'] = 'buffer_delete',
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
174
lua/plex/plugins/treesitter.lua
Normal file
174
lua/plex/plugins/treesitter.lua
Normal file
|
@ -0,0 +1,174 @@
|
|||
-- Plugins: Tree-sitter and Syntax
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
return {
|
||||
{
|
||||
'nvim-treesitter/nvim-treesitter',
|
||||
event = { 'BufReadPost', 'BufNewFile' },
|
||||
main = 'nvim-treesitter.configs',
|
||||
build = ':TSUpdate',
|
||||
dependencies = {
|
||||
'nvim-treesitter/nvim-treesitter-textobjects',
|
||||
{ 'nvim-treesitter/nvim-treesitter-context', opts = { enable = false } },
|
||||
'JoosepAlviste/nvim-ts-context-commentstring',
|
||||
'RRethy/nvim-treesitter-endwise',
|
||||
'windwp/nvim-ts-autotag',
|
||||
'andymass/vim-matchup',
|
||||
},
|
||||
cmd = {
|
||||
'TSUpdate',
|
||||
'TSInstall',
|
||||
'TSInstallInfo',
|
||||
'TSModuleInfo',
|
||||
'TSConfigInfo',
|
||||
'TSUpdateSync',
|
||||
},
|
||||
keys = {
|
||||
{ 'v', desc = 'Increment selection', mode = 'x' },
|
||||
{ 'V', desc = 'Shrink selection', mode = 'x' },
|
||||
},
|
||||
---@type TSConfig
|
||||
---@diagnostic disable-next-line: missing-fields
|
||||
opts = {
|
||||
highlight = { enable = true },
|
||||
indent = { enable = true },
|
||||
refactor = {
|
||||
highlight_definitions = { enable = true },
|
||||
highlight_current_scope = { enable = true },
|
||||
},
|
||||
|
||||
-- See: https://github.com/RRethy/nvim-treesitter-endwise
|
||||
endwise = { enable = true },
|
||||
|
||||
-- See: https://github.com/andymass/vim-matchup
|
||||
matchup = {
|
||||
enable = true,
|
||||
include_match_words = true,
|
||||
},
|
||||
|
||||
-- See: https://github.com/windwp/nvim-ts-autotag
|
||||
autotag = {
|
||||
enable = true,
|
||||
filetypes = {
|
||||
'markdown',
|
||||
'glimmer',
|
||||
'handlebars',
|
||||
'hbs',
|
||||
'html',
|
||||
'javascript',
|
||||
'javascriptreact',
|
||||
'jsx',
|
||||
'rescript',
|
||||
'svelte',
|
||||
'tsx',
|
||||
'typescript',
|
||||
'typescriptreact',
|
||||
'vue',
|
||||
'xml',
|
||||
},
|
||||
},
|
||||
|
||||
-- See: https://github.com/JoosepAlviste/nvim-ts-context-commentstring
|
||||
context_commentstring = { enable = true, enable_autocmd = false },
|
||||
|
||||
incremental_selection = {
|
||||
enable = true,
|
||||
keymaps = {
|
||||
init_selection = false,
|
||||
node_incremental = 'v',
|
||||
scope_incremental = false,
|
||||
node_decremental = 'V',
|
||||
},
|
||||
},
|
||||
|
||||
-- See: https://github.com/nvim-treesitter/nvim-treesitter-textobjects
|
||||
textobjects = {
|
||||
select = {
|
||||
enable = true,
|
||||
lookahead = true,
|
||||
keymaps = {
|
||||
['af'] = '@function.outer',
|
||||
['if'] = '@function.inner',
|
||||
['ac'] = '@class.outer',
|
||||
['ic'] = '@class.inner',
|
||||
['a,'] = '@parameter.outer',
|
||||
['i,'] = '@parameter.inner',
|
||||
},
|
||||
},
|
||||
move = {
|
||||
enable = true,
|
||||
set_jumps = true,
|
||||
goto_next_start = {
|
||||
['],'] = '@parameter.inner',
|
||||
},
|
||||
goto_previous_start = {
|
||||
['[,'] = '@parameter.inner',
|
||||
},
|
||||
},
|
||||
swap = {
|
||||
enable = true,
|
||||
swap_next = {
|
||||
['>,'] = '@parameter.inner',
|
||||
},
|
||||
swap_previous = {
|
||||
['<,'] = '@parameter.inner',
|
||||
},
|
||||
},
|
||||
},
|
||||
|
||||
-- https://github.com/nvim-treesitter/nvim-treesitter#supported-languages
|
||||
ensure_installed = {
|
||||
'bash',
|
||||
'comment',
|
||||
'css',
|
||||
'cue',
|
||||
'diff',
|
||||
'fish',
|
||||
'fennel',
|
||||
'git_config',
|
||||
'git_rebase',
|
||||
'gitcommit',
|
||||
'gitignore',
|
||||
'gitattributes',
|
||||
'graphql',
|
||||
'hcl',
|
||||
'html',
|
||||
'http',
|
||||
'java',
|
||||
'javascript',
|
||||
'jsdoc',
|
||||
'kotlin',
|
||||
'lua',
|
||||
'luadoc',
|
||||
'luap',
|
||||
'make',
|
||||
'markdown',
|
||||
'markdown_inline',
|
||||
'nix',
|
||||
'perl',
|
||||
'php',
|
||||
'pug',
|
||||
'regex',
|
||||
'ruby',
|
||||
'rust',
|
||||
'scala',
|
||||
'scss',
|
||||
'sql',
|
||||
'svelte',
|
||||
'terraform',
|
||||
'todotxt',
|
||||
'toml',
|
||||
'tsx',
|
||||
'typescript',
|
||||
'vim',
|
||||
'vimdoc',
|
||||
'vue',
|
||||
'zig',
|
||||
},
|
||||
},
|
||||
init = function ()
|
||||
vim.opt.concealcursor = "nc"
|
||||
vim.opt.conceallevel = 2
|
||||
end
|
||||
},
|
||||
}
|
38
lua/plex/plugins/ui.lua
Normal file
38
lua/plex/plugins/ui.lua
Normal file
|
@ -0,0 +1,38 @@
|
|||
-- Plugins: UI
|
||||
-- https://github.com/rafi/vim-config
|
||||
|
||||
return {
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
{ 'nvim-tree/nvim-web-devicons', lazy = false },
|
||||
{ 'MunifTanjim/nui.nvim', lazy = false },
|
||||
{
|
||||
'akinsho/bufferline.nvim', lazy = false, version = "*",
|
||||
dependencies = 'nvim-tree/nvim-web-devicons'
|
||||
},
|
||||
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
{
|
||||
'stevearc/dressing.nvim',
|
||||
init = function()
|
||||
---@diagnostic disable-next-line: duplicate-set-field
|
||||
vim.ui.select = function(...)
|
||||
require('lazy').load({ plugins = { 'dressing.nvim' } })
|
||||
return vim.ui.select(...)
|
||||
end
|
||||
---@diagnostic disable-next-line: duplicate-set-field
|
||||
vim.ui.input = function(...)
|
||||
require('lazy').load({ plugins = { 'dressing.nvim' } })
|
||||
return vim.ui.input(...)
|
||||
end
|
||||
end,
|
||||
},
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
{
|
||||
'tenxsoydev/tabs-vs-spaces.nvim',
|
||||
event = { 'BufReadPost', 'BufNewFile' },
|
||||
config = true,
|
||||
},
|
||||
}
|
|
@ -1,7 +0,0 @@
|
|||
gings
|
||||
Safety
|
||||
NewTec
|
||||
Rust
|
||||
Cybersecurity
|
||||
STM32
|
||||
STMicroelectronics
|
Binary file not shown.
|
@ -68,535 +68,3 @@ SHA
|
|||
Etablierungs
|
||||
the
|
||||
strikethrough
|
||||
RustBook
|
||||
IEC62443
|
||||
DHBW
|
||||
gelinked
|
||||
openssl
|
||||
Yocto
|
||||
gls
|
||||
ECC
|
||||
Kryptosystem
|
||||
github
|
||||
sfackler
|
||||
mathmatics
|
||||
www
|
||||
sagemath
|
||||
PlexSheep
|
||||
plexcryptool
|
||||
ECDSA
|
||||
EdDSA
|
||||
Stringverarbeitung
|
||||
#onblocking
|
||||
OOP
|
||||
Fifo
|
||||
serde
|
||||
Deserialisierung
|
||||
serde
|
||||
Skripte
|
||||
mathmatics
|
||||
bbc
|
||||
Kryptographischen/!
|
||||
PyO3
|
||||
#yo3
|
||||
JSON
|
||||
json
|
||||
#yo3
|
||||
Verifikationsmechanismus
|
||||
projektinterne
|
||||
Theoriephase
|
||||
weise/!
|
||||
Weise
|
||||
merksam
|
||||
Syscall
|
||||
Enum
|
||||
deu
|
||||
JS
|
||||
JS
|
||||
getElementById
|
||||
MDN
|
||||
WebDocs
|
||||
src
|
||||
txt
|
||||
ERRNO
|
||||
vvvv
|
||||
Rustonomicon
|
||||
Rustdoc
|
||||
paragraph
|
||||
rustc
|
||||
Klabnik
|
||||
io
|
||||
rustbook
|
||||
Deserialize
|
||||
deserialisierbaren
|
||||
SIGTERM
|
||||
Beendigungsabfrage
|
||||
SIGKILL
|
||||
stdout
|
||||
stderr
|
||||
Leveln
|
||||
gedroppt
|
||||
#ekonstruktor
|
||||
Dekonstruktor/!
|
||||
dealloziiert
|
||||
Dealloziierung
|
||||
Dealloziieren
|
||||
vvvv
|
||||
TODO
|
||||
vvvv
|
||||
Structs
|
||||
nomicon
|
||||
Wrapperklasse
|
||||
tx
|
||||
rx
|
||||
struct
|
||||
enum
|
||||
priorisierbar
|
||||
仕方がない
|
||||
Gleichzeitigkeitsmechanismen
|
||||
ServiceWrapper
|
||||
Repräsentierung
|
||||
Docstrings
|
||||
Backends
|
||||
dirs
|
||||
MessageFrame
|
||||
Addressor
|
||||
init
|
||||
Spektralgestalt
|
||||
CTS
|
||||
Addressor
|
||||
Timestamp
|
||||
str
|
||||
BASEDIRECTORY
|
||||
configs
|
||||
fifo
|
||||
PKI
|
||||
secp384r1
|
||||
Addressors
|
||||
Keystore
|
||||
Fifos
|
||||
SBC
|
||||
NTSecureCloudSolutions
|
||||
newtec
|
||||
loesungen
|
||||
subfigure
|
||||
Shield96
|
||||
ATSAMA5D27
|
||||
TrustZone
|
||||
A5
|
||||
ARMv7
|
||||
eMMC
|
||||
MT25QU0512BBB
|
||||
ATECC608
|
||||
Rückwärtskompatibilität
|
||||
tls
|
||||
opcua
|
||||
texttt
|
||||
rfcp
|
||||
ssl
|
||||
Lifecycle
|
||||
v0
|
||||
pyi
|
||||
bietete
|
||||
desc
|
||||
Scherr
|
||||
mariadb
|
||||
Gawa
|
||||
Django
|
||||
opensource
|
||||
Shader
|
||||
shader
|
||||
GLFW
|
||||
shaders
|
||||
GLSL
|
||||
cpp
|
||||
clangd
|
||||
Hashtypen
|
||||
Ver
|
||||
vshot
|
||||
oopsc
|
||||
antlr
|
||||
wir's
|
||||
Naja
|
||||
Vlam
|
||||
UNE
|
||||
Electionary
|
||||
UNE's
|
||||
recuse
|
||||
hacky
|
||||
config
|
||||
Yubi
|
||||
submodules
|
||||
Curve25519
|
||||
gpg
|
||||
devops
|
||||
lazygit
|
||||
IDEs
|
||||
hypervisors
|
||||
QEMU
|
||||
virt
|
||||
filetypes
|
||||
Parth
|
||||
Narula
|
||||
wordpress
|
||||
PlexSheep's
|
||||
nvchad
|
||||
IDK
|
||||
lazyloading
|
||||
nv
|
||||
ftplugins
|
||||
stylua
|
||||
nvim
|
||||
lsp
|
||||
builtins
|
||||
cmdline
|
||||
popupmenu
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#m
|
||||
ufo
|
||||
treesitter
|
||||
GitLab
|
||||
Gitea
|
||||
Autocrate
|
||||
YAML
|
||||
TOML
|
||||
autocrate
|
||||
TBD
|
||||
PRs
|
||||
yaml
|
||||
netpong
|
||||
gehostet
|
||||
IoT
|
||||
einen
|
||||
NTSecureGateway
|
||||
SoC
|
||||
Lockscreen
|
||||
licht/!
|
||||
Licht
|
||||
ESRDD
|
||||
erstmal
|
||||
warmweißer
|
||||
WG
|
||||
SilverBullet
|
||||
Forgejo
|
||||
additional
|
||||
scriptable
|
||||
Autcrate
|
||||
rustaceans
|
||||
serv0
|
||||
serv1
|
||||
serv2
|
||||
sequenceDiagram
|
||||
style
|
||||
BT
|
||||
style
|
||||
logdir
|
||||
traceback
|
||||
timestamp
|
||||
LoggerBuilder
|
||||
libpt
|
||||
T2000
|
||||
TINF22CS
|
||||
Fliegendes/!
|
||||
Gewöhnungsphase
|
||||
Notfallmaßnahmen
|
||||
übergriffig
|
||||
Eligswalde
|
||||
Usecases
|
||||
OpenAPI
|
||||
homeserver
|
||||
theseus
|
||||
Kernelmodus
|
||||
entziehbares
|
||||
vorkompiliert
|
||||
vorkompilierte
|
||||
Wordle
|
||||
Quotientenkriterium
|
||||
neovim
|
||||
authentik
|
||||
auth
|
||||
Mesum
|
||||
Raza
|
||||
letsencrypt
|
||||
MTA
|
||||
STS
|
||||
BIMI
|
||||
Minecraft
|
||||
exfiltrate
|
||||
VPS
|
||||
JVM
|
||||
Dammit/!
|
||||
Maxdorf
|
||||
Leininger
|
||||
Dockerfile
|
||||
yml
|
||||
CMD
|
||||
UDPP
|
||||
Unknowability
|
||||
unknowability
|
||||
talmann
|
||||
Goldberger
|
||||
ofc
|
||||
shockwaves
|
||||
deerhash
|
||||
argon2
|
||||
SCSS
|
||||
Eligswalde's
|
||||
Achmarel
|
||||
aswell
|
||||
AGI
|
||||
FTL
|
||||
Houten
|
||||
Gabriella
|
||||
Inrgid
|
||||
Usecase
|
||||
UITP
|
||||
UITP1
|
||||
UITP2
|
||||
UITP3
|
||||
UITP4
|
||||
UITPS
|
||||
PV
|
||||
UITPA
|
||||
Glänzer
|
||||
postgres
|
||||
sqlite
|
||||
REPL
|
||||
nested19
|
||||
GMs
|
||||
Yusuf
|
||||
nenoECC
|
||||
Nonadekagonic
|
||||
#ediverse
|
||||
fediverse
|
||||
nested19's
|
||||
Navier
|
||||
Poincaré
|
||||
Swinnerton
|
||||
lemmy
|
||||
selfhosting
|
||||
ELO
|
||||
FIDE
|
||||
BDD
|
||||
Pentesting
|
||||
Typst
|
||||
Multivariable
|
||||
envvar
|
||||
Featurefile
|
||||
maschinen
|
||||
menschenlesbar
|
||||
thiserror
|
||||
WSL
|
||||
verbindungen/!
|
||||
acl
|
||||
Metadatum
|
||||
Serve/!
|
||||
Featurefiles
|
||||
#orallem/!
|
||||
#orallem/!
|
||||
newglossaryentry
|
||||
CVE
|
||||
QUIC
|
||||
#orallem/!
|
||||
vorallem/!
|
||||
#roßteile/!
|
||||
großteile/!
|
||||
großteile
|
||||
Konfuguration/!
|
||||
typ
|
||||
Wooly
|
||||
addr
|
||||
#dress
|
||||
tokio
|
||||
address/!
|
||||
i32
|
||||
|
||||
C3
|
||||
TOTP
|
||||
Panta/!
|
||||
Panta
|
||||
kauma
|
||||
α
|
||||
XEX
|
||||
unintuitively
|
||||
sea128
|
||||
u8
|
||||
Base64
|
||||
ffield
|
||||
α's
|
||||
Vec
|
||||
u128
|
||||
number1
|
||||
number2
|
||||
i64
|
||||
Waldtraut
|
||||
Kiki
|
||||
Yevda
|
||||
Grischtoffshofen
|
||||
Riedsbach
|
||||
Grischtophus
|
||||
Sichheim
|
||||
Neuhofen
|
||||
Falkenhausen
|
||||
Auenheim
|
||||
KVK
|
||||
#uttslut
|
||||
Kiki's
|
||||
U256
|
||||
Netpulse
|
||||
PID
|
||||
obfuskiert
|
||||
ECB
|
||||
SHA3
|
||||
dnstego
|
||||
obfuskierte
|
||||
DNStego
|
||||
Fauth
|
||||
Lotz
|
||||
deobfuskiert
|
||||
Grischtoff
|
||||
shinobi
|
||||
Grischtoffshofen's
|
||||
Verwahrungskette
|
||||
Räty
|
||||
Aservat/!
|
||||
verfahrensrelevante
|
||||
verfahrensrelevanten
|
||||
Soria
|
||||
#erfahrensrelewand
|
||||
verfahrensrelewand/!
|
||||
#erfahrensrelewant
|
||||
verfahrensrelevant
|
||||
verfahrensrelewant/!
|
||||
gecached
|
||||
Hypervisor
|
||||
Asservats
|
||||
sergej
|
||||
NTLM
|
||||
gecrackt
|
||||
FileZilla
|
||||
EdgeHistory
|
||||
FirefoxWebVisit
|
||||
Artefakttyp
|
||||
HomeUsers
|
||||
hm
|
||||
BossMode
|
||||
Cooldown
|
||||
IRL
|
||||
Einlöser
|
||||
BugStalker
|
||||
libc
|
||||
Coreminer
|
||||
coreminer
|
||||
debuggees
|
||||
steckrs
|
||||
lifecycle
|
||||
Grischtoffshofener
|
||||
Kuppelverteidigungskorps
|
||||
Infrastrukturoffensive
|
||||
l'Avenir
|
||||
Staatsrat's
|
||||
publically
|
||||
Ellinor
|
||||
Thrain
|
||||
Leimann
|
||||
Grischtoff's
|
||||
Farid
|
||||
Nassar
|
||||
Casaus
|
||||
Schutzgardistin
|
||||
Rösch
|
||||
walkable
|
||||
BDSM
|
||||
Herrscher's
|
||||
ŧ
|
||||
GAI
|
||||
Waldtraut's
|
||||
QaaS
|
||||
Brousseau
|
||||
Jérôme
|
||||
Élise
|
||||
Musealisierung
|
||||
Grischtoffshofens
|
||||
Niamh
|
||||
Kuppeldecke
|
||||
Kuppelumgebung
|
||||
QuantumG
|
||||
Molekülmodellierung
|
||||
Stabilitätsfaktor
|
||||
herrscherial
|
||||
decisionmaker
|
||||
reconnections
|
||||
Grischtoffshofian
|
||||
Schutzteinheit
|
||||
Baumaßnahmen
|
||||
Grischtoffshofians
|
||||
GAX
|
||||
MSCI
|
||||
ACWI
|
||||
STMicroelectronics
|
||||
Nucleo
|
||||
STM32
|
||||
ohneweiteres/!
|
||||
STM32CubeIDE
|
||||
vor
|
||||
Möglich/!
|
||||
Systemprogrammiesprachen
|
||||
StableRef
|
||||
StableRefMut
|
||||
IntrusiveList
|
||||
datastructurs
|
||||
mut
|
||||
ptr
|
||||
NonNull
|
||||
vec
|
||||
const
|
||||
adress/!
|
||||
address
|
||||
日本語
|
||||
ICMP
|
||||
IPv4
|
||||
IPv6
|
||||
Cloudflare's
|
||||
SystemD
|
||||
ZSTD
|
||||
netpulsed
|
||||
sudo
|
||||
netpulse
|
||||
Dassault
|
||||
Kuppelstern
|
||||
Thrain's
|
||||
Kuppelstern
|
||||
Loyalistische
|
||||
Durand
|
||||
Renard
|
||||
Ellinor's
|
||||
Whitmore's
|
||||
Yevda's
|
||||
Blackwood's
|
||||
supermajority
|
||||
Ryker
|
||||
Whitmore
|
||||
Freytag
|
||||
Eisenhardt
|
||||
rechtssicherste
|
||||
votings
|
||||
einschätzung/!
|
||||
Einschätzung
|
||||
multiparadigmatische
|
||||
multiparadigmatisches
|
||||
datastructure
|
||||
wellbeing
|
||||
implementierung/!
|
||||
RFC1662
|
||||
Implementierung
|
||||
Redundanzprüfung
|
||||
RevEng
|
||||
geflasht
|
||||
HDLC
|
||||
Grischtophus
|
||||
|
|
BIN
spell/en.utf-8.add.spl
Normal file
BIN
spell/en.utf-8.add.spl
Normal file
Binary file not shown.
Loading…
Add table
Reference in a new issue