PlexSheep/neovim-confs
1
1
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

Compare commits

merge into: PlexSheep:master
Branches Tags
PlexSheep:master
PlexSheep:vscode
PlexSheep:stable
PlexSheep:getting-rid-of-nvchad
PlexSheep:mobile-synx
PlexSheep:mobile
PlexSheep:update-upstream
PlexSheep:mini
PlexSheep:minimal2
PlexSheep:rafi-fork
PlexSheep:minimal
PlexSheep:wsl
PlexSheep:v1.0.0
...
pull from: PlexSheep:minimal
Branches Tags
PlexSheep:master
PlexSheep:vscode
PlexSheep:stable
PlexSheep:getting-rid-of-nvchad
PlexSheep:mobile-synx
PlexSheep:mobile
PlexSheep:update-upstream
PlexSheep:mini
PlexSheep:minimal2
PlexSheep:rafi-fork
PlexSheep:minimal
PlexSheep:wsl
PlexSheep:v1.0.0

No commits in common. "master" and "minimal" have entirely different histories.
master ... minimal

47 changed files with 2488 additions and 3795 deletions
Show stats Expand all files Collapse all files

22
.github/workflows/stale.yml vendored
View file

@ -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
View file

@ -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
View file

@ -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

6
.stylua.toml
View file

@ -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
View file

@ -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
View file

@ -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
View file

@ -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()

92
lua/custom/autocmds.lua
View file

@ -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,
})

156
lua/custom/maps/init.lua
View file

@ -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>')

237
lua/custom/plugins/configs/lsp.lua
View file

@ -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

95
lua/custom/plugins/editing.lua
View file

@ -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,
},
}

103
lua/custom/plugins/init.lua
View file

@ -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' },
}

359
lua/custom/plugins/lsp.lua
View file

@ -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 = {},
},
}

100
lua/custom/plugins/ltex.lua
View file

@ -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,
}

164
lua/custom/plugins/telescope.lua
View file

@ -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 },
}

151
lua/custom/plugins/themes.lua
View file

@ -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,
},
}

31
lua/custom/plugins/tools.lua
View file

@ -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' },
},
}

696
lua/custom/plugins/ui.lua
View file

@ -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,
},
}

83
lua/custom/utils.lua
View file

@ -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

52
lua/kickstart/health.lua
View file

@ -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,
}

16
lua/kickstart/plugins/autopairs.lua
View file

@ -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,
}

212
lua/kickstart/plugins/debug.lua
View file

@ -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,
},
}

61
lua/kickstart/plugins/gitsigns.lua
View file

@ -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,
},
},
}

27
lua/kickstart/plugins/indent_line.lua
View file

@ -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,
},
},
}

55
lua/kickstart/plugins/lint.lua
View file

@ -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,
},
}

25
lua/kickstart/plugins/neo-tree.lua
View file

@ -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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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
View 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,
},
}

7
spell/de.utf-8.add
View file

@ -1,7 +0,0 @@
gings
Safety
NewTec
Rust
Cybersecurity
STM32
STMicroelectronics

BIN
spell/de.utf-8.add.spl
View file

Binary file not shown.

532
spell/en.utf-8.add
View file

@ -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
View file

Binary file not shown.