clippy fixes

Author: passcod

src/bin/gen-crds.rs

@@ -5,10 +5,10 @@ fn main() {
 	let replica_crd = serde_json::to_value(PostgresPhysicalReplica::crd()).unwrap();
 	let restore_crd = serde_json::to_value(PostgresPhysicalRestore::crd()).unwrap();
 
-	let docs = vec![replica_crd, restore_crd];
+	let docs = [replica_crd, restore_crd];
 	for (i, doc) in docs.iter().enumerate() {
 		if i > 0 {
-			print!("---\n");
+			println!("---");
 		}
 		print!("{}", serde_yaml::to_string(doc).unwrap());
 	}

src/controllers/replica.rs

@@ -222,16 +222,16 @@ pub async fn reconcile(replica: Arc<PostgresPhysicalReplica>, ctx: Arc<Context>)
 			&ctx.http_client,
 			&namespace,
 			&replica,
-			&switching,
+			switching,
 			&conn_info,
 			&creds_secret_name,
 			&ctx.metrics,
 		)
 		.await;
 
 		// Recompute next scheduled restore in case schedule changed while restore was in flight
-		if let Some(schedule) = &replica.spec.schedule {
-			if let Some(next) = compute_next_scheduled_restore(schedule) {
+		if let Some(schedule) = &replica.spec.schedule
+			&& let Some(next) = compute_next_scheduled_restore(schedule) {
 				update_replica_status_field(
 					client,
 					&namespace,
@@ -241,7 +241,6 @@ pub async fn reconcile(replica: Arc<PostgresPhysicalReplica>, ctx: Arc<Context>)
 				)
 				.await?;
 			}
-		}
 
 		return Ok(Action::requeue(Duration::from_secs(10)));
 	}
@@ -413,8 +412,8 @@ pub async fn reconcile(replica: Arc<PostgresPhysicalReplica>, ctx: Arc<Context>)
 
 		// Whether a restore was created or skipped, advance nextScheduledRestore
 		// so we don't re-trigger on the next reconciliation.
-		if let Some(schedule) = &replica.spec.schedule {
-			if let Some(next) = compute_next_scheduled_restore(schedule) {
+		if let Some(schedule) = &replica.spec.schedule
+			&& let Some(next) = compute_next_scheduled_restore(schedule) {
 				update_replica_status_field(
 					client,
 					&namespace,
@@ -424,7 +423,6 @@ pub async fn reconcile(replica: Arc<PostgresPhysicalReplica>, ctx: Arc<Context>)
 				)
 				.await?;
 			}
-		}
 	}
 
 	// Update phase based on current state
@@ -693,16 +691,15 @@ fn should_trigger_scheduled_restore(replica: &PostgresPhysicalReplica) -> bool {
 	let status = replica.status.as_ref();
 
 	// Check minimumTTL
-	if let Some(last_completed) = status.and_then(|s| s.last_restore_completed_at.as_ref()) {
-		if let Ok(last_completed) = last_completed.parse::<chrono::DateTime<Utc>>() {
+	if let Some(last_completed) = status.and_then(|s| s.last_restore_completed_at.as_ref())
+		&& let Ok(last_completed) = last_completed.parse::<chrono::DateTime<Utc>>() {
 			let minimum_ttl =
 				parse_duration(&replica.spec.minimum_ttl).unwrap_or(Duration::from_secs(6 * 3600));
 			let elapsed = Utc::now().signed_duration_since(last_completed);
 			if elapsed.to_std().unwrap_or_default() < minimum_ttl {
 				return false;
 			}
 		}
-	}
 
 	// Check cron schedule
 	let Ok(cron_schedule) = schedule.parse::<cron::Schedule>() else {
@@ -717,13 +714,12 @@ fn should_trigger_scheduled_restore(replica: &PostgresPhysicalReplica) -> bool {
 
 	let now = Utc::now();
 
-	if let Some(next_scheduled) = status.and_then(|s| s.next_scheduled_restore.as_ref()) {
-		if let Ok(next) = next_scheduled.parse::<chrono::DateTime<Utc>>() {
+	if let Some(next_scheduled) = status.and_then(|s| s.next_scheduled_restore.as_ref())
+		&& let Ok(next) = next_scheduled.parse::<chrono::DateTime<Utc>>() {
 			// Add jitter to the scheduled time
 			let trigger_at = next + chrono::Duration::from_std(jitter).unwrap_or_default();
 			return now >= trigger_at;
 		}
-	}
 
 	// Initial seed: nextScheduledRestore not yet set (first reconciliation or field was cleared).
 	// Fall back to checking whether a cron occurrence falls within a 24h lookback window.

src/controllers/restore.rs

@@ -349,8 +349,8 @@ async fn reconcile_ready(
 		}
 
 		// Check for timeout (10 minutes)
-		if let Some(created_at) = restore.status.as_ref().and_then(|s| s.restored_at.as_ref()) {
-			if let Ok(created) = created_at.parse::<chrono::DateTime<Utc>>() {
+		if let Some(created_at) = restore.status.as_ref().and_then(|s| s.restored_at.as_ref())
+			&& let Ok(created) = created_at.parse::<chrono::DateTime<Utc>>() {
 				let elapsed = Utc::now().signed_duration_since(created);
 				if elapsed > chrono::Duration::minutes(10) {
 					warn!(
@@ -383,7 +383,6 @@ async fn reconcile_ready(
 					return Ok(Action::requeue(Duration::from_secs(300)));
 				}
 			}
-		}
 
 		return Ok(Action::requeue(Duration::from_secs(10)));
 	}

src/kopia.rs

@@ -110,11 +110,10 @@ pub fn filter_snapshots(snapshots: &[Snapshot], filter: Option<&SnapshotFilter>)
 			}
 
 			// Host pattern filtering
-			if let Some(pattern) = &filter.host_pattern {
-				if !glob_matches(pattern, &snap.hostname) {
+			if let Some(pattern) = &filter.host_pattern
+				&& !glob_matches(pattern, &snap.hostname) {
 					return false;
 				}
-			}
 
 			true
 		})