path: root/src/options/args.rs

//! Argument parsing via clap + config files.
//!
//! Note that you probably want to keep this as a single file so the build script doesn't
//! trip all over itself.

// TODO: New sections are misaligned! See if we can get that fixed.
// TODO: This might need some more work when we do config screens. For example, we can't just merge args + config,
// since we need to know the state of the config, the overwriting args, and adjust the calculated app settings as
// they change.

use clap::*;
use indoc::indoc;
use serde::Deserialize;

const TEMPLATE: &str = indoc! {
    "{name} {version}
    {author}

    {about}

    {usage-heading} {usage}

    {all-args}"
};

const USAGE: &str = "btm [OPTIONS]";

const VERSION: &str = match option_env!("NIGHTLY_VERSION") {
    Some(nightly_version) => nightly_version,
    None => crate_version!(),
};

macro_rules! set_if_some {
    ($name:ident, $curr:expr, $new:expr) => {
        if $new.$name.is_some() {
            $curr.$name = $new.$name.clone();
        }
    };
}

#[derive(Clone, Debug, Deserialize)]
#[serde(untagged)]
pub(crate) enum StringOrNum {
    String(String),
    Num(u64),
}

impl From<&str> for StringOrNum {
    fn from(value: &str) -> Self {
        match value.parse::<u64>() {
            Ok(parsed) => StringOrNum::Num(parsed),
            Err(_) => StringOrNum::String(value.to_owned()),
        }
    }
}

impl From<u64> for StringOrNum {
    fn from(value: u64) -> Self {
        StringOrNum::Num(value)
    }
}

/// Represents the arguments that can be passed in to bottom.
#[derive(Parser, Debug)]
#[command(
    name = crate_name!(),
    version = VERSION,
    author = crate_authors!(),
    about = crate_description!(),
    disable_help_flag = true,
    disable_version_flag = true,
    color = ColorChoice::Auto,
    help_template = TEMPLATE,
    override_usage = USAGE,
)]
pub struct BottomArgs {
    #[command(flatten)]
    pub(crate) general: GeneralArgs,

    #[command(flatten)]
    pub(crate) process: ProcessArgs,

    #[command(flatten)]
    pub(crate) temperature: TemperatureArgs,

    #[command(flatten)]
    pub(crate) cpu: CpuArgs,

    #[command(flatten)]
    pub(crate) memory: MemoryArgs,

    #[command(flatten)]
    pub(crate) network: NetworkArgs,

    #[cfg(feature = "battery")]
    #[command(flatten)]
    pub(crate) battery: BatteryArgs,

    #[cfg(feature = "gpu")]
    #[command(flatten)]
    pub(crate) gpu: GpuArgs,

    #[command(flatten)]
    pub(crate) style: StyleArgs,

    #[command(flatten)]
    pub(crate) other: OtherArgs,
}

impl BottomArgs {
    /// Returns the config path if it is set.
    #[inline]
    pub fn config_path(&self) -> Option<&str> {
        self.general.config_location.as_deref()
    }
}

/// General arguments/config options.
#[derive(Args, Clone, Debug, Default, Deserialize)]
#[command(next_help_heading = "General Options", rename_all = "snake_case")]
pub(crate) struct GeneralArgs {
    #[arg(
        long,
        help = "Temporarily shows the time scale in graphs.",
        long_help = "Automatically hides the time scale in graphs after being shown for a brief moment when zoomed \
                    in/out. If time is disabled via --hide_time then this will have no effect."
    )]
    pub(crate) autohide_time: Option<bool>,

    #[arg(
        short = 'b',
        long,
        help = "Hides graphs and uses a more basic look.",
        long_help = "Hides graphs and uses a more basic look. Design is largely inspired by htop's."
    )]
    pub(crate) basic: Option<bool>,

    #[arg(
        short = 'C',
        long,
        value_name = "PATH",
        help = "Sets the location of the config file.",
        long_help = "Sets the location of the config file. Expects a config file in the TOML format. \
                    If it doesn't exist, a default config file is created at the path. If no path is provided,
                    the default config location will be used."
    )]
    #[serde(skip)]
    pub(crate) config_location: Option<String>,

    #[arg(
        short = 't',
        long,
        value_name = "TIME",
        help = "Default time value for graphs.",
        long_help = "Default time value for graphs. Either a number in milliseconds or a 'human duration' \
                    (e.g. 60s, 10m). Defaults to 60s, must be at least 30s."
    )]
    pub(crate) default_time_value: Option<StringOrNum>,

    // TODO: Charts are broken in the manpage
    #[arg(
        long,
        requires_all = ["default_widget_type"],
        value_name = "N",
        help = "Sets the n'th selected widget type as the default. Use --help for more info.",
        long_help = indoc! {
            "Sets the n'th selected widget type to use as the default widget.
            Requires 'default_widget_type' to also be set, and defaults to 1.

            This reads from left to right, top to bottom. For example, suppose
            we have a layout that looks like:
            +-------------------+-----------------------+
            |      CPU (1)      |        CPU (2)        |
            +---------+---------+-------------+---------+
            | Process | CPU (3) | Temperature | CPU (4) |
            +---------+---------+-------------+---------+

            And we set our default widget type to 'CPU'. If we set
            '--default_widget_count 1', then it would use the CPU (1) as
            the default widget. If we set '--default_widget_count 3', it would
            use CPU (3) as the default instead."
        }
    )]
    pub(crate) default_widget_count: Option<u32>,

    #[arg(
        long,
        value_name = "WIDGET",
        help = "Sets the default widget type. Use --help for more info.\n", // Newline to force the possible values to be on the next line.
        long_help = indoc!{
            "Sets which widget type to use as the default widget. For the default \
            layout, this defaults to the 'process' widget. For a custom layout, it defaults \
            to the first widget it sees.

            For example, suppose we have a layout that looks like:
            +-------------------+-----------------------+
            |      CPU (1)      |        CPU (2)        |
            +---------+---------+-------------+---------+
            | Process | CPU (3) | Temperature | CPU (4) |
            +---------+---------+-------------+---------+

            Setting '--default_widget_type Temp' will make the temperature widget selected by default."
        },
        value_parser = [
            "cpu",
            "mem",
            "net",
            "network",
            "proc",
            "process",
            "processes",
            "temp",
            "temperature",
            "disk",
            #[cfg(feature = "battery")]
            "batt",
            #[cfg(feature = "battery")]
            "battery",
        ],
    )]
    pub(crate) default_widget_type: Option<String>,

    #[arg(
        long,
        help = "Disables mouse clicks.",
        long_help = "Disables mouse clicks from interacting with bottom."
    )]
    pub(crate) disable_click: Option<bool>,

    #[arg(
        short = 'm',
        long,
        help = "Uses a dot marker for graphs.",
        long_help = "Uses a dot marker for graphs as opposed to the default braille marker."
    )]
    pub(crate) dot_marker: Option<bool>,

    #[arg(
        short = 'e',
        long,
        help = "Expand the default widget upon starting the app.",
        long_help = "Expand the default widget upon starting the app. This flag has no effect in basic mode (--basic)."
    )]
    pub(crate) expanded: Option<bool>,

    #[arg(long, help = "Hides spacing between table headers and entries.")]
    pub(crate) hide_table_gap: Option<bool>,

    #[arg(long, help = "Hides the time scale from being shown.")]
    pub(crate) hide_time: Option<bool>,

    #[arg(
        short = 'r',
        long,
        value_name = "TIME",
        help = "Sets how often data is refreshed.",
        long_help = "Sets how often data is refreshed. Either a number in milliseconds or a 'human duration' \
                    (e.g. 1s, 1m). Defaults to 1s, must be at least 250ms. Smaller values may result in \
                    higher system resource usage."
    )]
    pub(crate) rate: Option<StringOrNum>,

    #[arg(
        long,
        value_name = "TIME",
        help = "How far back data will be stored up to.",
        long_help = "How far back data will be stored up to. Either a number in milliseconds or a 'human duration' \
                    (e.g. 10m, 1h). Defaults to 10 minutes, and must be at least  1 minute. Larger values \
                    may result in higher memory usage."
    )]
    pub(crate) retention: Option<StringOrNum>,

    #[arg(long, help = "Show the current item entry position for table widgets.")]
    pub(crate) show_table_scroll_position: Option<bool>,

    #[arg(
        short = 'd',
        long,
        value_name = "TIME",
        help = "The amount of time changed upon zooming.",
        long_help = "How much time the x-axis shifts by each time you zoom in or out. Either a number in milliseconds \
                    or a 'human duration' (e.g. 15s, 1m). Defaults to 15 seconds."
    )]
    pub(crate) time_delta: Option<StringOrNum>,
}

impl GeneralArgs {
    pub(crate) fn merge(&mut self, other: &Self) {
        set_if_some!(autohide_time, self, other);
        set_if_some!(basic, self, other);
        set_if_some!(config_location, self, other);
        set_if_some!(default_time_value, self, other);
        set_if_some!(default_widget_count, self, other);
        set_if_some!(default_widget_type<