grenade/cull-gmail
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🔧 fix: Resolve clippy warnings and formatting issues

Browse Source 
- Remove unnecessary borrowing where values can be used directly
- Use variables directly in format strings for better readability
- Apply consistent code formatting per rustfmt standards
- All clippy warnings resolved with -D warnings flag
- Code now follows Rust idioms and best practices
This commit is contained in:
Jeremiah Russell
2025-10-21 07:41:31 +01:00
committed by Jeremiah Russell
parent 2bee42d7ba
commit 171f441f1d
2 changed files with 145 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/cli/main.rs
View File

@@ -511,15 +511,18 @@ async fn run_rules(client: &mut GmailClient, rules: Rules, execute: bool) -> Res
/// - CI/CD pipelines with stored token secrets /// - CI/CD pipelines with stored token secrets
/// - Ephemeral compute environments requiring periodic Gmail access /// - Ephemeral compute environments requiring periodic Gmail access
fn restore_tokens_if_available(config: &Config, client_config: &ClientConfig) -> Result<()> { fn restore_tokens_if_available(config: &Config, client_config: &ClientConfig) -> Result<()> {
let token_env_var = config.get_string("token_cache_env") let token_env_var = config
.get_string("token_cache_env")
.unwrap_or_else(|_| "CULL_GMAIL_TOKEN_CACHE".to_string()); .unwrap_or_else(|_| "CULL_GMAIL_TOKEN_CACHE".to_string());
if let Ok(token_data) = env::var(&token_env_var) { if let Ok(token_data) = env::var(&token_env_var) {
log::info!("Found {} environment variable, restoring tokens", token_env_var); log::info!("Found {token_env_var} environment variable, restoring tokens");
restore_tokens_from_string(&token_data, client_config.persist_path())?; restore_tokens_from_string(&token_data, client_config.persist_path())?;
log::info!("Tokens successfully restored from environment variable"); log::info!("Tokens successfully restored from environment variable");
} else { } else {
log::debug!("No {} environment variable found, proceeding with normal token flow", token_env_var); log::debug!(
"No {token_env_var} environment variable found, proceeding with normal token flow"
);
} }
Ok(()) Ok(())

130
src/cli/token_cli.rs
View File

@@ -57,12 +57,12 @@
//! - Token metadata and expiration //! - Token metadata and expiration
//! - Encoded as base64 for environment variable compatibility //! - Encoded as base64 for environment variable compatibility
use crate::{ClientConfig, Result};
use base64::{Engine as _, engine::general_purpose::STANDARD as Base64Engine};
use clap::Subcommand;
use cull_gmail::Error;
use std::fs; use std::fs;
use std::path::Path; use std::path::Path;
use clap::Subcommand;
use base64::{Engine as _, engine::general_purpose::STANDARD as Base64Engine};
use crate::{Result, ClientConfig};
use cull_gmail::Error;
/// Token management operations for ephemeral environments. /// Token management operations for ephemeral environments.
/// ///
@@ -213,12 +213,13 @@ async fn export_tokens(config: &ClientConfig) -> Result<()> {
if token_path.is_file() { if token_path.is_file() {
// OAuth2 token is stored as a single file // OAuth2 token is stored as a single file
let filename = token_path.file_name() let filename = token_path
.file_name()
.and_then(|n| n.to_str()) .and_then(|n| n.to_str())
.ok_or_else(|| Error::FileIo("Invalid token filename".to_string()))?; .ok_or_else(|| Error::FileIo("Invalid token filename".to_string()))?;
let content = fs::read_to_string(&token_path) let content = fs::read_to_string(token_path)
.map_err(|e| Error::FileIo(format!("Failed to read token file: {}", e)))?; .map_err(|e| Error::FileIo(format!("Failed to read token file: {e}")))?;
token_data.insert(filename.to_string(), content); token_data.insert(filename.to_string(), content);
} else if token_path.is_dir() { } else if token_path.is_dir() {
@@ -228,12 +229,14 @@ async fn export_tokens(config: &ClientConfig) -> Result<()> {
let path = entry.path(); let path = entry.path();
if path.is_file() { if path.is_file() {
let filename = path.file_name() let filename = path
.file_name()
.and_then(|n| n.to_str()) .and_then(|n| n.to_str())
.ok_or_else(|| Error::FileIo("Invalid filename in token cache".to_string()))?; .ok_or_else(|| Error::FileIo("Invalid filename in token cache".to_string()))?;
let content = fs::read_to_string(&path) let content = fs::read_to_string(&path).map_err(|e| {
.map_err(|e| Error::FileIo(format!("Failed to read token file {}: {}", filename, e)))?; Error::FileIo(format!("Failed to read token file {filename}: {e}"))
})?;
token_data.insert(filename.to_string(), content); token_data.insert(filename.to_string(), content);
} }
@@ -246,29 +249,33 @@ async fn export_tokens(config: &ClientConfig) -> Result<()> {
} }
if token_data.is_empty() { if token_data.is_empty() {
return Err(Error::TokenNotFound("No token data found in cache".to_string())); return Err(Error::TokenNotFound(
"No token data found in cache".to_string(),
));
} }
// Serialize to JSON // Serialize to JSON
let json_data = serde_json::to_string(&token_data) let json_data = serde_json::to_string(&token_data)
.map_err(|e| Error::SerializationError(format!("Failed to serialize token data: {}", e)))?; .map_err(|e| Error::SerializationError(format!("Failed to serialize token data: {e}")))?;
// Compress using flate2 // Compress using flate2
use flate2::write::GzEncoder;
use flate2::Compression; use flate2::Compression;
use flate2::write::GzEncoder;
use std::io::Write; use std::io::Write;
let mut encoder = GzEncoder::new(Vec::new(), Compression::default()); let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
encoder.write_all(json_data.as_bytes()) encoder
.map_err(|e| Error::SerializationError(format!("Failed to compress token data: {}", e)))?; .write_all(json_data.as_bytes())
let compressed_data = encoder.finish() .map_err(|e| Error::SerializationError(format!("Failed to compress token data: {e}")))?;
.map_err(|e| Error::SerializationError(format!("Failed to finalize compression: {}", e)))?; let compressed_data = encoder
.finish()
.map_err(|e| Error::SerializationError(format!("Failed to finalize compression: {e}")))?;
// Encode to base64 // Encode to base64
let encoded = Base64Engine.encode(&compressed_data); let encoded = Base64Engine.encode(&compressed_data);
// Output to stdout // Output to stdout
println!("{}", encoded); println!("{encoded}");
Ok(()) Ok(())
} }
@@ -302,10 +309,9 @@ async fn export_tokens(config: &ClientConfig) -> Result<()> {
/// - Decoding/decompression errors for malformed token data /// - Decoding/decompression errors for malformed token data
/// - I/O errors creating token files /// - I/O errors creating token files
pub async fn import_tokens(config: &ClientConfig) -> Result<()> { pub async fn import_tokens(config: &ClientConfig) -> Result<()> {
let token_env = std::env::var("CULL_GMAIL_TOKEN_CACHE") let token_env = std::env::var("CULL_GMAIL_TOKEN_CACHE").map_err(|_| {
.map_err(|_| Error::TokenNotFound( Error::TokenNotFound("CULL_GMAIL_TOKEN_CACHE environment variable not set".to_string())
"CULL_GMAIL_TOKEN_CACHE environment variable not set".to_string() })?;
))?;
restore_tokens_from_string(&token_env, config.persist_path())?; restore_tokens_from_string(&token_env, config.persist_path())?;
@@ -332,8 +338,9 @@ pub async fn import_tokens(config: &ClientConfig) -> Result<()> {
/// Created token files are set to 600 (owner read/write only) for security. /// Created token files are set to 600 (owner read/write only) for security.
pub fn restore_tokens_from_string(token_string: &str, persist_path: &str) -> Result<()> { pub fn restore_tokens_from_string(token_string: &str, persist_path: &str) -> Result<()> {
// Decode from base64 // Decode from base64
let compressed_data = Base64Engine.decode(token_string.trim()) let compressed_data = Base64Engine.decode(token_string.trim()).map_err(|e| {
.map_err(|e| Error::SerializationError(format!("Failed to decode base64 token data: {}", e)))?; Error::SerializationError(format!("Failed to decode base64 token data: {e}"))
})?;
// Decompress // Decompress
use flate2::read::GzDecoder; use flate2::read::GzDecoder;
@@ -341,76 +348,90 @@ pub fn restore_tokens_from_string(token_string: &str, persist_path: &str) -> Res
let mut decoder = GzDecoder::new(compressed_data.as_slice()); let mut decoder = GzDecoder::new(compressed_data.as_slice());
let mut json_data = String::new(); let mut json_data = String::new();
decoder.read_to_string(&mut json_data) decoder
.map_err(|e| Error::SerializationError(format!("Failed to decompress token data: {}", e)))?; .read_to_string(&mut json_data)
.map_err(|e| Error::SerializationError(format!("Failed to decompress token data: {e}")))?;
// Parse JSON // Parse JSON
let token_files: std::collections::HashMap<String, String> = serde_json::from_str(&json_data) let token_files: std::collections::HashMap<String, String> =
.map_err(|e| Error::SerializationError(format!("Failed to parse token JSON: {}", e)))?; serde_json::from_str(&json_data)
.map_err(|e| Error::SerializationError(format!("Failed to parse token JSON: {e}")))?;
let token_path = Path::new(persist_path); let token_path = Path::new(persist_path);
// Count files for logging // Count files for logging
let file_count = token_files.len(); let file_count = token_files.len();
if file_count == 1 && token_files.keys().next().map(|k| k.as_str()) == token_path.file_name().and_then(|n| n.to_str()) { if file_count == 1
&& token_files.keys().next().map(|k| k.as_str())
== token_path.file_name().and_then(|n| n.to_str())
{
// Single file case - write directly to the persist path // Single file case - write directly to the persist path
let content = token_files.into_values().next().unwrap(); let content = token_files.into_values().next().unwrap();
// Create parent directory if needed // Create parent directory if needed
if let Some(parent) = token_path.parent() { if let Some(parent) = token_path.parent() {
fs::create_dir_all(parent) fs::create_dir_all(parent).map_err(|e| {
.map_err(|e| Error::FileIo(format!("Failed to create token directory {}: {}", parent.display(), e)))?; Error::FileIo(format!(
"Failed to create token directory {}: {}",
parent.display(),
e
))
})?;
} }
fs::write(&token_path, &content) fs::write(token_path, &content)
.map_err(|e| Error::FileIo(format!("Failed to write token file: {}", e)))?; .map_err(|e| Error::FileIo(format!("Failed to write token file: {e}")))?;
// Set secure permissions (600 - owner read/write only) // Set secure permissions (600 - owner read/write only)
#[cfg(unix)] #[cfg(unix)]
{ {
use std::os::unix::fs::PermissionsExt; use std::os::unix::fs::PermissionsExt;
let mut perms = fs::metadata(&token_path) let mut perms = fs::metadata(token_path)
.map_err(|e| Error::FileIo(format!("Failed to get file metadata: {}", e)))? .map_err(|e| Error::FileIo(format!("Failed to get file metadata: {e}")))?
.permissions(); .permissions();
perms.set_mode(0o600); perms.set_mode(0o600);
fs::set_permissions(&token_path, perms) fs::set_permissions(token_path, perms)
.map_err(|e| Error::FileIo(format!("Failed to set file permissions: {}", e)))?; .map_err(|e| Error::FileIo(format!("Failed to set file permissions: {e}")))?;
} }
} else { } else {
// Multiple files case - create directory structure // Multiple files case - create directory structure
fs::create_dir_all(token_path) fs::create_dir_all(token_path).map_err(|e| {
.map_err(|e| Error::FileIo(format!("Failed to create token directory {}: {}", persist_path, e)))?; Error::FileIo(format!(
"Failed to create token directory {persist_path}: {e}"
))
})?;
// Write token files // Write token files
for (filename, content) in token_files { for (filename, content) in token_files {
let file_path = token_path.join(&filename); let file_path = token_path.join(&filename);
fs::write(&file_path, &content) fs::write(&file_path, &content).map_err(|e| {
.map_err(|e| Error::FileIo(format!("Failed to write token file {}: {}", filename, e)))?; Error::FileIo(format!("Failed to write token file {filename}: {e}"))
})?;
// Set secure permissions (600 - owner read/write only) // Set secure permissions (600 - owner read/write only)
#[cfg(unix)] #[cfg(unix)]
{ {
use std::os::unix::fs::PermissionsExt; use std::os::unix::fs::PermissionsExt;
let mut perms = fs::metadata(&file_path) let mut perms = fs::metadata(&file_path)
.map_err(|e| Error::FileIo(format!("Failed to get file metadata: {}", e)))? .map_err(|e| Error::FileIo(format!("Failed to get file metadata: {e}")))?
.permissions(); .permissions();
perms.set_mode(0o600); perms.set_mode(0o600);
fs::set_permissions(&file_path, perms) fs::set_permissions(&file_path, perms)
.map_err(|e| Error::FileIo(format!("Failed to set file permissions: {}", e)))?; .map_err(|e| Error::FileIo(format!("Failed to set file permissions: {e}")))?;
} }
} }
} }
log::info!("Restored {} token files to {}", file_count, persist_path); log::info!("Restored {file_count} token files to {persist_path}");
Ok(()) Ok(())
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use tempfile::TempDir;
use std::collections::HashMap; use std::collections::HashMap;
use tempfile::TempDir;
#[test] #[test]
fn test_token_export_import_cycle() { fn test_token_export_import_cycle() {
@@ -421,14 +442,17 @@ mod tests {
// Create mock token files // Create mock token files
let mut test_files = HashMap::new(); let mut test_files = HashMap::new();
test_files.insert("tokencache.json".to_string(), test_files.insert(
r#"{"access_token":"test_access","refresh_token":"test_refresh"}"#.to_string()); "tokencache.json".to_string(),
test_files.insert("metadata.json".to_string(), r#"{"access_token":"test_access","refresh_token":"test_refresh"}"#.to_string(),
r#"{"created":"2023-01-01","expires":"2023-12-31"}"#.to_string()); );
test_files.insert(
"metadata.json".to_string(),
r#"{"created":"2023-01-01","expires":"2023-12-31"}"#.to_string(),
);
for (filename, content) in &test_files { for (filename, content) in &test_files {
fs::write(token_dir.join(filename), content) fs::write(token_dir.join(filename), content).expect("Failed to write test token file");
.expect("Failed to write test token file");
} }
// Test export // Test export
@@ -458,8 +482,8 @@ mod tests {
let json_str = serde_json::to_string(&token_data).unwrap(); let json_str = serde_json::to_string(&token_data).unwrap();
// Compress // Compress
use flate2::write::GzEncoder;
use flate2::Compression; use flate2::Compression;
use flate2::write::GzEncoder;
use std::io::Write; use std::io::Write;
let mut encoder = GzEncoder::new(Vec::new(), Compression::default()); let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
@@ -471,7 +495,7 @@ mod tests {
// Test restore // Test restore
let result = restore_tokens_from_string(&encoded, &persist_path); let result = restore_tokens_from_string(&encoded, &persist_path);
assert!(result.is_ok(), "Restore should succeed: {:?}", result); assert!(result.is_ok(), "Restore should succeed: {result:?}");
// Verify file was created // Verify file was created
let restored_path = Path::new(&persist_path).join("test.json"); let restored_path = Path::new(&persist_path).join("test.json");