Title: About Language Server Protocol and Kakoune text editor
       Author: Solène
       Date: 24 November 2020
       Tags: kakoune editor openbsd
       Description: 
       
       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.
       
 (HTM) Language Server Protocol on Wikipedia
       
       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.
       
       
       ## Pre-requisites
       
       We need _kak-lsp_ which requires rust and cargo. We will need git too
       to fetch the sources, and obviously kakoune.
       
       ```shell command
       # pkg_add kakoune rust git
       ```
       
       ## Building
       
 (HTM) Official building steps documentation
       
       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.
       
       ```shell command
       $ git clone https://github.com/kak-lsp/kak-lsp
       $ cd kak-lsp
       $ cargo install --locked --force --path .
       ```
       
       ## Configuration
       
       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.
       
       ```shell command
       $ 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.
       
       ```Configuration file sample
       [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
       
       ```Configuration file sample
       eval %sh{/usr/local/bin/kak-lsp --kakoune -s $kak_session}
       hook global WinSetOption filetype=(rust|python|go|javascript|typescript|c|cpp) %{
               lsp-enable-window
       }
       ```
       
       Note that I used the full path of kak-lsp binary in the configuration
       file, this is due to a rust issue on OpenBSD.
 (HTM) Link to Rust issue on github
       
       ## 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):
       
       ```shell command
       $ 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.
       
       ## Using kak-lsp
       
       Now that it is installed and working, you may want to read the
       documentation.
 (HTM) kak-lsp usage
       
       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.
       
       
       ## Debugging
       
       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.
 (HTM) Official troubleshooting guide