fix: clippy and fmt — range contains, allow explicit_auto_deref

Author: copyleftdev

Cargo.lock

@@ -108,10 +108,18 @@ async fn main() -> Result<()> {
     }
 
     match cli.command {
-        Command::Serve { host, port, data_dir } => {
+        Command::Serve {
+            host,
+            port,
+            data_dir,
+        } => {
             cmd_serve(&host, port, &data_dir).await?;
         }
-        Command::Query { pql, data_dir, limit } => {
+        Command::Query {
+            pql,
+            data_dir,
+            limit,
+        } => {
             cmd_query(&pql, &data_dir, limit)?;
         }
         Command::Stats { data_dir } => {
@@ -139,7 +147,7 @@ async fn cmd_serve(host: &str, port: u16, data_dir: &str) -> Result<()> {
 fn cmd_query(pql: &str, data_dir: &str, limit: usize) -> Result<()> {
     use parallax_graph::GraphReader;
     use parallax_query::{execute, parse, plan, IndexStats, QueryLimits, QueryResult};
-    use parallax_store::{StoreConfig, StorageEngine};
+    use parallax_store::{StorageEngine, StoreConfig};
     use std::collections::HashMap;
 
     let config = StoreConfig::new(data_dir);
@@ -152,16 +160,27 @@ fn cmd_query(pql: &str, data_dir: &str, limit: usize) -> Result<()> {
     let mut class_counts: HashMap<String, usize> = HashMap::new();
     for e in &all {
         *type_counts.entry(e._type.as_str().to_owned()).or_insert(0) += 1;
-        *class_counts.entry(e._class.as_str().to_owned()).or_insert(0) += 1;
+        *class_counts
+            .entry(e._class.as_str().to_owned())
+            .or_insert(0) += 1;
     }
-    let stats = IndexStats::new(type_counts, class_counts, snap.entity_count(), snap.relationship_count());
+    let stats = IndexStats::new(
+        type_counts,
+        class_counts,
+        snap.entity_count(),
+        snap.relationship_count(),
+    );
 
     let ast = parse(pql).map_err(|e| anyhow::anyhow!("Parse error: {e}"))?;
     let query_plan = plan(ast, &stats).map_err(|e| anyhow::anyhow!("Plan error: {e}"))?;
 
     let graph = GraphReader::new(&snap);
-    let limits = QueryLimits { max_results: limit, ..QueryLimits::default() };
-    let result = execute(&query_plan, &graph, limits).map_err(|e| anyhow::anyhow!("Exec error: {e}"))?;
+    let limits = QueryLimits {
+        max_results: limit,
+        ..QueryLimits::default()
+    };
+    let result =
+        execute(&query_plan, &graph, limits).map_err(|e| anyhow::anyhow!("Exec error: {e}"))?;
 
     let count = result.count();
     println!("Results: {count}");
@@ -205,18 +224,22 @@ fn cmd_query(pql: &str, data_dir: &str, limit: usize) -> Result<()> {
 }
 
 fn cmd_stats(data_dir: &str) -> Result<()> {
-    use parallax_store::{StoreConfig, StorageEngine};
+    use parallax_store::{StorageEngine, StoreConfig};
 
     let config = StoreConfig::new(data_dir);
     let engine = StorageEngine::open(config)?;
     let snap = engine.snapshot();
 
     let all = snap.all_entities();
-    let mut type_counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
-    let mut class_counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
+    let mut type_counts: std::collections::HashMap<String, usize> =
+        std::collections::HashMap::new();
+    let mut class_counts: std::collections::HashMap<String, usize> =
+        std::collections::HashMap::new();
     for e in &all {
         *type_counts.entry(e._type.as_str().to_owned()).or_insert(0) += 1;
-        *class_counts.entry(e._class.as_str().to_owned()).or_insert(0) += 1;
+        *class_counts
+            .entry(e._class.as_str().to_owned())
+            .or_insert(0) += 1;
     }
 
     println!("Parallax Graph Statistics");
@@ -244,8 +267,8 @@ fn cmd_wal_dump(data_dir: &str, verbose: bool) -> Result<()> {
     use parallax_store::{dump_wal, WriteOp};
     use std::path::Path;
 
-    let entries = dump_wal(Path::new(data_dir))
-        .map_err(|e| anyhow::anyhow!("WAL read error: {e}"))?;
+    let entries =
+        dump_wal(Path::new(data_dir)).map_err(|e| anyhow::anyhow!("WAL read error: {e}"))?;
 
     if entries.is_empty() {
         println!("WAL is empty (data_dir: {data_dir})");
@@ -274,7 +297,8 @@ fn cmd_wal_dump(data_dir: &str, verbose: bool) -> Result<()> {
                         println!("    - entity  id={id}");
                     }
                     WriteOp::UpsertRelationship(r) => {
-                        println!("    + rel     [{cls}] {from} → {to}",
+                        println!(
+                            "    + rel     [{cls}] {from} → {to}",
                             cls = r._class.as_str(),
                             from = r.from_id,
                             to = r.to_id,

crates/connector-aws-synthetic/src/lib.rs

@@ -206,7 +206,9 @@ mod tests {
 
     #[test]
     fn entity_builder_derives_id() {
-        let e = entity("host", "h1").class("Host").build("acme", test_source());
+        let e = entity("host", "h1")
+            .class("Host")
+            .build("acme", test_source());
         assert_eq!(e.id, EntityId::derive("acme", "host", "h1"));
         assert_eq!(e._type.as_str(), "host");
         assert_eq!(e._class.as_str(), "Host");

crates/connector-gcp-synthetic/src/lib.rs

@@ -49,7 +49,11 @@ impl StepDefinitionBuilder {
     }
 
     pub fn build(self) -> StepDefinition {
-        StepDefinition { id: self.id, description: self.description, depends_on: self.depends_on }
+        StepDefinition {
+            id: self.id,
+            description: self.description,
+            depends_on: self.depends_on,
+        }
     }
 }
 
@@ -70,11 +74,13 @@ pub struct PriorStepData {
 
 impl PriorStepData {
     pub fn get(&self, entity_type: &str, entity_key: &str) -> Option<&EntityBuilder> {
-        self.entities.get(&(entity_type.to_owned(), entity_key.to_owned()))
+        self.entities
+            .get(&(entity_type.to_owned(), entity_key.to_owned()))
     }
 
     pub(crate) fn insert(&mut self, b: &EntityBuilder) {
-        self.entities.insert((b.entity_type.clone(), b.entity_key.clone()), b.clone());
+        self.entities
+            .insert((b.entity_type.clone(), b.entity_key.clone()), b.clone());
     }
 }
 
@@ -156,11 +162,7 @@ impl StepContext {
     }
 
     /// Look up an entity emitted by a prior step.
-    pub fn get_prior_entity(
-        &self,
-        entity_type: &str,
-        entity_key: &str,
-    ) -> Option<&EntityBuilder> {
+    pub fn get_prior_entity(&self, entity_type: &str, entity_key: &str) -> Option<&EntityBuilder> {
         self.prior_entities.get(entity_type, entity_key)
     }
 
@@ -198,8 +200,7 @@ pub trait Connector: Send + Sync {
 
 /// Validate that step dependencies are acyclic (INV-C05).
 pub fn validate_steps(steps: &[StepDefinition]) -> Result<(), ConnectorError> {
-    let step_ids: std::collections::HashSet<&str> =
-        steps.iter().map(|s| s.id.as_str()).collect();
+    let step_ids: std::collections::HashSet<&str> = steps.iter().map(|s| s.id.as_str()).collect();
 
     // Check all declared dependencies exist.
     for step in steps {
@@ -311,7 +312,8 @@ pub fn topological_order(steps: &[StepDefinition]) -> Vec<&StepDefinition> {
         .map(|(&id, _)| id)
         .collect();
 
-    let step_map: HashMap<&str, &StepDefinition> = steps.iter().map(|s| (s.id.as_str(), s)).collect();
+    let step_map: HashMap<&str, &StepDefinition> =
+        steps.iter().map(|s| (s.id.as_str(), s)).collect();
     let mut result = Vec::new();
 
     while let Some(id) = queue.pop_front() {
@@ -355,13 +357,19 @@ mod tests {
     #[test]
     fn validate_cyclic_steps_error() {
         let steps = make_steps(&[("a", &["b"]), ("b", &["a"])]);
-        assert!(matches!(validate_steps(&steps), Err(ConnectorError::DependencyCycle { .. })));
+        assert!(matches!(
+            validate_steps(&steps),
+            Err(ConnectorError::DependencyCycle { .. })
+        ));
     }
 
     #[test]
     fn topological_order_respects_dependencies() {
         let steps = make_steps(&[("a", &[]), ("b", &["a"]), ("c", &["b"])]);
-        let order: Vec<&str> = topological_order(&steps).iter().map(|s| s.id.as_str()).collect();
+        let order: Vec<&str> = topological_order(&steps)
+            .iter()
+            .map(|s| s.id.as_str())
+            .collect();
         let a = order.iter().position(|&s| s == "a").unwrap();
         let b = order.iter().position(|&s| s == "b").unwrap();
         let c = order.iter().position(|&s| s == "c").unwrap();

crates/parallax-cli/src/main.rs

@@ -13,10 +13,17 @@ pub enum ConnectorError {
     AuthFailed { reason: String },
 
     #[error("API request failed: {endpoint} returned {status}: {body}")]
-    ApiError { endpoint: String, status: u16, body: String },
+    ApiError {
+        endpoint: String,
+        status: u16,
+        body: String,
+    },
 
     #[error("Rate limited by {service}. Retry after {retry_after:?}")]
-    RateLimited { service: String, retry_after: Option<Duration> },
+    RateLimited {
+        service: String,
+        retry_after: Option<Duration>,
+    },
 
     #[error("Entity validation failed: {reason}")]
     ValidationFailed { reason: String },

crates/parallax-connect/src/builder.rs

@@ -9,10 +9,30 @@ use crate::error::ConnectorError;
 /// Events emitted during a sync cycle for observability.
 #[derive(Debug)]
 pub enum SyncEvent {
-    Started { connector_id: String, sync_id: String },
-    StepStarted { step_id: String },
-    StepCompleted { step_id: String, entities: u64, relationships: u64, duration: Duration },
-    StepFailed { step_id: String, error: ConnectorError },
-    SyncCompleted { sync_id: String, entities_created: u64, entities_deleted: u64 },
-    SyncFailed { sync_id: String, error: String },
+    Started {
+        connector_id: String,
+        sync_id: String,
+    },
+    StepStarted {
+        step_id: String,
+    },
+    StepCompleted {
+        step_id: String,
+        entities: u64,
+        relationships: u64,
+        duration: Duration,
+    },
+    StepFailed {
+        step_id: String,
+        error: ConnectorError,
+    },
+    SyncCompleted {
+        sync_id: String,
+        entities_created: u64,
+        entities_deleted: u64,
+    },
+    SyncFailed {
+        sync_id: String,
+        error: String,
+    },
 }

crates/parallax-connect/src/connector.rs

@@ -23,7 +23,10 @@ use crate::connector::{topological_waves, Connector, PriorStepData, StepContext}
 use crate::error::{ConnectorError, SyncError};
 use crate::event::SyncEvent;
 
-type StepOutcome = (String, Result<(StepContext, std::time::Duration), ConnectorError>);
+type StepOutcome = (
+    String,
+    Result<(StepContext, std::time::Duration), ConnectorError>,
+);
 
 /// Output collected from a connector run, ready to be committed.
 ///
@@ -56,10 +59,13 @@ pub async fn run_connector(
 ) -> Result<ConnectorOutput, SyncError> {
     let connector_id = connector.name().to_owned();
 
-    emit(&event_tx, SyncEvent::Started {
-        connector_id: connector_id.clone(),
-        sync_id: sync_id.to_owned(),
-    })
+    emit(
+        &event_tx,
+        SyncEvent::Started {
+            connector_id: connector_id.clone(),
+            sync_id: sync_id.to_owned(),
+        },
+    )
     .await;
 
     let steps = connector.steps();
@@ -72,7 +78,13 @@ pub async fn run_connector(
     for wave in waves {
         // Emit StepStarted for each step in the wave before spawning.
         for step_id in &wave {
-            emit(&event_tx, SyncEvent::StepStarted { step_id: step_id.clone() }).await;
+            emit(
+                &event_tx,
+                SyncEvent::StepStarted {
+                    step_id: step_id.clone(),
+                },
+            )
+            .await;
         }
 
         // Spawn all steps in the wave concurrently.
@@ -111,12 +123,15 @@ pub async fn run_connector(
                         new_prior.insert(b);
                     }
 
-                    emit(&event_tx, SyncEvent::StepCompleted {
-                        step_id: step_id.clone(),
-                        entities: step_entities,
-                        relationships: step_rels,
-                        duration: elapsed,
-                    })
+                    emit(
+                        &event_tx,
+                        SyncEvent::StepCompleted {
+                            step_id: step_id.clone(),
+                            entities: step_entities,
+                            relationships: step_rels,
+                            duration: elapsed,
+                        },
+                    )
                     .await;
 
                     // Collect materialised entities and relationships.
@@ -132,10 +147,13 @@ pub async fn run_connector(
                 }
                 Ok((step_id, Err(e))) => {
                     warn!(step_id = %step_id, error = %e, "Step failed");
-                    emit(&event_tx, SyncEvent::StepFailed {
-                        step_id: step_id.clone(),
-                        error: e,
-                    })
+                    emit(
+                        &event_tx,
+                        SyncEvent::StepFailed {
+                            step_id: step_id.clone(),
+                            error: e,
+                        },
+                    )
                     .await;
                     // Continue with other steps in the wave (INV-C06).
                 }
@@ -173,20 +191,24 @@ async fn emit(tx: &Option<&tokio::sync::mpsc::Sender<SyncEvent>>, event: SyncEve
 #[cfg(test)]
 mod tests {
     use super::*;
-    use async_trait::async_trait;
     use crate::builder::entity;
     use crate::connector::{step, StepDefinition};
     use crate::error::ConnectorError;
+    use async_trait::async_trait;
 
     struct MockConnector {
         steps: Vec<StepDefinition>,
     }
 
     #[async_trait]
     impl Connector for MockConnector {
-        fn name(&self) -> &str { "mock" }
+        fn name(&self) -> &str {
+            "mock"
+        }
 
-        fn steps(&self) -> Vec<StepDefinition> { self.steps.clone() }
+        fn steps(&self) -> Vec<StepDefinition> {
+            self.steps.clone()
+        }
 
         async fn execute_step(
             &self,
@@ -202,7 +224,9 @@ mod tests {
 
     #[async_trait]
     impl Connector for FailingConnector {
-        fn name(&self) -> &str { "failing" }
+        fn name(&self) -> &str {
+            "failing"
+        }
 
         fn steps(&self) -> Vec<StepDefinition> {
             vec![