From a55053dc97b3dc336e88cdc66527e672ee397eb3 Mon Sep 17 00:00:00 2001 From: deadvey Date: Thu, 14 May 2026 15:31:48 +0100 Subject: [PATCH] Clippy lint fixing --- server/Cargo.toml | 13 ++++++++++++ server/src/api.rs | 10 ++++----- server/src/character.rs | 8 +++---- server/src/main.rs | 44 +++++++++++++++++++------------------- server/src/parsing.rs | 47 ++++++++++++++++++++--------------------- 5 files changed, 67 insertions(+), 55 deletions(-) diff --git a/server/Cargo.toml b/server/Cargo.toml index 6ecc799..43f666a 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -3,6 +3,19 @@ name = "happening-server" version = "0.1.0" edition = "2024" +[lints.clippy] +cargo = { level = "warn", priority = -1 } +multiple_crate_versions = { level = "allow" } + +correctness = { level = "deny", priority = -1 } +nursery = { level = "deny", priority = -1 } +option_if_let_else = { level = "allow" } + +pedantic = { level = "deny", priority = -1 } +perf = { level = "deny", priority = -1 } +style = { level = "deny", priority = -1 } +unwrap_used = "deny" + [dependencies] env_logger = "0.11.10" log = "0.4.29" diff --git a/server/src/api.rs b/server/src/api.rs index d142709..f38b73a 100644 --- a/server/src/api.rs +++ b/server/src/api.rs @@ -49,7 +49,7 @@ pub async fn api_process // Perform this code on a GET request .map(|state: Arc>, tx_handle: Sender<(bool,usize)>| { - debug!("GET: {:?}", state); + debug!("GET: {state:?}"); let reply = state.as_ref(); let _ = tx_handle.send((true,0)); warp::reply::json(&reply) // Send the reply data (data_to_send formatted as JSON) @@ -60,9 +60,9 @@ pub async fn api_process .and(characters_filter) .map(|name: String, characters: Arc>>| { - let map = characters.lock().unwrap(); // TODO remove unwrap - let reply = map.get(&name).unwrap(); - debug!("GET: name: {}", name); + let map = characters.lock().unwrap(); // TODO eh + let reply = map.get(&name).unwrap(); // TODO eh + debug!("GET: name: {name}"); warp::reply::json(&reply) }).boxed(); let choice = warp::path("choice") @@ -70,7 +70,7 @@ pub async fn api_process .and(warp::body::json()) .and(tx_filter2) .map(|index: usize, tx_handle: Sender<(bool,usize)>| { - debug!("Choice: {}", index); + debug!("Choice: {index}"); let _ = tx_handle.send((true,index)); let reply = "ack"; warp::reply::json(&reply) diff --git a/server/src/character.rs b/server/src/character.rs index d7603bf..2fd8e8e 100644 --- a/server/src/character.rs +++ b/server/src/character.rs @@ -32,20 +32,20 @@ pub struct Character shoes: String, } -pub async fn character_parse(archive: &mut ZipArchive) +pub fn character_parse(archive: &mut ZipArchive) -> Result>>,String> { // Get the JSON file to a string let mut characters_file = archive.by_name("characters.json") - .map_err (|err| format!("Unable to read story file: {}",err))?; + .map_err (|err| format!("Unable to read story file: {err}"))?; let mut file_contents = String::new(); characters_file.read_to_string(&mut file_contents) - .map_err (|err| format!("Unable to read story file to string: {}",err))?; + .map_err (|err| format!("Unable to read story file to string: {err}"))?; // Serialise this to a HashMap let characters: HashMap = serde_json::from_str(&file_contents) .expect("JSON was not well-formatted"); - debug!("{:?}",characters); + debug!("{characters:?}"); Ok(Arc::new(Mutex::new(characters))) } diff --git a/server/src/main.rs b/server/src/main.rs index 7313434..cad2003 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -1,5 +1,6 @@ use std:: { + process::exit, env::args, fs::File, io::Read, @@ -28,7 +29,6 @@ mod character; mod config; mod api; -#[warn(clippy::all, clippy::pedantic)] #[tokio::main] async fn main() { @@ -41,38 +41,38 @@ async fn main() .unwrap_or_else (|| { error!("No filename specified"); - std::process::exit(5); + exit(5); }); - let file = File::open(format!("../stories/{}",file_name)) + let file = File::open(format!("../stories/{file_name}")) .unwrap_or_else (|err| { - error!("Failed to open file: {}", err); - std::process::exit(2); + error!("Failed to open file: {err}"); + exit(2); }); let mut archive = ZipArchive::new(file) .unwrap_or_else (|err| { - error!("Failed to open archive: {}", err); - std::process::exit(3); + error!("Failed to open archive: {err}"); + exit(3); }); // Setup the characters hashmap which will store each character in it as a Character struct - let characters = match character::character_parse(&mut archive).await + let characters = match character::character_parse(&mut archive) { Ok(result) => { - debug!("{:?}", result); + debug!("{result:?}"); result }, Err(error) => { - error!("{}",error); - std::process::exit(3); + error!("{error}"); + exit(3); }, }; // Initialise the data strcut that will be sent out during API GET requests let data_to_send = Arc::new(Mutex::new(api::DataToSend { - action_type: "begin".to_string(), + action_type: "begin".to_owned(), content: String::new(), character: String::new(), choices: vec![], @@ -83,7 +83,7 @@ async fn main() // Make clones of the data Arc for the two processes let data_clone1 = Arc::clone(&data_to_send); let characters_clone1 = Arc::clone(&characters); - let tx_clone = tx.clone(); + let tx_clone = tx; // Spawn a thread for warp api server tokio::spawn( async move { @@ -97,15 +97,15 @@ async fn main() let mut story_file = archive.by_name("story.ha") .unwrap_or_else (|err| { - error!("Unable to read story file: {}",err); - std::process::exit(4); + error!("Unable to read story file: {err}"); + exit(4); }); let mut file_contents = String::new(); story_file.read_to_string(&mut file_contents) .unwrap_or_else (|err| { - error!("Unable to read story file to string: {}",err); - std::process::exit(5); + error!("Unable to read story file to string: {err}"); + exit(5); }); // Tokenise story file let tokens: Vec<&str> = file_contents @@ -115,12 +115,12 @@ async fn main() { warn!("No END statement, story may exit unexpectedly"); } - debug!("{:?}", tokens); + debug!("{tokens:?}"); let data_clone2 = Arc::clone(&data_to_send); let characters_clone2 = Arc::clone(&characters); // Run the parsing process for the DSL - match parsing::token_parse(&tokens, characters_clone2, data_clone2, &rx).await + match parsing::token_parse(&tokens, characters_clone2, &data_clone2, &rx) { // Exit with error or success Ok(()) => @@ -133,12 +133,12 @@ async fn main() // Manually unlock the mutex std::mem::drop(data); let _ = rx.recv(); // Wait for the client to respond - std::process::exit(0); + exit(0); }, Err(error) => { - error!("{}", error); - std::process::exit(1); + error!("{error}"); + exit(1); }, } } diff --git a/server/src/parsing.rs b/server/src/parsing.rs index 3acfa8f..d8888c7 100644 --- a/server/src/parsing.rs +++ b/server/src/parsing.rs @@ -18,10 +18,10 @@ use crate:: // Parse the tokens in a file // Returns success or an error string -pub async fn token_parse( +pub fn token_parse( tokens: &Vec<&str>, characters: Arc>>, - data_to_send: Arc>, + data_to_send: &Arc>, rx: &Receiver<(bool,usize)>, ) -> Result<(),String> { @@ -31,7 +31,7 @@ pub async fn token_parse( { warn!("Some issue with api"); // TOD eh? - }; + } info!("Client has connected"); // Run an infinite loop 'parse_loop: loop @@ -40,14 +40,14 @@ pub async fn token_parse( let token = tokens .get(index) .ok_or_else(|| "File unexpectedly reached termination point".to_string())?; - debug!("{}: {}",index, token); + debug!("{index}: {token}"); // The instructions are related to characters if token.starts_with('@') { let character_name: String = token.chars().skip(1).collect(); - debug!("Doing something with a character: {}", character_name); + debug!("Doing something with a character: {character_name}"); // The index is incremented to after the character's instructions - index = match character_parse(index+1, tokens, character_name, &characters, &data_to_send).await + index = match character_parse(index+1, tokens, character_name, &characters, &data_to_send) { Ok(increment) => increment, Err(error) => return Err(error), @@ -65,7 +65,7 @@ pub async fn token_parse( }, "choice" => { - let (_,jump_points) = match choice_parse(index+1, tokens, &data_to_send).await + let (_,jump_points) = match choice_parse(index+1, tokens, &data_to_send) { Ok((increment,jump_point)) => (increment,jump_point), Err(error) => return Err(error), @@ -76,13 +76,13 @@ pub async fn token_parse( Ok((_,choice)) => (None::, choice), Err(err) => { - warn!("Error receiving choice from client, defaulting to choice 0 {}", err); + warn!("Error receiving choice from client, defaulting to choice 0 {err}"); (None::, 0) } }; index = jump_points[choice]; - info!("CHOICE command with {} choices", jump_points.len()); - debug!("{:?} {} {}",jump_points, choice, index); + info!("CHOICE command with {} choices",jump_points.len()); + debug!("{jump_points:?} {choice} {index}"); continue 'parse_loop }, "or" => @@ -91,7 +91,7 @@ pub async fn token_parse( index += match strings::closing_char(&tokens[index..], '{','}') // TODO eh { Ok(index) => index, - Err(_) => return Err(String::from("Unable to find closing brace to OR command")), + Err(()) => return Err(String::from("Unable to find closing brace to OR command")), }; continue }, @@ -102,20 +102,19 @@ pub async fn token_parse( }, _ => { - warn!("Invalid command: {}", token); + warn!("Invalid command: {token}"); } - }; + } } if rx.recv().is_err() { warn!("Some issue with api"); - continue } } } // Parse the options in a choice clause and returns the idexes of the code blocks -async fn choice_parse +fn choice_parse ( index: usize, tokens: &[&str], @@ -141,18 +140,19 @@ async fn choice_parse choice_indeces.push(sum_index+2); sum_index += strings::closing_char(&tokens[sum_index..], '{','}').unwrap() + 1; //TODO eh } - debug!("{:?}", choices); + debug!("{choices:?}"); let mut data = data_to_send.lock().unwrap(); data.action_type = String::from("choice"); - data.content = "".to_string(); - data.character = "".to_string(); + data.content = String::new(); + data.character = String::new(); data.choices = choices; //TODO Ok((sum_index + 1, choice_indeces)) } // Parsing character related instructions // TODO only send relevant tokens -#[allow(unused_variables)] async fn character_parse +#[allow(unused_variables)] +fn character_parse ( index: usize, tokens: &Vec<&str>, @@ -172,18 +172,17 @@ async fn choice_parse // to the client "says" => { - info!("SAYS command with character {}", character_name); + info!("SAYS command with character {character_name}"); match strings::extract_quoted(&tokens[sum_index+1..]) // TODO increment to after the string { Some((output_string, counter)) => { - debug!("{}", output_string); + debug!("{output_string}"); sum_index += counter; - debug!("{}",sum_index); let mut data = data_to_send.lock().unwrap(); data.action_type = String::from("output"); data.content = output_string; - data.character = character_name.clone(); + data.character = character_name; data.choices = vec![]; }, None => return Err(String::from("Unable to read string")), @@ -191,7 +190,7 @@ async fn choice_parse }, // Catch all condition, if the instruction is unrecognised as a // character command - _ => return Err(format!("Invalid command: {}", token)), + _ => return Err(format!("Invalid command: {token}")), } sum_index += 1; Ok(sum_index)