commit 99b722e36ef09e336d59b3c5b797c702d82bdf0b · hyperreal.bsky.moonshadow.dev/dotfiles

-8

config/nvim/.gitignore

-15

config/nvim/.neoconf.json

···

       1
       1
       -
       {

     

       2
       2
       -
         "neodev": {

     

       3
       3
       -
           "library": {

     

       4
       4
       -
             "enabled": true,

     

       5
       5
       -
             "plugins": true

     

       6
       6
       -
           }

     

       7
       7
       -
         },

     

       8
       8
       -
         "neoconf": {

     

       9
       9
       -
           "plugins": {

     

       10
       10
       -
             "lua_ls": {

     

       11
       11
       -
               "enabled": true

     

       12
       12
       -
             }

     

       13
       13
       -
           }

     

       14
       14
       -
         }

     

       15
       15
       -
       }

config/nvim/.stylua.toml

···

       1
       1
       +
       column_width = 160

     

       2
       2
       +
       line_endings = "Unix"

     

       3
       3
       +
       indent_type = "Spaces"

     

       4
       4
       +
       indent_width = 2

     

       5
       5
       +
       quote_style = "AutoPreferSingle"

     

       6
       6
       +
       call_parentheses = "None"

-201

config/nvim/LICENSE

···

       1
       1
       -
                                        Apache License

     

       2
       2
       -
                                  Version 2.0, January 2004

     

       3
       3
       -
                               http://www.apache.org/licenses/

     

       4
       4
       -
       

     

       5
       5
       -
          TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

     

       6
       6
       -
       

     

       7
       7
       -
          1. Definitions.

     

       8
       8
       -
       

     

       9
       9
       -
             "License" shall mean the terms and conditions for use, reproduction,

     

       10
       10
       -
             and distribution as defined by Sections 1 through 9 of this document.

     

       11
       11
       -
       

     

       12
       12
       -
             "Licensor" shall mean the copyright owner or entity authorized by

     

       13
       13
       -
             the copyright owner that is granting the License.

     

       14
       14
       -
       

     

       15
       15
       -
             "Legal Entity" shall mean the union of the acting entity and all

     

       16
       16
       -
             other entities that control, are controlled by, or are under common

     

       17
       17
       -
             control with that entity. For the purposes of this definition,

     

       18
       18
       -
             "control" means (i) the power, direct or indirect, to cause the

     

       19
       19
       -
             direction or management of such entity, whether by contract or

     

       20
       20
       -
             otherwise, or (ii) ownership of fifty percent (50%) or more of the

     

       21
       21
       -
             outstanding shares, or (iii) beneficial ownership of such entity.

     

       22
       22
       -
       

     

       23
       23
       -
             "You" (or "Your") shall mean an individual or Legal Entity

     

       24
       24
       -
             exercising permissions granted by this License.

     

       25
       25
       -
       

     

       26
       26
       -
             "Source" form shall mean the preferred form for making modifications,

     

       27
       27
       -
             including but not limited to software source code, documentation

     

       28
       28
       -
             source, and configuration files.

     

       29
       29
       -
       

     

       30
       30
       -
             "Object" form shall mean any form resulting from mechanical

     

       31
       31
       -
             transformation or translation of a Source form, including but

     

       32
       32
       -
             not limited to compiled object code, generated documentation,

     

       33
       33
       -
             and conversions to other media types.

     

       34
       34
       -
       

     

       35
       35
       -
             "Work" shall mean the work of authorship, whether in Source or

     

       36
       36
       -
             Object form, made available under the License, as indicated by a

     

       37
       37
       -
             copyright notice that is included in or attached to the work

     

       38
       38
       -
             (an example is provided in the Appendix below).

     

       39
       39
       -
       

     

       40
       40
       -
             "Derivative Works" shall mean any work, whether in Source or Object

     

       41
       41
       -
             form, that is based on (or derived from) the Work and for which the

     

       42
       42
       -
             editorial revisions, annotations, elaborations, or other modifications

     

       43
       43
       -
             represent, as a whole, an original work of authorship. For the purposes

     

       44
       44
       -
             of this License, Derivative Works shall not include works that remain

     

       45
       45
       -
             separable from, or merely link (or bind by name) to the interfaces of,

     

       46
       46
       -
             the Work and Derivative Works thereof.

     

       47
       47
       -
       

     

       48
       48
       -
             "Contribution" shall mean any work of authorship, including

     

       49
       49
       -
             the original version of the Work and any modifications or additions

     

       50
       50
       -
             to that Work or Derivative Works thereof, that is intentionally

     

       51
       51
       -
             submitted to Licensor for inclusion in the Work by the copyright owner

     

       52
       52
       -
             or by an individual or Legal Entity authorized to submit on behalf of

     

       53
       53
       -
             the copyright owner. For the purposes of this definition, "submitted"

     

       54
       54
       -
             means any form of electronic, verbal, or written communication sent

     

       55
       55
       -
             to the Licensor or its representatives, including but not limited to

     

       56
       56
       -
             communication on electronic mailing lists, source code control systems,

     

       57
       57
       -
             and issue tracking systems that are managed by, or on behalf of, the

     

       58
       58
       -
             Licensor for the purpose of discussing and improving the Work, but

     

       59
       59
       -
             excluding communication that is conspicuously marked or otherwise

     

       60
       60
       -
             designated in writing by the copyright owner as "Not a Contribution."

     

       61
       61
       -
       

     

       62
       62
       -
             "Contributor" shall mean Licensor and any individual or Legal Entity

     

       63
       63
       -
             on behalf of whom a Contribution has been received by Licensor and

     

       64
       64
       -
             subsequently incorporated within the Work.

     

       65
       65
       -
       

     

       66
       66
       -
          2. Grant of Copyright License. Subject to the terms and conditions of

     

       67
       67
       -
             this License, each Contributor hereby grants to You a perpetual,

     

       68
       68
       -
             worldwide, non-exclusive, no-charge, royalty-free, irrevocable

     

       69
       69
       -
             copyright license to reproduce, prepare Derivative Works of,

     

       70
       70
       -
             publicly display, publicly perform, sublicense, and distribute the

     

       71
       71
       -
             Work and such Derivative Works in Source or Object form.

     

       72
       72
       -
       

     

       73
       73
       -
          3. Grant of Patent License. Subject to the terms and conditions of

     

       74
       74
       -
             this License, each Contributor hereby grants to You a perpetual,

     

       75
       75
       -
             worldwide, non-exclusive, no-charge, royalty-free, irrevocable

     

       76
       76
       -
             (except as stated in this section) patent license to make, have made,

     

       77
       77
       -
             use, offer to sell, sell, import, and otherwise transfer the Work,

     

       78
       78
       -
             where such license applies only to those patent claims licensable

     

       79
       79
       -
             by such Contributor that are necessarily infringed by their

     

       80
       80
       -
             Contribution(s) alone or by combination of their Contribution(s)

     

       81
       81
       -
             with the Work to which such Contribution(s) was submitted. If You

     

       82
       82
       -
             institute patent litigation against any entity (including a

     

       83
       83
       -
             cross-claim or counterclaim in a lawsuit) alleging that the Work

     

       84
       84
       -
             or a Contribution incorporated within the Work constitutes direct

     

       85
       85
       -
             or contributory patent infringement, then any patent licenses

     

       86
       86
       -
             granted to You under this License for that Work shall terminate

     

       87
       87
       -
             as of the date such litigation is filed.

     

       88
       88
       -
       

     

       89
       89
       -
          4. Redistribution. You may reproduce and distribute copies of the

     

       90
       90
       -
             Work or Derivative Works thereof in any medium, with or without

     

       91
       91
       -
             modifications, and in Source or Object form, provided that You

     

       92
       92
       -
             meet the following conditions:

     

       93
       93
       -
       

     

       94
       94
       -
             (a) You must give any other recipients of the Work or

     

       95
       95
       -
                 Derivative Works a copy of this License; and

     

       96
       96
       -
       

     

       97
       97
       -
             (b) You must cause any modified files to carry prominent notices

     

       98
       98
       -
                 stating that You changed the files; and

     

       99
       99
       -
       

     

       100
       100
       -
             (c) You must retain, in the Source form of any Derivative Works

     

       101
       101
       -
                 that You distribute, all copyright, patent, trademark, and

     

       102
       102
       -
                 attribution notices from the Source form of the Work,

     

       103
       103
       -
                 excluding those notices that do not pertain to any part of

     

       104
       104
       -
                 the Derivative Works; and

     

       105
       105
       -
       

     

       106
       106
       -
             (d) If the Work includes a "NOTICE" text file as part of its

     

       107
       107
       -
                 distribution, then any Derivative Works that You distribute must

     

       108
       108
       -
                 include a readable copy of the attribution notices contained

     

       109
       109
       -
                 within such NOTICE file, excluding those notices that do not

     

       110
       110
       -
                 pertain to any part of the Derivative Works, in at least one

     

       111
       111
       -
                 of the following places: within a NOTICE text file distributed

     

       112
       112
       -
                 as part of the Derivative Works; within the Source form or

     

       113
       113
       -
                 documentation, if provided along with the Derivative Works; or,

     

       114
       114
       -
                 within a display generated by the Derivative Works, if and

     

       115
       115
       -
                 wherever such third-party notices normally appear. The contents

     

       116
       116
       -
                 of the NOTICE file are for informational purposes only and

     

       117
       117
       -
                 do not modify the License. You may add Your own attribution

     

       118
       118
       -
                 notices within Derivative Works that You distribute, alongside

     

       119
       119
       -
                 or as an addendum to the NOTICE text from the Work, provided

     

       120
       120
       -
                 that such additional attribution notices cannot be construed

     

       121
       121
       -
                 as modifying the License.

     

       122
       122
       -
       

     

       123
       123
       -
             You may add Your own copyright statement to Your modifications and

     

       124
       124
       -
             may provide additional or different license terms and conditions

     

       125
       125
       -
             for use, reproduction, or distribution of Your modifications, or

     

       126
       126
       -
             for any such Derivative Works as a whole, provided Your use,

     

       127
       127
       -
             reproduction, and distribution of the Work otherwise complies with

     

       128
       128
       -
             the conditions stated in this License.

     

       129
       129
       -
       

     

       130
       130
       -
          5. Submission of Contributions. Unless You explicitly state otherwise,

     

       131
       131
       -
             any Contribution intentionally submitted for inclusion in the Work

     

       132
       132
       -
             by You to the Licensor shall be under the terms and conditions of

     

       133
       133
       -
             this License, without any additional terms or conditions.

     

       134
       134
       -
             Notwithstanding the above, nothing herein shall supersede or modify

     

       135
       135
       -
             the terms of any separate license agreement you may have executed

     

       136
       136
       -
             with Licensor regarding such Contributions.

     

       137
       137
       -
       

     

       138
       138
       -
          6. Trademarks. This License does not grant permission to use the trade

     

       139
       139
       -
             names, trademarks, service marks, or product names of the Licensor,

     

       140
       140
       -
             except as required for reasonable and customary use in describing the

     

       141
       141
       -
             origin of the Work and reproducing the content of the NOTICE file.

     

       142
       142
       -
       

     

       143
       143
       -
          7. Disclaimer of Warranty. Unless required by applicable law or

     

       144
       144
       -
             agreed to in writing, Licensor provides the Work (and each

     

       145
       145
       -
             Contributor provides its Contributions) on an "AS IS" BASIS,

     

       146
       146
       -
             WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

     

       147
       147
       -
             implied, including, without limitation, any warranties or conditions

     

       148
       148
       -
             of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

     

       149
       149
       -
             PARTICULAR PURPOSE. You are solely responsible for determining the

     

       150
       150
       -
             appropriateness of using or redistributing the Work and assume any

     

       151
       151
       -
             risks associated with Your exercise of permissions under this License.

     

       152
       152
       -
       

     

       153
       153
       -
          8. Limitation of Liability. In no event and under no legal theory,

     

       154
       154
       -
             whether in tort (including negligence), contract, or otherwise,

     

       155
       155
       -
             unless required by applicable law (such as deliberate and grossly

     

       156
       156
       -
             negligent acts) or agreed to in writing, shall any Contributor be

     

       157
       157
       -
             liable to You for damages, including any direct, indirect, special,

     

       158
       158
       -
             incidental, or consequential damages of any character arising as a

     

       159
       159
       -
             result of this License or out of the use or inability to use the

     

       160
       160
       -
             Work (including but not limited to damages for loss of goodwill,

     

       161
       161
       -
             work stoppage, computer failure or malfunction, or any and all

     

       162
       162
       -
             other commercial damages or losses), even if such Contributor

     

       163
       163
       -
             has been advised of the possibility of such damages.

     

       164
       164
       -
       

     

       165
       165
       -
          9. Accepting Warranty or Additional Liability. While redistributing

     

       166
       166
       -
             the Work or Derivative Works thereof, You may choose to offer,

     

       167
       167
       -
             and charge a fee for, acceptance of support, warranty, indemnity,

     

       168
       168
       -
             or other liability obligations and/or rights consistent with this

     

       169
       169
       -
             License. However, in accepting such obligations, You may act only

     

       170
       170
       -
             on Your own behalf and on Your sole responsibility, not on behalf

     

       171
       171
       -
             of any other Contributor, and only if You agree to indemnify,

     

       172
       172
       -
             defend, and hold each Contributor harmless for any liability

     

       173
       173
       -
             incurred by, or claims asserted against, such Contributor by reason

     

       174
       174
       -
             of your accepting any such warranty or additional liability.

     

       175
       175
       -
       

     

       176
       176
       -
          END OF TERMS AND CONDITIONS

     

       177
       177
       -
       

     

       178
       178
       -
          APPENDIX: How to apply the Apache License to your work.

     

       179
       179
       -
       

     

       180
       180
       -
             To apply the Apache License to your work, attach the following

     

       181
       181
       -
             boilerplate notice, with the fields enclosed by brackets "[]"

     

       182
       182
       -
             replaced with your own identifying information. (Don't include

     

       183
       183
       -
             the brackets!)  The text should be enclosed in the appropriate

     

       184
       184
       -
             comment syntax for the file format. We also recommend that a

     

       185
       185
       -
             file or class name and description of purpose be included on the

     

       186
       186
       -
             same "printed page" as the copyright notice for easier

     

       187
       187
       -
             identification within third-party archives.

     

       188
       188
       -
       

     

       189
       189
       -
          Copyright [yyyy] [name of copyright owner]

     

       190
       190
       -
       

     

       191
       191
       -
          Licensed under the Apache License, Version 2.0 (the "License");

     

       192
       192
       -
          you may not use this file except in compliance with the License.

     

       193
       193
       -
          You may obtain a copy of the License at

     

       194
       194
       -
       

     

       195
       195
       -
              http://www.apache.org/licenses/LICENSE-2.0

     

       196
       196
       -
       

     

       197
       197
       -
          Unless required by applicable law or agreed to in writing, software

     

       198
       198
       -
          distributed under the License is distributed on an "AS IS" BASIS,

     

       199
       199
       -
          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

     

       200
       200
       -
          See the License for the specific language governing permissions and

     

       201
       201
       -
          limitations under the License.

+19

config/nvim/LICENSE.md

···

       1
       1
       +
       MIT License

     

       2
       2
       +
       

     

       3
       3
       +
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       4
       4
       +
       of this software and associated documentation files (the "Software"), to deal

     

       5
       5
       +
       in the Software without restriction, including without limitation the rights

     

       6
       6
       +
       to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       7
       7
       +
       copies of the Software, and to permit persons to whom the Software is

     

       8
       8
       +
       furnished to do so, subject to the following conditions:

     

       9
       9
       +
       

     

       10
       10
       +
       The above copyright notice and this permission notice shall be included in all

     

       11
       11
       +
       copies or substantial portions of the Software.

     

       12
       12
       +
       

     

       13
       13
       +
       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       14
       14
       +
       IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       15
       15
       +
       FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       16
       16
       +
       AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       17
       17
       +
       LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       18
       18
       +
       OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       19
       19
       +
       SOFTWARE.

+236 -5

config/nvim/README.md

···

       1
       1
       -
       # 💤 LazyVim

     

       1
       1
       +
       # kickstart.nvim

     

       2
       2
       +
       

     

       3
       3
       +
       ## Introduction

     

       4
       4
       +
       

     

       5
       5
       +
       A starting point for Neovim that is:

     

       6
       6
       +
       

     

       7
       7
       +
       * Small

     

       8
       8
       +
       * Single-file

     

       9
       9
       +
       * Completely Documented

     

       10
       10
       +
       

     

       11
       11
       +
       **NOT** a Neovim distribution, but instead a starting point for your configuration.

     

       12
       12
       +
       

     

       13
       13
       +
       ## Installation

     

       14
       14
       +
       

     

       15
       15
       +
       ### Install Neovim

     

       16
       16
       +
       

     

       17
       17
       +
       Kickstart.nvim targets *only* the latest

     

       18
       18
       +
       ['stable'](https://github.com/neovim/neovim/releases/tag/stable) and latest

     

       19
       19
       +
       ['nightly'](https://github.com/neovim/neovim/releases/tag/nightly) of Neovim.

     

       20
       20
       +
       If you are experiencing issues, please make sure you have the latest versions.

     

       21
       21
       +
       

     

       22
       22
       +
       ### Install External Dependencies

     

       23
       23
       +
       

     

       24
       24
       +
       External Requirements:

     

       25
       25
       +
       - Basic utils: `git`, `make`, `unzip`, C Compiler (`gcc`)

     

       26
       26
       +
       - [ripgrep](https://github.com/BurntSushi/ripgrep#installation)

     

       27
       27
       +
       - Clipboard tool (xclip/xsel/win32yank or other depending on the platform)

     

       28
       28
       +
       - A [Nerd Font](https://www.nerdfonts.com/): optional, provides various icons

     

       29
       29
       +
         - if you have it set `vim.g.have_nerd_font` in `init.lua` to true

     

       30
       30
       +
       - Emoji fonts (Ubuntu only, and only if you want emoji!) `sudo apt install fonts-noto-color-emoji`

     

       31
       31
       +
       - Language Setup:

     

       32
       32
       +
         - If you want to write Typescript, you need `npm`

     

       33
       33
       +
         - If you want to write Golang, you will need `go`

     

       34
       34
       +
         - etc.

     

       35
       35
       +
       

     

       36
       36
       +
       > **NOTE**

     

       37
       37
       +
       > See [Install Recipes](#Install-Recipes) for additional Windows and Linux specific notes

     

       38
       38
       +
       > and quick install snippets

     

       39
       39
       +
       

     

       40
       40
       +
       ### Install Kickstart

     

       41
       41
       +
       

     

       42
       42
       +
       > **NOTE**

     

       43
       43
       +
       > [Backup](#FAQ) your previous configuration (if any exists)

     

       44
       44
       +
       

     

       45
       45
       +
       Neovim's configurations are located under the following paths, depending on your OS:

     

       46
       46
       +
       

     

       47
       47
       +
       | OS | PATH |

     

       48
       48
       +
       | :- | :--- |

     

       49
       49
       +
       | Linux, MacOS | `$XDG_CONFIG_HOME/nvim`, `~/.config/nvim` |

     

       50
       50
       +
       | Windows (cmd)| `%localappdata%\nvim\` |

     

       51
       51
       +
       | Windows (powershell)| `$env:LOCALAPPDATA\nvim\` |

     

       52
       52
       +
       

     

       53
       53
       +
       #### Recommended Step

     

       54
       54
       +
       

     

       55
       55
       +
       [Fork](https://docs.github.com/en/get-started/quickstart/fork-a-repo) this repo

     

       56
       56
       +
       so that you have your own copy that you can modify, then install by cloning the

     

       57
       57
       +
       fork to your machine using one of the commands below, depending on your OS.

     

       58
       58
       +
       

     

       59
       59
       +
       > **NOTE**

     

       60
       60
       +
       > Your fork's URL will be something like this:

     

       61
       61
       +
       > `https://github.com/<your_github_username>/kickstart.nvim.git`

     

       62
       62
       +
       

     

       63
       63
       +
       You likely want to remove `lazy-lock.json` from your fork's `.gitignore` file

     

       64
       64
       +
       too - it's ignored in the kickstart repo to make maintenance easier, but it's

     

       65
       65
       +
       [recommended to track it in version control](https://lazy.folke.io/usage/lockfile).

     

       66
       66
       +
       

     

       67
       67
       +
       #### Clone kickstart.nvim

     

       68
       68
       +
       > **NOTE**

     

       69
       69
       +
       > If following the recommended step above (i.e., forking the repo), replace

     

       70
       70
       +
       > `nvim-lua` with `<your_github_username>` in the commands below

     

       71
       71
       +
       

     

       72
       72
       +
       <details><summary> Linux and Mac </summary>

     

       73
       73
       +
       

     

       74
       74
       +
       ```sh

     

       75
       75
       +
       git clone https://github.com/nvim-lua/kickstart.nvim.git "${XDG_CONFIG_HOME:-$HOME/.config}"/nvim

     

       76
       76
       +
       ```

     

       77
       77
       +
       

     

       78
       78
       +
       </details>

     

       79
       79
       +
       

     

       80
       80
       +
       <details><summary> Windows </summary>

     

       81
       81
       +
       

     

       82
       82
       +
       If you're using `cmd.exe`:

     

       83
       83
       +
       

     

       84
       84
       +
       ```

     

       85
       85
       +
       git clone https://github.com/nvim-lua/kickstart.nvim.git "%localappdata%\nvim"

     

       86
       86
       +
       ```

     

       87
       87
       +
       

     

       88
       88
       +
       If you're using `powershell.exe`

     

       89
       89
       +
       

     

       90
       90
       +
       ```

     

       91
       91
       +
       git clone https://github.com/nvim-lua/kickstart.nvim.git "${env:LOCALAPPDATA}\nvim"

     

       92
       92
       +
       ```

     

       93
       93
       +
       

     

       94
       94
       +
       </details>

     

       95
       95
       +
       

     

       96
       96
       +
       ### Post Installation

     

       97
       97
       +
       

     

       98
       98
       +
       Start Neovim

     

       99
       99
       +
       

     

       100
       100
       +
       ```sh

     

       101
       101
       +
       nvim

     

       102
       102
       +
       ```

     

       103
       103
       +
       

     

       104
       104
       +
       That's it! Lazy will install all the plugins you have. Use `:Lazy` to view

     

       105
       105
       +
       the current plugin status. Hit `q` to close the window.

     

       106
       106
       +
       

     

       107
       107
       +
       #### Read The Friendly Documentation

     

       108
       108
       +
       

     

       109
       109
       +
       Read through the `init.lua` file in your configuration folder for more

     

       110
       110
       +
       information about extending and exploring Neovim. That also includes

     

       111
       111
       +
       examples of adding popularly requested plugins.

     

       112
       112
       +
       

     

       113
       113
       +
       > [!NOTE]

     

       114
       114
       +
       > For more information about a particular plugin check its repository's documentation.

     

       115
       115
       +
       

     

       116
       116
       +
       

     

       117
       117
       +
       ### Getting Started

     

       118
       118
       +
       

     

       119
       119
       +
       [The Only Video You Need to Get Started with Neovim](https://youtu.be/m8C0Cq9Uv9o)

     

       120
       120
       +
       

     

       121
       121
       +
       ### FAQ

     

       2
       122
        
       

     

       3
       3
       -
       A starter template for [LazyVim](https://github.com/LazyVim/LazyVim).

     

       4
       4
       -
       Refer to the [documentation](https://lazyvim.github.io/installation) to get started.

     

       123
       123
       +
       * What should I do if I already have a pre-existing Neovim configuration?

     

       124
       124
       +
         * You should back it up and then delete all associated files.

     

       125
       125
       +
         * This includes your existing init.lua and the Neovim files in `~/.local`

     

       126
       126
       +
           which can be deleted with `rm -rf ~/.local/share/nvim/`

     

       127
       127
       +
       * Can I keep my existing configuration in parallel to kickstart?

     

       128
       128
       +
         * Yes! You can use [NVIM_APPNAME](https://neovim.io/doc/user/starting.html#%24NVIM_APPNAME)`=nvim-NAME`

     

       129
       129
       +
           to maintain multiple configurations. For example, you can install the kickstart

     

       130
       130
       +
           configuration in `~/.config/nvim-kickstart` and create an alias:

     

       131
       131
       +
           ```

     

       132
       132
       +
           alias nvim-kickstart='NVIM_APPNAME="nvim-kickstart" nvim'

     

       133
       133
       +
           ```

     

       134
       134
       +
           When you run Neovim using `nvim-kickstart` alias it will use the alternative

     

       135
       135
       +
           config directory and the matching local directory

     

       136
       136
       +
           `~/.local/share/nvim-kickstart`. You can apply this approach to any Neovim

     

       137
       137
       +
           distribution that you would like to try out.

     

       138
       138
       +
       * What if I want to "uninstall" this configuration:

     

       139
       139
       +
         * See [lazy.nvim uninstall](https://lazy.folke.io/usage#-uninstalling) information

     

       140
       140
       +
       * Why is the kickstart `init.lua` a single file? Wouldn't it make sense to split it into multiple files?

     

       141
       141
       +
         * The main purpose of kickstart is to serve as a teaching tool and a reference

     

       142
       142
       +
           configuration that someone can easily use to `git clone` as a basis for their own.

     

       143
       143
       +
           As you progress in learning Neovim and Lua, you might consider splitting `init.lua`

     

       144
       144
       +
           into smaller parts. A fork of kickstart that does this while maintaining the

     

       145
       145
       +
           same functionality is available here:

     

       146
       146
       +
           * [kickstart-modular.nvim](https://github.com/dam9000/kickstart-modular.nvim)

     

       147
       147
       +
         * Discussions on this topic can be found here:

     

       148
       148
       +
           * [Restructure the configuration](https://github.com/nvim-lua/kickstart.nvim/issues/218)

     

       149
       149
       +
           * [Reorganize init.lua into a multi-file setup](https://github.com/nvim-lua/kickstart.nvim/pull/473)

     

       5
       150
        
       

     

       6
       6
       -
       And now, a word from this repo's maintainer:

     

       151
       151
       +
       ### Install Recipes

     

       152
       152
       +
       

     

       153
       153
       +
       Below you can find OS specific install instructions for Neovim and dependencies.

     

       154
       154
       +
       

     

       155
       155
       +
       After installing all the dependencies continue with the [Install Kickstart](#Install-Kickstart) step.

     

       156
       156
       +
       

     

       157
       157
       +
       #### Windows Installation

     

       158
       158
       +
       

     

       159
       159
       +
       <details><summary>Windows with Microsoft C++ Build Tools and CMake</summary>

     

       160
       160
       +
       Installation may require installing build tools and updating the run command for `telescope-fzf-native`

     

       161
       161
       +
       

     

       162
       162
       +
       See `telescope-fzf-native` documentation for [more details](https://github.com/nvim-telescope/telescope-fzf-native.nvim#installation)

     

       7
       163
        
       

     

       8
       8
       -
       > i don't wanna learn lua. am use lazyvim instead. am pick up along teh way.

     

       164
       164
       +
       This requires:

     

       165
       165
       +
       

     

       166
       166
       +
       - Install CMake and the Microsoft C++ Build Tools on Windows

     

       167
       167
       +
       

     

       168
       168
       +
       ```lua

     

       169
       169
       +
       {'nvim-telescope/telescope-fzf-native.nvim', build = 'cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release && cmake --build build --config Release && cmake --install build --prefix build' }

     

       170
       170
       +
       ```

     

       171
       171
       +
       </details>

     

       172
       172
       +
       <details><summary>Windows with gcc/make using chocolatey</summary>

     

       173
       173
       +
       Alternatively, one can install gcc and make which don't require changing the config,

     

       174
       174
       +
       the easiest way is to use choco:

     

       175
       175
       +
       

     

       176
       176
       +
       1. install [chocolatey](https://chocolatey.org/install)

     

       177
       177
       +
       either follow the instructions on the page or use winget,

     

       178
       178
       +
       run in cmd as **admin**:

     

       179
       179
       +
       ```

     

       180
       180
       +
       winget install --accept-source-agreements chocolatey.chocolatey

     

       181
       181
       +
       ```

     

       182
       182
       +
       

     

       183
       183
       +
       2. install all requirements using choco, exit the previous cmd and

     

       184
       184
       +
       open a new one so that choco path is set, and run in cmd as **admin**:

     

       185
       185
       +
       ```

     

       186
       186
       +
       choco install -y neovim git ripgrep wget fd unzip gzip mingw make

     

       187
       187
       +
       ```

     

       188
       188
       +
       </details>

     

       189
       189
       +
       <details><summary>WSL (Windows Subsystem for Linux)</summary>

     

       190
       190
       +
       

     

       191
       191
       +
       ```

     

       192
       192
       +
       wsl --install

     

       193
       193
       +
       wsl

     

       194
       194
       +
       sudo add-apt-repository ppa:neovim-ppa/unstable -y

     

       195
       195
       +
       sudo apt update

     

       196
       196
       +
       sudo apt install make gcc ripgrep unzip git xclip neovim

     

       197
       197
       +
       ```

     

       198
       198
       +
       </details>

     

       199
       199
       +
       

     

       200
       200
       +
       #### Linux Install

     

       201
       201
       +
       <details><summary>Ubuntu Install Steps</summary>

     

       202
       202
       +
       

     

       203
       203
       +
       ```

     

       204
       204
       +
       sudo add-apt-repository ppa:neovim-ppa/unstable -y

     

       205
       205
       +
       sudo apt update

     

       206
       206
       +
       sudo apt install make gcc ripgrep unzip git xclip neovim

     

       207
       207
       +
       ```

     

       208
       208
       +
       </details>

     

       209
       209
       +
       <details><summary>Debian Install Steps</summary>

     

       210
       210
       +
       

     

       211
       211
       +
       ```

     

       212
       212
       +
       sudo apt update

     

       213
       213
       +
       sudo apt install make gcc ripgrep unzip git xclip curl

     

       214
       214
       +
       

     

       215
       215
       +
       # Now we install nvim

     

       216
       216
       +
       curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim-linux-x86_64.tar.gz

     

       217
       217
       +
       sudo rm -rf /opt/nvim-linux-x86_64

     

       218
       218
       +
       sudo mkdir -p /opt/nvim-linux-x86_64

     

       219
       219
       +
       sudo chmod a+rX /opt/nvim-linux-x86_64

     

       220
       220
       +
       sudo tar -C /opt -xzf nvim-linux-x86_64.tar.gz

     

       221
       221
       +
       

     

       222
       222
       +
       # make it available in /usr/local/bin, distro installs to /usr/bin

     

       223
       223
       +
       sudo ln -sf /opt/nvim-linux-x86_64/bin/nvim /usr/local/bin/

     

       224
       224
       +
       ```

     

       225
       225
       +
       </details>

     

       226
       226
       +
       <details><summary>Fedora Install Steps</summary>

     

       227
       227
       +
       

     

       228
       228
       +
       ```

     

       229
       229
       +
       sudo dnf install -y gcc make git ripgrep fd-find unzip neovim

     

       230
       230
       +
       ```

     

       231
       231
       +
       </details>

     

       232
       232
       +
       

     

       233
       233
       +
       <details><summary>Arch Install Steps</summary>

     

       234
       234
       +
       

     

       235
       235
       +
       ```

     

       236
       236
       +
       sudo pacman -S --noconfirm --needed gcc make git ripgrep fd unzip neovim

     

       237
       237
       +
       ```

     

       238
       238
       +
       </details>

     

       239
       239
       +

+24

config/nvim/doc/kickstart.txt

···

       1
       1
       +
       ================================================================================

     

       2
       2
       +
       INTRODUCTION                                                  *kickstart.nvim*

     

       3
       3
       +
       

     

       4
       4
       +
       Kickstart.nvim is a project to help you get started on your neovim journey.

     

       5
       5
       +
       

     

       6
       6
       +
                                                                   *kickstart-is-not*

     

       7
       7
       +
       It is not:

     

       8
       8
       +
       - Complete framework for every plugin under the sun

     

       9
       9
       +
       - Place to add every plugin that could ever be useful

     

       10
       10
       +
       

     

       11
       11
       +
                                                                       *kickstart-is*

     

       12
       12
       +
       It is:

     

       13
       13
       +
       - Somewhere that has a good start for the most common "IDE" type features:

     

       14
       14
       +
           - autocompletion

     

       15
       15
       +
           - goto-definition

     

       16
       16
       +
           - find references

     

       17
       17
       +
           - fuzzy finding

     

       18
       18
       +
           - and hinting at what more can be done :)

     

       19
       19
       +
       - A place to _kickstart_ your journey.

     

       20
       20
       +
           - You should fork this project and use/modify it so that it matches your

     

       21
       21
       +
             style and preferences. If you don't want to do that, there are probably

     

       22
       22
       +
             other projects that would fit much better for you (and that's great!)!

     

       23
       23
       +
       

     

       24
       24
       +
        vim:tw=78:ts=8:ft=help:norl:

config/nvim/doc/tags

···

       1
       1
       +
       kickstart-is	kickstart.txt	/*kickstart-is*

     

       2
       2
       +
       kickstart-is-not	kickstart.txt	/*kickstart-is-not*

     

       3
       3
       +
       kickstart.nvim	kickstart.txt	/*kickstart.nvim*

+27 -2

config/nvim/init.lua

···

       1
       1
       -
       -- bootstrap lazy.nvim, LazyVim and your plugins

     

       2
       2
       -
       require("config.lazy")

     

       1
       1
       +
       -- hyperreal's Neovim config

     

       2
       2
       +
       

     

       3
       3
       +
       -- Set <space> as the leader key

     

       4
       4
       +
       -- See `:help mapleader`

     

       5
       5
       +
       --  NOTE: Must happen before plugins are loaded (otherwise wrong leader will be used)

     

       6
       6
       +
       vim.g.mapleader = ' '

     

       7
       7
       +
       vim.g.maplocalleader = ' '

     

       8
       8
       +
       

     

       9
       9
       +
       -- Set to true if you have a Nerd Font installed and selected in the terminal

     

       10
       10
       +
       vim.g.have_nerd_font = true

     

       11
       11
       +
       

     

       12
       12
       +
       -- [[ Setting options ]]

     

       13
       13
       +
       require 'options'

     

       14
       14
       +
       

     

       15
       15
       +
       -- [[ Basic keymaps ]]

     

       16
       16
       +
       require 'keymaps'

     

       17
       17
       +
       

     

       18
       18
       +
       -- [[ Basic autocommands ]]

     

       19
       19
       +
       require 'autocommands'

     

       20
       20
       +
       

     

       21
       21
       +
       -- [[ Install `lazy.nvim` plugin manager ]]

     

       22
       22
       +
       require 'lazy-bootstrap'

     

       23
       23
       +
       

     

       24
       24
       +
       -- [[ Configure and install plugins ]]

     

       25
       25
       +
       require 'lazy-plugins'

     

       26
       26
       +
       

     

       27
       27
       +
       -- vim: ts=2 sts=2 sw=2 et

+23 -42

config/nvim/lazy-lock.json

···

       1
       1
        
       {

     

       2
       2
       -
         "LazyVim": { "branch": "main", "commit": "28db03f958d58dfff3c647ce28fdc1cb88ac158d" },

     

       3
       3
       -
         "SchemaStore.nvim": { "branch": "main", "commit": "eed1834170f343c14a6768f085b26b3571a55302" },

     

       4
       4
       -
         "bufferline.nvim": { "branch": "main", "commit": "655133c3b4c3e5e05ec549b9f8cc2894ac6f51b3" },

     

       5
       5
       -
         "catppuccin": { "branch": "main", "commit": "234fc048de931a0e42ebcad675bf6559d75e23df" },

     

       6
       6
       -
         "cmp-buffer": { "branch": "main", "commit": "b74fab3656eea9de20a9b8116afa3cfc4ec09657" },

     

       7
       7
       -
         "cmp-git": { "branch": "main", "commit": "b24309c386c9666c549a1abaedd4956541676d06" },

     

       8
       8
       -
         "cmp-nvim-lsp": { "branch": "main", "commit": "cbc7b02bb99fae35cb42f514762b89b5126651ef" },

     

       2
       2
       +
         "LuaSnip": { "branch": "master", "commit": "73813308abc2eaeff2bc0d3f2f79270c491be9d7" },

     

       3
       3
       +
         "catppuccin": { "branch": "main", "commit": "8c4125e3c746976ba025dc5d908fa22c6aa09486" },

     

       4
       4
       +
         "cmp-nvim-lsp": { "branch": "main", "commit": "bd5a7d6db125d4654b50eeae9f5217f24bb22fd3" },

     

       5
       5
       +
         "cmp-nvim-lsp-signature-help": { "branch": "main", "commit": "031e6ba70b0ad5eee49fd2120ff7a2e325b17fa7" },

     

       9
       6
        
         "cmp-path": { "branch": "main", "commit": "c642487086dbd9a93160e1679a1327be111cbc25" },

     

       10
       10
       -
         "conform.nvim": { "branch": "master", "commit": "cde4da5c1083d3527776fee69536107d98dae6c9" },

     

       11
       11
       -
         "crates.nvim": { "branch": "main", "commit": "ac9fa498a9edb96dc3056724ff69d5f40b898453" },

     

       12
       12
       -
         "dressing.nvim": { "branch": "master", "commit": "2d7c2db2507fa3c4956142ee607431ddb2828639" },

     

       13
       13
       -
         "flash.nvim": { "branch": "main", "commit": "fcea7ff883235d9024dc41e638f164a450c14ca2" },

     

       14
       14
       -
         "friendly-snippets": { "branch": "main", "commit": "572f5660cf05f8cd8834e096d7b4c921ba18e175" },

     

       7
       7
       +
         "cmp_luasnip": { "branch": "master", "commit": "98d9cb5c2c38532bd9bdb481067b20fea8f32e90" },

     

       8
       8
       +
         "conform.nvim": { "branch": "master", "commit": "9fd3d5e0b689ec1bf400c53cbbec72c6fdf24081" },

     

       9
       9
       +
         "fidget.nvim": { "branch": "main", "commit": "e32b672d8fd343f9d6a76944fedb8c61d7d8111a" },

     

       15
       10
        
         "gemini-vim-syntax": { "branch": "master", "commit": "596d1f36b386e5b2cc1af4f2f8285134626878d1" },

     

       16
       11
        
         "gitsigns.nvim": { "branch": "main", "commit": "20ad4419564d6e22b189f6738116b38871082332" },

     

       17
       17
       -
         "grug-far.nvim": { "branch": "main", "commit": "b58b2d65863f4ebad88b10a1ddd519e5380466e0" },

     

       18
       12
        
         "lazy.nvim": { "branch": "main", "commit": "85c7ff3711b730b4030d03144f6db6375044ae82" },

     

       19
       19
       -
         "lazydev.nvim": { "branch": "main", "commit": "5231c62aa83c2f8dc8e7ba957aa77098cda1257d" },

     

       20
       20
       -
         "lualine.nvim": { "branch": "master", "commit": "3946f0122255bc377d14a59b27b609fb3ab25768" },

     

       21
       21
       -
         "markview.nvim": { "branch": "main", "commit": "cfc8ec8466d5de7ad1bc671130e9c2b404116011" },

     

       22
       22
       -
         "mason-lspconfig.nvim": { "branch": "main", "commit": "b1d9a914b02ba5660f1e272a03314b31d4576fe2" },

     

       13
       13
       +
         "lazydev.nvim": { "branch": "main", "commit": "faf46237f0df43a29e12abd143ff1a0bbac27b7e" },

     

       14
       14
       +
         "markview.nvim": { "branch": "main", "commit": "c93ea99d96b4bfda5b7c7d0dfca9c26edf6e78f0" },

     

       15
       15
       +
         "mason-lspconfig.nvim": { "branch": "main", "commit": "3590d66effccc7376d8c3dbe45e8291f9fed2843" },

     

       16
       16
       +
         "mason-tool-installer.nvim": { "branch": "main", "commit": "517ef5994ef9d6b738322664d5fdd948f0fdeb46" },

     

       23
       17
        
         "mason.nvim": { "branch": "main", "commit": "ad7146aa61dcaeb54fa900144d768f040090bff0" },

     

       24
       24
       -
         "mini.ai": { "branch": "main", "commit": "0d3c9cf22e37b86b7a0dfbe7ef129ee7a5f4f93c" },

     

       25
       25
       -
         "mini.icons": { "branch": "main", "commit": "ff2e4f1d29f659cc2bad0f9256f2f6195c6b2428" },

     

       26
       26
       -
         "mini.pairs": { "branch": "main", "commit": "b316e68f2d242d5bd010deaab645daa27ed86297" },

     

       27
       27
       -
         "neo-tree.nvim": { "branch": "main", "commit": "0bf326c601063a6518aa9a039b71351debb83d2f" },

     

       28
       28
       -
         "noice.nvim": { "branch": "main", "commit": "7bfd942445fb63089b59f97ca487d605e715f155" },

     

       29
       29
       -
         "nui.nvim": { "branch": "main", "commit": "de740991c12411b663994b2860f1a4fd0937c130" },

     

       30
       30
       -
         "nushell-syntax-vim": { "branch": "main", "commit": "340c4e2975401a0676b499d1eb9a1a9559d6fcb7" },

     

       31
       31
       -
         "nvim-ansible": { "branch": "main", "commit": "bba61168b7aef735e7f950fdfece5ef6c388eacf" },

     

       32
       32
       -
         "nvim-cmp": { "branch": "main", "commit": "d78fb3b64eedb701c9939f97361c06483af575e0" },

     

       33
       33
       -
         "nvim-lint": { "branch": "master", "commit": "baf7c91c2b868b12446df511d4cdddc98e9bf66e" },

     

       34
       34
       -
         "nvim-lspconfig": { "branch": "master", "commit": "b34fbdffdcb6295c7a25df6ba375452a2e73c32e" },

     

       35
       35
       -
         "nvim-snippets": { "branch": "main", "commit": "56b4052f71220144689caaa2e5b66222ba5661eb" },

     

       36
       36
       -
         "nvim-treesitter": { "branch": "main", "commit": "b50774079aa3de80a06dce1634e7e1aa26d25848" },

     

       37
       37
       -
         "nvim-treesitter-textobjects": { "branch": "main", "commit": "227165aaeb07b567fb9c066f224816aa8f3ce63f" },

     

       38
       38
       -
         "nvim-ts-autotag": { "branch": "main", "commit": "c4ca798ab95b316a768d51eaaaee48f64a4a46bc" },

     

       39
       39
       -
         "persistence.nvim": { "branch": "main", "commit": "b20b2a7887bd39c1a356980b45e03250f3dce49c" },

     

       18
       18
       +
         "mini.nvim": { "branch": "main", "commit": "ee4a4a4abed25e3d108d985b0553c5271f2f71aa" },

     

       19
       19
       +
         "nerdcommenter": { "branch": "master", "commit": "02a3b6455fa07b61b9440a78732f1e9b7876c991" },

     

       20
       20
       +
         "nvim-cmp": { "branch": "main", "commit": "cf22c9e32512de3be1fd6b65fd25e3aabead4d8b" },

     

       21
       21
       +
         "nvim-lspconfig": { "branch": "master", "commit": "e25994a1c2373784364852cd904cb39b6d75f227" },

     

       22
       22
       +
         "nvim-tree.lua": { "branch": "master", "commit": "321bc61580fd066b76861c32de3319c3a6d089e7" },

     

       23
       23
       +
         "nvim-treesitter": { "branch": "master", "commit": "42fc28ba918343ebfd5565147a42a26580579482" },

     

       24
       24
       +
         "nvim-web-devicons": { "branch": "master", "commit": "8dcb311b0c92d460fac00eac706abd43d94d68af" },

     

       40
       25
        
         "plenary.nvim": { "branch": "master", "commit": "b9fd5226c2f76c951fc8ed5923d85e4de065e509" },

     

       41
       41
       -
         "rustaceanvim": { "branch": "master", "commit": "6bd02e97a1f3102f06a72726764f24d3b3a33a85" },

     

       42
       42
       -
         "snacks.nvim": { "branch": "main", "commit": "3c5c23ba91e608bd89bb36d76cb005aa63d20dbf" },

     

       43
       43
       -
         "telescope-fzf-native.nvim": { "branch": "main", "commit": "6fea601bd2b694c6f2ae08a6c6fab14930c60e2c" },

     

       44
       44
       -
         "telescope.nvim": { "branch": "master", "commit": "3a12a853ebf21ec1cce9a92290e3013f8ae75f02" },

     

       45
       45
       -
         "todo-comments.nvim": { "branch": "main", "commit": "31e3c38ce9b29781e4422fc0322eb0a21f4e8668" },

     

       46
       46
       -
         "tokyonight.nvim": { "branch": "main", "commit": "5da1b76e64daf4c5d410f06bcb6b9cb640da7dfd" },

     

       47
       47
       -
         "trouble.nvim": { "branch": "main", "commit": "bd67efe408d4816e25e8491cc5ad4088e708a69a" },

     

       48
       48
       -
         "ts-comments.nvim": { "branch": "main", "commit": "123a9fb12e7229342f807ec9e6de478b1102b041" },

     

       49
       49
       -
         "venv-selector.nvim": { "branch": "main", "commit": "58bae72c84b9f7f864c879ec1896e384296f9ffb" },

     

       26
       26
       +
         "telescope-fzf-native.nvim": { "branch": "main", "commit": "1f08ed60cafc8f6168b72b80be2b2ea149813e55" },

     

       27
       27
       +
         "telescope-media-files.nvim": { "branch": "master", "commit": "0826c7a730bc4d36068f7c85cf4c5b3fd9fb570a" },

     

       28
       28
       +
         "telescope-ui-select.nvim": { "branch": "master", "commit": "6e51d7da30bd139a6950adf2a47fda6df9fa06d2" },

     

       29
       29
       +
         "telescope.nvim": { "branch": "0.1.x", "commit": "a0bbec21143c7bc5f8bb02e0005fa0b982edc026" },

     

       30
       30
       +
         "todo-comments.nvim": { "branch": "main", "commit": "411503d3bedeff88484de572f2509c248e499b38" },

     

       50
       31
        
         "vim-sleuth": { "branch": "master", "commit": "be69bff86754b1aa5adcbb527d7fcd1635a84080" },

     

       51
       32
        
         "which-key.nvim": { "branch": "main", "commit": "3aab2147e74890957785941f0c1ad87d0a44c15a" }

     

       52
       33
        
       }

-22

config/nvim/lazyvim.json

···

       1
       1
       -
       {

     

       2
       2
       -
         "extras": [

     

       3
       3
       -
           "lazyvim.plugins.extras.coding.nvim-cmp",

     

       4
       4
       -
           "lazyvim.plugins.extras.editor.neo-tree",

     

       5
       5
       -
           "lazyvim.plugins.extras.editor.telescope",

     

       6
       6
       -
           "lazyvim.plugins.extras.formatting.black",

     

       7
       7
       -
           "lazyvim.plugins.extras.formatting.prettier",

     

       8
       8
       -
           "lazyvim.plugins.extras.lang.ansible",

     

       9
       9
       -
           "lazyvim.plugins.extras.lang.docker",

     

       10
       10
       -
           "lazyvim.plugins.extras.lang.git",

     

       11
       11
       -
           "lazyvim.plugins.extras.lang.nushell",

     

       12
       12
       -
           "lazyvim.plugins.extras.lang.python",

     

       13
       13
       -
           "lazyvim.plugins.extras.lang.rust",

     

       14
       14
       -
           "lazyvim.plugins.extras.lang.yaml",

     

       15
       15
       -
           "lazyvim.plugins.extras.lang.zig"

     

       16
       16
       -
         ],

     

       17
       17
       -
         "install_version": 8,

     

       18
       18
       -
         "news": {

     

       19
       19
       -
           "NEWS.md": "11866"

     

       20
       20
       -
         },

     

       21
       21
       -
         "version": 8

     

       22
       22
       -
       }

+15

config/nvim/lua/autocommands.lua

···

       1
       1
       +
       -- [[ Basic Autocommands ]]

     

       2
       2
       +
       --  See `:help lua-guide-autocommands`

     

       3
       3
       +
       

     

       4
       4
       +
       -- Highlight when yanking (copying) text

     

       5
       5
       +
       --  Try it with `yap` in normal mode

     

       6
       6
       +
       --  See `:help vim.highlight.on_yank()`

     

       7
       7
       +
       vim.api.nvim_create_autocmd('TextYankPost', {

     

       8
       8
       +
         desc = 'Highlight when yanking (copying) text',

     

       9
       9
       +
         group = vim.api.nvim_create_augroup('kickstart-highlight-yank', { clear = true }),

     

       10
       10
       +
         callback = function()

     

       11
       11
       +
           vim.highlight.on_yank()

     

       12
       12
       +
         end,

     

       13
       13
       +
       })

     

       14
       14
       +
       

     

       15
       15
       +
       -- vim: ts=2 sts=2 sw=2 et

-8

config/nvim/lua/config/autocmds.lua

···

       1
       1
       -
       -- Autocmds are automatically loaded on the VeryLazy event

     

       2
       2
       -
       -- Default autocmds that are always set: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/autocmds.lua

     

       3
       3
       -
       --

     

       4
       4
       -
       -- Add any additional autocmds here

     

       5
       5
       -
       -- with `vim.api.nvim_create_autocmd`

     

       6
       6
       -
       --

     

       7
       7
       -
       -- Or remove existing autocmds by their group name (which is prefixed with `lazyvim_` for the defaults)

     

       8
       8
       -
       -- e.g. vim.api.nvim_del_augroup_by_name("lazyvim_wrap_spell")

-3

config/nvim/lua/config/keymaps.lua

···

       1
       1
       -
       -- Keymaps are automatically loaded on the VeryLazy event

     

       2
       2
       -
       -- Default keymaps that are always set: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/keymaps.lua

     

       3
       3
       -
       -- Add any additional keymaps here

-53

config/nvim/lua/config/lazy.lua

···

       1
       1
       -
       local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"

     

       2
       2
       -
       if not (vim.uv or vim.loop).fs_stat(lazypath) then

     

       3
       3
       -
         local lazyrepo = "https://github.com/folke/lazy.nvim.git"

     

       4
       4
       -
         local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })

     

       5
       5
       -
         if vim.v.shell_error ~= 0 then

     

       6
       6
       -
           vim.api.nvim_echo({

     

       7
       7
       -
             { "Failed to clone lazy.nvim:\n", "ErrorMsg" },

     

       8
       8
       -
             { out, "WarningMsg" },

     

       9
       9
       -
             { "\nPress any key to exit..." },

     

       10
       10
       -
           }, true, {})

     

       11
       11
       -
           vim.fn.getchar()

     

       12
       12
       -
           os.exit(1)

     

       13
       13
       -
         end

     

       14
       14
       -
       end

     

       15
       15
       -
       vim.opt.rtp:prepend(lazypath)

     

       16
       16
       -
       

     

       17
       17
       -
       require("lazy").setup({

     

       18
       18
       -
         spec = {

     

       19
       19
       -
           -- add LazyVim and import its plugins

     

       20
       20
       -
           { "LazyVim/LazyVim", import = "lazyvim.plugins" },

     

       21
       21
       -
           -- import/override with your plugins

     

       22
       22
       -
           { import = "plugins" },

     

       23
       23
       -
         },

     

       24
       24
       -
         defaults = {

     

       25
       25
       -
           -- By default, only LazyVim plugins will be lazy-loaded. Your custom plugins will load during startup.

     

       26
       26
       -
           -- If you know what you're doing, you can set this to `true` to have all your custom plugins lazy-loaded by default.

     

       27
       27
       -
           lazy = false,

     

       28
       28
       -
           -- It's recommended to leave version=false for now, since a lot the plugin that support versioning,

     

       29
       29
       -
           -- have outdated releases, which may break your Neovim install.

     

       30
       30
       -
           version = false, -- always use the latest git commit

     

       31
       31
       -
           -- version = "*", -- try installing the latest stable version for plugins that support semver

     

       32
       32
       -
         },

     

       33
       33
       -
         install = { colorscheme = { "tokyonight", "habamax" } },

     

       34
       34
       -
         checker = {

     

       35
       35
       -
           enabled = true, -- check for plugin updates periodically

     

       36
       36
       -
           notify = false, -- notify on update

     

       37
       37
       -
         }, -- automatically check for plugin updates

     

       38
       38
       -
         performance = {

     

       39
       39
       -
           rtp = {

     

       40
       40
       -
             -- disable some rtp plugins

     

       41
       41
       -
             disabled_plugins = {

     

       42
       42
       -
               "gzip",

     

       43
       43
       -
               -- "matchit",

     

       44
       44
       -
               -- "matchparen",

     

       45
       45
       -
               -- "netrwPlugin",

     

       46
       46
       -
               "tarPlugin",

     

       47
       47
       -
               "tohtml",

     

       48
       48
       -
               "tutor",

     

       49
       49
       -
               "zipPlugin",

     

       50
       50
       -
             },

     

       51
       51
       -
           },

     

       52
       52
       -
         },

     

       53
       53
       -
       })

-3

config/nvim/lua/config/options.lua

···

       1
       1
       -
       -- Options are automatically loaded before lazy.nvim startup

     

       2
       2
       -
       -- Default options that are always set: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/options.lua

     

       3
       3
       -
       -- Add any additional options here

config/nvim/lua/custom/plugins/init.lua

···

       1
       1
       +
       -- You can add your own plugins here or in other files in this directory!

     

       2
       2
       +
       --  I promise not to create any merge conflicts in this directory :)

     

       3
       3
       +
       --

     

       4
       4
       +
       -- See the kickstart.nvim README for more information

     

       5
       5
       +
       return {}

+34

config/nvim/lua/keymaps.lua

···

       1
       1
       +
       -- [[ Basic Keymaps ]]

     

       2
       2
       +
       --  See `:help vim.keymap.set()`

     

       3
       3
       +
       

     

       4
       4
       +
       -- Clear highlights on search when pressing <Esc> in normal mode

     

       5
       5
       +
       --  See `:help hlsearch`

     

       6
       6
       +
       vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>')

     

       7
       7
       +
       

     

       8
       8
       +
       -- Diagnostic keymaps

     

       9
       9
       +
       vim.keymap.set('n', '<leader>q', vim.diagnostic.setloclist, { desc = 'Open diagnostic [Q]uickfix list' })

     

       10
       10
       +
       

     

       11
       11
       +
       -- Exit terminal mode in the builtin terminal with a shortcut that is a bit easier

     

       12
       12
       +
       -- for people to discover. Otherwise, you normally need to press <C-\><C-n>, which

     

       13
       13
       +
       -- is not what someone will guess without a bit more experience.

     

       14
       14
       +
       --

     

       15
       15
       +
       -- NOTE: This won't work in all terminal emulators/tmux/etc. Try your own mapping

     

       16
       16
       +
       -- or just use <C-\><C-n> to exit terminal mode

     

       17
       17
       +
       vim.keymap.set('t', '<Esc><Esc>', '<C-\\><C-n>', { desc = 'Exit terminal mode' })

     

       18
       18
       +
       

     

       19
       19
       +
       -- TIP: Disable arrow keys in normal mode

     

       20
       20
       +
       vim.keymap.set('n', '<left>', '<cmd>echo "Use h to move!!"<CR>')

     

       21
       21
       +
       vim.keymap.set('n', '<right>', '<cmd>echo "Use l to move!!"<CR>')

     

       22
       22
       +
       vim.keymap.set('n', '<up>', '<cmd>echo "Use k to move!!"<CR>')

     

       23
       23
       +
       vim.keymap.set('n', '<down>', '<cmd>echo "Use j to move!!"<CR>')

     

       24
       24
       +
       

     

       25
       25
       +
       -- Keybinds to make split navigation easier.

     

       26
       26
       +
       --  Use CTRL+<hjkl> to switch between windows

     

       27
       27
       +
       --

     

       28
       28
       +
       --  See `:help wincmd` for a list of all window commands

     

       29
       29
       +
       vim.keymap.set('n', '<C-h>', '<C-w><C-h>', { desc = 'Move focus to the left window' })

     

       30
       30
       +
       vim.keymap.set('n', '<C-l>', '<C-w><C-l>', { desc = 'Move focus to the right window' })

     

       31
       31
       +
       vim.keymap.set('n', '<C-j>', '<C-w><C-j>', { desc = 'Move focus to the lower window' })

     

       32
       32
       +
       vim.keymap.set('n', '<C-k>', '<C-w><C-k>', { desc = 'Move focus to the upper window' })

     

       33
       33
       +
       

     

       34
       34
       +
       -- vim: ts=2 sts=2 sw=2 et

+52

config/nvim/lua/kickstart/health.lua

···

       1
       1
       +
       --[[

     

       2
       2
       +
       --

     

       3
       3
       +
       -- This file is not required for your own configuration,

     

       4
       4
       +
       -- but helps people determine if their system is setup correctly.

     

       5
       5
       +
       --

     

       6
       6
       +
       --]]

     

       7
       7
       +
       

     

       8
       8
       +
       local check_version = function()

     

       9
       9
       +
         local verstr = tostring(vim.version())

     

       10
       10
       +
         if not vim.version.ge then

     

       11
       11
       +
           vim.health.error(string.format("Neovim out of date: '%s'. Upgrade to latest stable or nightly", verstr))

     

       12
       12
       +
           return

     

       13
       13
       +
         end

     

       14
       14
       +
       

     

       15
       15
       +
         if vim.version.ge(vim.version(), '0.10-dev') then

     

       16
       16
       +
           vim.health.ok(string.format("Neovim version is: '%s'", verstr))

     

       17
       17
       +
         else

     

       18
       18
       +
           vim.health.error(string.format("Neovim out of date: '%s'. Upgrade to latest stable or nightly", verstr))

     

       19
       19
       +
         end

     

       20
       20
       +
       end

     

       21
       21
       +
       

     

       22
       22
       +
       local check_external_reqs = function()

     

       23
       23
       +
         -- Basic utils: `git`, `make`, `unzip`

     

       24
       24
       +
         for _, exe in ipairs { 'git', 'make', 'unzip', 'rg' } do

     

       25
       25
       +
           local is_executable = vim.fn.executable(exe) == 1

     

       26
       26
       +
           if is_executable then

     

       27
       27
       +
             vim.health.ok(string.format("Found executable: '%s'", exe))

     

       28
       28
       +
           else

     

       29
       29
       +
             vim.health.warn(string.format("Could not find executable: '%s'", exe))

     

       30
       30
       +
           end

     

       31
       31
       +
         end

     

       32
       32
       +
       

     

       33
       33
       +
         return true

     

       34
       34
       +
       end

     

       35
       35
       +
       

     

       36
       36
       +
       return {

     

       37
       37
       +
         check = function()

     

       38
       38
       +
           vim.health.start 'kickstart.nvim'

     

       39
       39
       +
       

     

       40
       40
       +
           vim.health.info [[NOTE: Not every warning is a 'must-fix' in `:checkhealth`

     

       41
       41
       +
       

     

       42
       42
       +
         Fix only warnings for plugins and languages you intend to use.

     

       43
       43
       +
           Mason will give warnings for languages that are not installed.

     

       44
       44
       +
           You do not need to install, unless you want to use those languages!]]

     

       45
       45
       +
       

     

       46
       46
       +
           local uv = vim.uv or vim.loop

     

       47
       47
       +
           vim.health.info('System Information: ' .. vim.inspect(uv.os_uname()))

     

       48
       48
       +
       

     

       49
       49
       +
           check_version()

     

       50
       50
       +
           check_external_reqs()

     

       51
       51
       +
         end,

     

       52
       52
       +
       }

+16

config/nvim/lua/kickstart/plugins/autopairs.lua

···

       1
       1
       +
       -- autopairs

     

       2
       2
       +
       -- https://github.com/windwp/nvim-autopairs

     

       3
       3
       +
       

     

       4
       4
       +
       return {

     

       5
       5
       +
         'windwp/nvim-autopairs',

     

       6
       6
       +
         event = 'InsertEnter',

     

       7
       7
       +
         -- Optional dependency

     

       8
       8
       +
         dependencies = { 'hrsh7th/nvim-cmp' },

     

       9
       9
       +
         config = function()

     

       10
       10
       +
           require('nvim-autopairs').setup {}

     

       11
       11
       +
           -- If you want to automatically add `(` after selecting a function or method

     

       12
       12
       +
           local cmp_autopairs = require 'nvim-autopairs.completion.cmp'

     

       13
       13
       +
           local cmp = require 'cmp'

     

       14
       14
       +
           cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done())

     

       15
       15
       +
         end,

     

       16
       16
       +
       }

+148

config/nvim/lua/kickstart/plugins/debug.lua

···

       1
       1
       +
       -- debug.lua

     

       2
       2
       +
       --

     

       3
       3
       +
       -- Shows how to use the DAP plugin to debug your code.

     

       4
       4
       +
       --

     

       5
       5
       +
       -- Primarily focused on configuring the debugger for Go, but can

     

       6
       6
       +
       -- be extended to other languages as well. That's why it's called

     

       7
       7
       +
       -- kickstart.nvim and not kitchen-sink.nvim ;)

     

       8
       8
       +
       

     

       9
       9
       +
       return {

     

       10
       10
       +
         -- NOTE: Yes, you can install new plugins here!

     

       11
       11
       +
         'mfussenegger/nvim-dap',

     

       12
       12
       +
         -- NOTE: And you can specify dependencies as well

     

       13
       13
       +
         dependencies = {

     

       14
       14
       +
           -- Creates a beautiful debugger UI

     

       15
       15
       +
           'rcarriga/nvim-dap-ui',

     

       16
       16
       +
       

     

       17
       17
       +
           -- Required dependency for nvim-dap-ui

     

       18
       18
       +
           'nvim-neotest/nvim-nio',

     

       19
       19
       +
       

     

       20
       20
       +
           -- Installs the debug adapters for you

     

       21
       21
       +
           'williamboman/mason.nvim',

     

       22
       22
       +
           'jay-babu/mason-nvim-dap.nvim',

     

       23
       23
       +
       

     

       24
       24
       +
           -- Add your own debuggers here

     

       25
       25
       +
           'leoluz/nvim-dap-go',

     

       26
       26
       +
         },

     

       27
       27
       +
         keys = {

     

       28
       28
       +
           -- Basic debugging keymaps, feel free to change to your liking!

     

       29
       29
       +
           {

     

       30
       30
       +
             '<F5>',

     

       31
       31
       +
             function()

     

       32
       32
       +
               require('dap').continue()

     

       33
       33
       +
             end,

     

       34
       34
       +
             desc = 'Debug: Start/Continue',

     

       35
       35
       +
           },

     

       36
       36
       +
           {

     

       37
       37
       +
             '<F1>',

     

       38
       38
       +
             function()

     

       39
       39
       +
               require('dap').step_into()

     

       40
       40
       +
             end,

     

       41
       41
       +
             desc = 'Debug: Step Into',

     

       42
       42
       +
           },

     

       43
       43
       +
           {

     

       44
       44
       +
             '<F2>',

     

       45
       45
       +
             function()

     

       46
       46
       +
               require('dap').step_over()

     

       47
       47
       +
             end,

     

       48
       48
       +
             desc = 'Debug: Step Over',

     

       49
       49
       +
           },

     

       50
       50
       +
           {

     

       51
       51
       +
             '<F3>',

     

       52
       52
       +
             function()

     

       53
       53
       +
               require('dap').step_out()

     

       54
       54
       +
             end,

     

       55
       55
       +
             desc = 'Debug: Step Out',

     

       56
       56
       +
           },

     

       57
       57
       +
           {

     

       58
       58
       +
             '<leader>b',

     

       59
       59
       +
             function()

     

       60
       60
       +
               require('dap').toggle_breakpoint()

     

       61
       61
       +
             end,

     

       62
       62
       +
             desc = 'Debug: Toggle Breakpoint',

     

       63
       63
       +
           },

     

       64
       64
       +
           {

     

       65
       65
       +
             '<leader>B',

     

       66
       66
       +
             function()

     

       67
       67
       +
               require('dap').set_breakpoint(vim.fn.input 'Breakpoint condition: ')

     

       68
       68
       +
             end,

     

       69
       69
       +
             desc = 'Debug: Set Breakpoint',

     

       70
       70
       +
           },

     

       71
       71
       +
           -- Toggle to see last session result. Without this, you can't see session output in case of unhandled exception.

     

       72
       72
       +
           {

     

       73
       73
       +
             '<F7>',

     

       74
       74
       +
             function()

     

       75
       75
       +
               require('dapui').toggle()

     

       76
       76
       +
             end,

     

       77
       77
       +
             desc = 'Debug: See last session result.',

     

       78
       78
       +
           },

     

       79
       79
       +
         },

     

       80
       80
       +
         config = function()

     

       81
       81
       +
           local dap = require 'dap'

     

       82
       82
       +
           local dapui = require 'dapui'

     

       83
       83
       +
       

     

       84
       84
       +
           require('mason-nvim-dap').setup {

     

       85
       85
       +
             -- Makes a best effort to setup the various debuggers with

     

       86
       86
       +
             -- reasonable debug configurations

     

       87
       87
       +
             automatic_installation = true,

     

       88
       88
       +
       

     

       89
       89
       +
             -- You can provide additional configuration to the handlers,

     

       90
       90
       +
             -- see mason-nvim-dap README for more information

     

       91
       91
       +
             handlers = {},

     

       92
       92
       +
       

     

       93
       93
       +
             -- You'll need to check that you have the required things installed

     

       94
       94
       +
             -- online, please don't ask me how to install them :)

     

       95
       95
       +
             ensure_installed = {

     

       96
       96
       +
               -- Update this to ensure that you have the debuggers for the langs you want

     

       97
       97
       +
               'delve',

     

       98
       98
       +
             },

     

       99
       99
       +
           }

     

       100
       100
       +
       

     

       101
       101
       +
           -- Dap UI setup

     

       102
       102
       +
           -- For more information, see |:help nvim-dap-ui|

     

       103
       103
       +
           dapui.setup {

     

       104
       104
       +
             -- Set icons to characters that are more likely to work in every terminal.

     

       105
       105
       +
             --    Feel free to remove or use ones that you like more! :)

     

       106
       106
       +
             --    Don't feel like these are good choices.

     

       107
       107
       +
             icons = { expanded = '▾', collapsed = '▸', current_frame = '*' },

     

       108
       108
       +
             controls = {

     

       109
       109
       +
               icons = {

     

       110
       110
       +
                 pause = '⏸',

     

       111
       111
       +
                 play = '▶',

     

       112
       112
       +
                 step_into = '⏎',

     

       113
       113
       +
                 step_over = '⏭',

     

       114
       114
       +
                 step_out = '⏮',

     

       115
       115
       +
                 step_back = 'b',

     

       116
       116
       +
                 run_last = '▶▶',

     

       117
       117
       +
                 terminate = '⏹',

     

       118
       118
       +
                 disconnect = '⏏',

     

       119
       119
       +
               },

     

       120
       120
       +
             },

     

       121
       121
       +
           }

     

       122
       122
       +
       

     

       123
       123
       +
           -- Change breakpoint icons

     

       124
       124
       +
           -- vim.api.nvim_set_hl(0, 'DapBreak', { fg = '#e51400' })

     

       125
       125
       +
           -- vim.api.nvim_set_hl(0, 'DapStop', { fg = '#ffcc00' })

     

       126
       126
       +
           -- local breakpoint_icons = vim.g.have_nerd_font

     

       127
       127
       +
           --     and { Breakpoint = '', BreakpointCondition = '', BreakpointRejected = '', LogPoint = '', Stopped = '' }

     

       128
       128
       +
           --   or { Breakpoint = '●', BreakpointCondition = '⊜', BreakpointRejected = '⊘', LogPoint = '◆', Stopped = '⭔' }

     

       129
       129
       +
           -- for type, icon in pairs(breakpoint_icons) do

     

       130
       130
       +
           --   local tp = 'Dap' .. type

     

       131
       131
       +
           --   local hl = (type == 'Stopped') and 'DapStop' or 'DapBreak'

     

       132
       132
       +
           --   vim.fn.sign_define(tp, { text = icon, texthl = hl, numhl = hl })

     

       133
       133
       +
           -- end

     

       134
       134
       +
       

     

       135
       135
       +
           dap.listeners.after.event_initialized['dapui_config'] = dapui.open

     

       136
       136
       +
           dap.listeners.before.event_terminated['dapui_config'] = dapui.close

     

       137
       137
       +
           dap.listeners.before.event_exited['dapui_config'] = dapui.close

     

       138
       138
       +
       

     

       139
       139
       +
           -- Install golang specific config

     

       140
       140
       +
           require('dap-go').setup {

     

       141
       141
       +
             delve = {

     

       142
       142
       +
               -- On Windows delve must be run attached or it crashes.

     

       143
       143
       +
               -- See https://github.com/leoluz/nvim-dap-go/blob/main/README.md#configuring

     

       144
       144
       +
               detached = vim.fn.has 'win32' == 0,

     

       145
       145
       +
             },

     

       146
       146
       +
           }

     

       147
       147
       +
         end,

     

       148
       148
       +
       }

+61

config/nvim/lua/kickstart/plugins/gitsigns.lua

···

       1
       1
       +
       -- Adds git related signs to the gutter, as well as utilities for managing changes

     

       2
       2
       +
       -- NOTE: gitsigns is already included in init.lua but contains only the base

     

       3
       3
       +
       -- config. This will add also the recommended keymaps.

     

       4
       4
       +
       

     

       5
       5
       +
       return {

     

       6
       6
       +
         {

     

       7
       7
       +
           'lewis6991/gitsigns.nvim',

     

       8
       8
       +
           opts = {

     

       9
       9
       +
             on_attach = function(bufnr)

     

       10
       10
       +
               local gitsigns = require 'gitsigns'

     

       11
       11
       +
       

     

       12
       12
       +
               local function map(mode, l, r, opts)

     

       13
       13
       +
                 opts = opts or {}

     

       14
       14
       +
                 opts.buffer = bufnr

     

       15
       15
       +
                 vim.keymap.set(mode, l, r, opts)

     

       16
       16
       +
               end

     

       17
       17
       +
       

     

       18
       18
       +
               -- Navigation

     

       19
       19
       +
               map('n', ']c', function()

     

       20
       20
       +
                 if vim.wo.diff then

     

       21
       21
       +
                   vim.cmd.normal { ']c', bang = true }

     

       22
       22
       +
                 else

     

       23
       23
       +
                   gitsigns.nav_hunk 'next'

     

       24
       24
       +
                 end

     

       25
       25
       +
               end, { desc = 'Jump to next git [c]hange' })

     

       26
       26
       +
       

     

       27
       27
       +
               map('n', '[c', function()

     

       28
       28
       +
                 if vim.wo.diff then

     

       29
       29
       +
                   vim.cmd.normal { '[c', bang = true }

     

       30
       30
       +
                 else

     

       31
       31
       +
                   gitsigns.nav_hunk 'prev'

     

       32
       32
       +
                 end

     

       33
       33
       +
               end, { desc = 'Jump to previous git [c]hange' })

     

       34
       34
       +
       

     

       35
       35
       +
               -- Actions

     

       36
       36
       +
               -- visual mode

     

       37
       37
       +
               map('v', '<leader>hs', function()

     

       38
       38
       +
                 gitsigns.stage_hunk { vim.fn.line '.', vim.fn.line 'v' }

     

       39
       39
       +
               end, { desc = 'git [s]tage hunk' })

     

       40
       40
       +
               map('v', '<leader>hr', function()

     

       41
       41
       +
                 gitsigns.reset_hunk { vim.fn.line '.', vim.fn.line 'v' }

     

       42
       42
       +
               end, { desc = 'git [r]eset hunk' })

     

       43
       43
       +
               -- normal mode

     

       44
       44
       +
               map('n', '<leader>hs', gitsigns.stage_hunk, { desc = 'git [s]tage hunk' })

     

       45
       45
       +
               map('n', '<leader>hr', gitsigns.reset_hunk, { desc = 'git [r]eset hunk' })

     

       46
       46
       +
               map('n', '<leader>hS', gitsigns.stage_buffer, { desc = 'git [S]tage buffer' })

     

       47
       47
       +
               map('n', '<leader>hu', gitsigns.stage_hunk, { desc = 'git [u]ndo stage hunk' })

     

       48
       48
       +
               map('n', '<leader>hR', gitsigns.reset_buffer, { desc = 'git [R]eset buffer' })

     

       49
       49
       +
               map('n', '<leader>hp', gitsigns.preview_hunk, { desc = 'git [p]review hunk' })

     

       50
       50
       +
               map('n', '<leader>hb', gitsigns.blame_line, { desc = 'git [b]lame line' })

     

       51
       51
       +
               map('n', '<leader>hd', gitsigns.diffthis, { desc = 'git [d]iff against index' })

     

       52
       52
       +
               map('n', '<leader>hD', function()

     

       53
       53
       +
                 gitsigns.diffthis '@'

     

       54
       54
       +
               end, { desc = 'git [D]iff against last commit' })

     

       55
       55
       +
               -- Toggles

     

       56
       56
       +
               map('n', '<leader>tb', gitsigns.toggle_current_line_blame, { desc = '[T]oggle git show [b]lame line' })

     

       57
       57
       +
               map('n', '<leader>tD', gitsigns.preview_hunk_inline, { desc = '[T]oggle git show [D]eleted' })

     

       58
       58
       +
             end,

     

       59
       59
       +
           },

     

       60
       60
       +
         },

     

       61
       61
       +
       }

config/nvim/lua/kickstart/plugins/indent_line.lua

···

       1
       1
       +
       return {

     

       2
       2
       +
         { -- Add indentation guides even on blank lines

     

       3
       3
       +
           'lukas-reineke/indent-blankline.nvim',

     

       4
       4
       +
           -- Enable `lukas-reineke/indent-blankline.nvim`

     

       5
       5
       +
           -- See `:help ibl`

     

       6
       6
       +
           main = 'ibl',

     

       7
       7
       +
           opts = {},

     

       8
       8
       +
         },

     

       9
       9
       +
       }

+60

config/nvim/lua/kickstart/plugins/lint.lua

···

       1
       1
       +
       return {

     

       2
       2
       +
       

     

       3
       3
       +
         { -- Linting

     

       4
       4
       +
           'mfussenegger/nvim-lint',

     

       5
       5
       +
           event = { 'BufReadPre', 'BufNewFile' },

     

       6
       6
       +
           config = function()

     

       7
       7
       +
             local lint = require 'lint'

     

       8
       8
       +
             lint.linters_by_ft = {

     

       9
       9
       +
               markdown = { 'markdownlint' },

     

       10
       10
       +
             }

     

       11
       11
       +
       

     

       12
       12
       +
             -- To allow other plugins to add linters to require('lint').linters_by_ft,

     

       13
       13
       +
             -- instead set linters_by_ft like this:

     

       14
       14
       +
             -- lint.linters_by_ft = lint.linters_by_ft or {}

     

       15
       15
       +
             -- lint.linters_by_ft['markdown'] = { 'markdownlint' }

     

       16
       16
       +
             --

     

       17
       17
       +
             -- However, note that this will enable a set of default linters,

     

       18
       18
       +
             -- which will cause errors unless these tools are available:

     

       19
       19
       +
             -- {

     

       20
       20
       +
             --   clojure = { "clj-kondo" },

     

       21
       21
       +
             --   dockerfile = { "hadolint" },

     

       22
       22
       +
             --   inko = { "inko" },

     

       23
       23
       +
             --   janet = { "janet" },

     

       24
       24
       +
             --   json = { "jsonlint" },

     

       25
       25
       +
             --   markdown = { "vale" },

     

       26
       26
       +
             --   rst = { "vale" },

     

       27
       27
       +
             --   ruby = { "ruby" },

     

       28
       28
       +
             --   terraform = { "tflint" },

     

       29
       29
       +
             --   text = { "vale" }

     

       30
       30
       +
             -- }

     

       31
       31
       +
             --

     

       32
       32
       +
             -- You can disable the default linters by setting their filetypes to nil:

     

       33
       33
       +
             -- lint.linters_by_ft['clojure'] = nil

     

       34
       34
       +
             -- lint.linters_by_ft['dockerfile'] = nil

     

       35
       35
       +
             -- lint.linters_by_ft['inko'] = nil

     

       36
       36
       +
             -- lint.linters_by_ft['janet'] = nil

     

       37
       37
       +
             -- lint.linters_by_ft['json'] = nil

     

       38
       38
       +
             -- lint.linters_by_ft['markdown'] = nil

     

       39
       39
       +
             -- lint.linters_by_ft['rst'] = nil

     

       40
       40
       +
             -- lint.linters_by_ft['ruby'] = nil

     

       41
       41
       +
             -- lint.linters_by_ft['terraform'] = nil

     

       42
       42
       +
             -- lint.linters_by_ft['text'] = nil

     

       43
       43
       +
       

     

       44
       44
       +
             -- Create autocommand which carries out the actual linting

     

       45
       45
       +
             -- on the specified events.

     

       46
       46
       +
             local lint_augroup = vim.api.nvim_create_augroup('lint', { clear = true })

     

       47
       47
       +
             vim.api.nvim_create_autocmd({ 'BufEnter', 'BufWritePost', 'InsertLeave' }, {

     

       48
       48
       +
               group = lint_augroup,

     

       49
       49
       +
               callback = function()

     

       50
       50
       +
                 -- Only run the linter in buffers that you can modify in order to

     

       51
       51
       +
                 -- avoid superfluous noise, notably within the handy LSP pop-ups that

     

       52
       52
       +
                 -- describe the hovered symbol using Markdown.

     

       53
       53
       +
                 if vim.opt_local.modifiable:get() then

     

       54
       54
       +
                   lint.try_lint()

     

       55
       55
       +
                 end

     

       56
       56
       +
               end,

     

       57
       57
       +
             })

     

       58
       58
       +
           end,

     

       59
       59
       +
         },

     

       60
       60
       +
       }

+25

config/nvim/lua/kickstart/plugins/neo-tree.lua

···

       1
       1
       +
       -- Neo-tree is a Neovim plugin to browse the file system

     

       2
       2
       +
       -- https://github.com/nvim-neo-tree/neo-tree.nvim

     

       3
       3
       +
       

     

       4
       4
       +
       return {

     

       5
       5
       +
         'nvim-neo-tree/neo-tree.nvim',

     

       6
       6
       +
         version = '*',

     

       7
       7
       +
         dependencies = {

     

       8
       8
       +
           'nvim-lua/plenary.nvim',

     

       9
       9
       +
           'nvim-tree/nvim-web-devicons', -- not strictly required, but recommended

     

       10
       10
       +
           'MunifTanjim/nui.nvim',

     

       11
       11
       +
         },

     

       12
       12
       +
         cmd = 'Neotree',

     

       13
       13
       +
         keys = {

     

       14
       14
       +
           { '\\', ':Neotree reveal<CR>', desc = 'NeoTree reveal', silent = true },

     

       15
       15
       +
         },

     

       16
       16
       +
         opts = {

     

       17
       17
       +
           filesystem = {

     

       18
       18
       +
             window = {

     

       19
       19
       +
               mappings = {

     

       20
       20
       +
                 ['\\'] = 'close_window',

     

       21
       21
       +
               },

     

       22
       22
       +
             },

     

       23
       23
       +
           },

     

       24
       24
       +
         },

     

       25
       25
       +
       }

+16

config/nvim/lua/lazy-bootstrap.lua

···

       1
       1
       +
       -- [[ Install `lazy.nvim` plugin manager ]]

     

       2
       2
       +
       --    See `:help lazy.nvim.txt` or https://github.com/folke/lazy.nvim for more info

     

       3
       3
       +
       local lazypath = vim.fn.stdpath 'data' .. '/lazy/lazy.nvim'

     

       4
       4
       +
       if not (vim.uv or vim.loop).fs_stat(lazypath) then

     

       5
       5
       +
         local lazyrepo = 'https://github.com/folke/lazy.nvim.git'

     

       6
       6
       +
         local out = vim.fn.system { 'git', 'clone', '--filter=blob:none', '--branch=stable', lazyrepo, lazypath }

     

       7
       7
       +
         if vim.v.shell_error ~= 0 then

     

       8
       8
       +
           error('Error cloning lazy.nvim:\n' .. out)

     

       9
       9
       +
         end

     

       10
       10
       +
       end

     

       11
       11
       +
       

     

       12
       12
       +
       ---@type vim.Option

     

       13
       13
       +
       local rtp = vim.opt.rtp

     

       14
       14
       +
       rtp:prepend(lazypath)

     

       15
       15
       +
       

     

       16
       16
       +
       -- vim: ts=2 sts=2 sw=2 et

+845

config/nvim/lua/lazy-plugins.lua

···

       1
       1
       +
       -- [[ Configure and install plugins ]]

     

       2
       2
       +
       --

     

       3
       3
       +
       --  To check the current status of your plugins, run

     

       4
       4
       +
       --    :Lazy

     

       5
       5
       +
       --

     

       6
       6
       +
       --  You can press `?` in this menu for help. Use `:q` to close the window

     

       7
       7
       +
       --

     

       8
       8
       +
       --  To update plugins you can run

     

       9
       9
       +
       --    :Lazy update

     

       10
       10
       +
       --

     

       11
       11
       +
       -- NOTE: Here is where you install your plugins.

     

       12
       12
       +
       require('lazy').setup({

     

       13
       13
       +
         -- NOTE: Plugins can be added with a link (or for a github repo: 'owner/repo' link).

     

       14
       14
       +
         'tpope/vim-sleuth', -- Detect tabstop and shiftwidth automatically

     

       15
       15
       +
       

     

       16
       16
       +
         -- NOTE: Plugins can also be added by using a table,

     

       17
       17
       +
         -- with the first argument being the link and the following

     

       18
       18
       +
         -- keys can be used to configure plugin behavior/loading/etc.

     

       19
       19
       +
         --

     

       20
       20
       +
         -- Use `opts = {}` to automatically pass options to a plugin's `setup()` function, forcing the plugin to be loaded.

     

       21
       21
       +
         --

     

       22
       22
       +
       

     

       23
       23
       +
         -- Alternatively, use `config = function() ... end` for full control over the configuration.

     

       24
       24
       +
         -- If you prefer to call `setup` explicitly, use:

     

       25
       25
       +
         --    {

     

       26
       26
       +
         --        'lewis6991/gitsigns.nvim',

     

       27
       27
       +
         --        config = function()

     

       28
       28
       +
         --            require('gitsigns').setup({

     

       29
       29
       +
         --                -- Your gitsigns configuration here

     

       30
       30
       +
         --            })

     

       31
       31
       +
         --        end,

     

       32
       32
       +
         --    }

     

       33
       33
       +
         --

     

       34
       34
       +
         -- Here is a more advanced example where we pass configuration

     

       35
       35
       +
         -- options to `gitsigns.nvim`.

     

       36
       36
       +
         --

     

       37
       37
       +
         -- See `:help gitsigns` to understand what the configuration keys do

     

       38
       38
       +
         { -- Adds git related signs to the gutter, as well as utilities for managing changes

     

       39
       39
       +
           'lewis6991/gitsigns.nvim',

     

       40
       40
       +
           opts = {

     

       41
       41
       +
             signs = {

     

       42
       42
       +
               add = { text = '+' },

     

       43
       43
       +
               change = { text = '~' },

     

       44
       44
       +
               delete = { text = '_' },

     

       45
       45
       +
               topdelete = { text = '‾' },

     

       46
       46
       +
               changedelete = { text = '~' },

     

       47
       47
       +
             },

     

       48
       48
       +
           },

     

       49
       49
       +
         },

     

       50
       50
       +
       

     

       51
       51
       +
         -- NOTE: Plugins can also be configured to run Lua code when they are loaded.

     

       52
       52
       +
         --

     

       53
       53
       +
         -- This is often very useful to both group configuration, as well as handle

     

       54
       54
       +
         -- lazy loading plugins that don't need to be loaded immediately at startup.

     

       55
       55
       +
         --

     

       56
       56
       +
         -- For example, in the following configuration, we use:

     

       57
       57
       +
         --  event = 'VimEnter'

     

       58
       58
       +
         --

     

       59
       59
       +
         -- which loads which-key before all the UI elements are loaded. Events can be

     

       60
       60
       +
         -- normal autocommands events (`:help autocmd-events`).

     

       61
       61
       +
         --

     

       62
       62
       +
         -- Then, because we use the `opts` key (recommended), the configuration runs

     

       63
       63
       +
         -- after the plugin has been loaded as `require(MODULE).setup(opts)`.

     

       64
       64
       +
       

     

       65
       65
       +
         { -- Useful plugin to show you pending keybinds.

     

       66
       66
       +
           'folke/which-key.nvim',

     

       67
       67
       +
           event = 'VimEnter', -- Sets the loading event to 'VimEnter'

     

       68
       68
       +
           opts = {

     

       69
       69
       +
             -- delay between pressing a key and opening which-key (milliseconds)

     

       70
       70
       +
             -- this setting is independent of vim.opt.timeoutlen

     

       71
       71
       +
             delay = 0,

     

       72
       72
       +
             icons = {

     

       73
       73
       +
               -- set icon mappings to true if you have a Nerd Font

     

       74
       74
       +
               mappings = vim.g.have_nerd_font,

     

       75
       75
       +
               -- If you are using a Nerd Font: set icons.keys to an empty table which will use the

     

       76
       76
       +
               -- default which-key.nvim defined Nerd Font icons, otherwise define a string table

     

       77
       77
       +
               keys = vim.g.have_nerd_font and {} or {

     

       78
       78
       +
                 Up = '<Up> ',

     

       79
       79
       +
                 Down = '<Down> ',

     

       80
       80
       +
                 Left = '<Left> ',

     

       81
       81
       +
                 Right = '<Right> ',

     

       82
       82
       +
                 C = '<C-…> ',

     

       83
       83
       +
                 M = '<M-…> ',

     

       84
       84
       +
                 D = '<D-…> ',

     

       85
       85
       +
                 S = '<S-…> ',

     

       86
       86
       +
                 CR = '<CR> ',

     

       87
       87
       +
                 Esc = '<Esc> ',

     

       88
       88
       +
                 ScrollWheelDown = '<ScrollWheelDown> ',

     

       89
       89
       +
                 ScrollWheelUp = '<ScrollWheelUp> ',

     

       90
       90
       +
                 NL = '<NL> ',

     

       91
       91
       +
                 BS = '<BS> ',

     

       92
       92
       +
                 Space = '<Space> ',

     

       93
       93
       +
                 Tab = '<Tab> ',

     

       94
       94
       +
                 F1 = '<F1>',

     

       95
       95
       +
                 F2 = '<F2>',

     

       96
       96
       +
                 F3 = '<F3>',

     

       97
       97
       +
                 F4 = '<F4>',

     

       98
       98
       +
                 F5 = '<F5>',

     

       99
       99
       +
                 F6 = '<F6>',

     

       100
       100
       +
                 F7 = '<F7>',

     

       101
       101
       +
                 F8 = '<F8>',

     

       102
       102
       +
                 F9 = '<F9>',

     

       103
       103
       +
                 F10 = '<F10>',

     

       104
       104
       +
                 F11 = '<F11>',

     

       105
       105
       +
                 F12 = '<F12>',

     

       106
       106
       +
               },

     

       107
       107
       +
             },

     

       108
       108
       +
       

     

       109
       109
       +
             -- Document existing key chains

     

       110
       110
       +
             spec = {

     

       111
       111
       +
               { '<leader>c', group = '[C]ode', mode = { 'n', 'x' } },

     

       112
       112
       +
               { '<leader>d', group = '[D]ocument' },

     

       113
       113
       +
               { '<leader>r', group = '[R]ename' },

     

       114
       114
       +
               { '<leader>s', group = '[S]earch' },

     

       115
       115
       +
               { '<leader>w', group = '[W]orkspace' },

     

       116
       116
       +
               { '<leader>t', group = '[T]oggle' },

     

       117
       117
       +
               { '<leader>h', group = 'Git [H]unk', mode = { 'n', 'v' } },

     

       118
       118
       +
             },

     

       119
       119
       +
           },

     

       120
       120
       +
         },

     

       121
       121
       +
       

     

       122
       122
       +
         -- NOTE: Plugins can specify dependencies.

     

       123
       123
       +
         --

     

       124
       124
       +
         -- The dependencies are proper plugin specifications as well - anything

     

       125
       125
       +
         -- you do for a plugin at the top level, you can do for a dependency.

     

       126
       126
       +
         --

     

       127
       127
       +
         -- Use the `dependencies` key to specify the dependencies of a particular plugin

     

       128
       128
       +
       

     

       129
       129
       +
         { -- Fuzzy Finder (files, lsp, etc)

     

       130
       130
       +
           'nvim-telescope/telescope.nvim',

     

       131
       131
       +
           event = 'VimEnter',

     

       132
       132
       +
           branch = '0.1.x',

     

       133
       133
       +
           dependencies = {

     

       134
       134
       +
             'nvim-lua/plenary.nvim',

     

       135
       135
       +
             { -- If encountering errors, see telescope-fzf-native README for installation instructions

     

       136
       136
       +
               'nvim-telescope/telescope-fzf-native.nvim',

     

       137
       137
       +
       

     

       138
       138
       +
               -- `build` is used to run some command when the plugin is installed/updated.

     

       139
       139
       +
               -- This is only run then, not every time Neovim starts up.

     

       140
       140
       +
               build = 'make',

     

       141
       141
       +
       

     

       142
       142
       +
               -- `cond` is a condition used to determine whether this plugin should be

     

       143
       143
       +
               -- installed and loaded.

     

       144
       144
       +
               cond = function()

     

       145
       145
       +
                 return vim.fn.executable 'make' == 1

     

       146
       146
       +
               end,

     

       147
       147
       +
             },

     

       148
       148
       +
             { 'nvim-telescope/telescope-ui-select.nvim' },

     

       149
       149
       +
       

     

       150
       150
       +
             { -- NvimTree

     

       151
       151
       +
               'nvim-tree/nvim-tree.lua',

     

       152
       152
       +
               version = '*',

     

       153
       153
       +
               lazy = false,

     

       154
       154
       +
               dependencies = {

     

       155
       155
       +
                 'nvim-tree/nvim-web-devicons',

     

       156
       156
       +
               },

     

       157
       157
       +
               config = function()

     

       158
       158
       +
                 require('nvim-tree').setup {}

     

       159
       159
       +
               end,

     

       160
       160
       +
             },

     

       161
       161
       +
       

     

       162
       162
       +
             -- Useful for getting pretty icons, but requires a Nerd Font.

     

       163
       163
       +
             { 'nvim-tree/nvim-web-devicons', enabled = vim.g.have_nerd_font },

     

       164
       164
       +
           },

     

       165
       165
       +
           config = function()

     

       166
       166
       +
             -- Telescope is a fuzzy finder that comes with a lot of different things that

     

       167
       167
       +
             -- it can fuzzy find! It's more than just a "file finder", it can search

     

       168
       168
       +
             -- many different aspects of Neovim, your workspace, LSP, and more!

     

       169
       169
       +
             --

     

       170
       170
       +
             -- The easiest way to use Telescope, is to start by doing something like:

     

       171
       171
       +
             --  :Telescope help_tags

     

       172
       172
       +
             --

     

       173
       173
       +
             -- After running this command, a window will open up and you're able to

     

       174
       174
       +
             -- type in the prompt window. You'll see a list of `help_tags` options and

     

       175
       175
       +
             -- a corresponding preview of the help.

     

       176
       176
       +
             --

     

       177
       177
       +
             -- Two important keymaps to use while in Telescope are:

     

       178
       178
       +
             --  - Insert mode: <c-/>

     

       179
       179
       +
             --  - Normal mode: ?

     

       180
       180
       +
             --

     

       181
       181
       +
             -- This opens a window that shows you all of the keymaps for the current

     

       182
       182
       +
             -- Telescope picker. This is really useful to discover what Telescope can

     

       183
       183
       +
             -- do as well as how to actually do it!

     

       184
       184
       +
       

     

       185
       185
       +
             -- [[ Configure Telescope ]]

     

       186
       186
       +
             -- See `:help telescope` and `:help telescope.setup()`

     

       187
       187
       +
             require('telescope').setup {

     

       188
       188
       +
               -- You can put your default mappings / updates / etc. in here

     

       189
       189
       +
               --  All the info you're looking for is in `:help telescope.setup()`

     

       190
       190
       +
               --

     

       191
       191
       +
               -- defaults = {

     

       192
       192
       +
               --   mappings = {

     

       193
       193
       +
               --     i = { ['<c-enter>'] = 'to_fuzzy_refine' },

     

       194
       194
       +
               --   },

     

       195
       195
       +
               -- },

     

       196
       196
       +
               -- pickers = {}

     

       197
       197
       +
               extensions = {

     

       198
       198
       +
                 ['ui-select'] = {

     

       199
       199
       +
                   require('telescope.themes').get_dropdown(),

     

       200
       200
       +
                 },

     

       201
       201
       +
                 media_files = {

     

       202
       202
       +
                   -- filetypes whitelist

     

       203
       203
       +
                   -- defaults to {"png", "jpg", "mp4", "webm", "pdf"}

     

       204
       204
       +
                   filetypes = { 'png', 'jpg', 'jpeg', 'webp', 'mp4', 'webm', 'pdf', 'ico', 'svg' },

     

       205
       205
       +
                   -- find command (defaults to `fd`)

     

       206
       206
       +
                   find_cmd = 'rg',

     

       207
       207
       +
                 },

     

       208
       208
       +
               },

     

       209
       209
       +
             }

     

       210
       210
       +
       

     

       211
       211
       +
             -- Enable Telescope extensions if they are installed

     

       212
       212
       +
             pcall(require('telescope').load_extension, 'fzf')

     

       213
       213
       +
             pcall(require('telescope').load_extension, 'ui-select')

     

       214
       214
       +
             pcall(require('telescope').load_extension, 'media_files')

     

       215
       215
       +
       

     

       216
       216
       +
             -- See `:help telescope.builtin`

     

       217
       217
       +
             local builtin = require 'telescope.builtin'

     

       218
       218
       +
             vim.keymap.set('n', '<leader>sh', builtin.help_tags, { desc = '[S]earch [H]elp' })

     

       219
       219
       +
             vim.keymap.set('n', '<leader>sk', builtin.keymaps, { desc = '[S]earch [K]eymaps' })

     

       220
       220
       +
             vim.keymap.set('n', '<leader>sf', builtin.find_files, { desc = '[S]earch [F]iles' })

     

       221
       221
       +
             vim.keymap.set('n', '<leader>ss', builtin.builtin, { desc = '[S]earch [S]elect Telescope' })

     

       222
       222
       +
             vim.keymap.set('n', '<leader>sw', builtin.grep_string, { desc = '[S]earch current [W]ord' })

     

       223
       223
       +
             vim.keymap.set('n', '<leader>sg', builtin.live_grep, { desc = '[S]earch by [G]rep' })

     

       224
       224
       +
             vim.keymap.set('n', '<leader>sd', builtin.diagnostics, { desc = '[S]earch [D]iagnostics' })

     

       225
       225
       +
             vim.keymap.set('n', '<leader>sr', builtin.resume, { desc = '[S]earch [R]esume' })

     

       226
       226
       +
             vim.keymap.set('n', '<leader>s.', builtin.oldfiles, { desc = '[S]earch Recent Files ("." for repeat)' })

     

       227
       227
       +
             vim.keymap.set('n', '<leader><leader>', builtin.buffers, { desc = '[ ] Find existing buffers' })

     

       228
       228
       +
       

     

       229
       229
       +
             -- Slightly advanced example of overriding default behavior and theme

     

       230
       230
       +
             vim.keymap.set('n', '<leader>/', function()

     

       231
       231
       +
               -- You can pass additional configuration to Telescope to change the theme, layout, etc.

     

       232
       232
       +
               builtin.current_buffer_fuzzy_find(require('telescope.themes').get_dropdown {

     

       233
       233
       +
                 winblend = 10,

     

       234
       234
       +
                 previewer = false,

     

       235
       235
       +
               })

     

       236
       236
       +
             end, { desc = '[/] Fuzzily search in current buffer' })

     

       237
       237
       +
       

     

       238
       238
       +
             -- It's also possible to pass additional configuration options.

     

       239
       239
       +
             --  See `:help telescope.builtin.live_grep()` for information about particular keys

     

       240
       240
       +
             vim.keymap.set('n', '<leader>s/', function()

     

       241
       241
       +
               builtin.live_grep {

     

       242
       242
       +
                 grep_open_files = true,

     

       243
       243
       +
                 prompt_title = 'Live Grep in Open Files',

     

       244
       244
       +
               }

     

       245
       245
       +
             end, { desc = '[S]earch [/] in Open Files' })

     

       246
       246
       +
       

     

       247
       247
       +
             -- Shortcut for searching your Neovim configuration files

     

       248
       248
       +
             vim.keymap.set('n', '<leader>sn', function()

     

       249
       249
       +
               builtin.find_files { cwd = vim.fn.stdpath 'config' }

     

       250
       250
       +
             end, { desc = '[S]earch [N]eovim files' })

     

       251
       251
       +
           end,

     

       252
       252
       +
         },

     

       253
       253
       +
       

     

       254
       254
       +
         -- LSP Plugins

     

       255
       255
       +
         {

     

       256
       256
       +
           -- `lazydev` configures Lua LSP for your Neovim config, runtime and plugins

     

       257
       257
       +
           -- used for completion, annotations and signatures of Neovim apis

     

       258
       258
       +
           'folke/lazydev.nvim',

     

       259
       259
       +
           ft = 'lua',

     

       260
       260
       +
           opts = {

     

       261
       261
       +
             library = {

     

       262
       262
       +
               -- Load luvit types when the `vim.uv` word is found

     

       263
       263
       +
               { path = '${3rd}/luv/library', words = { 'vim%.uv' } },

     

       264
       264
       +
             },

     

       265
       265
       +
           },

     

       266
       266
       +
         },

     

       267
       267
       +
       

     

       268
       268
       +
         {

     

       269
       269
       +
           -- Main LSP Configuration

     

       270
       270
       +
           'neovim/nvim-lspconfig',

     

       271
       271
       +
           dependencies = {

     

       272
       272
       +
             -- Automatically install LSPs and related tools to stdpath for Neovim

     

       273
       273
       +
             -- Mason must be loaded before its dependents so we need to set it up here.

     

       274
       274
       +
             -- NOTE: `opts = {}` is the same as calling `require('mason').setup({})`

     

       275
       275
       +
             { 'williamboman/mason.nvim', opts = {} },

     

       276
       276
       +
             'williamboman/mason-lspconfig.nvim',

     

       277
       277
       +
             'WhoIsSethDaniel/mason-tool-installer.nvim',

     

       278
       278
       +
       

     

       279
       279
       +
             -- Useful status updates for LSP.

     

       280
       280
       +
             { 'j-hui/fidget.nvim', opts = {} },

     

       281
       281
       +
       

     

       282
       282
       +
             -- Allows extra capabilities provided by nvim-cmp

     

       283
       283
       +
             'hrsh7th/cmp-nvim-lsp',

     

       284
       284
       +
           },

     

       285
       285
       +
           config = function()

     

       286
       286
       +
             -- Brief aside: **What is LSP?**

     

       287
       287
       +
             --

     

       288
       288
       +
             -- LSP is an initialism you've probably heard, but might not understand what it is.

     

       289
       289
       +
             --

     

       290
       290
       +
             -- LSP stands for Language Server Protocol. It's a protocol that helps editors

     

       291
       291
       +
             -- and language tooling communicate in a standardized fashion.

     

       292
       292
       +
             --

     

       293
       293
       +
             -- In general, you have a "server" which is some tool built to understand a particular

     

       294
       294
       +
             -- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers

     

       295
       295
       +
             -- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone

     

       296
       296
       +
             -- processes that communicate with some "client" - in this case, Neovim!

     

       297
       297
       +
             --

     

       298
       298
       +
             -- LSP provides Neovim with features like:

     

       299
       299
       +
             --  - Go to definition

     

       300
       300
       +
             --  - Find references

     

       301
       301
       +
             --  - Autocompletion

     

       302
       302
       +
             --  - Symbol Search

     

       303
       303
       +
             --  - and more!

     

       304
       304
       +
             --

     

       305
       305
       +
             -- Thus, Language Servers are external tools that must be installed separately from

     

       306
       306
       +
             -- Neovim. This is where `mason` and related plugins come into play.

     

       307
       307
       +
             --

     

       308
       308
       +
             -- If you're wondering about lsp vs treesitter, you can check out the wonderfully

     

       309
       309
       +
             -- and elegantly composed help section, `:help lsp-vs-treesitter`

     

       310
       310
       +
       

     

       311
       311
       +
             --  This function gets run when an LSP attaches to a particular buffer.

     

       312
       312
       +
             --    That is to say, every time a new file is opened that is associated with

     

       313
       313
       +
             --    an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this

     

       314
       314
       +
             --    function will be executed to configure the current buffer

     

       315
       315
       +
             vim.api.nvim_create_autocmd('LspAttach', {

     

       316
       316
       +
               group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),

     

       317
       317
       +
               callback = function(event)

     

       318
       318
       +
                 -- NOTE: Remember that Lua is a real programming language, and as such it is possible

     

       319
       319
       +
                 -- to define small helper and utility functions so you don't have to repeat yourself.

     

       320
       320
       +
                 --

     

       321
       321
       +
                 -- In this case, we create a function that lets us more easily define mappings specific

     

       322
       322
       +
                 -- for LSP related items. It sets the mode, buffer and description for us each time.

     

       323
       323
       +
                 local map = function(keys, func, desc, mode)

     

       324
       324
       +
                   mode = mode or 'n'

     

       325
       325
       +
                   vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })

     

       326
       326
       +
                 end

     

       327
       327
       +
       

     

       328
       328
       +
                 -- Jump to the definition of the word under your cursor.

     

       329
       329
       +
                 --  This is where a variable was first declared, or where a function is defined, etc.

     

       330
       330
       +
                 --  To jump back, press <C-t>.

     

       331
       331
       +
                 map('gd', require('telescope.builtin').lsp_definitions, '[G]oto [D]efinition')

     

       332
       332
       +
       

     

       333
       333
       +
                 -- Find references for the word under your cursor.

     

       334
       334
       +
                 map('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')

     

       335
       335
       +
       

     

       336
       336
       +
                 -- Jump to the implementation of the word under your cursor.

     

       337
       337
       +
                 --  Useful when your language has ways of declaring types without an actual implementation.

     

       338
       338
       +
                 map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')

     

       339
       339
       +
       

     

       340
       340
       +
                 -- Jump to the type of the word under your cursor.

     

       341
       341
       +
                 --  Useful when you're not sure what type a variable is and you want to see

     

       342
       342
       +
                 --  the definition of its *type*, not where it was *defined*.

     

       343
       343
       +
                 map('<leader>D', require('telescope.builtin').lsp_type_definitions, 'Type [D]efinition')

     

       344
       344
       +
       

     

       345
       345
       +
                 -- Fuzzy find all the symbols in your current document.

     

       346
       346
       +
                 --  Symbols are things like variables, functions, types, etc.

     

       347
       347
       +
                 map('<leader>ds', require('telescope.builtin').lsp_document_symbols, '[D]ocument [S]ymbols')

     

       348
       348
       +
       

     

       349
       349
       +
                 -- Fuzzy find all the symbols in your current workspace.

     

       350
       350
       +
                 --  Similar to document symbols, except searches over your entire project.

     

       351
       351
       +
                 map('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols')

     

       352
       352
       +
       

     

       353
       353
       +
                 -- Rename the variable under your cursor.

     

       354
       354
       +
                 --  Most Language Servers support renaming across files, etc.

     

       355
       355
       +
                 map('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')

     

       356
       356
       +
       

     

       357
       357
       +
                 -- Execute a code action, usually your cursor needs to be on top of an error

     

       358
       358
       +
                 -- or a suggestion from your LSP for this to activate.

     

       359
       359
       +
                 map('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction', { 'n', 'x' })

     

       360
       360
       +
       

     

       361
       361
       +
                 -- WARN: This is not Goto Definition, this is Goto Declaration.

     

       362
       362
       +
                 --  For example, in C this would take you to the header.

     

       363
       363
       +
                 map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')

     

       364
       364
       +
       

     

       365
       365
       +
                 -- This function resolves a difference between neovim nightly (version 0.11) and stable (version 0.10)

     

       366
       366
       +
                 ---@param client vim.lsp.Client

     

       367
       367
       +
                 ---@param method vim.lsp.protocol.Method

     

       368
       368
       +
                 ---@param bufnr? integer some lsp support methods only in specific files

     

       369
       369
       +
                 ---@return boolean

     

       370
       370
       +
                 local function client_supports_method(client, method, bufnr)

     

       371
       371
       +
                   if vim.fn.has 'nvim-0.11' == 1 then

     

       372
       372
       +
                     return client:supports_method(method, bufnr)

     

       373
       373
       +
                   else

     

       374
       374
       +
                     return client.supports_method(method, { bufnr = bufnr })

     

       375
       375
       +
                   end

     

       376
       376
       +
                 end

     

       377
       377
       +
       

     

       378
       378
       +
                 -- The following two autocommands are used to highlight references of the

     

       379
       379
       +
                 -- word under your cursor when your cursor rests there for a little while.

     

       380
       380
       +
                 --    See `:help CursorHold` for information about when this is executed

     

       381
       381
       +
                 --

     

       382
       382
       +
                 -- When you move your cursor, the highlights will be cleared (the second autocommand).

     

       383
       383
       +
                 local client = vim.lsp.get_client_by_id(event.data.client_id)

     

       384
       384
       +
                 if client and client_supports_method(client, vim.lsp.protocol.Methods.textDocument_documentHighlight, event.buf) then

     

       385
       385
       +
                   local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })

     

       386
       386
       +
                   vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {

     

       387
       387
       +
                     buffer = event.buf,

     

       388
       388
       +
                     group = highlight_augroup,

     

       389
       389
       +
                     callback = vim.lsp.buf.document_highlight,

     

       390
       390
       +
                   })

     

       391
       391
       +
       

     

       392
       392
       +
                   vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {

     

       393
       393
       +
                     buffer = event.buf,

     

       394
       394
       +
                     group = highlight_augroup,

     

       395
       395
       +
                     callback = vim.lsp.buf.clear_references,

     

       396
       396
       +
                   })

     

       397
       397
       +
       

     

       398
       398
       +
                   vim.api.nvim_create_autocmd('LspDetach', {

     

       399
       399
       +
                     group = vim.api.nvim_create_augroup('kickstart-lsp-detach', { clear = true }),

     

       400
       400
       +
                     callback = function(event2)

     

       401
       401
       +
                       vim.lsp.buf.clear_references()

     

       402
       402
       +
                       vim.api.nvim_clear_autocmds { group = 'kickstart-lsp-highlight', buffer = event2.buf }

     

       403
       403
       +
                     end,

     

       404
       404
       +
                   })

     

       405
       405
       +
                 end

     

       406
       406
       +
       

     

       407
       407
       +
                 -- The following code creates a keymap to toggle inlay hints in your

     

       408
       408
       +
                 -- code, if the language server you are using supports them

     

       409
       409
       +
                 --

     

       410
       410
       +
                 -- This may be unwanted, since they displace some of your code

     

       411
       411
       +
                 if client and client_supports_method(client, vim.lsp.protocol.Methods.textDocument_inlayHint, event.buf) then

     

       412
       412
       +
                   map('<leader>th', function()

     

       413
       413
       +
                     vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled { bufnr = event.buf })

     

       414
       414
       +
                   end, '[T]oggle Inlay [H]ints')

     

       415
       415
       +
                 end

     

       416
       416
       +
               end,

     

       417
       417
       +
             })

     

       418
       418
       +
       

     

       419
       419
       +
             -- Diagnostic Config

     

       420
       420
       +
             -- See :help vim.diagnostic.Opts

     

       421
       421
       +
             vim.diagnostic.config {

     

       422
       422
       +
               severity_sort = true,

     

       423
       423
       +
               float = { border = 'rounded', source = 'if_many' },

     

       424
       424
       +
               underline = { severity = vim.diagnostic.severity.ERROR },

     

       425
       425
       +
               signs = vim.g.have_nerd_font and {

     

       426
       426
       +
                 text = {

     

       427
       427
       +
                   [vim.diagnostic.severity.ERROR] = '󰅚 ',

     

       428
       428
       +
                   [vim.diagnostic.severity.WARN] = '󰀪 ',

     

       429
       429
       +
                   [vim.diagnostic.severity.INFO] = '󰋽 ',

     

       430
       430
       +
                   [vim.diagnostic.severity.HINT] = '󰌶 ',

     

       431
       431
       +
                 },

     

       432
       432
       +
               } or {},

     

       433
       433
       +
               virtual_text = {

     

       434
       434
       +
                 source = 'if_many',

     

       435
       435
       +
                 spacing = 2,

     

       436
       436
       +
                 format = function(diagnostic)

     

       437
       437
       +
                   local diagnostic_message = {

     

       438
       438
       +
                     [vim.diagnostic.severity.ERROR] = diagnostic.message,

     

       439
       439
       +
                     [vim.diagnostic.severity.WARN] = diagnostic.message,

     

       440
       440
       +
                     [vim.diagnostic.severity.INFO] = diagnostic.message,

     

       441
       441
       +
                     [vim.diagnostic.severity.HINT] = diagnostic.message,

     

       442
       442
       +
                   }

     

       443
       443
       +
                   return diagnostic_message[diagnostic.severity]

     

       444
       444
       +
                 end,

     

       445
       445
       +
               },

     

       446
       446
       +
             }

     

       447
       447
       +
       

     

       448
       448
       +
             -- LSP servers and clients are able to communicate to each other what features they support.

     

       449
       449
       +
             --  By default, Neovim doesn't support everything that is in the LSP specification.

     

       450
       450
       +
             --  When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.

     

       451
       451
       +
             --  So, we create new capabilities with nvim cmp, and then broadcast that to the servers.

     

       452
       452
       +
             local capabilities = vim.lsp.protocol.make_client_capabilities()

     

       453
       453
       +
             capabilities = vim.tbl_deep_extend('force', capabilities, require('cmp_nvim_lsp').default_capabilities())

     

       454
       454
       +
       

     

       455
       455
       +
             -- Enable the following language servers

     

       456
       456
       +
             --  Feel free to add/remove any LSPs that you want here. They will automatically be installed.

     

       457
       457
       +
             --

     

       458
       458
       +
             --  Add any additional override configuration in the following tables. Available keys are:

     

       459
       459
       +
             --  - cmd (table): Override the default command used to start the server

     

       460
       460
       +
             --  - filetypes (table): Override the default list of associated filetypes for the server

     

       461
       461
       +
             --  - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features.

     

       462
       462
       +
             --  - settings (table): Override the default settings passed when initializing the server.

     

       463
       463
       +
             --        For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/

     

       464
       464
       +
             local servers = {

     

       465
       465
       +
               ansiblels = {},

     

       466
       466
       +
               awk_ls = {},

     

       467
       467
       +
               bashls = {},

     

       468
       468
       +
               css_variables = {},

     

       469
       469
       +
               cssls = {},

     

       470
       470
       +
               cssmodules_ls = {},

     

       471
       471
       +
               docker_compose_language_service = {},

     

       472
       472
       +
               dockerls = {},

     

       473
       473
       +
               html = {},

     

       474
       474
       +
               jsonls = {},

     

       475
       475
       +
               pyright = {},

     

       476
       476
       +
               yamlls = {},

     

       477
       477
       +
               lua_ls = {

     

       478
       478
       +
                 -- cmd = { ... },

     

       479
       479
       +
                 -- filetypes = { ... },

     

       480
       480
       +
                 -- capabilities = {},

     

       481
       481
       +
                 settings = {

     

       482
       482
       +
                   Lua = {

     

       483
       483
       +
                     completion = {

     

       484
       484
       +
                       callSnippet = 'Replace',

     

       485
       485
       +
                     },

     

       486
       486
       +
                     -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings

     

       487
       487
       +
                     -- diagnostics = { disable = { 'missing-fields' } },

     

       488
       488
       +
                   },

     

       489
       489
       +
                 },

     

       490
       490
       +
               },

     

       491
       491
       +
               marksman = {},

     

       492
       492
       +
             }

     

       493
       493
       +
       

     

       494
       494
       +
             -- Ensure the servers and tools above are installed

     

       495
       495
       +
             --

     

       496
       496
       +
             -- To check the current status of installed tools and/or manually install

     

       497
       497
       +
             -- other tools, you can run

     

       498
       498
       +
             --    :Mason

     

       499
       499
       +
             --

     

       500
       500
       +
             -- You can press `g?` for help in this menu.

     

       501
       501
       +
             --

     

       502
       502
       +
             -- `mason` had to be setup earlier: to configure its options see the

     

       503
       503
       +
             -- `dependencies` table for `nvim-lspconfig` above.

     

       504
       504
       +
             --

     

       505
       505
       +
             -- You can add other tools here that you want Mason to install

     

       506
       506
       +
             -- for you, so that they are available from within Neovim.

     

       507
       507
       +
             local ensure_installed = vim.tbl_keys(servers or {})

     

       508
       508
       +
             vim.list_extend(ensure_installed, {

     

       509
       509
       +
               'stylua', -- Used to format Lua code

     

       510
       510
       +
             })

     

       511
       511
       +
             require('mason-tool-installer').setup { ensure_installed = ensure_installed }

     

       512
       512
       +
       

     

       513
       513
       +
             require('mason-lspconfig').setup {

     

       514
       514
       +
               ensure_installed = {}, -- explicitly set to an empty table (Kickstart populates installs via mason-tool-installer)

     

       515
       515
       +
               automatic_installation = false,

     

       516
       516
       +
               handlers = {

     

       517
       517
       +
                 function(server_name)

     

       518
       518
       +
                   local server = servers[server_name] or {}

     

       519
       519
       +
                   -- This handles overriding only values explicitly passed

     

       520
       520
       +
                   -- by the server configuration above. Useful when disabling

     

       521
       521
       +
                   -- certain features of an LSP (for example, turning off formatting for ts_ls)

     

       522
       522
       +
                   server.capabilities = vim.tbl_deep_extend('force', {}, capabilities, server.capabilities or {})

     

       523
       523
       +
                   require('lspconfig')[server_name].setup(server)

     

       524
       524
       +
                 end,

     

       525
       525
       +
               },

     

       526
       526
       +
             }

     

       527
       527
       +
           end,

     

       528
       528
       +
         },

     

       529
       529
       +
       

     

       530
       530
       +
         { -- markview

     

       531
       531
       +
           'OXY2DEV/markview.nvim',

     

       532
       532
       +
           lazy = false,

     

       533
       533
       +
         },

     

       534
       534
       +
       

     

       535
       535
       +
         { -- Autoformat

     

       536
       536
       +
           'stevearc/conform.nvim',

     

       537
       537
       +
           event = { 'BufWritePre' },

     

       538
       538
       +
           cmd = { 'ConformInfo' },

     

       539
       539
       +
           keys = {

     

       540
       540
       +
             {

     

       541
       541
       +
               '<leader>f',

     

       542
       542
       +
               function()

     

       543
       543
       +
                 require('conform').format { async = true, lsp_format = 'fallback' }

     

       544
       544
       +
               end,

     

       545
       545
       +
               mode = '',

     

       546
       546
       +
               desc = '[F]ormat buffer',

     

       547
       547
       +
             },

     

       548
       548
       +
           },

     

       549
       549
       +
           opts = {

     

       550
       550
       +
             notify_on_error = false,

     

       551
       551
       +
             format_on_save = function(bufnr)

     

       552
       552
       +
               -- Disable "format_on_save lsp_fallback" for languages that don't

     

       553
       553
       +
               -- have a well standardized coding style. You can add additional

     

       554
       554
       +
               -- languages here or re-enable it for the disabled ones.

     

       555
       555
       +
               local disable_filetypes = { c = true, cpp = true }

     

       556
       556
       +
               local lsp_format_opt

     

       557
       557
       +
               if disable_filetypes[vim.bo[bufnr].filetype] then

     

       558
       558
       +
                 lsp_format_opt = 'never'

     

       559
       559
       +
               else

     

       560
       560
       +
                 lsp_format_opt = 'fallback'

     

       561
       561
       +
               end

     

       562
       562
       +
               return {

     

       563
       563
       +
                 timeout_ms = 500,

     

       564
       564
       +
                 lsp_format = lsp_format_opt,

     

       565
       565
       +
               }

     

       566
       566
       +
             end,

     

       567
       567
       +
             formatters_by_ft = {

     

       568
       568
       +
               ansible = { 'ansible-lint' },

     

       569
       569
       +
               bash = { 'shellcheck', 'shfmt' },

     

       570
       570
       +
               docker = { 'dockerfmt' },

     

       571
       571
       +
               json = { 'jq' },

     

       572
       572
       +
               just = { 'just' },

     

       573
       573
       +
               lua = { 'stylua' },

     

       574
       574
       +
               markdown = { 'markdownlint-cli2' },

     

       575
       575
       +
               nginx = { 'nginxfmt' },

     

       576
       576
       +
               nushell = { 'nufmt' },

     

       577
       577
       +
               python = { 'isort', 'black' },

     

       578
       578
       +
               yaml = { 'yamlfmt' },

     

       579
       579
       +
             },

     

       580
       580
       +
           },

     

       581
       581
       +
         },

     

       582
       582
       +
       

     

       583
       583
       +
         { -- Autocompletion

     

       584
       584
       +
           'hrsh7th/nvim-cmp',

     

       585
       585
       +
           event = 'InsertEnter',

     

       586
       586
       +
           dependencies = {

     

       587
       587
       +
             -- Snippet Engine & its associated nvim-cmp source

     

       588
       588
       +
             {

     

       589
       589
       +
               'L3MON4D3/LuaSnip',

     

       590
       590
       +
               build = (function()

     

       591
       591
       +
                 -- Build Step is needed for regex support in snippets.

     

       592
       592
       +
                 -- This step is not supported in many windows environments.

     

       593
       593
       +
                 -- Remove the below condition to re-enable on windows.

     

       594
       594
       +
                 if vim.fn.has 'win32' == 1 or vim.fn.executable 'make' == 0 then

     

       595
       595
       +
                   return

     

       596
       596
       +
                 end

     

       597
       597
       +
                 return 'make install_jsregexp'

     

       598
       598
       +
               end)(),

     

       599
       599
       +
               dependencies = {

     

       600
       600
       +
                 -- `friendly-snippets` contains a variety of premade snippets.

     

       601
       601
       +
                 --    See the README about individual language/framework/plugin snippets:

     

       602
       602
       +
                 --    https://github.com/rafamadriz/friendly-snippets

     

       603
       603
       +
                 -- {

     

       604
       604
       +
                 --   'rafamadriz/friendly-snippets',

     

       605
       605
       +
                 --   config = function()

     

       606
       606
       +
                 --     require('luasnip.loaders.from_vscode').lazy_load()

     

       607
       607
       +
                 --   end,

     

       608
       608
       +
                 -- },

     

       609
       609
       +
               },

     

       610
       610
       +
             },

     

       611
       611
       +
             'saadparwaiz1/cmp_luasnip',

     

       612
       612
       +
       

     

       613
       613
       +
             -- Adds other completion capabilities.

     

       614
       614
       +
             --  nvim-cmp does not ship with all sources by default. They are split

     

       615
       615
       +
             --  into multiple repos for maintenance purposes.

     

       616
       616
       +
             'hrsh7th/cmp-nvim-lsp',

     

       617
       617
       +
             'hrsh7th/cmp-path',

     

       618
       618
       +
             'hrsh7th/cmp-nvim-lsp-signature-help',

     

       619
       619
       +
           },

     

       620
       620
       +
           config = function()

     

       621
       621
       +
             -- See `:help cmp`

     

       622
       622
       +
             local cmp = require 'cmp'

     

       623
       623
       +
             local luasnip = require 'luasnip'

     

       624
       624
       +
             luasnip.config.setup {}

     

       625
       625
       +
       

     

       626
       626
       +
             cmp.setup {

     

       627
       627
       +
               snippet = {

     

       628
       628
       +
                 expand = function(args)

     

       629
       629
       +
                   luasnip.lsp_expand(args.body)

     

       630
       630
       +
                 end,

     

       631
       631
       +
               },

     

       632
       632
       +
               completion = { completeopt = 'menu,menuone,noinsert' },

     

       633
       633
       +
       

     

       634
       634
       +
               -- For an understanding of why these mappings were

     

       635
       635
       +
               -- chosen, you will need to read `:help ins-completion`

     

       636
       636
       +
               --

     

       637
       637
       +
               -- No, but seriously. Please read `:help ins-completion`, it is really good!

     

       638
       638
       +
               mapping = cmp.mapping.preset.insert {

     

       639
       639
       +
                 -- Select the [n]ext item

     

       640
       640
       +
                 ['<C-n>'] = cmp.mapping.select_next_item(),

     

       641
       641
       +
                 -- Select the [p]revious item

     

       642
       642
       +
                 ['<C-p>'] = cmp.mapping.select_prev_item(),

     

       643
       643
       +
       

     

       644
       644
       +
                 -- Scroll the documentation window [b]ack / [f]orward

     

       645
       645
       +
                 ['<C-b>'] = cmp.mapping.scroll_docs(-4),

     

       646
       646
       +
                 ['<C-f>'] = cmp.mapping.scroll_docs(4),

     

       647
       647
       +
       

     

       648
       648
       +
                 -- Accept ([y]es) the completion.

     

       649
       649
       +
                 --  This will auto-import if your LSP supports it.

     

       650
       650
       +
                 --  This will expand snippets if the LSP sent a snippet.

     

       651
       651
       +
                 ['<C-y>'] = cmp.mapping.confirm { select = true },

     

       652
       652
       +
       

     

       653
       653
       +
                 -- If you prefer more traditional completion keymaps,

     

       654
       654
       +
                 -- you can uncomment the following lines

     

       655
       655
       +
                 --['<CR>'] = cmp.mapping.confirm { select = true },

     

       656
       656
       +
                 --['<Tab>'] = cmp.mapping.select_next_item(),

     

       657
       657
       +
                 --['<S-Tab>'] = cmp.mapping.select_prev_item(),

     

       658
       658
       +
       

     

       659
       659
       +
                 -- Manually trigger a completion from nvim-cmp.

     

       660
       660
       +
                 --  Generally you don't need this, because nvim-cmp will display

     

       661
       661
       +
                 --  completions whenever it has completion options available.

     

       662
       662
       +
                 ['<C-Space>'] = cmp.mapping.complete {},

     

       663
       663
       +
       

     

       664
       664
       +
                 -- Think of <c-l> as moving to the right of your snippet expansion.

     

       665
       665
       +
                 --  So if you have a snippet that's like:

     

       666
       666
       +
                 --  function $name($args)

     

       667
       667
       +
                 --    $body

     

       668
       668
       +
                 --  end

     

       669
       669
       +
                 --

     

       670
       670
       +
                 -- <c-l> will move you to the right of each of the expansion locations.

     

       671
       671
       +
                 -- <c-h> is similar, except moving you backwards.

     

       672
       672
       +
                 ['<C-l>'] = cmp.mapping(function()

     

       673
       673
       +
                   if luasnip.expand_or_locally_jumpable() then

     

       674
       674
       +
                     luasnip.expand_or_jump()

     

       675
       675
       +
                   end

     

       676
       676
       +
                 end, { 'i', 's' }),

     

       677
       677
       +
                 ['<C-h>'] = cmp.mapping(function()

     

       678
       678
       +
                   if luasnip.locally_jumpable(-1) then

     

       679
       679
       +
                     luasnip.jump(-1)

     

       680
       680
       +
                   end

     

       681
       681
       +
                 end, { 'i', 's' }),

     

       682
       682
       +
       

     

       683
       683
       +
                 -- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:

     

       684
       684
       +
                 --    https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps

     

       685
       685
       +
               },

     

       686
       686
       +
               sources = {

     

       687
       687
       +
                 {

     

       688
       688
       +
                   name = 'lazydev',

     

       689
       689
       +
                   -- set group index to 0 to skip loading LuaLS completions as lazydev recommends it

     

       690
       690
       +
                   group_index = 0,

     

       691
       691
       +
                 },

     

       692
       692
       +
                 { name = 'nvim_lsp' },

     

       693
       693
       +
                 { name = 'luasnip' },

     

       694
       694
       +
                 { name = 'path' },

     

       695
       695
       +
                 { name = 'nvim_lsp_signature_help' },

     

       696
       696
       +
               },

     

       697
       697
       +
             }

     

       698
       698
       +
           end,

     

       699
       699
       +
         },

     

       700
       700
       +
       

     

       701
       701
       +
         { -- Catppuccin theme

     

       702
       702
       +
           'catppuccin/nvim',

     

       703
       703
       +
           name = 'catppuccin',

     

       704
       704
       +
           priority = 1000,

     

       705
       705
       +
           config = function()

     

       706
       706
       +
             vim.cmd 'colorscheme catppuccin'

     

       707
       707
       +
             require('catppuccin').setup {

     

       708
       708
       +
               flavor = 'mocha',

     

       709
       709
       +
             }

     

       710
       710
       +
           end,

     

       711
       711
       +
         },

     

       712
       712
       +
       

     

       713
       713
       +
         { -- Highlight todo, notes, etc in comments

     

       714
       714
       +
           'folke/todo-comments.nvim',

     

       715
       715
       +
           event = 'VimEnter',

     

       716
       716
       +
           dependencies = { 'nvim-lua/plenary.nvim' },

     

       717
       717
       +
           opts = { signs = false },

     

       718
       718
       +
         },

     

       719
       719
       +
       

     

       720
       720
       +
         { -- Collection of various small independent plugins/modules

     

       721
       721
       +
           'echasnovski/mini.nvim',

     

       722
       722
       +
           config = function()

     

       723
       723
       +
             -- Better Around/Inside textobjects

     

       724
       724
       +
             --

     

       725
       725
       +
             -- Examples:

     

       726
       726
       +
             --  - va)  - [V]isually select [A]round [)]paren

     

       727
       727
       +
             --  - yinq - [Y]ank [I]nside [N]ext [Q]uote

     

       728
       728
       +
             --  - ci'  - [C]hange [I]nside [']quote

     

       729
       729
       +
             require('mini.ai').setup { n_lines = 500 }

     

       730
       730
       +
       

     

       731
       731
       +
             -- Add/delete/replace surroundings (brackets, quotes, etc.)

     

       732
       732
       +
             --

     

       733
       733
       +
             -- - saiw) - [S]urround [A]dd [I]nner [W]ord [)]Paren

     

       734
       734
       +
             -- - sd'   - [S]urround [D]elete [']quotes

     

       735
       735
       +
             -- - sr)'  - [S]urround [R]eplace [)] [']

     

       736
       736
       +
             require('mini.surround').setup()

     

       737
       737
       +
       

     

       738
       738
       +
             -- Simple and easy statusline.

     

       739
       739
       +
             --  You could remove this setup call if you don't like it,

     

       740
       740
       +
             --  and try some other statusline plugin

     

       741
       741
       +
             local statusline = require 'mini.statusline'

     

       742
       742
       +
             -- set use_icons to true if you have a Nerd Font

     

       743
       743
       +
             statusline.setup { use_icons = vim.g.have_nerd_font }

     

       744
       744
       +
       

     

       745
       745
       +
             -- You can configure sections in the statusline by overriding their

     

       746
       746
       +
             -- default behavior. For example, here we set the section for

     

       747
       747
       +
             -- cursor location to LINE:COLUMN

     

       748
       748
       +
             ---@diagnostic disable-next-line: duplicate-set-field

     

       749
       749
       +
             statusline.section_location = function()

     

       750
       750
       +
               return '%2l:%-2v'

     

       751
       751
       +
             end

     

       752
       752
       +
       

     

       753
       753
       +
             -- ... and there is more!

     

       754
       754
       +
             --  Check out: https://github.com/echasnovski/mini.nvim

     

       755
       755
       +
           end,

     

       756
       756
       +
         },

     

       757
       757
       +
       

     

       758
       758
       +
         { -- Highlight, edit, and navigate code

     

       759
       759
       +
           'nvim-treesitter/nvim-treesitter',

     

       760
       760
       +
           build = ':TSUpdate',

     

       761
       761
       +
           main = 'nvim-treesitter.configs', -- Sets main module to use for opts

     

       762
       762
       +
           -- [[ Configure Treesitter ]] See `:help nvim-treesitter`

     

       763
       763
       +
           opts = {

     

       764
       764
       +
             ensure_installed = { 'bash', 'c', 'diff', 'html', 'lua', 'luadoc', 'markdown', 'markdown_inline', 'query', 'vim', 'vimdoc' },

     

       765
       765
       +
             -- Autoinstall languages that are not installed

     

       766
       766
       +
             auto_install = true,

     

       767
       767
       +
             highlight = {

     

       768
       768
       +
               enable = true,

     

       769
       769
       +
               -- Some languages depend on vim's regex highlighting system (such as Ruby) for indent rules.

     

       770
       770
       +
               --  If you are experiencing weird indenting issues, add the language to

     

       771
       771
       +
               --  the list of additional_vim_regex_highlighting and disabled languages for indent.

     

       772
       772
       +
               additional_vim_regex_highlighting = { 'ruby' },

     

       773
       773
       +
             },

     

       774
       774
       +
             indent = { enable = true, disable = { 'ruby' } },

     

       775
       775
       +
           },

     

       776
       776
       +
       

     

       777
       777
       +
           { --NERDCommenter

     

       778
       778
       +
             'preservim/nerdcommenter',

     

       779
       779
       +
           },

     

       780
       780
       +
       

     

       781
       781
       +
           { --Gemini file syntax highlighting

     

       782
       782
       +
             'https://tildegit.org/sloum/gemini-vim-syntax',

     

       783
       783
       +
           },

     

       784
       784
       +
       

     

       785
       785
       +
           { --telescope-media-files

     

       786
       786
       +
             'nvim-telescope/telescope-media-files.nvim',

     

       787
       787
       +
           },

     

       788
       788
       +
           -- There are additional nvim-treesitter modules that you can use to interact

     

       789
       789
       +
           -- with nvim-treesitter. You should go explore a few and see what interests you:

     

       790
       790
       +
           --

     

       791
       791
       +
           --    - Incremental selection: Included, see `:help nvim-treesitter-incremental-selection-mod`

     

       792
       792
       +
           --    - Show your current context: https://github.com/nvim-treesitter/nvim-treesitter-context

     

       793
       793
       +
           --    - Treesitter + textobjects: https://github.com/nvim-treesitter/nvim-treesitter-textobjects

     

       794
       794
       +
         },

     

       795
       795
       +
       

     

       796
       796
       +
         -- The following comments only work if you have downloaded the kickstart repo, not just copy pasted the

     

       797
       797
       +
         -- init.lua. If you want these files, they are in the repository, so you can just download them and

     

       798
       798
       +
         -- place them in the correct locations.

     

       799
       799
       +
       

     

       800
       800
       +
         -- NOTE: Next step on your Neovim journey: Add/Configure additional plugins for Kickstart

     

       801
       801
       +
         --

     

       802
       802
       +
         --  Here are some example plugins that I've included in the Kickstart repository.

     

       803
       803
       +
         --  Uncomment any of the lines below to enable them (you will need to restart nvim).

     

       804
       804
       +
         --

     

       805
       805
       +
         -- require 'kickstart.plugins.debug',

     

       806
       806
       +
         -- require 'kickstart.plugins.indent_line',

     

       807
       807
       +
         -- require 'kickstart.plugins.lint',

     

       808
       808
       +
         -- require 'kickstart.plugins.autopairs',

     

       809
       809
       +
         -- require 'kickstart.plugins.neo-tree',

     

       810
       810
       +
         -- require 'kickstart.plugins.gitsigns', -- adds gitsigns recommend keymaps

     

       811
       811
       +
       

     

       812
       812
       +
         -- NOTE: The import below can automatically add your own plugins, configuration, etc from `lua/custom/plugins/*.lua`

     

       813
       813
       +
         --    This is the easiest way to modularize your config.

     

       814
       814
       +
         --

     

       815
       815
       +
         --  Uncomment the following line and add your plugins to `lua/custom/plugins/*.lua` to get going.

     

       816
       816
       +
         -- { import = 'custom.plugins' },

     

       817
       817
       +
         --

     

       818
       818
       +
         -- For additional information with loading, sourcing and examples see `:help lazy.nvim-🔌-plugin-spec`

     

       819
       819
       +
         -- Or use telescope!

     

       820
       820
       +
         -- In normal mode type `<space>sh` then write `lazy.nvim-plugin`

     

       821
       821
       +
         -- you can continue same window with `<space>sr` which resumes last telescope search

     

       822
       822
       +
       }, {

     

       823
       823
       +
         ui = {

     

       824
       824
       +
           -- If you are using a Nerd Font: set icons to an empty table which will use the

     

       825
       825
       +
           -- default lazy.nvim defined Nerd Font icons, otherwise define a unicode icons table

     

       826
       826
       +
           icons = vim.g.have_nerd_font and {} or {

     

       827
       827
       +
             cmd = '⌘',

     

       828
       828
       +
             config = '🛠',

     

       829
       829
       +
             event = '📅',

     

       830
       830
       +
             ft = '📂',

     

       831
       831
       +
             init = '⚙',

     

       832
       832
       +
             keys = '🗝',

     

       833
       833
       +
             plugin = '🔌',

     

       834
       834
       +
             runtime = '💻',

     

       835
       835
       +
             require = '🌙',

     

       836
       836
       +
             source = '📄',

     

       837
       837
       +
             start = '🚀',

     

       838
       838
       +
             task = '📌',

     

       839
       839
       +
             lazy = '💤 ',

     

       840
       840
       +
           },

     

       841
       841
       +
         },

     

       842
       842
       +
       })

     

       843
       843
       +
       

     

       844
       844
       +
       -- The line beneath this is called `modeline`. See `:help modeline`

     

       845
       845
       +
       -- vim: ts=2 sts=2 sw=2 et

+69

config/nvim/lua/options.lua

···

       1
       1
       +
       -- [[ Setting options ]]

     

       2
       2
       +
       -- See `:help vim.opt`

     

       3
       3
       +
       -- NOTE: You can change these options as you wish!

     

       4
       4
       +
       --  For more options, you can see `:help option-list`

     

       5
       5
       +
       

     

       6
       6
       +
       -- Make line numbers default

     

       7
       7
       +
       vim.opt.number = true

     

       8
       8
       +
       -- You can also add relative line numbers, to help with jumping.

     

       9
       9
       +
       --  Experiment for yourself to see if you like it!

     

       10
       10
       +
       -- vim.opt.relativenumber = true

     

       11
       11
       +
       

     

       12
       12
       +
       -- Enable mouse mode, can be useful for resizing splits for example!

     

       13
       13
       +
       vim.opt.mouse = 'a'

     

       14
       14
       +
       

     

       15
       15
       +
       -- Don't show the mode, since it's already in the status line

     

       16
       16
       +
       vim.opt.showmode = false

     

       17
       17
       +
       

     

       18
       18
       +
       -- Sync clipboard between OS and Neovim.

     

       19
       19
       +
       --  Schedule the setting after `UiEnter` because it can increase startup-time.

     

       20
       20
       +
       --  Remove this option if you want your OS clipboard to remain independent.

     

       21
       21
       +
       --  See `:help 'clipboard'`

     

       22
       22
       +
       vim.schedule(function()

     

       23
       23
       +
         vim.opt.clipboard = 'unnamedplus'

     

       24
       24
       +
       end)

     

       25
       25
       +
       

     

       26
       26
       +
       -- Enable break indent

     

       27
       27
       +
       vim.opt.breakindent = true

     

       28
       28
       +
       

     

       29
       29
       +
       -- Save undo history

     

       30
       30
       +
       vim.opt.undofile = true

     

       31
       31
       +
       

     

       32
       32
       +
       -- Case-insensitive searching UNLESS \C or one or more capital letters in the search term

     

       33
       33
       +
       vim.opt.ignorecase = true

     

       34
       34
       +
       vim.opt.smartcase = true

     

       35
       35
       +
       

     

       36
       36
       +
       -- Keep signcolumn on by default

     

       37
       37
       +
       vim.opt.signcolumn = 'yes'

     

       38
       38
       +
       

     

       39
       39
       +
       -- Decrease update time

     

       40
       40
       +
       vim.opt.updatetime = 250

     

       41
       41
       +
       

     

       42
       42
       +
       -- Decrease mapped sequence wait time

     

       43
       43
       +
       vim.opt.timeoutlen = 300

     

       44
       44
       +
       

     

       45
       45
       +
       -- Configure how new splits should be opened

     

       46
       46
       +
       vim.opt.splitright = true

     

       47
       47
       +
       vim.opt.splitbelow = true

     

       48
       48
       +
       

     

       49
       49
       +
       -- Sets how neovim will display certain whitespace characters in the editor.

     

       50
       50
       +
       --  See `:help 'list'`

     

       51
       51
       +
       --  and `:help 'listchars'`

     

       52
       52
       +
       vim.opt.list = true

     

       53
       53
       +
       vim.opt.listchars = { tab = '» ', trail = '·', nbsp = '␣' }

     

       54
       54
       +
       

     

       55
       55
       +
       -- Preview substitutions live, as you type!

     

       56
       56
       +
       vim.opt.inccommand = 'split'

     

       57
       57
       +
       

     

       58
       58
       +
       -- Show which line your cursor is on

     

       59
       59
       +
       vim.opt.cursorline = true

     

       60
       60
       +
       

     

       61
       61
       +
       -- Minimal number of screen lines to keep above and below the cursor.

     

       62
       62
       +
       vim.opt.scrolloff = 10

     

       63
       63
       +
       

     

       64
       64
       +
       -- if performing an operation that would fail due to unsaved changes in the buffer (like `:q`),

     

       65
       65
       +
       -- instead raise a dialog asking if you wish to save the current file(s)

     

       66
       66
       +
       -- See `:help 'confirm'`

     

       67
       67
       +
       vim.opt.confirm = true

     

       68
       68
       +
       

     

       69
       69
       +
       -- vim: ts=2 sts=2 sw=2 et

-192

config/nvim/lua/plugins/custom.lua

···

       1
       1
       -
       -- every spec file under the "plugins" directory will be loaded automatically by lazy.nvim

     

       2
       2
       -
       --

     

       3
       3
       -
       -- In your plugin files, you can:

     

       4
       4
       -
       -- * add extra plugins

     

       5
       5
       -
       -- * disable/enabled LazyVim plugins

     

       6
       6
       -
       -- * override the configuration of LazyVim plugins

     

       7
       7
       -
       return {

     

       8
       8
       -
         -- Detect tabstop and shiftwidth automatically

     

       9
       9
       -
         { "tpope/vim-sleuth" },

     

       10
       10
       -
       

     

       11
       11
       -
         -- Gemini file syntax highlights

     

       12
       12
       -
         { "https://tildegit.org/sloum/gemini-vim-syntax" },

     

       13
       13
       -
       

     

       14
       14
       -
         -- nushell syntax highlights

     

       15
       15
       -
         { "elkasztano/nushell-syntax-vim" },

     

       16
       16
       -
       

     

       17
       17
       -
         -- markview

     

       18
       18
       -
         {

     

       19
       19
       -
           "OXY2DEV/markview.nvim",

     

       20
       20
       -
           lazy = false,

     

       21
       21
       -
         },

     

       22
       22
       -
       

     

       23
       23
       -
         -- catppuccin

     

       24
       24
       -
         {

     

       25
       25
       -
           "catppuccin/nvim",

     

       26
       26
       -
           lazy = true,

     

       27
       27
       -
           name = "catppuccin",

     

       28
       28
       -
           opts = {

     

       29
       29
       -
             lsp_styles = {

     

       30
       30
       -
               underlines = {

     

       31
       31
       -
                 errors = { "undercurl" },

     

       32
       32
       -
                 hints = { "undercurl" },

     

       33
       33
       -
                 warnings = { "undercurl" },

     

       34
       34
       -
                 information = { "undercurl" },

     

       35
       35
       -
               },

     

       36
       36
       -
             },

     

       37
       37
       -
             integrations = {

     

       38
       38
       -
               aerial = true,

     

       39
       39
       -
               alpha = true,

     

       40
       40
       -
               cmp = true,

     

       41
       41
       -
               dashboard = true,

     

       42
       42
       -
               flash = true,

     

       43
       43
       -
               fzf = true,

     

       44
       44
       -
               grug_far = true,

     

       45
       45
       -
               gitsigns = true,

     

       46
       46
       -
               headlines = true,

     

       47
       47
       -
               illuminate = true,

     

       48
       48
       -
               indent_blankline = { enabled = true },

     

       49
       49
       -
               leap = true,

     

       50
       50
       -
               lsp_trouble = true,

     

       51
       51
       -
               mason = true,

     

       52
       52
       -
               mini = true,

     

       53
       53
       -
               navic = { enabled = true, custom_bg = "lualine" },

     

       54
       54
       -
               neotest = true,

     

       55
       55
       -
               neotree = true,

     

       56
       56
       -
               noice = true,

     

       57
       57
       -
               notify = true,

     

       58
       58
       -
               snacks = true,

     

       59
       59
       -
               telescope = true,

     

       60
       60
       -
               treesitter_context = true,

     

       61
       61
       -
               which_key = true,

     

       62
       62
       -
             },

     

       63
       63
       -
           },

     

       64
       64
       -
           specs = {

     

       65
       65
       -
             {

     

       66
       66
       -
               "akinsho/bufferline.nvim",

     

       67
       67
       -
               optional = true,

     

       68
       68
       -
               opts = function(_, opts)

     

       69
       69
       -
                 if (vim.g.colors_name or ""):find("catppuccin") then

     

       70
       70
       -
                   opts.highlights = require("catppuccin.special.bufferline").get_theme()

     

       71
       71
       -
                 end

     

       72
       72
       -
               end,

     

       73
       73
       -
             },

     

       74
       74
       -
           },

     

       75
       75
       -
         },

     

       76
       76
       -
       

     

       77
       77
       -
         -- Configure LazyVim to load catppuccin

     

       78
       78
       -
         {

     

       79
       79
       -
           "LazyVim/LazyVim",

     

       80
       80
       -
           opts = {

     

       81
       81
       -
             colorscheme = "catppuccin",

     

       82
       82
       -
           },

     

       83
       83
       -
         },

     

       84
       84
       -
       

     

       85
       85
       -
         -- change trouble config

     

       86
       86
       -
         {

     

       87
       87
       -
           "folke/trouble.nvim",

     

       88
       88
       -
           -- opts will be merged with the parent spec

     

       89
       89
       -
           opts = { use_diagnostic_signs = true },

     

       90
       90
       -
         },

     

       91
       91
       -
       

     

       92
       92
       -
         -- customize noice.nvim

     

       93
       93
       -
         {

     

       94
       94
       -
           "folke/noice.nvim",

     

       95
       95
       -
           require("noice").setup({

     

       96
       96
       -
             views = {

     

       97
       97
       -
               cmdline_popup = {

     

       98
       98
       -
                 position = {

     

       99
       99
       -
                   row = "50%",

     

       100
       100
       -
                   col = "50%",

     

       101
       101
       -
                 },

     

       102
       102
       -
               },

     

       103
       103
       -
             },

     

       104
       104
       -
           }),

     

       105
       105
       -
         },

     

       106
       106
       -
       

     

       107
       107
       -
         -- change some telescope options and a keymap to browse plugin files

     

       108
       108
       -
         {

     

       109
       109
       -
           "nvim-telescope/telescope.nvim",

     

       110
       110
       -
           keys = {

     

       111
       111
       -
             -- add a keymap to browse plugin files

     

       112
       112
       -
             -- stylua: ignore

     

       113
       113
       -
             {

     

       114
       114
       -
               "<leader>fp",

     

       115
       115
       -
               function() require("telescope.builtin").find_files({ cwd = require("lazy.core.config").options.root }) end,

     

       116
       116
       -
               desc = "Find Plugin File",

     

       117
       117
       -
             },

     

       118
       118
       -
           },

     

       119
       119
       -
           -- change some options

     

       120
       120
       -
           opts = {

     

       121
       121
       -
             defaults = {

     

       122
       122
       -
               layout_strategy = "horizontal",

     

       123
       123
       -
               layout_config = { prompt_position = "top" },

     

       124
       124
       -
               sorting_strategy = "ascending",

     

       125
       125
       -
               winblend = 0,

     

       126
       126
       -
             },

     

       127
       127
       -
           },

     

       128
       128
       -
         },

     

       129
       129
       -
       

     

       130
       130
       -
         -- setup lspconfigs

     

       131
       131
       -
         {

     

       132
       132
       -
           "neovim/nvim-lspconfig",

     

       133
       133
       -
           ---@class PluginLspOpts

     

       134
       134
       -
           opts = {

     

       135
       135
       -
             ---@type lspconfig.options

     

       136
       136
       -
             servers = {

     

       137
       137
       -
               ansiblels = {},

     

       138
       138
       -
               awk_ls = {},

     

       139
       139
       -
               bashls = {},

     

       140
       140
       -
               css_variables = {},

     

       141
       141
       -
               cssls = {},

     

       142
       142
       -
               cssmodules_ls = {},

     

       143
       143
       -
               docker_compose_language_service = {},

     

       144
       144
       -
               dockerls = {},

     

       145
       145
       -
               html = {},

     

       146
       146
       -
               jsonls = {},

     

       147
       147
       -
               pyright = {},

     

       148
       148
       -
               marksman = {},

     

       149
       149
       -
               nushell = {},

     

       150
       150
       -
               yamlls = {},

     

       151
       151
       -
             },

     

       152
       152
       -
           },

     

       153
       153
       -
         },

     

       154
       154
       -
       

     

       155
       155
       -
         -- add more treesitter parsers

     

       156
       156
       -
         {

     

       157
       157
       -
           "nvim-treesitter/nvim-treesitter",

     

       158
       158
       -
           opts = function(_, opts)

     

       159
       159
       -
             vim.list_extend(opts.ensure_installed, {

     

       160
       160
       -
               "bash",

     

       161
       161
       -
               "html",

     

       162
       162
       -
               "json",

     

       163
       163
       -
               "lua",

     

       164
       164
       -
               "markdown",

     

       165
       165
       -
               "markdown_inline",

     

       166
       166
       -
               "nu",

     

       167
       167
       -
               "python",

     

       168
       168
       -
               "regex",

     

       169
       169
       -
               "vim",

     

       170
       170
       -
               "yaml",

     

       171
       171
       -
             })

     

       172
       172
       -
           end,

     

       173
       173
       -
         },

     

       174
       174
       -
       

     

       175
       175
       -
         -- add any tools you want to have installed below

     

       176
       176
       -
         {

     

       177
       177
       -
           "mason-org/mason.nvim",

     

       178
       178
       -
           opts = {

     

       179
       179
       -
             ensure_installed = {

     

       180
       180
       -
               "ansible-lint",

     

       181
       181
       -
               "black",

     

       182
       182
       -
               "isort",

     

       183
       183
       -
               "jq",

     

       184
       184
       -
               "markdownlint-cli2",

     

       185
       185
       -
               "shellcheck",

     

       186
       186
       -
               "shfmt",

     

       187
       187
       -
               "stylua",

     

       188
       188
       -
               "yamlfmt",

     

       189
       189
       -
             },

     

       190
       190
       -
           },

     

       191
       191
       -
         },

     

       192
       192
       -
       }

-3

config/nvim/stylua.toml

···

       1
       1
       -
       indent_type = "Spaces"

     

       2
       2
       -
       indent_width = 2

     

       3
       3
       -
       column_width = 120