chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Increase usage of implicit named arguments in format strings

Browse Source
This commit is contained in:
Jonas Platte 2022-06-03 10:06:28 +02:00
parent d24cbb981a
commit 8912182c56
No known key found for this signature in database
GPG Key ID: AAA7A61F696C3E0C
42 changed files with 133 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/ruma-appservice-api/src/event/push_events.rs
View File

@ -90,7 +90,7 @@ pub mod v1 {
let join = response.rooms.join.entry(room_id).or_default();
join.timeline.events.push(Raw::from_json(event_json));
} else {
warn!("Event without room_id: {}", event_json);
warn!("Event without room_id: {event_json}");
}
}

2
crates/ruma-client-api/src/session/get_login_types.rs
View File

@ -363,7 +363,7 @@ pub mod v3 {
let mut identity_providers = match flow {
Some(LoginType::Sso(SsoLoginType { identity_providers })) => identity_providers,
_ => panic!("unexpected enum variant: {:?}", flow),
_ => panic!("unexpected enum variant: {flow:?}"),
};
let provider = identity_providers.pop();

6
crates/ruma-client-api/src/state/get_state_events_for_key.rs
View File

@ -97,12 +97,10 @@ pub mod v3 {
&METADATA,
None,
Some(format_args!(
"/_matrix/client/r0/rooms/{}/state/{}",
room_id_percent, event_type_percent
"/_matrix/client/r0/rooms/{room_id_percent}/state/{event_type_percent}",
)),
Some(format_args!(
"/_matrix/client/v3/rooms/{}/state/{}",
room_id_percent, event_type_percent
"/_matrix/client/v3/rooms/{room_id_percent}/state/{event_type_percent}",
)),
)?
);

6
crates/ruma-client-api/src/state/send_state_event.rs
View File

@ -125,12 +125,10 @@ pub mod v3 {
&METADATA,
None,
Some(format_args!(
"/_matrix/client/r0/rooms/{}/state/{}",
room_id_percent, event_type_percent
"/_matrix/client/r0/rooms/{room_id_percent}/state/{event_type_percent}",
)),
Some(format_args!(
"/_matrix/client/v3/rooms/{}/state/{}",
room_id_percent, event_type_percent
"/_matrix/client/v3/rooms/{room_id_percent}/state/{event_type_percent}",
)),
)?
);

2
crates/ruma-client-api/src/uiaa.rs
View File

@ -717,7 +717,7 @@ impl fmt::Display for UiaaResponse {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::AuthResponse(_) => write!(f, "User-Interactive Authentication required."),
Self::MatrixError(err) => write!(f, "{}", err),
Self::MatrixError(err) => write!(f, "{err}"),
}
}
}

2
crates/ruma-client/build.rs
View File

@ -11,7 +11,7 @@ fn main() {
eprintln!("error: Only one tls features can be enabled.");
for (f, a) in &tls_features {
eprintln!(" {}: {}", f, if *a { "enabled" } else { "disabled" });
eprintln!(" {f}: {}", if *a { "enabled" } else { "disabled" });
}
process::exit(1);

8
crates/ruma-client/src/error.rs
View File

@ -30,10 +30,10 @@ impl<E: Display, F: Display> Display for Error<E, F> {
Self::AuthenticationRequired => {
write!(f, "The queried endpoint requires authentication but was called with an anonymous client.")
}
Self::IntoHttp(err) => write!(f, "HTTP request construction failed: {}", err),
Self::Url(err) => write!(f, "Invalid URL: {}", err),
Self::Response(err) => write!(f, "Couldn't obtain a response: {}", err),
Self::FromHttpResponse(err) => write!(f, "HTTP response conversion failed: {}", err),
Self::IntoHttp(err) => write!(f, "HTTP request construction failed: {err}"),
Self::Url(err) => write!(f, "Invalid URL: {err}"),
Self::Response(err) => write!(f, "Couldn't obtain a response: {err}"),
Self::FromHttpResponse(err) => write!(f, "HTTP response conversion failed: {err}"),
}
}
}

4
crates/ruma-client/src/lib.rs
View File

@ -187,8 +187,8 @@ fn add_user_id_to_query<C: HttpClient + ?Sized, R: OutgoingRequest>(
let extra_params = urlencoded::to_string(&[("user_id", user_id)]).unwrap();
let uri = http_request.uri_mut();
let new_path_and_query = match uri.query() {
Some(params) => format!("{}?{}&{}", uri.path(), params, extra_params),
None => format!("{}?{}", uri.path(), extra_params),
Some(params) => format!("{}?{params}&{extra_params}", uri.path()),
None => format!("{}?{extra_params}", uri.path()),
};
*uri = Uri::from_parts(assign!(uri.clone().into_parts(), {
path_and_query: Some(new_path_and_query.parse()?),

6
crates/ruma-common/src/api.rs
View File

@ -309,10 +309,10 @@ pub trait OutgoingRequestAppserviceExt: OutgoingRequest {
let path_and_query_with_user_id = match &parts.path_and_query {
Some(path_and_query) => match path_and_query.query() {
Some(_) => format!("{}&{}", path_and_query, user_id_query),
None => format!("{}?{}", path_and_query, user_id_query),
Some(_) => format!("{path_and_query}&{user_id_query}"),
None => format!("{path_and_query}?{user_id_query}"),
},
None => format!("/?{}", user_id_query),
None => format!("/?{user_id_query}"),
};
parts.path_and_query =

4
crates/ruma-common/src/api/error.rs
View File

@ -161,8 +161,8 @@ impl<E, F> FromHttpResponseError<Result<E, F>> {
impl<E: fmt::Display> fmt::Display for FromHttpResponseError<E> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Deserialization(err) => write!(f, "deserialization failed: {}", err),
Self::Server(err) => write!(f, "the server returned an error: {}", err),
Self::Deserialization(err) => write!(f, "deserialization failed: {err}"),
Self::Server(err) => write!(f, "the server returned an error: {err}"),
}
}
}

2
crates/ruma-common/src/api/metadata.rs
View File

@ -225,6 +225,6 @@ impl MatrixVersion {
impl Display for MatrixVersion {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (major, minor) = self.into_parts();
f.write_str(&format!("v{}.{}", major, minor))
f.write_str(&format!("v{major}.{minor}"))
}
}

2
crates/ruma-common/src/events/room/join_rules.rs
View File

@ -274,7 +274,7 @@ mod tests {
AllowRule::room_membership(room_id!("!users:example.org").to_owned())
]
),
rule => panic!("Deserialized to wrong variant: {:?}", rule),
rule => panic!("Deserialized to wrong variant: {rule:?}"),
}
}

2
crates/ruma-common/src/events/room/name.rs
View File

@ -135,7 +135,7 @@ mod tests {
let from_raw: Raw<RoomNameEventContent> = from_json_value(long_content_json).unwrap();
let result = from_raw.deserialize();
assert!(result.is_err(), "Result should be invalid: {:?}", result);
assert!(result.is_err(), "Result should be invalid: {result:?}");
}
#[test]

4
crates/ruma-common/src/identifiers/matrix_uri.rs
View File

@ -139,7 +139,7 @@ impl MatrixId {
"roomid" => '!',
_ => return Err(MatrixIdError::UnknownType.into()),
};
id = format!("{}/{}{}", id, sigil, id_without_sigil);
id = format!("{id}/{sigil}{id_without_sigil}");
}
Self::parse_with_sigil(&id)
@ -462,7 +462,7 @@ impl MatrixUri {
impl fmt::Display for MatrixUri {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}:{}", MATRIX_SCHEME, self.id().to_string_with_type())?;
write!(f, "{MATRIX_SCHEME}:{}", self.id().to_string_with_type())?;
let mut first = true;
for server_name in &self.via {

6
crates/ruma-common/src/identifiers/user_id.rs
View File

@ -51,7 +51,7 @@ impl UserId {
Self::parse(id).map(Into::into)
} else {
let _ = localpart_is_fully_conforming(id_str)?;
Ok(Self::from_borrowed(&format!("@{}:{}", id_str, server_name)).to_owned())
Ok(Self::from_borrowed(&format!("@{id_str}:{server_name}")).to_owned())
}
}
@ -68,7 +68,7 @@ impl UserId {
Self::parse_rc(id)
} else {
let _ = localpart_is_fully_conforming(id_str)?;
Ok(Self::from_rc(format!("@{}:{}", id_str, server_name).into()))
Ok(Self::from_rc(format!("@{id_str}:{server_name}").into()))
}
}
@ -85,7 +85,7 @@ impl UserId {
Self::parse_arc(id)
} else {
let _ = localpart_is_fully_conforming(id_str)?;
Ok(Self::from_arc(format!("@{}:{}", id_str, server_name).into()))
Ok(Self::from_arc(format!("@{id_str}:{server_name}").into()))
}
}

4
crates/ruma-common/src/push/condition.rs
View File

@ -288,13 +288,13 @@ impl FlattenedJson {
match value {
JsonValue::Object(fields) => {
for (key, value) in fields {
let path = if path.is_empty() { key } else { format!("{}.{}", path, key) };
let path = if path.is_empty() { key } else { format!("{path}.{key}") };
self.flatten_value(value, path);
}
}
JsonValue::String(s) => {
if self.map.insert(path.clone(), s).is_some() {
warn!("Duplicate path in flattened JSON: {}", path);
warn!("Duplicate path in flattened JSON: {path}");
}
}
JsonValue::Number(_) | JsonValue::Bool(_) | JsonValue::Array(_) | JsonValue::Null => {}

2
crates/ruma-common/src/push/condition/room_member_count_is.rs
View File

@ -115,7 +115,7 @@ impl fmt::Display for RoomMemberCountIs {
Op::Le => "<=",
};
write!(f, "{}{}", prefix, self.count)
write!(f, "{prefix}{}", self.count)
}
}

2
crates/ruma-common/src/serde/canonical_json.rs
View File

@ -22,7 +22,7 @@ impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::IntConvert => f.write_str("number found is not a valid `js_int::Int`"),
Error::SerDe(err) => write!(f, "serde Error: {}", err),
Error::SerDe(err) => write!(f, "serde Error: {err}"),
}
}
}

2
crates/ruma-common/src/serde/canonical_json/value.rs
View File

@ -317,7 +317,7 @@ mod tests {
let json: CanonicalJsonValue =
json!({ "city": "London", "street": "10 Downing Street" }).try_into().unwrap();
assert_eq!(format!("{}", json), CANONICAL_STR);
assert_eq!(format!("{json}"), CANONICAL_STR);
assert_eq!(format!("{:#}", json), CANONICAL_STR);
}
}

2
crates/ruma-common/src/serde/urlencoded/de.rs
View File

@ -77,7 +77,7 @@ where
let mut buf = vec![];
reader
.read_to_end(&mut buf)
.map_err(|e| de::Error::custom(format_args!("could not read input: {}", e)))?;
.map_err(|e| de::Error::custom(format_args!("could not read input: {e}")))?;
from_bytes(&buf)
}

4
crates/ruma-common/src/serde/urlencoded/ser.rs
View File

@ -60,7 +60,7 @@ impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Error::Custom(ref msg) => msg.fmt(f),
Error::Utf8(ref err) => write!(f, "invalid UTF-8: {}", err),
Error::Utf8(ref err) => write!(f, "invalid UTF-8: {err}"),
}
}
}
@ -85,7 +85,7 @@ impl error::Error for Error {
impl ser::Error for Error {
fn custom<T: fmt::Display>(msg: T) -> Self {
Error::Custom(format!("{}", msg).into())
Error::Custom(format!("{msg}").into())
}
}

2
crates/ruma-common/src/to_device.rs
View File

@ -25,7 +25,7 @@ pub enum DeviceIdOrAllDevices {
impl Display for DeviceIdOrAllDevices {
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
match self {
DeviceIdOrAllDevices::DeviceId(device_id) => write!(f, "{}", device_id),
DeviceIdOrAllDevices::DeviceId(device_id) => write!(f, "{device_id}"),
DeviceIdOrAllDevices::AllDevices => write!(f, "*"),
}
}

16
crates/ruma-common/tests/api/select_path.rs
View File

@ -31,7 +31,7 @@ const R: &str = "r";
fn select_stable() {
let meta = Metadata { added: Some(V1_1), ..BASE };
let res = select_path(&[V1_0, V1_1], &meta, None, None, Some(format_args!("{}", S)))
let res = select_path(&[V1_0, V1_1], &meta, None, None, Some(format_args!("{S}")))
.unwrap()
.to_string();
@ -43,7 +43,7 @@ fn select_unstable() {
let meta = BASE;
let res =
select_path(&[V1_0], &meta, Some(format_args!("{}", U)), None, None).unwrap().to_string();
select_path(&[V1_0], &meta, Some(format_args!("{U}")), None, None).unwrap().to_string();
assert_eq!(res, U);
}
@ -53,7 +53,7 @@ fn select_r0() {
let meta = Metadata { added: Some(V1_0), ..BASE };
let res =
select_path(&[V1_0], &meta, None, Some(format_args!("{}", R)), Some(format_args!("{}", S)))
select_path(&[V1_0], &meta, None, Some(format_args!("{R}")), Some(format_args!("{S}")))
.unwrap()
.to_string();
@ -67,9 +67,9 @@ fn select_removed_err() {
let res = select_path(
&[V1_2],
&meta,
Some(format_args!("{}", U)),
Some(format_args!("{}", R)),
Some(format_args!("{}", S)),
Some(format_args!("{U}")),
Some(format_args!("{R}")),
Some(format_args!("{S}")),
)
.unwrap_err();
@ -81,7 +81,7 @@ fn partially_removed_but_stable() {
let meta = Metadata { added: Some(V1_0), deprecated: Some(V1_1), removed: Some(V1_2), ..BASE };
let res =
select_path(&[V1_1], &meta, None, Some(format_args!("{}", R)), Some(format_args!("{}", S)))
select_path(&[V1_1], &meta, None, Some(format_args!("{R}")), Some(format_args!("{S}")))
.unwrap()
.to_string();
@ -93,7 +93,7 @@ fn no_unstable() {
let meta = Metadata { added: Some(V1_1), ..BASE };
let res =
select_path(&[V1_0], &meta, None, Some(format_args!("{}", R)), Some(format_args!("{}", S)))
select_path(&[V1_0], &meta, None, Some(format_args!("{R}")), Some(format_args!("{S}")))
.unwrap_err();
assert_matches!(res, IntoHttpError::NoUnstablePath);

2
crates/ruma-common/tests/events/location.rs
View File

@ -164,7 +164,7 @@ fn zoomlevel_deserialization_too_high() {
from_json_value::<LocationContent>(json_data),
Err(err)
if err.is_data()
&& format!("{}", err) == format!("{}", ZoomLevelError::TooHigh)
&& format!("{err}") == format!("{}", ZoomLevelError::TooHigh)
);
}

2
crates/ruma-common/tests/events/state_event.rs
View File

@ -287,7 +287,7 @@ fn deserialize_full_event_convert_to_sync() {
let full_ev: AnyStateEvent = from_json_value(json_data).unwrap();
let sync_ev = match AnySyncStateEvent::from(full_ev) {
AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(ev)) => ev,
ev => panic!("unexpected variant for event {:?}", ev),
ev => panic!("unexpected variant for event {ev:?}"),
};
assert_eq!(sync_ev.content.aliases, vec![room_alias_id!("#somewhere:localhost")]);

4
crates/ruma-macros/src/api/version.rs
View File

@ -28,11 +28,11 @@ impl Parse for MatrixVersionLiteral {
})?;
let major: NonZeroU8 = ver[0].parse().map_err(|e| {
Error::new_spanned(&fl, format!("major number failed to parse as >0 number: {}", e))
Error::new_spanned(&fl, format!("major number failed to parse as >0 number: {e}"))
})?;
let minor: u8 = ver[1]
.parse()
.map_err(|e| Error::new_spanned(&fl, format!("minor number failed to parse: {}", e)))?;
.map_err(|e| Error::new_spanned(&fl, format!("minor number failed to parse: {e}")))?;
Ok(Self { major, minor })
}

6
crates/ruma-macros/src/events/event_content.rs
View File

@ -329,7 +329,7 @@ fn generate_redacted_event_content<'a>(
let serde_json = quote! { #ruma_common::exports::serde_json };
let doc = format!("Redacted form of [`{}`]", ident);
let redacted_ident = format_ident!("Redacted{}", ident);
let redacted_ident = format_ident!("Redacted{ident}");
let kept_redacted_fields: Vec<_> = fields
.map(|f| {
@ -493,7 +493,7 @@ fn generate_event_type_aliases(
.iter()
.filter_map(|&var| Some((var, event_kind.to_event_ident(var).ok()?)))
.map(|(var, ev_struct)| {
let ev_type = format_ident!("{}{}", var, ev_type_s);
let ev_type = format_ident!("{var}{ev_type_s}");
let doc_text = match var {
EventKindVariation::None | EventKindVariation::Original => "",
@ -510,7 +510,7 @@ fn generate_event_type_aliases(
let ev_type_doc = format!("An `{}` event{}.", event_type, doc_text);
let content_struct = if var.is_redacted() {
Cow::Owned(format_ident!("Redacted{}", ident))
Cow::Owned(format_ident!("Redacted{ident}"))
} else {
Cow::Borrowed(ident)
};

4
crates/ruma-macros/src/events/event_enum.rs
View File

@ -811,14 +811,14 @@ impl EventEnumVariation {
pub fn to_sync(self) -> Self {
match self {
EventEnumVariation::None => EventEnumVariation::Sync,
_ => panic!("No sync form of {:?}", self),
_ => panic!("No sync form of {self:?}"),
}
}
pub fn to_full(self) -> Self {
match self {
EventEnumVariation::Sync => EventEnumVariation::None,
_ => panic!("No full form of {:?}", self),
_ => panic!("No full form of {self:?}"),
}
}
}

6
crates/ruma-macros/src/events/event_parse.rs
View File

@ -59,7 +59,7 @@ impl EventKindVariation {
match self {
EventKindVariation::Original => EventKindVariation::Redacted,
EventKindVariation::OriginalSync => EventKindVariation::RedactedSync,
_ => panic!("No redacted form of {:?}", self),
_ => panic!("No redacted form of {self:?}"),
}
}
@ -67,7 +67,7 @@ impl EventKindVariation {
match self {
EventKindVariation::OriginalSync => EventKindVariation::Original,
EventKindVariation::RedactedSync => EventKindVariation::Redacted,
_ => panic!("No original (unredacted) form of {:?}", self),
_ => panic!("No original (unredacted) form of {self:?}"),
}
}
}
@ -135,7 +135,7 @@ impl EventKind {
Self::MessageLike | Self::RoomRedaction | Self::State,
V::Original | V::OriginalSync | V::Redacted | V::RedactedSync,
)
| (Self::State, V::Stripped | V::Initial) => Ok(format_ident!("{}{}", var, self)),
| (Self::State, V::Stripped | V::Initial) => Ok(format_ident!("{var}{self}")),
_ => Err(syn::Error::new(
Span::call_site(),
format!(

10
crates/ruma-macros/src/identifiers.rs
View File

@ -25,7 +25,7 @@ impl Parse for IdentifierInput {
pub fn expand_id_zst(input: ItemStruct) -> syn::Result<TokenStream> {
let id = &input.ident;
let owned = format_ident!("Owned{}", id);
let owned = format_ident!("Owned{id}");
let owned_decl = expand_owned_id(&input);
@ -222,9 +222,9 @@ pub fn expand_id_zst(input: ItemStruct) -> syn::Result<TokenStream> {
fn expand_owned_id(input: &ItemStruct) -> TokenStream {
let id = &input.ident;
let owned = format_ident!("Owned{}", id);
let owned = format_ident!("Owned{id}");
let doc_header = format!("Owned variant of {}", id);
let doc_header = format!("Owned variant of {id}");
let (impl_generics, ty_generics, _where_clause) = input.generics.split_for_impl();
let id_ty = quote! { #id #ty_generics };
@ -405,7 +405,7 @@ fn expand_owned_id(input: &ItemStruct) -> TokenStream {
fn expand_checked_impls(input: &ItemStruct, validate: Path) -> TokenStream {
let id = &input.ident;
let owned = format_ident!("Owned{}", id);
let owned = format_ident!("Owned{id}");
let (impl_generics, ty_generics, _where_clause) = input.generics.split_for_impl();
let generic_params = &input.generics.params;
@ -553,7 +553,7 @@ fn expand_checked_impls(input: &ItemStruct, validate: Path) -> TokenStream {
fn expand_unchecked_impls(input: &ItemStruct) -> TokenStream {
let id = &input.ident;
let owned = format_ident!("Owned{}", id);
let owned = format_ident!("Owned{id}");
quote! {
impl<'a> From<&'a str> for &'a #id {

8
crates/ruma-macros/src/util.rs
View File

@ -5,16 +5,16 @@ use syn::{Ident, LitStr};
pub(crate) fn import_ruma_common() -> TokenStream {
if let Ok(FoundCrate::Name(name)) = crate_name("ruma-common") {
let import = format_ident!("{}", name);
let import = format_ident!("{name}");
quote! { ::#import }
} else if let Ok(FoundCrate::Name(name)) = crate_name("ruma") {
let import = format_ident!("{}", name);
let import = format_ident!("{name}");
quote! { ::#import }
} else if let Ok(FoundCrate::Name(name)) = crate_name("matrix-sdk") {
let import = format_ident!("{}", name);
let import = format_ident!("{name}");
quote! { ::#import::ruma }
} else if let Ok(FoundCrate::Name(name)) = crate_name("matrix-sdk-appservice") {
let import = format_ident!("{}", name);
let import = format_ident!("{name}");
quote! { ::#import::ruma }
} else {
quote! { ::ruma_common }

8
crates/ruma-signatures/src/functions.rs
View File

@ -1104,7 +1104,7 @@ mod tests {
if let Error::Verification(VerificationError::PublicKeyNotFound(entity)) = error_msg {
assert_eq!(entity, "domain-sender");
} else {
panic!("Error was not VerificationError::UnknownPublicKeysForEvent: {:?}", error_msg);
panic!("Error was not VerificationError::UnknownPublicKeysForEvent: {error_msg:?}");
};
}
@ -1152,11 +1152,9 @@ mod tests {
if let Error::Verification(VerificationError::Signature(error)) = error_msg {
// dalek doesn't expose InternalError :(
// https://github.com/dalek-cryptography/ed25519-dalek/issues/174
assert!(
format!("{:?}", error).contains("Some(Verification equation was not satisfied)")
);
assert!(format!("{error:?}").contains("Some(Verification equation was not satisfied)"));
} else {
panic!("Error was not VerificationError::Signature: {:?}", error_msg);
panic!("Error was not VerificationError::Signature: {error_msg:?}");
};
}

2
crates/ruma-state-res/benches/state_res_bench.rs
View File

@ -79,7 +79,7 @@ fn resolution_shallow_auth_chain(c: &mut Criterion) {
|id| ev_map.get(id).map(Arc::clone),
) {
Ok(state) => state,
Err(e) => panic!("{}", e),
Err(e) => panic!("{e}"),
};
});
});

10
crates/ruma-state-res/src/event_auth.rs
View File

@ -263,7 +263,7 @@ pub fn auth_check<E: Event>(
}
let target_user =
<&UserId>::try_from(state_key).map_err(|e| Error::InvalidPdu(format!("{}", e)))?;
<&UserId>::try_from(state_key).map_err(|e| Error::InvalidPdu(format!("{e}")))?;
let user_for_join_auth =
content.join_authorised_via_users_server.as_ref().and_then(|u| u.deserialize().ok());
@ -697,7 +697,7 @@ fn valid_membership_change(
fn can_send_event(event: impl Event, ple: Option<impl Event>, user_level: Int) -> bool {
let event_type_power_level = get_send_level(event.event_type(), event.state_key(), ple);
debug!("{} ev_type {} usr {}", event.event_id(), event_type_power_level, user_level);
debug!("{} ev_type {event_type_power_level} usr {user_level}", event.event_id());
if user_level < event_type_power_level {
return false;
@ -722,7 +722,7 @@ fn check_power_levels(
match power_event.state_key() {
Some("") => {}
Some(key) => {
error!("m.room.power_levels event has non-empty state key: {}", key);
error!("m.room.power_levels event has non-empty state key: {key}");
return None;
}
None => {
@ -756,7 +756,7 @@ fn check_power_levels(
user_levels_to_check.insert(user);
}
debug!("users to check {:?}", user_levels_to_check);
debug!("users to check {user_levels_to_check:?}");
let mut event_levels_to_check = BTreeSet::new();
let old_list = &current_content.events;
@ -765,7 +765,7 @@ fn check_power_levels(
event_levels_to_check.insert(ev_id);
}
debug!("events to check {:?}", event_levels_to_check);
debug!("events to check {event_levels_to_check:?}");
let old_state = &current_content;
let new_state = &user_content;

44
crates/ruma-state-res/src/lib.rs
View File

@ -70,7 +70,7 @@ where
let (clean, conflicting) = separate(state_sets.into_iter());
info!("non conflicting events: {}", clean.len());
trace!("{:?}", clean);
trace!("{clean:?}");
if conflicting.is_empty() {
info!("no conflicting state found");
@ -78,7 +78,7 @@ where
}
info!("conflicting events: {}", conflicting.len());
debug!("{:?}", conflicting);
debug!("{conflicting:?}");
// `all_conflicted` contains unique items
// synapse says `full_set = {eid for eid in full_conflicted_set if eid in event_map}`
@ -89,7 +89,7 @@ where
.collect();
info!("full conflicted set: {}", all_conflicted.len());
debug!("{:?}", all_conflicted);
debug!("{all_conflicted:?}");
// We used to check that all events are events from the correct room
// this is now a check the caller of `resolve` must make.
@ -106,7 +106,7 @@ where
reverse_topological_power_sort(control_events, &all_conflicted, &fetch_event)?;
debug!("sorted control events: {}", sorted_control_levels.len());
trace!("{:?}", sorted_control_levels);
trace!("{sorted_control_levels:?}");
let room_version = RoomVersion::new(room_version)?;
// Sequentially auth check each control event.
@ -114,7 +114,7 @@ where
iterative_auth_check(&room_version, &sorted_control_levels, clean.clone(), &fetch_event)?;
debug!("resolved control events: {}", resolved_control.len());
trace!("{:?}", resolved_control);
trace!("{resolved_control:?}");
// At this point the control_events have been resolved we now have to
// sort the remaining events using the mainline of the resolved power level.
@ -129,16 +129,16 @@ where
.collect::<Vec<_>>();
debug!("events left to resolve: {}", events_to_resolve.len());
trace!("{:?}", events_to_resolve);
trace!("{events_to_resolve:?}");
// This "epochs" power level event
let power_event = resolved_control.get(&(StateEventType::RoomPowerLevels, "".into()));
debug!("power event: {:?}", power_event);
debug!("power event: {power_event:?}");
let sorted_left_events = mainline_sort(&events_to_resolve, power_event.cloned(), &fetch_event)?;
trace!("events left, sorted: {:?}", sorted_left_events);
trace!("events left, sorted: {sorted_left_events:?}");
let mut resolved_state = iterative_auth_check(
&room_version,
@ -230,7 +230,7 @@ fn reverse_topological_power_sort<E: Event>(
let mut event_to_pl = HashMap::new();
for event_id in graph.keys() {
let pl = get_power_level_for_sender(event_id.borrow(), &fetch_event)?;
info!("{} power level {}", event_id, pl);
info!("{event_id} power level {pl}");
event_to_pl.insert(event_id.clone(), pl);
@ -361,7 +361,7 @@ fn get_power_level_for_sender<E: Event>(
event_id: &EventId,
fetch_event: impl Fn(&EventId) -> Option<E>,
) -> serde_json::Result<Int> {
info!("fetch event ({}) senders power level", event_id);
info!("fetch event ({event_id}) senders power level");
let event = fetch_event(event_id);
let mut pl = None;
@ -382,7 +382,7 @@ fn get_power_level_for_sender<E: Event>(
if let Some(ev) = event {
if let Some(&user_level) = content.users.get(ev.sender()) {
debug!("found {} at power_level {}", ev.sender(), user_level);
debug!("found {} at power_level {user_level}", ev.sender());
return Ok(user_level);
}
}
@ -407,13 +407,13 @@ fn iterative_auth_check<E: Event + Clone>(
) -> Result<StateMap<E::Id>> {
info!("starting iterative auth check");
debug!("performing auth checks on {:?}", events_to_check);
debug!("performing auth checks on {events_to_check:?}");
let mut resolved_state = unconflicted_state;
for event_id in events_to_check {
let event = fetch_event(event_id.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", event_id)))?;
.ok_or_else(|| Error::NotFound(format!("Failed to find {event_id}")))?;
let state_key = event
.state_key()
.ok_or_else(|| Error::InvalidPdu("State event had no state key".to_owned()))?;
@ -430,7 +430,7 @@ fn iterative_auth_check<E: Event + Clone>(
ev,
);
} else {
warn!("auth event id for {} is missing {}", aid, event_id);
warn!("auth event id for {aid} is missing {event_id}");
}
}
@ -463,7 +463,7 @@ fn iterative_auth_check<E: Event + Clone>(
resolved_state.insert(event.event_type().with_state_key(state_key), event_id.clone());
} else {
// synapse passes here on AuthError. We do not add this event to resolved_state.
warn!("event {} failed the authentication check", event_id);
warn!("event {event_id} failed the authentication check");
}
// TODO: if these functions are ever made async here
@ -498,11 +498,11 @@ fn mainline_sort<E: Event>(
mainline.push(p.clone());
let event = fetch_event(p.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", p)))?;
.ok_or_else(|| Error::NotFound(format!("Failed to find {p}")))?;
pl = None;
for aid in event.auth_events() {
let ev = fetch_event(aid.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
.ok_or_else(|| Error::NotFound(format!("Failed to find {aid}")))?;
if is_type_and_key(&ev, &RoomEventType::RoomPowerLevels, "") {
pl = Some(aid.to_owned());
break;
@ -561,7 +561,7 @@ fn get_mainline_depth<E: Event>(
event = None;
for aid in sort_ev.auth_events() {
let aev = fetch_event(aid.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
.ok_or_else(|| Error::NotFound(format!("Failed to find {aid}")))?;
if is_type_and_key(&aev, &RoomEventType::RoomPowerLevels, "") {
event = Some(aev);
break;
@ -1079,7 +1079,7 @@ mod tests {
|id| ev_map.get(id).map(Arc::clone),
) {
Ok(state) => state,
Err(e) => panic!("{}", e),
Err(e) => panic!("{e}"),
};
assert_eq!(expected, resolved);
@ -1179,14 +1179,14 @@ mod tests {
|id| ev_map.get(id).map(Arc::clone),
) {
Ok(state) => state,
Err(e) => panic!("{}", e),
Err(e) => panic!("{e}"),
};
debug!(
"{:#?}",
resolved
.iter()
.map(|((ty, key), id)| format!("(({}{:?}), {})", ty, key, id))
.map(|((ty, key), id)| format!("(({ty}{key:?}), {id})"))
.collect::<Vec<_>>()
);
@ -1202,7 +1202,7 @@ mod tests {
for id in expected.iter().map(|i| event_id(i)) {
// make sure our resolved events are equal to the expected list
assert!(resolved.values().any(|eid| eid == &id) || init.contains_key(&id), "{}", id);
assert!(resolved.values().any(|eid| eid == &id) || init.contains_key(&id), "{id}");
}
assert_eq!(expected.len(), resolved.len());
}

2
crates/ruma-state-res/src/room_version.rs
View File

@ -115,7 +115,7 @@ impl RoomVersion {
RoomVersionId::V7 => Self::V7,
RoomVersionId::V8 => Self::V8,
RoomVersionId::V9 => Self::V9,
ver => return Err(Error::Unsupported(format!("found version `{}`", ver.as_str()))),
ver => return Err(Error::Unsupported(format!("found version `{ver}`"))),
})
}
}

15
crates/ruma-state-res/src/test_utils.rs
View File

@ -107,7 +107,7 @@ pub fn do_check(
.iter()
.map(|map| map
.iter()
.map(|((ty, key), id)| format!("(({}{:?}), {})", ty, key, id))
.map(|((ty, key), id)| format!("(({ty}{key:?}), {id})"))
.collect::<Vec<_>>())
.collect::<Vec<_>>()
);
@ -124,7 +124,7 @@ pub fn do_check(
});
match resolved {
Ok(state) => state,
Err(e) => panic!("resolution for {} failed: {}", node, e),
Err(e) => panic!("resolution for {node} failed: {e}"),
}
};
@ -175,8 +175,7 @@ pub fn do_check(
for node in expected_state_ids {
let ev = event_map.get(&node).unwrap_or_else(|| {
panic!(
"{} not found in {:?}",
node,
"{node} not found in {:?}",
event_map.keys().map(ToString::to_string).collect::<Vec<_>>()
)
});
@ -214,7 +213,7 @@ impl<E: Event> TestStore<E> {
self.0
.get(event_id)
.map(Arc::clone)
.ok_or_else(|| Error::NotFound(format!("{} not found", event_id)))
.ok_or_else(|| Error::NotFound(format!("{event_id} not found")))
}
/// Returns a Vec of the related auth events to the given `event`.
@ -337,7 +336,7 @@ pub fn event_id(id: &str) -> OwnedEventId {
return id.try_into().unwrap();
}
format!("${}:foo", id).try_into().unwrap()
format!("${id}:foo").try_into().unwrap()
}
pub fn alice() -> &'static UserId {
@ -380,7 +379,7 @@ pub fn to_init_pdu_event(
content: Box<RawJsonValue>,
) -> Arc<PduEvent> {
let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst);
let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) };
let id = if id.contains('$') { id.to_owned() } else { format!("${id}:foo") };
let state_key = state_key.map(ToOwned::to_owned);
Arc::new(PduEvent {
@ -416,7 +415,7 @@ where
S: AsRef<str>,
{
let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst);
let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) };
let id = if id.contains('$') { id.to_owned() } else { format!("${id}:foo") };
let auth_events = auth_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();

28
examples/joke_bot/src/main.rs
View File

@ -22,7 +22,7 @@ use tokio_stream::StreamExt as _;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
if let Err(e) = run().await {
eprintln!("{}", e);
eprintln!("{e}");
exit(1)
}
Ok(())
@ -33,7 +33,7 @@ type MatrixClient = client::Client<client::http_client::HyperNativeTls>;
async fn run() -> Result<(), Box<dyn Error>> {
let config =
read_config().await.map_err(|e| format!("configuration in ./config is invalid: {}", e))?;
read_config().await.map_err(|e| format!("configuration in ./config is invalid: {e}"))?;
let http_client =
hyper::Client::builder().build::<_, hyper::Body>(hyper_tls::HttpsConnector::new());
let matrix_client = if let Some(state) = read_state().await.ok().flatten() {
@ -52,8 +52,7 @@ async fn run() -> Result<(), Box<dyn Error>> {
{
eprintln!(
"Failed to persist access token to disk. \
Re-authentication will be required on the next startup: {}",
err
Re-authentication will be required on the next startup: {err}",
);
}
client
@ -95,14 +94,14 @@ async fn run() -> Result<(), Box<dyn Error>> {
if let Err(err) =
handle_message(http_client, matrix_client, e, room_id, user_id).await
{
eprintln!("failed to respond to message: {}", err);
eprintln!("failed to respond to message: {err}");
}
}
});
let invite_futures = response.rooms.invite.iter().map(|(room_id, _)| async move {
if let Err(err) = handle_invitations(http_client, matrix_client, room_id).await {
eprintln!("failed to accept invitation for room {}: {}", &room_id, err);
eprintln!("failed to accept invitation for room {room_id}: {err}");
}
});
@ -127,14 +126,14 @@ async fn create_matrix_session(
let reason = match e {
client::Error::AuthenticationRequired => "invalid credentials specified".to_owned(),
client::Error::Response(response_err) => {
format!("failed to get a response from the server: {}", response_err)
format!("failed to get a response from the server: {response_err}")
}
client::Error::FromHttpResponse(parse_err) => {
format!("failed to parse log in response: {}", parse_err)
format!("failed to parse log in response: {parse_err}")
}
_ => e.to_string(),
};
return Err(format!("Failed to log in: {}", reason).into());
return Err(format!("Failed to log in: {reason}").into());
}
Ok(client)
@ -184,12 +183,12 @@ async fn handle_invitations(
matrix_client: &MatrixClient,
room_id: &RoomId,
) -> Result<(), Box<dyn Error>> {
println!("invited to {}", &room_id);
println!("invited to {room_id}");
matrix_client.send_request(join_room_by_id::v3::Request::new(room_id)).await?;
let greeting = "Hello! My name is Mr. Bot! I like to tell jokes. Like this one: ";
let joke = get_joke(http_client).await.unwrap_or_else(|_| "err... never mind.".to_owned());
let content = RoomMessageEventContent::text_plain(format!("{}\n{}", greeting, joke));
let content = RoomMessageEventContent::text_plain(format!("{greeting}\n{joke}"));
let txn_id = TransactionId::new();
let message = send_message_event::v3::Request::new(room_id, &txn_id, &content)?;
matrix_client.send_request(message).await?;
@ -244,9 +243,10 @@ async fn read_config() -> io::Result<Config> {
"homeserver" => homeserver = Some(value.trim().to_owned()),
// TODO: infer domain from `homeserver`
"username" => {
username = value.trim().to_owned().try_into().map_err(|e| {
format!("invalid Matrix user ID format for `username`: {}", e)
});
username =
value.trim().to_owned().try_into().map_err(|e| {
format!("invalid Matrix user ID format for `username`: {e}")
});
}
"password" => password = Some(value.trim().to_owned()),
_ => {}

2
examples/message_log/src/main.rs
View File

@ -58,7 +58,7 @@ async fn log_messages(
}),
)) = event
{
println!("{:?} in {:?}: {}", sender, room_id, msg_body);
println!("{sender} in {room_id}: {msg_body}");
}
}
}

16
xtask/src/cargo.rs
View File

@ -30,7 +30,7 @@ pub struct Package {
impl Package {
/// Update the version of this crate.
pub fn update_version(&mut self, version: &Version, dry_run: bool) -> Result<()> {
println!("Updating {} to version {}…", self.name, version);
println!("Updating {} to version {version}…", self.name);
if !dry_run {
let mut document = read_file(&self.manifest_path)?.parse::<Document>()?;
@ -96,9 +96,9 @@ impl Package {
..self.version.clone()
};
let update = if changelog.starts_with(&format!("# {}\n", version)) {
let update = if changelog.starts_with(&format!("# {version}\n")) {
false
} else if changelog.starts_with(&format!("# {} (unreleased)\n", version))
} else if changelog.starts_with(&format!("# {version} (unreleased)\n"))
|| changelog.starts_with("# [unreleased]\n")
{
update
@ -124,12 +124,8 @@ impl Package {
};
if update {
let changelog = format!(
"# [unreleased]\n\n# {}\n\n{}\n{}",
self.version,
changes,
&changelog[changes_end..]
);
let rest = &changelog[changes_end..];
let changelog = format!("# [unreleased]\n\n# {}\n\n{changes}\n{rest}", self.version);
write_file(&changelog_path, changelog)?;
}
@ -140,7 +136,7 @@ impl Package {
/// Check if the current version of the crate is published on crates.io.
pub fn is_published(&self, client: &HttpClient) -> Result<bool> {
let response: CratesIoCrate =
client.get(format!("{}/{}/{}", CRATESIO_API, self.name, self.version))?.json()?;
client.get(format!("{CRATESIO_API}/{}/{}", self.name, self.version))?.json()?;
Ok(response.version.is_some())
}

18
xtask/src/release.rs
View File

@ -63,7 +63,7 @@ impl ReleaseTask {
.clone()
.into_iter()
.find(|p| p.name == name)
.ok_or(format!("Package {} not found in cargo metadata", name))?;
.ok_or(format!("Package {name} not found in cargo metadata"))?;
let config = crate::Config::load()?.github;
@ -87,12 +87,11 @@ impl ReleaseTask {
let publish_only = self.package.name == "ruma-identifiers-validation";
println!(
"Starting {} for {}…",
"Starting {} for {title}…",
match prerelease {
true => "pre-release",
false => "release",
},
title
);
if self.is_released()? {
@ -246,7 +245,7 @@ impl ReleaseTask {
if !self.dry_run {
let instructions = "Ready to commit the changes. [continue/abort/diff]: ";
print!("{}", instructions);
print!("{instructions}");
stdout().flush()?;
let mut handle = stdin.lock();
@ -272,7 +271,7 @@ impl ReleaseTask {
println!("Unknown command.");
}
}
print!("{}", instructions);
print!("{instructions}");
stdout().flush()?;
input.clear();
@ -292,11 +291,8 @@ impl ReleaseTask {
/// Check if the tag for the current version of the crate has been pushed on GitHub.
fn is_released(&self) -> Result<bool> {
let response = self.http_client.get(format!(
"{}/releases/tags/{}",
GITHUB_API_RUMA,
self.tag_name()
))?;
let response =
self.http_client.get(format!("{GITHUB_API_RUMA}/releases/tags/{}", self.tag_name()))?;
Ok(response.status() == StatusCode::OK)
}
@ -400,7 +396,7 @@ impl VersionExt for Version {
fn increment_pre_number(&mut self) {
if let Some((prefix, num)) = self.pre.as_str().rsplit_once('.') {
if let Ok(num) = num.parse::<u8>() {
self.pre = semver::Prerelease::new(&format!("{}.{}", prefix, num + 1)).unwrap();
self.pre = semver::Prerelease::new(&format!("{prefix}.{}", num + 1)).unwrap();
}
}
}

2
xtask/src/util.rs
View File

@ -9,7 +9,7 @@ pub fn ask_yes_no(question: &str) -> Result<bool> {
let mut input = String::new();
let stdin = stdin();
print!("{} [y/N]: ", question);
print!("{question} [y/N]: ");
stdout().flush()?;
let mut handle = stdin.lock();