char
/
matrix-rust-sdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

various typos

master
Jonathan de Jong 2021-06-05 14:35:20 +02:00
parent 0df782e93e
commit 74a6d39b9f
25 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
matrix_sdk/examples/cross_signing_bootstrap.rs
View File

@ -40,7 +40,7 @@ async fn bootstrap(client: Client, user_id: UserId, password: String) {
.await
.expect("Couldn't bootstrap cross signing")
} else {
panic!("Error durign cross signing bootstrap {:#?}", e);
panic!("Error during cross-signing bootstrap {:#?}", e);
}
}

2
matrix_sdk/src/event_handler/mod.rs
View File

@ -215,7 +215,7 @@ impl Handler {
pub(crate) async fn handle_stripped_state_event(
&self,
// TODO these events are only handleted in invited rooms.
// TODO these events are only handled in invited rooms.
room: Room,
event: &AnyStrippedStateEvent,
) {

4
matrix_sdk/src/room/common.rs
View File

@ -12,7 +12,7 @@ use matrix_sdk_common::{
use crate::{BaseRoom, Client, Result, RoomMember};
/// A struct containing methodes that are common for Joined, Invited and Left
/// A struct containing methods that are common for Joined, Invited and Left
/// Rooms
#[derive(Debug, Clone)]
pub struct Common {
@ -55,7 +55,7 @@ impl Common {
/// Only invited and left rooms can be joined via this method
pub(crate) async fn join(&self) -> Result<()> {
let request = join_room_by_id::Request::new(self.inner.room_id());
let _resposne = self.client.send(request, None).await?;
let _response = self.client.send(request, None).await?;
Ok(())
}

2
matrix_sdk/src/room/invited.rs
View File

@ -4,7 +4,7 @@ use crate::{room::Common, BaseRoom, Client, Result, RoomType};
/// A room in the invited state.
///
/// This struct contains all methodes specific to a `Room` with type
/// This struct contains all methods specific to a `Room` with type
/// `RoomType::Invited`. Operations may fail once the underlying `Room` changes
/// `RoomType`.
#[derive(Debug, Clone)]

2
matrix_sdk/src/room/joined.rs
View File

@ -47,7 +47,7 @@ const TYPING_NOTICE_RESEND_TIMEOUT: Duration = Duration::from_secs(3);
/// A room in the joined state.
///
/// The `JoinedRoom` contains all methodes specific to a `Room` with type
/// The `JoinedRoom` contains all methods specific to a `Room` with type
/// `RoomType::Joined`. Operations may fail once the underlying `Room` changes
/// `RoomType`.
#[derive(Debug, Clone)]

2
matrix_sdk/src/room/left.rs
View File

@ -6,7 +6,7 @@ use crate::{room::Common, BaseRoom, Client, Result, RoomType};
/// A room in the left state.
///
/// This struct contains all methodes specific to a `Room` with type
/// This struct contains all methods specific to a `Room` with type
/// `RoomType::Left`. Operations may fail once the underlying `Room` changes
/// `RoomType`.
#[derive(Debug, Clone)]

2
matrix_sdk/src/sas.rs
View File

@ -137,7 +137,7 @@ impl Sas {
self.inner.is_cancelled()
}
/// Get the other users device that we're veryfying.
/// Get the other users device that we're verifying.
pub fn other_device(&self) -> &ReadOnlyDevice {
self.inner.other_device()
}

2
matrix_sdk_appservice/src/lib.rs
View File

@ -214,7 +214,7 @@ impl Appservice {
/// * `server_name` - The server name to use when constructing user ids from
/// the localpart.
/// * `registration` - The [Appservice Registration] to use when interacting
/// with the homserver.
/// with the homeserver.
///
/// [Appservice Registration]: https://matrix.org/docs/spec/application_service/r0.1.2#registration
pub async fn new(

4
matrix_sdk_base/src/client.rs
View File

@ -749,8 +749,8 @@ impl BaseClient {
if let Some(o) = &*olm {
// Let the crypto machine handle the sync response, this
// decryptes to-device events, but leaves room events alone.
// This makes sure that we have the deryption keys for the room
// decrypts to-device events, but leaves room events alone.
// This makes sure that we have the decryption keys for the room
// events at hand.
o.receive_sync_changes(to_device, &device_lists, &device_one_time_keys_count)
.await?

4
matrix_sdk_base/src/rooms/normal.rs
View File

@ -46,7 +46,7 @@ use crate::{
};
/// The underlying room data structure collecting state for joined, left and
/// invtied rooms.
/// invited rooms.
#[derive(Debug, Clone)]
pub struct Room {
room_id: Arc<RoomId>,
@ -178,7 +178,7 @@ impl Room {
/// If this room is a direct message, get the member that we're sharing the
/// room with.
///
/// *Note*: The member list might have been moddified in the meantime and
/// *Note*: The member list might have been modified in the meantime and
/// the target might not even be in the room anymore. This setting should
/// only be considered as guidance.
pub fn direct_target(&self) -> Option<UserId> {

6
matrix_sdk_common/src/deserialized_responses.rs
View File

@ -120,7 +120,7 @@ pub struct SyncResponse {
pub presence: Presence,
/// The global private data created by this user.
pub account_data: GlobalAccountData,
/// Messages sent dirrectly between devices.
/// Messages sent directly between devices.
pub to_device: ToDevice,
/// Information on E2E device updates.
///
@ -129,7 +129,7 @@ pub struct SyncResponse {
/// For each key algorithm, the number of unclaimed one-time keys
/// currently held on the server for a device.
pub device_one_time_keys_count: BTreeMap<DeviceKeyAlgorithm, u64>,
/// Collection of ambiguioty changes that room member events trigger.
/// Collection of ambiguity changes that room member events trigger.
pub ambiguity_changes: AmbiguityChanges,
/// New notifications per room.
pub notifications: BTreeMap<RoomId, Vec<Notification>>,
@ -343,6 +343,6 @@ impl From<StrippedMemberEvent> for StrippedStateEvent<MemberEventContent> {
pub struct MembersResponse {
/// The list of members events.
pub chunk: Vec<MemberEvent>,
/// Collection of ambiguioty changes that room member events trigger.
/// Collection of ambiguity changes that room member events trigger.
pub ambiguity_changes: AmbiguityChanges,
}

2
matrix_sdk_crypto/src/file_encryption/key_export.rs
View File

@ -115,7 +115,7 @@ pub fn decrypt_key_export(
///
/// * `rounds` - The number of rounds that should be used for the key
/// derivation when the passphrase gets turned into an AES key. More rounds are
/// increasingly computationally intensive and as such help against bruteforce
/// increasingly computationally intensive and as such help against brute-force
/// attacks. Should be at least `10000`, while values in the `100000` ranges
/// should be preferred.
///

2
matrix_sdk_crypto/src/identities/device.rs
View File

@ -385,7 +385,7 @@ impl ReadOnlyDevice {
// only the identity is trusted, if the identity and the device are
// trusted.
if self.is_trusted() {
// If the device is localy marked as verified just return so, no
// If the device is locally marked as verified just return so, no
// need to check signatures.
true
} else {

2
matrix_sdk_crypto/src/identities/manager.rs
View File

@ -320,7 +320,7 @@ impl IdentityManager {
/// Get a key query request if one is needed.
///
/// Returns a key query reqeust if the client should query E2E keys,
/// Returns a key query request if the client should query E2E keys,
/// otherwise None.
///
/// The response of a successful key query requests needs to be passed to

2
matrix_sdk_crypto/src/identities/mod.rs
View File

@ -38,7 +38,7 @@
//! additional public keys for other users, while it will give us access to all
//! 3 for our own user.
//!
//! Both identity sets need to reqularly fetched from the server using the
//! Both identity sets need to regularly fetched from the server using the
//! `/keys/query` API call.
pub(crate) mod device;
mod manager;

10
matrix_sdk_crypto/src/key_request.rs
View File

@ -161,7 +161,7 @@ impl OutgoingKeyRequest {
wrap_key_request_content(self.request_recipient.clone(), self.request_id, &content)
}
fn to_cancelation(
fn to_cancellation(
&self,
own_device_id: &DeviceId,
) -> Result<OutgoingRequest, serde_json::Error> {
@ -594,7 +594,7 @@ impl KeyRequestMachine {
let request = self.store.get_key_request_by_info(&key_info).await?;
if let Some(request) = request {
let cancel = request.to_cancelation(self.device_id())?;
let cancel = request.to_cancellation(self.device_id())?;
let request = request.to_request(self.device_id())?;
Ok((Some(cancel), request))
@ -707,7 +707,7 @@ impl KeyRequestMachine {
/// Mark the given outgoing key info as done.
///
/// This will queue up a request cancelation.
/// This will queue up a request cancellation.
async fn mark_as_done(&self, key_info: OutgoingKeyRequest) -> Result<(), CryptoStoreError> {
// TODO perhaps only remove the key info if the first known index is 0.
trace!("Successfully received a forwarded room key for {:#?}", key_info);
@ -717,7 +717,7 @@ impl KeyRequestMachine {
// can delete it in one transaction.
self.delete_key_info(&key_info).await?;
let request = key_info.to_cancelation(self.device_id())?;
let request = key_info.to_cancellation(self.device_id())?;
self.outgoing_to_device_requests.insert(request.request_id, request);
Ok(())
@ -1351,7 +1351,7 @@ mod test {
// Receive the room key request from alice.
bob_machine.receive_incoming_key_request(&event);
bob_machine.collect_incoming_key_requests().await.unwrap();
// Bob doens't have an outgoing requests since we're lacking a session.
// Bob doesn't have an outgoing requests since we're lacking a session.
assert!(bob_machine.outgoing_to_device_requests().await.unwrap().is_empty());
assert!(!bob_machine.users_for_key_claim.is_empty());
assert!(!bob_machine.wait_queue.is_empty());

22
matrix_sdk_crypto/src/machine.rs
View File

@ -76,7 +76,7 @@ pub struct OlmMachine {
account: Account,
/// The private part of our cross signing identity.
/// Used to sign devices and other users, might be missing if some other
/// device bootstraped cross signing or cross signing isn't bootstrapped at
/// device bootstrapped cross signing or cross signing isn't bootstrapped at
/// all.
user_identity: Arc<Mutex<PrivateCrossSigningIdentity>>,
/// Store for the encryption keys.
@ -735,7 +735,7 @@ impl OlmMachine {
self.account.update_uploaded_key_count(key_count).await;
}
async fn handle_to_device_evnet(&self, event: &AnyToDeviceEvent) {
async fn handle_to_device_event(&self, event: &AnyToDeviceEvent) {
match event {
AnyToDeviceEvent::RoomKeyRequest(e) => {
self.key_request_machine.receive_incoming_key_request(&e)
@ -771,7 +771,7 @@ impl OlmMachine {
/// response.
///
/// * `changed_devices` - The list of devices that changed in this sync
/// resopnse.
/// response.
///
/// * `one_time_keys_count` - The current one-time keys counts that the sync
/// response returned.
@ -855,12 +855,12 @@ impl OlmMachine {
}
if let Some(event) = decrypted.deserialized_event {
self.handle_to_device_evnet(&event).await;
self.handle_to_device_event(&event).await;
}
raw_event = decrypted.event;
}
e => self.handle_to_device_evnet(&e).await,
e => self.handle_to_device_event(&e).await,
}
events.push(raw_event);
@ -880,11 +880,11 @@ impl OlmMachine {
/// Request a room key from our devices.
///
/// This method will return a request cancelation and a new key request if
/// This method will return a request cancellation and a new key request if
/// the key was already requested, otherwise it will return just the key
/// request.
///
/// The request cancelation *must* be sent out before the request is sent
/// The request cancellation *must* be sent out before the request is sent
/// out, otherwise devices will ignore the key request.
///
/// # Arguments
@ -942,7 +942,7 @@ impl OlmMachine {
algorithm_info: AlgorithmInfo::MegolmV1AesSha2 {
curve25519_key: session.sender_key().to_owned(),
sender_claimed_keys: session.signing_keys().to_owned(),
forwarding_curve25519_key_chain: session.forwading_key_chain().to_vec(),
forwarding_curve25519_key_chain: session.forwarding_key_chain().to_vec(),
},
verification_state,
})
@ -1167,7 +1167,7 @@ impl OlmMachine {
///
/// * `predicate` - A closure that will be called for every known
/// `InboundGroupSession`, which represents a room key. If the closure
/// returns `true` the `InboundGroupSessoin` will be included in the export,
/// returns `true` the `InboundGroupSession` will be included in the export,
/// if the closure returns `false` it will not be included.
///
/// # Panics
@ -1318,10 +1318,10 @@ pub(crate) mod test {
let alice_device = alice_device_id();
let alice = OlmMachine::new(&alice_id, &alice_device);
let alice_deivce = ReadOnlyDevice::from_machine(&alice).await;
let alice_device = ReadOnlyDevice::from_machine(&alice).await;
let bob_device = ReadOnlyDevice::from_machine(&bob).await;
alice.store.save_devices(&[bob_device]).await.unwrap();
bob.store.save_devices(&[alice_deivce]).await.unwrap();
bob.store.save_devices(&[alice_device]).await.unwrap();
(alice, bob, otk)
}

14
matrix_sdk_crypto/src/olm/group_sessions/inbound.rs
View File

@ -42,9 +42,9 @@ use zeroize::Zeroizing;
use super::{ExportedGroupSessionKey, ExportedRoomKey, GroupSessionKey};
use crate::error::{EventError, MegolmResult};
// TODO add creation times to the inbound grop sessions so we can export
// TODO add creation times to the inbound group sessions so we can export
// sessions that were created between some time period, this should only be set
// for non-imported sessoins.
// for non-imported sessions.
/// Inbound group session.
///
@ -172,7 +172,7 @@ impl InboundGroupSession {
sender_key: self.sender_key.to_string(),
signing_key: (&*self.signing_keys).clone(),
room_id: (&*self.room_id).clone(),
forwarding_chains: self.forwading_key_chain().to_vec(),
forwarding_chains: self.forwarding_key_chain().to_vec(),
imported: *self.imported,
history_visibility: self.history_visibility.as_ref().clone(),
}
@ -201,7 +201,7 @@ impl InboundGroupSession {
/// Each ed25519 key represents a single device. If device A forwards the
/// session to device B and device B to C this list will contain the ed25519
/// keys of A and B.
pub fn forwading_key_chain(&self) -> &[String] {
pub fn forwarding_key_chain(&self) -> &[String] {
&self.forwarding_chains
}
@ -218,7 +218,7 @@ impl InboundGroupSession {
room_id: (&*self.room_id).clone(),
sender_key: (&*self.sender_key).to_owned(),
session_id: self.session_id().to_owned(),
forwarding_curve25519_key_chain: self.forwading_key_chain().to_vec(),
forwarding_curve25519_key_chain: self.forwarding_key_chain().to_vec(),
sender_claimed_keys: (&*self.signing_keys).clone(),
session_key,
}
@ -361,10 +361,10 @@ pub struct PickledInboundGroupSession {
/// The id of the room that the session is used in.
pub room_id: RoomId,
/// The list of claimed ed25519 that forwarded us this key. Will be None if
/// we dirrectly received this session.
/// we directly received this session.
#[serde(default)]
pub forwarding_chains: Vec<String>,
/// Flag remembering if the session was dirrectly sent to us by the sender
/// Flag remembering if the session was directly sent to us by the sender
/// or if it was imported.
pub imported: bool,
/// History visibility of the room when the session was created.

4
matrix_sdk_crypto/src/olm/session.rs
View File

@ -265,8 +265,8 @@ pub struct PickledSession {
pub struct SessionPickle(String);
impl From<String> for SessionPickle {
fn from(picle_string: String) -> Self {
SessionPickle(picle_string)
fn from(pickle_string: String) -> Self {
SessionPickle(pickle_string)
}
}

2
matrix_sdk_crypto/src/session_manager/group_sessions.rs
View File

@ -503,7 +503,7 @@ impl GroupSessionManager {
.collect();
for result in join_all(tasks).await {
let used_sessions: OlmResult<Vec<Session>> = result.expect("Encryption task paniced");
let used_sessions: OlmResult<Vec<Session>> = result.expect("Encryption task panicked");
changes.sessions.extend(used_sessions?);
}

10
matrix_sdk_crypto/src/store/mod.rs
View File

@ -279,7 +279,7 @@ pub enum CryptoStoreError {
#[error("An object failed to be decrypted while unpickling")]
UnpicklingError,
/// A Matirx identifier failed to be validated.
/// A Matrix identifier failed to be validated.
#[error(transparent)]
IdentifierValidation(#[from] IdentifierValidationError),
@ -338,7 +338,7 @@ pub trait CryptoStore: AsyncTraitDeps {
/// Get all the inbound group sessions we have stored.
async fn get_inbound_group_sessions(&self) -> Result<Vec<InboundGroupSession>>;
/// Get the outobund group sessions we have stored that is used for the
/// Get the outbound group sessions we have stored that is used for the
/// given room.
async fn get_outbound_group_sessions(
&self,
@ -399,7 +399,7 @@ pub trait CryptoStore: AsyncTraitDeps {
/// Check if a hash for an Olm message stored in the database.
async fn is_message_known(&self, message_hash: &OlmMessageHash) -> Result<bool>;
/// Get an outoing key request that we created that matches the given
/// Get an outgoing key request that we created that matches the given
/// request id.
///
/// # Arguments
@ -411,7 +411,7 @@ pub trait CryptoStore: AsyncTraitDeps {
request_id: Uuid,
) -> Result<Option<OutgoingKeyRequest>>;
/// Get an outoing key request that we created that matches the given
/// Get an outgoing key request that we created that matches the given
/// requested key info.
///
/// # Arguments
@ -425,7 +425,7 @@ pub trait CryptoStore: AsyncTraitDeps {
/// Get all outgoing key requests that we have in the store.
async fn get_unsent_key_requests(&self) -> Result<Vec<OutgoingKeyRequest>>;
/// Delete an outoing key request that we created that matches the given
/// Delete an outgoing key request that we created that matches the given
/// request id.
///
/// # Arguments

10
matrix_sdk_crypto/src/verification/machine.rs
View File

@ -167,7 +167,7 @@ impl VerificationMachine {
return Ok(());
};
let flow_id_missmatch = || {
let flow_id_mismatch = || {
warn!(
sender = event.sender().as_str(),
flow_id = flow_id.as_str(),
@ -215,7 +215,7 @@ impl VerificationMachine {
// TODO remove this unwrap.
request.receive_ready(event.sender(), c).unwrap();
} else {
flow_id_missmatch();
flow_id_mismatch();
}
}
}
@ -224,7 +224,7 @@ impl VerificationMachine {
if request.flow_id() == &flow_id {
request.receive_start(event.sender(), &c).await?
} else {
flow_id_missmatch();
flow_id_mismatch();
}
} else if let FlowId::ToDevice(_) = flow_id {
// TODO remove this soon, this has been deprecated by
@ -268,7 +268,7 @@ impl VerificationMachine {
);
}
} else {
flow_id_missmatch();
flow_id_mismatch();
}
}
}
@ -281,7 +281,7 @@ impl VerificationMachine {
self.mark_sas_as_done(s, content).await?;
}
} else {
flow_id_missmatch();
flow_id_mismatch();
}
}
}

4
matrix_sdk_crypto/src/verification/requests.rs
View File

@ -484,7 +484,7 @@ impl RequestState<Requested> {
flow_id: &FlowId,
content: &RequestContent,
) -> RequestState<Requested> {
// TODO only create this if we suport the methods
// TODO only create this if we support the methods
RequestState {
account,
private_cross_signing_identity: private_identity,
@ -617,7 +617,7 @@ impl RequestState<Ready> {
}
},
m => {
warn!(method =? m, "Received a key verificaton start event with an unsupported method")
warn!(method =? m, "Received a key verification start event with an unsupported method")
}
}

2
matrix_sdk_crypto/src/verification/sas/sas_state.rs
View File

@ -274,7 +274,7 @@ pub struct MacReceived {
/// The SAS state we're going to be in after we receive a MAC event in a DM. DMs
/// require a final message `m.key.verification.done` message to conclude the
/// verificaton. This state waits for such a message.
/// verification. This state waits for such a message.
#[derive(Clone, Debug)]
pub struct WaitingForDone {
verified_devices: Arc<[ReadOnlyDevice]>,