From f1d3db0ea3378cdbf8a05f43c543ffdc5a0ff544 Mon Sep 17 00:00:00 2001 From: timedout Date: Fri, 26 Jun 2026 06:31:46 +0100 Subject: [PATCH] style: Eliminate `implement` --- src/admin/check/commands.rs | 30 +++--- src/core/matrix/pdu/redact.rs | 40 ++++---- src/core/matrix/pdu/unsigned.rs | 156 ++++++++++++++++---------------- 3 files changed, 113 insertions(+), 113 deletions(-) diff --git a/src/admin/check/commands.rs b/src/admin/check/commands.rs index e482d1a9b..96dd9e4b3 100644 --- a/src/admin/check/commands.rs +++ b/src/admin/check/commands.rs @@ -1,23 +1,23 @@ use conduwuit::Result; -use conduwuit_macros::implement; use futures::StreamExt; use crate::Context; -#[implement(Context, params = "<'_>")] -pub(super) async fn check_all_users(&self) -> Result { - let timer = tokio::time::Instant::now(); - let users = self.services.users.stream().collect::>().await; - let query_time = timer.elapsed(); +impl Context { + pub(super) async fn check_all_users(&self) -> Result { + let timer = tokio::time::Instant::now(); + let users = self.services.users.stream().collect::>().await; + let query_time = timer.elapsed(); - let total = users.len(); - let err_count = users.iter().filter(|_user| false).count(); - let ok_count = users.iter().filter(|_user| true).count(); + let total = users.len(); + let err_count = users.iter().filter(|_user| false).count(); + let ok_count = users.iter().filter(|_user| true).count(); - self.write_str(&format!( - "Database query completed in {query_time:?}:\n\n```\nTotal entries: \ - {total:?}\nFailure/Invalid user count: {err_count:?}\nSuccess/Valid user count: \ - {ok_count:?}\n```" - )) - .await + self.write_str(&format!( + "Database query completed in {query_time:?}:\n\n```\nTotal entries: \ + {total:?}\nFailure/Invalid user count: {err_count:?}\nSuccess/Valid user count: \ + {ok_count:?}\n```" + )) + .await + } } diff --git a/src/core/matrix/pdu/redact.rs b/src/core/matrix/pdu/redact.rs index 280c62622..e60dccdd5 100644 --- a/src/core/matrix/pdu/redact.rs +++ b/src/core/matrix/pdu/redact.rs @@ -1,32 +1,34 @@ use ruma::{RoomVersionId, canonical_json::redact_content_in_place}; use serde_json::{Value as JsonValue, json, value::to_raw_value}; -use crate::{Err, Result, err, implement}; +use crate::{Err, Result, err}; -#[implement(super::Pdu)] -pub fn redact(&mut self, room_version_id: &RoomVersionId, reason: JsonValue) -> Result { - let Some(rules) = room_version_id.rules() else { - return Err!("Cannot redact event for unknown room version {room_version_id}"); - }; +impl super::Pdu { + pub fn redact(&mut self, room_version_id: &RoomVersionId, reason: JsonValue) -> Result { + let Some(rules) = room_version_id.rules() else { + return Err!("Cannot redact event for unknown room version {room_version_id}"); + }; - self.unsigned = None; + self.unsigned = None; - let mut content = serde_json::from_str(self.content.get()) - .map_err(|e| err!(Request(BadJson("Failed to deserialize content into type: {e}"))))?; + let mut content = serde_json::from_str(self.content.get()).map_err(|e| { + err!(Request(BadJson("Failed to deserialize content into type: {e}"))) + })?; - redact_content_in_place(&mut content, &rules.redaction, self.kind.to_string()); + redact_content_in_place(&mut content, &rules.redaction, self.kind.to_string()); - let reason = serde_json::to_value(reason).expect("Failed to preserialize reason"); + let reason = serde_json::to_value(reason).expect("Failed to preserialize reason"); - let redacted_because = json!({ - "redacted_because": reason, - }); + let redacted_because = json!({ + "redacted_because": reason, + }); - self.unsigned = to_raw_value(&redacted_because) - .expect("Failed to serialize unsigned") - .into(); + self.unsigned = to_raw_value(&redacted_because) + .expect("Failed to serialize unsigned") + .into(); - self.content = to_raw_value(&content).expect("Failed to serialize content"); + self.content = to_raw_value(&content).expect("Failed to serialize content"); - Ok(()) + Ok(()) + } } diff --git a/src/core/matrix/pdu/unsigned.rs b/src/core/matrix/pdu/unsigned.rs index d3da10531..2db1d55af 100644 --- a/src/core/matrix/pdu/unsigned.rs +++ b/src/core/matrix/pdu/unsigned.rs @@ -4,85 +4,83 @@ use serde_json::value::{RawValue as RawJsonValue, Value as JsonValue, to_raw_value}; use super::Pdu; -use crate::{Result, err, implement, result::LogErr}; +use crate::{Result, err, result::LogErr}; -/// Set the `unsigned` field of the PDU using only information in the PDU. -/// Some unsigned data is already set within the database (eg. prev events, -/// threads). Once this is done, other data must be calculated from the database -/// (eg. relations) This is for server-to-client events. -/// Backfill handles this itself. -#[implement(Pdu)] -pub fn set_unsigned(&mut self, user_id: Option<&ruma::UserId>) { - if Some(self.sender.borrow()) != user_id { - self.remove_transaction_id().log_err().ok(); +impl Pdu { + /// Set the `unsigned` field of the PDU using only information in the PDU. + /// Some unsigned data is already set within the database (eg. prev events, + /// threads). Once this is done, other data must be calculated from the + /// database (eg. relations) This is for server-to-client events. + /// Backfill handles this itself. + pub fn set_unsigned(&mut self, user_id: Option<&ruma::UserId>) { + if Some(self.sender.borrow()) != user_id { + self.remove_transaction_id().log_err().ok(); + } + self.add_age().log_err().ok(); + } + + pub fn remove_transaction_id(&mut self) -> Result { + use BTreeMap as Map; + + let Some(unsigned) = &self.unsigned else { + return Ok(()); + }; + + let mut unsigned: Map<&str, Box> = serde_json::from_str(unsigned.get()) + .map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?; + + unsigned.remove("transaction_id"); + self.unsigned = to_raw_value(&unsigned) + .map(Some) + .expect("unsigned is valid"); + + Ok(()) + } + + pub fn add_age(&mut self) -> Result { + use BTreeMap as Map; + + let mut unsigned: Map<&str, Box> = self + .unsigned + .as_deref() + .map(RawJsonValue::get) + .map_or_else(|| Ok(Map::new()), serde_json::from_str) + .map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?; + + // deliberately allowing for the possibility of negative age + let now: i128 = MilliSecondsSinceUnixEpoch::now().get().into(); + let then: i128 = self.origin_server_ts.into(); + let this_age = now.saturating_sub(then); + + unsigned.insert("age", to_raw_value(&this_age)?); + self.unsigned = Some(to_raw_value(&unsigned)?); + + Ok(()) + } + + pub fn add_relation(&mut self, name: &str, pdu: Option<&Pdu>) -> Result { + use serde_json::Map; + + let mut unsigned: Map = self + .unsigned + .as_deref() + .map(RawJsonValue::get) + .map_or_else(|| Ok(Map::new()), serde_json::from_str) + .map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?; + + let pdu = pdu + .map(serde_json::to_value) + .transpose()? + .unwrap_or_else(|| JsonValue::Object(Map::new())); + + unsigned + .entry("m.relations") + .or_insert(JsonValue::Object(Map::new())) + .as_object_mut() + .map(|object| object.insert(name.to_owned(), pdu)); + + self.unsigned = Some(to_raw_value(&unsigned)?); + + Ok(()) } - self.add_age().log_err().ok(); -} - -#[implement(Pdu)] -pub fn remove_transaction_id(&mut self) -> Result { - use BTreeMap as Map; - - let Some(unsigned) = &self.unsigned else { - return Ok(()); - }; - - let mut unsigned: Map<&str, Box> = serde_json::from_str(unsigned.get()) - .map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?; - - unsigned.remove("transaction_id"); - self.unsigned = to_raw_value(&unsigned) - .map(Some) - .expect("unsigned is valid"); - - Ok(()) -} - -#[implement(Pdu)] -pub fn add_age(&mut self) -> Result { - use BTreeMap as Map; - - let mut unsigned: Map<&str, Box> = self - .unsigned - .as_deref() - .map(RawJsonValue::get) - .map_or_else(|| Ok(Map::new()), serde_json::from_str) - .map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?; - - // deliberately allowing for the possibility of negative age - let now: i128 = MilliSecondsSinceUnixEpoch::now().get().into(); - let then: i128 = self.origin_server_ts.into(); - let this_age = now.saturating_sub(then); - - unsigned.insert("age", to_raw_value(&this_age)?); - self.unsigned = Some(to_raw_value(&unsigned)?); - - Ok(()) -} - -#[implement(Pdu)] -pub fn add_relation(&mut self, name: &str, pdu: Option<&Pdu>) -> Result { - use serde_json::Map; - - let mut unsigned: Map = self - .unsigned - .as_deref() - .map(RawJsonValue::get) - .map_or_else(|| Ok(Map::new()), serde_json::from_str) - .map_err(|e| err!(Database("Invalid unsigned in pdu event: {e}")))?; - - let pdu = pdu - .map(serde_json::to_value) - .transpose()? - .unwrap_or_else(|| JsonValue::Object(Map::new())); - - unsigned - .entry("m.relations") - .or_insert(JsonValue::Object(Map::new())) - .as_object_mut() - .map(|object| object.insert(name.to_owned(), pdu)); - - self.unsigned = Some(to_raw_value(&unsigned)?); - - Ok(()) }