Compare commits

...

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

109 changed files with 3708 additions and 7583 deletions

161
.github/CONTRIBUTING.md vendored Normal file
View File

@ -0,0 +1,161 @@
# [CONTRIBUTING](https://nvchad.github.io/contribute)
## NvChad install for contributors
If you wish to contribute to NvChad, you should:
1. [create a fork on GitHub](https://docs.github.com/en/get-started/quickstart/fork-a-repo)
2. clone your fork to your machine
- For ssh:
```shell
$ git clone git@github.com:<YOUR GITHUB USERNAME>/NvChad.git ~/.config/nvim
```
- For https:
```shell
$ git clone https://github.com/<YOUR GITHUB USERNAME>/NvChad.git ~/.config/nvim
```
3. [add a new remote repo to track](https://www.atlassian.com/git/tutorials/git-forks-and-upstreams)
- this means you can push/pull as normal to your own repo, but also easily track & update from the NvChad repo
- for ssh:
```shell
$ git remote add upstream git@github.com:NvChad/NvChad.git
```
- for https:
```shell
$ git remote add upstream https://github.com/NvChad/NvChad.git
```
4. any time you create a branch to do some work, use
```shell
$ git fetch upstream && git checkout -b dev-myFEAT upstream/main
```
5. only use the **--rebase** flag to update your dev branch
- this means that there are no `Merge NvChad/main into devBranch` commits, which are to be avoided
```shell
$ git pull upstream --rebase
```
## Things to know before contributing
- When making a PR (pull request), please be very descriptive about what you've done!
- PR titles should be formatted with 'fix', 'chore' or 'feat'. ex: `feat: add new plugin`
- PRs should follow the pull request formats where applicable
- We are open to all PRs, but may decline some for a myriad of reasons. Though don't be discouraged! We'll still be open to discussions.
- PR's are always welcomed however NvChad aims to be less bloated. So PR's regarding existing plugin's enhancement and creating new features with existing plugins itself ( without adding a new plugin), bug fixes and corrections are more encouraged.
- NvChad won't keep adding more and more features (like adding new plugins most likely) as requested if they feel unneeded and aren't usable by the majority!! If you think the plugin you want to be added is very useful and many NvChaders would find it useful, then such feature's PR is welcomed!
- But adding specific features like adding config for [wakatime](https://github.com/wakatime/vim-wakatime) etc will be added in this [chad user configs](https://github.com/NvChad/NvChad/wiki/Chad-user-configs). This lets the user select the things only they want ( adding configs from extra configs ).
## How to remove or edit commits from your PR
> You may have been directed here to remove a commit such as a merge commit: `Merge NvChad/main into devBranch` from your PR
> As these commands edit your git history, you may need to **force push** with `git push origin --force`
1. Run the following:
```
$ git rebase -i HEAD~<NUMBER OF COMMITS TO GO BACK>
```
<details><summary>Example</summary>
<p>
```shell
$ git rebase -i HEAD~4
```
```shell
pick 28b2dcb statusline add lsp status
pick dad9a39 feat: Added lsp radial progress
pick 68f72f1 add clickable btn for exiting nvim
pick b281b53 avoid using q! for quitting vim
# Rebase 52b655b..b281b53 onto 52b655b (4 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# . create a merge commit using the original merge commit's
# . message (or the oneline, if no original merge commit was
# . specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out
```
</p>
</details>
2. Change the `pick` commands to whatever you wish, you may wish to `d` `drop` or `e` `edit` a commit. Then save & quit this git file to run it.
<details><summary>Example</summary>
<p>
```shell {3,4}
pick 28b2dcb statusline add lsp status
pick dad9a39 feat: Added lsp radial progress
edit 68f72f1 add clickable btn for exiting nvim
d b281b53 avoid using q! for quitting vim
# Rebase 52b655b..b281b53 onto 52b655b (4 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# . create a merge commit using the original merge commit's
# . message (or the oneline, if no original merge commit was
# . specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out
```
</p>
</details>
3. If you picked `drop` you are done, if you picked `edit` then edit your files, then run:
```shell
$ git add <files>
```
4. Once you have edited & added your files, run:
```shell
$ git rebase --continue
```
5. You will likely need to push using:
```shell
$ git push origin --force
```
## Help
For help with contributing and anything else nvChad related join the [discord](https://discord.gg/VyPxsGArXc)

3
.github/FUNDING.yml vendored Normal file
View File

@ -0,0 +1,3 @@
patreon: siduck
ko_fi: siduck
custom: ["https://www.buymeacoffee.com/siduck", "https://www.paypal.com/paypalme/siduck76"]

34
.github/ISSUE_TEMPLATE/bug_report.md vendored Normal file
View File

@ -0,0 +1,34 @@
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
<!-- Before reporting: update nvchad to the latest version,read breaking changes page,search existing issues. -->
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Desktop (please complete the following information):**
- Operating System
- Terminal
- Version of Neovim
**Additional context**
Add any other context about the problem here.

8
.github/ISSUE_TEMPLATE/config.yml vendored Normal file
View File

@ -0,0 +1,8 @@
blank_issues_enabled: false
contact_links:
- name: Wiki
url: https://github.com/siduck76/NvChad/wiki
about: "Walks you through how to use and Configure NvChad."
- name: Visit our gitter chat
url: https://gitter.im/neovim-dotfiles/community
about: "A place where we dicuss NvChad related stuff."

View File

@ -0,0 +1,23 @@
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem was.
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
**Screenshot**
Maybe a screenshot of the feature

View File

@ -0,0 +1,14 @@
Fixes Issue # (If it doesn't fix an issue then delete this line)
Features Added:
- Plugin Name (Add links if possible too)
Reasoning:
List why the feature is needed
Speed (If applicable):
Show the impact on the speed of nvChad
Other:
Anything else relevant goes here

16
.github/PULL_REQUEST_TEMPLATE/plugin.md vendored Normal file
View File

@ -0,0 +1,16 @@
(Make sure your title is either: 'fix', 'chore', or 'feat' then your title. ex: `fix: add new plugin`)
Fixes Issue # (If it doesn't fix an issue then delete this line)
Plugins Added:
- [Plugin Name](Plugin Link)
- [Plugin Name](Plugin Link)
Reasoning:
List why the plugin(s) should be added
Speed:
Show the impact on the speed of nvChad
Other:
Anything else relevant goes here

121
.github/README.md vendored Normal file
View File

@ -0,0 +1,121 @@
<h1 align="center">NvChad</h1>
<div align="center">
<a href="https://nvchad.com/">Home</a>
<span></span>
<a href="https://nvchad.com/docs/quickstart/install">Install</a>
<span></span>
<a href="https://nvchad.com/docs/contribute">Contribute</a>
<span></span>
<a href="https://github.com/NvChad/NvChad#gift_heart-support">Support</a>
<span></span>
<a href="https://nvchad.com/docs/features">Features</a>
<p></p>
</div>
<div align="center">
[![Neovim Minimum Version](https://img.shields.io/badge/Neovim-0.9.0-blueviolet.svg?style=flat-square&logo=Neovim&color=90E59A&logoColor=white)](https://github.com/neovim/neovim)
[![GitHub Issues](https://img.shields.io/github/issues/NvChad/NvChad.svg?style=flat-square&label=Issues&color=d77982)](https://github.com/NvChad/NvChad/issues)
[![Discord](https://img.shields.io/discord/869557815780470834?color=738adb&label=Discord&logo=discord&logoColor=white&style=flat-square)](https://discord.gg/gADmkJb9Fb)
[![Matrix](https://img.shields.io/badge/Matrix-40aa8b.svg?style=flat-square&logo=Matrix&logoColor=white)](https://matrix.to/#/#nvchad:matrix.org)
[![Telegram](https://img.shields.io/badge/Telegram-blue.svg?style=flat-square&logo=Telegram&logoColor=white)](https://t.me/DE_WM)
</div>
## Showcase
<img src="https://nvchad.com/features/nvdash.webp">
<img src="https://nvchad.com/banner.webp">
<img src="https://nvchad.com/screenshots/onedark.webp">
<img src="https://nvchad.com/screenshots/rxyhn1.webp">
## What is it?
- NvChad is a neovim config written in lua aiming to provide a base configuration with very beautiful UI and blazing fast startuptime (around 0.02 secs ~ 0.07 secs). We tweak UI plugins such as telescope, nvim-tree, bufferline etc well to provide an aesthetic UI experience.
- Lazy loading is done 93% of the time meaning that plugins will not be loaded by default, they will be loaded only when required also at specific commands, events etc. This lowers the startuptime and it was like 0.07~ secs tested on an old pentium machine 1.4ghz + 4gb ram & HDD.
- NvChad isn't a framework! It's supposed to be used as a "base" config, so users can tweak the defaults well, and also remove the things they don't like in the default config and build their config on top of it. Users can tweak the entire default config while staying in their custom config (lua/custom dir). This is the control center of the user's config and gitignored so the users can stay up-to-date with NvChad's latest config (main branch) while still controlling it with their chadrc (file that controls entire custom dir).
## Theme Showcase
<details><summary> <b>Images (Click to expand!)</b></summary>
![4 themes](https://nvchad.com/screenshots/four_Themes.webp)
![radium 1](https://nvchad.com/screenshots/radium1.webp)
![radium 2](https://nvchad.com/screenshots/radium2.webp)
![radium 3](https://nvchad.com/screenshots/radium3.webp)
(Note: these are just 4-5 themes, NvChad has around 56 themes)
</details>
## UI related plugins used
<details><summary> <b>Images (Click to expand!)</b></summary>
<h3> Nvim-tree.lua </h3>
Fast file tree:
<kbd><img src="https://nvchad.com/features/nvimtree.webp"></kbd>
<h3> Telescope-nvim </h3>
A fuzzy file finder, picker, sorter, previewer and much more:
<kbd><img src="https://nvchad.com/features/telescope.webp"></kbd>
<h3> Our own statusline written from scratch </h3>
[NvChad UI](https://github.com/NvChad/ui)
<kbd><img src="https://nvchad.com/features/statuslines.webp"></kbd>
<h3> Tabufline (our own pertab bufferline) </h3>
<kbd><img src="https://nvchad.com/features/tabufline.webp"></kbd>
- Here's a [video](https://www.youtube.com/watch?v=V_9iJ96U_k8&ab_channel=siduck) that showcases it.
<h3> NvCheatsheet ( our UI Plugin ) </h3>
<kbd> <img src="https://nvchad.com/features/nvcheatsheet.webp"/></kbd>
</details>
## Plugins list
- Inbuilt terminal toggling & management with [Nvterm](https://github.com/NvChad/nvterm)
- Lightweight & performant ui plugin with [NvChad UI](https://github.com/NvChad/ui) It provides statusline modules, tabufline ( tabs + buffer manager) , beautiful cheatsheets, NvChad updater, hide & unhide terminal buffers, theme switcher and much more!
- File navigation with [nvim-tree.lua](https://github.com/kyazdani42/nvim-tree.lua)
- Beautiful and configurable icons with [nvim-web-devicons](https://github.com/kyazdani42/nvim-web-devicons)
- Git diffs and more with [gitsigns.nvim](https://github.com/lewis6991/gitsigns.nvim)
- NeoVim Lsp configuration with [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig) and [mason.nvim](https://github.com/williamboman/mason.nvim)
- Autocompletion with [nvim-cmp](https://github.com/hrsh7th/nvim-cmp)
- File searching, previewing image and text files and more with [telescope.nvim](https://github.com/nvim-telescope/telescope.nvim).
- Syntax highlighting with [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter)
- Autoclosing braces and html tags with [nvim-autopairs](https://github.com/windwp/nvim-autopairs)
- Indentlines with [indent-blankline.nvim](https://github.com/lukas-reineke/indent-blankline.nvim)
- Useful snippets with [friendly snippets](https://github.com/rafamadriz/friendly-snippets) + [LuaSnip](https://github.com/L3MON4D3/LuaSnip).
- Popup mappings keysheet [whichkey.nvim](https://github.com/folke/which-key.nvim)
## History
- I (@siduck i.e creator of NvChad) in my initial days of learning to program wanted a lightweight IDE for writing code, I had a very low end system which was like 1.4ghz pentium + 4gb ram & HDD. I was into web dev stuff so many suggested me to use vscode but that thing was very heavy on my system, It took more ram than my browser! ( minimal ungoogled chromium ) so I never tried it again, sublime text was nice but the fear of using proprietary software XD for a linux user bugged me a lot. Then I tried doom-emacs which looked pretty but it was slow and I was lost within its docs, I tried lunarvim but too lazy to read the docs. Doom-emacs and lunarvim inspired me to make a config which is the prettiest + very fast and simple.
- I'm decent at ricing i.e customizing system and making it look pretty so I posted my neovim rice on [neovim subreddit](https://www.reddit.com/r/neovim/comments/m3xl4f/neovim_rice/), my neovim-dotfiles github repo blew up and then I had to come up with a name, I was amazed by the chad meme lol so I put NvChad as the name, the chad word in here doesnt literally mean the chad guy but in the sense such as chad linux vs windows i.e meaning superior, best etc. NvChad was made for my personal use but it gained some popularity which inspired me to make a public config i.e config usable by many and less hassle to update as everyone's going to use the same base config (NvChad) with their custom modifications (which are gitignored so that wont mess up), without the custom config stuff users would have to keep a track of every commit and copy paste git diffs to manually update nvchad.
## :gift_heart: Support
If you like NvChad and would like to support & appreciate it via donation then I'll gladly accept it.
[![kofi](https://img.shields.io/badge/Ko--fi-F16061?style=for-the-badge&logo=ko-fi&logoColor=white)](https://ko-fi.com/siduck)
[![paypal](https://img.shields.io/badge/PayPal-00457C?style=for-the-badge&logo=paypal&logoColor=white)](https://paypal.me/siduck13)
[![buymeacoffee](https://img.shields.io/badge/Buy_Me_A_Coffee-FFDD00?style=for-the-badge&logo=buy-me-a-coffee&logoColor=black)](https://www.buymeacoffee.com/siduck)
[![patreon](https://img.shields.io/badge/Patreon-F96854?style=for-the-badge&logo=patreon&logoColor=white)](https://www.patreon.com/siduck)
## Credits
- [Elianiva](https://github.com/elianiva) helped me with NeoVim Lua related issues many times, NvChad wouldn't exist without his help at all as he helped me in my initial neovim journey!
- @lorvethe for making the beautiful NvChad logo.

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

@ -0,0 +1,22 @@
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 Normal file
View File

@ -0,0 +1,21 @@
# 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 .

9
.gitignore vendored
View File

@ -1 +1,10 @@
plugin
ftplugin
syntax
coc-settings.json
.luarc.json
lazy-lock.json lazy-lock.json
after
**/.DS_Store
lua/custom/secret
lua/custom/configs/secret

6
.stylua.toml Normal file
View File

@ -0,0 +1,6 @@
column_width = 160
line_endings = "Unix"
indent_type = "Spaces"
indent_width = 2
quote_style = "AutoPreferSingle"
call_parentheses = "None"

19
LICENSE.md Normal file
View File

@ -0,0 +1,19 @@
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 Normal file
View File

@ -0,0 +1,229 @@
# 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>

244
init.lua
View File

@ -1,50 +1,206 @@
-- rafi Neovim entry-point vim.g.mapleader = ' '
-- https://git.cscherr.de/PlexSheep/neovim-conf vim.g.maplocalleader = ';'
-- vim.g.python3_host_prog = '/usr/bin/python3'
local config = require('plex.config') vim.opt.mouse = 'a' -- mouse does annoying things for me if it's not 'a'
config.ensure_lazy() 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
-- Start lazy.nvim plugin manager. -- Tabs and Indents
require('lazy').setup(vim.tbl_extend('keep', config.user_lazy_opts(), { -- ===
spec = { vim.opt.textwidth = 80 -- Text width maximum chars before wrapping
{ import = 'plex.plugins' }, vim.opt.tabstop = 4 -- The number of spaces a tab is
{ import = 'plex.plugins.extras.coding' }, vim.opt.shiftwidth = 4 -- Number of spaces to use in auto(indent)
{ import = 'plex.plugins.extras.ui' }, vim.opt.smarttab = true -- Tab insert blanks according to 'shiftwidth'
{ import = 'plex.plugins.extras.treesitter' }, vim.opt.autoindent = true -- Use same indenting on new lines
{ import = 'plex.plugins.extras.formatting' }, vim.opt.smartindent = true -- Smart autoindenting on new lines
{ import = 'plex.plugins.extras.editor' }, vim.opt.shiftround = true -- Round indent to multiple of 'shiftwidth'
{ import = 'plex.plugins.extras.org' },
{ import = 'plex.plugins.extras.lang.go' },
{ import = 'plex.plugins.extras.lang.cpp' }, -- also does C and rust
{ import = 'plex.plugins.extras.lang.json' },
{ import = 'plex.plugins.extras.lang.python' },
{ import = 'plex.plugins.extras.lang.yaml' },
-- This will load a custom user lua/plugins.lua or lua/plugins/* -- Timing
config.has_user_plugins() and { import = 'plugins' } or nil, -- ===
}, vim.opt.ttimeout = true
concurrency = vim.loop.available_parallelism() * 2, vim.opt.timeoutlen = 500 -- Time out on mappings
defaults = { lazy = true, version = false }, vim.opt.ttimeoutlen = 10 -- Time out on key codes
dev = { path = config.path_join(vim.fn.stdpath('config'), 'dev') }, vim.opt.updatetime = 250 -- Idle time to write swap and trigger CursorHold
install = { missing = true, colorscheme = {} },
checker = { enabled = true, notify = false }, -- Searching
change_detection = { notify = false }, -- ===
ui = { border = 'rounded' }, vim.opt.ignorecase = true -- Search ignoring case
diff = { cmd = 'terminal_git' }, vim.opt.smartcase = true -- Keep case when searching with *
performance = { vim.opt.infercase = true -- Adjust case in insert completion mode
rtp = { vim.opt.incsearch = true -- Incremental search
disabled_plugins = { vim.opt.hlsearch = true -- highlight searched stuff
'gzip',
'vimballPlugin', -- Formatting
'matchit', -- ===
'matchparen',
'2html_plugin', vim.opt.wrap = false -- No wrap by default
'tarPlugin', vim.opt.linebreak = true -- Break long lines at 'breakat'
'tutor', vim.opt.breakat = '\\ \\ ;:,!?' -- Long lines break chars
'zipPlugin', 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 = true -- 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'
-- 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 = '💤 ',
}, },
}, },
}, })
}))
config.setup() require 'kickstart.health'
-- The line beneath this is called `modeline`. See `:help modeline`
-- vim: ts=2 sts=2 sw=2 et

106
lua/custom/autocmds.lua Normal file
View File

@ -0,0 +1,106 @@
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,
})
-- pin main.typ for typst projects
vim.api.nvim_create_autocmd('FileType', {
group = augroup,
pattern = {
'typst',
},
callback = function()
-- pin the main file
vim.lsp.buf.execute_command { command = 'tinymist.pinMain', arguments = { vim.api.nvim_buf_get_name(0) } }
-- -- unpin the main file
-- vim.lsp.buf.execute_command { command = 'tinymist.pinMain', arguments = { nil } }
end,
})

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

@ -0,0 +1,156 @@
--------------------------------------------------------------------------------
-- 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 = '[Q]uit the current window' })
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>')

View File

@ -0,0 +1,260 @@
-- 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')
-- 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.
local capabilities = vim.lsp.protocol.make_client_capabilities()
capabilities = vim.tbl_deep_extend('force', capabilities, require('cmp_nvim_lsp').default_capabilities())
-- 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 = {
-- clangd = {},
-- gopls = {},
-- pyright = {},
-- rust_analyzer = {},
-- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs
--
-- Some languages (like typescript) have entire language plugins that can be useful:
-- https://github.com/pmizio/typescript-tools.nvim
--
-- But for many setups, the LSP (`tsserver`) will work just fine
-- tsserver = {},
--
tinymist = {},
html = {},
cssls = {},
clangd = {},
pyright = {},
bashls = {},
yamlls = {},
texlab = {},
rust_analyzer = {
settings = {
['rust-analyzer'] = {
check = {
command = 'clippy',
},
imports = {
granularity = {
group = 'module',
},
prefix = 'self',
},
cargo = {
features = 'all',
buildScripts = {
enable = true,
},
},
procMacro = {
enable = true,
},
},
},
},
ltex = {
use_spellfile = true,
autostart = false,
filetypes = { 'latex', 'tex', 'markdown', 'typst' },
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 = {
'bibtex',
'tex',
'typst',
'latex',
'gitcommit',
'markdown',
'org',
'restructuredtext',
'rsweave',
'quarto',
'rmd',
'context',
-- "html",
-- "xhtml",
},
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
},
},
languageToolOrg = {
apiKey = require 'custom.secret.languagetool',
username = 'accounts@cscherr.de',
languageToolHttpServerUrl = 'https://api.languagetoolplus.com/v2/',
},
languageToolHttpServerUrl = 'https://api.languagetoolplus.com/v2/',
},
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, {
'stylua',
'typstfmt',
})
require('mason-tool-installer').setup { ensure_installed = ensure_installed }
require('mason-lspconfig').setup {
handlers = {
function(server_name)
local server = servers[server_name] or {}
-- 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,
},
}

View File

@ -0,0 +1,95 @@
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,
},
}

View File

@ -0,0 +1,92 @@
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)
-- 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 }
return {
timeout_ms = 500,
lsp_fallback = not disable_filetypes[vim.bo[bufnr].filetype],
}
end,
formatters_by_ft = {
lua = { 'stylua' },
-- 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 = { { "prettierd", "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' },
}

328
lua/custom/plugins/lsp.lua Normal file
View File

@ -0,0 +1,328 @@
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
}

View File

@ -0,0 +1,163 @@
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 },
},
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>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>fd', builtin.diagnostics, { desc = '[D]iagnostics' })
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 },
}

View File

@ -0,0 +1,122 @@
return {
{
'zaldih/themery.nvim',
priority = 1000, -- Make sure to load this before all the other start plugins.
cmd = 'Themery',
keys = {
{ ';ft', '<cmd> Themery <cr>', desc = '[F]ind [T]heme' },
},
init = function()
require 'settings.theme'
end,
config = function()
require('themery').setup {
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"
]],
},
-- 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"
]],
},
},
themeConfigFile = '~/.config/nvim/lua/settings/theme.lua',
livePreview = true, -- Apply theme while browsing. Default to true.
}
end,
},
'folke/tokyonight.nvim',
'rebelot/kanagawa.nvim',
{ 'zenbones-theme/zenbones.nvim', dependencies = { 'rktjmp/lush.nvim' } },
}

View File

@ -0,0 +1,13 @@
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',
},
},
}

706
lua/custom/plugins/ui.lua Normal file
View File

@ -0,0 +1,706 @@
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' },
-- 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>fdt', '<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,
},
{
'iamcco/markdown-preview.nvim',
cmd = { 'MarkdownPreviewToggle', 'MarkdownPreview', 'MarkdownPreviewStop' },
ft = { 'markdown' },
build = function()
vim.fn['mkdp#util#install']()
end,
config = function()
-- Ugly fix for wsl not finding my browser
-- I HATE windows
vim.g.mkdp_echo_preview_url = 1
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,
},
{
'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.colorcolumn = '0'
vim.opt_local.spell = false
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,
},
}

84
lua/custom/utils.lua Normal file
View File

@ -0,0 +1,84 @@
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) .. "'"
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 Normal file
View File

@ -0,0 +1,52 @@
--[[
--
-- 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,
}

View File

@ -0,0 +1,16 @@
-- 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,
}

View File

@ -0,0 +1,212 @@
-- 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,
},
}

View File

@ -0,0 +1,61 @@
-- 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,
},
},
}

View File

@ -0,0 +1,27 @@
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,
},
},
}

View File

@ -0,0 +1,55 @@
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,
},
}

View File

@ -0,0 +1,25 @@
-- 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',
},
},
},
},
}

View File

@ -1,168 +0,0 @@
-- 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',
})
-- Caution: Causes Errors?
-- -- Open Neotree in new tabs
-- vim.api.nvim_create_autocmd({'TabNewEntered' }, {
-- group = augroup('automatic_neotree'),
-- callback = function()
-- vim.cmd('Neotree')
-- end,
-- })
-- 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 = { 'latex', 'tex' },
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,
})

View File

@ -1,318 +0,0 @@
-- 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 = 'kanagawa',
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

View File

@ -1,372 +0,0 @@
-- 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
-- See vim-smoothie
--map({ 'n', 'x' }, 'K', "<C-u>")
--map({ 'n', 'x' }, 'J', "<C-d>")
-- Easier line-wise movement
map({'n', 'v'}, 'H', '<HOME>')
map({'n', 'v'}, 'L', '<END>')
-- 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', '<leader>cj', function ()
vim.diagnostic.goto_next()
end, { desc = 'go to next diagnostic'})
map('n', '<leader>ck', 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')
-- move screen and line up
map('n', '<C-k>', '<C-y>k')
map('n', '<C-j>', '<C-e>j')
-- 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>uf', require('plex.plugins.lsp.format').toggle, { desc = 'Toggle format on Save' })
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' })
-- Show treesitter nodes under cursor
-- highlights under cursor
if vim.fn.has('nvim-0.9') == 1 then
map('n', '<Leader>ui', vim.show_pos, { desc = 'Show Treesitter Node' })
end
-- 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>w%', '<cmd>split<CR>', { desc = 'Split window horizontally' })
map('n', '<leader>w"', '<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' })

View File

@ -1,256 +0,0 @@
-- 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 = 3
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"

View File

@ -1,8 +0,0 @@
local M = {}
---@param opts? RafiConfig
function M.setup(opts)
require('plex.config').setup(opts)
end
return M

View File

@ -1,210 +0,0 @@
-- 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

View File

@ -1,140 +0,0 @@
-- 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

View File

@ -1,94 +0,0 @@
-- 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

View File

@ -1,141 +0,0 @@
-- 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

View File

@ -1,108 +0,0 @@
-- 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

View File

@ -1,122 +0,0 @@
-- 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

View File

@ -1,385 +0,0 @@
-- Plugins: Coding
-- https://github.com/rafi/vim-config
return {
-----------------------------------------------------------------------------
{
'hrsh7th/nvim-cmp',
event = 'InsertEnter',
dependencies = {
'hrsh7th/cmp-nvim-lsp',
'hrsh7th/cmp-buffer',
'hrsh7th/cmp-path',
'hrsh7th/cmp-emoji',
{ 'saadparwaiz1/cmp_luasnip', dependencies = 'L3MON4D3/LuaSnip' },
'andersevenrud/cmp-tmux',
},
opts = function()
local cmp = require('cmp')
local defaults = require('cmp.config.default')()
local luasnip = require('luasnip')
local function has_words_before()
if vim.bo.buftype == 'prompt' then
return false
end
local line, col = unpack(vim.api.nvim_win_get_cursor(0))
-- stylua: ignore
return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match('%s') == nil
end
return {
preselect = cmp.PreselectMode.None,
sorting = defaults.sorting,
experimental = {
ghost_text = {
hl_group = 'Comment',
},
},
snippet = {
expand = function(args)
require('luasnip').lsp_expand(args.body)
end,
},
sources = cmp.config.sources({
{ name = 'nvim_lsp', priority = 50 },
{ name = 'path', priority = 40 },
{ name = 'luasnip', priority = 30 },
}, {
{ name = 'buffer', priority = 50, keyword_length = 3 },
{ name = 'emoji', insert = true, priority = 20 },
{
name = 'tmux',
priority = 10,
keyword_length = 3,
option = { all_panes = true, label = 'tmux' },
},
}),
mapping = cmp.mapping.preset.insert({
-- <CR> accepts currently selected item.
-- Set `select` to `false` to only confirm explicitly selected items.
['<CR>'] = cmp.mapping({
i = function(fallback)
if cmp.visible() and cmp.get_active_entry() then
cmp.confirm({ select = false })
else
fallback()
end
end,
s = cmp.mapping.confirm({
select = true,
behavior = cmp.ConfirmBehavior.Replace,
}),
-- Do not set command mode, it will interfere with noice popmenu.
}),
['<S-CR>'] = cmp.mapping.confirm({
behavior = cmp.ConfirmBehavior.Replace,
select = true,
}),
['<C-Space>'] = cmp.mapping.complete(),
['<C-n>'] = cmp.mapping.select_next_item(),
['<C-p>'] = cmp.mapping.select_prev_item(),
['<C-d>'] = cmp.mapping.select_next_item({ count = 5 }),
['<C-u>'] = cmp.mapping.select_prev_item({ count = 5 }),
['<C-f>'] = cmp.mapping.scroll_docs(4),
['<C-b>'] = cmp.mapping.scroll_docs(-4),
['<C-c>'] = function(fallback)
cmp.close()
fallback()
end,
['<Tab>'] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_next_item()
elseif luasnip.jumpable(1) then
luasnip.jump(1)
elseif has_words_before() then
cmp.complete()
else
fallback()
end
end, { 'i', 's' }),
['<S-Tab>'] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_prev_item()
elseif luasnip.jumpable(-1) then
luasnip.jump(-1)
else
fallback()
end
end, { 'i', 's' }),
}),
formatting = {
format = function(entry, vim_item)
-- Prepend with a fancy icon from config lua/plex/config/init.lua
local icons = require('plex.config').icons
if entry.source.name == 'git' then
vim_item.kind = icons.git
else
local symbol = icons.kinds[vim_item.kind]
if symbol ~= nil then
vim_item.kind = symbol .. ' ' .. vim_item.kind
end
end
return vim_item
end,
},
}
end,
},
-----------------------------------------------------------------------------
{
'L3MON4D3/LuaSnip',
event = 'InsertEnter',
dependencies = { 'rafamadriz/friendly-snippets' },
build = (not jit.os:find('Windows'))
and "echo 'jsregexp is optional, so not a big deal if it fails to build'; make install_jsregexp"
or nil,
-- stylua: ignore
keys = {
{
'<C-l>',
function() require('luasnip').expand_or_jump() end,
mode = { 'i', 's' },
},
},
opts = {
-- Don't store snippet history for less overhead
history = false,
-- Event on which to check for exiting a snippet's region
region_check_events = 'InsertEnter',
delete_check_events = 'InsertLeave',
ft_func = function()
return vim.split(vim.bo.filetype, '.', { plain = true })
end,
},
config = function(_, opts)
require('luasnip').setup(opts)
require('luasnip.loaders.from_vscode').lazy_load()
require('luasnip.loaders.from_lua').load({ paths = './snippets' })
vim.api.nvim_create_user_command('LuaSnipEdit', function()
require('luasnip.loaders.from_lua').edit_snippet_files()
end, {})
end,
},
-----------------------------------------------------------------------------
{
'ziontee113/SnippetGenie',
event = 'InsertEnter',
dependencies = 'L3MON4D3/LuaSnip',
opts = {
snippets_directory = vim.fn.stdpath('config') .. '/snippets',
},
},
-----------------------------------------------------------------------------
{
'danymat/neogen',
-- stylua: ignore
keys = {
{
'<leader>cc',
function() require('neogen').generate({}) end,
desc = 'Neogen Comment',
},
},
opts = { snippet_engine = 'luasnip' },
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.pairs',
event = 'VeryLazy',
opts = {},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.surround',
enabled = false,
-- stylua: ignore
keys = function(_, keys)
-- Populate the keys based on the user's options
local plugin = require('lazy.core.config').spec.plugins['mini.surround']
local opts = require('lazy.core.plugin').values(plugin, 'opts', false)
local mappings = {
{ opts.mappings.add, desc = 'Add surrounding', mode = { 'n', 'x', 'v' } },
{ opts.mappings.delete, desc = 'Delete surrounding', mode = { 'n', 'x', 'v' } },
{ opts.mappings.find, desc = 'Find right surrounding', mode = { 'n', 'x', 'v' } },
{ opts.mappings.find_left, desc = 'Find left surrounding', mode = { 'n', 'x', 'v' } },
{ opts.mappings.highlight, desc = 'Highlight surrounding', mode = { 'n', 'x', 'v' } },
{ opts.mappings.replace, desc = 'Replace surrounding', mode = { 'n', 'x', 'v' } },
{ opts.mappings.update_n_lines, desc = 'Update `MiniSurround.config.n_lines`', mode = { 'n', 'x', 'v' } },
}
mappings = vim.tbl_filter(function(m)
return m[1] and #m[1] > 0
end, mappings)
return vim.list_extend(mappings, keys)
end,
opts = {
mappings = {
add = '<leader>sa', -- Add surrounding in Normal and Visual modes
delete = '<leader>sd', -- Delete surrounding
find = '<leader>sf', -- Find surrounding (to the right)
find_left = '<leader>sF', -- Find surrounding (to the left)
highlight = '<leader>sh', -- Highlight surrounding
replace = '<leader>cs', -- Replace surrounding
update_n_lines = '<leader>su', -- Update `n_lines`
},
},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.comment',
event = 'VeryLazy',
dependencies = { 'JoosepAlviste/nvim-ts-context-commentstring' },
keys = {
{ '<Leader>v', 'gcc', remap = true, silent = true, mode = 'n' },
{ '<Leader>v', 'gc', remap = true, silent = true, mode = 'x' },
},
opts = {
options = {
custom_commentstring = function()
return require('ts_context_commentstring.internal').calculate_commentstring()
or vim.bo.commentstring
end,
},
},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.trailspace',
event = { 'BufReadPost', 'BufNewFile' },
opts = {},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.ai',
event = 'VeryLazy',
dependencies = { 'nvim-treesitter/nvim-treesitter-textobjects' },
opts = function()
local ai = require('mini.ai')
return {
n_lines = 500,
-- stylua: ignore
custom_textobjects = {
o = ai.gen_spec.treesitter({
a = { '@block.outer', '@conditional.outer', '@loop.outer' },
i = { '@block.inner', '@conditional.inner', '@loop.inner' },
}, {}),
},
}
end,
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.splitjoin',
keys = {
{
'<leader>sj',
'<cmd>lua MiniSplitjoin.join()<CR>',
mode = { 'n', 'x' },
desc = 'Join arguments',
},
{
'<leader>sk',
'<cmd>lua MiniSplitjoin.split()<CR>',
mode = { 'n', 'x' },
desc = 'Split arguments',
},
},
opts = {
mappings = { toggle = '' },
},
},
-----------------------------------------------------------------------------
{
'AndrewRadev/linediff.vim',
cmd = { 'Linediff', 'LinediffAdd' },
keys = {
{ '<Leader>mdf', ':Linediff<CR>', mode = 'x', desc = 'Line diff' },
{ '<Leader>mda', ':LinediffAdd<CR>', mode = 'x', desc = 'Line diff add' },
{ '<Leader>mds', '<cmd>LinediffShow<CR>', desc = 'Line diff show' },
{ '<Leader>mdr', '<cmd>LinediffReset<CR>', desc = 'Line diff reset' },
},
},
-----------------------------------------------------------------------------
{
'AndrewRadev/dsf.vim',
-- stylua: ignore
keys = {
{ 'dsf', '<Plug>DsfDelete', noremap = true, desc = 'Delete Surrounding Function' },
{ 'csf', '<Plug>DsfChange', noremap = true, desc = 'Change Surrounding Function' },
},
init = function()
vim.g.dsf_no_mappings = 1
end,
},
-----------------------------------------------------------------------------
{
-- TODO:
-- make debugging for C. Cpp, Rust, Python work
'mfussenegger/nvim-dap',
keys = {
{
'<leader>db',
'<cmd>lua require\'dap\'.toggle_breakpoint()<CR>',
mode = { 'n', 'x' },
desc = 'Debugging: Toggle breakpoint',
},
{
'<leader>dc',
'<cmd>lua require\'dap\'.continue()<CR>',
mode = { 'n', 'x' },
desc = 'Debugging: Start or continue debug session',
},
{
'<leader>dsi',
'<cmd>lua require\'dap\'.step_into()<CR>',
mode = { 'n', 'x' },
desc = 'Debugging: Step into code',
},
{
'<leader>dso',
'<cmd>lua require\'dap\'.step_over()<CR>',
mode = { 'n', 'x' },
desc = 'Debugging: Step over code',
},
{
'<leader>dr',
'<cmd>lua require\'dap\'.repl.open()<CR>',
mode = { 'n', 'x' },
desc = 'Debugging: repl Menu',
},
{
'<leader>dms',
function()
local widgets = require('dap.ui.widgets')
local my_sidebar = widgets.sidebar(widgets.scopes)
my_sidebar.open()
end,
mode = { 'n', 'x' },
desc = 'Debugging: Menu scopes',
},
{
'<leader>dmf',
function()
local widgets = require('dap.ui.widgets')
local my_sidebar = widgets.sidebar(widgets.frames)
my_sidebar.open()
end,
mode = { 'n', 'x' },
desc = 'Debugging: Menu frames',
},
},
},
}

View File

@ -1,93 +0,0 @@
return {
{ 'rafi/neo-hybrid.vim', priority = 100, lazy = false },
{ 'rafi/awesome-vim-colorschemes', lazy = false },
{ 'AlexvZyl/nordic.nvim' },
{ 'folke/tokyonight.nvim', opts = { style = 'night' } },
{ 'rebelot/kanagawa.nvim' },
{ 'olimorris/onedarkpro.nvim' },
{ 'EdenEast/nightfox.nvim' },
{ 'nyoom-engineering/oxocarbon.nvim' },
{
'catppuccin/nvim',
lazy = true,
name = 'catppuccin',
opts = {
flavour = 'latte', -- latte, frappe, macchiato, mocha
dim_inactive = { enabled = false },
integrations = {
alpha = true,
cmp = true,
flash = true,
gitsigns = true,
illuminate = true,
indent_blankline = { enabled = true },
lsp_trouble = true,
markdown = true,
mason = true,
mini = true,
native_lsp = {
enabled = true,
virtual_text = {
errors = { 'italic' },
hints = { 'italic' },
warnings = { 'italic' },
information = { 'italic' },
},
underlines = {
errors = { 'undercurl' },
hints = { 'undercurl' },
warnings = { 'undercurl' },
information = { 'undercurl' },
},
inlay_hints = {
background = true,
},
},
navic = { enabled = true },
neogit = true,
neotest = true,
neotree = true,
noice = true,
notify = true,
semantic_tokens = true,
symbols_outline = true,
treesitter_context = true,
telescope = { enabled = true },
treesitter = true,
which_key = true,
},
},
},
{
'rebelot/kanagawa.nvim',
lazy = false,
name = 'kanagawa',
config = function()
require('kanagawa').setup({
compile = true, -- enable compiling the colorscheme
undercurl = true, -- enable undercurls
commentStyle = { italic = false },
functionStyle = {},
keywordStyle = { bold = true },
statementStyle = { bold = true },
typeStyle = {},
transparent = false, -- do not set background color
dimInactive = false, -- dim inactive window `:h hl-NormalNC`
terminalColors = true, -- define vim.g.terminal_color_{0,17}
colors = { -- add/modify theme and palette colors
palette = {},
theme = { wave = {}, lotus = {}, dragon = {}, all = {} },
},
overrides = function(colors) -- add/modify highlights
return {}
end,
theme = "dragon", -- Load "wave" theme when 'background' option is not set
background = { -- map the value of 'background' option to a theme
dark = "wave", -- try "dragon" !
light = "lotus"
},
})
end
},
}

View File

@ -1,6 +0,0 @@
require('plex.config').init()
return {
{ 'folke/lazy.nvim', version = '*' },
{ 'nvim-lua/plenary.nvim', lazy = false },
}

View File

@ -1,529 +0,0 @@
-- Plugins: Editor
-- https://github.com/rafi/vim-config
local is_windows = vim.loop.os_uname().sysname == 'Windows_NT'
return {
-----------------------------------------------------------------------------
{ 'nmac427/guess-indent.nvim', lazy = false, priority = 50, config = true },
{ 'tweekmonster/helpful.vim', cmd = 'HelpfulVersion' },
{ 'lambdalisue/suda.vim', lazy = false, event = 'BufRead' },
-----------------------------------------------------------------------------
{
'christoomey/vim-tmux-navigator',
lazy = false,
cond = not is_windows,
-- stylua: ignore
keys = {
{ '<C-h>', '<cmd>TmuxNavigateLeft<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to left pane' },
{ '<C-j>', '<cmd>TmuxNavigateDown<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to lower pane' },
{ '<C-k>', '<cmd>TmuxNavigateUp<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to upper pane' },
{ '<C-l>', '<cmd>TmuxNavigateRight<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to right pane' },
},
init = function()
vim.g.tmux_navigator_no_mappings = true
end,
},
-----------------------------------------------------------------------------
{
'olimorris/persisted.nvim',
enabled = true,
event = 'VimEnter',
priority = 1000,
opts = {
autoload = false,
follow_cwd = false,
ignored_dirs = { '/usr', '/opt', '~/.cache', vim.env.TMPDIR or '/tmp' },
},
config = function(_, opts)
if vim.g.in_pager_mode or vim.env.GIT_EXEC_PATH ~= nil then
-- Do not autoload if stdin has been provided, or git commit session.
opts.autoload = false
opts.autosave = false
end
require('persisted').setup(opts)
end,
init = function()
-- Detect if stdin has been provided.
vim.g.in_pager_mode = false
vim.api.nvim_create_autocmd('StdinReadPre', {
group = vim.api.nvim_create_augroup('plex_persisted', {}),
callback = function()
vim.g.in_pager_mode = true
end,
})
-- Close all floats before loading a session. (e.g. Lazy.nvim)
vim.api.nvim_create_autocmd('User', {
group = 'plex_persisted',
pattern = 'PersistedLoadPre',
callback = function()
for _, win in pairs(vim.api.nvim_tabpage_list_wins(0)) do
if vim.api.nvim_win_get_config(win).zindex then
vim.api.nvim_win_close(win, false)
end
end
end,
})
-- Close all plugin owned buffers before saving a session.
vim.api.nvim_create_autocmd('User', {
pattern = 'PersistedSavePre',
group = 'plex_persisted',
callback = function()
-- Detect if window is owned by plugin by checking buftype.
local current_buffer = vim.api.nvim_get_current_buf()
for _, win in ipairs(vim.fn.getwininfo()) do
local buftype = vim.bo[win.bufnr].buftype
if buftype ~= '' and buftype ~= 'help' then
-- Delete plugin owned window buffers.
if win.bufnr == current_buffer then
-- Jump to previous window if current window is not a real file
vim.cmd.wincmd('p')
end
vim.api.nvim_buf_delete(win.bufnr, {})
end
end
end,
})
-- Before switching to a different session using Telescope, save and stop
-- current session to avoid previous session to be overwritten.
vim.api.nvim_create_autocmd('User', {
pattern = 'PersistedTelescopeLoadPre',
group = 'plex_persisted',
callback = function()
require('persisted').save()
require('persisted').stop()
end,
})
-- After switching to a different session using Telescope, start it so it
-- will be auto-saved.
vim.api.nvim_create_autocmd('User', {
pattern = 'PersistedTelescopeLoadPost',
group = 'plex_persisted',
callback = function(session)
require('persisted').start()
print('Started session ' .. session.data.name)
end,
})
end,
},
-----------------------------------------------------------------------------
{
'RRethy/vim-illuminate',
event = { 'BufReadPost', 'BufNewFile' },
opts = {
delay = 200,
under_cursor = false,
modes_allowlist = { 'n', 'no', 'nt' },
filetypes_denylist = {
'DiffviewFileHistory',
'DiffviewFiles',
'SidebarNvim',
'fugitive',
'git',
'minifiles',
'neo-tree',
},
},
keys = {
{ ']]', desc = 'Next Reference' },
{ '[[', desc = 'Prev Reference' },
},
config = function(_, opts)
require('illuminate').configure(opts)
local function map(key, dir, buffer)
vim.keymap.set('n', key, function()
require('illuminate')['goto_' .. dir .. '_reference'](false)
end, {
desc = dir:sub(1, 1):upper() .. dir:sub(2) .. ' Reference',
buffer = buffer,
})
end
map(']]', 'next')
map('[[', 'prev')
-- also set it after loading ftplugins, since a lot overwrite [[ and ]]
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_illuminate', {}),
callback = function()
local buffer = vim.api.nvim_get_current_buf()
map(']]', 'next', buffer)
map('[[', 'prev', buffer)
end,
})
end,
},
-----------------------------------------------------------------------------
{
'mbbill/undotree',
cmd = 'UndotreeToggle',
keys = {
{ '<Leader>gu', '<cmd>UndotreeToggle<CR>', desc = 'Undo Tree' },
},
},
-----------------------------------------------------------------------------
{
-- NOTE: This is leap for selecting things!
'ggandor/flit.nvim',
enabled = true,
keys = function()
---@type LazyKeys[]
local ret = {}
for _, key in ipairs({ 'f', 'F', 't', 'T' }) do
ret[#ret + 1] = { key, mode = { 'n', 'x', 'o' }, desc = key }
end
return ret
end,
opts = { labeled_modes = 'nx' },
},
-----------------------------------------------------------------------------
{
'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>wgl', '<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,
},
-----------------------------------------------------------------------------
{
'kana/vim-niceblock',
-- stylua: ignore
keys = {
{ 'I', '<Plug>(niceblock-I)', silent = true, mode = 'x', desc = 'Blockwise Insert' },
{ 'gI', '<Plug>(niceblock-gI)', silent = true, mode = 'x', desc = 'Blockwise Insert' },
{ 'A', '<Plug>(niceblock-A)', silent = true, mode = 'x', desc = 'Blockwise Append' },
},
init = function()
vim.g.niceblock_no_default_key_mappings = 0
end,
},
-----------------------------------------------------------------------------
{
'haya14busa/vim-edgemotion',
-- stylua: ignore
keys = {
{ 'gj', '<Plug>(edgemotion-j)', mode = { 'n', 'x' }, desc = 'Move to bottom edge' },
{ 'gk', '<Plug>(edgemotion-k)', mode = { 'n', 'x' }, desc = 'Move to top edge' },
},
},
-----------------------------------------------------------------------------
{
'folke/zen-mode.nvim',
cmd = 'ZenMode',
keys = {
{ '<Leader>zz', '<cmd>ZenMode<CR>', noremap = true, desc = 'Zen Mode' },
},
opts = {
plugins = {
gitsigns = { enabled = true },
tmux = { enabled = vim.env.TMUX ~= nil },
},
},
},
-----------------------------------------------------------------------------
-- 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,
},
-----------------------------------------------------------------------------
{
'folke/todo-comments.nvim',
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>dt', '<cmd>TodoTelescope<CR>', desc = 'todo' },
{ '<leader>xt', '<cmd>TodoTrouble<CR>', desc = 'Todo (Trouble)' },
{ '<leader>xT', '<cmd>TodoTrouble keywords=TODO,FIX,FIXME<cr>', desc = 'Todo/Fix/Fixme (Trouble)' },
{ '<leader>St', '<cmd>TodoTelescope<cr>', desc = 'Todo' },
{ '<leader>ST', '<cmd>TodoTelescope keywords=TODO,FIX,FIXME<cr>', desc = 'Todo/Fix/Fixme' },
},
opts = { signs = false },
},
-----------------------------------------------------------------------------
{
'folke/trouble.nvim',
cmd = { 'Trouble', 'TroubleToggle' },
opts = { use_diagnostic_signs = true },
-- stylua: ignore
keys = {
{ '<leader>e', '<cmd>TroubleToggle document_diagnostics<CR>', noremap = true, desc = 'Document Diagnostics' },
{ '<leader>r', '<cmd>TroubleToggle workspace_diagnostics<CR>', noremap = true, desc = 'Workspace Diagnostics' },
{ '<leader>xx', '<cmd>TroubleToggle document_diagnostics<cr>', desc = 'Document Diagnostics (Trouble)' },
{ '<leader>xX', '<cmd>TroubleToggle workspace_diagnostics<cr>', desc = 'Workspace Diagnostics (Trouble)' },
{ '<leader>xQ', '<cmd>TroubleToggle quickfix<cr>', desc = 'Quickfix List (Trouble)' },
{ '<leader>xL', '<cmd>TroubleToggle loclist<cr>', desc = 'Location List (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',
},
},
},
-----------------------------------------------------------------------------
{
'akinsho/toggleterm.nvim',
cmd = 'ToggleTerm',
keys = {
{
'<C-_>',
mode = { 'n', 't' },
silent = true,
function()
local venv = vim.b['virtual_env']
local term = require('toggleterm.terminal').Terminal:new({
env = venv and { VIRTUAL_ENV = venv } or nil,
count = vim.v.count > 0 and vim.v.count or 1,
})
term:toggle()
end,
desc = 'Toggle terminal',
},
},
opts = {
open_mapping = false,
float_opts = {
border = 'curved',
},
},
},
-----------------------------------------------------------------------------
{
'simrat39/symbols-outline.nvim',
cmd = { 'SymbolsOutline', 'SymbolsOutlineOpen' },
keys = {
{ '<Leader>o', '<cmd>SymbolsOutline<CR>', desc = 'Symbols Outline' },
},
opts = {
width = 30,
autofold_depth = 0,
keymaps = {
hover_symbol = 'K',
toggle_preview = 'p',
},
},
init = function()
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_outline', {}),
pattern = 'Outline',
callback = function()
vim.opt_local.winhighlight = 'CursorLine:WildMenu'
vim.opt_local.signcolumn = 'auto'
end,
})
end,
},
-----------------------------------------------------------------------------
{
's1n7ax/nvim-window-picker',
event = 'VeryLazy',
keys = function(_, keys)
local pick_window = function()
local picked_window_id = require('window-picker').pick_window()
if picked_window_id ~= nil then
vim.api.nvim_set_current_win(picked_window_id)
end
end
local swap_window = function()
local picked_window_id = require('window-picker').pick_window()
if picked_window_id ~= nil then
local current_winnr = vim.api.nvim_get_current_win()
local current_bufnr = vim.api.nvim_get_current_buf()
local other_bufnr = vim.api.nvim_win_get_buf(picked_window_id)
vim.api.nvim_win_set_buf(current_winnr, other_bufnr)
vim.api.nvim_win_set_buf(picked_window_id, current_bufnr)
end
end
local mappings = {
{ '-', pick_window, desc = 'Pick window' },
{ '<leader>wp', pick_window, desc = 'Pick window' },
{ '<leader>ww', swap_window, desc = 'Swap picked window' },
}
return vim.list_extend(mappings, keys)
end,
opts = {
hint = 'floating-big-letter',
show_prompt = false,
filter_rules = {
include_current_win = true,
bo = {
filetype = { 'notify', 'noice' },
buftype = {},
},
},
},
},
-----------------------------------------------------------------------------
{
'rest-nvim/rest.nvim',
ft = 'http',
keys = {
{ '<Leader>mh', '<Plug>RestNvim', desc = 'Execute HTTP request' },
},
opts = { skip_ssl_verification = true },
},
-----------------------------------------------------------------------------
{
'mickael-menu/zk-nvim',
name = 'zk',
ft = 'markdown',
cmd = { 'ZkNew', 'ZkNotes', 'ZkTags', 'ZkMatch' },
-- stylua: ignore
keys = {
{ '<leader>zn', "<Cmd>ZkNew { title = vim.fn.input('Title: ') }<CR>", desc = 'Zk New' },
{ '<leader>zo', "<Cmd>ZkNotes { sort = { 'modified' } }<CR>", desc = 'Zk Notes' },
{ '<leader>zt', '<Cmd>ZkTags<CR>', desc = 'Zk Tags' },
{ '<leader>zf', "<Cmd>ZkNotes { sort = { 'modified' }, match = vim.fn.input('Search: ') }<CR>", desc = 'Zk Search' },
{ '<leader>zf', ":'<,'>ZkMatch<CR>", mode = 'x', desc = 'Zk Match' },
{ '<leader>zb', '<Cmd>ZkBacklinks<CR>', desc = 'Zk Backlinks' },
{ '<leader>zl', '<Cmd>ZkLinks<CR>', desc = 'Zk Links' },
},
opts = { picker = 'telescope' },
},
-----------------------------------------------------------------------------
{
'nvim-pack/nvim-spectre',
-- stylua: ignore
keys = {
{ '<Leader>Sp', function() require('spectre').toggle() end, desc = 'Spectre', },
{ '<Leader>Sp', function() require('spectre').open_visual({ select_word = true }) end, mode = 'x', desc = 'Spectre Word' },
},
opts = {
mapping = {
['toggle_gitignore'] = {
map = 'tg',
cmd = "<cmd>lua require('spectre').change_options('gitignore')<CR>",
desc = 'toggle gitignore',
},
},
find_engine = {
['rg'] = {
cmd = 'rg',
args = {
'--color=never',
'--no-heading',
'--with-filename',
'--line-number',
'--column',
'--ignore',
},
options = {
['gitignore'] = {
value = '--no-ignore',
icon = '[G]',
desc = 'gitignore',
},
},
},
},
default = {
find = {
cmd = 'rg',
options = { 'ignore-case', 'hidden', 'gitignore' },
},
},
},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.bufremove',
opts = {},
-- stylua: ignore
keys = {
{ '<leader>bd', function() require('mini.bufremove').delete(0, false) end, desc = 'Delete Buffer', },
},
},
-----------------------------------------------------------------------------
{
'mzlogin/vim-markdown-toc',
cmd = { 'GenTocGFM', 'GenTocRedcarpet', 'GenTocGitLab', 'UpdateToc' },
ft = 'markdown',
init = function()
vim.g.vmt_auto_update_on_save = 0
end,
},
}

View File

@ -1,18 +0,0 @@
return {
{
'windwp/nvim-autopairs',
dependencies = 'hrsh7th/nvim-cmp',
config = function()
local autopairs = require('nvim-autopairs')
autopairs.setup()
-- Disable [ rule, it interferes with zk-nvim link completion.
local cond = require('nvim-autopairs.conds')
autopairs.get_rule('['):with_pair(cond.not_filetypes({ 'markdown' }))
-- Insert `(` after function or method item selection.
local cmp_autopairs = require('nvim-autopairs.completion.cmp')
require('cmp').event:on('confirm_done', cmp_autopairs.on_confirm_done())
end,
},
}

View File

@ -1,26 +0,0 @@
return {
{
'hrsh7th/nvim-cmp',
optional = true,
dependencies = { 'petertriho/cmp-git' },
},
{
'petertriho/cmp-git',
opts = {},
config = function()
local cmp = require('cmp')
---@diagnostic disable-next-line: missing-fields
cmp.setup.filetype('gitcommit', {
sources = cmp.config.sources({
{ name = 'git', priority = 50 },
{ name = 'path', priority = 40 },
}, {
{ name = 'buffer', priority = 50 },
{ name = 'emoji', insert = true, priority = 20 },
}),
})
end,
},
}

View File

@ -1,108 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/coding/copilot.lua
return {
-----------------------------------------------------------------------------
{
'zbirenbaum/copilot.lua',
enabled = false,
cmd = 'Copilot',
build = ':Copilot auth',
opts = {
suggestion = { enabled = false },
panel = { enabled = false },
filetypes = {
markdown = true,
help = true,
},
},
},
-----------------------------------------------------------------------------
{
'nvim-lualine/lualine.nvim',
optional = true,
event = 'VeryLazy',
opts = function(_, opts)
local get_color = require('plex.lib.color').get_color
local fg = function(...)
return { fg = get_color('fg', ...) }
end
local colors = {
[''] = fg({ 'Comment' }),
['Normal'] = fg({ 'Comment' }),
['Warning'] = fg({ 'DiagnosticError' }),
['InProgress'] = fg({ 'DiagnosticWarn' }),
}
-- Add copilot icon to lualine statusline
table.insert(opts.sections.lualine_x, {
function()
local icon = require('plex.config').icons.kinds.Copilot
local status = require('copilot.api').status.data
return icon .. (status.message or '')
end,
cond = function()
local clients
if vim.lsp.get_clients ~= nil then
clients = vim.lsp.get_clients({ name = 'copilot', bufnr = 0 })
else
---@diagnostic disable-next-line: deprecated
clients = vim.lsp.get_active_clients({
name = 'copilot',
bufnr = 0,
})
end
return #clients > 0
end,
color = function()
if not package.loaded["copilot"] then
return
end
local status = require('copilot.api').status.data
return colors[status.status] or colors['']
end,
})
end,
},
-----------------------------------------------------------------------------
{
'nvim-cmp',
dependencies = {
{
'zbirenbaum/copilot-cmp',
dependencies = 'zbirenbaum/copilot.lua',
opts = {},
config = function(_, opts)
local copilot_cmp = require('copilot_cmp')
copilot_cmp.setup(opts)
-- attach cmp source whenever copilot attaches
-- fixes lazy-loading issues with the copilot cmp source
---@param client lsp.Client
require('plex.lib.utils').on_attach(function(client)
if client.name == 'copilot' then
copilot_cmp._on_insert_enter({})
end
end)
end,
},
},
---@param opts cmp.ConfigSchema|{sources: table[]}
opts = function(_, opts)
-- Add copilot nvim-cmp source.
table.insert(opts.sources, 1, {
name = 'copilot',
group_index = 2,
priority = 60,
})
opts.sorting = opts.sorting or require('cmp.config.default')().sorting
table.insert(
opts.sorting.comparators,
1,
require('copilot_cmp.comparators').prioritize
)
end,
},
}

View File

@ -1,20 +0,0 @@
return {
{
'sgur/vim-editorconfig',
lazy = false,
init = function()
vim.g.editorconfig_verbose = 1
vim.g.editorconfig_blacklist = {
filetype = {
'git.*',
'fugitive',
'help',
'lsp-.*',
'any-jump',
'gina-.*',
},
pattern = { '\\.un~$' },
}
end,
},
}

View File

@ -1,31 +0,0 @@
return {
{
'mattn/emmet-vim',
ft = { 'html', 'css', 'vue', 'javascript', 'javascriptreact', 'svelte' },
init = function()
vim.g.user_emmet_mode = 'i'
vim.g.user_emmet_install_global = 0
vim.g.user_emmet_install_command = 0
vim.g.user_emmet_complete_tag = 0
end,
config = function()
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_emmet', {}),
pattern = {
'css',
'html',
'javascript',
'javascriptreact',
'svelte',
'vue',
},
callback = function()
vim.cmd([[
EmmetInstall
imap <silent><buffer> <C-y> <Plug>(emmet-expand-abbr)
]])
end,
})
end,
},
}

View File

@ -1,21 +0,0 @@
return {
{
-- I dont get how this stuff works
'machakann/vim-sandwich',
enabled = false,
-- stylua: ignore
keys = {
-- See https://github.com/machakann/vim-sandwich/blob/master/macros/sandwich/keymap/surround.vim
{ '<leader>sd', '<Plug>(operator-sandwich-delete)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-query-a)', silent = true },
{ '<leader>ssd', '<Plug>(operator-sandwich-delete)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-auto-a)', silent = true },
{ '<leader>sc', '<Plug>(operator-sandwich-replace)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-query-a)', silent = true },
{ '<leader>ssc', '<Plug>(operator-sandwich-replace)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-auto-a)', silent = true },
{ '<leader>sa', '<Plug>(operator-sandwich-add)', silent = true, mode = { 'n', 'x', 'o' }},
{ '<leader>si', '<Plug>(textobj-sandwich-auto-i)', silent = true, mode = { 'x', 'o' }},
{ '<leader>sa', '<Plug>(textobj-sandwich-auto-a)', silent = true, mode = { 'x', 'o' }},
},
init = function()
vim.g.sandwich_no_default_key_mappings = 1
end,
},
}

View File

@ -1,22 +0,0 @@
return {
{
'williamboman/mason.nvim',
opts = function(_, opts)
table.insert(opts.ensure_installed, 'proselint')
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
local source = nls.builtins.diagnostics.proselint.with({
diagnostics_postprocess = function(diagnostic)
diagnostic.severity = vim.diagnostic.severity.HINT
end,
})
table.insert(opts.sources, source)
end,
},
}

View File

@ -1,22 +0,0 @@
return {
{
'williamboman/mason.nvim',
opts = function(_, opts)
table.insert(opts.ensure_installed, 'write-good')
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
local source = nls.builtins.diagnostics.write_good.with({
diagnostics_postprocess = function(diagnostic)
diagnostic.severity = vim.diagnostic.severity.HINT
end,
})
table.insert(opts.sources, source)
end,
},
}

View File

@ -1,22 +0,0 @@
return {
{
'pechorin/any-jump.vim',
cmd = { 'AnyJump', 'AnyJumpVisual' },
keys = {
{ '<leader>ii', '<cmd>AnyJump<CR>', desc = 'Any Jump' },
{ '<leader>ii', '<cmd>AnyJumpVisual<CR>', mode = 'x', desc = 'Any Jump' },
{ '<leader>ib', '<cmd>AnyJumpBack<CR>', desc = 'Any Jump Back' },
{ '<leader>il', '<cmd>AnyJumpLastResults<CR>', desc = 'Any Jump Resume' },
},
init = function()
vim.g.any_jump_disable_default_keybindings = 1
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_any-jump', {}),
pattern = 'any-jump',
callback = function()
vim.opt.cursorline = true
end,
})
end,
},
}

View File

@ -1,11 +0,0 @@
return {
{
'glepnir/flybuf.nvim',
cmd = 'FlyBuf',
keys = {
-- stylua: ignore
{ '<Leader><Tab>', function() require('flybuf').toggle() end, desc = 'Flybuf' },
},
opts = {},
},
}

View File

@ -1,14 +0,0 @@
return {
{
'sidebar-nvim/sidebar.nvim',
main = 'sidebar-nvim',
cmd = { 'SidebarNvimToggle', 'SidebarNvimOpen' },
opts = {
open = true,
bindings = {
-- stylua: ignore
['q'] = function() require('sidebar-nvim').close() end,
},
},
},
}

View File

@ -1,8 +0,0 @@
return {
{
"dhruvasagar/vim-table-mode",
lazy = false,
-- <Leader>tm is automatically set for toggle
-- see <Leader>t menu
},
}

View File

@ -1,112 +0,0 @@
return {
{
'neovim/nvim-lspconfig',
opts = {
capabilities = {
textDocument = {
foldingRange = {
dynamicRegistration = false,
lineFoldingOnly = true,
},
},
},
},
},
{
'kevinhwang91/nvim-ufo',
event = { 'BufReadPost', 'BufNewFile' },
-- stylua: ignore
keys = {
{ 'zR', function() require('ufo').openAllFolds() end },
{ 'zM', function() require('ufo').closeAllFolds() end },
-- { 'zr', function() require('ufo').openFoldsExceptKinds() end },
-- { 'zm', function() require('ufo').closeFoldsWith() end },
},
dependencies = {
'kevinhwang91/promise-async',
'nvim-treesitter/nvim-treesitter',
'neovim/nvim-lspconfig',
},
opts = function()
-- lsp->treesitter->indent
---@param bufnr number
---@return table
local function customizeSelector(bufnr)
local function handleFallbackException(err, providerName)
if type(err) == 'string' and err:match('UfoFallbackException') then
return require('ufo').getFolds(bufnr, providerName)
else
return require('promise').reject(err)
end
end
return require('ufo')
.getFolds(bufnr, 'lsp')
:catch(function(err)
return handleFallbackException(err, 'treesitter')
end)
:catch(function(err)
return handleFallbackException(err, 'indent')
end)
end
local ft_providers = {
vim = 'indent',
python = { 'indent' },
git = '',
help = '',
qf = '',
fugitive = '',
fugitiveblame = '',
['neo-tree'] = '',
}
return {
open_fold_hl_timeout = 0,
preview = {
win_config = {
border = { '', '', '', '', '', '', '', '' },
winhighlight = 'Normal:Folded',
winblend = 10,
},
mappings = {
scrollU = '<C-u>',
scrollD = '<C-d>',
jumpTop = '[',
jumpBot = ']',
},
},
-- Select the fold provider.
provider_selector = function(_, filetype, _)
return ft_providers[filetype] or customizeSelector
end,
-- Display text for folded lines.
---@param text table
---@param lnum integer
---@param endLnum integer
---@param width integer
---@return table
fold_virt_text_handler = function(text, lnum, endLnum, width)
local suffix = ' 󰇘 '
local lines = (' 󰁂 %d '):format(endLnum - lnum)
local cur_width = 0
for _, section in ipairs(text) do
cur_width = cur_width + vim.fn.strdisplaywidth(section[1])
end
suffix = suffix
.. (' '):rep(width - cur_width - vim.fn.strdisplaywidth(lines) - 3)
table.insert(text, { suffix, 'UfoFoldedEllipsis' })
table.insert(text, { lines, 'Folded' })
return text
end,
}
end,
},
}

View File

@ -1,13 +0,0 @@
return {
{
-- enables UNIX specific stuff in vim,
-- specifically:
-- :SudoWrite
-- :SudoRead
-- :Chmod
-- and also some more, but those are easy done with shell
"tpope/vim-eunuch",
enabled = false,
lazy=false,
}
}

View File

@ -1,53 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/formatting/prettier.lua
return {
{
"williamboman/mason.nvim",
opts = function(_, opts)
if type(opts.ensure_installed) == "table" then
table.insert(opts.ensure_installed, "prettierd")
end
end,
},
{
"mhartington/formatter.nvim",
optional = true,
keys = {
{ "<Leader>ff", "<cmd>Format<CR>", desc = "Use Formatter" },
},
opts = function(_, opts)
opts = opts or {}
local filetypes = {
-- FIXME:add more filetypes
json = { require("formatter.defaults.prettierd") },
rust = {
rustfmt = function()
return {
exe = "rustfmt",
args = { "--emit=std ut" },
stdin = true,
}
end,
},
["*"] = {
-- "formatter.filetypes.any" defines default configurations for any
-- filetype
require("formatter.filetypes.any").remove_trailing_whitespace,
},
}
opts.filetype = vim.tbl_extend("keep", opts.filetype or {}, filetypes)
end,
},
{
"jose-elias-alvarez/null-ls.nvim",
optional = true,
opts = function(_, opts)
local nls = require("null-ls")
table.insert(opts.sources, nls.builtins.formatting.prettierd)
end,
},
}

View File

@ -1,31 +0,0 @@
return {
-----------------------------------------------------------------------------
{
'tpope/vim-fugitive',
cmd = { 'G', 'Git', 'Gfetch', 'Gpush', 'Gclog', 'Gdiffsplit' },
keys = {
{ '<leader>gd', '<cmd>Gdiffsplit<CR>', desc = 'Git diff' },
{ '<leader>gb', '<cmd>Git blame<CR>', desc = 'Git blame' },
},
config = function()
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('rafi_fugitive', {}),
pattern = 'fugitiveblame',
callback = function()
vim.schedule(function()
vim.cmd.normal('A')
end)
end,
})
end,
},
-----------------------------------------------------------------------------
{
'junegunn/gv.vim',
dependencies = { 'tpope/vim-fugitive' },
cmd = 'GV',
},
}

View File

@ -1,72 +0,0 @@
-- rafi.plugins.extras.lang.ansible
--
return {
{
'nvim-treesitter/nvim-treesitter',
dependencies = {
'pearofducks/ansible-vim',
ft = { 'ansible', 'ansible_hosts', 'jinja2' },
},
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'yaml' })
end
vim.g.ansible_extra_keywords_highlight = 1
vim.g.ansible_template_syntaxes = {
['*.json.j2'] = 'json',
['*.(ba)?sh.j2'] = 'sh',
['*.ya?ml.j2'] = 'yaml',
['*.xml.j2'] = 'xml',
['*.conf.j2'] = 'conf',
['*.ini.j2'] = 'ini',
}
-- Setup filetype settings
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_ftplugin_ansible', {}),
pattern = 'ansible',
callback = function()
-- Add '.' to iskeyword for ansible modules, e.g. ansible.builtin.copy
vim.opt_local.iskeyword:append('.')
vim.b.undo_ftplugin = (vim.b.undo_ftplugin or '')
.. (vim.b.undo_ftplugin ~= nil and ' | ' or '')
.. 'setlocal iskeyword<'
if vim.fn.executable('ansible-doc') then
vim.b.undo_ftplugin = vim.b.undo_ftplugin
.. '| sil! nunmap <buffer> gK'
vim.keymap.set('n', 'gK', function()
-- Open ansible-doc in a vertical split with word under cursor.
vim.cmd([[
vertical split
| execute('terminal PAGER=cat ansible-doc ' .. shellescape(expand('<cword>')))
| setf man
| wincmd p
]])
end, { buffer = 0 })
end
end,
})
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
ansiblels = {},
},
},
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'ansible-lint' })
end,
},
}

View File

@ -1,64 +0,0 @@
return {
{
'mfussenegger/nvim-dap',
-- optional = true,
dependencies = {
'mfussenegger/nvim-dap-python',
},
-- stylua: ignore
-- keys = {
-- { '<leader>dPt', function() require('dap-python').test_method() end, desc = 'Debug Method' },
-- { '<leader>dPc', function() require('dap-python').test_class() end, desc = 'Debug Class' },
-- },
opts = function()
local dap = require('dap')
dap.adapters.cppdbg = {
id = 'cppdbg',
type = 'executable',
command = '/home/cscherr/.local/share/nvim/nvim-dap/debuggers/cpptools/extension/debugAdapters/bin/OpenDebugAD7',
}
dap.configurations.cpp = {
{
name = "Launch file",
type = "cppdbg",
request = "launch",
program = function()
return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
end,
cwd = '${workspaceFolder}',
stopAtEntry = true,
setupCommands = {
{
text = '-enable-pretty-printing',
description = 'enable pretty printing',
ignoreFailures = false
},
},
},
{
name = 'Attach to gdbserver :1234',
type = 'cppdbg',
request = 'launch',
MIMode = 'gdb',
miDebuggerServerAddress = 'localhost:1234',
miDebuggerPath = '/usr/bin/gdb',
cwd = '${workspaceFolder}',
program = function()
return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
end,
setupCommands = {
{
text = '-enable-pretty-printing',
description = 'enable pretty printing',
ignoreFailures = false
},
},
},
}
dap.configurations.c = dap.configurations.cpp
dap.configurations.rust = dap.configurations.cpp
end,
},
}

View File

@ -1,50 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/docker.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'dockerfile' })
end
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
dockerls = {},
-- docker_compose_language_service = {},
},
},
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'hadolint' })
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
opts.sources = opts.sources or {}
vim.list_extend(opts.sources, {
nls.builtins.diagnostics.hadolint,
})
end,
dependencies = {
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'hadolint' })
end,
},
},
}

View File

@ -1,199 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/go.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, {
'go',
'gomod',
'gosum',
'gowork',
})
end
-- Convert a JSON string to a Go struct.
vim.api.nvim_buf_create_user_command(
0,
'JsonToStruct',
---@param args table
function(args)
local range = args.line1 .. ',' .. args.line2
local fname = vim.api.nvim_buf_get_name(0)
local cmd = { '!json-to-struct' }
table.insert(cmd, '-name ' .. vim.fn.fnamemodify(fname, ':t:r'))
table.insert(cmd, '-pkg ' .. vim.fn.fnamemodify(fname, ':h:t:r'))
vim.cmd(range .. ' ' .. table.concat(cmd, ' '))
end,
{ bar = true, nargs = 0, range = true }
)
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
-- gopls = {
-- settings = {
-- -- https://github.com/golang/tools/blob/master/gopls/doc/settings.md
-- gopls = {
-- gofumpt = true,
-- usePlaceholders = true,
-- completeUnimported = true,
-- staticcheck = true,
-- directoryFilters = {
-- '-.git',
-- '-.vscode',
-- '-.idea',
-- '-.vscode-test',
-- '-node_modules',
-- },
-- semanticTokens = true,
-- codelenses = {
-- gc_details = false,
-- generate = true,
-- regenerate_cgo = true,
-- run_govulncheck = true,
-- test = true,
-- tidy = true,
-- upgrade_dependency = true,
-- vendor = true,
-- },
-- hints = {
-- assignVariableTypes = true,
-- compositeLiteralFields = true,
-- compositeLiteralTypes = true,
-- constantValues = true,
-- functionTypeParameters = true,
-- parameterNames = true,
-- rangeVariableTypes = true,
-- },
-- -- https://github.com/golang/tools/blob/master/gopls/doc/analyzers.md
-- analyses = {
-- fieldalignment = true,
-- nilness = true,
-- unusedparams = true,
-- unusedwrite = true,
-- useany = true,
-- -- fillreturns = true,
-- -- nonewvars = true,
-- -- shadow = true,
-- -- undeclaredname = true,
-- -- unusedvariable = true,
-- -- ST1000 = false,
-- -- ST1005 = false,
-- },
-- },
-- },
-- },
},
setup = {
gopls = function(_, _)
-- workaround for gopls not supporting semanticTokensProvider
-- https://github.com/golang/go/issues/54531#issuecomment-1464982242
require('plex.lib.utils').on_attach(function(client, _)
if client.name == 'gopls' then
if not client.server_capabilities.semanticTokensProvider then
local semantic =
client.config.capabilities.textDocument.semanticTokens
if semantic ~= nil then
client.server_capabilities.semanticTokensProvider = {
full = true,
legend = {
tokenTypes = semantic.tokenTypes,
tokenModifiers = semantic.tokenModifiers,
},
range = true,
}
end
end
end
end)
-- end workaround
end,
},
},
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, {
'gofumpt',
'goimports-reviser',
'gomodifytags',
'impl',
'json-to-struct',
})
end,
},
{
'mhartington/formatter.nvim',
optional = true,
opts = function(_, opts)
opts = opts or {}
local filetypes = {
go = {
require('formatter.filetypes.go').gofumpt,
},
}
opts.filetype = vim.tbl_extend('keep', opts.filetype or {}, filetypes)
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
local sources = {
nls.builtins.code_actions.gomodifytags,
nls.builtins.code_actions.impl,
nls.builtins.formatting.gofumpt,
-- nls.builtins.formatting.goimports_reviser,
}
opts.sources = opts.sources or {}
for _, source in ipairs(sources) do
table.insert(opts.sources, source)
end
end,
},
{
'mfussenegger/nvim-dap',
optional = true,
dependencies = {
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'delve' })
end,
},
{
'leoluz/nvim-dap-go',
config = true,
},
},
},
{
'nvim-neotest/neotest',
optional = true,
dependencies = { 'nvim-neotest/neotest-go' },
opts = {
adapters = {
['neotest-go'] = {
-- Here we can set options for neotest-go, e.g.
-- args = { '-tags=integration' }
},
},
},
},
}

View File

@ -1,24 +0,0 @@
-- rafi.plugins.extras.lang.helm
--
return {
{ 'towolf/vim-helm', ft = 'helm' },
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'yaml' })
end
end,
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'helm-ls' })
end,
},
}

View File

@ -1,40 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/json.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'json', 'json5', 'jsonc' })
end
end,
},
{
'neovim/nvim-lspconfig',
dependencies = { 'b0o/SchemaStore.nvim', version = false },
opts = {
servers = {
jsonls = {
-- lazy-load schemastore when needed
on_new_config = function(new_config)
new_config.settings.json.schemas = new_config.settings.json.schemas
or {}
vim.list_extend(
new_config.settings.json.schemas,
require('schemastore').json.schemas()
)
end,
settings = {
json = {
format = { enable = true },
validate = { enable = true },
},
},
},
},
},
},
}

View File

@ -1,72 +0,0 @@
-- rafi.plugins.extras.lang.python
--
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/python.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(
opts.ensure_installed,
{ 'ninja', 'python', 'requirements', 'rst', 'toml' }
)
end
end,
},
{
'neovim/nvim-lspconfig',
dependencies = 'rafi/neoconf-venom.nvim',
opts = {
servers = {
pyright = {},
},
},
},
{
'rafi/neoconf-venom.nvim',
main = 'venom',
opts = {},
-- stylua: ignore
keys = {
{ '<leader>cv', '<cmd>Telescope venom virtualenvs<cr>', desc = 'Select VirtualEnv' },
},
},
{
'nvim-neotest/neotest',
optional = true,
dependencies = { 'nvim-neotest/neotest-python' },
opts = {
adapters = {
['neotest-python'] = {
-- Here you can specify the settings for the adapter, i.e.
-- runner = "pytest",
-- python = '.venv/bin/python',
},
},
},
},
{
'mfussenegger/nvim-dap',
optional = true,
dependencies = {
'mfussenegger/nvim-dap-python',
-- stylua: ignore
keys = {
{ '<leader>dPt', function() require('dap-python').test_method() end, desc = 'Debug Method' },
{ '<leader>dPc', function() require('dap-python').test_class() end, desc = 'Debug Class' },
},
config = function()
local path =
require('mason-registry').get_package('debugpy'):get_install_path()
require('dap-python').setup(path .. '/venv/bin/python')
end,
},
},
}

View File

@ -1,42 +0,0 @@
return {
{
'mfussenegger/nvim-dap',
optional = true,
dependencies = {
'mfussenegger/nvim-dap-python',
},
-- stylua: ignore
-- keys = {
-- { '<leader>dPt', function() require('dap-python').test_method() end, desc = 'Debug Method' },
-- { '<leader>dPc', function() require('dap-python').test_class() end, desc = 'Debug Class' },
-- },
config = function()
local dap = require('dap')
dap.configurations.rust = {
{
-- ... the previous config goes here ...,
initCommands = function()
-- Find out where to look for the pretty printer Python module
local rustc_sysroot = vim.fn.trim(vim.fn.system('rustc --print sysroot'))
local script_import = 'command script import "' .. rustc_sysroot .. '/lib/rustlib/etc/lldb_lookup.py"'
local commands_file = rustc_sysroot .. '/lib/rustlib/etc/lldb_commands'
local commands = {}
local file = io.open(commands_file, 'r')
if file then
for line in file:lines() do
table.insert(commands, line)
end
file:close()
end
table.insert(commands, 1, script_import)
return commands
end,
-- ...,
}
}
end,
},
}

View File

@ -1,38 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/terraform.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, {
'terraform',
'hcl',
})
end
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
terraformls = {},
},
},
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
if type(opts.sources) == 'table' then
local builtins = require('null-ls.builtins')
table.insert(opts.sources, builtins.formatting.terraform_fmt)
table.insert(opts.sources, builtins.diagnostics.terraform_validate)
end
end,
},
}

View File

@ -1,28 +0,0 @@
return {
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
if type(opts.ensure_installed) == "table" then
vim.list_extend(opts.ensure_installed, { "rust" })
end
end,
},
{
"neovim/nvim-lspconfig",
-- dependencies = { 'b0o/SchemaStore.nvim', version = false },
opts = {
servers = {
texlab = {
rootDirectory = ".",
auxDirectory = ".",
latexFormatter = "latexindent",
latexindent = {
modifyLineBreaks = true,
},
},
},
},
},
}

View File

@ -1,125 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/typescript.lua
return {
-- add typescript to treesitter
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'typescript', 'tsx' })
end
end,
},
-- correctly setup lspconfig
{
'neovim/nvim-lspconfig',
dependencies = { 'jose-elias-alvarez/typescript.nvim' },
opts = {
-- make sure mason installs the server
servers = {
---@type lspconfig.options.tsserver
tsserver = {
-- stylua: ignore
keys = {
{ '<leader>co', '<cmd>TypescriptOrganizeImports<CR>', desc = 'Organize Imports' },
{ '<leader>cR', '<cmd>TypescriptRenameFile<CR>', desc = 'Rename File' },
},
settings = {
---@diagnostic disable: missing-fields
typescript = {
format = {
indentSize = vim.o.shiftwidth,
convertTabsToSpaces = vim.o.expandtab,
tabSize = vim.o.tabstop,
},
},
javascript = {
format = {
indentSize = vim.o.shiftwidth,
convertTabsToSpaces = vim.o.expandtab,
tabSize = vim.o.tabstop,
},
},
completions = {
completeFunctionCalls = true,
},
},
},
},
setup = {
tsserver = function(_, opts)
require('typescript').setup({ server = opts })
return true
end,
},
},
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
table.insert(
opts.sources,
require('typescript.extensions.null-ls.code-actions')
)
end,
},
{
'mfussenegger/nvim-dap',
optional = true,
dependencies = {
{
'williamboman/mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
table.insert(opts.ensure_installed, 'js-debug-adapter')
end,
},
},
opts = function()
local dap = require('dap')
if not dap.adapters['pwa-node'] then
require('dap').adapters['pwa-node'] = {
type = 'server',
host = 'localhost',
port = '${port}',
executable = {
command = 'node',
-- 💀 Make sure to update this path to point to your installation
args = {
require('mason-registry')
.get_package('js-debug-adapter')
:get_install_path() .. '/js-debug/src/dapDebugServer.js',
'${port}',
},
},
}
end
for _, language in ipairs({ 'typescript', 'javascript' }) do
if not dap.configurations[language] then
dap.configurations[language] = {
{
type = 'pwa-node',
request = 'launch',
name = 'Launch file',
program = '${file}',
cwd = '${workspaceFolder}',
},
{
type = 'pwa-node',
request = 'attach',
name = 'Attach',
processId = require('dap.utils').pick_process,
cwd = '${workspaceFolder}',
},
}
end
end
end,
},
}

View File

@ -1,63 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/yaml.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'yaml' })
end
end,
},
{
'neovim/nvim-lspconfig',
dependencies = { 'b0o/SchemaStore.nvim', version = false },
opts = {
servers = {
yamlls = {
-- Have to add this for yamlls to understand that we support line folding
capabilities = {
textDocument = {
foldingRange = {
dynamicRegistration = false,
lineFoldingOnly = true,
},
},
},
-- Lazy-load schemastore when needed
on_new_config = function(new_config)
new_config.settings.yaml.schemas = vim.tbl_extend(
'force',
require('schemastore').yaml.schemas(),
new_config.settings.yaml.schemas or {}
)
end,
settings = {
redhat = { telemetry = { enabled = false } },
yaml = {
completion = true,
hover = true,
validate = true,
format = {
enable = true,
},
schemaStore = {
-- Must disable built-in schemaStore support to use
-- schemas from SchemaStore.nvim plugin
enable = false,
-- Avoid TypeError: Cannot read properties of undefined (reading 'length')
url = '',
},
schemas = {
kubernetes = { 'k8s**.yaml', 'kube*/*.yaml' },
},
},
},
},
},
},
},
}

View File

@ -1,50 +0,0 @@
return {
{
'neovim/nvim-lspconfig',
opts = {
servers = {
ruff_lsp = {},
},
setup = {
ruff_lsp = function(_, opts)
local root_files = {
'.python-version',
'pyproject.toml',
'ruff.toml',
}
local util = require('lspconfig.util')
opts.root_dir = util.root_pattern(unpack(root_files))
or util.find_git_ancestor()
require('plex.lib.utils').on_attach(function(client, _)
if client.name == 'ruff_lsp' then
client.server_capabilities.hoverProvider = false
end
end)
end,
},
},
},
{
'williamboman/mason.nvim',
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, {
'ruff',
'ruff-lsp',
})
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
if type(opts.sources) == 'table' then
local nls = require('null-ls')
table.insert(opts.sources, nls.builtins.formatting.ruff)
end
end,
},
}

View File

@ -1,33 +0,0 @@
return {
{
'hrsh7th/nvim-gtd',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = 'neovim/nvim-lspconfig',
-- stylua: ignore
keys = {
{
'gf',
function() require('gtd').exec({ command = 'split' }) end,
desc = 'Go to definition or file',
},
},
---@type gtd.kit.App.Config.Schema
opts = {
sources = {
{ name = 'findup' },
{
name = 'walk',
root_markers = {
'.git',
'.neoconf.json',
'Makefile',
'package.json',
'tsconfig.json',
},
ignore_patterns = { '/node_modules', '/.git' },
},
{ name = 'lsp' },
},
},
},
}

View File

@ -1,22 +0,0 @@
return {
-- Not needed anymore with nvim-0.10.0
{
'lvimuser/lsp-inlayhints.nvim',
branch = 'anticonceal',
event = 'LspAttach',
opts = {},
config = function(_, opts)
require('lsp-inlayhints').setup(opts)
vim.api.nvim_create_autocmd('LspAttach', {
group = vim.api.nvim_create_augroup('LspAttach_inlayhints', {}),
callback = function(args)
if not (args.data and args.data.client_id) then
return
end
local client = vim.lsp.get_client_by_id(args.data.client_id)
require('lsp-inlayhints').on_attach(client, args.buf)
end,
})
end,
},
}

View File

@ -1,20 +0,0 @@
return {
{
'kosayoda/nvim-lightbulb',
event = { 'BufReadPre', 'BufNewFile' },
opts = {
ignore = {
clients = { 'null-ls' },
},
},
config = function(_, opts)
require('nvim-lightbulb').setup(opts)
vim.api.nvim_create_autocmd('CursorHold', {
group = vim.api.nvim_create_augroup('rafi_lightbulb', {}),
callback = function()
require('nvim-lightbulb').update_lightbulb()
end,
})
end,
},
}

View File

@ -1,62 +0,0 @@
return {
{
'jose-elias-alvarez/null-ls.nvim',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = { 'williamboman/mason.nvim' },
opts = function(_, opts)
-- https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/doc/BUILTINS.md
local builtins = require('null-ls').builtins
local sources = {
builtins.formatting.stylua,
builtins.formatting.shfmt,
}
for _, source in ipairs(sources) do
table.insert(opts.sources, source)
end
opts.fallback_severity = vim.diagnostic.severity.INFO
opts.should_attach = function(bufnr)
return not vim.api.nvim_buf_get_name(bufnr):match('^[a-z]+://')
end
opts.root_dir = require('null-ls.utils').root_pattern(
'.git',
'_darcs',
'.hg',
'.bzr',
'.svn',
'.null-ls-root',
'.neoconf.json',
'.python-version',
'Makefile'
)
end,
},
-- You can add your own sources. Here's an example:
-- {
-- 'jose-elias-alvarez/null-ls.nvim',
-- optional = true,
-- opts = function(_, opts)
-- local builtins = require('null-ls.builtins')
-- local sources = {
-- builtins.formatting.black,
-- builtins.formatting.fixjson,
-- builtins.formatting.golines,
-- builtins.formatting.markdownlint,
-- builtins.formatting.shellharden,
-- builtins.formatting.sql_formatter,
-- builtins.formatting.taplo,
-- builtins.diagnostics.markdownlint,
-- builtins.diagnostics.mypy,
-- builtins.diagnostics.vint,
-- builtins.diagnostics.yamllint,
-- builtins.code_actions.shellcheck,
-- }
-- opts.sources = opts.sources or {}
-- for _, source in ipairs(sources) do
-- table.insert(opts.sources, source)
-- end
-- end,
-- },
}

View File

@ -1,33 +0,0 @@
return {
{
'neovim/nvim-lspconfig',
opts = {
setup = {
yamlls = function(_, _)
local yamlls_opts = require('yaml-companion').setup(
require('plex.lib.utils').opts('yaml-companion.nvim')
)
require('lspconfig')['yamlls'].setup(yamlls_opts)
return true
end,
},
},
},
{
'someone-stole-my-name/yaml-companion.nvim',
dependencies = {
'neovim/nvim-lspconfig',
'nvim-telescope/telescope.nvim',
},
keys = {
-- stylua: ignore
{ '<localleader>y', '<cmd>Telescope yaml_schema<CR>', desc = 'YAML Schema' },
},
opts = {},
config = function(_, _)
require('telescope').load_extension('yaml_schema')
end,
},
}

View File

@ -1,28 +0,0 @@
return {
{
"nvim-neorg/neorg",
enabled = true,
lazy = true,
build = ":Neorg sync-parsers",
dependencies = { "nvim-lua/plenary.nvim" },
config = function()
require("neorg").setup {
load = {
["core.defaults"] = {}, -- Loads default behaviour
["core.concealer"] = {}, -- Adds pretty icons to your documents
["core.export"] = {},
["core.dirman"] = { -- Manages Neorg workspaces
config = {
workspaces = {
-- FIXME: This shouldn't be in the Versioncontrol. Make this
-- into a local extension of the plugin.
main = "~/winhome/Nextcloud/Neorg",
notes = "~/winhome/Nextcloud/Notizen",
},
},
},
},
}
end,
},
}

View File

@ -1,45 +0,0 @@
return {
{
'vimwiki/vimwiki',
enabled = false,
cmd = { 'VimwikiIndex', 'VimwikiUISelect' },
keys = {
{ '<Leader>W', '<cmd>VimwikiIndex<CR>', { noremap = true } },
},
init = function()
vim.g.vimwiki_global_ext = 0
vim.g.vimwiki_use_calendar = 1
vim.g.vimwiki_hl_headers = 1
vim.g.vimwiki_hl_cb_checked = 1
vim.g.vimwiki_autowriteall = 0
vim.g.vimwiki_listsym_rejected = ''
vim.g.vimwiki_listsyms = '✗○◐●✓'
end,
config = function()
vim.g.vimwiki_key_mappings = {
all_maps = 1,
global = 1,
headers = 1,
text_objs = 1,
table_format = 1,
table_mappings = 1,
lists = 1,
links = 1,
html = 1,
mouse = 0,
}
vim.g.vimwiki_list = {
{
diary_header = 'Diary',
diary_link_fmt = '%Y-%m/%d',
auto_toc = 1,
path = '~/docs/wiki/',
syntax = 'markdown',
ext = '.md',
},
{ path = '~/docs/books/', syntax = 'markdown', ext = '.md' },
{ path = '~/notes/', syntax = 'markdown', ext = '.md' },
}
end,
},
}

View File

@ -1,12 +0,0 @@
return {
{
'Wansmer/treesj',
enabled = true,
lazy = false,
cmd = { 'TSJJoin', 'TSJSplit' },
keys = {
{ '<leader>sj', '<cmd>TSJJoin<CR>' },
{ '<leader>sk', '<cmd>TSJSplit<CR>' },
},
},
}

View File

@ -1,28 +0,0 @@
return {
{
'utilyre/barbecue.nvim',
dependencies = { 'SmiteshP/nvim-navic', 'nvim-tree/nvim-web-devicons' },
keys = {
{
'<Leader>ub',
function()
local off = vim.b['barbecue_entries'] == nil
require('barbecue.ui').toggle(off and true or nil)
end,
desc = 'Breadcrumbs toggle',
},
},
opts = function()
local kind_icons = vim.tbl_map(function(icon)
return vim.trim(icon)
end, require('plex.config').icons.kinds)
return {
attach_navic = false,
show_dirname = false,
show_modified = true,
kinds = kind_icons,
symbols = { separator = '' },
}
end,
},
}

View File

@ -1,54 +0,0 @@
return {
{
'akinsho/bufferline.nvim',
event = 'VeryLazy',
opts = {
options = {
-- :h bufferline-configuration
mode = 'tabs',
separator_style = {"", ""},
themable = true,
numbers = "ordinal",
show_close_icon = false,
show_buffer_close_icons = false,
diagnostics = true,
indicator = {
-- icon = ' ', -- this should be omitted if indicator style is not 'icon'
-- windows terminal sucks
style = 'none',
},
always_show_bufferline = true,
diagnostics_indicator = function(_, _, diag)
local icons = require('plex.config').icons.diagnostics
local ret = (diag.error and icons.Error .. diag.error .. ' ' or '')
.. (diag.warning and icons.Warn .. diag.warning or '')
return vim.trim(ret)
end,
custom_areas = {
right = function()
local project_root = require('plex.lib.badge').project()
local result = {}
local part = {}
part.text = '%#BufferLineTab# ' .. project_root
table.insert(result, part)
-- Session indicator
if vim.v['this_session'] ~= '' then
table.insert(result, { text = '%#BufferLineTab#  ' })
end
return result
end,
},
offsets = {
{
filetype = 'neo-tree',
text = 'Neo-tree',
highlight = 'Directory',
text_align = 'center',
},
},
},
},
},
}

View File

@ -1,47 +0,0 @@
return {
{
'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,
},
}

View File

@ -1,21 +0,0 @@
return {
{
'ghillb/cybu.nvim',
dependencies = { 'nvim-tree/nvim-web-devicons', 'nvim-lua/plenary.nvim' },
keys = {
{ '[b', '<Plug>(CybuPrev)' },
{ ']b', '<Plug>(CybuNext)' },
{ '<C-S-Tab>', '<Plug>(CybuLastusedPrev)' },
{ '<C-Tab>', '<Plug>(CybuLastusedNext)' },
},
config = true,
},
{
'echasnovski/mini.bracketed',
optional = true,
opts = function(_, opts)
opts.buffer = { suffix = '' }
return opts
end,
},
}

View File

@ -1,85 +0,0 @@
local function get_header()
-- see https://github.com/MaximilianLloyd/ascii.nvim
return {
-- The following is a customized version!
[[ ]],
[[ ]],
[[ █ ████████ █████ ███████ ████ ]],
[[ ███ ██████ █████ █████████ ██████ ]],
[[ █████ ██████████████████████ ████ ███████████████ ]],
[[ ██ ██ █████ █████████████ ████ ████████████████ ]],
[[ ████ ███████████████ █████████ ████ █████ ██████ ████ ]],
[[ ██████ ██████ ███ █████████ ████ █████ █████ ████ ]],
[[ ████████ ███████████████████ ████ ████ █████ ████ ████ ]],
[[ ]],
}
end
return {
{
'glepnir/dashboard-nvim',
event = 'VimEnter',
config = function()
require('dashboard').setup({
theme = 'hyper',
config = {
header = get_header(),
week_header = {
enable = false,
},
shortcut = {
{
desc = '󰊳 Update',
group = '@property',
action = 'Lazy update',
key = 'u'
},
{
icon = '',
icon_hl = '@variable',
desc = 'Files',
group = 'Label',
action = 'Telescope find_files',
key = 'f',
},
{
desc = ' Git',
group = 'Label',
action = function()
local Util = require('plex.lib.utils')
Util.float_term({ 'lazygit'}, { cwd = Util.get_root() })
end,
key = 'g',
},
{
desc = ' Neorg',
group = 'Number',
action = 'Neorg workspace main',
key = 'o',
},
{
desc = '󰘁 Sessions',
group = 'Number',
action = 'Telescope persisted',
key = 's',
},
},
project = {
enable = true,
limit = 8,
icon = '',
label = ' Projects',
action = 'Telescope find_files cwd='
},
packages = { enable = true},
mru = { limit = 10, icon = '', label = ' Last Edited'},
-- footer = { 'footer bar foo' },
},
})
end,
dependencies = { {'nvim-tree/nvim-web-devicons'}}
}
}

View File

@ -1,9 +0,0 @@
return {
{
'Bekaboo/deadcolumn.nvim',
event = { 'BufReadPre', 'BufNewFile' },
opts = {
scope = 'visible',
},
},
}

View File

@ -1,51 +0,0 @@
return {
{
'rmagatti/goto-preview',
dependencies = 'nvim-telescope/telescope.nvim',
keys = {
{
'gpd',
function()
require('goto-preview').goto_preview_definition({})
end,
{ noremap = true },
},
{
'gpi',
function()
require('goto-preview').goto_preview_implementation({})
end,
{ noremap = true },
},
{
'gpc',
function()
require('goto-preview').close_all_win()
end,
{ noremap = true },
},
{
'gpr',
function()
require('goto-preview').goto_preview_references({})
end,
{ noremap = true },
},
},
opts = {
width = 78,
height = 15,
default_mappings = false,
opacity = 10,
post_open_hook = function(_, win)
vim.api.nvim_win_set_config(win, {
border = { '', '', '', '', '', '', '', '' },
})
local scope = { scope = 'local', win = win }
vim.api.nvim_set_option_value('spell', false, scope)
vim.api.nvim_set_option_value('signcolumn', 'no', scope)
vim.keymap.set('n', '<Esc>', '<cmd>quit<CR>')
end,
},
},
}

View File

@ -1,7 +0,0 @@
return {
{
'b0o/incline.nvim',
event = 'FileType',
opts = {},
},
}

View File

@ -1,19 +0,0 @@
return {
{
'echasnovski/mini.map',
keys = {
{ '<Leader>mn', '<cmd>lua MiniMap.toggle()<CR>', desc = 'Mini map' },
},
opts = function()
local minimap = require('mini.map')
return {
integrations = {
minimap.gen_integration.diagnostic(),
minimap.gen_integration.builtin_search(),
minimap.gen_integration.gitsigns(),
},
window = { winblend = 50 },
}
end,
},
}

View File

@ -1,24 +0,0 @@
return {
{
'luukvbaal/statuscol.nvim',
event = 'BufReadPost',
init = function()
vim.opt_global.foldcolumn = '1'
end,
opts = function()
local builtin = require('statuscol.builtin')
return {
setopt = true,
relculright = true,
segments = {
{
sign = { name = { '.*' }, maxwidth = 2, colwidth = 1, auto = true },
click = 'v:lua.ScSa',
},
{ text = { builtin.lnumfunc }, click = 'v:lua.ScLa' },
{ text = { builtin.foldfunc }, click = 'v:lua.ScFa' },
},
}
end,
},
}

View File

@ -1,10 +0,0 @@
return {
{
'psliwka/vim-smoothie',
lazy = true,
keys = {
{ "J", '<cmd>call smoothie#do("\\<C-D>") <CR>', mode = {'n', 'v', 'x'}, desc = "Scroll down" },
{ "K", '<cmd>call smoothie#do("\\<C-U>") <CR>', mode = {'n', 'v', 'x'}, desc = "Scroll up" },
},
},
}

View File

@ -1,246 +0,0 @@
-- Plugins: Git
-- https://github.com/rafi/vim-config
return {
-----------------------------------------------------------------------------
{
'lewis6991/gitsigns.nvim',
event = { 'BufReadPre', 'BufNewFile' },
-- See: https://github.com/lewis6991/gitsigns.nvim#usage
-- stylua: ignore
opts = {
signcolumn = true, -- Toggle with `:Gitsigns toggle_signs`
numhl = false, -- Toggle with `:Gitsigns toggle_numhl`
linehl = false, -- Toggle with `:Gitsigns toggle_linehl`
word_diff = false, -- Toggle with `:Gitsigns toggle_word_diff`
current_line_blame = false, -- Toggle with `:Gitsigns toggle_current_line_blame`
attach_to_untracked = true,
watch_gitdir = {
interval = 1000,
follow_files = true,
},
preview_config = {
border = 'rounded',
},
on_attach = function(bufnr)
local gs = package.loaded.gitsigns
local function map(mode, l, r, opts)
opts = opts or {}
opts.buffer = bufnr
vim.keymap.set(mode, l, r, opts)
end
-- Navigation
---@return string
map('n', ']g', function()
if vim.wo.diff then return ']c' end
vim.schedule(function() gs.next_hunk() end)
return '<Ignore>'
end, { expr = true, desc = 'Git hunk forward' })
map('n', '[g', function()
if vim.wo.diff then return '[c' end
vim.schedule(function() gs.prev_hunk() end)
return '<Ignore>'
end, { expr = true, desc = 'Git hunk last' })
-- Actions
--
map('n', '<leader>hs', gs.stage_hunk, { silent = true, desc = 'Stage hunk' })
map('n', '<leader>hr', gs.reset_hunk, { silent = true, desc = 'Reset hunk' })
map('x', '<leader>hs', function() gs.stage_hunk({vim.fn.line('.'), vim.fn.line('v')}) end)
map('x', '<leader>hr', function() gs.reset_hunk({vim.fn.line('.'), vim.fn.line('v')}) end)
map('n', '<leader>hS', gs.stage_buffer, { silent = true, desc = 'Stage buffer' })
map('n', '<leader>hu', gs.undo_stage_hunk, { desc = 'Undo staged hunk' })
map('n', '<leader>hR', gs.reset_buffer, { desc = 'Reset buffer' })
map('n', 'gs', gs.preview_hunk, { desc = 'Preview hunk' })
map('n', '<leader>hp', gs.preview_hunk_inline, { desc = 'Preview hunk inline' })
map('n', '<leader>hb', function() gs.blame_line({ full=true }) end, { desc = 'Show blame commit' })
map('n', '<leader>tb', gs.toggle_current_line_blame, { desc = 'Toggle Git line blame' })
-- map('n', '<leader>tw', gs.toggle_word_diff)
map('n', '<leader>hd', gs.diffthis, { desc = 'Diff against the index' })
map('n', '<leader>hD', function() gs.diffthis('~') end, { desc = 'Diff against the last commit' })
map('n', '<leader>td', gs.toggle_deleted, { desc = 'Toggle Git deleted' })
map('n', '<leader>hl', function()
if vim.bo.filetype ~= 'qf' then
require('gitsigns').setqflist(0, { use_location_list = true })
end
end, { desc = 'Send to location list' })
-- Text object
map({'o', 'x'}, 'ih', ':<C-U>Gitsigns select_hunk<CR>', { silent = true, desc = 'Select hunk'})
end,
},
},
-----------------------------------------------------------------------------
{
'sindrets/diffview.nvim',
cmd = { 'DiffviewOpen', 'DiffviewFileHistory' },
keys = {
{ '<Leader>gd', '<cmd>DiffviewFileHistory<CR>', desc = 'Diff File' },
{ '<Leader>gv', '<cmd>DiffviewOpen<CR>', desc = 'Diff View' },
},
opts = function()
local actions = require('diffview.actions')
vim.api.nvim_create_autocmd({ 'WinEnter', 'BufEnter' }, {
group = vim.api.nvim_create_augroup('plex_diffview', {}),
pattern = 'diffview:///panels/*',
callback = function()
vim.opt_local.cursorline = true
vim.opt_local.winhighlight = 'CursorLine:WildMenu'
end,
})
return {
enhanced_diff_hl = true, -- See ':h diffview-config-enhanced_diff_hl'
keymaps = {
view = {
{ 'n', 'q', '<cmd>DiffviewClose<CR>' },
{ 'n', '<Tab>', actions.select_next_entry },
{ 'n', '<S-Tab>', actions.select_prev_entry },
{ 'n', '<LocalLeader>a', actions.focus_files },
{ 'n', '<LocalLeader>e', actions.toggle_files },
},
file_panel = {
{ 'n', 'q', '<cmd>DiffviewClose<CR>' },
{ 'n', 'h', actions.prev_entry },
{ 'n', 'o', actions.focus_entry },
{ 'n', 'gf', actions.goto_file },
{ 'n', 'sg', actions.goto_file_split },
{ 'n', 'st', actions.goto_file_tab },
{ 'n', '<C-r>', actions.refresh_files },
{ 'n', ';e', actions.toggle_files },
},
file_history_panel = {
{ 'n', 'q', '<cmd>DiffviewClose<CR>' },
{ 'n', 'o', actions.focus_entry },
{ 'n', 'O', actions.options },
},
},
}
end,
},
-----------------------------------------------------------------------------
{
'NeogitOrg/neogit',
dependencies = {
'sindrets/diffview.nvim',
'nvim-telescope/telescope.nvim'
},
cmd = 'Neogit',
keys = {
{ '<Leader>mg', '<cmd>Neogit<CR>', desc = 'Neogit' },
},
-- See: https://github.com/TimUntersberger/neogit#configuration
opts = {
disable_signs = false,
disable_context_highlighting = false,
disable_commit_confirmation = false,
signs = {
section = { '>', 'v' },
item = { '>', 'v' },
hunk = { '', '' },
},
integrations = {
diffview = true,
},
},
},
-----------------------------------------------------------------------------
{
'FabijanZulj/blame.nvim',
cmd = 'ToggleBlame',
-- stylua: ignore
keys = {
{ '<leader>gb', '<cmd>ToggleBlame virtual<CR>', desc = 'Git blame' },
{ '<leader>gB', '<cmd>ToggleBlame window<CR>', desc = 'Git blame (window)' },
},
opts = {
date_format = '%Y-%m-%d %H:%M',
},
},
-----------------------------------------------------------------------------
{
'rhysd/git-messenger.vim',
cmd = 'GitMessenger',
keys = {
{ '<Leader>gm', '<Plug>(git-messenger)', desc = 'Git messenger'}
},
init = function()
vim.g.git_messenger_include_diff = 'current'
vim.g.git_messenger_no_default_mappings = false
vim.g.git_messenger_floating_win_opts = { border = 'rounded' }
end,
},
-----------------------------------------------------------------------------
{
'ruifm/gitlinker.nvim',
keys = {
{
'<leader>go',
function()
require('gitlinker').get_buf_range_url('n')
end,
silent = true,
desc = 'Git open in browser',
},
{
'<leader>go',
function()
require('gitlinker').get_buf_range_url('v')
end,
mode = 'x',
desc = 'Git open in browser',
},
},
opts = {
mappings = nil,
opts = {
add_current_line_on_normal_mode = true,
print_url = false,
action_callback = function(...)
return require('gitlinker.actions').open_in_browser(...)
end,
},
},
},
-----------------------------------------------------------------------------
{
'rhysd/committia.vim',
event = 'BufReadPre COMMIT_EDITMSG',
init = function()
-- See: https://github.com/rhysd/committia.vim#variables
vim.g.committia_min_window_width = 30
vim.g.committia_edit_window_width = 75
end,
config = function()
vim.g.committia_hooks = {
edit_open = function()
vim.cmd.resize(10)
local opts = {
buffer = vim.api.nvim_get_current_buf(),
silent = true,
}
local function imap(lhs, rhs)
vim.keymap.set('i', lhs, rhs, opts)
end
imap('<C-d>', '<Plug>(committia-scroll-diff-down-half)')
imap('<C-u>', '<Plug>(committia-scroll-diff-up-half)')
imap('<C-f>', '<Plug>(committia-scroll-diff-down-page)')
imap('<C-b>', '<Plug>(committia-scroll-diff-up-page)')
imap('<C-j>', '<Plug>(committia-scroll-diff-down)')
imap('<C-k>', '<Plug>(committia-scroll-diff-up)')
end,
}
end,
},
}

View File

@ -1,166 +0,0 @@
-- LSP: Auto-format on save
-- 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/plugins/lsp/format.lua
local M = {}
---@type PluginLspOpts
M.opts = nil
function M.enabled()
return M.opts.autoformat
end
function M.toggle()
if vim.b.autoformat == false then
vim.b.autoformat = nil
M.opts.autoformat = true
else
M.opts.autoformat = not M.opts.autoformat
end
local msg = M.opts.autoformat and 'Enabled' or 'Disabled'
vim.notify(
msg .. ' format on save',
vim.log.levels.INFO,
{ title = 'Format' }
)
end
---@param opts? {force?:boolean}
function M.format(opts)
local buf = vim.api.nvim_get_current_buf()
if vim.b.autoformat == false and not (opts and opts.force) then
return
end
local formatters = M.get_formatters(buf)
local client_ids = vim.tbl_map(function(client)
return client.id
end, formatters.active)
if #client_ids == 0 then
return
end
if M.opts.format_notify then
M.notify(formatters)
end
vim.lsp.buf.format(vim.tbl_deep_extend('force', {
bufnr = buf,
filter = function(client)
return vim.tbl_contains(client_ids, client.id)
end,
}, require('plex.lib.utils').opts('nvim-lspconfig').format or {}))
end
---@param formatters LazyVimFormatters
function M.notify(formatters)
local lines = { '# Active:' }
for _, client in ipairs(formatters.active) do
local line = '- **' .. client.name .. '**'
if client.name == 'null-ls' then
line = line
.. ' ('
.. table.concat(
vim.tbl_map(function(f)
return '`' .. f.name .. '`'
end, formatters.null_ls),
', '
)
.. ')'
end
table.insert(lines, line)
end
if #formatters.available > 0 then
table.insert(lines, '')
table.insert(lines, '# Disabled:')
for _, client in ipairs(formatters.available) do
table.insert(lines, '- **' .. client.name .. '**')
end
end
vim.notify(table.concat(lines, '\n'), vim.log.levels.INFO, {
title = 'Formatting',
on_open = function(win)
local scope = { scope = 'local', win = win }
vim.api.nvim_set_option_value('conceallevel', 3, scope)
vim.api.nvim_set_option_value('spell', false, scope)
local buf = vim.api.nvim_win_get_buf(win)
vim.treesitter.start(buf, 'markdown')
end,
})
end
-- Gets all lsp clients that support formatting.
-- When a null-ls formatter is available for the current filetype,
-- only null-ls formatters are returned.
function M.get_formatters(bufnr)
local ft = vim.bo[bufnr].filetype
-- check if we have any null-ls formatters for the current filetype
local null_ls = package.loaded['null-ls']
and require('null-ls.sources').get_available(ft, 'NULL_LS_FORMATTING')
or {}
---@class LazyVimFormatters
local ret = {
---@type lsp.Client[]
active = {},
---@type lsp.Client[]
available = {},
null_ls = null_ls,
}
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
for _, client in ipairs(clients) do
if M.supports_format(client) then
if (#null_ls > 0 and client.name == 'null-ls') or #null_ls == 0 then
table.insert(ret.active, client)
else
table.insert(ret.available, client)
end
end
end
return ret
end
-- Gets all lsp clients that support formatting
-- and have not disabled it in their client config
---@param client lsp.Client
function M.supports_format(client)
if
client.config
and client.config.capabilities
and client.config.capabilities['documentFormattingProvider'] == false
then
return false
end
return client.supports_method('textDocument/formatting')
or client.supports_method('textDocument/rangeFormatting')
end
---@param opts PluginLspOpts
function M.setup(opts)
M.opts = opts
vim.api.nvim_create_autocmd('BufWritePre', {
group = vim.api.nvim_create_augroup('plex_format', {}),
callback = function()
if M.opts.autoformat then
M.format()
end
end,
})
end
return M

View File

@ -1,47 +0,0 @@
-- LSP: Highlights
-- https://github.com/rafi/vim-config
-- This is part of LunarVim's code, with my modifications.
-- Reference: https://github.com/LunarVim/LunarVim
local M = {}
---@param client lsp.Client
---@param bufnr integer
function M.on_attach(client, bufnr)
if require('plex.lib.utils').has('vim-illuminate') then
-- Skipped setup for document_highlight, illuminate is installed.
return
end
local status_ok, highlight_supported = pcall(function()
return client.supports_method('textDocument/documentHighlight')
end)
if not status_ok or not highlight_supported then
return
end
local group_name = 'lsp_document_highlight'
local ok, hl_autocmds = pcall(vim.api.nvim_get_autocmds, {
group = group_name,
buffer = bufnr,
event = 'CursorHold',
})
if ok and #hl_autocmds > 0 then
return
end
vim.api.nvim_create_augroup(group_name, { clear = false })
vim.api.nvim_create_autocmd('CursorHold', {
group = group_name,
buffer = bufnr,
callback = vim.lsp.buf.document_highlight,
})
vim.api.nvim_create_autocmd('CursorMoved', {
group = group_name,
buffer = bufnr,
callback = vim.lsp.buf.clear_references,
})
end
return M

View File

@ -1,335 +0,0 @@
-- LSP: Plugins
-- 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/plugins/lsp/init.lua
return {
-----------------------------------------------------------------------------
{
'neovim/nvim-lspconfig',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = {
{ 'folke/neoconf.nvim', cmd = 'Neoconf', config = false, dependencies = { 'nvim-lspconfig' } },
{ 'folke/neodev.nvim', opts = {} },
'williamboman/mason.nvim',
'williamboman/mason-lspconfig.nvim',
{
'hrsh7th/cmp-nvim-lsp',
cond = function()
return require('plex.lib.utils').has('nvim-cmp')
end,
},
},
---@class PluginLspOpts
opts = {
-- Options for vim.diagnostic.config()
diagnostics = {
signs = true,
underline = true,
update_in_insert = false,
virtual_text = {
spacing = 4,
source = 'if_many',
prefix = '',
},
severity_sort = true,
float = {
show_header = true,
border = 'rounded',
source = 'always',
},
},
-- Enable this to enable the builtin LSP inlay hints on Neovim >= 0.10.0
-- Be aware that you also will need to properly configure your LSP server to
-- provide the inlay hints.
inlay_hints = {
enabled = false,
},
-- Add any global capabilities here
capabilities = {},
-- Automatically format on save
autoformat = false,
-- Options for vim.lsp.buf.format
-- `bufnr` and `filter` is handled by the formatter,
-- but can be also overridden when specified
format = {
formatting_options = nil,
timeout_ms = nil,
},
-- Enable this to show formatters used in a notification
-- Useful for debugging formatter issues
format_notify = false,
-- LSP Server Settings
---@type lspconfig.options
---@diagnostic disable: missing-fields
servers = {
-- jsonls = {},
lua_ls = {
settings = {
Lua = {
workspace = { checkThirdParty = false },
completion = { callSnippet = 'Replace' },
},
},
},
texlab = {
}
},
-- you can do any additional lsp server setup here
-- return true if you don't want this server to be setup with lspconfig
---@type table<string, fun(server:string, opts:_.lspconfig.options):boolean?>
setup = {
-- example to setup with typescript.nvim
-- tsserver = function(_, opts)
-- require('typescript').setup({ server = opts })
-- return true
-- end,
-- Specify * to use this function as a fallback for any server
-- ['*'] = function(server, opts) end,
},
},
---@param opts PluginLspOpts
config = function(_, opts)
if require('plex.lib.utils').has('neoconf.nvim') then
local plugin = require('lazy.core.config').spec.plugins['neoconf.nvim']
require('neoconf').setup(require('lazy.core.plugin').values(plugin, 'opts', false))
end
-- Setup autoformat
require('plex.plugins.lsp.format').setup(opts)
-- Setup formatting, keymaps and highlights.
local lsp_on_attach = require('plex.lib.utils').on_attach
---@param client lsp.Client
---@param buffer integer
lsp_on_attach(function(client, buffer)
require('plex.plugins.lsp.keymaps').on_attach(client, buffer)
require('plex.plugins.lsp.highlight').on_attach(client, buffer)
if vim.diagnostic.is_disabled() or vim.bo[buffer].buftype ~= '' then
vim.diagnostic.disable(buffer)
return
end
end)
local register_capability = vim.lsp.handlers['client/registerCapability']
---@diagnostic disable-next-line: duplicate-set-field
vim.lsp.handlers['client/registerCapability'] = function(err, res, ctx)
local ret = register_capability(err, res, ctx)
local client_id = ctx.client_id
---@type lsp.Client|nil
local client = vim.lsp.get_client_by_id(client_id)
local buffer = vim.api.nvim_get_current_buf()
if client ~= nil then
require('plex.plugins.lsp.keymaps').on_attach(client, buffer)
end
return ret
end
-- Diagnostics signs and highlights
for type, icon in pairs(require('plex.config').icons.diagnostics) do
local hl = 'DiagnosticSign' .. type
vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = '' })
end
-- Setup inlay-hints
local inlay_hint = vim.lsp.buf.inlay_hint or vim.lsp.inlay_hint
if opts.inlay_hints.enabled and inlay_hint then
lsp_on_attach(function(client, buffer)
if client.supports_method('textDocument/inlayHint') then
inlay_hint(buffer, true)
end
end)
end
if
type(opts.diagnostics.virtual_text) == 'table'
and opts.diagnostics.virtual_text.prefix == 'icons'
then
opts.diagnostics.virtual_text.prefix = vim.fn.has('nvim-0.10') == 0
and ''
or function(diagnostic)
local icons = require('plex.config').icons.diagnostics
for d, icon in pairs(icons) do
if diagnostic.severity == vim.diagnostic.severity[d:upper()] then
return icon
end
end
end
end
vim.diagnostic.config(vim.deepcopy(opts.diagnostics))
-- Initialize LSP servers and ensure Mason packages
-- Setup base config for all servers.
local servers = opts.servers
local has_cmp, cmp_nvim_lsp = pcall(require, 'cmp_nvim_lsp')
local capabilities = vim.tbl_deep_extend(
'force',
{},
vim.lsp.protocol.make_client_capabilities(),
has_cmp and cmp_nvim_lsp.default_capabilities() or {},
opts.capabilities or {}
)
-- Combine base config for each server and merge user-defined settings.
-- These can be overridden locally by lua/lsp/<server_name>.lua
---@param server_name string
local function make_config(server_name)
local server_opts = vim.tbl_deep_extend('force', {
capabilities = vim.deepcopy(capabilities),
}, servers[server_name] or {})
if opts.setup[server_name] then
if opts.setup[server_name](server_name, server_opts) then
return
end
elseif opts.setup['*'] then
if opts.setup['*'](server_name, server_opts) then
return
end
end
local exists, module = pcall(require, 'lsp.' .. server_name)
if exists and module ~= nil then
local user_config = module.config(server_opts) or {}
server_opts = vim.tbl_deep_extend('force', server_opts, user_config)
end
require('lspconfig')[server_name].setup(server_opts)
end
-- Get all the servers that are available thourgh mason-lspconfig
local have_mason, mlsp = pcall(require, 'mason-lspconfig')
local all_mslp_servers = {}
if have_mason then
all_mslp_servers = vim.tbl_keys(
require('mason-lspconfig.mappings.server').lspconfig_to_package
)
end
local ensure_installed = {} ---@type string[]
for server, server_opts in pairs(servers) do
if server_opts then
server_opts = server_opts == true and {} or server_opts
-- run manual setup if mason=false or if this is a server that cannot
-- be installed with mason-lspconfig
if
server_opts.mason == false
or not vim.tbl_contains(all_mslp_servers, server)
then
make_config(server)
else
ensure_installed[#ensure_installed + 1] = server
end
end
end
if have_mason then
mlsp.setup({
ensure_installed = ensure_installed,
handlers = { make_config },
})
end
-- Enable rounded borders in :LspInfo window.
require('lspconfig.ui.windows').default_options.border = 'rounded'
end,
},
-----------------------------------------------------------------------------
{
'williamboman/mason.nvim',
cmd = 'Mason',
build = ':MasonUpdate',
keys = { { '<leader>mm', '<cmd>Mason<cr>', desc = 'Mason' } },
opts = {
ensure_installed = {
'rust-analyzer',
'clangd',
'pyright',
'bash-language-server',
'codelldb',
},
ui = {
border = 'rounded',
},
},
---@param opts MasonSettings | {ensure_installed: string[]}
config = function(_, opts)
require('mason').setup(opts)
local mr = require('mason-registry')
local function ensure_installed()
for _, tool in ipairs(opts.ensure_installed) do
local p = mr.get_package(tool)
if not p:is_installed() then
p:install()
end
end
end
if mr.refresh then
mr.refresh(ensure_installed)
else
ensure_installed()
end
end,
},
-----------------------------------------------------------------------------
{
'mhartington/formatter.nvim',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = { 'williamboman/mason.nvim', 'neovim/nvim-lspconfig' },
opts = function(_, opts)
opts = opts or {}
local defaults = {
logging = true,
log_level = vim.log.levels.WARN,
filetype = {
lua = { require('formatter.filetypes.lua').stylua },
},
}
opts = vim.tbl_extend('keep', opts, defaults)
return opts
end,
config = true,
},
-----------------------------------------------------------------------------
{
'dnlhc/glance.nvim',
cmd = 'Glance',
keys = {
{ 'gpd', '<cmd>Glance definitions<CR>' },
{ 'gpr', '<cmd>Glance references<CR>' },
{ 'gpy', '<cmd>Glance type_definitions<CR>' },
{ 'gpi', '<cmd>Glance implementations<CR>' },
},
opts = function()
local actions = require('glance').actions
return {
folds = {
fold_closed = '󰅂', -- 󰅂 
fold_open = '󰅀', -- 󰅀 
folded = true,
},
mappings = {
list = {
['<C-u>'] = actions.preview_scroll_win(5),
['<C-d>'] = actions.preview_scroll_win(-5),
['sg'] = actions.jump_vsplit,
['sv'] = actions.jump_split,
['st'] = actions.jump_tab,
['p'] = actions.enter_win('preview'),
},
preview = {
['q'] = actions.close,
['p'] = actions.enter_win('list'),
},
},
}
end,
},
}

Some files were not shown because too many files have changed in this diff Show More