Improve additional command outputs containing codeblocks.

Signed-off-by: Jason Volk <jason@zemos.net>

src/admin/appservice/commands.rs

@@ -1,6 +1,6 @@
 use ruma::{api::appservice::Registration, events::room::message::RoomMessageEventContent};
 
-use crate::{escape_html, services, Result};
+use crate::{services, Result};
 
 pub(super) async fn register(body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
@@ -48,12 +48,7 @@ pub(super) async fn show(_body: Vec<&str>, appservice_identifier: String) -> Res
 		Some(config) => {
 			let config_str = serde_yaml::to_string(&config).expect("config should've been validated on register");
 			let output = format!("Config for {appservice_identifier}:\n\n```yaml\n{config_str}\n```",);
-			let output_html = format!(
+			Ok(RoomMessageEventContent::notice_markdown(output))
-				"Config for {}:\n\n<pre><code class=\"language-yaml\">{}</code></pre>",
-				escape_html(&appservice_identifier),
-				escape_html(&config_str),
-			);
-			Ok(RoomMessageEventContent::text_html(output, output_html))
 		},
 		None => Ok(RoomMessageEventContent::text_plain("Appservice does not exist.")),
 	}

src/admin/debug/commands.rs

@@ -8,7 +8,6 @@ use api::client::validate_and_add_event_id;
 use conduit::{
 	debug, info, log,
 	log::{capture, Capture},
-	utils::HtmlEscape,
 	warn, Error, Result,
 };
 use ruma::{
@@ -93,26 +92,15 @@ pub(super) async fn get_pdu(_body: Vec<&str>, event_id: Box<EventId>) -> Result<
 	match pdu_json {
 		Some(json) => {
 			let json_text = serde_json::to_string_pretty(&json).expect("canonical json is valid json");
-			Ok(RoomMessageEventContent::text_html(
+			Ok(RoomMessageEventContent::notice_markdown(format!(
-				format!(
+				"{}\n```json\n{}\n```",
-					"{}\n```json\n{}\n```",
+				if outlier {
-					if outlier {
+					"Outlier PDU found in our database"
-						"Outlier PDU found in our database"
+				} else {
-					} else {
+					"PDU found in our database"
-						"PDU found in our database"
+				},
-					},
+				json_text
-					json_text
+			)))
-				),
-				format!(
-					"<p>{}</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
-					if outlier {
-						"Outlier PDU found in our database"
-					} else {
-						"PDU found in our database"
-					},
-					HtmlEscape(&json_text)
-				),
-			))
 		},
 		None => Ok(RoomMessageEventContent::text_plain("PDU not found locally.")),
 	}
@@ -237,17 +225,10 @@ pub(super) async fn get_remote_pdu(
 
 			let json_text = serde_json::to_string_pretty(&json).expect("canonical json is valid json");
 
-			Ok(RoomMessageEventContent::text_html(
+			Ok(RoomMessageEventContent::notice_markdown(format!(
-				format!(
+				"{}\n```json\n{}\n```",
-					"{}\n```json\n{}\n```",
+				"Got PDU from specified server and handled as backfilled PDU successfully. Event body:", json_text
-					"Got PDU from specified server and handled as backfilled PDU successfully. Event body:", json_text
+			)))
-				),
-				format!(
-					"<p>{}</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
-					"Got PDU from specified server and handled as backfilled PDU successfully. Event body:",
-					HtmlEscape(&json_text)
-				),
-			))
 		},
 		Err(e) => Ok(RoomMessageEventContent::text_plain(format!(
 			"Remote server did not have PDU or failed sending request to remote server: {e}"
@@ -278,14 +259,10 @@ pub(super) async fn get_room_state(_body: Vec<&str>, room_id: Box<RoomId>) -> Re
 		)
 	})?;
 
-	Ok(RoomMessageEventContent::text_html(
+	Ok(RoomMessageEventContent::notice_markdown(format!(
-		format!("{}\n```json\n{}\n```", "Found full room state", json_text),
+		"{}\n```json\n{}\n```",
-		format!(
+		"Found full room state", json_text
-			"<p>{}</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
+	)))
-			"Found full room state",
-			HtmlEscape(&json_text)
-		),
-	))
 }
 
 pub(super) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<RoomMessageEventContent> {
@@ -308,14 +285,9 @@ pub(super) async fn ping(_body: Vec<&str>, server: Box<ServerName>) -> Result<Ro
 			let json_text_res = serde_json::to_string_pretty(&response.server);
 
 			if let Ok(json) = json_text_res {
-				return Ok(RoomMessageEventContent::text_html(
+				return Ok(RoomMessageEventContent::notice_markdown(format!(
-					format!("Got response which took {ping_time:?} time:\n```json\n{json}\n```"),
+					"Got response which took {ping_time:?} time:\n```json\n{json}\n```"
-					format!(
+				)));
-						"<p>Got response which took {ping_time:?} time:</p>\n<pre><code \
-						 class=\"language-json\">{}\n</code></pre>\n",
-						HtmlEscape(&json)
-					),
-				));
 			}
 
 			Ok(RoomMessageEventContent::text_plain(format!(

src/admin/federation/commands.rs

@@ -2,7 +2,7 @@ use std::fmt::Write;
 
 use ruma::{events::room::message::RoomMessageEventContent, OwnedRoomId, RoomId, ServerName, UserId};
 
-use crate::{escape_html, get_room_info, services, utils::HtmlEscape, Result};
+use crate::{escape_html, get_room_info, services, Result};
 
 pub(super) async fn disable_room(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
 	services().rooms.metadata.disable_room(&room_id, true)?;
@@ -63,13 +63,9 @@ pub(super) async fn fetch_support_well_known(
 		},
 	};
 
-	Ok(RoomMessageEventContent::text_html(
+	Ok(RoomMessageEventContent::notice_markdown(format!(
-		format!("Got JSON response:\n\n```json\n{pretty_json}\n```"),
+		"Got JSON response:\n\n```json\n{pretty_json}\n```"
-		format!(
+	)))
-			"<p>Got JSON response:</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
-			HtmlEscape(&pretty_json)
-		),
-	))
 }
 
 pub(super) async fn remote_user_in_rooms(_body: Vec<&str>, user_id: Box<UserId>) -> Result<RoomMessageEventContent> {

src/admin/fsck/commands.rs

@@ -22,5 +22,5 @@ pub(super) async fn check_all_users(_body: Vec<&str>) -> Result<RoomMessageEvent
 		 {err_count:?}\nSuccess/Valid user count: {ok_count:?}```"
 	);
 
-	Ok(RoomMessageEventContent::notice_html(message, String::new()))
+	Ok(RoomMessageEventContent::notice_markdown(message))
 }

src/admin/handler.rs

@@ -103,9 +103,7 @@ async fn process_admin_message(msg: String) -> RoomMessageEventContent {
 		Ok(reply_message) => reply_message,
 		Err(error) => {
 			let markdown_message = format!("Encountered an error while handling the command:\n```\n{error}\n```",);
-			let html_message = format!("Encountered an error while handling the command:\n<pre>\n{error}\n</pre>",);
+			RoomMessageEventContent::notice_markdown(markdown_message)
-
-			RoomMessageEventContent::text_html(markdown_message, html_message)
 		},
 	}
 }

src/admin/room/room_info_commands.rs

@@ -1,10 +1,8 @@
-use std::fmt::Write;
-
 use ruma::{events::room::message::RoomMessageEventContent, RoomId};
 use service::services;
 
 use super::RoomInfoCommand;
-use crate::{escape_html, Result};
+use crate::Result;
 
 pub(super) async fn process(command: RoomInfoCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	match command {
@@ -57,26 +55,7 @@ async fn list_joined_members(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<R
 			.join("\n")
 	);
 
-	let output_html = format!(
+	Ok(RoomMessageEventContent::notice_markdown(output_plain))
-		"<table><caption>{} Members in Room \"{}\" </caption>\n<tr><th>MXID</th>\t<th>Display \
-		 Name</th></tr>\n{}</table>",
-		member_info.len(),
-		room_name,
-		member_info
-			.iter()
-			.fold(String::new(), |mut output, (mxid, displayname)| {
-				writeln!(
-					output,
-					"<tr><td>{}</td>\t<td>{}</td></tr>",
-					mxid,
-					escape_html(displayname.as_ref())
-				)
-				.expect("should be able to write to string buffer");
-				output
-			})
-	);
-
-	Ok(RoomMessageEventContent::text_html(output_plain, output_html))
 }
 
 async fn view_room_topic(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomMessageEventContent> {
@@ -84,10 +63,7 @@ async fn view_room_topic(_body: Vec<&str>, room_id: Box<RoomId>) -> Result<RoomM
 		return Ok(RoomMessageEventContent::text_plain("Room does not have a room topic set."));
 	};
 
-	let output_html = format!("<p>Room topic:</p>\n<hr>\n{}<hr>", escape_html(&room_topic));
+	Ok(RoomMessageEventContent::notice_markdown(format!(
-
+		"Room topic:\n\n```{room_topic}\n```"
-	Ok(RoomMessageEventContent::text_html(
+	)))
-		format!("Room topic:\n\n```{room_topic}\n```"),
-		output_html,
-	))
 }

src/admin/room/room_moderation_commands.rs

@@ -1,5 +1,3 @@
-use std::fmt::Write;
-
 use api::client::{get_alias_helper, leave_room};
 use ruma::{
 	events::room::message::RoomMessageEventContent, OwnedRoomId, OwnedUserId, RoomAliasId, RoomId, RoomOrAliasId,
@@ -7,7 +5,7 @@ use ruma::{
 use tracing::{debug, error, info, warn};
 
 use super::{super::Service, RoomModerationCommand};
-use crate::{escape_html, get_room_info, services, user_is_local, Result};
+use crate::{get_room_info, services, user_is_local, Result};
 
 pub(super) async fn process(command: RoomModerationCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
 	match command {
@@ -492,26 +490,7 @@ async fn list_banned_rooms(_body: Vec<&str>) -> Result<RoomMessageEventContent>
 					.join("\n")
 			);
 
-			let output_html = format!(
+			Ok(RoomMessageEventContent::notice_markdown(output_plain))
-				"<table><caption>Rooms Banned ({}) \
-				 </caption>\n<tr><th>id</th>\t<th>members</th>\t<th>name</th></tr>\n{}</table>",
-				rooms.len(),
-				rooms
-					.iter()
-					.fold(String::new(), |mut output, (id, members, name)| {
-						writeln!(
-							output,
-							"<tr><td>{}</td>\t<td>{}</td>\t<td>{}</td></tr>",
-							id,
-							members,
-							escape_html(name.as_ref())
-						)
-						.expect("should be able to write to string buffer");
-						output
-					})
-			);
-
-			Ok(RoomMessageEventContent::text_html(output_plain, output_html))
 		},
 		Err(e) => {
 			error!("Failed to list banned rooms: {}", e);

src/admin/user/commands.rs

@@ -26,10 +26,7 @@ pub(super) async fn list(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
 			plain_msg += &users.join("\n");
 			plain_msg += "\n```";
 
-			let mut html_msg = format!("<p>Found {} local user account(s):</p><pre><code>", users.len());
+			Ok(RoomMessageEventContent::notice_markdown(plain_msg))
-			html_msg += &users.join("\n");
-			html_msg += "\n</code></pre>";
-			Ok(RoomMessageEventContent::text_html(&plain_msg, &html_msg))
 		},
 		Err(e) => Ok(RoomMessageEventContent::text_plain(e.to_string())),
 	}
@@ -419,8 +416,8 @@ pub(super) async fn get_room_tags(
 		|e| serde_json::from_str(e.get()).expect("Bad account data in database for user {user_id}"),
 	);
 
-	Ok(RoomMessageEventContent::text_html(
+	Ok(RoomMessageEventContent::notice_markdown(format!(
-		format!("<pre><code>\n{:?}\n</code></pre>", tags_event.content.tags),
+		"```\n{:#?}\n```",
-		format!("```\n{:?}\n```", tags_event.content.tags),
+		tags_event.content.tags
-	))
+	)))
 }

src/admin/utils.rs

@@ -1,4 +1,3 @@
-pub(crate) use conduit::utils::HtmlEscape;
 use conduit_core::Error;
 use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
 use service::user_is_local;