Run cargo fmt for CI compliance

sunilp · sunilp · commit f1e53e4a4469 · 2026-03-28T23:25:20.000+05:30
diff --git a/examples/rust_quickstart.rs b/examples/rust_quickstart.rs
@@ -11,8 +11,8 @@
 //!
 //! Requires a running LDP delegate at localhost:8090 (see examples/python_sdk/ldp_delegate.py)
 
-use ldp_protocol::{register_ldp, LdpAdapterConfig, SessionConfig, PayloadMode};
 use ldp_protocol::protocol::ProtocolRegistry;
+use ldp_protocol::{register_ldp, LdpAdapterConfig, PayloadMode, SessionConfig};
 
 #[tokio::main]
 async fn main() {
@@ -33,7 +33,10 @@ async fn main() {
     };
 
     println!("Config: delegate_id={}", config.delegate_id);
-    println!("  payload modes: {:?}", config.session.preferred_payload_modes);
+    println!(
+        "  payload modes: {:?}",
+        config.session.preferred_payload_modes
+    );
     println!("  trust enforcement: {}", config.enforce_trust_domains);
     println!("  attach provenance: {}", config.attach_provenance);
 
@@ -43,7 +46,10 @@ async fn main() {
 
     // Now ldp:// URLs are handled by the LDP adapter
     println!("\nRegistered protocols: {:?}", registry.protocols());
-    println!("  ldp:// adapter: {}", registry.adapter_for_url("ldp://localhost:8090").is_some());
+    println!(
+        "  ldp:// adapter: {}",
+        registry.adapter_for_url("ldp://localhost:8090").is_some()
+    );
 
     // 3. In production, use the registry to discover and invoke:
     //
diff --git a/src/adapter.rs b/src/adapter.rs
@@ -27,10 +27,7 @@ use tokio::sync::RwLock;
 use tracing::{debug, info, instrument};
 
 /// Validate a task result against its contract. Returns violation codes.
-fn validate_contract(
-    contract: &DelegationContract,
-    provenance: &Provenance,
-) -> Vec<String> {
+fn validate_contract(contract: &DelegationContract, provenance: &Provenance) -> Vec<String> {
     let mut violations = Vec::new();
 
     // Deadline check (client's local UTC time is authoritative)
@@ -407,8 +404,14 @@ impl ProtocolAdapter for LdpAdapter {
                     Ok(TaskStatus::Working)
                 }
             }
-            LdpMessageBody::TaskResult { output, mut provenance, .. } => {
-                provenance.lineage.insert(0, build_lineage_entry(&provenance, "task"));
+            LdpMessageBody::TaskResult {
+                output,
+                mut provenance,
+                ..
+            } => {
+                provenance
+                    .lineage
+                    .insert(0, build_lineage_entry(&provenance, "task"));
                 provenance.normalize();
                 let contracts = self.contracts.read().await;
                 if let Some(contract) = contracts.get(task_id) {
diff --git a/src/client.rs b/src/client.rs
@@ -70,10 +70,7 @@ impl LdpClient {
     ///
     /// Identity cards are served at `{url}/ldp/identity`.
     #[instrument(skip(self), fields(url = %url))]
-    pub async fn fetch_identity_card(
-        &self,
-        url: &str,
-    ) -> Result<LdpIdentityCard, String> {
+    pub async fn fetch_identity_card(&self, url: &str) -> Result<LdpIdentityCard, String> {
         let endpoint = format!("{}/ldp/identity", url.trim_end_matches('/'));
 
         debug!(endpoint = %endpoint, "Fetching LDP identity card");
@@ -105,9 +102,10 @@ impl LdpClient {
         let wellknown = format!("{}/.well-known/ldp-identity", url.trim_end_matches('/'));
 
         match self.http.get(&wellknown).send().await {
-            Ok(resp) if resp.status().is_success() => {
-                resp.json().await.map_err(|e| format!("Failed to parse identity: {e}"))
-            }
+            Ok(resp) if resp.status().is_success() => resp
+                .json()
+                .await
+                .map_err(|e| format!("Failed to parse identity: {e}")),
             _ => self.fetch_identity_card(url).await,
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -38,10 +38,10 @@ pub mod client;
 pub mod config;
 pub mod plugin;
 pub mod protocol;
+pub mod replay;
 pub mod server;
 pub mod session_manager;
 pub mod signing;
-pub mod replay;
 pub mod types;
 
 pub use adapter::LdpAdapter;
diff --git a/src/plugin.rs b/src/plugin.rs
@@ -83,7 +83,9 @@ mod tests {
         let mut registry = ProtocolRegistry::new();
         register_ldp(&mut registry, None);
 
-        assert!(registry.adapter_for_url("ldp://delegate.example.com").is_some());
+        assert!(registry
+            .adapter_for_url("ldp://delegate.example.com")
+            .is_some());
         assert!(registry.adapter_for_url("https://not-ldp.com").is_none());
     }
 
diff --git a/src/replay.rs b/src/replay.rs
@@ -21,13 +21,24 @@ impl ReplayGuard {
     }
 
     /// Check if a message should be accepted. Returns Err with reason if rejected.
-    pub fn check(&mut self, message_id: &str, nonce: Option<&str>, timestamp: &str) -> Result<(), String> {
+    pub fn check(
+        &mut self,
+        message_id: &str,
+        nonce: Option<&str>,
+        timestamp: &str,
+    ) -> Result<(), String> {
         // 1. Timestamp freshness check
         if let Ok(msg_time) = chrono::DateTime::parse_from_rfc3339(timestamp) {
             let now = chrono::Utc::now();
-            let diff = (now - msg_time.with_timezone(&chrono::Utc)).num_seconds().unsigned_abs();
+            let diff = (now - msg_time.with_timezone(&chrono::Utc))
+                .num_seconds()
+                .unsigned_abs();
             if diff > self.window.as_secs() {
-                return Err(format!("Message timestamp too old: {}s > {}s window", diff, self.window.as_secs()));
+                return Err(format!(
+                    "Message timestamp too old: {}s > {}s window",
+                    diff,
+                    self.window.as_secs()
+                ));
             }
         }
 
diff --git a/src/server.rs b/src/server.rs
@@ -110,9 +110,7 @@ impl LdpServer {
             metadata: HashMap::new(),
         };
 
-        let handler: TaskHandler = Arc::new(|_skill, input| {
-            json!({ "echo": input })
-        });
+        let handler: TaskHandler = Arc::new(|_skill, input| json!({ "echo": input }));
 
         Self::new(identity, handler)
     }
@@ -152,24 +150,32 @@ impl LdpServer {
         }
 
         let mut response = match &envelope.body {
-            LdpMessageBody::Hello { delegate_id, supported_modes } => {
-                self.handle_hello(&envelope, delegate_id, supported_modes).await
+            LdpMessageBody::Hello {
+                delegate_id,
+                supported_modes,
+            } => {
+                self.handle_hello(&envelope, delegate_id, supported_modes)
+                    .await
             }
             LdpMessageBody::SessionPropose { config } => {
                 self.handle_session_propose(&envelope, config).await
             }
-            LdpMessageBody::TaskSubmit { task_id, skill, input, .. } => {
-                self.handle_task_submit(&envelope, task_id, skill, input).await
+            LdpMessageBody::TaskSubmit {
+                task_id,
+                skill,
+                input,
+                ..
+            } => {
+                self.handle_task_submit(&envelope, task_id, skill, input)
+                    .await
             }
             LdpMessageBody::TaskUpdate { task_id, .. } => {
                 self.handle_task_status_query(&envelope, task_id).await
             }
             LdpMessageBody::TaskCancel { task_id } => {
                 self.handle_task_cancel(&envelope, task_id).await
             }
-            LdpMessageBody::SessionClose { .. } => {
-                self.handle_session_close(&envelope).await
-            }
+            LdpMessageBody::SessionClose { .. } => self.handle_session_close(&envelope).await,
             _ => Err(format!("Unhandled message type")),
         }?;
 
@@ -315,10 +321,8 @@ impl LdpServer {
         }
 
         // Build provenance.
-        let mut provenance = Provenance::new(
-            &self.identity.delegate_id,
-            &self.identity.model_version,
-        );
+        let mut provenance =
+            Provenance::new(&self.identity.delegate_id, &self.identity.model_version);
         provenance.verification_status = VerificationStatus::SelfVerified;
         #[allow(deprecated)]
         {
@@ -358,10 +362,8 @@ impl LdpServer {
         if let Some(record) = tasks.get(task_id) {
             let body = match record.state {
                 TaskRecordState::Completed => {
-                    let mut provenance = Provenance::new(
-                        &self.identity.delegate_id,
-                        &self.identity.model_version,
-                    );
+                    let mut provenance =
+                        Provenance::new(&self.identity.delegate_id, &self.identity.model_version);
                     provenance.verification_status = VerificationStatus::SelfVerified;
                     #[allow(deprecated)]
                     {
@@ -372,12 +374,15 @@ impl LdpServer {
                         output: record.output.clone().unwrap_or(json!(null)),
                         provenance,
                     }
-                },
+                }
                 TaskRecordState::Failed => LdpMessageBody::TaskFailed {
                     task_id: task_id.to_string(),
                     error: LdpError::runtime(
                         "TASK_FAILED",
-                        record.error.clone().unwrap_or_else(|| "unknown error".into()),
+                        record
+                            .error
+                            .clone()
+                            .unwrap_or_else(|| "unknown error".into()),
                     ),
                 },
                 _ => LdpMessageBody::TaskUpdate {
@@ -423,10 +428,7 @@ impl LdpServer {
     }
 
     /// Handle SESSION_CLOSE.
-    async fn handle_session_close(
-        &self,
-        envelope: &LdpEnvelope,
-    ) -> Result<LdpEnvelope, String> {
+    async fn handle_session_close(&self, envelope: &LdpEnvelope) -> Result<LdpEnvelope, String> {
         info!(session_id = %envelope.session_id, "Session closed");
 
         let mut sessions = self.sessions.write().await;
diff --git a/src/session_manager.rs b/src/session_manager.rs
@@ -119,10 +119,8 @@ impl SessionManager {
         let remote_delegate_id = hello_response.from.clone();
 
         // Step 3: Negotiate payload mode
-        let negotiated = negotiate_payload_mode(
-            &session_config.preferred_payload_modes,
-            &remote_modes,
-        );
+        let negotiated =
+            negotiate_payload_mode(&session_config.preferred_payload_modes, &remote_modes);
 
         debug!(
             mode = %negotiated.mode,
diff --git a/src/signing.rs b/src/signing.rs
@@ -50,9 +50,7 @@ pub fn sign_envelope(envelope: &LdpEnvelope, secret: &str) -> String {
             mac.update(reason.as_bytes());
             "SESSION_REJECT"
         }
-        LdpMessageBody::TaskSubmit {
-            task_id, skill, ..
-        } => {
+        LdpMessageBody::TaskSubmit { task_id, skill, .. } => {
             mac.update(task_id.as_bytes());
             mac.update(b"|");
             mac.update(skill.as_bytes());
@@ -148,10 +146,7 @@ mod tests {
         let mut envelope = make_envelope();
         apply_signature(&mut envelope, "test-secret");
         assert!(envelope.signature.is_some());
-        assert_eq!(
-            envelope.signature_algorithm.as_deref(),
-            Some("hmac-sha256")
-        );
+        assert_eq!(envelope.signature_algorithm.as_deref(), Some("hmac-sha256"));
     }
 
     #[test]
diff --git a/src/types/contract.rs b/src/types/contract.rs
@@ -93,23 +93,30 @@ mod tests {
 
     #[test]
     fn contract_creation() {
-        let contract = DelegationContract::new("Summarize the document", vec!["<=300 words".into()]);
+        let contract =
+            DelegationContract::new("Summarize the document", vec!["<=300 words".into()]);
         assert!(!contract.contract_id.is_empty());
         assert_eq!(contract.objective, "Summarize the document");
         assert!(contract.deadline.is_none());
     }
 
     #[test]
     fn contract_with_deadline() {
-        let contract = DelegationContract::new("task", vec![]).with_deadline("2026-12-31T23:59:59Z");
+        let contract =
+            DelegationContract::new("task", vec![]).with_deadline("2026-12-31T23:59:59Z");
         assert_eq!(contract.deadline.as_deref(), Some("2026-12-31T23:59:59Z"));
     }
 
     #[test]
     fn contract_with_budget() {
-        let contract = DelegationContract::new("task", vec![])
-            .with_budget(BudgetPolicy { max_tokens: Some(5000), max_cost_usd: Some(0.05) });
-        assert_eq!(contract.policy.budget.as_ref().unwrap().max_tokens, Some(5000));
+        let contract = DelegationContract::new("task", vec![]).with_budget(BudgetPolicy {
+            max_tokens: Some(5000),
+            max_cost_usd: Some(0.05),
+        });
+        assert_eq!(
+            contract.policy.budget.as_ref().unwrap().max_tokens,
+            Some(5000)
+        );
     }
 
     #[test]
@@ -122,7 +129,10 @@ mod tests {
     fn serialization_roundtrip() {
         let contract = DelegationContract::new("Analyze data", vec!["accuracy > 0.9".into()])
             .with_deadline("2026-06-01T00:00:00Z")
-            .with_budget(BudgetPolicy { max_tokens: Some(10000), max_cost_usd: None })
+            .with_budget(BudgetPolicy {
+                max_tokens: Some(10000),
+                max_cost_usd: None,
+            })
             .with_failure_policy(FailurePolicy::FailClosed);
         let json = serde_json::to_value(&contract).unwrap();
         let restored: DelegationContract = serde_json::from_value(json).unwrap();
diff --git a/src/types/identity.rs b/src/types/identity.rs
@@ -76,10 +76,7 @@ impl LdpIdentityCard {
         labels.insert("ldp.model_family".into(), self.model_family.clone());
         labels.insert("ldp.model_version".into(), self.model_version.clone());
         labels.insert("ldp.trust_domain".into(), self.trust_domain.name.clone());
-        labels.insert(
-            "ldp.context_window".into(),
-            self.context_window.to_string(),
-        );
+        labels.insert("ldp.context_window".into(), self.context_window.to_string());
 
         if let Some(ref fp) = self.weights_fingerprint {
             labels.insert("ldp.weights_fingerprint".into(), fp.clone());
diff --git a/src/types/mod.rs b/src/types/mod.rs
@@ -14,13 +14,13 @@ pub mod session;
 pub mod trust;
 pub mod verification;
 
-pub use capability::{LdpCapability, QualityMetrics, ClaimType};
-pub use contract::{DelegationContract, PolicyEnvelope, FailurePolicy, BudgetPolicy};
-pub use error::{LdpError, FailureCategory, ErrorSeverity};
+pub use capability::{ClaimType, LdpCapability, QualityMetrics};
+pub use contract::{BudgetPolicy, DelegationContract, FailurePolicy, PolicyEnvelope};
+pub use error::{ErrorSeverity, FailureCategory, LdpError};
 pub use identity::LdpIdentityCard;
 pub use messages::{LdpEnvelope, LdpMessageBody};
 pub use payload::PayloadMode;
 pub use provenance::Provenance;
 pub use session::{LdpSession, SessionConfig, SessionState};
 pub use trust::TrustDomain;
-pub use verification::{VerificationStatus, EvidenceRef, ProvenanceEntry};
+pub use verification::{EvidenceRef, ProvenanceEntry, VerificationStatus};
diff --git a/src/types/provenance.rs b/src/types/provenance.rs
@@ -4,7 +4,7 @@
 //! which model, what payload mode, confidence, and verification status.
 
 use crate::types::payload::PayloadMode;
-use crate::types::verification::{VerificationStatus, EvidenceRef, ProvenanceEntry};
+use crate::types::verification::{EvidenceRef, ProvenanceEntry, VerificationStatus};
 use serde::{Deserialize, Serialize};
 
 /// Provenance metadata attached to every LDP task result.
diff --git a/src/types/verification.rs b/src/types/verification.rs
@@ -48,7 +48,10 @@ mod tests {
 
     #[test]
     fn default_verification_is_unverified() {
-        assert_eq!(VerificationStatus::default(), VerificationStatus::Unverified);
+        assert_eq!(
+            VerificationStatus::default(),
+            VerificationStatus::Unverified
+        );
     }
 
     #[test]
@@ -100,6 +103,9 @@ mod tests {
         let json = serde_json::to_value(&entry).unwrap();
         let restored: ProvenanceEntry = serde_json::from_value(json).unwrap();
         assert_eq!(restored.delegate_id, "ldp:delegate:alpha");
-        assert_eq!(restored.verification_status, VerificationStatus::SelfVerified);
+        assert_eq!(
+            restored.verification_status,
+            VerificationStatus::SelfVerified
+        );
     }
 }
diff --git a/tests/ldp_integration.rs b/tests/ldp_integration.rs

Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,9 @@ mod tests {`
`83`	`83`	`let mut registry = ProtocolRegistry::new();`
`84`	`84`	`register_ldp(&mut registry, None);`
`85`	`85`
`86`		`- assert!(registry.adapter_for_url("ldp://delegate.example.com").is_some());`
	`86`	`+ assert!(registry`
	`87`	`+ .adapter_for_url("ldp://delegate.example.com")`
	`88`	`+ .is_some());`
`87`	`89`	`assert!(registry.adapter_for_url("https://not-ldp.com").is_none());`
`88`	`90`	`}`
`89`	`91`