use std::collections::TryReserveError;
use std::env;
use std::fs;
use std::io::{self, Write};
use std::path::PathBuf;
use crate::color::{Color, ColorSupport, ResolvedColor, parse_color};
#[derive(Debug, Clone)]
pub struct ClientConfig {
pub status_bar: StatusBarConfig,
pub remember_sessions: bool,
}
impl Default for ClientConfig {
fn default() -> Self {
ClientConfig {
status_bar: StatusBarConfig::default(),
remember_sessions: true,
}
}
}
#[derive(Debug, Clone)]
pub struct StatusBarConfig {
pub connected_format: String,
pub local_format: String,
pub fg: Option<Color>,
pub bg: Option<Color>,
pub reverse: bool,
}
impl Default for StatusBarConfig {
fn default() -> Self {
StatusBarConfig {
connected_format:
"{fill}[ {uri}{security} ]{fill}[ {scroll} {focus} ]{fill}[ {help} ]{fill}".into(),
local_format: "{fill}[ dustnet ]{fill}[ {scroll} {focus} ]{fill}[ {help} ]{fill}"
.into(),
fg: Some(Color::Rgb {
r: 0x88,
g: 0x88,
b: 0x88,
}),
bg: Some(Color::Rgb { r: 0, g: 0, b: 0 }),
reverse: false,
}
}
}
#[derive(Default)]
pub struct StatusBarVars {
pub uri: String,
pub title: String,
pub scroll: String,
pub focus: String,
pub security: String,
pub help: String,
pub mem: String,
}
pub fn expand_format(format: &str, vars: &StatusBarVars) -> String {
expand_format_width(format, vars, 0)
}
pub fn expand_format_width(format: &str, vars: &StatusBarVars, term_width: u16) -> String {
try_expand_format_width(format, vars, term_width).unwrap_or_default()
}
pub fn try_expand_format_width(
format: &str,
vars: &StatusBarVars,
term_width: u16,
) -> Result<String, TryReserveError> {
let mut parts: Vec<String> = Vec::new();
parts.try_reserve(format.len().saturating_add(1))?;
let mut fill_count = 0usize;
let mut chars = format.chars().peekable();
let mut current = String::new();
while let Some(ch) = chars.next() {
if ch == '{' {
let mut name = String::new();
let mut found_close = false;
for inner in chars.by_ref() {
if inner == '}' {
found_close = true;
break;
}
name.try_reserve(inner.len_utf8())?;
name.push(inner);
}
if found_close {
match name.as_str() {
"fill" => {
parts.push(std::mem::take(&mut current));
let mut fill = String::new();
fill.try_reserve_exact("{fill}".len())?;
fill.push_str("{fill}");
parts.push(fill);
fill_count += 1;
}
"uri" => try_push_str(&mut current, &vars.uri)?,
"title" => try_push_str(&mut current, &vars.title)?,
"scroll" => try_push_str(&mut current, &vars.scroll)?,
"focus" => try_push_str(&mut current, &vars.focus)?,
"security" => try_push_str(&mut current, &vars.security)?,
"help" => try_push_str(&mut current, &vars.help)?,
"mem" => try_push_str(&mut current, &vars.mem)?,
_ => {
current.try_reserve(name.len().saturating_add(2))?;
current.push('{');
current.push_str(&name);
current.push('}');
}
}
} else {
current.try_reserve(name.len().saturating_add(1))?;
current.push('{');
current.push_str(&name);
}
} else {
current.try_reserve(ch.len_utf8())?;
current.push(ch);
}
}
parts.push(current);
if fill_count == 0 || term_width == 0 {
return try_join_parts(&parts, 0);
}
let fixed_width: usize = parts
.iter()
.filter(|p| *p != "{fill}")
.map(|p| visible_width_without_ansi(p))
.sum();
let remaining = (term_width as usize).saturating_sub(fixed_width);
let per_fill = remaining / fill_count.max(1);
try_join_parts(&parts, per_fill)
}
fn try_push_str(output: &mut String, value: &str) -> Result<(), TryReserveError> {
output.try_reserve(value.len())?;
output.push_str(value);
Ok(())
}
fn try_join_parts(parts: &[String], fill_width: usize) -> Result<String, TryReserveError> {
let fill_bytes = fill_width.saturating_mul("─".len());
let bytes = parts
.iter()
.try_fold(0usize, |total, part| {
total.checked_add(if part == "{fill}" {
fill_bytes
} else {
part.len()
})
})
.unwrap_or(usize::MAX);
let mut output = String::new();
output.try_reserve_exact(bytes)?;
for part in parts {
if part == "{fill}" {
for _ in 0..fill_width {
output.push('─');
}
} else {
output.push_str(part);
}
}
Ok(output)
}
fn visible_width_without_ansi(value: &str) -> usize {
let mut width = 0usize;
let mut visible_start = 0usize;
let mut chars = value.char_indices().peekable();
while let Some((index, ch)) = chars.next() {
if ch == '\x1b' {
width = width.saturating_add(unicode_width::UnicodeWidthStr::width(
&value[visible_start..index],
));
let mut escape_end = index + ch.len_utf8();
if let Some((bracket_index, _)) = chars.next_if(|(_, next)| *next == '[') {
escape_end = bracket_index + 1;
for (inner_index, inner) in chars.by_ref() {
escape_end = inner_index + inner.len_utf8();
if inner.is_ascii_alphabetic() || inner == 'm' {
break;
}
}
}
visible_start = escape_end;
}
}
width.saturating_add(unicode_width::UnicodeWidthStr::width(
&value[visible_start..],
))
}
pub fn status_bar_sgr(config: &StatusBarConfig, color_support: ColorSupport) -> (String, String) {
if config.reverse && config.fg.is_none() && config.bg.is_none() {
return ("\x1b[7m".into(), "\x1b[0m".into());
}
let mut params = Vec::new();
if let Some(ref fg) = config.fg
&& let Some(resolved) = fg.resolve(color_support)
{
match resolved {
ResolvedColor::Named(n) => params.push(n.fg_sgr().to_string()),
ResolvedColor::Palette(idx) => params.push(format!("38;5;{idx}")),
ResolvedColor::Rgb(r, g, b) => params.push(format!("38;2;{r};{g};{b}")),
}
}
if let Some(ref bg) = config.bg
&& let Some(resolved) = bg.resolve(color_support)
{
match resolved {
ResolvedColor::Named(n) => params.push(n.bg_sgr().to_string()),
ResolvedColor::Palette(idx) => params.push(format!("48;5;{idx}")),
ResolvedColor::Rgb(r, g, b) => params.push(format!("48;2;{r};{g};{b}")),
}
}
if config.reverse {
params.push("7".into());
}
if params.is_empty() {
("\x1b[7m".into(), "\x1b[0m".into())
} else {
(format!("\x1b[{}m", params.join(";")), "\x1b[0m".into())
}
}
pub fn write_status_bar_sgr(
out: &mut impl Write,
config: &StatusBarConfig,
color_support: ColorSupport,
) -> io::Result<()> {
if config.reverse && config.fg.is_none() && config.bg.is_none() {
return out.write_all(b"\x1b[7m");
}
out.write_all(b"\x1b[")?;
let mut first = true;
macro_rules! parameter {
($($arg:tt)*) => {{
if !first { out.write_all(b";")?; }
first = false;
write!(out, $($arg)*)?;
}};
}
if let Some(resolved) = config
.fg
.as_ref()
.and_then(|color| color.resolve(color_support))
{
match resolved {
ResolvedColor::Named(color) => parameter!("{}", color.fg_sgr()),
ResolvedColor::Palette(index) => parameter!("38;5;{index}"),
ResolvedColor::Rgb(red, green, blue) => parameter!("38;2;{red};{green};{blue}"),
}
}
if let Some(resolved) = config
.bg
.as_ref()
.and_then(|color| color.resolve(color_support))
{
match resolved {
ResolvedColor::Named(color) => parameter!("{}", color.bg_sgr()),
ResolvedColor::Palette(index) => parameter!("48;5;{index}"),
ResolvedColor::Rgb(red, green, blue) => parameter!("48;2;{red};{green};{blue}"),
}
}
if config.reverse {
parameter!("7");
}
if first {
out.write_all(b"7")?;
}
out.write_all(b"m")
}
fn config_path() -> Option<PathBuf> {
let config_dir = if let Ok(xdg) = env::var("XDG_CONFIG_HOME") {
PathBuf::from(xdg)
} else {
let home = env::var("HOME").ok()?;
PathBuf::from(home).join(".config")
};
Some(config_dir.join("dustnet").join("client.conf"))
}
pub fn load_config() -> ClientConfig {
let mut config = ClientConfig::default();
if let Some(path) = config_path()
&& let Ok(contents) = fs::read_to_string(&path)
{
apply_config_file(&mut config, &contents);
}
if let Ok(val) = env::var("DUSTNET_STATUS_FORMAT") {
config.status_bar.connected_format = val;
}
if let Ok(val) = env::var("DUSTNET_STATUS_LOCAL_FORMAT") {
config.status_bar.local_format = val;
}
if let Ok(val) = env::var("DUSTNET_STATUS_FG")
&& let Ok(color) = parse_color(&val)
{
config.status_bar.fg = Some(color);
config.status_bar.reverse = false;
}
if let Ok(val) = env::var("DUSTNET_STATUS_BG")
&& let Ok(color) = parse_color(&val)
{
config.status_bar.bg = Some(color);
config.status_bar.reverse = false;
}
if let Ok(val) = env::var("DUSTNET_REMEMBER_SESSIONS") {
config.remember_sessions = truthy(&val);
}
config
}
fn truthy(value: &str) -> bool {
value == "true" || value == "yes" || value == "1"
}
fn apply_config_file(config: &mut ClientConfig, contents: &str) {
for line in contents.lines() {
let line = line.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
if let Some((key, value)) = line.split_once('=') {
let key = key.trim();
let value = value.trim();
match key {
"status-format" => {
config.status_bar.connected_format = value.to_string();
}
"status-local-format" => {
config.status_bar.local_format = value.to_string();
}
"status-fg" => {
if let Ok(color) = parse_color(value) {
config.status_bar.fg = Some(color);
config.status_bar.reverse = false;
}
}
"status-bg" => {
if let Ok(color) = parse_color(value) {
config.status_bar.bg = Some(color);
config.status_bar.reverse = false;
}
}
"status-reverse" => {
config.status_bar.reverse = truthy(value);
}
"remember-sessions" => {
config.remember_sessions = truthy(value);
}
_ => {
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn remember_sessions_is_on_until_the_config_turns_it_off() {
let mut config = ClientConfig::default();
assert!(
config.remember_sessions,
"logging in once should last by default"
);
for value in ["false", "no", "0"] {
let mut config = ClientConfig::default();
apply_config_file(&mut config, &format!("remember-sessions = {value}\n"));
assert!(!config.remember_sessions, "`{value}` should disable it");
}
for value in ["true", "yes", "1"] {
let mut config = ClientConfig {
remember_sessions: false,
..ClientConfig::default()
};
apply_config_file(&mut config, &format!("remember-sessions = {value}\n"));
assert!(config.remember_sessions, "`{value}` should enable it");
}
apply_config_file(
&mut config,
"# remember-sessions = false\nstatus-reverse = true\n",
);
assert!(config.remember_sessions);
}
#[test]
fn expand_mem_variable() {
let vars = StatusBarVars {
mem: "1.1M".into(),
..Default::default()
};
assert_eq!(expand_format("[{mem}]", &vars), "[1.1M]");
assert_eq!(expand_format("[{mem}]", &StatusBarVars::default()), "[]");
}
#[test]
fn fill_width_treats_joined_emoji_as_one_grapheme() {
let vars = StatusBarVars {
title: "👩💻".into(),
..StatusBarVars::default()
};
assert_eq!(expand_format_width("{title}{fill}", &vars, 4), "👩💻──");
}
#[test]
fn expand_all_variables() {
let vars = StatusBarVars {
uri: "atp://example.com/".into(),
title: "Home".into(),
scroll: "42%".into(),
focus: "[1/3]".into(),
security: "".into(),
help: ":q quit".into(),
mem: String::new(),
};
let result = expand_format(" {uri} {title} {scroll} {focus} {help}", &vars);
assert_eq!(result, " atp://example.com/ Home 42% [1/3] :q quit");
}
#[test]
fn expand_empty_variables() {
let vars = StatusBarVars {
uri: "atp://x/".into(),
title: "".into(),
scroll: "".into(),
focus: "".into(),
security: "".into(),
help: ":q quit".into(),
mem: String::new(),
};
let result = expand_format(" {uri}{security} {scroll}{focus} | {help}", &vars);
assert_eq!(result, " atp://x/ | :q quit");
}
#[test]
fn expand_unknown_variable_passthrough() {
let vars = StatusBarVars {
uri: "".into(),
title: "".into(),
scroll: "".into(),
focus: "".into(),
security: "".into(),
help: "".into(),
mem: String::new(),
};
let result = expand_format("{unknown} text", &vars);
assert_eq!(result, "{unknown} text");
}
#[test]
fn expand_unclosed_brace() {
let vars = StatusBarVars {
uri: "x".into(),
title: "".into(),
scroll: "".into(),
focus: "".into(),
security: "".into(),
help: "".into(),
mem: String::new(),
};
let result = expand_format("{uri} {oops", &vars);
assert_eq!(result, "x {oops");
}
#[test]
fn expand_literal_only() {
let vars = StatusBarVars {
uri: "".into(),
title: "".into(),
scroll: "".into(),
focus: "".into(),
security: "".into(),
help: "".into(),
mem: String::new(),
};
let result = expand_format(" dustnet | q quit ", &vars);
assert_eq!(result, " dustnet | q quit ");
}
#[test]
fn config_file_parsing() {
let mut config = ClientConfig::default();
let contents = r#"
# Status bar config
status-format = {title} | {uri} {scroll}
status-fg = cyan
status-bg = #1a1a2e
status-reverse = false
"#;
apply_config_file(&mut config, contents);
assert_eq!(
config.status_bar.connected_format,
"{title} | {uri} {scroll}"
);
assert_eq!(
config.status_bar.fg,
Some(Color::Named(crate::color::NamedColor::Cyan))
);
assert_eq!(
config.status_bar.bg,
Some(Color::Rgb {
r: 0x1a,
g: 0x1a,
b: 0x2e
})
);
assert!(!config.status_bar.reverse);
}
#[test]
fn config_file_skips_unknown_keys() {
let mut config = ClientConfig::default();
apply_config_file(&mut config, "unknown-key = whatever\n");
assert_eq!(
config.status_bar.connected_format,
StatusBarConfig::default().connected_format
);
}
#[test]
fn default_status_bar_sgr_names_both_colours() {
let config = StatusBarConfig::default();
let (open, close) = status_bar_sgr(&config, ColorSupport::Truecolor);
assert_eq!(open, "\x1b[38;2;136;136;136;48;2;0;0;0m");
assert_eq!(close, "\x1b[0m");
let mut direct = Vec::new();
write_status_bar_sgr(&mut direct, &config, ColorSupport::Truecolor).unwrap();
assert_eq!(direct, open.as_bytes());
}
#[test]
fn reverse_is_still_available() {
let config = StatusBarConfig {
reverse: true,
fg: None,
bg: None,
..StatusBarConfig::default()
};
let (open, _) = status_bar_sgr(&config, ColorSupport::Truecolor);
assert_eq!(open, "\x1b[7m");
}
#[test]
fn the_default_connected_format_reports_transport_security() {
let config = StatusBarConfig::default();
assert!(
config.connected_format.contains("{security}"),
"default status bar drops the transport indicator: {}",
config.connected_format
);
let vars = StatusBarVars {
uri: "atp://example.com/".into(),
security: "pinned".into(),
..StatusBarVars::default()
};
let rendered = expand_format(&config.connected_format, &vars);
assert!(
rendered.contains("pinned"),
"the indicator is in the format but not the output: {rendered}"
);
}
#[test]
fn custom_colors_sgr() {
let config = StatusBarConfig {
fg: Some(Color::Named(crate::color::NamedColor::White)),
bg: Some(Color::Named(crate::color::NamedColor::Blue)),
reverse: false,
..StatusBarConfig::default()
};
let (open, _close) = status_bar_sgr(&config, ColorSupport::Basic);
assert!(open.contains("37")); assert!(open.contains("44")); let mut direct = Vec::new();
write_status_bar_sgr(&mut direct, &config, ColorSupport::Basic).unwrap();
assert_eq!(direct, open.as_bytes());
}
#[test]
fn reverse_with_colors_sgr() {
let config = StatusBarConfig {
fg: Some(Color::Named(crate::color::NamedColor::Cyan)),
bg: None,
reverse: true,
..StatusBarConfig::default()
};
let (open, _) = status_bar_sgr(&config, ColorSupport::Basic);
assert!(open.contains("36")); assert!(open.contains("7")); }
}