Added keybindings-help-menu-format option

Author: fritzrehde

README.md

@@ -267,8 +267,8 @@ This powerful combination allows you to set some initial state with `initial-env
 ### Help menu
 
 Watchbind supports a help menu that displays:
-1. All environment variables set by `set-env` commands along with their values.
-2. All keybindings along with the operations and the description they are mapped to.
+- All environment variables set by `set-env` commands along with their values.
+- All keybindings along with the operations and the description they are mapped to, though you can customize what exactly gets displayed with `--keybindings-help-menu-format`.
 
 
 ## Tips

src/config/fields/field_selection.rs

@@ -16,6 +16,7 @@ struct FieldSelection {
     end: Option<usize>,
 }
 
+// TODO: should be (at least partially) generated by e.g. parse_display crate
 impl FromStr for FieldSelections {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {

src/config/keybindings/help_menu_format.rs

@@ -0,0 +1,33 @@
+use anyhow::{Error, Result};
+use derive_more::IntoIterator;
+use parse_display::{Display, FromStr};
+use serde::Deserialize;
+use std::str;
+
+/// Specifies which columns should be included in the keybindings help menu,
+/// and in what order.
+#[derive(Debug, Deserialize, Clone, IntoIterator)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct KeybindingsHelpMenuFormat(#[into_iterator(ref)] Vec<KeybindingsHelpMenuColumn>);
+
+#[derive(Debug, Deserialize, FromStr, Display, Clone)]
+#[cfg_attr(test, derive(PartialEq))]
+#[serde(rename_all = "kebab-case")]
+#[display(style = "kebab-case")]
+pub enum KeybindingsHelpMenuColumn {
+    Key,
+    Operations,
+    Description,
+}
+
+// TODO: should get generated by e.g. parse_display directly
+impl str::FromStr for KeybindingsHelpMenuFormat {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let help_menu_columns = s
+            .split(',')
+            .map(KeybindingsHelpMenuColumn::from_str)
+            .collect::<Result<_, _>>()?;
+        Ok(Self(help_menu_columns))
+    }
+}

src/config/keybindings/mod.rs

@@ -1,3 +1,4 @@
+mod help_menu_format;
 mod key;
 mod operations;
 
@@ -11,6 +12,7 @@ use tokio::sync::Mutex;
 use super::table::Table;
 use crate::ui::EnvVariables;
 
+pub use self::help_menu_format::{KeybindingsHelpMenuColumn, KeybindingsHelpMenuFormat};
 pub use self::key::{KeyCode, KeyEvent, KeyModifier};
 pub use self::operations::{OperationExecutable, OperationParsed, Operations, OperationsParsed};
 
@@ -75,46 +77,65 @@ type KeyPrintable = String;
 type OperationsPrintable = String;
 type DescriptionPrintable = String;
 
-#[derive(Debug, Clone, PartialEq, Eq, From)]
-pub struct KeybindingsPrintable(HashMap<KeyPrintable, (OperationsPrintable, DescriptionPrintable)>);
+#[derive(Debug, Clone, From)]
+pub struct KeybindingsPrintable {
+    keybindings: HashMap<KeyPrintable, (OperationsPrintable, DescriptionPrintable)>,
+    format: KeybindingsHelpMenuFormat,
+    header_column_names: Vec<String>,
+}
 
 impl KeybindingsPrintable {
+    pub fn new(keybindings_parsed: KeybindingsParsed, format: KeybindingsHelpMenuFormat) -> Self {
+        let keybindings_printable = keybindings_parsed
+            .0
+            .into_iter()
+            .map(|(key, (operations, description))| {
+                (
+                    key.to_string(),
+                    (operations.to_string(), description.to_string()),
+                )
+            })
+            .collect();
+
+        let header_column_names = (&format)
+            .into_iter()
+            .map(|column_name| column_name.to_string())
+            .collect();
+
+        Self {
+            keybindings: keybindings_printable,
+            format,
+            header_column_names,
+        }
+    }
+
     pub fn display<U>(&self, display_width: U) -> String
     where
         usize: From<U>,
     {
-        let column_names = ["key", "operations", "description"];
+        let column_names = self.header_column_names.as_slice();
 
         let rows_iter = self
-            .0
+            .keybindings
             .iter()
-            .map(|(key, (operations, description))| [key, operations, description]);
+            .map(|(key, (operations, description))| {
+                // TODO: optimize, since currently O(n^2) (iterating format for every keybinding)
+                (&self.format).into_iter().map(move |column| match column {
+                    KeybindingsHelpMenuColumn::Key => key,
+                    KeybindingsHelpMenuColumn::Operations => operations,
+                    KeybindingsHelpMenuColumn::Description => description,
+                })
+            });
 
         Table::new(rows_iter)
             .width(Some(display_width))
             .left_margin(2)
+            .header(column_names)
             .border()
-            .header(&column_names)
             .make_string()
     }
 }
 
-impl From<KeybindingsParsed> for KeybindingsPrintable {
-    fn from(parsed: KeybindingsParsed) -> Self {
-        let keybindings_printable = parsed
-            .0
-            .into_iter()
-            .map(|(key, (operations, description))| {
-                (
-                    key.to_string(),
-                    (operations.to_string(), description.to_string()),
-                )
-            })
-            .collect();
-        Self(keybindings_printable)
-    }
-}
-
 /// Keybindings parsed from TOML.
 #[derive(Debug, Deserialize, Clone)]
 #[cfg_attr(test, derive(PartialEq))]

src/config/mod.rs

@@ -21,14 +21,11 @@ use terminal_size::Width;
 #[cfg(test)]
 use derive_builder::Builder;
 
+use crate::config::keybindings::{KeyCode, KeyModifier};
 use crate::config::style::PrettyColor;
-use crate::config::{
-    keybindings::{KeyCode, KeyModifier},
-    table::Table,
-};
 use crate::utils::possible_enum_values::PossibleEnumValues;
 
-use self::keybindings::{KeybindingCli, KeybindingsToml};
+use self::keybindings::{KeybindingCli, KeybindingsHelpMenuFormat, KeybindingsToml};
 use self::style::{Boldness, Color, Style};
 use self::{
     fields::{FieldSelections, FieldSeparator},
@@ -41,6 +38,7 @@ pub use self::keybindings::{
     OperationParsed, Operations, OperationsParsed,
 };
 pub use self::style::Styles;
+pub use self::table::Table;
 
 // TODO: don't have public members
 
@@ -50,6 +48,7 @@ pub struct Config {
     pub watch_rate: Duration,
     pub styles: Styles,
     pub keybindings_parsed: KeybindingsParsed,
+    pub keybindings_help_menu_format: KeybindingsHelpMenuFormat,
     pub header_lines: usize,
     pub fields: Fields,
     pub initial_env_ops: OperationsParsed,
@@ -155,6 +154,7 @@ impl TryFrom<PartialConfig> for Config {
             watch_rate: Duration::from_secs_f64(expect!(config, interval)),
             styles,
             keybindings_parsed: expect!(config, keybindings),
+            keybindings_help_menu_format: expect!(config, keybindings_help_menu_format),
             header_lines: expect!(config, header_lines),
             fields: Fields::try_new(config.field_separator, config.field_selections)?,
             update_ui_while_blocking: expect!(config, update_ui_while_blocking),
@@ -186,6 +186,7 @@ pub struct PartialConfig {
     field_separator: Option<FieldSeparator>,
     update_ui_while_blocking: Option<bool>,
     keybindings: Option<KeybindingsParsed>,
+    keybindings_help_menu_format: Option<KeybindingsHelpMenuFormat>,
 }
 
 impl PartialConfig {
@@ -238,6 +239,9 @@ impl PartialConfig {
                 .update_ui_while_blocking
                 .or(other.update_ui_while_blocking),
             keybindings: KeybindingsParsed::merge(self.keybindings, other.keybindings),
+            keybindings_help_menu_format: self
+                .keybindings_help_menu_format
+                .or(other.keybindings_help_menu_format),
         }
     }
 
@@ -308,8 +312,9 @@ pub struct TomlFileConfig {
 
     update_ui_while_blocking: Option<bool>,
 
-    // keybindings: Option<StringKeybindings>,
     keybindings: Option<KeybindingsToml>,
+
+    keybindings_help_menu_format: Option<KeybindingsHelpMenuFormat>,
 }
 
 impl TomlFileConfig {
@@ -363,6 +368,7 @@ impl TryFrom<TomlFileConfig> for PartialConfig {
                 .keybindings
                 .map(KeybindingsParsed::try_from)
                 .transpose()?,
+            keybindings_help_menu_format: toml.keybindings_help_menu_format,
         })
     }
 }
@@ -394,6 +400,7 @@ impl TryFrom<CliArgs> for PartialConfig {
                 .map(KeybindingsCli::from)
                 .map(KeybindingsParsed::try_from)
                 .transpose()?,
+            keybindings_help_menu_format: cli.keybindings_help_menu_format,
         })
     }
 }
@@ -421,6 +428,8 @@ impl Default for PartialConfig {
 
             "update-ui-while-blocking" = false
 
+            "keybindings-help-menu-format" = [ "key", "operations", "description" ]
+
             [keybindings]
             "ctrl+c" = { operations = "exit", description = "Exit watchbind." }
             "q" = { operations = "exit", description = "Exit watchbind." }
@@ -594,6 +603,10 @@ pub struct CliArgs {
     /// Keybindings as comma-separated `KEY:OP[+OP]*` pairs, e.g. `q:select+exit,r:reload`.
     #[arg(short = 'b', long = "bind", value_name = "LIST", value_delimiter = ',')]
     keybindings: Option<Vec<KeybindingCli>>,
+
+    /// Format of keybindings help menu as comma-separated list, e.g. `key,operations,description`.
+    #[arg(long, value_name = "FORMAT")]
+    keybindings_help_menu_format: Option<KeybindingsHelpMenuFormat>,
 }
 
 /// Convert [[&str, String]] to [[Cow::Borrowed(&str), Cow::Owned(&str)]].

src/config/table.rs

@@ -1,4 +1,4 @@
-use std::{fmt, ops::Deref};
+use std::fmt;
 use tabled::{
     builder::Builder,
     settings::{
@@ -19,7 +19,7 @@ where
     width: Option<usize>,
     left_margin: Option<usize>,
     border: bool,
-    header: Option<&'a [&'a str]>,
+    header: Option<&'a [String]>,
 }
 
 impl<'a, RowsIter, RowIter, TableItem> Table<'a, RowsIter, RowIter, TableItem>
@@ -60,7 +60,7 @@ where
     }
 
     /// Use the first input row as a header.
-    pub fn header(mut self, column_names: &'a [&'a str]) -> Self {
+    pub fn header(mut self, column_names: &'a [String]) -> Self {
         self.header = Some(column_names);
         self
     }
@@ -85,15 +85,16 @@ where
         } else {
             table
                 .with(Style::blank())
-                // Add left margin for indent.
-                .with(Margin::new(left_margin, 0, 0, 0))
-                // Remove left padding, as it interferes with margin.
+                // Remove left padding.
                 .with(Padding::new(0, 1, 0, 0));
         }
 
+        // Add left margin for indent.
+        table.with(Margin::new(left_margin, 0, 0, 0));
+
         if let Some(column_names) = self.header {
             // Set the header to the column names.
-            table.with(ColumnNames::new(column_names.iter().map(Deref::deref)));
+            table.with(ColumnNames::new(column_names));
         }
 
         if let Some(width) = self.width {

src/ui/mod.rs

@@ -165,7 +165,10 @@ impl UI {
             config.header_lines,
             config.fields,
             config.styles,
-            KeybindingsPrintable::from(config.keybindings_parsed.clone()),
+            KeybindingsPrintable::new(
+                config.keybindings_parsed.clone(),
+                config.keybindings_help_menu_format,
+            ),
             EnvVariables::new(),
         );
         state

src/ui/state/env_variables/mod.rs

@@ -1,13 +1,12 @@
 mod env_variable;
 
-use anyhow::Result;
-use itertools::Itertools;
-use std::{collections::HashMap, fmt, io::Write};
-use tabwriter::TabWriter;
+use std::collections::HashMap;
+
+use crate::config::Table;
 
 pub use self::env_variable::EnvVariable;
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone)]
 pub struct EnvVariables(HashMap<EnvVariable, String>);
 
 impl EnvVariables {
@@ -32,30 +31,23 @@ impl EnvVariables {
         self.0.remove(env_var);
     }
 
-    /// Write formatted version (insert elastic tabstops) to a buffer.
-    fn write<W: Write>(&self, writer: W) -> Result<()> {
-        let mut tw = TabWriter::new(writer);
-        for (env_variable, value) in self.0.iter().sorted() {
-            writeln!(tw, "{}\t= \"{}\"", env_variable, value)?;
-        }
-        tw.flush()?;
-        Ok(())
-    }
+    pub fn display<U>(&self, display_width: U) -> String
+    where
+        usize: From<U>,
+    {
+        let column_names = &["environment variable".to_string(), "value".to_string()];
 
-    // TODO: code duplication from KeybindingsParsed
-    fn fmt(&self) -> Result<String> {
-        let mut buffer = vec![];
-        self.write(&mut buffer)?;
-        let written = String::from_utf8(buffer)?;
-        Ok(written)
-    }
-}
+        let rows_iter = self
+            .0
+            .iter()
+            .map(|(env_variable, value)| [env_variable.to_string(), value.to_owned()]);
 
-// TODO: code duplication from KeybindingsParsed
-impl fmt::Display for EnvVariables {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let formatted = self.fmt().map_err(|_| fmt::Error)?;
-        f.write_str(&formatted)
+        Table::new(rows_iter)
+            .width(Some(display_width))
+            .left_margin(2)
+            .header(column_names)
+            .border()
+            .make_string()
     }
 }