cargo fmt and clippy changes.

Author: fabiomolinar

src/git_utils.rs

@@ -1,14 +1,14 @@
 use crate::repository::Repository;
 use git2::Repository as Git2Repository;
-use tokio::fs;
 use reqwest::Client;
 use serde::Deserialize;
 use std::path::Path;
+use tokio::fs;
 
 #[derive(Deserialize)]
 struct GitHubPRFile {
     filename: String,
-    patch: Option<String>,  // not always present (binary files)
+    patch: Option<String>, // not always present (binary files)
 }
 
 pub async fn clone_repository(repository: &Repository) -> Result<Git2Repository, String> {
@@ -37,7 +37,10 @@ pub async fn fetch_and_reconstruct_pr_files(
     pr_number: u32,
     base_path: &Path,
 ) -> Result<(), String> {
-    let api_url = format!("https://api.github.com/repos/{}/pulls/{}/files", repo, pr_number);
+    let api_url = format!(
+        "https://api.github.com/repos/{}/pulls/{}/files",
+        repo, pr_number
+    );
 
     let client = Client::new();
     let resp = client
@@ -60,13 +63,17 @@ pub async fn fetch_and_reconstruct_pr_files(
         if let Some(patch) = file.patch {
             let file_path = base_path.join(&file.filename);
             if let Some(parent) = file_path.parent() {
-                fs::create_dir_all(parent).await.map_err(|e| e.to_string())?;
+                fs::create_dir_all(parent)
+                    .await
+                    .map_err(|e| e.to_string())?;
             }
-            fs::write(&file_path, patch).await.map_err(|e| e.to_string())?;
+            fs::write(&file_path, patch)
+                .await
+                .map_err(|e| e.to_string())?;
         } else {
             eprintln!("Skipping file {} (no patch, maybe binary)", file.filename);
         }
     }
 
     Ok(())
-}
+}

src/lib.rs

@@ -40,10 +40,17 @@ pub async fn process_github_urls(
         .map(|url| {
             let repository = Repository::new(&download_dir, url);
             let ignore_patterns = Arc::clone(&ignore_patterns);
-            let folder = folder.clone();            
+            let folder = folder.clone();
             tokio::spawn(async move {
-                process_single_repository(repository, no_headers, merge_files, ignore_patterns, folder, pr)
-                    .await
+                process_single_repository(
+                    repository,
+                    no_headers,
+                    merge_files,
+                    ignore_patterns,
+                    folder,
+                    pr,
+                )
+                .await
             })
         })
         .collect();

src/processing.rs

@@ -45,7 +45,7 @@ pub async fn process_single_repository(
         repository.content = Some(content);
         return Ok(repository);
     }
-    
+
     // Case 2: Normal mode → clone repo
     println!(
         "Preparing to clone {} to {:?}",
@@ -57,9 +57,14 @@ pub async fn process_single_repository(
         repository.name, repository.path
     );
 
-    let content =
-        process_repository_files(&repository.path, no_headers, merge_files, &ignore_patterns, folder.as_deref())
-            .await?;
+    let content = process_repository_files(
+        &repository.path,
+        no_headers,
+        merge_files,
+        &ignore_patterns,
+        folder.as_deref(),
+    )
+    .await?;
     repository.content = Some(content);
 
     Ok(repository)
@@ -82,7 +87,10 @@ pub async fn process_repository_files(
     };
 
     if !base_path.exists() {
-        return Err(format!("Specified folder {:?} not found in repo", base_path));
+        return Err(format!(
+            "Specified folder {:?} not found in repo",
+            base_path
+        ));
     }
 
     for entry in WalkDir::new(&base_path).into_iter().filter_map(|e| e.ok()) {
@@ -171,7 +179,18 @@ fn is_valid_file(
     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" | "der"
+            "png"
+                | "jpg"
+                | "jpeg"
+                | "gif"
+                | "zip"
+                | "tar"
+                | "gz"
+                | "bin"
+                | "o"
+                | "so"
+                | "dll"
+                | "der"
         )
     {
         return false;

src/repository.rs

@@ -1,4 +1,7 @@
-use std::{fmt, path::{Path, PathBuf}};
+use std::{
+    fmt,
+    path::{Path, PathBuf},
+};
 
 #[derive(Clone, Debug)]
 pub struct Repository {
@@ -29,8 +32,12 @@ impl Repository {
 impl fmt::Display for Repository {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
-            f, "Repository(name: {}, url: {}, path: {:?}, has_content: {})", 
-            self.name, self.url, self.path, self.has_content()
+            f,
+            "Repository(name: {}, url: {}, path: {:?}, has_content: {})",
+            self.name,
+            self.url,
+            self.path,
+            self.has_content()
         )
     }
-}
+}

tests/integration_tests.rs

@@ -53,17 +53,19 @@ async fn test_process_repository_files() -> Result<(), Box<dyn std::error::Error
     let src_main_path = PathBuf::from("src").join("main.rs");
     let readme_path = PathBuf::from("README.md");
 
-    let content_with_headers = process_repository_files(&test_repo_path, false, false, &Vec::new(), None)
-        .await
-        .unwrap();
+    let content_with_headers =
+        process_repository_files(&test_repo_path, false, false, &Vec::new(), None)
+            .await
+            .unwrap();
     assert!(content_with_headers.contains(&format!("## File: {}", src_main_path.display())));
     assert!(content_with_headers.contains("fn main() { println!(\"Hello\"); }"));
     assert!(content_with_headers.contains(&format!("## File: {}", readme_path.display())));
     assert!(content_with_headers.contains("# Test Repo"));
 
-    let content_no_headers = process_repository_files(&test_repo_path, true, false, &Vec::new(), None)
-        .await
-        .unwrap();
+    let content_no_headers =
+        process_repository_files(&test_repo_path, true, false, &Vec::new(), None)
+            .await
+            .unwrap();
     assert!(!content_no_headers.contains(&format!("## File: {}", src_main_path.display())));
     assert!(content_no_headers.contains("fn main() { println!(\"Hello\"); }"));
     assert!(!content_no_headers.contains(&format!("## File: {}", readme_path.display())));
@@ -126,7 +128,8 @@ async fn test_ignore_patterns_cross_platform() -> Result<(), Box<dyn std::error:
     ];
 
     let content =
-        processing::process_repository_files(&test_repo_path, true, true, &ignore_patterns, None).await?;
+        processing::process_repository_files(&test_repo_path, true, true, &ignore_patterns, None)
+            .await?;
 
     // Ignored files should not be in the output
     assert!(!content.contains("secret.txt"));