132 lines
3.4 KiB
Rust
132 lines
3.4 KiB
Rust
// TODO: An actual proper command line parsing
|
|
use indoc::indoc;
|
|
|
|
const VERSION: &str = env!("CARGO_PKG_VERSION");
|
|
|
|
fn usage() {
|
|
println!(indoc! {"
|
|
usage: fwd [--version] (<server> | browse <url>)
|
|
|
|
To connect a client to a server that has an `fwd` installed in its path, run
|
|
`fwd <server>` on the client, where <server> is the name of the server to
|
|
connect to.
|
|
|
|
On a server that already has a client connected to it you can use `fwd browse
|
|
<url>` to open `<url>` in the default browser of the client.
|
|
"});
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
enum Args {
|
|
Help,
|
|
Version,
|
|
Server,
|
|
Client(String),
|
|
Browse(String),
|
|
Error,
|
|
}
|
|
|
|
fn parse_args(args: Vec<String>) -> Args {
|
|
// Look for help; allow it to come anywhere because sometimes you just
|
|
// want to jam it on the end of an existing command line.
|
|
for arg in &args {
|
|
if arg == "--help" || arg == "-?" || arg == "-h" {
|
|
return Args::Help;
|
|
}
|
|
}
|
|
|
|
// No help, parse for reals.
|
|
if args.len() >= 2 && args[1] == "--version" {
|
|
Args::Version
|
|
} else if args.len() == 2 && &args[1] == "--server" {
|
|
Args::Server
|
|
} else if args.len() == 3 && args[1] == "browse" {
|
|
Args::Browse(args[2].to_string())
|
|
} else {
|
|
if args.len() != 2 {
|
|
Args::Error
|
|
} else {
|
|
Args::Client(args[1].to_string())
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
match parse_args(std::env::args().collect()) {
|
|
Args::Help => {
|
|
usage();
|
|
}
|
|
Args::Version => {
|
|
println!("fwd {VERSION}");
|
|
}
|
|
Args::Server => {
|
|
fwd::run_server().await;
|
|
}
|
|
Args::Browse(url) => {
|
|
fwd::browse_url(&url).await;
|
|
}
|
|
Args::Client(server) => {
|
|
fwd::run_client(&server).await;
|
|
}
|
|
Args::Error => {
|
|
usage();
|
|
std::process::exit(1);
|
|
}
|
|
};
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use assert_matches::assert_matches;
|
|
|
|
// Goldarn it.
|
|
fn args(x: &[&str]) -> Vec<String> {
|
|
let mut vec: Vec<String> =
|
|
x.into_iter().map(|a| a.to_string()).collect();
|
|
vec.insert(0, "fwd".to_string());
|
|
vec
|
|
}
|
|
|
|
macro_rules! assert_arg_parse {
|
|
( $x:expr, $p:pat ) => {
|
|
assert_matches!(parse_args(args($x)), $p)
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn help() {
|
|
assert_arg_parse!(&["--help"], Args::Help);
|
|
assert_arg_parse!(&["browse", "--help"], Args::Help);
|
|
assert_arg_parse!(&["foo.com", "--help"], Args::Help);
|
|
assert_arg_parse!(&["--help", "foo.com"], Args::Help);
|
|
assert_arg_parse!(&["browse", "-?"], Args::Help);
|
|
assert_arg_parse!(&["foo.com", "-h"], Args::Help);
|
|
}
|
|
|
|
#[test]
|
|
fn errors() {
|
|
assert_arg_parse!(&[], Args::Error);
|
|
assert_arg_parse!(&["browse", "google.com", "what"], Args::Error);
|
|
assert_arg_parse!(&["a", "b"], Args::Error);
|
|
assert_arg_parse!(&["--server", "something"], Args::Error);
|
|
}
|
|
|
|
#[test]
|
|
fn client() {
|
|
assert_arg_parse!(&["foo.com"], Args::Client(_));
|
|
assert_arg_parse!(&["a"], Args::Client(_));
|
|
assert_arg_parse!(&["browse"], Args::Client(_));
|
|
}
|
|
|
|
#[test]
|
|
fn server() {
|
|
assert_arg_parse!(&["--server"], Args::Server);
|
|
}
|
|
|
|
#[test]
|
|
fn browse() {
|
|
assert_arg_parse!(&["browse", "google.com"], Args::Browse(_));
|
|
}
|
|
}
|