chore: apply updated styling rules

Author: evansims

examples/src/bin/axum_middleware.rs

@@ -20,15 +20,14 @@
 //! curl -X DELETE http://localhost:3000/documents/readme
 //! ```
 
-use std::env;
-use std::net::SocketAddr;
+use std::{env, net::SocketAddr};
 
 use axum::{
+    Router,
     extract::{Path, State},
     http::StatusCode,
     response::IntoResponse,
     routing::{delete, get},
-    Router,
 };
 use inferadb::prelude::*;
 
@@ -84,11 +83,7 @@ async fn view_document(
     let resource = format!("document:{doc_id}");
 
     // Use require() pattern - converts denial to error
-    state
-        .vault
-        .check(user_id, "view", &resource)
-        .require()
-        .await?;
+    state.vault.check(user_id, "view", &resource).require().await?;
 
     // User is authorized - return document content
     Ok(format!("Document content for: {doc_id}"))
@@ -103,11 +98,7 @@ async fn delete_document(
     let resource = format!("document:{doc_id}");
 
     // Check authorization first
-    state
-        .vault
-        .check(user_id, "delete", &resource)
-        .require()
-        .await?;
+    state.vault.check(user_id, "delete", &resource).require().await?;
 
     // User is authorized - delete the document
     Ok(format!("Deleted document: {doc_id}"))
@@ -157,7 +148,7 @@ impl IntoResponse for AppError {
                     ),
                 )
                     .into_response()
-            }
+            },
             AppError::InferaDb(err) => {
                 // Map SDK errors to HTTP status codes
                 let status = match err.kind() {
@@ -176,7 +167,7 @@ impl IntoResponse for AppError {
                 };
 
                 (status, message).into_response()
-            }
+            },
         }
     }
 }

examples/src/bin/basic_check.rs

@@ -53,26 +53,18 @@ async fn main() -> Result<()> {
     // Policies can use context values for attribute-based decisions
     let allowed_with_context = vault
         .check("user:alice", "view", "document:confidential")
-        .with_context(
-            Context::new()
-                .with("ip_address", "10.0.0.50")
-                .with("mfa_verified", true),
-        )
+        .with_context(Context::new().with("ip_address", "10.0.0.50").with("mfa_verified", true))
         .await?;
 
     println!("user:alice can view document:confidential (with MFA): {allowed_with_context}");
 
     // The require() pattern - recommended for HTTP handlers
     // Converts denial (false) into Err(AccessDenied), integrates with ?
-    match vault
-        .check("user:alice", "delete", "document:readme")
-        .require()
-        .await
-    {
+    match vault.check("user:alice", "delete", "document:readme").require().await {
         Ok(()) => println!("user:alice can delete document:readme"),
         Err(AccessDenied { .. }) => {
             println!("user:alice cannot delete document:readme (access denied)")
-        }
+        },
     }
 
     println!("\nExample complete!");

examples/src/bin/batch_operations.rs

@@ -90,19 +90,13 @@ async fn main() -> Result<()> {
     // Write returns a consistency token for read-after-write consistency
     let token = vault
         .relationships()
-        .write(Relationship::new(
-            "document:new-doc",
-            "viewer",
-            "user:charlie",
-        ))
+        .write(Relationship::new("document:new-doc", "viewer", "user:charlie"))
         .await?;
 
     println!("  Write returned consistency token: {}", token.value());
 
     // After writing, the authorization check will reflect the new relationship
-    let allowed = vault
-        .check("user:charlie", "view", "document:new-doc")
-        .await?;
+    let allowed = vault.check("user:charlie", "view", "document:new-doc").await?;
 
     println!("  user:charlie can view document:new-doc: {allowed}");
 
@@ -115,11 +109,7 @@ async fn main() -> Result<()> {
     // Delete the test relationships
     vault
         .relationships()
-        .delete(Relationship::new(
-            "document:new-doc",
-            "viewer",
-            "user:charlie",
-        ))
+        .delete(Relationship::new("document:new-doc", "viewer", "user:charlie"))
         .await?;
 
     println!("  Deleted test relationship");

inferadb-derive/src/lib.rs

@@ -45,7 +45,7 @@
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use syn::{parse_macro_input, Data, DeriveInput, Error, Fields, Ident, LitStr, Result};
+use syn::{Data, DeriveInput, Error, Fields, Ident, LitStr, Result, parse_macro_input};
 
 /// Derive macro for implementing the `Resource` trait.
 ///
@@ -183,27 +183,21 @@ fn find_id_field(data: &Data, attr_name: &str) -> Result<Ident> {
                 return Err(Error::new(
                     proc_macro2::Span::call_site(),
                     "tuple structs are not supported",
-                ))
-            }
+                ));
+            },
             Fields::Unit => {
                 return Err(Error::new(
                     proc_macro2::Span::call_site(),
                     "unit structs are not supported",
-                ))
-            }
+                ));
+            },
         },
         Data::Enum(_) => {
-            return Err(Error::new(
-                proc_macro2::Span::call_site(),
-                "enums are not supported",
-            ))
-        }
+            return Err(Error::new(proc_macro2::Span::call_site(), "enums are not supported"));
+        },
         Data::Union(_) => {
-            return Err(Error::new(
-                proc_macro2::Span::call_site(),
-                "unions are not supported",
-            ))
-        }
+            return Err(Error::new(proc_macro2::Span::call_site(), "unions are not supported"));
+        },
     };
 
     for field in fields {

src/auth/credentials.rs

@@ -1,7 +1,6 @@
 //! Credentials types for InferaDB authentication.
 
-use std::fmt;
-use std::sync::Arc;
+use std::{fmt, sync::Arc};
 
 use super::Ed25519PrivateKey;
 
@@ -71,11 +70,7 @@ impl ClientCredentialsConfig {
     /// );
     /// ```
     pub fn new(client_id: impl Into<String>, private_key: Ed25519PrivateKey) -> Self {
-        Self {
-            client_id: client_id.into(),
-            private_key,
-            certificate_id: None,
-        }
+        Self { client_id: client_id.into(), private_key, certificate_id: None }
     }
 
     /// Sets the certificate ID for certificate binding.
@@ -141,9 +136,7 @@ impl BearerCredentialsConfig {
     /// let config = BearerCredentialsConfig::new("eyJhbGciOiJFZERTQSI...");
     /// ```
     pub fn new(token: impl Into<String>) -> Self {
-        Self {
-            token: Arc::from(token.into()),
-        }
+        Self { token: Arc::from(token.into()) }
     }
 
     /// Returns the bearer token.
@@ -154,9 +147,7 @@ impl BearerCredentialsConfig {
 
 impl fmt::Debug for BearerCredentialsConfig {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("BearerCredentialsConfig")
-            .field("token", &"[REDACTED]")
-            .finish()
+        f.debug_struct("BearerCredentialsConfig").field("token", &"[REDACTED]").finish()
     }
 }
 
@@ -228,7 +219,7 @@ impl fmt::Debug for Credentials {
         match self {
             Credentials::ClientCredentials(config) => {
                 f.debug_tuple("ClientCredentials").field(config).finish()
-            }
+            },
             Credentials::Bearer(config) => f.debug_tuple("Bearer").field(config).finish(),
         }
     }

src/auth/ed25519.rs

@@ -1,9 +1,8 @@
 //! Ed25519 private key handling for JWT signing.
 
-use std::fmt;
-use std::path::Path;
+use std::{fmt, path::Path};
 
-use ed25519_dalek::{SigningKey, SECRET_KEY_LENGTH};
+use ed25519_dalek::{SECRET_KEY_LENGTH, SigningKey};
 use zeroize::Zeroizing;
 
 use crate::Error;
@@ -74,9 +73,7 @@ impl Ed25519PrivateKey {
     /// ```
     pub fn generate() -> Self {
         let mut csprng = rand::rngs::OsRng;
-        Self {
-            key: SigningKey::generate(&mut csprng),
-        }
+        Self { key: SigningKey::generate(&mut csprng) }
     }
 
     /// Creates a key from raw bytes.
@@ -111,9 +108,7 @@ impl Ed25519PrivateKey {
         // Wrap in Zeroizing for secure cleanup
         let zeroizing_bytes = Zeroizing::new(key_bytes);
 
-        Ok(Self {
-            key: SigningKey::from_bytes(&zeroizing_bytes),
-        })
+        Ok(Self { key: SigningKey::from_bytes(&zeroizing_bytes) })
     }
 
     /// Creates a key from a hex-encoded string.

src/auth/provider.rs

@@ -1,8 +1,6 @@
 //! Credentials provider trait for dynamic credential management.
 
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::Arc;
+use std::{future::Future, pin::Pin, sync::Arc};
 
 use crate::Error;
 
@@ -164,9 +162,7 @@ pub struct StaticTokenProvider {
 impl StaticTokenProvider {
     /// Creates a new static token provider.
     pub fn new(token: impl Into<String>) -> Self {
-        Self {
-            token: Arc::from(token.into()),
-        }
+        Self { token: Arc::from(token.into()) }
     }
 }
 
@@ -226,17 +222,13 @@ mod tests {
 
     impl CustomProvider {
         fn new() -> Self {
-            Self {
-                counter: std::sync::atomic::AtomicU32::new(0),
-            }
+            Self { counter: std::sync::atomic::AtomicU32::new(0) }
         }
     }
 
     impl CredentialsProvider for CustomProvider {
         fn get_token(&self) -> CredentialsFuture<'_> {
-            let count = self
-                .counter
-                .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+            let count = self.counter.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
             Box::pin(async move { Ok(format!("token_{}", count)) })
         }
 
@@ -253,10 +245,7 @@ mod tests {
     async fn test_custom_provider() {
         let provider = CustomProvider::new();
         assert!(provider.supports_refresh());
-        assert_eq!(
-            provider.refresh_hint(),
-            Some(std::time::Duration::from_secs(300))
-        );
+        assert_eq!(provider.refresh_hint(), Some(std::time::Duration::from_secs(300)));
 
         let token1 = provider.get_token().await.unwrap();
         let token2 = provider.get_token().await.unwrap();
@@ -269,10 +258,7 @@ mod tests {
         let provider: Arc<dyn CredentialsProvider> = Arc::new(CustomProvider::new());
         // Test that Arc properly delegates all methods
         assert!(provider.supports_refresh());
-        assert_eq!(
-            provider.refresh_hint(),
-            Some(std::time::Duration::from_secs(300))
-        );
+        assert_eq!(provider.refresh_hint(), Some(std::time::Duration::from_secs(300)));
         let token = provider.get_token().await.unwrap();
         assert_eq!(token, "token_0");
     }
@@ -282,10 +268,7 @@ mod tests {
         let provider: Box<dyn CredentialsProvider> = Box::new(CustomProvider::new());
         // Test that Box properly delegates all methods
         assert!(provider.supports_refresh());
-        assert_eq!(
-            provider.refresh_hint(),
-            Some(std::time::Duration::from_secs(300))
-        );
+        assert_eq!(provider.refresh_hint(), Some(std::time::Duration::from_secs(300)));
         let token = provider.get_token().await.unwrap();
         assert_eq!(token, "token_0");
     }