Fix CI: reformat with stable rustfmt, remove nightly-only rustfmt options

ilyazub · ilyazub · commit 1b5772122ed7 · 2026-03-25T22:02:56.000+01:00
The rustfmt.toml contained nightly-only options (imports_granularity,
group_imports) that were silently ignored by stable Rust. Code had been
formatted using nightly rustfmt, so 'cargo fmt --check' on stable (as
used in CI) failed with exit code 1.

Remove the nightly-only options and reformat all files with stable rustfmt
so the CI formatting check passes.
diff --git a/rustfmt.toml b/rustfmt.toml
@@ -1,3 +1 @@
-# Group imports: std, then third-party, then crate-local
-group_imports = "StdExternalCrate"
-imports_granularity = "Module"
+
diff --git a/src/commands/account.rs b/src/commands/account.rs
@@ -6,9 +6,6 @@ use std::collections::HashMap;
 /// Fetch and return the account information for the given API key.
 pub async fn run(api_key: &str) -> Result<Value, CliError> {
     let client = make_client(api_key)?;
-    let result = client
-        .account(HashMap::new())
-        .await
-        .map_err(network_err)?;
+    let result = client.account(HashMap::new()).await.map_err(network_err)?;
     check_api_error(result)
 }
diff --git a/src/commands/archive.rs b/src/commands/archive.rs
@@ -5,9 +5,6 @@ use serde_json::Value;
 /// Retrieve a previously cached search result from the SerpApi archive by its ID.
 pub async fn run(id: &str, api_key: &str) -> Result<Value, CliError> {
     let client = make_client(api_key)?;
-    let result = client
-        .search_archive(id)
-        .await
-        .map_err(network_err)?;
+    let result = client.search_archive(id).await.map_err(network_err)?;
     check_api_error(result)
 }
diff --git a/src/commands/locations.rs b/src/commands/locations.rs
@@ -8,9 +8,6 @@ pub async fn run(params: Vec<Param>) -> Result<Value, CliError> {
     let params_map = params::params_to_hashmap(params);
     // Locations endpoint is public – no API key needed.
     let client = make_client("")?;
-    let result = client
-        .location(params_map)
-        .await
-        .map_err(network_err)?;
+    let result = client.location(params_map).await.map_err(network_err)?;
     check_api_error(result)
 }
diff --git a/src/commands/login.rs b/src/commands/login.rs
@@ -5,10 +5,11 @@ use std::collections::HashMap;
 
 /// Prompt the user for their SerpApi API key, verify it, and persist it to the config file.
 pub async fn run() -> Result<(), CliError> {
-    let api_key = rpassword::prompt_password("Enter your SerpApi API key: ")
-        .map_err(|e| CliError::UsageError {
+    let api_key = rpassword::prompt_password("Enter your SerpApi API key: ").map_err(|e| {
+        CliError::UsageError {
             message: format!("Failed to read input: {e}"),
-        })?;
+        }
+    })?;
     let api_key = api_key.trim();
 
     if api_key.is_empty() {
@@ -18,10 +19,7 @@ pub async fn run() -> Result<(), CliError> {
     }
 
     let client = make_client(api_key)?;
-    let result = client
-        .account(HashMap::new())
-        .await
-        .map_err(network_err)?;
+    let result = client.account(HashMap::new()).await.map_err(network_err)?;
 
     let result = check_api_error(result)?;
     let email = result
diff --git a/src/commands/mod.rs b/src/commands/mod.rs
@@ -4,18 +4,20 @@ use std::collections::HashMap;
 
 use crate::error::CliError;
 
-pub mod search;
 pub mod account;
-pub mod locations;
 pub mod archive;
+pub mod locations;
 pub mod login;
+pub mod search;
 
 /// The query-parameter name used to pass the SerpApi key to every request.
 pub(crate) const API_KEY_PARAM: &str = "api_key";
 
 /// Convert a `Box<dyn Error>` from the serpapi client into a [`CliError::NetworkError`].
 pub(crate) fn network_err(e: Box<dyn std::error::Error>) -> CliError {
-    CliError::NetworkError { message: e.to_string() }
+    CliError::NetworkError {
+        message: e.to_string(),
+    }
 }
 
 /// Build a `serpapi::Client` authenticated with the given API key.
diff --git a/src/commands/search.rs b/src/commands/search.rs
@@ -1,10 +1,10 @@
-use std::collections::{HashMap, HashSet};
-use std::time::Duration;
-use url::Url;
 use crate::commands::{check_api_error, make_client, network_err, API_KEY_PARAM};
 use crate::error::CliError;
 use crate::params::{self, Param};
 use serde_json::Value;
+use std::collections::{HashMap, HashSet};
+use std::time::Duration;
+use url::Url;
 
 /// Execute a SerpApi search, optionally accumulating all pages into a single result.
 pub async fn run(
@@ -19,13 +19,12 @@ pub async fn run(
 
     if !all_pages && max_pages.is_none() {
         let client = make_client(api_key)?;
-        let result = tokio::time::timeout(
-            Duration::from_secs(30),
-            client.search(params_map),
-        )
-        .await
-        .map_err(|_| CliError::NetworkError { message: "Request timed out after 30s".to_string() })?
-        .map_err(network_err)?;
+        let result = tokio::time::timeout(Duration::from_secs(30), client.search(params_map))
+            .await
+            .map_err(|_| CliError::NetworkError {
+                message: "Request timed out after 30s".to_string(),
+            })?
+            .map_err(network_err)?;
         return check_api_error(result);
     }
 
@@ -45,7 +44,9 @@ pub async fn run(
             client.search(current_params.clone()),
         )
         .await
-        .map_err(|_| CliError::NetworkError { message: "Request timed out after 30s".to_string() })?
+        .map_err(|_| CliError::NetworkError {
+            message: "Request timed out after 30s".to_string(),
+        })?
         .map_err(network_err)?;
         let page = check_api_error(result)?;
         pages_fetched += 1;
@@ -67,8 +68,12 @@ pub async fn run(
                             // are kept from the first page, as they describe the overall
                             // query rather than per-page state.
                             match acc_map.get_mut(key) {
-                                Some(Value::Array(existing)) => existing.extend(new_items.iter().cloned()),
-                                _ => { acc_map.insert(key.clone(), val.clone()); }
+                                Some(Value::Array(existing)) => {
+                                    existing.extend(new_items.iter().cloned())
+                                }
+                                _ => {
+                                    acc_map.insert(key.clone(), val.clone());
+                                }
                             }
                         }
                     }
diff --git a/src/config.rs b/src/config.rs
@@ -1,6 +1,6 @@
+use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::PathBuf;
-use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
 struct Config {
@@ -43,10 +43,9 @@ pub fn save_config(api_key: &str) -> Result<(), crate::error::CliError> {
     }
     #[cfg(not(unix))]
     {
-        std::fs::create_dir_all(&dir)
-            .map_err(|e| crate::error::CliError::UsageError {
-                message: format!("Failed to create config dir: {e}"),
-            })?;
+        std::fs::create_dir_all(&dir).map_err(|e| crate::error::CliError::UsageError {
+            message: format!("Failed to create config dir: {e}"),
+        })?;
     }
 
     let config = Config {
@@ -69,7 +68,8 @@ pub fn save_config(api_key: &str) -> Result<(), crate::error::CliError> {
             .mode(0o600)
             .open(&tmp_path)
             .map_err(|e| to_cli_err(&e))?;
-        file.write_all(content.as_bytes()).map_err(|e| to_cli_err(&e))?;
+        file.write_all(content.as_bytes())
+            .map_err(|e| to_cli_err(&e))?;
     }
     #[cfg(not(unix))]
     {
@@ -89,17 +89,15 @@ pub fn save_config(api_key: &str) -> Result<(), crate::error::CliError> {
 
 /// Resolve the API key from the already-merged clap value (flag or env var), then
 /// fall back to the saved config file. The env-var lookup is handled by clap upstream.
-pub fn resolve_api_key(
-    from_clap: Option<&str>,
-) -> Result<String, crate::error::CliError> {
+pub fn resolve_api_key(from_clap: Option<&str>) -> Result<String, crate::error::CliError> {
     if let Some(key) = from_clap {
         return Ok(key.to_string());
     }
-    
+
     if let Some(key) = load_api_key() {
         return Ok(key);
     }
-    
+
     Err(crate::error::CliError::UsageError {
         message: "No API key found. Run 'serpapi login' or set SERPAPI_KEY.".to_string(),
     })
diff --git a/src/error.rs b/src/error.rs
@@ -52,8 +52,10 @@ pub fn print_error(err: &CliError) {
 
     match serde_json::to_string_pretty(&error_json) {
         Ok(s) => eprintln!("{s}"),
-        Err(_) => eprintln!("{{\"error\":{{\"code\":\"{code}\",\"message\":\"{}\"}}}}",
-            message.replace('\\', "\\\\").replace('"', "\\\"")),
+        Err(_) => eprintln!(
+            "{{\"error\":{{\"code\":\"{code}\",\"message\":\"{}\"}}}}",
+            message.replace('\\', "\\\\").replace('"', "\\\"")
+        ),
     }
 }
 
diff --git a/src/jq.rs b/src/jq.rs
@@ -24,7 +24,10 @@ pub fn apply(expression: &str, input: Value) -> Result<Vec<Value>, Box<dyn std::
     let inputs = RcIter::new(std::iter::empty());
     let out: Vec<Value> = filter
         .run((Ctx::new(Vec::new(), &inputs), Val::from(input)))
-        .map(|v| v.map(Value::from).map_err(|e| format!("jq runtime error: {e}")))
+        .map(|v| {
+            v.map(Value::from)
+                .map_err(|e| format!("jq runtime error: {e}"))
+        })
         .collect::<Result<Vec<_>, _>>()?;
 
     Ok(out)
diff --git a/src/lib.rs b/src/lib.rs
@@ -13,6 +13,6 @@
 pub mod commands;
 pub mod config;
 pub mod error;
+pub mod jq;
 pub mod output;
 pub mod params;
-pub mod jq;
diff --git a/src/main.rs b/src/main.rs
@@ -1,5 +1,5 @@
 use clap::Parser;
-use serpapi_cli::{commands, output, error, config, params, jq};
+use serpapi_cli::{commands, config, error, jq, output, params};
 
 #[derive(Parser, Debug)]
 #[command(
@@ -65,27 +65,44 @@ async fn main() {
     let resolve_api_key = || config::resolve_api_key(cli.api_key.as_deref());
 
     let result = match cli.command {
-        Command::Search { params, all_pages, max_pages } => {
+        Command::Search {
+            params,
+            all_pages,
+            max_pages,
+        } => {
             let api_key = resolve_api_key().unwrap_or_else(|e| die(e));
-            let parsed_params = params.iter()
+            let parsed_params = params
+                .iter()
                 .map(|s| s.parse::<params::Param>())
                 .collect::<Result<Vec<_>, _>>()
-                .unwrap_or_else(|e| die(error::CliError::UsageError {
-                    message: e.to_string(),
-                }));
-            commands::search::run(parsed_params, &api_key, cli.fields.as_deref(), all_pages, max_pages).await
+                .unwrap_or_else(|e| {
+                    die(error::CliError::UsageError {
+                        message: e.to_string(),
+                    })
+                });
+            commands::search::run(
+                parsed_params,
+                &api_key,
+                cli.fields.as_deref(),
+                all_pages,
+                max_pages,
+            )
+            .await
         }
         Command::Account => {
             let api_key = resolve_api_key().unwrap_or_else(|e| die(e));
             commands::account::run(&api_key).await
         }
         Command::Locations { params } => {
-            let parsed_params = params.iter()
+            let parsed_params = params
+                .iter()
                 .map(|s| s.parse::<params::Param>())
                 .collect::<Result<Vec<_>, _>>()
-                .unwrap_or_else(|e| die(error::CliError::UsageError {
-                    message: e.to_string(),
-                }));
+                .unwrap_or_else(|e| {
+                    die(error::CliError::UsageError {
+                        message: e.to_string(),
+                    })
+                });
             commands::locations::run(parsed_params).await
         }
         Command::Archive { id } => {
@@ -103,10 +120,11 @@ async fn main() {
     match result {
         Ok(value) => {
             if let Some(expr) = cli.jq.as_deref() {
-                let results = jq::apply(expr, value)
-                    .unwrap_or_else(|e| die(error::CliError::UsageError {
+                let results = jq::apply(expr, value).unwrap_or_else(|e| {
+                    die(error::CliError::UsageError {
                         message: e.to_string(),
-                    }));
+                    })
+                });
                 for v in &results {
                     if let Err(e) = output::print_jq_value(v, &mut std::io::stdout()) {
                         die(error::CliError::ApiError {
diff --git a/src/output.rs b/src/output.rs
@@ -17,7 +17,10 @@ pub fn print_json(value: &Value, plain: bool) -> Result<(), Box<dyn std::error::
 /// Print a jq result value with raw scalar output (like gh --jq / jq -r).
 /// Strings are printed unquoted, numbers as plain text, booleans as true/false,
 /// null as empty string. Objects and arrays are JSON-encoded.
-pub fn print_jq_value(value: &Value, writer: &mut impl std::io::Write) -> Result<(), Box<dyn std::error::Error>> {
+pub fn print_jq_value(
+    value: &Value,
+    writer: &mut impl std::io::Write,
+) -> Result<(), Box<dyn std::error::Error>> {
     match value {
         Value::String(s) => writeln!(writer, "{s}")?,
         Value::Number(n) => writeln!(writer, "{n}")?,
diff --git a/src/params.rs b/src/params.rs
@@ -1,5 +1,5 @@
-use std::str::FromStr;
 use std::collections::HashMap;
+use std::str::FromStr;
 
 #[derive(Debug, Clone)]
 pub struct Param {
@@ -14,9 +14,10 @@ impl FromStr for Param {
         let mut parts = s.splitn(2, '=');
         match (parts.next(), parts.next()) {
             (Some(""), Some(_)) => Err("Empty parameter key".to_string()),
-            (Some("api_key"), Some(_)) => {
-                Err("Use --api-key or SERPAPI_KEY instead of passing api_key as a parameter".to_string())
-            }
+            (Some("api_key"), Some(_)) => Err(
+                "Use --api-key or SERPAPI_KEY instead of passing api_key as a parameter"
+                    .to_string(),
+            ),
             (Some(key), Some(value)) => Ok(Self {
                 key: key.to_string(),
                 value: value.to_string(),
@@ -30,16 +31,12 @@ impl FromStr for Param {
     }
 }
 
-
 pub fn params_to_hashmap(params: Vec<Param>) -> HashMap<String, String> {
-    params
-        .into_iter()
-        .map(|p| (p.key, p.value))
-        .collect()
+    params.into_iter().map(|p| (p.key, p.value)).collect()
 }
 
 pub fn apply_fields(params: &mut HashMap<String, String>, fields: Option<&str>) {
     if let Some(expr) = fields {
         params.insert("json_restrictor".to_string(), expr.to_string());
     }
-}
+}
diff --git a/tests/e2e.rs b/tests/e2e.rs
@@ -136,7 +136,8 @@ fn test_search_all_pages() {
         .arg("q=coffee")
         .arg("num=1")
         .arg("--all-pages")
-        .arg("--max-pages").arg("2")
+        .arg("--max-pages")
+        .arg("2")
         .assert()
         .success()
         .stdout(predicate::str::contains("organic_results"));
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
diff --git a/tests/test_url_cycle.rs b/tests/test_url_cycle.rs

Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,10 @@ pub fn print_error(err: &CliError) {`
`52`	`52`
`53`	`53`	`match serde_json::to_string_pretty(&error_json) {`
`54`	`54`	`Ok(s) => eprintln!("{s}"),`
`55`		`- Err(_) => eprintln!("{{\"error\":{{\"code\":\"{code}\",\"message\":\"{}\"}}}}",`
`56`		`- message.replace('\\', "\\\\").replace('"', "\\\"")),`
	`55`	`+ Err(_) => eprintln!(`
	`56`	`+ "{{\"error\":{{\"code\":\"{code}\",\"message\":\"{}\"}}}}",`
	`57`	`+ message.replace('\\', "\\\\").replace('"', "\\\"")`
	`58`	`+ ),`
`57`	`59`	`}`
`58`	`60`	`}`
`59`	`61`