perf: reduce allocations across hot paths

Algorithm5838 · Algorithm5838 · commit 6e96738fed09 · 2026-04-26T23:24:12.000+03:00
diff --git a/src/client.rs b/src/client.rs
@@ -66,6 +66,44 @@ pub fn build_client() -> WreqClient {
 		.expect("Should always be able to build a client")
 }
 
+/// Convert a wreq Response into a hyper Response<Body>.
+/// This bridge lets the rest of the codebase stay unchanged.
+trait IntoHyperResponse {
+	async fn into_hyper(self) -> Result<Response<Body>, String>;
+}
+
+impl IntoHyperResponse for wreq::Response {
+	async fn into_hyper(self) -> Result<Response<Body>, String> {
+		// wreq uses http v1.x; hyper uses http v0.2.x. Convert via primitives.
+		let status_u16 = self.status().as_u16();
+		let status = hyper::StatusCode::from_u16(status_u16).map_err(|e| e.to_string())?;
+
+		// Snapshot headers before consuming self (bytes() moves self).
+		// Use SmallVec-style stack storage: most responses have < 32 headers.
+		let mut builder = hyper::Response::builder().status(status);
+		for (k, v) in self.headers() {
+			// Skip headers that hyper rejects (e.g. non-ASCII bytes in CDN headers)
+			// rather than aborting the entire response.
+			if let (Ok(key), Ok(val)) = (
+				hyper::header::HeaderName::from_bytes(k.as_str().as_bytes()),
+				hyper::header::HeaderValue::from_bytes(v.as_bytes()),
+			) {
+				builder = builder.header(key, val);
+			}
+		}
+
+		let bytes = self.bytes().await.map_err(|e| e.to_string())?;
+		// wreq already decompresses; remove the content-encoding header so
+		// downstream code doesn't try to decompress again.
+		if let Some(h) = builder.headers_mut() {
+			h.remove(header::CONTENT_ENCODING);
+			h.insert(header::CONTENT_LENGTH, bytes.len().into());
+		}
+
+		builder.body(Body::from(bytes)).map_err(|e| e.to_string())
+	}
+}
+
 /// Gets the canonical path for a resource on Reddit. This is accomplished by
 /// making a `HEAD` request to Reddit at the path given in `path`.
 ///
diff --git a/src/post.rs b/src/post.rs
@@ -4,12 +4,12 @@ use crate::config::get_setting;
 use crate::server::RequestExt;
 use crate::subreddit::{can_access_quarantine, quarantine};
 use crate::utils::{
-	error, format_num, get_filters, nsfw_landing, param, parse_post, rewrite_emotes, setting, template, time, val, Author, Awards, Comment, Flair, FlairPart, Post, Preferences,
+	error, format_num, nsfw_landing, param, parse_post, rewrite_emotes, setting, template, time, val, Author, Awards, Comment, Flair, FlairPart, Post, Preferences,
 };
 use askama::Template;
 use hyper::{Body, Request, Response};
 use regex::Regex;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
 use std::sync::LazyLock;
 
 // STRUCTS
@@ -76,13 +76,13 @@ pub async fn item(req: Request<Body>) -> Result<Response<Body>, String> {
 				None => String::new(),
 			};
 
-			let query_string = format!("q={query_body}&type=comment");
-			let form = url::form_urlencoded::parse(query_string.as_bytes()).collect::<HashMap<_, _>>();
-			let query = form.get("q").unwrap().clone().to_string();
+			let query = query_body;
 
+			let prefs = Preferences::new(&req);
+			let filters: HashSet<String> = prefs.filters.iter().cloned().collect();
 			let comments = match query.as_str() {
-				"" => parse_comments(&response[1], &post.permalink, &post.author.name, highlighted_comment, &get_filters(&req), &req),
-				_ => query_comments(&response[1], &post.permalink, &post.author.name, highlighted_comment, &get_filters(&req), &query, &req),
+				"" => parse_comments(&response[1], &post.permalink, &post.author.name, highlighted_comment, &filters, &req),
+				_ => query_comments(&response[1], &post.permalink, &post.author.name, highlighted_comment, &filters, &query, &req),
 			};
 
 			// Use the Post and Comment structs to generate a website to show users
@@ -91,7 +91,7 @@ pub async fn item(req: Request<Body>) -> Result<Response<Body>, String> {
 				post,
 				url_without_query: url.clone().trim_end_matches(&format!("?q={query}&type=comment")).to_string(),
 				sort,
-				prefs: Preferences::new(&req),
+				prefs,
 				single_thread,
 				url: req_url,
 				comment_query: query,
@@ -170,8 +170,10 @@ fn build_comment(
 	req: &Request<Body>,
 ) -> Comment {
 	let id = val(comment, "id");
+	let comment_author = val(comment, "author");
+	let comment_body = val(comment, "body");
 
-	let body = if (val(comment, "author") == "[deleted]" && val(comment, "body") == "[removed]") || val(comment, "body") == "[ Removed by Reddit ]" {
+	let body = if (comment_author == "[deleted]" && comment_body == "[removed]") || comment_body == "[ Removed by Reddit ]" {
 		format!(
 			"<div class=\"md\"><p>[removed] — <a href=\"https://{}{post_link}{id}\">view removed comment</a></p></div>",
 			get_setting("REDLIB_PUSHSHIFT_FRONTEND").unwrap_or_else(|| String::from(crate::config::DEFAULT_PUSHSHIFT_FRONTEND)),
@@ -203,7 +205,7 @@ fn build_comment(
 	let highlighted = id == highlighted_comment;
 
 	let author = Author {
-		name: val(comment, "author"),
+		name: comment_author,
 		flair: Flair {
 			flair_parts: FlairPart::parse(
 				data["author_flair_type"].as_str().unwrap_or_default(),
diff --git a/src/user.rs b/src/user.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::cmp_owned)]
 use crate::client::json;
 use crate::server::RequestExt;
-use crate::utils::{error, filter_posts, format_url, get_filters, nsfw_landing, param, setting, template, Post, Preferences, User};
+use crate::utils::{error, filter_posts, format_url, nsfw_landing, param, setting, template, Post, Preferences, User};
 use crate::{config, utils};
 use askama::Template;
 use chrono::DateTime;
@@ -60,15 +60,16 @@ pub async fn profile(req: Request<Body>) -> Result<Response<Body>, String> {
 		return Ok(nsfw_landing(req, req_url).await.unwrap_or_default());
 	}
 
-	let filters = get_filters(&req);
+	let prefs = Preferences::new(&req);
+	let filters: std::collections::HashSet<String> = prefs.filters.iter().cloned().collect();
 	if filters.contains(&["u_", &username].concat()) {
 		Ok(template(&UserTemplate {
 			user,
 			posts: Vec::new(),
 			sort: (sort, param(&path, "t").unwrap_or_default()),
 			ends: (param(&path, "after").unwrap_or_default(), String::new()),
 			listing,
-			prefs: Preferences::new(&req),
+			prefs,
 			url,
 			redirect_url,
 			is_filtered: true,
@@ -89,7 +90,7 @@ pub async fn profile(req: Request<Body>) -> Result<Response<Body>, String> {
 					sort: (sort, param(&path, "t").unwrap_or_default()),
 					ends: (param(&path, "after").unwrap_or_default(), after),
 					listing,
-					prefs: Preferences::new(&req),
+					prefs,
 					url,
 					redirect_url,
 					is_filtered: false,
diff --git a/src/utils.rs b/src/utils.rs
@@ -14,10 +14,9 @@ use rust_embed::RustEmbed;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::Value;
 use serde_json_path::{JsonPath, JsonPathExt};
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
 use std::env;
 use std::io::{Read, Write};
-use std::str::FromStr;
 use std::string::ToString;
 use std::sync::LazyLock;
 use time::{macros::format_description, Duration, OffsetDateTime};
@@ -522,22 +521,16 @@ impl std::fmt::Display for Awards {
 impl Awards {
 	/// Convert Reddit awards JSON to Awards struct
 	pub fn parse(items: &Value) -> Self {
-		let parsed = items.as_array().unwrap_or(&Vec::new()).iter().fold(Vec::new(), |mut awards, item| {
-			let name = item["name"].as_str().unwrap_or_default().to_string();
-			let icon_url = format_url(item["resized_icons"][0]["url"].as_str().unwrap_or_default());
-			let description = item["description"].as_str().unwrap_or_default().to_string();
-			let count: i64 = i64::from_str(&item["count"].to_string()).unwrap_or(1);
-
-			awards.push(Award {
-				name,
-				icon_url,
-				description,
-				count,
+		let arr = items.as_array().map(|v| v.as_slice()).unwrap_or_default();
+		let mut parsed = Vec::with_capacity(arr.len());
+		for item in arr {
+			parsed.push(Award {
+				name: item["name"].as_str().unwrap_or_default().to_string(),
+				icon_url: format_url(item["resized_icons"][0]["url"].as_str().unwrap_or_default()),
+				description: item["description"].as_str().unwrap_or_default().to_string(),
+				count: item["count"].as_i64().unwrap_or(1),
 			});
-
-			awards
-		});
-
+		}
 		Self(parsed)
 	}
 }
@@ -896,15 +889,10 @@ pub async fn parse_post(post: &Value) -> Post {
 
 /// Grab a query parameter from a url
 pub fn param(path: &str, value: &str) -> Option<String> {
-	Some(
-		Url::parse(format!("https://libredd.it/{path}").as_str())
-			.ok()?
-			.query_pairs()
-			.into_owned()
-			.collect::<HashMap<_, _>>()
-			.get(value)?
-			.clone(),
-	)
+	let query = path.splitn(2, '?').nth(1).unwrap_or_default();
+	url::form_urlencoded::parse(query.as_bytes())
+		.find(|(k, _)| k == value)
+		.map(|(_, v)| v.into_owned())
 }
 
 /// Retrieve the value of a setting by name
@@ -1092,25 +1080,18 @@ pub fn rewrite_urls(input_text: &str) -> String {
 		// Rewrite Reddit links to Redlib
 		REDDIT_REGEX.replace_all(input_text, r#"href="/"#).to_string();
 
-	loop {
-		if REDDIT_EMOJI_REGEX.find(&text1).is_none() {
-			break;
-		} else {
-			text1 = REDDIT_EMOJI_REGEX
-				.replace_all(&text1, format_url(REDDIT_EMOJI_REGEX.find(&text1).map(|x| x.as_str()).unwrap_or_default()))
-				.to_string()
-		}
-	}
+	text1 = REDDIT_EMOJI_REGEX.replace_all(&text1, |caps: &regex::Captures| format_url(&caps[0])).to_string();
 
 	// Remove (html-encoded) "\" from URLs.
 	text1 = text1.replace("%5C", "").replace("\\_", "_");
 
 	// Rewrite external media previews to Redlib
 	loop {
-		if REDDIT_PREVIEW_REGEX.find(&text1).is_none() {
+		let Some(caps) = REDDIT_PREVIEW_REGEX.captures(&text1) else {
 			return text1;
-		} else {
-			let formatted_url = format_url(REDDIT_PREVIEW_REGEX.find(&text1).map(|x| x.as_str()).unwrap_or_default());
+		};
+		{
+			let formatted_url = format_url(caps.get(0).map_or("", |m| m.as_str()));
 
 			let image_url = REDLIB_PREVIEW_LINK_REGEX.find(&formatted_url).map_or("", |m| m.as_str());
 			let mut image_caption = REDLIB_PREVIEW_TEXT_REGEX.find(&formatted_url).map_or("", |m| m.as_str());
@@ -1139,7 +1120,7 @@ pub fn rewrite_urls(input_text: &str) -> String {
 
 			/* In order to know if we're dealing with a normal or external preview we need to take a look at the first capture group of REDDIT_PREVIEW_REGEX
 			if it's preview we're dealing with something that needs /preview/pre, external-preview is /preview/external-pre, and i is /img */
-			let reddit_preview_regex_capture = REDDIT_PREVIEW_REGEX.captures(&text1).unwrap().get(1).map_or("", |m| m.as_str());
+			let reddit_preview_regex_capture = caps.get(1).map_or("", |m| m.as_str());
 
 			let _preview_type = match reddit_preview_regex_capture {
 				"preview" => "/preview/pre",
@@ -1389,12 +1370,14 @@ pub async fn nsfw_landing(req: Request<Body>, req_url: String) -> Result<Respons
 
 	// Determine from the request URL if the resource is a subreddit, a user
 	// page, or a post.
-	let resource: String = if !req.param("name").unwrap_or_default().is_empty() {
+	let name = req.param("name").unwrap_or_default();
+	let id = req.param("id").unwrap_or_default();
+	let resource: String = if !name.is_empty() {
 		res_type = ResourceType::User;
-		req.param("name").unwrap_or_default()
-	} else if !req.param("id").unwrap_or_default().is_empty() {
+		name
+	} else if !id.is_empty() {
 		res_type = ResourceType::Post;
-		req.param("id").unwrap_or_default()
+		id
 	} else {
 		res_type = ResourceType::Subreddit;
 		req.param("sub").unwrap_or_default()
