* mvp of strider fuzzy find
* improve search ui
* various refactoringz
* moar refactoring
* even more refactoring
* tests and more refactoring
* refactor: remove unused stuff
* style(fmt): rustfmt
* debug ci
* debug ci
* correct path for plugin system tests
* fix plugin system ci tests
* remove debugging statements from test
* fix plugin worker persistence
* add test for plugin worker persistence
* style(fmt): rustfmt
* final cleanups
* remove outdated comments
* rust: Update toolchain version to 1.67
* xtask/pipeline/publish: Drop manual "wait"
for crates.io to catch up, which is obsolete with rust 1.66 and up.
Cargo does that on its own now. See
https://github.com/rust-lang/cargo/pull/11062
* xtask: Add function to obtain asset_dir
instead of assembling it on demand throughout the codebase.
* xtask/run: Add '--quick-run' flag
as a convenient shorthand for `cargo xtask run --data-dir
$PROJECT_ROOT/zellij-utils/assets`.
* cargo: Add 'q' command alias
as a shorthand for 'cargo xtask run --quick-run'
* cargo: Update thiserror to 1.0.40
* cargo: Update anyhow to 1.0.70
and specify dependency only once inside `zellij-utils`, not inside the
zellij root crate.
* cargo: Update names to 0.14.0
* cargo: Update miette to 5.7.0
and re-export the dependency from zellij-utils, to avoid duplicate
(incompatible) includes from inside zellij-utils and the root crate.
* cargo: Update dialoguer to 0.10.4
* fix formatting
* changelog: Add PR #2375
* feat(layout): Support environment variables in cwd (#2288)
* add `shellexpand` as dependency
* expand environment variable in kdl parser's `parse_cwd()`
* Fix and enhance environment variable expansion.
* Return a proper `ConfigError` on failures.
* Replace raw cwd parsing with `parse_cwd()`.
* Add tests that verify correct expansions.
* Perform env var expansion in more contexts.
* feat(layout): Rewrite env var tests as snapshots.
* Update layout env var expansion test snapshot.
* working-ish minus a few race conditions
* relax atomicity
* various refactoringz
* remove commented out code
* clarify some stuffs
* refactor(plugins): move PluginMap and friends to a different file
* refactor(plugins): move zellij_exports and friends to a different file
* style(fmt): rustfmt
* fix(e2e): adjust tests for flakiness async loading
When a client connects to the zellij server, a Unix socket is created.
However, a bug in version 1.1.1 and earlier of the interprocess crate
used for interprocess communication (IPC) prevented the socket from
being properly disposed of after use, which generated a descriptor
leak.
The bug was fixed in version 1.2.0 of the interprocess crate.
* Add unit test for plugin run location parsing
* Fix file plugin parsing for relative paths
* Update test to check for path with spaces
* Add a couple more tests
* Add new feature flags
* Use singlepass in debug mode
* Use Cow to avoid unnecessary copies
- Instead of removing and reinserting into the memory cache, use Cow to
model both owned an borrowed data
- Log at debug-level the time to compile/load a wasm module
- A little clippy drive-by on touched files
* Satisfy the assumption from zellij-utils/src/consts.rs for target-dir
* Allow forcing cranlift in debug mode
* Remove deprecated comments
* PR comment: typo
* Remove extras
* xtask: Implement a new build system
xtask is a cargo alias that is used to extend the cargo build system
with custom commands. For an introduction to xtask, see here:
https://github.com/matklad/cargo-xtask/
The idea is that instead of writing makefiles, xtask requires no
additional dependencies except `cargo` and `rustc`, which must be
available to build the project anyway.
This commit provides a basic implementation of the `build` and `test`
subcommands.
* xtask/deps: Add 'which'
* xtask/test: Handle error when cargo not found
* xtask/flags: Add more commands
to perform different useful tasks. Includes:
- clippy
- format
- "make" (composite)
- "install" (composite)
Also add more options to `build` to selectively compile plugins or leave
them out entirely.
* xtask/main: Return error when cargo not found
* xtask/build: Add more subtasks
- `wasm_opt_plugins` and
- `manpage`
that perform other build commands. Add thorough documentation on what
each of these does and also handle the new `build` cli flags
appropriately.
* xtask/clippy: Add job to run clippy
* xtask/format: Add job to run rustfmt
* xtask/pipeline: Add composite commands
that perform multiple atomic xtask commands sequentially in a pipeline
sort of fashion.
* xtask/deps: Pin dependencies
* xtask/main: Integrate new jobs
and add documentation.
* xtask: Implement 'dist'
which performs an 'install' and copies the resulting zellij binary along
with some other assets to a `target/dist` folder.
* cargo: Update xflags version
* xtask: Measure task time, update tty title
* xtask: Update various tasks
* xtask: wasm-opt plugins in release builds
automatically.
* xtask/build: Copy debug plugins to assets folder
* xtask: Add 'run' subcommand
* xtask: Add arbitrary args to test and run
* xtask: Rearrange CLI commands in help
* xtask: Add deprecation notice
* docs: Replace `cargo make` with `xtask`
* github: Use `xtask` in workflows.
* xtask: Add support for CI commands
* xtask: Streamline error handling
* github: Use new xtask commands in CI
* xtask: Add 'publish' job
* xtask/publish: Add retry when publish fails
* xtask: Apply rustfmt
* xtask: Refine 'make' deprecation warning
* xtask: add task to build manpage
* contributing: Fix e2e commands
* xtask/run: Add missing `--`
to pass all arguments following `xtask run` directly to the zellij
binary being run.
* xtask: Stay in invocation dir
and make all tasks that need it change to the project root dir
themselves.
* xtask/run: Add `--data-dir` flag
which will allow very quick iterations when not changing the plugins
between builds.
* xtask/ci: Install dependencies without asking
* utils: Allow including plugins from target folder
* utils/assets: Reduce asset map complexity
* utils/consts: Update asset map docs
* xtask: Fix plugin includes
* xtask/test: Build plugins first
because the zellij binary needs to include the plugins.
* xtask/test: Fix formatting
* xtask: Add notice on how to disable it
* server/tab: Don't panic in `Pane::render`
and do not crash the application on failure to receive a render update
from plugins any longer. Instead, will print a simple string with a hint
to check the application logs, where a more thorough error indication
can be found.
* utils/errors: re-export `anyhow::Error`
to create ad-hoc errors with custom error types, without having to wrap
them into a `context()` before to turn the into anyhow errors.
* plugins: Check plugin version on startup
and terminate execution with a descriptive error message in case the
plugin version is incompatible with the version of zellij being run.
* server/wasm_vm: Add plugin path in version error
so the user knows which plugin to look at in case they're using custom
plugins.
* server/wasm_vm: Check plugin version for equality
Previously we would accept cases where the plugin version was newer than
the zellij version, which doesn't make a lot of sense.
* server/wasm_vm: Prettier error handling
in call to `wasmer::Function::call` in case a plugin version mismatch
can occur.
* tile: Install custom panic handler
that will print the panic message to a plugins stdout and then call a
panic handler on the host that turns it into a real application-level
panic.
* tile: Catch errors in event deserialization
and turn them into proper panics. These errors are symptomatic of an
uncaught plugin version mismatch, for example when developing from main
and compiling zellij/the plugins from source. Normal users should never
get to see this error.
* utils/errors: Improve output in `to_stdout`
for anyhow errors. The default anyhow error formatting of `{:?}` is
already very good, and we just made it worse by trying to invent our own
formatting.
* tile: Reword plugin mismatch error message
* zellij: Apply rustfmt
* changelog: Add PR #1838
Improve error handling on plugin version mismatch.
* server/wasm_vm: Rephrase error in passive voice
* utils/errors: Add `ToAnyhow` trait
for converting `Result` types that don't satisfy `anyhow`s trait
constraints (`Display + Send + Sync + 'static`) conveniently.
An example of such a Result is the `SendError` returned from
`send_to_plugins`, which sends `PluginInstruction`s as message type.
One of the enum variants can contain a `mpsc::Sender`, which is `!Sync`
and hence makes the whole `SendError` be `!Sync` in this case. Add an
implementation for this case that takes the message and converts it into
an error containing the message formatted as string, with the additional
`ErrorContext` as anyhow context.
* server/tab: Remove calls to `unwrap()`
and apply error reporting via `anyhow` instead. Make all relevant
functions return `Result`s where previously a panic could occur and
attach error context.
* server/screen: Modify `update_tab!`
to accept an optional 4th parameter, a literal "?". If present, this
will append a `?` to the given closure verbatim to handle/propagate
errors from within the generated macro code.
* server/screen: Handle new `Result`s from `Tab`
and apply appropriate error context and propagate errors further up.
* server/tab/unit: `unwrap` on new `Result`s
* server/unit: Unwrap `Results` in screen tests
* server/tab: Better message for ad-hoc errors
created with `anyhow!`. Since these errors don't have an underlying
cause, we describe the cause in the macro instead and then attach the
error context as usual before `?`ing the error back up.
* utils/cargo: Activate `anyhow`s "backtrace" feature
to capture error backtraces at the error origins (i.e. where we first
receive an error and convert it to a `anyhow::Error`). Since we
propagate error back up the call stack now, the place where we `unwrap`
on errors doesn't match the place where the error originated. Hence, the
callstack, too, is quite misleading since it contains barely any
references of the functions that triggered the error.
As a consequence, we have 2 backtraces now when zellij crashes: One from
`anyhow` (that is implicitly attached to anyhows error reports), and one
from the custom panic handler (which is displayed through `miette`).
* utils/errors: Separate stack traces
in the output of miette. Since we record backtraces with `anyhow` now,
we end up having two backtraces in the output: One from the `anyhow`
error and one from the actual call to `panic`. Adds a comment explaining
the situation and another "section" to the error output of miette: We
print the backtrace from anyhow as "Stack backtrace", and the output
from the panic handler as "Panic backtrace". We keep both for the
(hopefully unlikely) case that the anyhow backtrace isn't existent, so
we still have at least something to work with.
* server/screen: Remove calls to `fatal`
and leave the `panic`ing to the calling function instead.
* server/screen: Remove needless macro
which extended `active_tab!` by passing the client IDs to the closure.
However, this isn't necessary because closures capture their environment
already, and the client_id needn't be mutable.
* server/screen: Handle unused result
* server/screen: Reintroduce arcane macro
that defaults to some default client_id if it isn't valid (e.g. when the
ScreenInstruction is sent via CLI).
* server/tab/unit: Unwrap new results
* update vte to v0.11.0, and turn off it's default-features
* vte's default includes no_std, and in that case the osc params buffer is capped at 1024 bytes
* add changelog entry
* status-bar: first_line: Use more generic var names
Rename all `CtrlKey...` to the equivalent `Key...` to make the name less
specific. It implies that all key bindings use Ctrl as modifier key,
which needn't necessarily be the case.
* status-bar: first_line: Refactor `ctrl_keys`
Removes lots of code duplication by `Unselect`ing all keys by default
and only `Select`ing what is actually required for a given Input mode.
* utils: conditionally compile unix-specific code
In `zellij_utils`, the following modules each contained code that was
previously targeting only the unix platform:
- consts: Works with unix-specific filesystem attributes to set e.g.
special file permissions. Also relies on having a UID.
- shared: Uses unix-specific filesystem attributes to set file
permissions
These will never work when targeting wasm. Hence the concerning code
passages have been moved into private submodules that are only compiled
and re-exported when the target isn't `#[cfg(unix)]`. The re-export
makes sure that crates from the outside that use `zellij_utils` work as
before, since from their point of view nothing has changed.
* utils: Share more modules with wasm
that work on both wasm and unix natively. This requires factoring out
bits of code in the `setup` and `input` modules into a private submodule
that is re-exported when the compilation target is *not* "wasm". The
following modules are now available to the wasm target:
- cli
- consts
- data
- envs
- input (partial)
- actions
- command
- configs
- keybinds
- layout
- options
- plugins
- theme
- pane_size
- position
- setup (partial)
- shared
The remaining modules unavailable to wasm have dependencies on crates
that cannot compile against wasm, such as `async_std` or `termwiz`.
* utils/input/keybinds_test: Fix import
of the `CharOrArrow` struct which is now part of the `data` submodule.
* utils/layout: Use global serde crate
Previously the code was decorated with `#[serde(crate = "self::serde")]`
statements which cannot be shared with wasm. Use the regular serde
without specifying which serde is meant.
* utils/data: Implement `fmt::Display` for `Key`
so the Keybindings can be displayed via `format!` and friends in e.g.
the status bar.
* tile/prelude: Re-export `actions`
submodule of `zellij_utils` so the plugins can access the `ModeKeybinds`
struct with all of its members.
* utils/data: Fix `ModeInfo::keybinds` type
and transfer a vector of `(Key, Vec<Action>)` to the plugins so they can
parse it themselves, instead of passing strings around. Due to the
requirement of the `Eq` trait derive on `ModeInfo` this requires
deriving `Eq` on all the types included by `Key` and `Action` as well.
Note that `Action` includes the `layout::SplitSize` structure as a
member. We cannot derive `Eq` here since `SplitSize::Percent(f64)`
cannot satisfy `Eq` because `f64` doesn't implement this. So we add a
new type to hack around this limitation by storing the percentage as
`u64` internally, scaled by a factor of 10 000 and transforming it to
f64 when needed. Refer to the documentation of `layout::Percent` for
further information.
* utils/data: Make `Key` sortable
so the keybindings can be sorted after their keys.
* WIP: utils/input: Make keybinds accessible
when generating `ModeInfo` structs.
* utils/data: Handle unprintable chars in `Key`
when displaying via the `fmt::Display` trait. Handles `\t` and `\n` and
represents them as UTF-8 arrow glyphs.
* HACK: utils/layout: Use u64 for SplitSize::Percent
The previous workaround using a custom `Percent` type fails at the
absolute latest when confronted with user layouts, since these do not
know about the scaling factor and will thus break. It still breaks
currently because `Percent` now expects a u64 (i.e. `50`, not `50.0`)
but this is more easily explained and understood.
* status-bar: Add helper macros
that retrieve the key bound to execute a sequence of `Action` given a
specific Keybinding, and a shorthand that expands to
`Action::SwitchToMode(InputMode::Normal)` used for pattern matching with
the `matches!` macro.
* status-bar/first_line: Get shared superkey if any
from the `ModeKeybindings` in the current `ModeInfo` struct. If the
configured keybindings for switching the modes don't have a superkey in
common, do not print a common prefix.
* status-bar/first_line: Add key to KeyShortcut
which is the key that must be pressed in the current mode to execute the
given shortcut (i.e. switch to the given mode).
* status-bar/first_line: Dynamically set mode binds
Read the keybindings for switching the modes to print in the first line
from the actually configured keybindings for the current mode. Add some
logic to the code that:
- Prints only the "single letter" of the keybinding if all mode-switch
shortcuts *share the same modifier key*,
- Or prints the whole keybinding (with modified) into each segment if
there is no common modifier key.
* status-bar/second_line: Display configured binds
Instead of showing some hard-coded default values. For each mode, reads
the keybindings from the configured keybindings based on some sequence
of action. For example, the keybinding for `New` in the `Pane` menu is
now determined by looking into the configured keybindings and finding
what key is bound to the `Action::NewPane(None)` action.
If no keybinding is found for a given sequence of actions, it will not
show up in the segments either.
* WIP: utils/keybinds: Make key order deterministic
by using a BTreeMap which by default has all of its elements in sorted
order internally. As of currently this doesn't seem to impress the order
in which the keybindings are sent to the plugins, though.
* utils/data: Reorder `Key` variants
to have the Arrow keys sorted as "left", "down", "up", "right" in
accordance with the display in e.g. the status bar.
* status-bar/first_line: Fix inverted `matches!`
when trying to obtain the keybindings to switch between the input modes.
Its initial purpose was to filter out all ' ', '\n' and 'Esc'
keybindings for switching modes (As these are the default and not of
interest for the status bar display), but it was not negated and thus
only filtered out the aforementioned keys.
* status-bar: Don't get all modeswitch keybinds
but only those that are displayed in the status bar. This currently
excludes the keybindings for Entering the Pane/TabRename mode, Tmux mode
and Prompt mode. We must explicitly exclude these since they aren't
bound to the same Modifiers as the regular keys. Thus, if we e.g. enter
Pane or Tab mode, it will pick up the
`SwitchToMode(InputMode::TabRename)` action as being bound to `c`, hence
the `superkey` function cannot find a common modifier, etc. But we don't
display the `TabRename` input mode in the first line anyway, so we must
ignore it.
Therefore, we additionally add the keybinding to call the `Action::Quit`
action to terminate zellij to the vector we return. Also remove the
`(Key, InputMode)` tuple and convert the return type to a plain
`Vec<Key>`, since the never worked with the `InputMode` in the first
place.
* status-bar/first_line: Fix output for tight screen
Implement the "Squeezed" display variant where we do not display which
of the modes each keybinding switches to, but only the keybinding
itself.
* status-bar/second_line: Remove trailing " / "
* status-bar/second-line: Refactor key hints
Instead of determining the appropriate key hints for every case
separately (i.e. enough space to show all, show shortened, shot
best-effort), create a central function that returns for the current
`InputMode` a Vector with tuples of:
- A String to show in full-length mode
- A String to show in shortened/best-effort mode
- The vector of keys that goes with this key hint
This allows all functions that need the hints to iterate over the vector
and pick whatever hint suits them along with the Keys to display.
* status-bar/second-line: Implement shortened hints
* utils/data: Fix display for `Key::Alt`
which previously printed only the internal char but not the modifier.
* status-bar/first-line: Add hidden Tmux tile
that is only shown when in Tmux mode. Note that with the default config
this "breaks" the shared superkey display, because it correctly
identifies that one can switch to Scroll mode via `[`.
* status-bar: Print superkey as part of first line
Instead of first obtaining the superkey and then the rest of the first
line to display. This way we don't need to split up individual data
structures and carry a boolean flag around multiple functions.
It also has the advantage that when the available space is really tight,
the first line is entirely empty and doesn't display a stale superkey
without any other keybinding hints.
* status-bar: Rework keybinding theming
Previously there were individual functions to create the tiles in the
first line depending on whether:
- A tile was selected, unselected, unselected alternate (for theming) or disabled, and
- Tiles had full length or were displayed shortened
In the first case, the functions that previously handled the theming
only differed in what theme they apply to the otherwise identical
content. Since the theming information was drawn from a flat structure
that simulated hierarchy by giving hierarchical names to its theme
"members", this couldn't be handled in code. In the second case, some of
the theming information needed for the full-length shortcuts was
replicated for the shortened shortcuts.
Instead, rewrite the general Theming structure into a hierarchical one:
Adds a new structure `SegmentStyle` that contains the style for a single
segment depending on whether it is selected, unselected (alternate) or
disabled. Refactor the `first-line` module to use a single function to
generate either full-length or shortened tiles, that does functionally
the same but switches themes based on the selection status of the tile
it themes.
* status-bar/second-line: Return new `LinePart`s
from the `add_shortcut` function instead of modifying the input
parameters.
* status-bar/second-line: Implement adaptive behavior
and make the keyhints adapt when the screen runs out of space. The hints
first become shortened and when necessary partially disappear to display
a "..." hint instead.
* status-bar/second-line: Show float pane binding
based on the keycombination that's really bound to switching into the
"Pane" input mode.
* status-bar/get_keys_and_hints: Add more modes
for the keybindings in Tmux and the Pane/TabRename input modes.
* status-bar/second-line: Unify mode handling
and don't do extra shortcut handling for Tmux and the Pane/TabRename
modes any longer. Instead, assemble this like for all other modes from
the keybinding and hints vector.
* status-bar/first-line: Refactor common modifier
to a separate function so it can be used by other modules, too.
* status-bar/second-line: Display modifier in hints
when available. For example, for bindings to move between panes when in
PaneRename mode, now displays "Alt + <hjkl>" instead of
"<Alt+hAlt+j...>".
* utils/ipc: Remove `Copy` from `ClientAttributes`
as preparation to add `Keybinds` as a member to the `ClientAttributes`
struct. `Keybinds` contains a `HashMap`, for which the `std` doesn't
derive `Copy` but only `Clone`.
* utils/input/keybinds: Fix import path
Import `Key` and `InputMode` directly from `data`.
* utils/ipc: Add `Keybinds` to `ClientAttributes`
so we can keep track, pre-client, of the configured key bindings and
pass them around further in the code.
* server/lib: Store `ClientAttributes` over `Style`
in `SessionMetadata` to be able to pass Keybindings to other places in
the code, too. Since `Style` is also a member of `ClientAttributes`,
this works with minimal modifications.
* utils/input: Change `get_mode_info` parameters
to take a `ClientAttributes` struct instead of merely the `Style`
information. This way we can get the `Style` from the
`ClientAttributes`, and also have access to the `keybinds` member that
stores the keybinding configuration.
* utils/ipc: Use `rmp` for serde of IPC messages
instead of `bincode`, which seemingly has issues (de)serializing
`HashMap`s and `BTreeMap`s since `deserialize_any` isn't implemented for
these types.
* fix(nix): remove `assets` from `gitignore`
Remove `assets` from the gitignore of the plugins themselves,
since every single plugin now depends on the asset being accessible
in its source directory.
* tests/e2e: Fix status bar in snapshots
to reflect the current state of the dynamic keybindings.
* status_bar/first_line: Don't show unbound modes
If switching to a specific mode isn't bound to a key, don't show a
tile/ribbon for it either. E.g. in `LOCKED` mode, this will only show
the tile for the `LOCK` mode and ignore all others.
* utils/data: Make 'Key::Char(' ') visible as "␣"
so the user doesn't only see a blank char but has an idea that the space
key is meant.
* status_bar/second_line: Remove extra hints
generated by the `hint_producing_function` that would tell the user in
every input mode how to get back to normal mode. Instead, add this as
keybinding to the general keybindings vector.
This removes some lines of duplicated code but most of all now applies
the correct theming to this keybinding. Additionally, previously the
`RenameTab` and `RenamePane` input modes would show the keybinding to
get back to normal mode twice and both of them were hardcoded. This
binding is now dynamically displayed based on what the user configured
as keybinding.
* utils/data: format unprintable chars as words
instead of unicode symbols. E.g. write "SPACE" instead of "␣".
* utils/data: Fix display for `Ctrl`/`Alt` keys
previously their "inner" chars would be displayed with a regular
`fmt::Display` for the `&str` type they are. This doesn't match what we
want to output. So instead we wrap the inner chars into `Key::Char`
before printing them.
* utils/data: Change order of `Key`s
so that e.g. for the default bindings in `Scroll` mode we prefer to show
`PgDn|PgUp` rather than the arrow keys these actions are bound to as
well.
* status_bar/first_line: Don't ignore default char
bindings by default. These include the '\n', ' ' and 'Esc' bindings that
by default lead back to `Normal` input mode from all the modes.
Previously we would unconditionally ignore them and consequently not
print the tile when in fact the user may have bound this particular
action to either of the keys.
Instead now we first ignore the keys mentioned and if we turn up with an
undefined binding, we consider these default keys as well so we get
*something* to display in any case.
* status_bar/first_line: Add space when no modifier
is shared between the keybindings. This way there isn't a stray arrow at
the very border of the screen, but it is spaced just like the tab-bar
and the second line is.
* status_bar/second_line: Print separators
between consecutive keys bound to specific actions. This allows the user
to visually differ between different keys.
* status_bar/main: Don't return modifier if empty
* status_bar/first_line: Don't suppress Disabled tiles
Disabled is a special state that the keybindings only assume in locked
mode. It turns the respective tiles grey to signal to the user that
these are currently inactive. With respect to users new to zellij, it
may appear confusing that when entering locked mode all the other tiles
disappear (which they do because they have no valid keybinding
assigned). Since we have no keybinding for them, we still display them
but without any associated key (i.e. as `<>` for the binding).
* status_bar/first_line: Don't print leading triangle
on first tile, when there is no shared superkey.
* status_bar/second_line: Add exceptions
for inter-key separators. Keeps groups of `hjkl` and arrow keys intact
(doesn't add separators between the keys) but separates all others.
* status_bar/main: Refactor `action_key`
to a regular function instead of a macro. It turns out that while being
able to match patterns is a nice feature, we completely rely on the keys
that drop out of the pattern found this way to be sorted in a sensible
way. Since we sort the key vectors in the necessary places after the
keys, and not the actions, this of course doesn't apply when the user
changes "hjkl" to "zjkl", which would then become "jklz". Now this is of
course wrong, because "z" still means "Move focus left", and not "Move
focus right".
With the function we now assume a slice of Actions that we match the
action vectors from the keybindings against to obtain the necessary
keys. In order to avoid ugly `into_iter().chain(...)` constructs we had
before we also add a new function `action_key_group` that takes a sliced
array of slices to get a whole group of keys to display.
* status_bar/first_line: Fix "triangle" for short tiles
since we do not want to display a colored triangle at the start of the
line when in sortened mode (just as we do for the long tiles now).
Also fix a bug that would make the triangle reappear when the first
keybinding to be displayed didn't have a key assigned and thus wouldn't
be displayed at all.
* status_bar/second_line: Fix typo
that would cause single `Ctrl+?` bindings for actions in the second line
to be displayed as `Ctrl + <Ctrl+?>`.
* status_bar/second_line: Fix char count
when displaying groups of keys in a binding with or without a separator.
* status_bar: Use new `action_key` fn
instead of the previous macro to obtain the keys to display in the
status bar in a fixed given order. Also fix the display "bug" where tab
switching would be shows as "ArrowLeft/ArrowDown" instead of
"ArrowLeft/ArrowRight".
* status_bar/second_line: Fix floating pane hint
that tells the user what keybinding to press to suppress the currently
active floating panes. This was previously hardcoded.
* utils: Send full keybinds in `ModeInfo`
instead of the currently active `ModeKeybinds` for the active input
mode. Some of the UI issues cannot be solved without having access to
*all* keybindings.
* utils: Refactor keybinds vec into type
to make clippy happy.
* status_bar/first_line: Remove needless borrows
* status_bar: Factor out printing keybindings
into a separate function that takes a vector of keys and a palette and
returns the painted key groups, with correct inter-character separation
where necessary and factoring out common modifier keys.
* status_bar/tip: Use real keybindings
instead of printing hard-coded messages to the user.
* status_bar: abort early when keyvector is empty
in `style_key_with_modifier`.
* status_bar/tip: Fix all keybindings
and make them dynamic given the keybindings really active in the current
session. Also display **UNBOUND** is some keybinding is missing from the
users config.
* status_bar: Go clippy!
* status_bar: Add documentation
and add a new exception group to `action_key_group` that ensures that
`hl` and `jk` won't be separated with `|`.
* status_bar/tip: Detect when key aren't bound
correctly and show "UNBOUND" as keyhint instead, then. Previously we
would only check the length of the whole keybinding segment, but that
isn't a good indicator since most of the bindings require changing modes
first, which already adds a variable number of letters to the segment.
However, there is not point in showing how to get to a certain mode, if
the binding needed in that mode doesn't exist.
* status_bar/first_line: Show bindings when locked
if the user has any configured.
* status_bar: Don't consider 'hl', 'jk' groups
that don't need a separator in between the letters.
* status_bar/second_line: Add "search" keybindings
for the new Search functionality.
* tests/e2e: Fix snapshots
with what the status bar now really displays.
* status_bar: Remove old comments
* status_bar/first_line: Rename 'long_tile'
to the more descriptive name 'mode_shortcut', which better describes
what this function does.
* status_bar/first_line: Fix spacing in simple UI
where the modifier would be shows as `Ctrl +`, without a trailing space.
This isn't an issue in regular mode, where we have the spacing from the
arrow gaps (`>>`) that "simulates" this effect.
* status_bar: Refactor and rename `ctrl_keys`
so it doesn't rely on some "external" index for operation any more.
* status_bar: Add unit tests to shared functions
and fix a bug in the process where certain `Ctrl` keybindings would be
displayed wrong.
* status_bar/first_line: Rename functions
responsible for printing the long and short shortcut keyhint tiles. Also
add some documentation that explains their purpose and the arguments
they accept.
* status_bar/tips: Remove stray "/" in quicknav tip
* utils/layout: Remove old comments
introduced when rewriting `SplitSize::Percent` to not hold an `f64`
type.
* status_bar: Add "regex" as test dependency
We use regular expressions to strip all ANSI escape sequences in the
strings that are produced by the plugin functions during testing. We do
not test for the style information, but merely for the raw text.
* status_bar: Implement unit tests
* Makefile: Always run tests on host triple
This allows the unit tests for all plugins to be run on the host as well
(because their default compilation target is wasm32-wasi).
* tests/e2e: Add test for custom bindings
in the status bar. Makes sure that the modified bindings from a custom
configuration file are read and applied to the UI.
Co-authored-by: a-kenji <aks.kenji@protonmail.com>
