lint: cargo fmt

Author: iinuwa

xyz-iinuwa-credential-manager-portal-gtk/src/credential_service/hybrid.rs

@@ -11,10 +11,7 @@ use libwebauthn::transport::cable::qr_code_device::{CableQrCodeDevice, QrCodeOpe
 use libwebauthn::transport::Device;
 use libwebauthn::webauthn::{Error as WebAuthnError, WebAuthn};
 
-use crate::{
-    dbus::CredentialRequest,
-    tokio_runtime,
-};
+use crate::{dbus::CredentialRequest, tokio_runtime};
 
 use super::AuthenticatorResponse;
 
@@ -23,16 +20,14 @@ pub(crate) trait HybridHandler {
     fn start(&self, request: &CredentialRequest) -> Self::Stream;
 }
 
-
 #[derive(Debug)]
 pub struct InternalHybridHandler {}
 impl InternalHybridHandler {
     pub fn new() -> Self {
-        Self { }
+        Self {}
     }
 }
 
-
 impl HybridHandler for InternalHybridHandler {
     type Stream = InternalHybridStream;
 
@@ -41,8 +36,12 @@ impl HybridHandler for InternalHybridHandler {
         let (tx, rx) = async_std::channel::unbounded();
         async_std::task::spawn(async move {
             let hint = match request {
-                CredentialRequest::CreatePublicKeyCredentialRequest(_) => QrCodeOperationHint::MakeCredential,
-                CredentialRequest::GetPublicKeyCredentialRequest(_) => QrCodeOperationHint::GetAssertionRequest,
+                CredentialRequest::CreatePublicKeyCredentialRequest(_) => {
+                    QrCodeOperationHint::MakeCredential
+                }
+                CredentialRequest::GetPublicKeyCredentialRequest(_) => {
+                    QrCodeOperationHint::GetAssertionRequest
+                }
             };
             let mut device = CableQrCodeDevice::new_transient(hint);
             let qr_code = device.qr_code.to_string();
@@ -55,10 +54,7 @@ impl HybridHandler for InternalHybridHandler {
                 let response: AuthenticatorResponse = loop {
                     match &request {
                         CredentialRequest::CreatePublicKeyCredentialRequest(make_request) => {
-                            match channel
-                                .webauthn_make_credential(&make_request)
-                                .await
-                            {
+                            match channel.webauthn_make_credential(&make_request).await {
                                 Ok(response) => break Ok(response.into()),
                                 Err(WebAuthnError::Ctap(ctap_error)) => {
                                     if ctap_error.is_retryable_user_error() {
@@ -69,13 +65,9 @@ impl HybridHandler for InternalHybridHandler {
                                 }
                                 Err(err) => break Err(err),
                             };
-
                         }
                         CredentialRequest::GetPublicKeyCredentialRequest(get_request) => {
-                            match channel
-                                .webauthn_get_assertion(&get_request)
-                                .await
-                            {
+                            match channel.webauthn_get_assertion(&get_request).await {
                                 Ok(response) => break Ok(response.into()),
                                 Err(WebAuthnError::Ctap(ctap_error)) => {
                                     if ctap_error.is_retryable_user_error() {
@@ -86,29 +78,30 @@ impl HybridHandler for InternalHybridHandler {
                                 }
                                 Err(err) => break Err(err),
                             };
-
                         }
                     }
                 }
                 .unwrap();
                 if let Err(err) = tx.send(HybridStateInternal::Completed(response)).await {
                     tracing::error!("Failed to send caBLE update: {:?}", err)
                 }
-
             });
         });
         InternalHybridStream { rx }
     }
 }
 
 pub struct InternalHybridStream {
-    rx: Receiver<HybridStateInternal>
+    rx: Receiver<HybridStateInternal>,
 }
 
 impl Stream for InternalHybridStream {
     type Item = HybridStateInternal;
 
-    fn poll_next(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
         match self.rx.recv().poll(cx) {
             Poll::Pending => Poll::Pending,
             Poll::Ready(Ok(state)) => Poll::Ready(Some(state)),
@@ -126,15 +119,15 @@ impl DummyHybridHandler {
     #[cfg(test)]
     pub fn new(states: Vec<HybridStateInternal>) -> Self {
         Self {
-            stream: DummyHybridStateStream { states }
+            stream: DummyHybridStateStream { states },
         }
     }
 }
 
 impl Default for DummyHybridHandler {
     fn default() -> Self {
         Self {
-            stream: DummyHybridStateStream::default()
+            stream: DummyHybridStateStream::default(),
         }
     }
 }
@@ -254,11 +247,10 @@ impl From<HybridStateInternal> for HybridState {
     fn from(value: HybridStateInternal) -> Self {
         match value {
             HybridStateInternal::Init(qr_code) => HybridState::Init(qr_code),
-            HybridStateInternal::Waiting       => HybridState::Waiting,
-            HybridStateInternal::Connecting    => HybridState::Connecting,
-            HybridStateInternal::Completed(_)  => HybridState::Completed,
+            HybridStateInternal::Waiting => HybridState::Waiting,
+            HybridStateInternal::Connecting => HybridState::Connecting,
+            HybridStateInternal::Completed(_) => HybridState::Completed,
             HybridStateInternal::UserCancelled => HybridState::UserCancelled,
-
         }
     }
 }

xyz-iinuwa-credential-manager-portal-gtk/src/credential_service/mod.rs

@@ -367,23 +367,32 @@ where
             Poll::Ready(Some(state)) => {
                 if let HybridStateInternal::Completed(hybrid_response) = &state {
                     let response = match hybrid_response {
-                        AuthenticatorResponse::CredentialCreated(make_response) => CredentialResponse::CreatePublicKeyCredentialResponse(
-                                        MakeCredentialResponseInternal::new(
-                                            make_response.clone(),
-                                            vec![String::from("hybrid")],
-                                            String::from("cross-platform"),
-                                        )),
+                        AuthenticatorResponse::CredentialCreated(make_response) => {
+                            CredentialResponse::CreatePublicKeyCredentialResponse(
+                                MakeCredentialResponseInternal::new(
+                                    make_response.clone(),
+                                    vec![String::from("hybrid")],
+                                    String::from("cross-platform"),
+                                ),
+                            )
+                        }
 
-                        AuthenticatorResponse::CredentialsAsserted(GetAssertionResponse { assertions }) if assertions.len() == 1 => CredentialResponse::GetPublicKeyCredentialResponse(
-                            GetAssertionResponseInternal::new(
-                                assertions[0].clone(),
-                                String::from("cross-platform"),
+                        AuthenticatorResponse::CredentialsAsserted(GetAssertionResponse {
+                            assertions,
+                        }) if assertions.len() == 1 => {
+                            CredentialResponse::GetPublicKeyCredentialResponse(
+                                GetAssertionResponseInternal::new(
+                                    assertions[0].clone(),
+                                    String::from("cross-platform"),
+                                ),
                             )
-                        ),
-                        AuthenticatorResponse::CredentialsAsserted(GetAssertionResponse { assertions }) => {
+                        }
+                        AuthenticatorResponse::CredentialsAsserted(GetAssertionResponse {
+                            assertions,
+                        }) => {
                             assert!(!assertions.is_empty());
                             todo!("need to support selection from multiple credentials");
-                        },
+                        }
                     };
                     let mut cred_response = cred_response.lock().unwrap();
                     cred_response.replace(response);
@@ -551,9 +560,7 @@ impl From<GetAssertionResponse> for AuthenticatorResponse {
 
 #[cfg(test)]
 mod test {
-    use std::{
-        sync::{Arc, Mutex},
-    };
+    use std::sync::{Arc, Mutex};
 
     use async_std::stream::StreamExt;
 
@@ -562,7 +569,8 @@ mod test {
     };
 
     use super::{
-        hybrid::{DummyHybridHandler, HybridStateInternal}, AuthenticatorResponse, CredentialService
+        hybrid::{DummyHybridHandler, HybridStateInternal},
+        AuthenticatorResponse, CredentialService,
     };
 
     #[test]
@@ -580,9 +588,7 @@ mod test {
         ]);
         let cred_service = CredentialService::new(request, response, hybrid_handler);
         let mut stream = cred_service.get_hybrid_credential();
-        async_std::task::block_on(async {
-            while let Some(_) = stream.next().await { }
-        });
+        async_std::task::block_on(async { while let Some(_) = stream.next().await {} });
         assert!(cred_service.cred_response.lock().unwrap().is_some());
     }
 
@@ -643,8 +649,7 @@ mod test {
         use libwebauthn::{
             fido::{AuthenticatorData, AuthenticatorDataFlags},
             ops::webauthn::{Assertion, GetAssertionResponse},
-            proto::ctap2::{Ctap2Transport, Ctap2PublicKeyCredentialDescriptor},
-
+            proto::ctap2::{Ctap2PublicKeyCredentialDescriptor, Ctap2Transport},
         };
         // SHA256("webauthn.io")
         let rp_id_hash = [
@@ -677,6 +682,9 @@ mod test {
             enterprise_attestation: None,
             attestation_statement: None,
         };
-        GetAssertionResponse { assertions: vec![assertion] }.into()
+        GetAssertionResponse {
+            assertions: vec![assertion],
+        }
+        .into()
     }
 }

xyz-iinuwa-credential-manager-portal-gtk/src/dbus.rs

@@ -66,8 +66,11 @@ fn start_gui_thread(rx: Receiver<(CredentialRequest, Sender<Option<CredentialRes
                         cred_types: vec![CredentialType::Passkey],
                     },
                 };
-                let credential_service =
-                    CredentialService::new(cred_request, data.clone(), InternalHybridHandler::new());
+                let credential_service = CredentialService::new(
+                    cred_request,
+                    data.clone(),
+                    InternalHybridHandler::new(),
+                );
                 let event_loop = async_std::task::spawn(async move {
                     let mut vm = view_model::ViewModel::new(
                         operation,

xyz-iinuwa-credential-manager-portal-gtk/src/main.rs

@@ -19,7 +19,9 @@ use async_std::task;
 fn main() {
     // Initialize logger
     tracing_subscriber::fmt::init();
-    rustls::crypto::ring::default_provider().install_default().expect("Failed to install rustls crypto provider");
+    rustls::crypto::ring::default_provider()
+        .install_default()
+        .expect("Failed to install rustls crypto provider");
     _ = tokio_runtime::get();
 
     println!("Starting...");

xyz-iinuwa-credential-manager-portal-gtk/src/view_model/mod.rs

@@ -454,7 +454,9 @@ impl From<crate::credential_service::hybrid::HybridState> for HybridState {
             crate::credential_service::hybrid::HybridState::Waiting => HybridState::Waiting,
             crate::credential_service::hybrid::HybridState::Connecting => HybridState::Connecting,
             crate::credential_service::hybrid::HybridState::Completed => HybridState::Completed,
-            crate::credential_service::hybrid::HybridState::UserCancelled => HybridState::UserCancelled,
+            crate::credential_service::hybrid::HybridState::UserCancelled => {
+                HybridState::UserCancelled
+            }
         }
     }
 }