chore: linter fixes

Author: evansims

src/client/auth.rs

@@ -128,10 +128,10 @@ impl OAuthFlow {
             .expires_in()
             .map(|d| chrono::Utc::now() + chrono::Duration::seconds(d.as_secs() as i64));
 
-        if let Some(refresh) = refresh_token {
-            if let Some(expires) = expires_at {
-                return Ok(Credentials::with_refresh(access_token, refresh, expires));
-            }
+        if let Some(refresh) = refresh_token
+            && let Some(expires) = expires_at
+        {
+            return Ok(Credentials::with_refresh(access_token, refresh, expires));
         }
 
         Ok(Credentials::new(access_token))

src/commands/dev/reset.rs

@@ -219,11 +219,10 @@ fn redeploy_applications(deploy_dir: &std::path::Path) {
                     "-o",
                     "jsonpath={.status.readyReplicas}",
                 ],
-            ) {
-                if output.trim() == "1" {
-                    ready = true;
-                    break;
-                }
+            ) && output.trim() == "1"
+            {
+                ready = true;
+                break;
             }
             std::thread::sleep(Duration::from_secs(2));
         }

src/commands/dev/start.rs

@@ -53,10 +53,11 @@ pub async fn start(
     commit: Option<&str>,
 ) -> Result<()> {
     // Save CLI-provided credentials if both are present
-    if let (Some(client_id), Some(client_secret)) = (&tailscale_client, &tailscale_secret) {
-        if !client_id.is_empty() && !client_secret.is_empty() {
-            save_tailscale_credentials(client_id, client_secret)?;
-        }
+    if let (Some(client_id), Some(client_secret)) = (&tailscale_client, &tailscale_secret)
+        && !client_id.is_empty()
+        && !client_secret.is_empty()
+    {
+        save_tailscale_credentials(client_id, client_secret)?;
     }
 
     // For new cluster creation, use interactive mode if requested
@@ -854,10 +855,10 @@ fn start_with_streaming(skip_build: bool, force: bool, commit: Option<&str>) ->
     )?;
 
     run_step(&StartStep::with_ok("Setting kubectl context", "Set kubectl context"), || {
-        if let Some(current) = kubectl_current_context() {
-            if current == KUBE_CONTEXT {
-                return Ok(StepOutcome::Skipped);
-            }
+        if let Some(current) = kubectl_current_context()
+            && current == KUBE_CONTEXT
+        {
+            return Ok(StepOutcome::Skipped);
         }
         kubectl_use_context(KUBE_CONTEXT).map(|()| StepOutcome::Success)
     })?;

src/commands/dev/status.rs

@@ -123,31 +123,29 @@ fn print_nodes_status() {
     let red = Color::Red.to_ansi_fg();
     let reset = RESET;
 
-    if let Some(output) = output {
-        if let Ok(json) = serde_json::from_str::<serde_json::Value>(&output) {
-            if let Some(items) = json["items"].as_array() {
-                for node in items {
-                    let name = node["metadata"]["name"].as_str().unwrap_or("");
-                    let labels = &node["metadata"]["labels"];
-                    let is_control_plane =
-                        labels.get("node-role.kubernetes.io/control-plane").is_some();
-
-                    let ready = node["status"]["conditions"]
-                        .as_array()
-                        .and_then(|conditions| conditions.iter().find(|c| c["type"] == "Ready"))
-                        .is_some_and(|c| c["status"] == "True");
-
-                    let role = if is_control_plane { "control-plane" } else { "worker" };
-                    let status = if ready {
-                        format!("{green}Ready{reset} ({role})")
-                    } else {
-                        format!("{red}NotReady{reset} ({role})")
-                    };
-
-                    let display_name = name.strip_prefix("inferadb-dev-").unwrap_or(name);
-                    print_prefixed_dot_leader(" ", display_name, &status);
-                }
-            }
+    if let Some(output) = output
+        && let Ok(json) = serde_json::from_str::<serde_json::Value>(&output)
+        && let Some(items) = json["items"].as_array()
+    {
+        for node in items {
+            let name = node["metadata"]["name"].as_str().unwrap_or("");
+            let labels = &node["metadata"]["labels"];
+            let is_control_plane = labels.get("node-role.kubernetes.io/control-plane").is_some();
+
+            let ready = node["status"]["conditions"]
+                .as_array()
+                .and_then(|conditions| conditions.iter().find(|c| c["type"] == "Ready"))
+                .is_some_and(|c| c["status"] == "True");
+
+            let role = if is_control_plane { "control-plane" } else { "worker" };
+            let status = if ready {
+                format!("{green}Ready{reset} ({role})")
+            } else {
+                format!("{red}NotReady{reset} ({role})")
+            };
+
+            let display_name = name.strip_prefix("inferadb-dev-").unwrap_or(name);
+            print_prefixed_dot_leader(" ", display_name, &status);
         }
     }
 }
@@ -216,10 +214,10 @@ fn print_pods_status() {
 
     if let Some(output) = inferadb_pods {
         for line in output.lines() {
-            if let Some((name, status)) = format_pod(line) {
-                if seen_names.insert(name.clone()) {
-                    print_prefixed_dot_leader(" ", &name, &status);
-                }
+            if let Some((name, status)) = format_pod(line)
+                && seen_names.insert(name.clone())
+            {
+                print_prefixed_dot_leader(" ", &name, &status);
             }
         }
     }

src/commands/dev/stop.rs

@@ -339,24 +339,24 @@ fn cleanup_tailscale_devices() -> Result<()> {
         .map_err(|e| Error::Other(e.to_string()))?;
 
     let response = String::from_utf8_lossy(&output.stdout);
-    if let Ok(json) = serde_json::from_str::<serde_json::Value>(&response) {
-        if let Some(devices) = json.get("devices").and_then(|d| d.as_array()) {
-            for device in devices {
-                let name = device.get("hostname").and_then(|n| n.as_str()).unwrap_or("");
-                let id = device.get("id").and_then(|i| i.as_str()).unwrap_or("");
-
-                if name.starts_with(TAILSCALE_DEVICE_PREFIX) && !id.is_empty() {
-                    let _ = Command::new("curl")
-                        .args([
-                            "-s",
-                            "-X",
-                            "DELETE",
-                            "-H",
-                            &format!("Authorization: Bearer {token}"),
-                            &format!("https://api.tailscale.com/api/v2/device/{id}"),
-                        ])
-                        .output();
-                }
+    if let Ok(json) = serde_json::from_str::<serde_json::Value>(&response)
+        && let Some(devices) = json.get("devices").and_then(|d| d.as_array())
+    {
+        for device in devices {
+            let name = device.get("hostname").and_then(|n| n.as_str()).unwrap_or("");
+            let id = device.get("id").and_then(|i| i.as_str()).unwrap_or("");
+
+            if name.starts_with(TAILSCALE_DEVICE_PREFIX) && !id.is_empty() {
+                let _ = Command::new("curl")
+                    .args([
+                        "-s",
+                        "-X",
+                        "DELETE",
+                        "-H",
+                        &format!("Authorization: Bearer {token}"),
+                        &format!("https://api.tailscale.com/api/v2/device/{id}"),
+                    ])
+                    .output();
             }
         }
     }

src/commands/dev/tailscale.rs

@@ -74,10 +74,10 @@ pub fn get_tailscale_credentials() -> Result<(String, String)> {
     // Try environment variables first
     if let (Ok(id), Ok(secret)) =
         (env::var("TAILSCALE_CLIENT_ID"), env::var("TAILSCALE_CLIENT_SECRET"))
+        && !id.is_empty()
+        && !secret.is_empty()
     {
-        if !id.is_empty() && !secret.is_empty() {
-            return Ok((id, secret));
-        }
+        return Ok((id, secret));
     }
 
     // Try cached credentials

src/commands/identity.rs

@@ -289,12 +289,10 @@ async fn show_health(ctx: &Context, verbose: bool) -> Result<()> {
             println!("Status: ✓ healthy");
             println!("Latency: {}ms", start.elapsed().as_millis());
 
-            if verbose {
-                if let Ok(body) = resp.text().await {
-                    println!();
-                    println!("Response:");
-                    println!("{body}");
-                }
+            if verbose && let Ok(body) = resp.text().await {
+                println!();
+                println!("Response:");
+                println!("{body}");
             }
         },
         Ok(resp) => {
@@ -522,17 +520,17 @@ pub async fn what_changed(
             if log.timestamp < since_time {
                 return false;
             }
-            if let Some(ref ut) = until_time {
-                if log.timestamp > *ut {
-                    return false;
-                }
+            if let Some(ref ut) = until_time
+                && log.timestamp > *ut
+            {
+                return false;
             }
 
             // Actor filter
-            if let Some(a) = actor {
-                if !log.actor.id.contains(a) {
-                    return false;
-                }
+            if let Some(a) = actor
+                && !log.actor.id.contains(a)
+            {
+                return false;
             }
 
             // Resource filter
@@ -1202,25 +1200,25 @@ fn parse_time_spec(spec: &str) -> chrono::DateTime<chrono::Utc> {
         "today" => now - Duration::hours(i64::from(now.hour())),
         _ => {
             // Try parsing as duration like "1h", "1d", "30m"
-            if let Some(stripped) = spec.strip_suffix('h') {
-                if let Ok(hours) = stripped.parse::<i64>() {
-                    return now - Duration::hours(hours);
-                }
+            if let Some(stripped) = spec.strip_suffix('h')
+                && let Ok(hours) = stripped.parse::<i64>()
+            {
+                return now - Duration::hours(hours);
             }
-            if let Some(stripped) = spec.strip_suffix('d') {
-                if let Ok(days) = stripped.parse::<i64>() {
-                    return now - Duration::days(days);
-                }
+            if let Some(stripped) = spec.strip_suffix('d')
+                && let Ok(days) = stripped.parse::<i64>()
+            {
+                return now - Duration::days(days);
             }
-            if let Some(stripped) = spec.strip_suffix('m') {
-                if let Ok(mins) = stripped.parse::<i64>() {
-                    return now - Duration::minutes(mins);
-                }
+            if let Some(stripped) = spec.strip_suffix('m')
+                && let Ok(mins) = stripped.parse::<i64>()
+            {
+                return now - Duration::minutes(mins);
             }
-            if let Some(stripped) = spec.strip_suffix('w') {
-                if let Ok(weeks) = stripped.parse::<i64>() {
-                    return now - Duration::weeks(weeks);
-                }
+            if let Some(stripped) = spec.strip_suffix('w')
+                && let Ok(weeks) = stripped.parse::<i64>()
+            {
+                return now - Duration::weeks(weeks);
             }
 
             // Default to 1 day ago

src/commands/mod.rs

@@ -596,8 +596,8 @@ async fn cheatsheet(_ctx: &Context, _role: Option<&str>) -> Result<()> {
     Ok(())
 }
 
-fn print_completions<G: clap_complete::Generator>(gen: G, cmd: &mut clap::Command) {
-    clap_complete::generate(gen, cmd, cmd.get_name().to_string(), &mut std::io::stdout());
+fn print_completions<G: clap_complete::Generator>(generator: G, cmd: &mut clap::Command) {
+    clap_complete::generate(generator, cmd, cmd.get_name().to_string(), &mut std::io::stdout());
 }
 
 async fn completion(_ctx: &Context, shell: &crate::cli::Shell) -> Result<()> {

src/commands/tokens.rs

@@ -78,25 +78,24 @@ pub async fn list(ctx: &Context) -> Result<()> {
     }
 
     // Also check "default" if not in profiles
-    if !ctx.config.profiles.contains_key("default") {
-        if let Ok(Some(creds)) = store.load("default") {
-            let status = if creds.is_expired() {
-                "expired".to_string()
-            } else if creds.expires_soon() {
-                "expires soon".to_string()
-            } else {
-                "valid".to_string()
-            };
+    if !ctx.config.profiles.contains_key("default")
+        && let Ok(Some(creds)) = store.load("default")
+    {
+        let status = if creds.is_expired() {
+            "expired".to_string()
+        } else if creds.expires_soon() {
+            "expires soon".to_string()
+        } else {
+            "valid".to_string()
+        };
 
-            let expires = creds.expires_at.map_or_else(
-                || "unknown".to_string(),
-                |dt| dt.format("%Y-%m-%d %H:%M").to_string(),
-            );
+        let expires = creds
+            .expires_at
+            .map_or_else(|| "unknown".to_string(), |dt| dt.format("%Y-%m-%d %H:%M").to_string());
 
-            let can_refresh = if creds.can_refresh() { "yes" } else { "no" }.to_string();
+        let can_refresh = if creds.can_refresh() { "yes" } else { "no" }.to_string();
 
-            rows.push(TokenRow { profile: "default".to_string(), status, expires, can_refresh });
-        }
+        rows.push(TokenRow { profile: "default".to_string(), status, expires, can_refresh });
     }
 
     if rows.is_empty() {
@@ -223,10 +222,10 @@ pub async fn inspect(ctx: &Context, token: Option<&str>, verify: bool) -> Result
             }
 
             // Show issued at
-            if let Some(iat) = payload.get("iat").and_then(serde_json::Value::as_i64) {
-                if let Some(dt) = chrono::DateTime::from_timestamp(iat, 0) {
-                    println!("Issued: {}", dt.format("%Y-%m-%d %H:%M:%S UTC"));
-                }
+            if let Some(iat) = payload.get("iat").and_then(serde_json::Value::as_i64)
+                && let Some(dt) = chrono::DateTime::from_timestamp(iat, 0)
+            {
+                println!("Issued: {}", dt.format("%Y-%m-%d %H:%M:%S UTC"));
             }
         },
         Err(e) => {