feat(console): Support config file

tokio-console/Cargo.toml

@@ -44,3 +44,6 @@ h2 = "0.3"
 regex = "1.5"
 once_cell = "1.8"
 humantime = "2.1.0"
+serde = { version = "1", features = ["derive"] }
+toml = "0.5"
+dirs = "4"

tokio-console/src/config.rs

@@ -1,5 +1,10 @@
 use crate::view::Palette;
 use clap::{ArgGroup, Parser as Clap, ValueHint};
+use color_eyre::eyre::WrapErr;
+use serde::Deserialize;
+use std::fs;
+use std::ops::Not;
+use std::path::PathBuf;
 use std::process::Command;
 use std::str::FromStr;
 use std::time::Duration;
@@ -71,15 +76,15 @@ struct RetainFor(Option<Duration>);
 pub struct ViewOptions {
     /// Disable ANSI colors entirely.
     #[clap(name = "no-colors", long = "no-colors")]
-    no_colors: bool,
+    no_colors: Option<bool>,
 
     /// Overrides the terminal's default language.
-    #[clap(long = "lang", env = "LANG", default_value = "en_us.UTF-8")]
-    lang: String,
+    #[clap(long = "lang", env = "LANG")]
+    lang: Option<String>,
 
     /// Explicitly use only ASCII characters.
     #[clap(long = "ascii-only")]
-    ascii_only: bool,
+    ascii_only: Option<bool>,
 
     /// Overrides the value of the `COLORTERM` environment variable.
     ///
@@ -107,20 +112,66 @@ pub struct ViewOptions {
 }
 
 /// Toggles on and off color coding for individual UI elements.
-#[derive(Clap, Debug, Copy, Clone)]
+#[derive(Clap, Debug, Copy, Clone, Deserialize)]
 pub struct ColorToggles {
     /// Disable color-coding for duration units.
-    #[clap(long = "no-duration-colors", parse(from_flag = std::ops::Not::not), group = "colors")]
-    pub(crate) color_durations: bool,
+    #[clap(long = "no-duration-colors", group = "colors")]
+    #[serde(rename = "durations")]
+    color_durations: Option<bool>,
 
     /// Disable color-coding for terminated tasks.
-    #[clap(long = "no-terminated-colors", parse(from_flag = std::ops::Not::not), group = "colors")]
-    pub(crate) color_terminated: bool,
+    #[clap(long = "no-terminated-colors", group = "colors")]
+    #[serde(rename = "terminated")]
+    color_terminated: Option<bool>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ConfigFile {
+    charset: Option<CharsetConfig>,
+    colors: Option<ColorsConfig>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct CharsetConfig {
+    lang: Option<String>,
+    ascii_only: Option<bool>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ColorsConfig {
+    enabled: Option<bool>,
+    truecolor: Option<bool>,
+    palette: Option<Palette>,
+    enable: Option<ColorToggles>,
 }
 
 // === impl Config ===
 
 impl Config {
+    pub fn from_config() -> color_eyre::Result<Self> {
+        let xdg = ViewOptions::from_config(ConfigPath::Xdg)?;
+        let current = ViewOptions::from_config(ConfigPath::Current)?;
+        let base = match (xdg, current) {
+            (None, None) => None,
+            (Some(xdg), None) => Some(xdg),
+            (None, Some(current)) => Some(current),
+            (Some(mut xdg), Some(current)) => {
+                xdg.merge_with(current);
+                Some(xdg)
+            }
+        };
+        let mut config = Self::parse();
+        let view_options = match base {
+            None => config.view_options,
+            Some(mut base) => {
+                base.merge_with(config.view_options);
+                base
+            }
+        };
+        config.view_options = view_options;
+        Ok(config)
+    }
+
     pub fn trace_init(&mut self) -> color_eyre::Result<()> {
         let filter = std::mem::take(&mut self.env_filter);
         use tracing_subscriber::prelude::*;
@@ -167,7 +218,9 @@ impl Config {
 
 impl ViewOptions {
     pub fn is_utf8(&self) -> bool {
-        self.lang.ends_with("UTF-8") && !self.ascii_only
+        let lang = self.lang.as_deref().unwrap_or_default();
+        let ascii_only = self.ascii_only.unwrap_or(true);
+        lang.ends_with("UTF-8") && !ascii_only
     }
 
     /// Determines the color palette to use.
@@ -179,7 +232,7 @@ impl ViewOptions {
     /// - Checking the `terminfo` database via `tput`
     pub(crate) fn determine_palette(&self) -> Palette {
         // Did the user explicitly disable colors?
-        if self.no_colors {
+        if self.no_colors.unwrap_or(true) {
             tracing::debug!("colors explicitly disabled by `--no-colors`");
             return Palette::NoColors;
         }
@@ -219,6 +272,27 @@ impl ViewOptions {
     pub(crate) fn toggles(&self) -> ColorToggles {
         self.toggles
     }
+
+    fn from_config(path: ConfigPath) -> color_eyre::Result<Option<Self>> {
+        let options = ConfigFile::from_config(path)?.map(|config| config.into_view_options());
+        Ok(options)
+    }
+
+    fn merge_with(&mut self, command_line: ViewOptions) {
+        self.no_colors = command_line.no_colors.or_else(|| self.no_colors.take());
+        self.lang = command_line.lang.or_else(|| self.lang.take());
+        self.ascii_only = command_line.ascii_only.or_else(|| self.ascii_only.take());
+        self.truecolor = command_line.truecolor.or_else(|| self.truecolor.take());
+        self.palette = command_line.palette.or_else(|| self.palette.take());
+        self.toggles.color_durations = command_line
+            .toggles
+            .color_durations
+            .or_else(|| self.toggles.color_durations.take());
+        self.toggles.color_terminated = command_line
+            .toggles
+            .color_terminated
+            .or_else(|| self.toggles.color_terminated.take());
+    }
 }
 
 fn parse_true_color(s: &str) -> bool {
@@ -238,3 +312,86 @@ impl FromStr for RetainFor {
         }
     }
 }
+
+// === impl ColorToggles ===
+
+impl ColorToggles {
+    pub fn color_durations(&self) -> bool {
+        self.color_durations.map(std::ops::Not::not).unwrap_or(true)
+    }
+
+    pub fn color_terminated(&self) -> bool {
+        self.color_durations.map(std::ops::Not::not).unwrap_or(true)
+    }
+}
+
+// === impl ColorToggles ===
+
+impl ConfigFile {
+    fn from_config(path: ConfigPath) -> color_eyre::Result<Option<Self>> {
+        let config = path
+            .into_path()
+            .and_then(|path| fs::read_to_string(path).ok())
+            .map(|raw| toml::from_str::<ConfigFile>(&raw))
+            .transpose()
+            .wrap_err_with(|| format!("failed to parse {:?}", path.into_path()))?;
+        Ok(config)
+    }
+
+    fn into_view_options(self) -> ViewOptions {
+        ViewOptions {
+            no_colors: self.no_colors(),
+            lang: self.charset.as_ref().and_then(|config| config.lang.clone()),
+            ascii_only: self.charset.as_ref().and_then(|config| config.ascii_only),
+            truecolor: self.colors.as_ref().and_then(|config| config.truecolor),
+            palette: self.colors.as_ref().and_then(|config| config.palette),
+            toggles: ColorToggles {
+                color_durations: self.color_durations(),
+                color_terminated: self.color_terminated(),
+            },
+        }
+    }
+
+    fn no_colors(&self) -> Option<bool> {
+        self.colors
+            .as_ref()
+            .and_then(|config| config.enabled.map(Not::not))
+    }
+
+    fn color_durations(&self) -> Option<bool> {
+        self.colors
+            .as_ref()
+            .and_then(|config| config.enable.map(|toggles| toggles.color_durations()))
+    }
+
+    fn color_terminated(&self) -> Option<bool> {
+        self.colors
+            .as_ref()
+            .and_then(|config| config.enable.map(|toggles| toggles.color_terminated()))
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum ConfigPath {
+    Xdg,
+    Current,
+}
+
+impl ConfigPath {
+    fn into_path(self) -> Option<PathBuf> {
+        match self {
+            Self::Xdg => {
+                let mut path = dirs::config_dir();
+                if let Some(path) = path.as_mut() {
+                    path.push("tokio-console/console.toml");
+                }
+                path
+            }
+            Self::Current => {
+                let mut path = PathBuf::new();
+                path.push("./console.toml");
+                Some(path)
+            }
+        }
+    }
+}

tokio-console/src/main.rs

@@ -2,7 +2,6 @@ use color_eyre::{eyre::eyre, Help, SectionExt};
 use console_api::tasks::TaskDetails;
 use state::State;
 
-use clap::Parser as Clap;
 use futures::stream::StreamExt;
 use tokio::sync::{mpsc, watch};
 use tui::{
@@ -26,7 +25,13 @@ mod warnings;
 
 #[tokio::main]
 async fn main() -> color_eyre::Result<()> {
-    let mut args = config::Config::parse();
+    let mut args = match config::Config::from_config() {
+        Err(e) => {
+            eprintln!("failed to parse config file: {:#?}", e);
+            std::process::exit(1);
+        }
+        Ok(args) => args,
+    };
     let retain_for = args.retain_for();
     args.trace_init()?;
     tracing::debug!(?args.target_addr, ?args.view_options);