Just like writing and qutebrowser modules, restructured the version
control software module to make more use of dotter's ability to
precisely link files. All contained programs have a top-level directory
and all the files that correspond to that specific software lie beneath
in the directory tree.
Removed the left-over bib-due scripts. They were neat and fun when I
wrote them but they are not useful for me anymore. Additionally they are
very brittle and I do not want to deal with fixing or updating them.
Similarly to the qutebrowser module we change the layout to have a
program name at the top-level and all required files for that specific
program within, whether they reside within .config, .local or anywhere
else.
We use dotter mappings to achieve this.
I have not used pubs (the reference management software) for year(s) now
and there is little chance I will in the near future. This removes the
leftover configuration.
When using filtile layout it also gives the option of using 'monocle'
mode which is similar to fullscreen in that it only shows one window at
a time (which also occupies the full screen, except for the statusbar)
but you can cycle between the windows shown as you would usually between
the different views in a tag. You can imagine the windows 'stacked' on
top of each other and cycling which one is on top or on the bottom.
Toggled with `Mod+Shift+F`, shifting up from fullscreen mode.
TODO: Ideally, it would be accompanied by an indicator in the statusbar
but I have no time to create one currently. Without one, it is sometimes
hard to remember that other windows exist on the tag after a while.
Simplify the system of mappings in floating:
- HJKL for moving a floating window around.
- C-HJKL for quickly snapping to screen edges (as before)
- Mod-HJKL for resizing the floating window.
- Mod-Shift-HJKL for changing the tag's setting:
- HL to change size ratio of main/side pane
- JK to change amount of windows in main pane
`super+F11` enters passthrough mode (displayed on waybar) which disables
all normal keybinds that river listens to and - surprise - passes them
through to whatever application is running. The same binding exits the
mode.
`mcd` will, similarly to `md` create a directory and all the necessary
top-level directories but, unlike `md`, afterwards also enter the
created directory for the current shell.
Extract lualine into its own 'statusline.lua' plugin file. This makes
the ui plugin file a little more lean but also prepares the way of
tinkering with statusline alternatives, like heirline.
Since sometimes it is necessary to have correct access to the files
functionality earlier than was possible with the old lazy loading this
instead loads it at program start as well.
Check that the trouble plugin exists before adding its maps to the
telescope buffer. Should probably go into trouble setup instead but
works as a quick safeguard for now.
Remove `<localleader>s` 'set' group of mappings (setting buffer wrapping
mode, setting colorizing) and replace it with explicit on/off mappings
via [o<setting> and ]o<setting>.
Wrapping can be set to soft with `[ow`, hard with `]ow`.
Colorizer can be disabled with `[oc`, enabled with `]oc`.
Colorizer can highlight virtual text with `[oC`, highlight background
with `]oC`.
This should make it hopefully still clear that they are expected plugins
for the configuration while also delineating it from the 'core' module
which bootstraps lazy and sets fundamental options and so on.
Before we load the lazy spec from the 'lua/plugins' directory, we check
that the directory exists and contains at least one .lua file. We do not
check that the file returns a valid spec but that is just assumed in
this case.
Begin a larger refactor with nvim-cmp, which separates out the different
nvim-cmp modules to be loaded at different times and for different files
(such as beancount completion on loaded for beancount files and so on).
This is by no means complete but the start of a larger overhaul process.
Except for mini.starter which we need right at the - well - start, we
can lazy load most other modules. It's a little awkward since we lazy
load them *within* the setup function with a manual autocommand but it
should work fine for the time being.
This is something I used to use quite a bit in tmux. I have a feeling I
will not be making extensive use of it in wezterm, but can always remove
it if I reach the point of forgetting the mapping later.
Added mapping `<leader><c-q>` to select a pane which will be moved out
to a new tab.
Slightly changed pane switching on `<leader><s-q>` to keep focus on the
pane instead of switching to the other pane.
Finally, added two simple relative tab movement maps to cycle forward
with `<leader>.` and reverse with `<leader>,`. This replaces the old tab
movement (moving the actual tab around) left and right which are now on
`<leader><s-,>` and `<ledaer><s-.>` respectively.
Since they are all used for file picking (among editing and creating)
I'll just have them run under pickers for now. If the name turns out to
be confusing or not descriptive anymore I can still change it at any
time.
Remove redundant conceallevel fix (not required for quarto files
anymore), add additional filetype injections and do not highlight
codeblocks as much (no sign colum entry, bg not over whole doc width).
Changed maps to increment on <C-S> (instead of the usual <C-A>) and
decrement on the typical <C-X>. This makes it work much better with
wezterm leader key (<C-A>) and as far as I can see does not directly
clash with any other binds.
Since we use Mason to automatically install any formatter we need, there
is (currently) no need for the more complicated logic of deciding
between multiple formatters (since the one we prefer should always be
available). This also fixes an issue that we can set 'prettier' specific
options in conform.nvim but those do not apply to 'prettierd' the same
way - we now just use prettier and ignore prettierd.
Instead of doing all kinds of security checks beforehand, we simply wrap
the molten kernel check into a lua protected call and return an empty
result if we would error. We only return the symbol if we don't error
and we have an active kernel.
