style: run formatter on comments and doc strings

Author: fewerner

crypto-ffi/src/bundles/commit.rs

@@ -14,7 +14,8 @@ pub struct CommitBundle {
     pub commit: Vec<u8>,
     /// `GroupInfo` if the commit is merged
     pub group_info: GroupInfoBundle,
-    /// An encrypted message to fan out to all other conversation members in the new epoch
+    /// An encrypted message to fan out to all other conversation members in the
+    /// new epoch
     pub encrypted_message: Option<Vec<u8>>,
 }
 

crypto-ffi/src/ciphersuite.rs

@@ -1,8 +1,9 @@
 //! Ciphersuites in bindings
 //!
-//! Both wasm-bindgen and uniffi support emitting enums, as long as they directly implement the enum;
-//! it doesn't work on newtypes around external enums. We therefore redefine the ciphersuites enum
-//! here with appropriate annotations such that it gets exported to all relevant bindings.
+//! Both wasm-bindgen and uniffi support emitting enums, as long as they
+//! directly implement the enum; it doesn't work on newtypes around external
+//! enums. We therefore redefine the ciphersuites enum here with appropriate
+//! annotations such that it gets exported to all relevant bindings.
 
 use core_crypto::{Ciphersuite as CryptoCiphersuite, MlsCiphersuite};
 

crypto-ffi/src/client_id.rs

@@ -1,8 +1,8 @@
 /// A Client identifier
 ///
-/// A unique identifier for clients. A client is an identifier for each App a user is using, such as desktop,
-/// mobile, etc. Users can have multiple clients.
-/// More information [here](https://messaginglayersecurity.rocks/mls-architecture/draft-ietf-mls-architecture.html#name-group-members-and-clients)
+/// A unique identifier for clients. A client is an identifier for each App a
+/// user is using, such as desktop, mobile, etc. Users can have multiple
+/// clients. More information [here](https://messaginglayersecurity.rocks/mls-architecture/draft-ietf-mls-architecture.html#name-group-members-and-clients)
 #[derive(Debug, Clone, Eq, Hash, PartialEq, derive_more::From, uniffi::Object)]
 pub struct ClientId(pub(crate) core_crypto::ClientId);
 

crypto-ffi/src/core_crypto/client.rs

@@ -2,12 +2,13 @@ use crate::{Ciphersuite, CoreCryptoFfi, CoreCryptoResult, CredentialType};
 
 #[uniffi::export]
 impl CoreCryptoFfi {
-    /// Gets the public key from a [`Credential`][crate::Credential] which has been added to this client.
+    /// Gets the public key from a [`Credential`][crate::Credential] which has
+    /// been added to this client.
     ///
     /// The ciphersuite and credential type act as filters.
     ///
-    /// If there exist multiple credentials which match these filters, this returns the one with
-    /// the latest `earliest_validity`.
+    /// If there exist multiple credentials which match these filters, this
+    /// returns the one with the latest `earliest_validity`.
     ///
     /// See [core_crypto::transaction_context::TransactionContext::client_public_key]
     pub async fn client_public_key(

crypto-ffi/src/core_crypto/command/mod.rs

@@ -5,7 +5,8 @@ use std::sync::Arc;
 
 use crate::{CoreCryptoContext, CoreCryptoFfi, CoreCryptoResult};
 
-/// A `CoreCryptoCommand` has an `execute` method which accepts a `CoreCryptoContext` and returns nothing.
+/// A `CoreCryptoCommand` has an `execute` method which accepts a
+/// `CoreCryptoContext` and returns nothing.
 ///
 /// It is the argument to a `CoreCrypto::transaction` call.
 #[uniffi::export(with_foreign)]
@@ -16,7 +17,8 @@ pub trait CoreCryptoCommand: Send + Sync {
     async fn execute(&self, context: Arc<CoreCryptoContext>) -> CoreCryptoResult<()>;
 }
 
-/// When building outside WASM, any async function of appropriate signature is a `CoreCryptoCommand`.
+/// When building outside WASM, any async function of appropriate signature is a
+/// `CoreCryptoCommand`.
 
 #[cfg_attr(target_family = "wasm", async_trait::async_trait(?Send))]
 #[cfg_attr(not(target_family = "wasm"), async_trait::async_trait)]
@@ -35,11 +37,13 @@ type Command = Arc<dyn CoreCryptoCommand>;
 
 #[uniffi::export]
 impl CoreCryptoFfi {
-    /// Starts a new transaction in Core Crypto. If the callback succeeds, it will be committed,
-    /// otherwise, every operation performed with the context will be discarded.
+    /// Starts a new transaction in Core Crypto. If the callback succeeds, it
+    /// will be committed, otherwise, every operation performed with the
+    /// context will be discarded.
     ///
-    /// When calling this function from within Rust, async functions accepting a context
-    /// implement `CoreCryptoCommand`, so operations can be defined inline as follows:
+    /// When calling this function from within Rust, async functions accepting a
+    /// context implement `CoreCryptoCommand`, so operations can be defined
+    /// inline as follows:
     ///
     /// ```ignore
     /// core_crypto.transaction(Arc::new(async |context| {
@@ -54,9 +58,9 @@ impl CoreCryptoFfi {
             inner: inner_context.clone(),
         };
 
-        // We need one more layer of Arc-wrapping in uniffi. It's kind of silly, given the
-        // also-mandatory Arc-wrapping internally, but that's the price we have to pay in order
-        // to reuse the code in both target contexts.
+        // We need one more layer of Arc-wrapping in uniffi. It's kind of silly, given
+        // the also-mandatory Arc-wrapping internally, but that's the price we
+        // have to pay in order to reuse the code in both target contexts.
         let context = Arc::new(context);
 
         let result = command.execute(context).await;

crypto-ffi/src/core_crypto/command/transaction_helper.rs

@@ -7,18 +7,18 @@ use crate::{CoreCryptoContext, CoreCryptoResult};
 
 /// Helper for working with the new transasction interface.
 ///
-/// This helper serves two purposes: to present a `FnOnce` interface for transactions,
-/// and to allow the extraction of data from within transactions.
+/// This helper serves two purposes: to present a `FnOnce` interface for
+/// transactions, and to allow the extraction of data from within transactions.
 ///
 /// ## Extracting Data
 ///
-/// The `CoreCryptoCommand` interface requires some kind of interior mutability to extract
-/// any data: it takes an immutable reference to the implementing item, and returns the unit struct
-/// in the success case.
+/// The `CoreCryptoCommand` interface requires some kind of interior mutability
+/// to extract any data: it takes an immutable reference to the implementing
+/// item, and returns the unit struct in the success case.
 ///
-/// That pattern is relatively arcane and verbose, particularly when we just want to smuggle out
-/// some data from within the transaction. This helper is intended to ease and automate
-/// that process.
+/// That pattern is relatively arcane and verbose, particularly when we just
+/// want to smuggle out some data from within the transaction. This helper is
+/// intended to ease and automate that process.
 ///
 /// Use it like this (pseudocode):
 ///

crypto-ffi/src/core_crypto/epoch_observer.rs

@@ -25,26 +25,29 @@ pub trait EpochObserver: Send + Sync {
     ///
     /// <div class="warning">
     /// This function must not block! Foreign implementors of this interface can
-    /// spawn a task indirecting the notification, or (unblocking) send the notification
-    /// on some kind of channel, or anything else, as long as the operation completes
-    /// quickly.
+    /// spawn a task indirecting the notification, or (unblocking) send the
+    /// notification on some kind of channel, or anything else, as long as
+    /// the operation completes quickly.
     /// </div>
     ///
-    /// Though the signature includes an error type, that error is only present because
-    /// it is required by `uniffi` in order to handle panics. This function should suppress
-    /// and ignore internal errors instead of propagating them, to the maximum extent possible.
+    /// Though the signature includes an error type, that error is only present
+    /// because it is required by `uniffi` in order to handle panics. This
+    /// function should suppress and ignore internal errors instead of
+    /// propagating them, to the maximum extent possible.
     async fn epoch_changed(
         &self,
         conversation_id: ConversationIdMaybeArc,
         epoch: u64,
     ) -> Result<(), EpochChangedReportingError>;
 }
 
-/// This shim bridges the public `EpochObserver` interface with the internal one defined by `core-crypto`.
+/// This shim bridges the public `EpochObserver` interface with the internal one
+/// defined by `core-crypto`.
 ///
-/// This is slightly unfortunate, as it introduces an extra layer of indirection before a change notice can
-/// actually reach its foreign target. However, the orphan rule prevents us from just tying the two traits
-/// together directly, so this is the straightforward way to accomplish that.
+/// This is slightly unfortunate, as it introduces an extra layer of indirection
+/// before a change notice can actually reach its foreign target. However, the
+/// orphan rule prevents us from just tying the two traits together directly, so
+/// this is the straightforward way to accomplish that.
 struct ObserverShim(Arc<dyn EpochObserver>);
 
 #[cfg_attr(target_family = "wasm", async_trait::async_trait(?Send))]
@@ -57,7 +60,8 @@ impl core_crypto::mls::EpochObserver for ObserverShim {
             .await
         {
             // we don't _care_ if an error is thrown by the notification function, per se,
-            // but this would probably be useful information for downstream debugging efforts
+            // but this would probably be useful information for downstream debugging
+            // efforts
             log::warn!(
                 conversation_id = &conversation_id,
                 epoch,
@@ -72,8 +76,9 @@ impl core_crypto::mls::EpochObserver for ObserverShim {
 impl CoreCryptoFfi {
     /// Add an epoch observer to this client.
     ///
-    /// This function should be called 0 or 1 times in a session's lifetime. If called
-    /// when an epoch observer already exists, this will return an error.
+    /// This function should be called 0 or 1 times in a session's lifetime. If
+    /// called when an epoch observer already exists, this will return an
+    /// error.
     pub async fn register_epoch_observer(&self, epoch_observer: Arc<dyn EpochObserver>) -> CoreCryptoResult<()> {
         let shim = Arc::new(ObserverShim(epoch_observer));
         self.inner

crypto-ffi/src/core_crypto/history_observer.rs

@@ -22,30 +22,34 @@ pub enum NewHistoryClientReportingError {
 pub trait HistoryObserver: Send + Sync {
     /// This function will be called every time a new history client is created.
     ///
-    /// The `secret` parameter is the secret associated with the new history client
+    /// The `secret` parameter is the secret associated with the new history
+    /// client
     ///
     /// <div class="warning">
     /// This function must not block! Foreign implementors of this interface can
-    /// spawn a task indirecting the notification, or (unblocking) send the notification
-    /// on some kind of channel, or anything else, as long as the operation completes
-    /// quickly.
+    /// spawn a task indirecting the notification, or (unblocking) send the
+    /// notification on some kind of channel, or anything else, as long as
+    /// the operation completes quickly.
     /// </div>
     ///
-    /// Though the signature includes an error type, that error is only present because
-    /// it is required by `uniffi` in order to handle panics. This function should suppress
-    /// and ignore internal errors instead of propagating them, to the maximum extent possible.
+    /// Though the signature includes an error type, that error is only present
+    /// because it is required by `uniffi` in order to handle panics. This
+    /// function should suppress and ignore internal errors instead of
+    /// propagating them, to the maximum extent possible.
     async fn history_client_created(
         &self,
         conversation_id: ConversationIdMaybeArc,
         secret: HistorySecret,
     ) -> Result<(), NewHistoryClientReportingError>;
 }
 
-/// This shim bridges the public `HistoryObserver` interface with the internal one defined by `core-crypto`.
+/// This shim bridges the public `HistoryObserver` interface with the internal
+/// one defined by `core-crypto`.
 ///
-/// This is slightly unfortunate, as it introduces an extra layer of indirection before a change notice can
-/// actually reach its foreign target. However, the orphan rule prevents us from just tying the two traits
-/// together directly, so this is the straightforward way to accomplish that.
+/// This is slightly unfortunate, as it introduces an extra layer of indirection
+/// before a change notice can actually reach its foreign target. However, the
+/// orphan rule prevents us from just tying the two traits together directly, so
+/// this is the straightforward way to accomplish that.
 struct ObserverShim(Arc<dyn HistoryObserver>);
 
 #[cfg_attr(target_family = "wasm", async_trait(?Send))]
@@ -65,7 +69,8 @@ impl core_crypto::mls::HistoryObserver for ObserverShim {
             .await
         {
             // we don't _care_ if an error is thrown by the notification function, per se,
-            // but this would probably be useful information for downstream debugging efforts
+            // but this would probably be useful information for downstream debugging
+            // efforts
             log::warn!(
                 conversation_id = conversation_id,
                 err = log::kv::Value::from_dyn_error(&err);
@@ -79,8 +84,9 @@ impl core_crypto::mls::HistoryObserver for ObserverShim {
 impl CoreCryptoFfi {
     /// Add a history observer to this client.
     ///
-    /// This function should be called 0 or 1 times in a session's lifetime. If called
-    /// when an history observer already exists, this will return an error.
+    /// This function should be called 0 or 1 times in a session's lifetime. If
+    /// called when an history observer already exists, this will return an
+    /// error.
     pub async fn register_history_observer(&self, history_observer: Arc<dyn HistoryObserver>) -> CoreCryptoResult<()> {
         let shim = Arc::new(ObserverShim(history_observer));
         self.inner

crypto-ffi/src/core_crypto/logger.rs

@@ -57,12 +57,14 @@ pub enum LoggingError {
     Ffi(#[from] uniffi::UnexpectedUniFFICallbackError),
 }
 
-/// This trait is used to provide a callback mechanism to hook up the respective platform logging system.
+/// This trait is used to provide a callback mechanism to hook up the respective
+/// platform logging system.
 #[uniffi::export(with_foreign)]
 pub trait CoreCryptoLogger: std::fmt::Debug + Send + Sync {
     /// Core Crypto will call this method whenever it needs to log a message.
     ///
-    /// This function catches panics and other unexpected errors. In those cases, it writes to `stderr`.
+    /// This function catches panics and other unexpected errors. In those
+    /// cases, it writes to `stderr`.
     fn log(&self, level: CoreCryptoLogLevel, message: String, context: Option<String>) -> Result<(), LoggingError>;
 }
 
@@ -77,7 +79,8 @@ impl CoreCryptoLogger for DummyLogger {
     }
 }
 
-/// The uniffi log shim is a simple wrapper around the foreign implementer of the trait
+/// The uniffi log shim is a simple wrapper around the foreign implementer of
+/// the trait
 #[derive(Clone, derive_more::Constructor)]
 struct LogShim {
     logger: Arc<dyn CoreCryptoLogger>,

crypto-ffi/src/core_crypto/mls_transport.rs

@@ -1,22 +1,24 @@
 //! Implement the MLS Transport interface.
 //!
-//! Unfortunately, there is no good way to reuse code between uniffi and wasm for an interface
-//! like this; the fundamental techniques in use are very different. So we just have to feature-gate
-//! everything.
+//! Unfortunately, there is no good way to reuse code between uniffi and wasm
+//! for an interface like this; the fundamental techniques in use are very
+//! different. So we just have to feature-gate everything.
 use std::{fmt, sync::Arc};
 
 use core_crypto::{HistorySecret, MlsCommitBundle};
 
 use crate::{ClientId, CommitBundle, CoreCryptoFfi, CoreCryptoResult, HistorySecret as HistorySecretFfi};
 
-/// MLS transport may or may not succeeed; this response indicates to CC the outcome of the transport attempt.
+/// MLS transport may or may not succeeed; this response indicates to CC the
+/// outcome of the transport attempt.
 #[derive(Debug, Clone, PartialEq, Eq, uniffi::Enum)]
 pub enum MlsTransportResponse {
     /// The message was accepted by the distribution service
     Success,
     /// A client should have consumed all incoming messages before re-trying.
     Retry,
-    /// The message was rejected by the delivery service and there's no recovery.
+    /// The message was rejected by the delivery service and there's no
+    /// recovery.
     Abort {
         /// Why was this message rejected
         reason: String,
@@ -48,8 +50,9 @@ impl From<MlsTransportResponse> for core_crypto::MlsTransportResponse {
     }
 }
 
-/// Used by core crypto to send commits or application messages to the delivery service.
-/// This trait must be implemented before calling any functions that produce commits.
+/// Used by core crypto to send commits or application messages to the delivery
+/// service. This trait must be implemented before calling any functions that
+/// produce commits.
 #[uniffi::export(with_foreign)]
 #[cfg_attr(target_family = "wasm", async_trait::async_trait(?Send))]
 #[cfg_attr(not(target_family = "wasm"), async_trait::async_trait)]