fix: optimistic programming and add anyhow

Cargo.lock

@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 4
 
-[[package]]
-name = "aho-corasick"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.102"
@@ -103,10 +94,10 @@ dependencies = [
 name = "button"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "axum",
  "futures",
  "rand 0.10.1",
- "regex",
  "serde",
  "serde_json",
  "tokio",
@@ -677,35 +668,6 @@ dependencies = [
  "bitflags",
 ]
 
-[[package]]
-name = "regex"
-version = "1.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
-
 [[package]]
 name = "ryu"
 version = "1.0.23"

Cargo.toml

@@ -4,11 +4,31 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+anyhow = "1.0.102"
 axum = { version = "0.8.9", features = ["ws"] }
 futures = "0.3.32"
 rand = "0.10.1"
-regex = "1.12.3"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
 tokio = { version = "1.52.3", features = ["full"] }
 tower-http = { version = "0.6.11", features = ["fs"] }
+
+[profile.release]
+codegen-units = 1
+opt-level = 3
+lto = true
+strip = "symbols"
+panic = "abort"
+
+[lints.clippy]
+cargo = { level = "warn", priority = -1 }
+correctness = { level = "deny", priority = -1 }
+nursery = { level = "deny", priority = -1 }
+option_if_let_else = { level = "allow" }
+cargo_common_metadata = "allow"
+multiple_crate_versions = "allow"
+
+pedantic = { level = "deny", priority = -1 }
+perf = { level = "deny", priority = -1 }
+style = { level = "deny", priority = -1 }
+unwrap_used = "deny"

rustfmt.toml

@@ -0,0 +1 @@
+hard_tabs = true

src/main.rs

@@ -1,95 +1,135 @@
+use std::{
+	collections::HashMap,
+	fs,
+	io::Write,
+	ops::{Deref, DerefMut},
+	sync::Arc,
+};
+
 use axum::{
-	extract::ws::{Message, WebSocket, WebSocketUpgrade},
+	Router,
+	extract::{
+		State,
+		ws::{Message, WebSocket, WebSocketUpgrade},
+	},
 	response::{Html, IntoResponse},
 	routing::get,
-	Router,
 };
-use std::collections::HashMap;
+use futures::StreamExt as _;
-use axum::extract::State;
 use rand::random_bool;
-use futures::stream::StreamExt;
+use serde::{Deserialize, Serialize, de};
-use serde_json;
 use serde_json::json;
-use serde::{Deserialize, Serialize};
+use tokio::{
-use std::fs;
+	sync::{Mutex, mpsc},
-use std::io::Write;
+	time::{Duration, sleep},
-use std::sync::mpsc;
+};
-use std::sync::{Mutex, Arc};
-use tokio::time::{sleep,Duration};
-use regex::Regex;
 
 #[derive(Deserialize, Serialize, Debug, Ord, Eq, PartialEq, PartialOrd, Clone)]
-struct Entry
+struct Entry {
-{
 	score: u32,
 	person: String,
 }
-enum Leaderboard
-{
-	Hiscores,
-	Loscores,
-	Pingscores,
-}
 
 #[derive(Clone)]
 struct AppState {
-	tx: mpsc::Sender<(Entry,Leaderboard)>,
+	tx: mpsc::Sender<LeaderboardUpdate>,
 	hiscores: Arc<Mutex<Vec<Entry>>>,
 	loscores: Arc<Mutex<Vec<Entry>>>,
 	pingscores: Arc<Mutex<HashMap<String, (u64, u32)>>>, // u64 is reset count and u32 is PB
 }
 
-static CHANCE: f64 = 1.0/3.0;
+struct LeaderboardUpdate {
+	name: Arc<str>,
+	update: LeaderboardUpdateType,
+}
+
+enum LeaderboardUpdateType {
+	Reset { hiscore_pingscore: u32 },
+	Increment { loscore: u32 },
+}
+
+const CHANCE: f64 = 1.0 / 3.0;
+
+const PATH_HISCORES: &str = "hiscores.json";
+const PATH_LOSCORES: &str = "loscores.json";
+const PATH_PINGSCORES: &str = "pingscores.json";
+
+const MAX_LEADERBOARD: usize = 20;
 
 #[tokio::main]
-async fn main() {
+async fn main() -> anyhow::Result<()> {
-	let file_contents: String = fs::read_to_string("hiscores.json").unwrap();
+	fn read_file<T: for<'de> de::Deserialize<'de>>(
-	let hiscores: Arc<Mutex<Vec<Entry>>> = Arc::new(Mutex::new(serde_json::from_str(&file_contents).unwrap()));
+		file_path: &str,
-	let file_contents: String = fs::read_to_string("loscores.json").unwrap();
+	) -> anyhow::Result<Arc<Mutex<T>>> {
-	let loscores: Arc<Mutex<Vec<Entry>>> = Arc::new(Mutex::new(serde_json::from_str(&file_contents).unwrap()));
+		let file_contents: String = fs::read_to_string(file_path)?;
-	let file_contents: String = fs::read_to_string("pingscores.json").unwrap();
+		Ok(Arc::new(Mutex::new(serde_json::from_str(&file_contents)?)))
-	let pingscores: Arc<Mutex<HashMap<String,(u64,u32)>>> = Arc::new(Mutex::new(serde_json::from_str(&file_contents).unwrap()));
-	let hiscore_clone1 = Arc::clone(&hiscores);
-	let loscore_clone1 = Arc::clone(&loscores);
-	let pingscore_clone1 = Arc::clone(&pingscores);
-
-	let (tx, rx) = mpsc::channel::<(Entry,Leaderboard)>();
-
-	tokio::spawn(
-		async move {
-			handle_hiscores(rx, hiscore_clone1, loscore_clone1, pingscore_clone1);
 	}
-	);
+
-	let pingscore_clone2 = Arc::clone(&pingscores);
+	/// Makes the vector at `vec` one with a capacity of exactly [`MAX_LEADERBOARD`] if `vec` is
-	tokio::spawn(
+	/// smaller or equal.
-		async move {
+	fn exact_leaderboard<T>(mut vec: impl DerefMut<Target = Vec<T>>) {
-			loop // write pingscores every 30s
+		let old_vec = std::mem::replace(&mut *vec, Vec::with_capacity(MAX_LEADERBOARD));
+		for e in old_vec {
+			vec.push(e);
+		}
+	}
+
+	let hiscores: Arc<Mutex<Vec<Entry>>> = read_file(PATH_HISCORES)?;
+	exact_leaderboard(hiscores.lock().await);
+	let loscores: Arc<Mutex<Vec<Entry>>> = read_file(PATH_LOSCORES)?;
+	exact_leaderboard(loscores.lock().await);
+	let pingscores: Arc<Mutex<HashMap<String, (u64, u32)>>> = read_file(PATH_PINGSCORES)?;
+
+	let (tx, rx) = mpsc::channel::<LeaderboardUpdate>(1024);
+
 	{
-				sleep(Duration::from_millis(30000)).await;
+		let (hiscores, loscores, pingscores) =
-				let pingscores = pingscore_clone2.lock().unwrap();
+			(hiscores.clone(), loscores.clone(), pingscores.clone());
-				let file_contents: String = serde_json::to_string(&pingscores.clone()).unwrap();
+		tokio::spawn(async move {
+			handle_hiscores(rx, &hiscores, &loscores, &pingscores).await;
+		});
+	}
+
+	{
+		let pingscores = pingscores.clone();
+		tokio::spawn(async move {
+			// write pingscores every 30s
+			loop {
+				sleep(Duration::from_secs(30)).await;
+				let pingscores = pingscores.lock().await;
+				let file_contents: String = serde_json::to_string(&pingscores.clone())
+					.expect("failed to serialize pingscores");
 				drop(pingscores);
-				let mut file = fs::OpenOptions::new().write(true).truncate(true).open("pingscores.json").unwrap();
+				let mut file = fs::OpenOptions::new()
-				file.write_all(file_contents.as_bytes()).unwrap();
+					.write(true)
-				file.flush().unwrap();
+					.truncate(true)
+					.open(PATH_PINGSCORES)
+					.expect("failed to open pingscores file");
+				file.write_all(file_contents.as_bytes())
+					.expect("failed to write pingscores");
+				drop(file);
+			}
+		});
 	}
-		}
-	);
 
-	let state = AppState { tx,hiscores: Arc::clone(&hiscores),loscores: Arc::clone(&loscores), pingscores: Arc::clone(&pingscores)};
 	let app = Router::new()
 		.route("/", get(index))
 		.route("/ws", get(ws_handler))
 		.route("/leaderboard", get(leaderboard))
-		.with_state(state);
+		.with_state(AppState {
+			tx,
+			hiscores: Arc::clone(&hiscores),
+			loscores: Arc::clone(&loscores),
+			pingscores: Arc::clone(&pingscores),
+		});
 
-	let listener = tokio::net::TcpListener::bind("0.0.0.0:8084")
+	let listener = tokio::net::TcpListener::bind("0.0.0.0:8084").await?;
-		.await
-		.unwrap();
 
 	println!("http://0.0.0.0:8084");
 
-	axum::serve(listener, app).await.unwrap();
+	axum::serve(listener, app).await?;
+
+	Ok(())
 }
 
 async fn index() -> Html<&'static str> {
@@ -100,128 +140,188 @@ async fn leaderboard() -> Html<&'static str> {
 	Html(include_str!("../leaderboard.html"))
 }
 // receiver: 0 for hiscore, 1 for loscore, 2 for pingscore
-fn handle_hiscores(rx: mpsc::Receiver<(Entry, Leaderboard)>, hiscores_arc: Arc<Mutex<Vec<Entry>>>, loscores_arc: Arc<Mutex<Vec<Entry>>>,pingscores_arc: Arc<Mutex<HashMap<String,(u64,u32)>>>,) 
+async fn handle_hiscores(
-{
+	mut rx: mpsc::Receiver<LeaderboardUpdate>,
+	hiscores: &Mutex<Vec<Entry>>,
+	loscores: &Mutex<Vec<Entry>>,
+	pingscores: &Mutex<HashMap<String, (u64, u32)>>,
+) {
+	fn update_scoretable<G: Deref<Target = Vec<Entry>> + DerefMut>(
+		score_name: &str,
+		mut scoretable_lock: G,
+		name: &str,
+		score: u32,
+		file_path: &str,
+	) -> anyhow::Result<()> {
+		let scoretable = &mut *scoretable_lock;
+
+		if let Some(index_to_insert_at) = scoretable.iter().position(|e| score > e.score) {
+			println!("New {score_name} {score} by {name}");
+			scoretable[index_to_insert_at..].rotate_right(1);
+			let push_out = std::mem::replace(
+				&mut scoretable[index_to_insert_at],
+				Entry {
+					score,
+					person: name.to_string(),
+				},
+			);
+			if scoretable.len() < MAX_LEADERBOARD {
+				scoretable.push(push_out);
+			}
+
+			let file_contents: String = serde_json::to_string(&*scoretable_lock)?;
+			drop(scoretable_lock);
+			let mut file = fs::OpenOptions::new()
+				.write(true)
+				.truncate(true)
+				.open(file_path)?;
+			file.write_all(file_contents.as_bytes())?;
+			file.flush()?;
+		} else if scoretable.len() < MAX_LEADERBOARD {
+			println!("New {score_name} {score} by {name}");
+			scoretable.push(Entry {
+				score,
+				person: name.to_string(),
+			});
+		}
+
+		Ok(())
+	}
+
 	// Panic galore
-	let mut hiscores = hiscores_arc.lock().unwrap();
+	let mut hiscores_lock = hiscores.lock().await;
-	hiscores.sort();
+	hiscores_lock.sort();
-	hiscores.reverse();
+	hiscores_lock.reverse();
-	let file_contents: String = serde_json::to_string(&hiscores.clone()).unwrap();
+	let file_contents: String =
-	drop(hiscores);
+		serde_json::to_string(&hiscores_lock.clone()).expect("failed to serialize hiscores");
-	let mut file = fs::OpenOptions::new().write(true).truncate(true).open("hiscores.json").unwrap();
+	drop(hiscores_lock);
-	file.write_all(file_contents.as_bytes()).unwrap();
+	let mut file = fs::OpenOptions::new()
-	file.flush().unwrap();
+		.write(true)
-	loop
+		.truncate(true)
-	{
+		.open(PATH_HISCORES)
-		match rx.recv()
+		.expect("failed to open hiscores");
-		{
+	file.write_all(file_contents.as_bytes())
-			Ok((new_entry,Leaderboard::Hiscores)) =>
+		.expect("failed to write hiscores");
-			{
+	drop(file);
-				let mut hiscores = hiscores_arc.lock().unwrap();
+
-				if new_entry.score > hiscores[19].score {
+	loop {
-					println!("New hiscore {new_entry:?}");
+		let LeaderboardUpdate { name, update } = rx.recv().await.expect("channel error");
-					hiscores.push(new_entry);
+
-					hiscores.sort();
+		match update {
-					hiscores.reverse();
+			LeaderboardUpdateType::Reset { hiscore_pingscore } => {
-					hiscores.truncate(20);
+				// Hiscore
-					let file_contents: String = serde_json::to_string(&hiscores.clone()).unwrap();
+				update_scoretable(
-					drop(hiscores);
+					"hiscore",
-					let mut file = fs::OpenOptions::new().write(true).truncate(true).open("hiscores.json").unwrap();
+					hiscores.lock().await,
-					file.write_all(file_contents.as_bytes()).unwrap();
+					&name,
-					file.flush().unwrap();
+					hiscore_pingscore,
+					PATH_HISCORES,
+				)
+				.expect("failed to update hiscores");
+
+				// Pingscore
+				let mut pingscores = pingscores.lock().await;
+				// pb
+				if hiscore_pingscore > pingscores.get(&*name).unwrap_or(&(0, 0)).1 {
+					pingscores.entry(name.to_string()).or_insert((0, 0)).1 = hiscore_pingscore;
+					println!("{name} new PB: {hiscore_pingscore}");
 				}
-			},
+				pingscores.entry(name.to_string()).or_insert((0, 0)).0 += 1; // reset count
-			Ok((new_entry,Leaderboard::Loscores)) =>
-			{
-				let mut loscores = loscores_arc.lock().unwrap();
-				if new_entry.score > loscores[19].score {
-					println!("New loscore {new_entry:?}");
-					loscores.push(new_entry);
-					loscores.sort();
-					loscores.reverse();
-					loscores.truncate(20);
-					let file_contents: String = serde_json::to_string(&loscores.clone()).unwrap();
-					drop(loscores);
-					let mut file = fs::OpenOptions::new().write(true).truncate(true).open("loscores.json").unwrap();
-					file.write_all(file_contents.as_bytes()).unwrap();
-					file.flush().unwrap();
-				}
-			},
-			Ok((new_entry,Leaderboard::Pingscores)) =>
-			{
-				let name = new_entry.person;
-				let mut pingscores = pingscores_arc.lock().unwrap();
-				if new_entry.score > pingscores.get(&name).unwrap_or(&(0,0)).1 // pb
-				{
-					pingscores.entry(name.clone()).or_insert((0,0)).1 = new_entry.score;
-					println!("{name} new PB: {}",new_entry.score);
-				};
-				pingscores.entry(name.clone()).or_insert((0,0)).0 += 1; // reset count
 				drop(pingscores);
 			}
-			Err(error) => println!("{error}"),
+
+			LeaderboardUpdateType::Increment { loscore } => {
+				update_scoretable(
+					"loscore",
+					loscores.lock().await,
+					&name,
+					loscore,
+					PATH_LOSCORES,
+				)
+				.expect("failed to update loscores");
+			}
 		}
 	}
 }
 
-async fn ws_handler(
+async fn ws_handler(ws: WebSocketUpgrade, State(state): State<AppState>) -> impl IntoResponse {
-	ws: WebSocketUpgrade,
+	ws.on_upgrade(|socket| async move {
-	State(state): State<AppState>,
+		handle_socket(
-) -> impl IntoResponse {
+			socket,
-	ws.on_upgrade(move |socket| {
+			&state.tx,
-		let tx = state.tx.clone();
+			&state.hiscores,
-		let hiscores = Arc::clone(&state.hiscores);
+			&state.loscores,
-		let loscores = Arc::clone(&state.loscores);
+			&state.pingscores,
-		let pingscores = Arc::clone(&state.pingscores);
+		)
-		async move {
+		.await;
-			handle_socket(socket, tx, hiscores, loscores, pingscores).await;
-		}
 	})
 }
 
-async fn handle_socket
+async fn handle_socket(
-(
 	mut socket: WebSocket,
-	tx: mpsc::Sender<(Entry,Leaderboard)>,
+	tx: &mpsc::Sender<LeaderboardUpdate>,
-	hiscores_arc: Arc<Mutex<Vec<Entry>>>,
+	hiscores: &Mutex<Vec<Entry>>,
-	loscores_arc: Arc<Mutex<Vec<Entry>>>,
+	loscores: &Mutex<Vec<Entry>>,
-	pingscores_arc: Arc<Mutex<HashMap<String,(u64,u32)>>>,
+	pingscores: &Mutex<HashMap<String, (u64, u32)>>,
 ) {
 	let mut value: u32 = 0;
-	let msg = 
+
-	{
+	let msg = {
-		let hiscores = hiscores_arc.lock().unwrap();
+		json!({
-		let loscores = loscores_arc.lock().unwrap();
+			"hiscores": &*hiscores.lock().await,
-		let pingscores = pingscores_arc.lock().unwrap();
+			"loscores": &*loscores.lock().await,
-		json!({ "hiscores": &*hiscores, "loscores": &*loscores, "pingscores": &*pingscores}).to_string()
+			"pingscores": &*pingscores.lock().await
+		})
+		.to_string()
 	};
-	let name_message = socket.next().await.unwrap().unwrap();
+
-	let name: String = match name_message 
+	let Some(name) = socket.next().await else {
-	{
+		eprintln!("user gave no username");
-		Message::Text(text) => validate_name(text.to_string()),
+		return;
-		_ => "anon".to_string(),
 	};
+	let name: Arc<str> = match name.expect("failed to recv socket msg") {
+		Message::Text(text)
+			if let text = text.to_string()
+				&& validate_name(&text) =>
+		{
+			Arc::from(text.into_boxed_str())
+		}
+		_ => Arc::from("anon"),
+	};
+
 	println!("Client connected: {name}");
+
 	let mut resets: u32 = 0;
 	let mut prev: u32 = 0;
 
-	let _ = socket
+	let _ = socket.send(Message::Text(msg.into())).await;
-		.send(Message::Text(msg.into()))
-		.await;
 
 	while let Some(msg) = socket.next().await {
 		match msg {
 			Ok(Message::Text(_)) => {
-				if random_bool(CHANCE) { // reset
+				if random_bool(CHANCE) {
-					let _ = tx.send((Entry{ person: name.clone(), score: value },Leaderboard::Hiscores)); //hiscores
+					// reset
-					let _ = tx.send((Entry{ person: name.clone(), score: value },Leaderboard::Pingscores)); //pingscores
+					let _ = tx
+						.send(LeaderboardUpdate {
+							name: name.clone(),
+							update: LeaderboardUpdateType::Reset {
+								hiscore_pingscore: value,
+							},
+						})
+						.await;
 					resets += 1;
-					value = 0
+					value = 0;
-				} // 1/3 chance of failing
+				}
+				// 1/3 chance of failing
 				else {
 					value += 1;
 					if prev == 0 {
-						let _ = tx.send((Entry{ person: name.clone(), score: resets },Leaderboard::Loscores));//loscores
+						let _ = tx
+							.send(LeaderboardUpdate {
+								name: name.clone(),
+								update: LeaderboardUpdateType::Increment { loscore: resets },
+							})
+							.await;
 						resets = 0;
 					}
 				}
@@ -238,25 +338,13 @@ async fn handle_socket
 	}
 }
 
-
+fn validate_name(input: &str) -> bool {
-fn validate_name(input: String) -> String {
 	let input = input.trim();
-    if input == "null"
+
-    {
-        return "anon".to_string();
-    }
 	// Length check
 	if input.is_empty() || input.len() > 32 {
-		return "anon".to_string();
+		return false;
 	}
 
-	// Allow only letters, numbers, _ and -
+	input.chars().all(|c| c.is_ascii_alphanumeric())
-	let re = Regex::new(r"^[a-zA-Z0-9_-]+$").unwrap();
-
-	if re.is_match(input) {
-		input.to_string()
-	} else {
-		"anon".to_string()
 }
-}
-