cybermango / init.vimango Goto Github PK

Probably by using nvm-cmp

Move all core configurations to Lua, including:

• LSP configurations using builtin lua api.
• Move vimscript/python/javascript plugins to lua alternatives when it makes sense.
• keymaps, settings, helper functions.

Choose a form of tag files - catgs/cscope/gnu tags/global tags/universal ctags and integrate it into your vim setup.

Tags are useful for nearly all languages, and can be used for languages i dont have an lsp for, or for cross-language projects. They are also useful for symbol-based navigation, jumping to symbols from comments and docs, and in general are a complementary feature for an lsp.

Integrate running python inside of vim:

• run an interpreter split window (preferabely ipython) (easy).
• Run whole project and see output while still in vim. utilize :make and set makeprg ?
• Run parts of the code. maybe with a plugin like atom's hydrogen.

it could be used to configure some extra functionalities about packer.

Its a builtin tool that makes the editor understand the content of your code. could be used for error corrections, syntax highlighting and more.

Find a good way to integrate cpp compilation.
might use the :make command.

Even if it uses an external cmake/make command, it should link from the error messages into the relevant lines of code in vim (perhaps use the quickfix list).

Might be useful to look for something inspired by cxxd's project build feature.

Add easy configs for using multiple clipboards, not just the basic vim and system ones.

Its a tool for fuzzy finding which uses neovim core instead of external tools.

Add auto doxygen doc functionality.
There are many old plugins for this.

Add git integration inside of nvim:

• Files tree marks changed files.
• Easy files diff view.
• Easy file adding/staging.
• Nice commits tree view.
• Thin wrappers for git commands?
• Git blame for code lines.

Keywords to look at:

• fugitive.
• gitgutter.
• vim-signify.
• lazygit.

Integrate debugging into vim, like in an IDE.
Mainly for cpp and python.

temporary solution: :Termdebug command. uses gdb inside of vim, but only supports the basics, and its nearly like using plain gdb, just with the output in a different window and the code shown in a vim window.

might use:

• some coc extension: maybe a port from vscode.
• vimspector: mainly supports cpp and python.
  • Made for self usage so not very mature and not a hell lot of support.
  • Still isnt supporting neovim (but will soon).
  • Doesnt fully support windows - (cant use at work).
  • I might need to contribute to make this work for me. Its python code.
• :Termdebug + .gdbinit: if nothing else works, for cpp debugging i might just twick gdb a little bit with a .gdbinit (like gdb-dashboard) and use :Termdebug to watch everything in vim.
• termdbg: a minimal debugger plugin for python (also for go and cpp but without gdb).

Decide what bracket auto closing plugin do you use.

From what i have seen, those options seem to be the best:

• autopairs: Works, mature, configurable. currently installed.
  • cons: vimscript, so not very fast.
  • Result: has many small bugs, annoying so and its better without it.
• lexima: seems to work, mature, supports dot operator. currently installed.
  • cons: vimscript, so not very fast.
  • Result: works well enough, but 1)Requires a hack so that closing pair is only inserted b4 whitespace. 2)Wont remove auto created closing bracket when its typed after an expansion.
• vim-gimini: works, much shorter so probably more lightweight then the others.
  • cons: no serious developement, was made just for fun.
  • Result: Works but 1)bug-wont expand after <CR>. 2)like lexima (2).
• pear-tree: New and is still being developed.
  • Result: works but 1)dot feature is broken with nested brackets. 2)like lexima (2).

vim-airline is currently used for prettier statusline and tabline.
Even though it is easy to use and works well, it slows nvim startup. Find a better plugin for this

Options:

• lightline: supposed to be a lighter airline.
• lualine - became a standard nvim choice.

Add features for managing projects in vim:

• Open a project workspace, with project dir being cwd.
• Create new projects with a certain template and pre-made files, like .ccls files for cpp.
• Browse existing projects.

Might use:

• :mksession and vim -S .
• vim-session plugin.
• some project manager plugin.
• Some plugin I'll make?

Add linting functionality into vim, and then add linters for python and cpp.

might use:

• ale: can be integrated with coc.
• some coc extension.

Defx is the current file tree plugin. It works fine after heavy configurations, but it still aint perfect.
Remaining issues:

• tabedit from inside of defx opens the file in the defx buffer window.
• cant recursivley open already openend dirs.
• no easy way to open a dir like in an explorer.
• file open might move to different tab if file is opened there (due to drop's behavior).
• In general, requires programming too much by myself due to missing features.

should be replaced with a better plugin.
Options:

• tree.nvim: supposed to be fast. might be buggy due to it being in cpp. Not yet finished.
• coc-explorer: looks good. Uses coc which is already installed. Not yet finished.

Python intellisense had been briefly set up. Improve it!

• integrate the pyls doc linters and style linters, and in general all of the main pyls plugins.
• add the right path to the path variable so that site-packages are included in it.
• Add the necessary steps to set it up (basically pip install lots of shit) to setup.txt.

should make some startup faster. might be useful someday.