Merge pull request #133 from RafaelJohn9/feat/saving-with-different-name

Feat/saving with different name

Author: RafaelJohn9

src/commands/gitignore/add.rs

@@ -37,6 +37,21 @@ pub struct AddArgs {
     /// Update the gitignore cache
     #[arg(long = "update-cache", default_value = "false")]
     pub update_cache: bool,
+
+    /// Use the remote template file name as the output file name
+    #[arg(long = "use-remote-name", short = 'n', default_value_t = false)]
+    pub use_remote_name: bool,
+
+    /// Output file name (default: .gitignore)
+    #[arg(
+        long = "output",
+        short = 'o',
+        value_name = "FILENAME",
+        num_args = 1.., // Accepts one or more values
+        default_value = ".gitignore",
+        requires = "templates"
+    )]
+    pub output: Vec<String>,
 }
 
 impl super::Runnable for AddArgs {
@@ -51,7 +66,7 @@ impl super::Runnable for AddArgs {
         };
 
         if self.all {
-            download_all_templates(dir.as_ref(), self.force, &cache)?;
+            download_all_templates(dir.as_ref(), self.force, &cache, self.use_remote_name)?;
         } else if self.templates.is_empty() {
             return Err(anyhow::anyhow!(
                 "No gitignore template specified. Use `--all` or pass template names."
@@ -60,9 +75,11 @@ impl super::Runnable for AddArgs {
             download_templates(
                 &self.templates,
                 dir.as_ref(),
+                &self.output,
                 self.force,
                 &cache,
                 self.append,
+                self.use_remote_name,
             )?;
         }
 
@@ -74,83 +91,207 @@ fn download_all_templates(
     dir_path: Option<&PathBuf>,
     force: bool,
     cache: &Cache<String>,
+    use_remote_name: bool,
 ) -> Result<()> {
     println!("Fetching all gitignore templates...");
+    let fetcher = Fetcher::new();
 
-    let dest_path = dir_path
-        .map(|p| p.join(".gitignore"))
-        .unwrap_or_else(|| Path::new(OUTPUT_BASE_PATH).join(OUTPUT).join(".gitignore"));
+    if use_remote_name {
+        // Save each template as its remote filename (e.g., Python.gitignore)
+        for (_key, rel_path_entry) in cache.entries.iter() {
+            let url = format!("{}/{}", GITHUB_RAW_BASE, rel_path_entry.data);
 
-    if force && dest_path.exists() {
-        std::fs::remove_file(&dest_path)?;
-    }
+            // Extract remote filename from rel_path_entry.data
+            let remote_filename = Path::new(&rel_path_entry.data)
+                .file_name()
+                .and_then(|s| s.to_str())
+                .ok_or_else(|| anyhow::anyhow!("Invalid template path: {}", rel_path_entry.data))?;
 
-    for (key, rel_path_entry) in cache.entries.iter() {
-        let fetcher = Fetcher::new();
-        let url = format!("{}/{}", GITHUB_RAW_BASE, rel_path_entry.data);
+            let dest_path = dir_path
+                .map(|p| p.join(remote_filename))
+                .unwrap_or_else(|| {
+                    Path::new(OUTPUT_BASE_PATH)
+                        .join(OUTPUT)
+                        .join(remote_filename)
+                });
 
-        let msg = format!("Downloading gitignore template: {}", key);
-        let pb = progress::spinner(&msg);
-        let content = fetcher.fetch_content(&url)?;
-        pb.set_message("Download Complete");
-        pb.finish_and_clear();
+            if force && dest_path.exists() {
+                std::fs::remove_file(&dest_path)?;
+            }
 
-        let section = format!("# ===== {}.gitignore =====\n{}\n\n", key, content);
-        file::append_file(&section, &dest_path, None)?;
-    }
+            let msg = format!("Downloading gitignore template: {}", remote_filename);
+            let pb = progress::spinner(&msg);
+            let content = fetcher.fetch_content(&url)?;
+            pb.set_message("Download Complete");
+            pb.finish_and_clear();
+
+            let section = format!("# ===== {} =====\n{}\n\n", remote_filename, content);
+            file::save_file(&section, &dest_path, force)?;
+
+            println!(
+                "{} Downloaded gitignore template: {} to {}",
+                "✓".green(),
+                remote_filename,
+                dest_path.display()
+            );
+        }
+    } else {
+        // Merge all templates into a single .gitignore file
+        let dest_path = dir_path
+            .map(|p| p.join(".gitignore"))
+            .unwrap_or_else(|| Path::new(OUTPUT_BASE_PATH).join(OUTPUT).join(".gitignore"));
+
+        if force && dest_path.exists() {
+            std::fs::remove_file(&dest_path)?;
+        }
 
-    println!(
-        "{} Downloaded and merged all gitignore templates to {}",
-        "✓".green(),
-        dest_path.display()
-    );
+        for (key, rel_path_entry) in cache.entries.iter() {
+            let url = format!("{}/{}", GITHUB_RAW_BASE, rel_path_entry.data);
+
+            let msg = format!("Downloading gitignore template: {}", key);
+            let pb = progress::spinner(&msg);
+            let content = fetcher.fetch_content(&url)?;
+            pb.set_message("Download Complete");
+            pb.finish_and_clear();
+
+            let section = format!("# ===== {}.gitignore =====\n{}\n\n", key, content);
+            file::append_file(&section, &dest_path, None)?;
+        }
+
+        println!(
+            "{} Downloaded and merged all gitignore templates to {}",
+            "✓".green(),
+            dest_path.display()
+        );
+    }
 
     Ok(())
 }
 
 fn download_templates(
     templates: &[String],
     dir_path: Option<&PathBuf>,
+    output: &[String],
     force: bool,
     cache: &Cache<String>,
     append: bool,
+    use_remote_name: bool,
 ) -> Result<()> {
-    let mut merged_content = String::new();
+    let fetcher = Fetcher::new(); // Create once, reuse
 
-    for template_name in templates {
-        // Try to find the template in cache with different key formats
-        let template_path = find_template_in_cache(template_name, cache)?;
+    if use_remote_name {
+        // Each template is saved using its remote filename (e.g., Python.gitignore)
+        for template_name in templates {
+            let template_path = find_template_in_cache(template_name, cache)?;
+            let url = format!("{}/{}", GITHUB_RAW_BASE, template_path);
 
-        let fetcher = Fetcher::new();
-        let url = format!("{}/{}", GITHUB_RAW_BASE, template_path);
+            // Extract filename from template_path (e.g., "Python.gitignore")
+            let remote_filename = Path::new(&template_path)
+                .file_name()
+                .and_then(|s| s.to_str())
+                .ok_or_else(|| anyhow::anyhow!("Invalid template path: {}", template_path))?;
 
-        let msg = format!("Downloading gitignore template: {}", template_name);
-        let pb = progress::spinner(&msg);
-        let content = fetcher.fetch_content(&url)?;
-        pb.set_message("Download Complete");
-        pb.finish_and_clear();
+            let msg = format!("Downloading gitignore template: {}", template_name);
+            let pb = progress::spinner(&msg);
+            let content = fetcher.fetch_content(&url)?;
+            pb.set_message("Download Complete");
+            pb.finish_and_clear();
 
-        merged_content.push_str(&format!(
-            "# ===== {}.gitignore =====\n{}\n\n",
-            template_name, content
-        ));
-    }
+            let section = format!("# ===== {} =====\n{}\n\n", remote_filename, content);
 
-    let dest_path = dir_path
-        .map(|p| p.join(".gitignore"))
-        .unwrap_or_else(|| Path::new(OUTPUT_BASE_PATH).join(OUTPUT).join(".gitignore"));
+            let dest_path = dir_path
+                .map(|p| p.join(remote_filename))
+                .unwrap_or_else(|| {
+                    Path::new(OUTPUT_BASE_PATH)
+                        .join(OUTPUT)
+                        .join(remote_filename)
+                });
 
-    if append {
-        file::append_file(&merged_content, &dest_path, None)?;
+            if append {
+                file::append_file(&section, &dest_path, None)?;
+            } else {
+                file::save_file(&section, &dest_path, force)?;
+            }
+
+            println!(
+                "{} Added gitignore template: {} to {}",
+                "✓".green(),
+                template_name,
+                dest_path.display()
+            );
+        }
+    } else if output.len() == templates.len() {
+        // Save each template to its own file as specified in output
+        for (template_name, output_file) in templates.iter().zip(output.iter()) {
+            let template_path = find_template_in_cache(template_name, cache)?;
+            let url = format!("{}/{}", GITHUB_RAW_BASE, template_path);
+
+            let msg = format!("Downloading gitignore template: {}", template_name);
+            let pb = progress::spinner(&msg);
+            let content = fetcher.fetch_content(&url)?;
+            pb.set_message("Download Complete");
+            pb.finish_and_clear();
+
+            let section = format!("# ===== {}.gitignore =====\n{}\n\n", template_name, content);
+
+            let dest_path = dir_path
+                .map(|p| p.join(output_file))
+                .unwrap_or_else(|| Path::new(OUTPUT_BASE_PATH).join(OUTPUT).join(output_file));
+
+            if append {
+                file::append_file(&section, &dest_path, None)?;
+            } else {
+                file::save_file(&section, &dest_path, force)?;
+            }
+
+            println!(
+                "{} Added gitignore template: {} to {}",
+                "✓".green(),
+                template_name,
+                dest_path.display()
+            );
+        }
+    } else if output.len() == 1 {
+        // Merge all templates into one file
+        let mut merged_content = String::new();
+
+        for template_name in templates {
+            let template_path = find_template_in_cache(template_name, cache)?;
+            let url = format!("{}/{}", GITHUB_RAW_BASE, template_path);
+
+            let msg = format!("Downloading gitignore template: {}", template_name);
+            let pb = progress::spinner(&msg);
+            let content = fetcher.fetch_content(&url)?;
+            pb.set_message("Download Complete");
+            pb.finish_and_clear();
+
+            merged_content.push_str(&format!(
+                "# ===== {}.gitignore =====\n{}\n\n",
+                template_name, content
+            ));
+        }
+
+        let dest_path = dir_path
+            .map(|p| p.join(&output[0]))
+            .unwrap_or_else(|| Path::new(OUTPUT_BASE_PATH).join(OUTPUT).join(&output[0]));
+
+        if append {
+            file::append_file(&merged_content, &dest_path, None)?;
+        } else {
+            file::save_file(&merged_content, &dest_path, force)?;
+        }
+
+        println!(
+            "{} Added gitignore templates: {} to {}",
+            "✓".green(),
+            templates.join(", "),
+            dest_path.display()
+        );
     } else {
-        file::save_file(&merged_content, &dest_path, force)?;
+        return Err(anyhow::anyhow!(
+            "Number of output files must be either 1 or match the number of templates when not using --use-remote-name"
+        ));
     }
 
-    println!(
-        "{} Added gitignore templates: {}",
-        "✓".green(),
-        templates.join(", ")
-    );
-
     Ok(())
 }

src/commands/issue/add.rs

@@ -30,6 +30,10 @@ pub struct AddArgs {
     /// Download all available templates
     #[arg(long)]
     pub all: bool,
+
+    /// Output file names for the templates (in order of templates)
+    #[arg(short='o', long, value_name = "OUTPUT", num_args = 1.., requires = "templates")]
+    pub output: Vec<String>,
 }
 
 impl super::Runnable for AddArgs {
@@ -41,8 +45,24 @@ impl super::Runnable for AddArgs {
                 "No issue template specified. Use `--all` or pass template names."
             ));
         } else {
-            for template_name in &self.templates {
-                download_single_template(template_name, self.dir.as_ref(), self.force)?;
+            if !self.output.is_empty() {
+                if self.templates.len() != self.output.len() {
+                    return Err(anyhow::anyhow!(
+                        "The number of templates and output file names must match."
+                    ));
+                }
+                for (template_name, output_name) in self.templates.iter().zip(self.output.iter()) {
+                    download_single_template(
+                        template_name,
+                        self.dir.as_ref(),
+                        self.force,
+                        Some(output_name.clone()),
+                    )?;
+                }
+            } else {
+                for template_name in &self.templates {
+                    download_single_template(template_name, self.dir.as_ref(), self.force, None)?;
+                }
             }
         }
 
@@ -65,7 +85,7 @@ fn download_all_templates(dir_path: Option<&PathBuf>, force: bool) -> anyhow::Re
             None => &entry.name,
         };
 
-        if let Err(e) = download_single_template(template_name, dir_path, force) {
+        if let Err(e) = download_single_template(template_name, dir_path, force, None) {
             eprintln!(
                 "{} Failed to add template '{}': {}",
                 "✗".red(),
@@ -101,9 +121,9 @@ fn download_single_template(
     template_name: &str,
     dir_path: Option<&PathBuf>,
     force: bool,
+    output: Option<String>,
 ) -> anyhow::Result<()> {
     let fetcher = Fetcher::new();
-
     let url = format!("{}/issue-templates/{}.yml", GITHUB_RAW_BASE, template_name);
 
     let msg = format!("Downloading issue template: {}", template_name);
@@ -112,13 +132,31 @@ fn download_single_template(
     pb.set_message("Download Complete");
     pb.finish_and_clear();
 
-    let default_path = Path::new(OUTPUT_BASE_PATH).join(OUTPUT);
-    let base_path = dir_path.map_or(default_path.as_path(), |p| p.as_path());
-    let dest_path = base_path.join(format!("{}.yml", template_name));
+    // Determine output path logic
+    let dest_path = if let Some(mut output_file) = output {
+        // Technical Debt: Add .yml extension if not present. Not flexible for other formats.
+        if Path::new(&output_file).extension().is_none() {
+            output_file.push_str(".yml");
+        }
+        dir_path
+            .map(|p| p.join(&output_file))
+            .unwrap_or_else(|| Path::new(OUTPUT_BASE_PATH).join(OUTPUT).join(&output_file))
+    } else {
+        // Default: .github/ISSUE_TEMPLATE/<template_name>.yml
+        let default_path = Path::new(OUTPUT_BASE_PATH).join(OUTPUT);
+        dir_path
+            .map(|p| p.join(format!("{}.yml", template_name)))
+            .unwrap_or_else(|| default_path.join(format!("{}.yml", template_name)))
+    };
 
     file::save_file(&content, &dest_path, force)?;
 
-    println!("{} Added template: {}", "✓".green(), template_name);
+    println!(
+        "{} Added template: {} to {}",
+        "✓".green(),
+        template_name,
+        dest_path.display()
+    );
 
     Ok(())
 }