Update after fmt.

fabiomolinar · fabiomolinar · commit 975f0f62e321 · 2025-08-27T16:57:09.000+02:00
diff --git a/README.md b/README.md
@@ -81,9 +81,9 @@ As I am starting my journey with Rust, here it goes a few reminders so I don't h
 
 Before pushing to *crates.io*, run the following:
 
-1. `cargo build`
-2. `cargo test`
-3. `cargo fmt`
+1. `cargo fmt`
+2. `cargo build`
+3. `cargo test`
 4. `cargo clippy`
 
 If all good, `cargo package` and then `cargo publish`.
diff --git a/src/git_utils.rs b/src/git_utils.rs
@@ -8,14 +8,16 @@ pub async fn clone_repository(repository: &Repository) -> Result<Git2Repository,
 
     // Remove existing folder if it exists
     if repository.path.exists() {
-        fs::remove_dir_all(&repository.path)
-            .await
-            .map_err(|e| format!("Failed to remove existing directory {:?}: {}", repository.path, e))?;
+        fs::remove_dir_all(&repository.path).await.map_err(|e| {
+            format!(
+                "Failed to remove existing directory {:?}: {}",
+                repository.path, e
+            )
+        })?;
     }
 
     tokio::task::spawn_blocking(move || {
-        Git2Repository::clone(&repo_url, &path)
-            .map_err(|e| format!("Git clone error: {}", e))
+        Git2Repository::clone(&repo_url, &path).map_err(|e| format!("Git clone error: {}", e))
     })
     .await
     .map_err(|e| format!("Blocking task join error: {}", e))?
diff --git a/src/io_utils.rs b/src/io_utils.rs
@@ -20,9 +20,16 @@ pub async fn read_ignore_patterns(ignore_file: Option<PathBuf>) -> Result<Vec<St
             let content = fs::read_to_string(&path)
                 .await
                 .map_err(|e| format!("Failed to read ignore file {:?}: {}", path, e))?;
-            return Ok(content.lines().map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect());
+            return Ok(content
+                .lines()
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+                .collect());
         } else {
-            eprintln!("Warning: Ignore file {:?} not found. Proceeding without ignore patterns.", path);
+            eprintln!(
+                "Warning: Ignore file {:?} not found. Proceeding without ignore patterns.",
+                path
+            );
         }
     }
     Ok(Vec::new())
@@ -43,37 +50,35 @@ pub async fn write_content_to_file(path: &Path, content: &str) -> Result<(), Str
 /// The aliases are from the list of languages supported by Highlight.js.
 /// Returns an empty string if no alias is found.
 pub fn get_language_alias(path: &Path) -> &'static str {
-    let extension = path.extension()
-        .and_then(|ext| ext.to_str())
-        .unwrap_or("");
+    let extension = path.extension().and_then(|ext| ext.to_str()).unwrap_or("");
 
     match extension.to_lowercase().as_str() {
-        "sh" | "bash"                => "bash",
-        "c"                          => "c",
+        "sh" | "bash" => "bash",
+        "c" => "c",
         "cc" | "cxx" | "c++" | "cpp" => "cpp",
-        "cs"                         => "csharp",
-        "css"                        => "css",
-        "go"                         => "go",
-        "html" | "htm"               => "xml",
-        "java"                       => "java",
-        "js" | "cjs" | "mjs"         => "javascript",
-        "json"                       => "json",
-        "jsx"                        => "jsx",
-        "kt" | "kts"                 => "kotlin",
-        "md" | "markdown"            => "markdown",
-        "php"                        => "php",
-        "py"                         => "python",
-        "rb"                         => "ruby",
-        "rs"                         => "rust",
-        "scss"                       => "scss",
-        "sql"                        => "sql",
-        "swift"                      => "swift",
-        "toml"                       => "toml",
-        "ts" | "cts" | "mts"         => "typescript",
-        "tsx"                        => "tsx",
-        "txt"                        => "",
-        "yaml" | "yml"               => "yaml",
-        _                            => "",
+        "cs" => "csharp",
+        "css" => "css",
+        "go" => "go",
+        "html" | "htm" => "xml",
+        "java" => "java",
+        "js" | "cjs" | "mjs" => "javascript",
+        "json" => "json",
+        "jsx" => "jsx",
+        "kt" | "kts" => "kotlin",
+        "md" | "markdown" => "markdown",
+        "php" => "php",
+        "py" => "python",
+        "rb" => "ruby",
+        "rs" => "rust",
+        "scss" => "scss",
+        "sql" => "sql",
+        "swift" => "swift",
+        "toml" => "toml",
+        "ts" | "cts" | "mts" => "typescript",
+        "tsx" => "tsx",
+        "txt" => "",
+        "yaml" | "yml" => "yaml",
+        _ => "",
     }
 }
 
@@ -111,4 +116,4 @@ mod tests {
         assert_eq!(get_language_alias(&PathBuf::from("unrecognized.xyz")), "");
         assert_eq!(get_language_alias(&PathBuf::from("no_extension")), "");
     }
-}
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,15 +1,15 @@
-pub mod repository;
-pub mod io_utils;
 pub mod git_utils;
+pub mod io_utils;
 pub mod processing;
+pub mod repository;
 
-use repository::Repository;
-use processing::process_single_repository;
+use futures::future::join_all;
 use io_utils::{ensure_directories, read_ignore_patterns};
-use tokio::fs;
+use processing::process_single_repository;
+use repository::Repository;
 use std::path::PathBuf;
-use futures::future::join_all;
 use std::sync::Arc;
+use tokio::fs;
 
 /// Processes a list of GitHub URLs concurrently, downloads and processes content,
 /// and prepares it for AI tools.
@@ -19,7 +19,10 @@ pub async fn process_github_urls(
     merge_files: bool,
     ignore_file: Option<PathBuf>,
 ) -> Result<Vec<PathBuf>, String> {
-    println!("Library received URLs: {:?}, no_headers: {}, merge_files: {}", urls, no_headers, merge_files);
+    println!(
+        "Library received URLs: {:?}, no_headers: {}, merge_files: {}",
+        urls, no_headers, merge_files
+    );
 
     // Prepare directories
     let download_dir = PathBuf::from("./temp_repos");
@@ -30,13 +33,17 @@ pub async fn process_github_urls(
     let ignore_patterns = Arc::new(read_ignore_patterns(ignore_file).await?);
 
     // Spawn processing tasks
-    let tasks: Vec<_> = urls.iter().map(|url| {
-        let repository = Repository::new(&download_dir, url);
-        let ignore_patterns = Arc::clone(&ignore_patterns);
-        tokio::spawn(async move {
-            process_single_repository(repository, no_headers, merge_files, ignore_patterns).await
+    let tasks: Vec<_> = urls
+        .iter()
+        .map(|url| {
+            let repository = Repository::new(&download_dir, url);
+            let ignore_patterns = Arc::clone(&ignore_patterns);
+            tokio::spawn(async move {
+                process_single_repository(repository, no_headers, merge_files, ignore_patterns)
+                    .await
+            })
         })
-    }).collect();
+        .collect();
 
     let results = join_all(tasks).await;
 
diff --git a/src/main.rs b/src/main.rs
@@ -1,4 +1,4 @@
-use clap::{Parser};
+use clap::Parser;
 use git2prompt::process_github_urls;
 use std::path::PathBuf;
 
@@ -21,7 +21,11 @@ struct Args {
 
     /// Path to a file containing a list of files/folders to ignore.
     /// Each line in the file should be a path or pattern to be excluded.
-    #[clap(long, value_name = "PATH TO IGNORE FILE", default_value = ".git2promptignore")]
+    #[clap(
+        long,
+        value_name = "PATH TO IGNORE FILE",
+        default_value = ".git2promptignore"
+    )]
     ignore_file: PathBuf,
 }
 
@@ -35,7 +39,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Merge into a single output file: {}", args.merge_files);
 
     // Call the library function to process the URLs, wrapping the ignore file path in Some
-    match process_github_urls(args.urls, args.no_headers, args.merge_files, Some(args.ignore_file)).await {
+    match process_github_urls(
+        args.urls,
+        args.no_headers,
+        args.merge_files,
+        Some(args.ignore_file),
+    )
+    .await
+    {
         Ok(output_paths) => {
             println!("Processing complete. Output files created:");
             for path in output_paths {
diff --git a/src/processing.rs b/src/processing.rs
@@ -1,10 +1,10 @@
-use crate::repository::Repository;
 use crate::git_utils::clone_repository;
-use crate::io_utils::{write_content_to_file, get_language_alias};
+use crate::io_utils::{get_language_alias, write_content_to_file};
+use crate::repository::Repository;
+use std::path::PathBuf;
+use std::sync::Arc;
 use tokio::fs;
 use walkdir::WalkDir;
-use std::sync::Arc;
-use std::path::PathBuf;
 
 /// Process a single repository: clone and process files
 pub async fn process_single_repository(
@@ -13,11 +13,19 @@ pub async fn process_single_repository(
     merge_files: bool,
     ignore_patterns: Arc<Vec<String>>,
 ) -> Result<Repository, String> {
-    println!("Preparing to clone {} to {:?}", repository.url, repository.path);
+    println!(
+        "Preparing to clone {} to {:?}",
+        repository.url, repository.path
+    );
     clone_repository(&repository).await?;
-    println!("Successfully cloned {} to {:?}", repository.name, repository.path);
-
-    let content = process_repository_files(&repository.path, no_headers, merge_files, &ignore_patterns).await?;
+    println!(
+        "Successfully cloned {} to {:?}",
+        repository.name, repository.path
+    );
+
+    let content =
+        process_repository_files(&repository.path, no_headers, merge_files, &ignore_patterns)
+            .await?;
     repository.content = Some(content);
 
     Ok(repository)
@@ -39,15 +47,18 @@ pub async fn process_repository_files(
             let with_headers = !no_headers;
 
             if let Ok(content) = fs::read_to_string(path).await {
-                let relative_path = path.strip_prefix(repo_path)
+                let relative_path = path
+                    .strip_prefix(repo_path)
                     .map_err(|e| format!("Failed to strip prefix: {}", e))?;
                 let alias = get_language_alias(path);
 
                 if with_headers {
                     if merge_files {
-                        combined_content.push_str(&format!("### File: {}\n", relative_path.display()));
+                        combined_content
+                            .push_str(&format!("### File: {}\n", relative_path.display()));
                     } else {
-                        combined_content.push_str(&format!("## File: {}\n", relative_path.display()));
+                        combined_content
+                            .push_str(&format!("## File: {}\n", relative_path.display()));
                     }
                 }
                 combined_content.push_str(&format!("```{}\n", alias));
@@ -97,23 +108,43 @@ pub async fn handle_results(
 }
 
 /// Check if a file should be processed
-fn is_valid_file(path: &std::path::Path, repo_path: &std::path::Path, ignore_patterns: &[String]) -> bool {
-    if path.components().any(|c| c.as_os_str() == ".git") { return false; }
-    if ignore_due_to_pattern(path, repo_path, ignore_patterns) { return false; }
-    if !path.is_file() { return false; }
+fn is_valid_file(
+    path: &std::path::Path,
+    repo_path: &std::path::Path,
+    ignore_patterns: &[String],
+) -> bool {
+    if path.components().any(|c| c.as_os_str() == ".git") {
+        return false;
+    }
+    if ignore_due_to_pattern(path, repo_path, ignore_patterns) {
+        return false;
+    }
+    if !path.is_file() {
+        return false;
+    }
 
     if let Some(ext) = path.extension().and_then(|s| s.to_str())
-        && matches!(ext, "png" | "jpg" | "jpeg" | "gif" | "zip" | "tar" | "gz" | "bin" | "o" | "so" | "dll") {
+        && matches!(
+            ext,
+            "png" | "jpg" | "jpeg" | "gif" | "zip" | "tar" | "gz" | "bin" | "o" | "so" | "dll"
+        )
+    {
         return false;
     }
 
     true
 }
 
-fn ignore_due_to_pattern(path: &std::path::Path, repo_path: &std::path::Path, ignore_patterns: &[String]) -> bool {
+fn ignore_due_to_pattern(
+    path: &std::path::Path,
+    repo_path: &std::path::Path,
+    ignore_patterns: &[String],
+) -> bool {
     let relative_path_str = match path.strip_prefix(repo_path) {
         Ok(p) => p.to_string_lossy().replace("\\", "/"),
         Err(_) => return false,
     };
-    ignore_patterns.iter().any(|pattern| relative_path_str.contains(&pattern.replace("\\", "/")))
+    ignore_patterns
+        .iter()
+        .any(|pattern| relative_path_str.contains(&pattern.replace("\\", "/")))
 }
diff --git a/src/repository.rs b/src/repository.rs
@@ -14,6 +14,11 @@ impl Repository {
         let name = repo_url.replace("/", "-");
         let path = base_download_dir.join(&name);
 
-        Self { url, name, path, content: None }
+        Self {
+            url,
+            name,
+            path,
+            content: None,
+        }
     }
 }
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,11 @@ impl Repository {`
`14`	`14`	`let name = repo_url.replace("/", "-");`
`15`	`15`	`let path = base_download_dir.join(&name);`
`16`	`16`
`17`		`- Self { url, name, path, content: None }`
	`17`	`+ Self {`
	`18`	`+ url,`
	`19`	`+ name,`
	`20`	`+ path,`
	`21`	`+ content: None,`
	`22`	`+ }`
`18`	`23`	`}`
`19`	`24`	`}`