style: Apply rustfmt formatting

Author: ApiliumTeam

crates/aingle_minimal/src/error.rs

@@ -79,7 +79,10 @@ pub enum Error {
 #[derive(Debug, Clone)]
 pub enum CryptoError {
     /// Invalid key format or length.
-    InvalidKey { expected_len: usize, actual_len: usize },
+    InvalidKey {
+        expected_len: usize,
+        actual_len: usize,
+    },
     /// Signature verification failed.
     InvalidSignature,
     /// Key generation failed.
@@ -225,8 +228,15 @@ impl std::fmt::Display for Error {
 impl std::fmt::Display for CryptoError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            CryptoError::InvalidKey { expected_len, actual_len } => {
-                write!(f, "Invalid key: expected {} bytes, got {}", expected_len, actual_len)
+            CryptoError::InvalidKey {
+                expected_len,
+                actual_len,
+            } => {
+                write!(
+                    f,
+                    "Invalid key: expected {} bytes, got {}",
+                    expected_len, actual_len
+                )
             }
             CryptoError::InvalidSignature => write!(f, "Invalid signature"),
             CryptoError::KeyGenerationFailed(s) => write!(f, "Key generation failed: {}", s),
@@ -735,7 +745,13 @@ mod tests {
     #[test]
     fn test_crypto_error_display() {
         assert_eq!(
-            format!("{}", CryptoError::InvalidKey { expected_len: 32, actual_len: 16 }),
+            format!(
+                "{}",
+                CryptoError::InvalidKey {
+                    expected_len: 32,
+                    actual_len: 16
+                }
+            ),
             "Invalid key: expected 32 bytes, got 16"
         );
         assert_eq!(

crates/aingle_minimal/src/lib.rs

@@ -207,6 +207,8 @@ pub mod network;
 pub mod node;
 pub mod ota;
 pub mod power;
+#[cfg(feature = "quic")]
+pub mod quic;
 pub mod sensors;
 #[cfg(feature = "smart_agents")]
 pub mod smart;
@@ -216,8 +218,6 @@ pub mod types;
 pub mod wallet;
 #[cfg(feature = "webrtc")]
 pub mod webrtc;
-#[cfg(feature = "quic")]
-pub mod quic;
 
 // Storage - trait is always available
 pub mod storage_trait;
@@ -243,8 +243,6 @@ pub use storage_trait::{StorageBackend, StorageStats};
 pub use bluetooth::{BleConfig, BleManager, BlePeer, BleState, BleStats};
 #[cfg(feature = "coap")]
 pub use coap::{CoapConfig, CoapServer};
-#[cfg(feature = "quic")]
-pub use quic::{QuicConfig, QuicServer};
 pub use config::{Config, GossipConfig, MeshMode, PowerMode, StorageConfig, TransportConfig};
 pub use discovery::{DiscoveredPeer, Discovery};
 #[cfg(feature = "coap")]
@@ -259,6 +257,8 @@ pub use memory::IoTMemory;
 pub use node::{MinimalNode, PeerRecord};
 pub use ota::{OtaManager, UpdateChannel, UpdateInfo, UpdateState};
 pub use power::{BatteryInfo, PowerManager, PowerProfile};
+#[cfg(feature = "quic")]
+pub use quic::{QuicConfig, QuicServer};
 pub use sensors::{CalibrationParams, Sensor, SensorManager, SensorReading, SensorType};
 #[cfg(feature = "smart_agents")]
 pub use smart::{IoTPolicyBuilder, SensorAdapter, SmartNode, SmartNodeConfig, SmartNodeStats};

crates/aingle_minimal/src/main.rs

@@ -137,11 +137,9 @@ fn main() -> Result<()> {
     let cli = Cli::parse();
 
     // Initialize logging
-    env_logger::Builder::from_env(
-        env_logger::Env::default().default_filter_or(&cli.log_level),
-    )
-    .format_timestamp_millis()
-    .init();
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or(&cli.log_level))
+        .format_timestamp_millis()
+        .init();
 
     match cli.command {
         Some(Commands::Run {
@@ -169,7 +167,10 @@ fn main() -> Result<()> {
         Some(Commands::Info) => show_info(),
         Some(Commands::Config { action }) => config_action(action),
         Some(Commands::Version) => show_version(),
-        Some(Commands::Bench { entries, iterations }) => run_benchmark(entries, iterations),
+        Some(Commands::Bench {
+            entries,
+            iterations,
+        }) => run_benchmark(entries, iterations),
         None => {
             // Default: show help
             print_banner();
@@ -240,10 +241,7 @@ fn run_node(
     }
 
     // Update transport config
-    config.transport = aingle_minimal::TransportConfig::Coap {
-        bind_addr,
-        port,
-    };
+    config.transport = aingle_minimal::TransportConfig::Coap { bind_addr, port };
 
     // Print configuration
     println!("\nConfiguration:");
@@ -316,7 +314,10 @@ fn show_info() -> Result<()> {
     println!("Build Information:");
     println!("  Version: {}", aingle_minimal::VERSION);
     println!("  MSRV: {}", aingle_minimal::MSRV);
-    println!("  Memory budget: {} KB", aingle_minimal::MEMORY_BUDGET / 1024);
+    println!(
+        "  Memory budget: {} KB",
+        aingle_minimal::MEMORY_BUDGET / 1024
+    );
     println!();
 
     println!("Features:");
@@ -408,7 +409,10 @@ fn print_config(config: &Config) {
     println!("\nGossip:");
     println!("    max_peers: {}", config.gossip.max_peers);
     println!("    loop_delay: {:?}", config.gossip.loop_delay);
-    println!("    output_target_mbps: {}", config.gossip.output_target_mbps);
+    println!(
+        "    output_target_mbps: {}",
+        config.gossip.output_target_mbps
+    );
     println!("\nStorage:");
     println!("    db_path: {}", config.storage.db_path);
     println!("    backend: {:?}", config.storage.backend);
@@ -430,13 +434,21 @@ fn print_config(config: &Config) {
             println!("    mode: {:?}", mode);
         }
         #[cfg(feature = "webrtc")]
-        aingle_minimal::TransportConfig::WebRtc { stun_server, signaling_port, .. } => {
+        aingle_minimal::TransportConfig::WebRtc {
+            stun_server,
+            signaling_port,
+            ..
+        } => {
             println!("    type: WebRTC");
             println!("    stun_server: {}", stun_server);
             println!("    signaling_port: {}", signaling_port);
         }
         #[cfg(feature = "ble")]
-        aingle_minimal::TransportConfig::Ble { device_name, mesh_relay, tx_power } => {
+        aingle_minimal::TransportConfig::Ble {
+            device_name,
+            mesh_relay,
+            tx_power,
+        } => {
             println!("    type: Bluetooth LE");
             println!("    device_name: {}", device_name);
             println!("    mesh_relay: {}", mesh_relay);
@@ -450,7 +462,10 @@ fn show_version() -> Result<()> {
     println!();
     println!("Build info:");
     println!("  Rust MSRV: {}", aingle_minimal::MSRV);
-    println!("  Target memory: {} KB", aingle_minimal::MEMORY_BUDGET / 1024);
+    println!(
+        "  Target memory: {} KB",
+        aingle_minimal::MEMORY_BUDGET / 1024
+    );
 
     #[cfg(debug_assertions)]
     println!("  Profile: debug");

crates/aingle_minimal/src/network.rs

@@ -207,11 +207,7 @@ impl MeshManager {
     }
 
     /// Wrap a message for mesh relay
-    pub fn wrap_for_relay(
-        node_id: &str,
-        message: Message,
-        ttl: Option<u8>,
-    ) -> Message {
+    pub fn wrap_for_relay(node_id: &str, message: Message, ttl: Option<u8>) -> Message {
         let message_id = Self::generate_message_id(node_id);
         Message::MeshRelay {
             message_id,
@@ -639,12 +635,7 @@ impl Network {
             return Err(e);
         }
 
-        log::debug!(
-            "RPC call {} to {}: method={}",
-            request_id,
-            addr,
-            method
-        );
+        log::debug!("RPC call {} to {}: method={}", request_id, addr, method);
 
         // Wait for response with timeout
         match smol::future::or(
@@ -698,11 +689,7 @@ impl Network {
             let elapsed = pending.sent_at.elapsed();
 
             if let Err(e) = pending.response_tx.try_send(response) {
-                log::warn!(
-                    "Failed to deliver RPC response {}: {:?}",
-                    request_id,
-                    e
-                );
+                log::warn!("Failed to deliver RPC response {}: {:?}", request_id, e);
             } else {
                 log::debug!(
                     "RPC {} response delivered (method={}, elapsed={:?})",
@@ -1703,7 +1690,13 @@ mod tests {
         assert!(json.contains("get_status"));
 
         let parsed: Message = serde_json::from_str(&json).unwrap();
-        if let Message::RemoteCall { request_id, from, method, payload } = parsed {
+        if let Message::RemoteCall {
+            request_id,
+            from,
+            method,
+            payload,
+        } = parsed
+        {
             assert_eq!(request_id, "rpc-123");
             assert_eq!(from, "node-abc");
             assert_eq!(method, "get_status");
@@ -1727,7 +1720,12 @@ mod tests {
         assert!(json.contains("true"));
 
         let parsed: Message = serde_json::from_str(&json).unwrap();
-        if let Message::RemoteCallResponse { request_id, success, data } = parsed {
+        if let Message::RemoteCallResponse {
+            request_id,
+            success,
+            data,
+        } = parsed
+        {
             assert_eq!(request_id, "rpc-456");
             assert!(success);
             assert_eq!(data, b"result data".to_vec());
@@ -1763,12 +1761,9 @@ mod tests {
 
         smol::block_on(async {
             let addr: SocketAddr = "127.0.0.1:5683".parse().unwrap();
-            let result = network.send_remote_call(
-                &addr,
-                "test_method",
-                vec![],
-                Duration::from_secs(1),
-            ).await;
+            let result = network
+                .send_remote_call(&addr, "test_method", vec![], Duration::from_secs(1))
+                .await;
 
             // Without CoAP feature, should return error
             assert!(result.is_err());
@@ -1798,8 +1793,7 @@ mod tests {
     fn test_mesh_manager_process_relay_new() {
         let mut mesh = MeshManager::new();
 
-        let (should_process, should_relay, new_ttl) =
-            mesh.process_relay("msg-1", 5);
+        let (should_process, should_relay, new_ttl) = mesh.process_relay("msg-1", 5);
 
         assert!(should_process);
         assert!(should_relay);
@@ -1835,8 +1829,7 @@ mod tests {
     fn test_mesh_manager_process_relay_ttl_one() {
         let mut mesh = MeshManager::new();
 
-        let (should_process, should_relay, new_ttl) =
-            mesh.process_relay("msg-1", 1);
+        let (should_process, should_relay, new_ttl) = mesh.process_relay("msg-1", 1);
 
         assert!(should_process);
         assert!(!should_relay); // TTL=0 after decrement, no relay

crates/aingle_minimal/src/node.rs

@@ -817,14 +817,21 @@ impl MinimalNode {
         for record in peer_records {
             // Skip peers with very low quality or that haven't been seen in > 24 hours
             if record.quality < 10 {
-                log::debug!("Skipping low-quality peer: {} (quality={})", record.addr, record.quality);
+                log::debug!(
+                    "Skipping low-quality peer: {} (quality={})",
+                    record.addr,
+                    record.quality
+                );
                 continue;
             }
 
             let age_secs = now.saturating_sub(record.last_seen_secs);
             if age_secs > 24 * 60 * 60 {
-                log::debug!("Skipping stale peer: {} (last seen {} hours ago)",
-                    record.addr, age_secs / 3600);
+                log::debug!(
+                    "Skipping stale peer: {} (last seen {} hours ago)",
+                    record.addr,
+                    age_secs / 3600
+                );
                 continue;
             }
 
@@ -1372,7 +1379,9 @@ mod tests {
         }];
 
         let json = serde_json::to_string(&records).unwrap();
-        node.storage.set_metadata(PEERS_METADATA_KEY, &json).unwrap();
+        node.storage
+            .set_metadata(PEERS_METADATA_KEY, &json)
+            .unwrap();
 
         // Load peers - should skip the low-quality peer
         node.load_peers().unwrap();
@@ -1402,7 +1411,9 @@ mod tests {
         }];
 
         let json = serde_json::to_string(&records).unwrap();
-        node.storage.set_metadata(PEERS_METADATA_KEY, &json).unwrap();
+        node.storage
+            .set_metadata(PEERS_METADATA_KEY, &json)
+            .unwrap();
 
         // Load peers - should skip the stale peer
         node.load_peers().unwrap();
@@ -1431,7 +1442,9 @@ mod tests {
         }];
 
         let json = serde_json::to_string(&records).unwrap();
-        node.storage.set_metadata(PEERS_METADATA_KEY, &json).unwrap();
+        node.storage
+            .set_metadata(PEERS_METADATA_KEY, &json)
+            .unwrap();
 
         // Load peers - should accept the good peer
         node.load_peers().unwrap();
@@ -1460,7 +1473,9 @@ mod tests {
         }];
 
         let json = serde_json::to_string(&records).unwrap();
-        node.storage.set_metadata(PEERS_METADATA_KEY, &json).unwrap();
+        node.storage
+            .set_metadata(PEERS_METADATA_KEY, &json)
+            .unwrap();
 
         // Load peers - should succeed but skip invalid address
         let result = node.load_peers();

crates/aingle_minimal/src/ota.rs

@@ -83,7 +83,10 @@ impl UpdateInfo {
     /// Check if update is newer than current version
     pub fn is_newer(&self, current_version: &str) -> bool {
         // Use proper semver comparison
-        match (Version::parse(&self.version), Version::parse(current_version)) {
+        match (
+            Version::parse(&self.version),
+            Version::parse(current_version),
+        ) {
             (Ok(update_ver), Ok(current)) => update_ver > current,
             // Fallback to string comparison if parsing fails
             _ => self.version.as_str() > current_version,