chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions 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
42 changed files with 133 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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<_>>();