style: apply cargo fmt to codebase

Author: zfarrell

src/auth.rs

@@ -31,33 +31,32 @@ pub fn check_status(profile_config: &config::ProfileConfig) -> AuthStatus {
     // 2. on-disk sandbox session (sandbox set <id>)
     // 3. user-scoped CLI session / api_key fallback
     let api_url = profile_config.api_url.to_string();
-    let access_token = if let Some((sandbox_jwt, _)) =
-        crate::sandbox_session::sandbox_token_in_use()
-    {
-        sandbox_jwt
-    } else if crate::sandbox_session::load().is_some() {
-        match crate::sandbox_session::ensure_access_token(&api_url) {
-            Some(t) => t,
-            None => return AuthStatus::Invalid(401),
-        }
-    } else {
-        let api_key_fallback = profile_config
-            .api_key
-            .as_deref()
-            .filter(|k| !k.is_empty() && *k != "PLACEHOLDER");
-
-        // PKCE-origin sessions don't write an api_key, so absence of a key
-        // alone isn't "not configured" — only true if there's also no
-        // cached JWT session to validate.
-        if api_key_fallback.is_none() && crate::jwt::load_session().is_none() {
-            return AuthStatus::NotConfigured;
-        }
+    let access_token =
+        if let Some((sandbox_jwt, _)) = crate::sandbox_session::sandbox_token_in_use() {
+            sandbox_jwt
+        } else if crate::sandbox_session::load().is_some() {
+            match crate::sandbox_session::ensure_access_token(&api_url) {
+                Some(t) => t,
+                None => return AuthStatus::Invalid(401),
+            }
+        } else {
+            let api_key_fallback = profile_config
+                .api_key
+                .as_deref()
+                .filter(|k| !k.is_empty() && *k != "PLACEHOLDER");
 
-        match crate::jwt::ensure_access_token(profile_config, api_key_fallback) {
-            Ok(t) => t,
-            Err(_) => return AuthStatus::Invalid(401),
-        }
-    };
+            // PKCE-origin sessions don't write an api_key, so absence of a key
+            // alone isn't "not configured" — only true if there's also no
+            // cached JWT session to validate.
+            if api_key_fallback.is_none() && crate::jwt::load_session().is_none() {
+                return AuthStatus::NotConfigured;
+            }
+
+            match crate::jwt::ensure_access_token(profile_config, api_key_fallback) {
+                Ok(t) => t,
+                Err(_) => return AuthStatus::Invalid(401),
+            }
+        };
 
     let url = format!("{}/workspaces", profile_config.api_url);
     let client = reqwest::blocking::Client::new();
@@ -120,8 +119,9 @@ pub fn status(profile: &str) {
                 .api_key
                 .as_deref()
                 .map(crate::util::mask_credential),
-            ApiKeySource::Config => crate::jwt::load_session()
-                .map(|s| crate::util::mask_credential(&s.refresh_token)),
+            ApiKeySource::Config => {
+                crate::jwt::load_session().map(|s| crate::util::mask_credential(&s.refresh_token))
+            }
         };
         (label.to_string(), tail)
     };
@@ -142,8 +142,20 @@ pub fn status(profile: &str) {
             );
             match profile_config.workspaces.first() {
                 Some(w) => {
-                    print_row("Workspace", &format!("{} {}", w.name.as_str().cyan(), format!("({})", w.public_id).dark_grey()));
-                    print_row("", &"use 'hotdata workspaces set' to switch workspaces".dark_grey().to_string());
+                    print_row(
+                        "Workspace",
+                        &format!(
+                            "{} {}",
+                            w.name.as_str().cyan(),
+                            format!("({})", w.public_id).dark_grey()
+                        ),
+                    );
+                    print_row(
+                        "",
+                        &"use 'hotdata workspaces set' to switch workspaces"
+                            .dark_grey()
+                            .to_string(),
+                    );
                 }
                 None => print_row("Current Workspace", &"None".dark_grey().to_string()),
             }
@@ -163,10 +175,15 @@ pub fn status(profile: &str) {
 }
 
 #[derive(Deserialize)]
-struct WsListResponse { workspaces: Vec<WsItem> }
+struct WsListResponse {
+    workspaces: Vec<WsItem>,
+}
 
 #[derive(Deserialize)]
-struct WsItem { public_id: String, name: String }
+struct WsItem {
+    public_id: String,
+    name: String,
+}
 
 /// Wait for the browser callback, verify state, and extract the authorization code.
 ///
@@ -179,12 +196,16 @@ fn receive_callback(
     success_title: &str,
     success_body: &str,
 ) -> Result<String, String> {
-    let request = server.recv().map_err(|e| format!("failed to receive callback: {e}"))?;
+    let request = server
+        .recv()
+        .map_err(|e| format!("failed to receive callback: {e}"))?;
     let raw_url = request.url().to_string();
     let params = parse_query_params(&raw_url);
 
     if params.get("state").map(String::as_str) != Some(expected_state) {
-        let _ = request.respond(tiny_http::Response::from_string("Login failed: state mismatch"));
+        let _ = request.respond(tiny_http::Response::from_string(
+            "Login failed: state mismatch",
+        ));
         return Err("state mismatch — possible CSRF attack".into());
     }
 
@@ -338,11 +359,17 @@ fn run_browser_auth(
                 Some(w) => {
                     print_row(
                         "Workspace",
-                        &format!("{} {}", w.name.as_str().cyan(), format!("({})", w.public_id).dark_grey()),
+                        &format!(
+                            "{} {}",
+                            w.name.as_str().cyan(),
+                            format!("({})", w.public_id).dark_grey()
+                        ),
                     );
                     print_row(
                         "",
-                        &"use 'hotdata workspaces set' to switch workspaces".dark_grey().to_string(),
+                        &"use 'hotdata workspaces set' to switch workspaces"
+                            .dark_grey()
+                            .to_string(),
                     );
                 }
                 None => print_row("Workspace", &"None".dark_grey().to_string()),
@@ -619,10 +646,7 @@ mod tests {
         let (_tmp, _guard) = with_temp_config_dir();
         save_test_session("revoked-jwt");
         let mut server = mockito::Server::new();
-        let mock = server
-            .mock("GET", "/workspaces")
-            .with_status(401)
-            .create();
+        let mock = server.mock("GET", "/workspaces").with_status(401).create();
 
         let profile = mock_profile(&server.url(), None);
         assert_eq!(check_status(&profile), AuthStatus::Invalid(401));
@@ -634,10 +658,7 @@ mod tests {
         let (_tmp, _guard) = with_temp_config_dir();
         save_test_session("jwt");
         let mut server = mockito::Server::new();
-        let mock = server
-            .mock("GET", "/workspaces")
-            .with_status(403)
-            .create();
+        let mock = server.mock("GET", "/workspaces").with_status(403).create();
 
         let profile = mock_profile(&server.url(), None);
         assert_eq!(check_status(&profile), AuthStatus::Invalid(403));
@@ -651,10 +672,7 @@ mod tests {
         // the user they need to re-auth.
         let (_tmp, _guard) = with_temp_config_dir();
         let mut server = mockito::Server::new();
-        let mock = server
-            .mock("POST", "/o/token/")
-            .with_status(401)
-            .create();
+        let mock = server.mock("POST", "/o/token/").with_status(401).create();
 
         let profile = mock_profile(&server.url(), Some("hd_revoked"));
         assert_eq!(check_status(&profile), AuthStatus::Invalid(401));
@@ -703,10 +721,7 @@ mod tests {
         let (_tmp, _guard) = with_temp_config_dir();
         save_test_session("expired-jwt");
         let mut server = mockito::Server::new();
-        let mock = server
-            .mock("GET", "/workspaces")
-            .with_status(401)
-            .create();
+        let mock = server.mock("GET", "/workspaces").with_status(401).create();
 
         let profile = mock_profile(&server.url(), None);
         assert!(!is_already_signed_in(&profile));

src/command.rs

@@ -469,7 +469,11 @@ pub enum DatasetsCommands {
         description: Option<String>,
 
         /// SQL query to create the dataset from
-        #[arg(long, conflicts_with = "query_id", required_unless_present = "query_id")]
+        #[arg(
+            long,
+            conflicts_with = "query_id",
+            required_unless_present = "query_id"
+        )]
         sql: Option<String>,
 
         /// Saved query ID to create the dataset from

src/config.rs

@@ -127,8 +127,8 @@ pub fn clear_workspaces(profile: &str) -> Result<(), String> {
         return Ok(());
     }
 
-    let content = fs::read_to_string(&config_path)
-        .map_err(|e| format!("error reading config file: {e}"))?;
+    let content =
+        fs::read_to_string(&config_path).map_err(|e| format!("error reading config file: {e}"))?;
     let mut config_file: ConfigFile =
         serde_yaml::from_str(&content).map_err(|e| format!("error parsing config file: {e}"))?;
 
@@ -174,11 +174,15 @@ pub fn save_default_workspace(profile: &str, workspace: WorkspaceEntry) -> Resul
             .map_err(|e| format!("error reading config file: {e}"))?;
         serde_yaml::from_str(&content).map_err(|e| format!("error parsing config file: {e}"))?
     } else {
-        ConfigFile { profiles: HashMap::new() }
+        ConfigFile {
+            profiles: HashMap::new(),
+        }
     };
 
     let entry = config_file.profiles.entry(profile.to_string()).or_default();
-    entry.workspaces.retain(|w| w.public_id != workspace.public_id);
+    entry
+        .workspaces
+        .retain(|w| w.public_id != workspace.public_id);
     entry.workspaces.insert(0, workspace);
 
     let content = serde_yaml::to_string(&config_file)
@@ -194,7 +198,9 @@ pub fn save_sandbox(profile: &str, sandbox_id: &str) -> Result<(), String> {
             .map_err(|e| format!("error reading config file: {e}"))?;
         serde_yaml::from_str(&content).map_err(|e| format!("error parsing config file: {e}"))?
     } else {
-        ConfigFile { profiles: HashMap::new() }
+        ConfigFile {
+            profiles: HashMap::new(),
+        }
     };
 
     config_file
@@ -215,8 +221,8 @@ pub fn clear_sandbox(profile: &str) -> Result<(), String> {
         return Ok(());
     }
 
-    let content = fs::read_to_string(&config_path)
-        .map_err(|e| format!("error reading config file: {e}"))?;
+    let content =
+        fs::read_to_string(&config_path).map_err(|e| format!("error reading config file: {e}"))?;
     let mut config_file: ConfigFile =
         serde_yaml::from_str(&content).map_err(|e| format!("error parsing config file: {e}"))?;
 
@@ -229,15 +235,21 @@ pub fn clear_sandbox(profile: &str) -> Result<(), String> {
     write_config(&config_path, &content)
 }
 
-pub fn save_current_database(profile: &str, workspace_id: &str, database_id: &str) -> Result<(), String> {
+pub fn save_current_database(
+    profile: &str,
+    workspace_id: &str,
+    database_id: &str,
+) -> Result<(), String> {
     let config_path = config_path()?;
 
     let mut config_file: ConfigFile = if config_path.exists() {
         let content = fs::read_to_string(&config_path)
             .map_err(|e| format!("error reading config file: {e}"))?;
         serde_yaml::from_str(&content).map_err(|e| format!("error parsing config file: {e}"))?
     } else {
-        ConfigFile { profiles: HashMap::new() }
+        ConfigFile {
+            profiles: HashMap::new(),
+        }
     };
 
     config_file
@@ -259,7 +271,12 @@ pub fn load_current_database(profile: &str, workspace_id: &str) -> Option<String
     }
     let content = fs::read_to_string(&config_path).ok()?;
     let config_file: ConfigFile = serde_yaml::from_str(&content).ok()?;
-    config_file.profiles.get(profile)?.current_databases.get(workspace_id).cloned()
+    config_file
+        .profiles
+        .get(profile)?
+        .current_databases
+        .get(workspace_id)
+        .cloned()
 }
 
 pub fn clear_current_database(profile: &str, workspace_id: &str) -> Result<(), String> {
@@ -269,8 +286,8 @@ pub fn clear_current_database(profile: &str, workspace_id: &str) -> Result<(), S
         return Ok(());
     }
 
-    let content = fs::read_to_string(&config_path)
-        .map_err(|e| format!("error reading config file: {e}"))?;
+    let content =
+        fs::read_to_string(&config_path).map_err(|e| format!("error reading config file: {e}"))?;
     let mut config_file: ConfigFile =
         serde_yaml::from_str(&content).map_err(|e| format!("error parsing config file: {e}"))?;
 
@@ -283,7 +300,10 @@ pub fn clear_current_database(profile: &str, workspace_id: &str) -> Result<(), S
     write_config(&config_path, &content)
 }
 
-pub fn resolve_workspace_id(provided: Option<String>, profile_config: &ProfileConfig) -> Result<String, String> {
+pub fn resolve_workspace_id(
+    provided: Option<String>,
+    profile_config: &ProfileConfig,
+) -> Result<String, String> {
     if let Some(id) = provided {
         return Ok(id);
     }
@@ -306,14 +326,20 @@ pub fn load(profile: &str) -> Result<ProfileConfig, String> {
     let config_file = config_path()?;
 
     let mut profile_config = if config_file.exists() {
-        let content =
-            fs::read_to_string(&config_file).map_err(|e| format!("error reading config file: {e}"))?;
+        let content = fs::read_to_string(&config_file)
+            .map_err(|e| format!("error reading config file: {e}"))?;
         let config_file: ConfigFile = serde_yaml::from_str(&content).unwrap_or_else(|_| {
             eprintln!("{}", "error parsing config file.".red());
-            eprintln!("Run 'hotdata auth login' (or 'hotdata auth') to generate a new config file.");
+            eprintln!(
+                "Run 'hotdata auth login' (or 'hotdata auth') to generate a new config file."
+            );
             std::process::exit(1);
         });
-        config_file.profiles.get(profile).cloned().unwrap_or_default()
+        config_file
+            .profiles
+            .get(profile)
+            .cloned()
+            .unwrap_or_default()
     } else {
         ProfileConfig::default()
     };
@@ -364,11 +390,14 @@ pub mod test_helpers {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use super::test_helpers::with_temp_config_dir;
+    use super::*;
 
     fn ws(id: &str, name: &str) -> WorkspaceEntry {
-        WorkspaceEntry { public_id: id.into(), name: name.into() }
+        WorkspaceEntry {
+            public_id: id.into(),
+            name: name.into(),
+        }
     }
 
     #[test]
@@ -490,7 +519,10 @@ mod tests {
     #[test]
     fn resolve_workspace_id_prefers_provided() {
         let profile = ProfileConfig {
-            workspaces: vec![WorkspaceEntry { public_id: "ws-1".into(), name: "WS".into() }],
+            workspaces: vec![WorkspaceEntry {
+                public_id: "ws-1".into(),
+                name: "WS".into(),
+            }],
             ..Default::default()
         };
         let result = resolve_workspace_id(Some("explicit-id".into()), &profile).unwrap();
@@ -500,7 +532,10 @@ mod tests {
     #[test]
     fn resolve_workspace_id_falls_back_to_first() {
         let profile = ProfileConfig {
-            workspaces: vec![WorkspaceEntry { public_id: "ws-1".into(), name: "WS".into() }],
+            workspaces: vec![WorkspaceEntry {
+                public_id: "ws-1".into(),
+                name: "WS".into(),
+            }],
             ..Default::default()
         };
         let result = resolve_workspace_id(None, &profile).unwrap();