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

Replace remaining uses of boxed IDs with dedicated owned ones

Browse Source
This commit is contained in:
Jonas Platte 2022-04-14 20:22:52 +02:00 committed by Jonas Platte
parent 76478de953
commit efe48af207
23 changed files with 134 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -15,7 +15,7 @@ pub mod unban_user;
use std::collections::BTreeMap;
use ruma_common::{
serde::Incoming, thirdparty::Medium, OwnedServerName, ServerSigningKeyId, UserId,
serde::Incoming, thirdparty::Medium, OwnedServerName, OwnedServerSigningKeyId, UserId,
};
use serde::Serialize;
@ -34,7 +34,7 @@ pub struct ThirdPartySigned<'a> {
pub token: &'a str,
/// A signatures object containing a signature of the entire signed object.
pub signatures: BTreeMap<OwnedServerName, BTreeMap<Box<ServerSigningKeyId>, String>>,
pub signatures: BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, String>>,
}
impl<'a> ThirdPartySigned<'a> {
@ -44,7 +44,7 @@ impl<'a> ThirdPartySigned<'a> {
sender: &'a UserId,
mxid: &'a UserId,
token: &'a str,
signatures: BTreeMap<OwnedServerName, BTreeMap<Box<ServerSigningKeyId>, String>>,
signatures: BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, String>>,
) -> Self {
Self { sender, mxid, token, signatures }
}

8
crates/ruma-common/src/events.rs
View File

@ -41,8 +41,10 @@
//! [`OriginalSyncMessageLikeEvent`] struct but any [`OriginalMessageLikeEvent`] struct would work.
//!
//! ```rust
//! use ruma_common::events::{macros::EventContent, OriginalSyncMessageLikeEvent};
//! use ruma_common::EventId;
//! use ruma_common::{
//! events::{macros::EventContent, OriginalSyncMessageLikeEvent},
//! OwnedEventId,
//! };
//! use serde::{Deserialize, Serialize};
//!
//! #[derive(Clone, Debug, Deserialize, Serialize)]
@ -51,7 +53,7 @@
//! #[serde(rename = "m.annotation")]
//! Annotation {
//! /// The event this reaction relates to.
//! event_id: Box<EventId>,
//! event_id: OwnedEventId,
//! /// The displayable content of the reaction.
//! key: String,
//! },

6
crates/ruma-common/src/events/direct.rs
View File

@ -10,7 +10,7 @@ use std::{
use ruma_macros::EventContent;
use serde::{Deserialize, Serialize};
use crate::{RoomId, UserId};
use crate::{OwnedRoomId, OwnedUserId};
/// The content of an `m.direct` event.
///
@ -21,10 +21,10 @@ use crate::{RoomId, UserId};
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[allow(clippy::exhaustive_structs)]
#[ruma_event(type = "m.direct", kind = GlobalAccountData)]
pub struct DirectEventContent(pub BTreeMap<Box<UserId>, Vec<Box<RoomId>>>);
pub struct DirectEventContent(pub BTreeMap<OwnedUserId, Vec<OwnedRoomId>>);
impl Deref for DirectEventContent {
type Target = BTreeMap<Box<UserId>, Vec<Box<RoomId>>>;
type Target = BTreeMap<OwnedUserId, Vec<OwnedRoomId>>;
fn deref(&self) -> &Self::Target {
&self.0

12
crates/ruma-common/src/events/room/pinned_events.rs
View File

@ -5,7 +5,7 @@
use ruma_macros::EventContent;
use serde::{Deserialize, Serialize};
use crate::EventId;
use crate::OwnedEventId;
/// The content of an `m.room.pinned_events` event.
///
@ -15,12 +15,12 @@ use crate::EventId;
#[ruma_event(type = "m.room.pinned_events", kind = State)]
pub struct RoomPinnedEventsEventContent {
/// An ordered list of event IDs to pin.
pub pinned: Vec<Box<EventId>>,
pub pinned: Vec<OwnedEventId>,
}
impl RoomPinnedEventsEventContent {
/// Creates a new `RoomPinnedEventsEventContent` with the given events.
pub fn new(pinned: Vec<Box<EventId>>) -> Self {
pub fn new(pinned: Vec<OwnedEventId>) -> Self {
Self { pinned }
}
}
@ -45,10 +45,10 @@ mod tests {
let event = OriginalStateEvent {
content: content.clone(),
event_id: EventId::new(server_name).into(),
event_id: EventId::new(server_name),
origin_server_ts: MilliSecondsSinceUnixEpoch(1_432_804_485_886_u64.try_into().unwrap()),
room_id: RoomId::new(server_name).into(),
sender: UserId::new(server_name).into(),
room_id: RoomId::new(server_name),
sender: UserId::new(server_name),
state_key: "".into(),
unsigned: StateUnsigned::default(),
};

5
crates/ruma-common/src/identifiers/client_secret.rs
View File

@ -21,9 +21,10 @@ impl ClientSecret {
/// This will currently be a UUID without hyphens, but no guarantees are made about the
/// structure of client secrets generated from this function.
#[cfg(feature = "rand")]
pub fn new() -> Box<Self> {
#[allow(clippy::new_ret_no_self)]
pub fn new() -> OwnedClientSecret {
let id = uuid::Uuid::new_v4();
Self::from_box(id.to_simple().to_string().into_boxed_str())
ClientSecret::from_borrowed(&id.to_simple().to_string()).to_owned()
}
}

15
crates/ruma-common/src/identifiers/device_id.rs
View File

@ -11,7 +11,7 @@ use super::generate_localpart;
/// # Example
///
/// ```
/// use ruma_common::{device_id, DeviceId};
/// use ruma_common::{device_id, DeviceId, OwnedDeviceId};
///
/// # #[cfg(feature = "rand")] {
/// let random_id = DeviceId::new();
@ -24,7 +24,7 @@ use super::generate_localpart;
/// let ref_id: &DeviceId = "abcdefghi".into();
/// assert_eq!(ref_id.as_str(), "abcdefghi");
///
/// let owned_id: Box<DeviceId> = "ijklmnop".into();
/// let owned_id: OwnedDeviceId = "ijklmnop".into();
/// assert_eq!(owned_id.as_str(), "ijklmnop");
/// ```
#[repr(transparent)]
@ -34,14 +34,15 @@ pub struct DeviceId(str);
impl DeviceId {
/// Generates a random `DeviceId`, suitable for assignment to a new device.
#[cfg(feature = "rand")]
pub fn new() -> Box<Self> {
Self::from_box(generate_localpart(8))
#[allow(clippy::new_ret_no_self)]
pub fn new() -> OwnedDeviceId {
Self::from_borrowed(&generate_localpart(8)).to_owned()
}
}
#[cfg(all(test, feature = "rand"))]
mod tests {
use super::DeviceId;
use super::{DeviceId, OwnedDeviceId};
#[test]
fn generate_device_id() {
@ -56,14 +57,14 @@ mod tests {
#[test]
fn create_boxed_device_id_from_str() {
let box_id: Box<DeviceId> = "12345678".into();
let box_id: OwnedDeviceId = "12345678".into();
assert_eq!(box_id.as_str(), "12345678");
}
#[test]
fn create_device_id_from_box() {
let box_str: Box<str> = "ijklmnop".into();
let device_id: Box<DeviceId> = box_str.into();
let device_id: OwnedDeviceId = box_str.into();
assert_eq!(device_id.as_str(), "ijklmnop");
}
}

8
crates/ruma-common/src/identifiers/device_key_id.rs
View File

@ -12,7 +12,7 @@ pub struct DeviceKeyId(str);
impl DeviceKeyId {
/// Create a `DeviceKeyId` from a `DeviceKeyAlgorithm` and a `DeviceId`.
pub fn from_parts(algorithm: DeviceKeyAlgorithm, device_id: &DeviceId) -> Box<Self> {
pub fn from_parts(algorithm: DeviceKeyAlgorithm, device_id: &DeviceId) -> OwnedDeviceKeyId {
let algorithm: &str = algorithm.as_ref();
let device_id: &str = device_id.as_ref();
@ -21,7 +21,7 @@ impl DeviceKeyId {
res.push(':');
res.push_str(device_id);
Self::from_box(res.into())
Self::from_borrowed(&res).to_owned()
}
/// Returns key algorithm of the device key ID.
@ -43,7 +43,7 @@ impl DeviceKeyId {
mod tests {
use std::convert::TryFrom;
use super::DeviceKeyId;
use super::{DeviceKeyId, OwnedDeviceKeyId};
use crate::identifiers::{crypto_algorithms::DeviceKeyAlgorithm, IdParseError};
#[test]
@ -65,7 +65,7 @@ mod tests {
#[test]
fn deserialize_device_key_id() {
let deserialized: Box<DeviceKeyId> =
let deserialized: OwnedDeviceKeyId =
serde_json::from_value(serde_json::json!("ed25519:JLAFKJWSCS")).unwrap();
let expected = <&DeviceKeyId>::try_from("ed25519:JLAFKJWSCS").unwrap();

14
crates/ruma-common/src/identifiers/event_id.rs
View File

@ -48,8 +48,10 @@ impl EventId {
/// This should only be used for events in the original format as used by Matrix room versions
/// 1 and 2.
#[cfg(feature = "rand")]
pub fn new(server_name: &ServerName) -> Box<Self> {
Self::from_box(format!("${}:{}", super::generate_localpart(18), server_name).into())
#[allow(clippy::new_ret_no_self)]
pub fn new(server_name: &ServerName) -> OwnedEventId {
Self::from_borrowed(&format!("${}:{}", super::generate_localpart(18), server_name))
.to_owned()
}
/// Returns the event's unique ID.
@ -78,7 +80,7 @@ impl EventId {
mod tests {
use std::convert::TryFrom;
use super::EventId;
use super::{EventId, OwnedEventId};
use crate::IdParseError;
#[test]
@ -158,7 +160,7 @@ mod tests {
#[test]
fn deserialize_valid_original_event_id() {
assert_eq!(
serde_json::from_str::<Box<EventId>>(r#""$39hvsi03hlne:example.com""#)
serde_json::from_str::<OwnedEventId>(r#""$39hvsi03hlne:example.com""#)
.expect("Failed to convert JSON to EventId"),
<&EventId>::try_from("$39hvsi03hlne:example.com").expect("Failed to create EventId.")
);
@ -167,7 +169,7 @@ mod tests {
#[test]
fn deserialize_valid_base64_event_id() {
assert_eq!(
serde_json::from_str::<Box<EventId>>(
serde_json::from_str::<OwnedEventId>(
r#""$acR1l0raoZnm60CBwAVgqbZqoO/mYU81xysh1u7XcJk""#
)
.expect("Failed to convert JSON to EventId"),
@ -179,7 +181,7 @@ mod tests {
#[test]
fn deserialize_valid_url_safe_base64_event_id() {
assert_eq!(
serde_json::from_str::<Box<EventId>>(
serde_json::from_str::<OwnedEventId>(
r#""$Rqnc-F-dvnEYJTyHq_iKxU2bZ1CI92-kuZq3a5lr5Zg""#
)
.expect("Failed to convert JSON to EventId"),

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

@ -17,7 +17,7 @@ pub struct KeyId<A, K: ?Sized>(PhantomData<(A, K)>, str);
impl<A, K: ?Sized> KeyId<A, K> {
/// Creates a new `KeyId` from an algorithm and key name.
pub fn from_parts(algorithm: A, key_name: &K) -> Box<Self>
pub fn from_parts(algorithm: A, key_name: &K) -> OwnedKeyId<A, K>
where
A: AsRef<str>,
K: AsRef<str>,
@ -30,7 +30,7 @@ impl<A, K: ?Sized> KeyId<A, K> {
res.push(':');
res.push_str(key_name);
Self::from_box(res.into())
Self::from_borrowed(&res).to_owned()
}
/// Returns key algorithm of the key ID.

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

@ -9,7 +9,10 @@ use ruma_identifiers_validation::{
};
use url::Url;
use super::{EventId, OwnedServerName, RoomAliasId, RoomId, RoomOrAliasId, ServerName, UserId};
use super::{
EventId, OwnedEventId, OwnedRoomAliasId, OwnedRoomId, OwnedRoomOrAliasId, OwnedServerName,
OwnedUserId, RoomAliasId, RoomId, RoomOrAliasId, ServerName, UserId,
};
use crate::PrivOwnedStr;
const MATRIX_TO_BASE_URL: &str = "https://matrix.to/#/";
@ -46,16 +49,16 @@ const RESERVED: &AsciiSet = &CONTROLS
#[non_exhaustive]
pub enum MatrixId {
/// A room ID.
Room(Box<RoomId>),
Room(OwnedRoomId),
/// A room alias.
RoomAlias(Box<RoomAliasId>),
RoomAlias(OwnedRoomAliasId),
/// A user ID.
User(Box<UserId>),
User(OwnedUserId),
/// An event ID.
Event(Box<RoomOrAliasId>, Box<EventId>),
Event(OwnedRoomOrAliasId, OwnedEventId),
}
impl MatrixId {

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

@ -63,7 +63,7 @@ impl RoomAliasId {
mod tests {
use std::convert::TryFrom;
use super::RoomAliasId;
use super::{OwnedRoomAliasId, RoomAliasId};
use crate::IdParseError;
#[test]
@ -97,7 +97,7 @@ mod tests {
#[test]
fn deserialize_valid_room_alias_id() {
assert_eq!(
serde_json::from_str::<Box<RoomAliasId>>(r##""#ruma:example.com""##)
serde_json::from_str::<OwnedRoomAliasId>(r##""#ruma:example.com""##)
.expect("Failed to convert JSON to RoomAliasId"),
<&RoomAliasId>::try_from("#ruma:example.com").expect("Failed to create RoomAliasId.")
);

10
crates/ruma-common/src/identifiers/room_id.rs
View File

@ -27,8 +27,10 @@ impl RoomId {
///
/// Fails if the given homeserver cannot be parsed as a valid host.
#[cfg(feature = "rand")]
pub fn new(server_name: &ServerName) -> Box<Self> {
Self::from_box(format!("!{}:{}", super::generate_localpart(18), server_name).into())
#[allow(clippy::new_ret_no_self)]
pub fn new(server_name: &ServerName) -> OwnedRoomId {
Self::from_borrowed(&format!("!{}:{}", super::generate_localpart(18), server_name))
.to_owned()
}
/// Returns the rooms's unique ID.
@ -110,7 +112,7 @@ impl RoomId {
mod tests {
use std::convert::TryFrom;
use super::RoomId;
use super::{OwnedRoomId, RoomId};
use crate::IdParseError;
#[test]
@ -157,7 +159,7 @@ mod tests {
#[test]
fn deserialize_valid_room_id() {
assert_eq!(
serde_json::from_str::<Box<RoomId>>(r#""!29fhd83h92h0:example.com""#)
serde_json::from_str::<OwnedRoomId>(r#""!29fhd83h92h0:example.com""#)
.expect("Failed to convert JSON to RoomId"),
<&RoomId>::try_from("!29fhd83h92h0:example.com").expect("Failed to create RoomId.")
);

44
crates/ruma-common/src/identifiers/room_or_room_alias_id.rs
View File

@ -4,7 +4,7 @@ use std::{convert::TryFrom, hint::unreachable_unchecked};
use ruma_macros::IdZst;
use super::{server_name::ServerName, RoomAliasId, RoomId};
use super::{server_name::ServerName, OwnedRoomAliasId, OwnedRoomId, RoomAliasId, RoomId};
/// A Matrix [room ID] or a Matrix [room alias ID].
///
@ -82,15 +82,17 @@ impl<'a> From<&'a RoomAliasId> for &'a RoomOrAliasId {
}
}
impl From<Box<RoomId>> for Box<RoomOrAliasId> {
fn from(room_id: Box<RoomId>) -> Self {
RoomOrAliasId::from_box(room_id.into_owned())
impl From<OwnedRoomId> for OwnedRoomOrAliasId {
fn from(room_id: OwnedRoomId) -> Self {
// FIXME: Don't allocate
RoomOrAliasId::from_borrowed(room_id.as_str()).to_owned()
}
}
impl From<Box<RoomAliasId>> for Box<RoomOrAliasId> {
fn from(room_alias_id: Box<RoomAliasId>) -> Self {
RoomOrAliasId::from_box(room_alias_id.into_owned())
impl From<OwnedRoomAliasId> for OwnedRoomOrAliasId {
fn from(room_alias_id: OwnedRoomAliasId) -> Self {
// FIXME: Don't allocate
RoomOrAliasId::from_borrowed(room_alias_id.as_str()).to_owned()
}
}
@ -116,24 +118,26 @@ impl<'a> TryFrom<&'a RoomOrAliasId> for &'a RoomAliasId {
}
}
impl TryFrom<Box<RoomOrAliasId>> for Box<RoomId> {
type Error = Box<RoomAliasId>;
impl TryFrom<OwnedRoomOrAliasId> for OwnedRoomId {
type Error = OwnedRoomAliasId;
fn try_from(id: Box<RoomOrAliasId>) -> Result<Box<RoomId>, Box<RoomAliasId>> {
fn try_from(id: OwnedRoomOrAliasId) -> Result<OwnedRoomId, OwnedRoomAliasId> {
// FIXME: Don't allocate
match id.variant() {
Variant::RoomId => Ok(RoomId::from_box(id.into_owned())),
Variant::RoomAliasId => Err(RoomAliasId::from_box(id.into_owned())),
Variant::RoomId => Ok(RoomId::from_borrowed(id.as_str()).to_owned()),
Variant::RoomAliasId => Err(RoomAliasId::from_borrowed(id.as_str()).to_owned()),
}
}
}
impl TryFrom<Box<RoomOrAliasId>> for Box<RoomAliasId> {
type Error = Box<RoomId>;
impl TryFrom<OwnedRoomOrAliasId> for OwnedRoomAliasId {
type Error = OwnedRoomId;
fn try_from(id: Box<RoomOrAliasId>) -> Result<Box<RoomAliasId>, Box<RoomId>> {
fn try_from(id: OwnedRoomOrAliasId) -> Result<OwnedRoomAliasId, OwnedRoomId> {
// FIXME: Don't allocate
match id.variant() {
Variant::RoomAliasId => Ok(RoomAliasId::from_box(id.into_owned())),
Variant::RoomId => Err(RoomId::from_box(id.into_owned())),
Variant::RoomAliasId => Ok(RoomAliasId::from_borrowed(id.as_str()).to_owned()),
Variant::RoomId => Err(RoomId::from_borrowed(id.as_str()).to_owned()),
}
}
}
@ -142,7 +146,7 @@ impl TryFrom<Box<RoomOrAliasId>> for Box<RoomAliasId> {
mod tests {
use std::convert::TryFrom;
use super::RoomOrAliasId;
use super::{OwnedRoomOrAliasId, RoomOrAliasId};
use crate::IdParseError;
#[test]
@ -200,7 +204,7 @@ mod tests {
#[test]
fn deserialize_valid_room_id_or_alias_id_with_a_room_alias_id() {
assert_eq!(
serde_json::from_str::<Box<RoomOrAliasId>>(r##""#ruma:example.com""##)
serde_json::from_str::<OwnedRoomOrAliasId>(r##""#ruma:example.com""##)
.expect("Failed to convert JSON to RoomAliasId"),
<&RoomOrAliasId>::try_from("#ruma:example.com").expect("Failed to create RoomAliasId.")
);
@ -209,7 +213,7 @@ mod tests {
#[test]
fn deserialize_valid_room_id_or_alias_id_with_a_room_id() {
assert_eq!(
serde_json::from_str::<Box<RoomOrAliasId>>(r##""!29fhd83h92h0:example.com""##)
serde_json::from_str::<OwnedRoomOrAliasId>(r##""!29fhd83h92h0:example.com""##)
.expect("Failed to convert JSON to RoomId"),
<&RoomOrAliasId>::try_from("!29fhd83h92h0:example.com")
.expect("Failed to create RoomAliasId.")

12
crates/ruma-common/src/identifiers/signatures.rs
View File

@ -2,15 +2,15 @@ use std::{borrow::Borrow, collections::BTreeMap};
use serde::{Deserialize, Serialize};
use super::{DeviceId, KeyName, ServerName, SigningKeyId, UserId};
use super::{OwnedDeviceId, OwnedKeyName, OwnedServerName, OwnedSigningKeyId, OwnedUserId};
/// Map of key identifier to signature values.
pub type EntitySignatures<K> = BTreeMap<Box<SigningKeyId<K>>, String>;
pub type EntitySignatures<K> = BTreeMap<OwnedSigningKeyId<K>, String>;
/// Map of all signatures, grouped by entity
///
/// ```
/// # use ruma_common::{server_name, {KeyId, Signatures, SigningKeyAlgorithm}};
/// # use ruma_common::{server_name, KeyId, Signatures, SigningKeyAlgorithm};
/// let key_identifier = KeyId::from_parts(SigningKeyAlgorithm::Ed25519, "1");
/// let mut signatures = Signatures::new();
/// let server_name = server_name!("example.org");
@ -34,7 +34,7 @@ impl<E: Ord, K: ?Sized> Signatures<E, K> {
pub fn insert(
&mut self,
entity: E,
key_identifier: Box<SigningKeyId<K>>,
key_identifier: OwnedSigningKeyId<K>,
value: String,
) -> Option<String> {
self.0.entry(entity).or_insert_with(Default::default).insert(key_identifier, value)
@ -51,7 +51,7 @@ impl<E: Ord, K: ?Sized> Signatures<E, K> {
}
/// Map of server signatures for an event, grouped by server.
pub type ServerSignatures = Signatures<Box<ServerName>, Box<KeyName>>;
pub type ServerSignatures = Signatures<OwnedServerName, OwnedKeyName>;
/// Map of device signatures for an event, grouped by user.
pub type DeviceSignatures = Signatures<UserId, Box<DeviceId>>;
pub type DeviceSignatures = Signatures<OwnedUserId, OwnedDeviceId>;

5
crates/ruma-common/src/identifiers/transaction_id.rs
View File

@ -18,8 +18,9 @@ impl TransactionId {
/// This will currently be a UUID without hyphens, but no guarantees are made about the
/// structure of transaction IDs generated from this function.
#[cfg(feature = "rand")]
pub fn new() -> Box<Self> {
#[allow(clippy::new_ret_no_self)]
pub fn new() -> OwnedTransactionId {
let id = uuid::Uuid::new_v4();
Self::from_box(id.to_simple().to_string().into_boxed_str())
Self::from_borrowed(&id.to_simple().to_string()).to_owned()
}
}

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

@ -25,10 +25,14 @@ impl UserId {
/// Attempts to generate a `UserId` for the given origin server with a localpart consisting of
/// 12 random ASCII characters.
#[cfg(feature = "rand")]
pub fn new(server_name: &ServerName) -> Box<Self> {
Self::from_box(
format!("@{}:{}", super::generate_localpart(12).to_lowercase(), server_name).into(),
)
#[allow(clippy::new_ret_no_self)]
pub fn new(server_name: &ServerName) -> OwnedUserId {
Self::from_borrowed(&format!(
"@{}:{}",
super::generate_localpart(12).to_lowercase(),
server_name
))
.to_owned()
}
/// Attempts to complete a user ID, by adding the colon + server name and `@` prefix, if not
@ -41,14 +45,14 @@ impl UserId {
pub fn parse_with_server_name(
id: impl AsRef<str> + Into<Box<str>>,
server_name: &ServerName,
) -> Result<Box<Self>, IdParseError> {
) -> Result<OwnedUserId, IdParseError> {
let id_str = id.as_ref();
if id_str.starts_with('@') {
Self::parse(id)
Self::parse(id).map(Into::into)
} else {
let _ = localpart_is_fully_conforming(id_str)?;
Ok(Self::from_box(format!("@{}:{}", id_str, server_name).into()))
Ok(Self::from_borrowed(&format!("@{}:{}", id_str, server_name)).to_owned())
}
}
@ -153,7 +157,7 @@ use ruma_macros::IdZst;
mod tests {
use std::convert::TryFrom;
use super::UserId;
use super::{OwnedUserId, UserId};
use crate::{server_name, IdParseError};
#[test]
@ -272,7 +276,7 @@ mod tests {
#[test]
fn deserialize_valid_user_id() {
assert_eq!(
serde_json::from_str::<Box<UserId>>(r#""@carl:example.com""#)
serde_json::from_str::<OwnedUserId>(r#""@carl:example.com""#)
.expect("Failed to convert JSON to UserId"),
<&UserId>::try_from("@carl:example.com").expect("Failed to create UserId.")
);

8
crates/ruma-common/tests/api/manual_endpoint_impl.rs
View File

@ -12,15 +12,15 @@ use ruma_common::{
AuthScheme, EndpointError, IncomingRequest, IncomingResponse, MatrixVersion, Metadata,
OutgoingRequest, OutgoingResponse, SendAccessToken,
},
RoomAliasId, RoomId,
OwnedRoomAliasId, OwnedRoomId,
};
use serde::{Deserialize, Serialize};
/// A request to create a new room alias.
#[derive(Debug)]
pub struct Request {
pub room_id: Box<RoomId>, // body
pub room_alias: Box<RoomAliasId>, // path
pub room_id: OwnedRoomId, // body
pub room_alias: OwnedRoomAliasId, // path
}
const METADATA: Metadata = Metadata {
@ -104,7 +104,7 @@ impl IncomingRequest for Request {
#[derive(Debug, Serialize, Deserialize)]
struct RequestBody {
room_id: Box<RoomId>,
room_id: OwnedRoomId,
}
/// The response to a request to create a new room alias.

4
crates/ruma-common/tests/api/ruma_api_macros.rs
View File

@ -5,7 +5,7 @@ pub mod some_endpoint {
api::ruma_api,
events::{tag::TagEvent, AnyRoomEvent},
serde::Raw,
UserId,
OwnedUserId,
};
ruma_api! {
@ -33,7 +33,7 @@ pub mod some_endpoint {
// This value will be inserted into the request's URL in place of the
// ":user" path component.
#[ruma_api(path)]
pub user: Box<UserId>,
pub user: OwnedUserId,
}
response: {

12
crates/ruma-common/tests/api/ui/03-move-value.rs
View File

@ -2,7 +2,7 @@
// consume the request/response.
mod newtype_body {
use ruma_common::{api::ruma_api, UserId};
use ruma_common::{api::ruma_api, OwnedUserId};
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct Foo;
@ -25,7 +25,7 @@ mod newtype_body {
pub bar: String,
#[ruma_api(query)]
pub baz: Box<UserId>,
pub baz: OwnedUserId,
#[ruma_api(header = CONTENT_TYPE)]
pub world: String,
@ -42,7 +42,7 @@ mod newtype_body {
}
mod raw_body {
use ruma_common::{api::ruma_api, UserId};
use ruma_common::{api::ruma_api, OwnedUserId};
ruma_api! {
metadata: {
@ -62,7 +62,7 @@ mod raw_body {
pub bar: String,
#[ruma_api(query)]
pub baz: Box<UserId>,
pub baz: OwnedUserId,
#[ruma_api(header = CONTENT_TYPE)]
pub world: String,
@ -79,7 +79,7 @@ mod raw_body {
}
mod plain {
use ruma_common::{api::ruma_api, UserId};
use ruma_common::{api::ruma_api, OwnedUserId};
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct Foo;
@ -101,7 +101,7 @@ mod plain {
pub bar: String,
#[ruma_api(query)]
pub baz: Box<UserId>,
pub baz: OwnedUserId,
#[ruma_api(header = CONTENT_TYPE)]
pub world: String,

10
crates/ruma-federation-api/src/discovery.rs
View File

@ -2,7 +2,9 @@
use std::collections::BTreeMap;
use ruma_common::{serde::Base64, MilliSecondsSinceUnixEpoch, OwnedServerName, ServerSigningKeyId};
use ruma_common::{
serde::Base64, MilliSecondsSinceUnixEpoch, OwnedServerName, OwnedServerSigningKeyId,
};
use serde::{Deserialize, Serialize};
pub mod discover_homeserver;
@ -55,15 +57,15 @@ pub struct ServerSigningKeys {
pub server_name: OwnedServerName,
/// Public keys of the homeserver for verifying digital signatures.
pub verify_keys: BTreeMap<Box<ServerSigningKeyId>, VerifyKey>,
pub verify_keys: BTreeMap<OwnedServerSigningKeyId, VerifyKey>,
/// Public keys that the homeserver used to use and when it stopped using them.
pub old_verify_keys: BTreeMap<Box<ServerSigningKeyId>, OldVerifyKey>,
pub old_verify_keys: BTreeMap<OwnedServerSigningKeyId, OldVerifyKey>,
/// Digital signatures of this object signed using the verify_keys.
///
/// Map of server name to keys by key ID.
pub signatures: BTreeMap<OwnedServerName, BTreeMap<Box<ServerSigningKeyId>, String>>,
pub signatures: BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, String>>,
/// Timestamp when the keys should be refreshed.
///

7
crates/ruma-federation-api/src/discovery/get_remote_server_keys_batch.rs
View File

@ -11,7 +11,8 @@ pub mod v2 {
use std::collections::BTreeMap;
use ruma_common::{
api::ruma_api, serde::Raw, MilliSecondsSinceUnixEpoch, OwnedServerName, ServerSigningKeyId,
api::ruma_api, serde::Raw, MilliSecondsSinceUnixEpoch, OwnedServerName,
OwnedServerSigningKeyId,
};
use serde::{Deserialize, Serialize};
@ -37,7 +38,7 @@ pub mod v2 {
/// notary server must return an empty server_keys array in the response.
///
/// The notary server may return multiple keys regardless of the Key IDs given.
pub server_keys: BTreeMap<OwnedServerName, BTreeMap<Box<ServerSigningKeyId>, QueryCriteria>>,
pub server_keys: BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, QueryCriteria>>,
}
@ -52,7 +53,7 @@ pub mod v2 {
pub fn new(
server_keys: BTreeMap<
OwnedServerName,
BTreeMap<Box<ServerSigningKeyId>, QueryCriteria>,
BTreeMap<OwnedServerSigningKeyId, QueryCriteria>,
>,
) -> Self {
Self { server_keys }

8
crates/ruma-federation-api/src/keys/claim_keys.rs
View File

@ -13,7 +13,7 @@ pub mod v1 {
api::ruma_api,
encryption::OneTimeKey,
serde::{Base64, Raw},
DeviceKeyAlgorithm, DeviceKeyId, OwnedDeviceId, OwnedUserId,
DeviceKeyAlgorithm, OwnedDeviceId, OwnedDeviceKeyId, OwnedUserId,
};
use serde::{Deserialize, Serialize};
@ -58,7 +58,7 @@ pub mod v1 {
/// One time keys for use in pre-key messages
pub type OneTimeKeys =
BTreeMap<OwnedUserId, BTreeMap<OwnedDeviceId, BTreeMap<Box<DeviceKeyId>, Raw<OneTimeKey>>>>;
BTreeMap<OwnedUserId, BTreeMap<OwnedDeviceId, BTreeMap<OwnedDeviceKeyId, Raw<OneTimeKey>>>>;
/// A key and its signature
#[derive(Debug, Clone, Serialize, Deserialize)]
@ -68,14 +68,14 @@ pub mod v1 {
pub key: Base64,
/// Signature of the key object.
pub signatures: BTreeMap<OwnedUserId, BTreeMap<Box<DeviceKeyId>, String>>,
pub signatures: BTreeMap<OwnedUserId, BTreeMap<OwnedDeviceKeyId, String>>,
}
impl KeyObject {
/// Creates a new `KeyObject` with the given key and signatures.
pub fn new(
key: Base64,
signatures: BTreeMap<OwnedUserId, BTreeMap<Box<DeviceKeyId>, String>>,
signatures: BTreeMap<OwnedUserId, BTreeMap<OwnedDeviceKeyId, String>>,
) -> Self {
Self { key, signatures }
}

8
crates/ruma-federation-api/src/thirdparty/bind_callback.rs vendored
View File

@ -12,8 +12,8 @@ pub mod v1 {
use std::collections::BTreeMap;
use ruma_common::{
api::ruma_api, thirdparty::Medium, OwnedRoomId, OwnedServerName, OwnedUserId,
ServerSigningKeyId, UserId,
api::ruma_api, thirdparty::Medium, OwnedRoomId, OwnedServerName, OwnedServerSigningKeyId,
OwnedUserId, UserId,
};
use serde::{Deserialize, Serialize};
@ -88,7 +88,7 @@ pub mod v1 {
pub sender: OwnedUserId,
/// Signature from the identity server using a long-term private key.
pub signed: BTreeMap<OwnedServerName, BTreeMap<Box<ServerSigningKeyId>, String>>,
pub signed: BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, String>>,
}
impl ThirdPartyInvite {
@ -98,7 +98,7 @@ pub mod v1 {
mxid: OwnedUserId,
room_id: OwnedRoomId,
sender: OwnedUserId,
signed: BTreeMap<OwnedServerName, BTreeMap<Box<ServerSigningKeyId>, String>>,
signed: BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, String>>,
) -> Self {
Self { medium: Medium::Email, address, mxid, room_id, sender, signed }
}