summaryrefslogtreecommitdiff
path: root/src/config
diff options
context:
space:
mode:
Diffstat (limited to 'src/config')
-rw-r--r--src/config/keybinds.rs209
-rw-r--r--src/config/model.rs43
2 files changed, 216 insertions, 36 deletions
diff --git a/src/config/keybinds.rs b/src/config/keybinds.rs
index 5f4b46de..903f85ca 100644
--- a/src/config/keybinds.rs
+++ b/src/config/keybinds.rs
@@ -10,12 +10,38 @@ use crate::popup_size::PopupSize;
pub type KeyCombo = (KeyCode, KeyModifiers);
+/// Built-in prefix used when `keys.prefix` is unset or invalid.
+pub(crate) const DEFAULT_PREFIX: KeyCombo = (KeyCode::Char('b'), KeyModifiers::CONTROL);
+
#[derive(Debug, Clone)]
pub struct LiveKeybindConfig {
- pub prefix: KeyCombo,
+ /// Every configured prefix key. The first entry is the primary prefix used
+ /// for compact display; all entries enter prefix mode.
+ pub prefix: Vec<KeyCombo>,
pub keybinds: Keybinds,
}
+impl LiveKeybindConfig {
+ /// Whether `key` is one of the configured prefix keys.
+ pub fn matches_prefix(&self, key: &TerminalKey) -> bool {
+ self.prefix
+ .iter()
+ .any(|combo| terminal_key_matches_combo(key, *combo))
+ }
+
+ /// Primary prefix combo, used for the compact status bar.
+ pub fn primary_prefix(&self) -> Option<KeyCombo> {
+ self.prefix.first().copied()
+ }
+
+ /// Primary prefix rendered for the compact status bar.
+ pub fn primary_prefix_label(&self) -> String {
+ self.primary_prefix()
+ .map(format_key_combo)
+ .unwrap_or_else(|| format_key_combo(DEFAULT_PREFIX))
+ }
+}
+
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BindingConfig {
@@ -45,6 +71,13 @@ impl BindingConfig {
}
}
+ pub(crate) fn into_values(self) -> Vec<String> {
+ match self {
+ Self::One(value) => vec![value],
+ Self::Many(values) => values,
+ }
+ }
+
pub(crate) fn has_values(&self) -> bool {
self.values().iter().any(|value| !value.trim().is_empty())
}
@@ -397,16 +430,19 @@ struct RegisteredBinding {
}
struct BindingRegistry {
- prefix_combo: KeyCombo,
+ prefix_combos: Vec<KeyCombo>,
prefix_source: BindingSource,
direct: std::collections::HashMap<KeyCombo, RegisteredBinding>,
prefix: std::collections::HashMap<KeyCombo, RegisteredBinding>,
}
impl BindingRegistry {
- fn new(prefix_combo: KeyCombo, prefix_source: BindingSource) -> Self {
+ fn new(prefix_combos: Vec<KeyCombo>, prefix_source: BindingSource) -> Self {
+ let mut normalized: Vec<KeyCombo> =
+ prefix_combos.into_iter().map(normalize_key_combo).collect();
+ normalized.dedup();
Self {
- prefix_combo: normalize_key_combo(prefix_combo),
+ prefix_combos: normalized,
prefix_source,
direct: std::collections::HashMap::new(),
prefix: std::collections::HashMap::new(),
@@ -422,8 +458,18 @@ impl BindingRegistry {
});
}
+ /// Reserve every configured prefix key as a direct/modifier key so no
+ /// action can hijack it before prefix mode starts.
+ fn reserve_prefix_keys(&mut self, field: &str, source: BindingSource) {
+ let combos = self.prefix_combos.clone();
+ for combo in combos {
+ self.reserve_direct(combo, field, source);
+ }
+ }
+
fn prefix_rhs_is_reserved(&self, combo: KeyCombo) -> bool {
- normalize_key_combo(combo) == self.prefix_combo
+ let combo = normalize_key_combo(combo);
+ self.prefix_combos.contains(&combo)
}
fn conflict(&self, binding: &ResolvedBinding) -> Option<&RegisteredBinding> {
@@ -450,27 +496,28 @@ impl BindingRegistry {
}
impl Config {
- pub(super) fn validated_keybinds(&self) -> (Option<String>, KeyCombo, Vec<String>, Keybinds) {
- let mut diagnostics = Vec::new();
- let (prefix, prefix_diag) = parse_key_combo_with_diagnostic(
- &self.keys.prefix,
- "keys.prefix",
- (KeyCode::Char('b'), KeyModifiers::CONTROL),
- );
+ pub(super) fn validated_keybinds(
+ &self,
+ ) -> (Option<String>, Vec<KeyCombo>, Vec<String>, Keybinds) {
+ let (prefix_keys, prefix_diag, mut diagnostics) = parse_prefix_keys(&self.keys.prefix);
if let Some(diag) = &prefix_diag {
warn!(message = %diag, "config diagnostic");
}
+ for diag in &diagnostics {
+ warn!(message = %diag, "config diagnostic");
+ }
let prefix_source = if self.keys.key_field_is_user_configured("prefix") {
BindingSource::User
} else {
BindingSource::Default
};
- let mut registry = BindingRegistry::new(prefix, prefix_source);
- registry.reserve_direct(prefix, "keys.prefix", prefix_source);
- let mut navigate_registry = BindingRegistry::new(prefix, prefix_source);
- navigate_registry.reserve_direct(prefix, "keys.prefix", prefix_source);
+ let mut registry = BindingRegistry::new(prefix_keys.clone(), prefix_source);
+ registry.reserve_prefix_keys("keys.prefix", prefix_source);
+ let mut navigate_registry = BindingRegistry::new(prefix_keys.clone(), prefix_source);
+ navigate_registry.reserve_prefix_keys("keys.prefix", prefix_source);
reserve_navigate_runtime_keys(&mut navigate_registry);
+ let prefix = prefix_keys;
macro_rules! empty_action {
() => {
@@ -1306,19 +1353,45 @@ fn single_key_char(s: &str) -> Option<char> {
}
}
-fn parse_key_combo_with_diagnostic(
- s: &str,
- field: &str,
- fallback: KeyCombo,
-) -> (KeyCombo, Option<String>) {
- match parse_key_combo(s) {
- Some(binding) => (binding, None),
- None => {
- let diag = format!("invalid keybinding: {field} = {s:?}; using fallback");
- warn!(message = %diag, "config diagnostic");
- (fallback, Some(diag))
+/// Parse the configured prefix keys. Returns the effective list, an optional
+/// rejection diagnostic (used when nothing valid remains, so the caller keeps
+/// the previous keybinds), and per-entry diagnostics.
+fn parse_prefix_keys(config: &BindingConfig) -> (Vec<KeyCombo>, Option<String>, Vec<String>) {
+ let mut combos: Vec<KeyCombo> = Vec::new();
+ let mut diagnostics = Vec::new();
+
+ for raw in config.values() {
+ let raw = raw.trim();
+ match parse_key_combo(raw) {
+ Some(combo) if !combos.contains(&combo) => combos.push(combo),
+ Some(_) => {}
+ None => diagnostics.push(format!(
+ "invalid keybinding: keys.prefix = {raw:?}; ignoring prefix"
+ )),
}
}
+
+ if combos.is_empty() {
+ let reject = Some(format!(
+ "invalid keybinding: keys.prefix; using fallback {}",
+ format_key_combo(DEFAULT_PREFIX)
+ ));
+ return (vec![DEFAULT_PREFIX], reject, diagnostics);
+ }
+
+ (combos, None, diagnostics)
+}
+
+/// Render all configured prefix keys for the help panel.
+pub fn format_prefix_combos(prefixes: &[KeyCombo]) -> String {
+ if prefixes.is_empty() {
+ return format_key_combo(DEFAULT_PREFIX);
+ }
+ prefixes
+ .iter()
+ .map(|combo| format_key_combo(*combo))
+ .collect::<Vec<_>>()
+ .join(" / ")
}
pub fn normalize_key_combo((mut code, mut modifiers): KeyCombo) -> KeyCombo {
@@ -1532,8 +1605,8 @@ prefix = "ö"
)
.unwrap();
assert_eq!(
- config.prefix_key(),
- (KeyCode::Char('ö'), KeyModifiers::empty())
+ config.prefix_keys(),
+ vec![(KeyCode::Char('ö'), KeyModifiers::empty())]
);
assert!(config.collect_diagnostics().is_empty());
}
@@ -1822,6 +1895,84 @@ help = "prefix+ctrl+b"
}
#[test]
+ fn multiple_prefix_keys_parse_reserve_and_share_prefix_bindings() {
+ let config: Config = toml::from_str(
+ r#"
+[keys]
+prefix = ["ctrl+space", "ctrl+s"]
+help = "prefix+?"
+"#,
+ )
+ .unwrap();
+ assert_eq!(
+ config.prefix_keys(),
+ vec![
+ (KeyCode::Char(' '), KeyModifiers::CONTROL),
+ (KeyCode::Char('s'), KeyModifiers::CONTROL),
+ ]
+ );
+ assert!(config.collect_diagnostics().is_empty());
+
+ // A prefix action works regardless of which prefix key started prefix mode.
+ let help = &config.keybinds().help;
+ assert!(
+ help.matches_prefix_key(&TerminalKey::new(KeyCode::Char('?'), KeyModifiers::empty()))
+ );
+
+ // Every prefix key is reserved as a prefix-mode right-hand side.
+ let reserved: Config = toml::from_str(
+ r#"
+[keys]
+prefix = ["ctrl+space", "ctrl+s"]
+help = "prefix+ctrl+s"
+"#,
+ )
+ .unwrap();
+ assert!(reserved.keybinds().help.bindings.is_empty());
+ assert!(reserved
+ .collect_diagnostics()
+ .iter()
+ .any(|diag| diag.contains("reserved keybinding")));
+ }
+
+ #[test]
+ fn invalid_prefix_entries_are_dropped_while_valid_ones_survive() {
+ let config: Config = toml::from_str(
+ r#"
+[keys]
+prefix = ["ctrl+a", "wat"]
+"#,
+ )
+ .unwrap();
+ assert_eq!(
+ config.prefix_keys(),
+ vec![(KeyCode::Char('a'), KeyModifiers::CONTROL)]
+ );
+ assert!(config
+ .collect_diagnostics()
+ .iter()
+ .any(|diag| diag.contains("keys.prefix") && diag.contains("ignoring prefix")));
+ }
+
+ #[test]
+ fn empty_prefix_list_is_rejected_and_keeps_the_fallback() {
+ let config: Config = toml::from_str(
+ r#"
+[keys]
+prefix = []
+"#,
+ )
+ .unwrap();
+ assert_eq!(config.prefix_keys(), vec![DEFAULT_PREFIX]);
+ assert!(config
+ .collect_diagnostics()
+ .iter()
+ .any(|diag| diag.contains("keys.prefix")));
+ // A reload treats the empty list as invalid and keeps the current keybinds.
+ assert!(config.live_keybinds_with_diagnostics().is_err());
+ }
+
+ #[test]
fn navigate_bindings_allow_plain_keys_and_reject_local_conflicts() {
let config: Config = toml::from_str(
r#"
diff --git a/src/config/model.rs b/src/config/model.rs
index ce59eb2e..0e2e57ce 100644
--- a/src/config/model.rs
+++ b/src/config/model.rs
@@ -334,8 +334,9 @@ pub struct LoadedConfig {
#[derive(Debug, Clone, Serialize)]
pub struct KeysConfig {
- /// Prefix key to enter prefix mode (e.g. "ctrl+b", "f12", "esc").
- pub prefix: String,
+ /// Prefix key(s) to enter prefix mode (e.g. "ctrl+b", "f12", "esc", or an
+ /// array to accept several).
+ pub prefix: BindingConfig,
/// Open keybinding help. Default: "prefix+?"
pub help: BindingConfig,
/// Open settings. Default: "prefix+s"
@@ -467,7 +468,12 @@ pub struct KeysConfig {
#[serde(default)]
pub(crate) struct KeysConfigOverlay {
#[serde(skip_serializing_if = "Option::is_none")]
- prefix: Option<String>,
+ prefix: Option<BindingConfig>,
+ /// Additional prefix keys published for cross-version compatibility.
+ /// Older clients parse `prefix` as a single string and ignore this field;
+ /// new clients merge it into the effective prefix list.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ extra_prefixes: Option<BindingConfig>,
#[serde(skip_serializing_if = "Option::is_none")]
help: Option<BindingConfig>,
#[serde(skip_serializing_if = "Option::is_none")]
@@ -592,8 +598,13 @@ pub(crate) struct KeysConfigOverlay {
}
impl KeysConfigOverlay {
- pub(crate) fn set_prefix(&mut self, prefix: String) {
- self.prefix = Some(prefix);
+ pub(crate) fn set_prefixes(&mut self, prefixes: &[super::keybinds::KeyCombo]) {
+ let mut labels = prefixes
+ .iter()
+ .map(|combo| super::keybinds::format_key_combo(*combo));
+ self.prefix = Some(BindingConfig::One(labels.next().unwrap_or_default()));
+ let extra: Vec<String> = labels.collect();
+ self.extra_prefixes = (!extra.is_empty()).then_some(BindingConfig::Many(extra));
}
}
@@ -605,6 +616,25 @@ impl<'de> Deserialize<'de> for KeysConfig {
let input = KeysConfigOverlay::deserialize(deserializer)?;
let mut keys = KeysConfig::default();
+ let prefix_was_supplied = input.prefix.is_some() || input.extra_prefixes.is_some();
+ let mut prefix_values = Vec::new();
+ if let Some(prefix) = input.prefix {
+ prefix_values.extend(prefix.into_values());
+ }
+ if let Some(extra) = input.extra_prefixes {
+ prefix_values.extend(extra.into_values());
+ }
+ if prefix_was_supplied {
+ // An explicitly empty list stays empty so prefix validation rejects
+ // it and a reload keeps the current keybindings.
+ keys.prefix = match prefix_values.len() {
+ 0 => BindingConfig::Many(Vec::new()),
+ 1 => BindingConfig::One(prefix_values.remove(0)),
+ _ => BindingConfig::Many(prefix_values),
+ };
+ keys.user_fields.insert("prefix");
+ }
+
macro_rules! apply_field {
($field:ident) => {
if let Some(value) = input.$field {
@@ -614,7 +644,6 @@ impl<'de> Deserialize<'de> for KeysConfig {
};
}
- apply_field!(prefix);
apply_field!(help);
apply_field!(settings);
apply_field!(new_workspace);
@@ -1088,7 +1117,7 @@ pub struct ExperimentalConfig {
impl Default for KeysConfig {
fn default() -> Self {
Self {
- prefix: "ctrl+b".into(),
+ prefix: BindingConfig::one("ctrl+b"),
help: BindingConfig::one("prefix+?"),
settings: BindingConfig::one("prefix+s"),
new_workspace: BindingConfig::one("prefix+shift+n"),