#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TabName {
Mesh,
Account,
Share,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Command {
Price(f64),
Workers(u32),
Share(bool),
Refresh,
Copy(String),
Quit,
Tab(TabName),
External(Vec<String>),
}
pub const NATIVE: &[&str] = &[
"account", "copy", "mesh", "price", "quit", "refresh", "share", "workers",
];
pub const EXTERNAL: &[&str] = &[
"brokers",
"connect",
"credits",
"deployments",
"disconnect",
"down",
"info",
"init",
"join",
"login",
"me",
"status",
"token",
"up",
"update",
"whoami",
];
pub fn parse(line: &str) -> Result<Command, String> {
let words: Vec<&str> = line.split_whitespace().collect();
let Some(&verb) = words.first() else {
return Err(String::new());
};
if words.iter().any(|w| {
w.chars()
.any(|c| matches!(c, ';' | '|' | '&' | '`' | '$' | '>' | '<'))
}) {
return Err(format!("unknown command `{verb}` — ? lists them"));
}
let arg = words.get(1).copied();
match verb {
"price" => match arg.and_then(|a| a.parse::<f64>().ok()) {
Some(p) if p > 0.0 && words.len() == 2 => Ok(Command::Price(p)),
_ => Err("usage: price <credits per hour>".into()),
},
"workers" => match arg.and_then(|a| a.parse::<u32>().ok()) {
Some(n) if words.len() == 2 => Ok(Command::Workers(n)),
_ => Err("usage: workers <count>".into()),
},
"share" => match arg {
None => Ok(Command::Tab(TabName::Share)),
Some("on") => Ok(Command::Share(true)),
Some("off") => Ok(Command::Share(false)),
Some(_) => Err("usage: share [on|off]".into()),
},
"mesh" => Ok(Command::Tab(TabName::Mesh)),
"account" => Ok(Command::Tab(TabName::Account)),
"refresh" | "r" => Ok(Command::Refresh),
"quit" | "q" => Ok(Command::Quit),
"copy" => match arg {
Some(a) => Ok(Command::Copy(a.to_string())),
None => Err("usage: copy <zc://…>".into()),
},
v if EXTERNAL.contains(&v) => Ok(Command::External(
words.iter().map(|w| w.to_string()).collect(),
)),
other => Err(format!("unknown command `{other}` — ? lists them")),
}
}
#[derive(Debug, Clone, Default)]
pub struct Completions {
pub addresses: Vec<String>,
}
pub fn complete(line: &str, c: &Completions) -> Vec<String> {
let mut out: Vec<String> = match line.split_once(' ') {
None => NATIVE
.iter()
.chain(EXTERNAL)
.filter(|w| w.starts_with(line))
.map(|w| w.to_string())
.collect(),
Some((verb, rest)) => {
let options: Vec<String> = match verb {
"share" => vec!["on".into(), "off".into()],
"copy" => c.addresses.clone(),
_ => vec![],
};
options
.into_iter()
.filter(|o| o.starts_with(rest.trim_start()))
.map(|o| format!("{verb} {o}"))
.collect()
}
};
out.sort();
out.dedup();
out
}
#[derive(Debug, Clone, Default, PartialEq)]
pub struct CommandBar {
pub input: String,
pub hist_idx: Option<usize>,
pub matches: Vec<String>,
}
impl CommandBar {
pub fn new() -> Self {
Self::default()
}
pub fn tab(&mut self, c: &Completions) {
let found = complete(&self.input, c);
match found.len() {
0 => self.matches.clear(),
1 => {
self.input = format!("{} ", found[0]);
self.matches.clear();
}
_ => {
let mut prefix = found[0].clone();
for f in &found[1..] {
while !f.starts_with(&prefix) {
prefix.pop();
}
}
if prefix.len() > self.input.len() {
self.input = prefix;
}
self.matches = found;
}
}
}
pub fn history_up(&mut self, history: &[String]) {
if history.is_empty() {
return;
}
let i = match self.hist_idx {
None => history.len() - 1,
Some(i) => i.saturating_sub(1),
};
self.hist_idx = Some(i);
self.input = history[i].clone();
}
pub fn history_down(&mut self, history: &[String]) {
match self.hist_idx {
Some(i) if i + 1 < history.len() => {
self.hist_idx = Some(i + 1);
self.input = history[i + 1].clone();
}
_ => {
self.hist_idx = None;
self.input.clear();
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn native_commands_parse_with_their_arguments() {
assert_eq!(parse("price 22"), Ok(Command::Price(22.0)));
assert_eq!(parse(" workers 3 "), Ok(Command::Workers(3)));
assert_eq!(parse("share on"), Ok(Command::Share(true)));
assert_eq!(parse("share off"), Ok(Command::Share(false)));
assert_eq!(parse("share"), Ok(Command::Tab(TabName::Share)));
assert_eq!(parse("mesh"), Ok(Command::Tab(TabName::Mesh)));
assert_eq!(parse("refresh"), Ok(Command::Refresh));
assert_eq!(parse("q"), Ok(Command::Quit));
assert_eq!(
parse("copy zc://node-ab"),
Ok(Command::Copy("zc://node-ab".into()))
);
}
#[test]
fn bad_arguments_say_how_to_use_the_command() {
assert!(parse("price").unwrap_err().contains("usage: price"));
assert!(parse("price -1").unwrap_err().contains("usage: price"));
assert!(parse("workers many")
.unwrap_err()
.contains("usage: workers"));
assert!(parse("share maybe").unwrap_err().contains("usage: share"));
}
#[test]
fn known_zc_verbs_run_outside_the_session() {
assert_eq!(
parse("connect --native"),
Ok(Command::External(vec!["connect".into(), "--native".into()]))
);
assert_eq!(
parse("update"),
Ok(Command::External(vec!["update".into()]))
);
}
#[test]
fn unknown_and_shellish_input_is_rejected() {
assert!(parse("rm -rf /")
.unwrap_err()
.contains("unknown command `rm`"));
assert!(parse("; ls").unwrap_err().contains("unknown command"));
assert!(parse("connect; rm x")
.unwrap_err()
.contains("unknown command"));
assert_eq!(parse(" "), Err(String::new()));
}
#[test]
fn completion_offers_commands_then_arguments() {
let c = Completions {
addresses: vec!["zc://node-aaaa".into(), "zc://node-abcd".into()],
};
assert_eq!(complete("pr", &c), vec!["price".to_string()]);
assert!(complete("", &c).len() > 5);
assert_eq!(
complete("share o", &c),
vec!["share off".to_string(), "share on".to_string()]
);
assert_eq!(
complete("copy zc://node-ab", &c),
vec!["copy zc://node-abcd".to_string()]
);
}
#[test]
fn tab_fills_a_single_match_or_the_common_prefix() {
let c = Completions { addresses: vec![] };
let mut bar = CommandBar::new();
bar.input = "ref".into();
bar.tab(&c);
assert_eq!(bar.input, "refresh ");
bar.input = "di".into();
bar.tab(&c);
assert_eq!(bar.input, "disconnect ");
bar.input = "d".into();
bar.tab(&c);
assert_eq!(bar.input, "d"); assert!(bar.matches.len() >= 3);
}
#[test]
fn history_walks_back_and_forward() {
let h = vec!["price 18".to_string(), "workers 2".to_string()];
let mut bar = CommandBar::new();
bar.history_up(&h);
assert_eq!(bar.input, "workers 2");
bar.history_up(&h);
assert_eq!(bar.input, "price 18");
bar.history_up(&h);
assert_eq!(bar.input, "price 18");
bar.history_down(&h);
assert_eq!(bar.input, "workers 2");
bar.history_down(&h);
assert_eq!(bar.input, "");
}
}