+205

src/cli.rs

··· 1 1 + use std::{ 2 2 + error::Error, 3 3 + fmt::Display, 4 4 + net::{AddrParseError, SocketAddr}, 5 5 + path::PathBuf, 6 6 + }; 7 7 + 8 8 + #[derive(Debug, PartialEq, Eq)] 9 9 + pub enum Args { 10 10 + Help, 11 11 + Host { boats: PathBuf, addr: SocketAddr }, 12 12 + Join { boats: PathBuf, addr: SocketAddr }, 13 13 + } 14 14 + 15 15 + #[derive(Debug, PartialEq, Eq)] 16 16 + pub enum ArgsParseError { 17 17 + NotEnoughArguments, 18 18 + InvalidMode(String), 19 19 + InvalidAddr(AddrParseError), 20 20 + } 21 21 + 22 22 + impl Error for ArgsParseError { 23 23 + fn source(&self) -> Option<&(dyn Error + 'static)> { 24 24 + match self { 25 25 + ArgsParseError::NotEnoughArguments => None, 26 26 + ArgsParseError::InvalidMode(_) => None, 27 27 + ArgsParseError::InvalidAddr(e) => Some(e), 28 28 + } 29 29 + } 30 30 + } 31 31 + 32 32 + impl Display for ArgsParseError { 33 33 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 34 34 + match self { 35 35 + ArgsParseError::NotEnoughArguments => write!(f, "not enough arguments"), 36 36 + ArgsParseError::InvalidMode(mode) => write!(f, "invalid mode: '{mode}'"), 37 37 + ArgsParseError::InvalidAddr(e) => write!(f, "error parsing address: {e}"), 38 38 + } 39 39 + } 40 40 + } 41 41 + 42 42 + impl Args { 43 43 + pub fn parse<S: AsRef<str>>(iter: impl IntoIterator<Item = S>) -> Result<Self, ArgsParseError> { 44 44 + let mut iter = iter.into_iter(); 45 45 + let Some(arg) = iter.next() else { 46 46 + return Ok(Self::Help); 47 47 + }; 48 48 + 49 49 + if matches!(arg.as_ref(), "-h" | "--help") { 50 50 + return Ok(Self::Help); 51 51 + } 52 52 + 53 53 + let boats = PathBuf::from(arg.as_ref()); 54 54 + let arg = iter.next().ok_or(ArgsParseError::NotEnoughArguments)?; 55 55 + 56 56 + let addr = iter 57 57 + .next() 58 58 + .ok_or(ArgsParseError::NotEnoughArguments)? 59 59 + .as_ref() 60 60 + .parse::<SocketAddr>() 61 61 + .map_err(ArgsParseError::InvalidAddr)?; 62 62 + 63 63 + match arg.as_ref() { 64 64 + "host" => Ok(Self::Host { boats, addr }), 65 65 + "join" => Ok(Self::Join { boats, addr }), 66 66 + a => Err(ArgsParseError::InvalidMode(a.to_string())), 67 67 + } 68 68 + } 69 69 + 70 70 + pub fn print_help(arg0: &str) { 71 71 + println!("Battleship game!"); 72 72 + println!(); 73 73 + println!("Usage:"); 74 74 + println!(" {arg0} [-h|--help]"); 75 75 + println!(" \tPrint help information and exit."); 76 76 + println!(" {arg0} <BOATS_FILE> host <ADDRESS>:<PORT>"); 77 77 + println!(" \tHost a game. Use 127.0.0.1 for a local"); 78 78 + println!(" \t game. Use 0.0.0.0 to make it joinable by"); 79 79 + println!(" \t other hosts. IPv6 is also supported!"); 80 80 + println!(" {arg0} <BOATS_FILE> join <ADDRESS>:<PORT>"); 81 81 + println!(" \tJoin a game. IPv4 and IPv6 are supported!"); 82 82 + } 83 83 + } 84 84 + 85 85 + #[cfg(test)] 86 86 + mod tests { 87 87 + use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; 88 88 + 89 89 + use super::*; 90 90 + 91 91 + #[test] 92 92 + fn parse_nothing() { 93 93 + assert_eq!(Args::parse::<String>([]), Ok(Args::Help)); 94 94 + } 95 95 + 96 96 + #[test] 97 97 + fn parse_help() { 98 98 + assert_eq!(Args::parse(["-h"]), Ok(Args::Help)); 99 99 + assert_eq!(Args::parse(["--help"]), Ok(Args::Help)); 100 100 + } 101 101 + 102 102 + #[test] 103 103 + fn parse_host() { 104 104 + assert_eq!( 105 105 + Args::parse(["./my_boats", "host", "127.0.0.1:8080"]), 106 106 + Ok(Args::Host { 107 107 + boats: "./my_boats".into(), 108 108 + addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8080), 109 109 + }) 110 110 + ); 111 111 + assert_eq!( 112 112 + Args::parse(["./my_boats", "host", "0.0.0.0:8080"]), 113 113 + Ok(Args::Host { 114 114 + boats: "./my_boats".into(), 115 115 + addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 8080), 116 116 + }) 117 117 + ); 118 118 + assert_eq!( 119 119 + Args::parse(["./my_boats", "host", "[::1]:8080"]), 120 120 + Ok(Args::Host { 121 121 + boats: "./my_boats".into(), 122 122 + addr: SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 8080), 123 123 + }) 124 124 + ); 125 125 + assert_eq!( 126 126 + Args::parse(["./my_boats", "host", "[::]:8080"]), 127 127 + Ok(Args::Host { 128 128 + boats: "./my_boats".into(), 129 129 + addr: SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 8080), 130 130 + }) 131 131 + ); 132 132 + } 133 133 + 134 134 + #[test] 135 135 + fn parse_join() { 136 136 + assert_eq!( 137 137 + Args::parse(["./my_boats", "join", "127.0.0.1:8080"]), 138 138 + Ok(Args::Join { 139 139 + boats: "./my_boats".into(), 140 140 + addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8080), 141 141 + }) 142 142 + ); 143 143 + assert_eq!( 144 144 + Args::parse(["./my_boats", "join", "0.0.0.0:8080"]), 145 145 + Ok(Args::Join { 146 146 + boats: "./my_boats".into(), 147 147 + addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 8080), 148 148 + }) 149 149 + ); 150 150 + assert_eq!( 151 151 + Args::parse(["./my_boats", "join", "[::1]:8080"]), 152 152 + Ok(Args::Join { 153 153 + boats: "./my_boats".into(), 154 154 + addr: SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 8080), 155 155 + }) 156 156 + ); 157 157 + assert_eq!( 158 158 + Args::parse(["./my_boats", "join", "[::]:8080"]), 159 159 + Ok(Args::Join { 160 160 + boats: "./my_boats".into(), 161 161 + addr: SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 8080), 162 162 + }) 163 163 + ); 164 164 + } 165 165 + 166 166 + #[test] 167 167 + fn parse_errors() { 168 168 + assert_eq!( 169 169 + Args::parse(["abcoabcuobacwa"]), 170 170 + Err(ArgsParseError::NotEnoughArguments) 171 171 + ); 172 172 + assert_eq!( 173 173 + Args::parse(["./my_boats", "foobar"]), 174 174 + Err(ArgsParseError::NotEnoughArguments) 175 175 + ); 176 176 + assert_eq!( 177 177 + Args::parse(["./my_boats", "foobar", "127.0.0.1:8080"]), 178 178 + Err(ArgsParseError::InvalidMode("foobar".into())) 179 179 + ); 180 180 + assert!(matches!( 181 181 + Args::parse(["./my_boats", "host", "blablabla"]), 182 182 + Err(ArgsParseError::InvalidAddr(_)) 183 183 + )); 184 184 + assert!(matches!( 185 185 + Args::parse(["./my_boats", "host", "localhost"]), 186 186 + Err(ArgsParseError::InvalidAddr(_)) 187 187 + )); 188 188 + assert!(matches!( 189 189 + Args::parse(["./my_boats", "host", "0.0.0.0"]), 190 190 + Err(ArgsParseError::InvalidAddr(_)) 191 191 + )); 192 192 + assert!(matches!( 193 193 + Args::parse(["./my_boats", "join", "127.0.0.1"]), 194 194 + Err(ArgsParseError::InvalidAddr(_)) 195 195 + )); 196 196 + assert!(matches!( 197 197 + Args::parse(["./my_boats", "join", "localhost"]), 198 198 + Err(ArgsParseError::InvalidAddr(_)) 199 199 + )); 200 200 + assert!(matches!( 201 201 + Args::parse(["./my_boats", "join", "localhost:8080"]), 202 202 + Err(ArgsParseError::InvalidAddr(_)) 203 203 + )); 204 204 + } 205 205 + }

+24 -2

src/main.rs

··· 1 1 - fn main() { 2 2 - println!("Hello, world!"); 1 1 + use std::process::ExitCode; 2 2 + 3 3 + mod cli; 4 4 + 5 5 + fn main() -> ExitCode { 6 6 + let mut args = std::env::args(); 7 7 + let arg0 = args.next(); 8 8 + let args = match cli::Args::parse(args) { 9 9 + Err(e) => { 10 10 + eprintln!("Invalid arguments: {e}"); 11 11 + return ExitCode::FAILURE; 12 12 + } 13 13 + Ok(args) => args, 14 14 + }; 15 15 + 16 16 + eprintln!("Parsed arguments: {args:#?}"); 17 17 + 18 18 + match args { 19 19 + cli::Args::Help => cli::Args::print_help(arg0.as_deref().unwrap_or("navy")), 20 20 + cli::Args::Host { .. } => todo!(), 21 21 + cli::Args::Join { .. } => todo!(), 22 22 + } 23 23 + 24 24 + ExitCode::SUCCESS 3 25 }