This is a simple kakoune cheat sheet to help me (and readers) remember some very useful features.
To see kakoune in action.
Commands (in command mode)
Select from START to END position.
Use `Z` to mark start and `alt+z i` to select unti current position.
Add a vertical cursor (useful to mimic rectangle operation)
Type `C` to add a new cursor below your current cursor.
Clear all cursors
Type `space` to remove all cursors except one.
Pasting text verbatim (without completion/indentation)
You have to use "disable hook" command before inserting text. This is done with `\i` with `\` disabling hooks.
Split selection into cursors
When you make a selection, you can use `s` and type a pattern, this will create a new cursor at the start of every pattern match.
This is useful to make replacements for words or characters.
A pattern can be a word, a letter, or even `^` to tell the beginning of each line.
In kakoune there are often multiples way to do operations.
Select multiples lines
Go to first line, press `J` to create cursors below and press `X` to select whole lines of every cursors.
Using start / end markers
Press `Z` on first line, and `alt+z i` on last line and then press `X` to select whole lines of every lines.
Press `X` until you reach the last line.
Replace characters or words
Make a selection and type `|`, you are then asked for a shell command, you have to use `sed`.
Sed can be used, but you can also select the lines and split the selection to make a new cursor before each word and replace the content by typing it, using the `s` command.
For my blog I format paragraphs so lines are not longer than 80 characters. This can be done by selecting lines and run `fmt` using a pipe command. You can use other software if fmt doesn't please you.
In this article I will explain how to install a lsp plugin for kakoune to add language specific features such as autocompletion, syntax error reporting, easier navigation to definitions and more.
The principle is to use "Language Server Protocol" (LSP) to communicate between the editor and a daemon specific to a programming language. This can be also done with emacs, vim and neovim using the according plugins.
For python, _pyls_ would be used while for C or C++ it would be _clangd_.
The how-to will use OpenBSD as a base. The package names may certainly vary for other systems.
We need _kak-lsp_ which requires rust and cargo. We will need git too to fetch the sources, and obviously kakoune.
# pkg_add kakoune rust git
I recommend using a dedicated build user when building programs from sources, without a real audit you can't know what happens exactly in the build process. Mistakes could be done and do nasty things with your data.
$ git clone https://github.com/kak-lsp/kak-lsp $ cd kak-lsp $ cargo install --locked --force --path .
There are a few steps. kak-lsp has its own configuration file but the default one is good enough and kakoune must be configured to run the kak-lsp program when needed.
Take care about the second command if you built from another user, you have to fix the path.
$ mkdir -p ~/.config/kak-lsp $ cp kak-lsp.toml ~/.config/kak-lsp/
This configuration file tells what program must be used depending of the programming language required.
[language.python] filetypes = ["python"] roots = ["requirements.txt", "setup.py", ".git", ".hg"] command = "pyls" offset_encoding = "utf-8"
Taking the configuration block for python, we can see the command used is _pyls_.
For kakoune configuration, we need a simple configuration in ~/.config/kak/kakrc
Note that I used the full path of kak-lsp binary in the configuration file, this is due to a rust issue on OpenBSD.
Trying with python
To support python programs you need to install python-language-server which is available in pip. There are no package for it on OpenBSD. If you install the program with pip, take care to have the binary in your $PATH (either by extending $PATH to ~/.local/bin/ or by copying the binary in /usr/local/bin/ or whatever suits you).
The pip command would be the following (your pip binary name may change):
$ pip3.8 install --user 'python-language-server[all]'
Then, opening python source file should activate the analyzer automatically. If you add a mistake, you should see `!` or `*` in the most left column.
Trying with C
To support C programs, clangd binary is required. On OpenBSD it is provided by the clang-tools-extra package. If clangd is in your $PATH then you should have working support.
Now that it is installed and working, you may want to read the documentation.
I didn't look deep for now, the autocompletion automatically but may be slow in some situation.
Default keybindings for "gr" and "gd" are made respectively for "jump to reference" and "jump to definition".
Typing "diag" in the command prompt runs "lsp-diagnostics" which will open a new buffer explaining where errors are warnings are located in your source file. This is very useful to fix errors before compiling or running the program.
The official documentation explains well how you can check what is wrong with the setup. It consists into starting kak-lsp in a terminal and kakoune separately and check kak-lsp output. This helped me a lot.