Changeset 319b736 in gignore

Timestamp:

7 Dec 2025, 16:25:36 (5 months ago)

Author:

Asher Mullaney <asher.mullaney@…>

Branches:

error_handling, file_locations, help, json_tlib, logging, man, multi_arg, trunk, visibility

Children:

b6c2333

Parents:

48d7b95

Message:

First commit! Fully functional.

Files:

• .gitignore (modified) (1 diff)
• Cargo.toml (modified) (1 diff)
• src/lib.rs (modified) (9 diffs)
• src/template.rs (added)
• test_gitignore (deleted)

.gitignore

@@ -1 +1 @@
 target/
-*.swp
-*/*.swp
 Cargo.lock
+**.swp
+test.txt
+python.txt
+rust.txt
+mutants.out
+vi.txt
+html.txt

Cargo.toml

@@ -6 +6 @@
 [dependencies]
 clap = { version = "4.5.53", features = ["derive"] }
+home = "0.5.12"

src/lib.rs

@@ -1 +1 @@
 #![warn(clippy::unwrap_used)]
+
+mod template;
 
 use clap::{Subcommand, Parser};
@@ -9 +11 @@
     process::exit,
     io,
+    path::Path,
 };
+
+trait HandleErr {
+    type OkType;
+
+    fn handle_err(self, _: &str) -> Self::OkType;
+}
+
+impl<T, E: std::fmt::Display> HandleErr for Result<T, E> {
+    type OkType = T;
+
+    fn handle_err(self, operation: &str) -> Self::OkType {
+        match self {
+            Ok(val) => val,
+            Err(e) => {
+                eprintln!("Error {operation}: {e}");
+                exit(1);
+            },
+        }
+    }
+}
+impl<T> HandleErr for Option<T> {
+    type OkType = T;
+
+    fn handle_err(self, none_message: &str) -> Self::OkType {
+        match self {
+            Some(val) => val,
+            None => {
+                eprintln!("{none_message}");
+                exit(1);
+            },
+        }
+    }
+}
+
 #[derive(Parser)]
 #[command(about = ".gitignore manipulator tool.", long_about = None, version)]
@@ -33 +70 @@
     /// Lists items within .gitignore
     List {
+        /// Print contents on one line, separated by whitespace.
         #[arg(long)]
         oneline: bool,
     },
+
+    /// Add, remove, or use templates.
+    Template {
+        #[command(subcommand)]
+        operation: TemplateCommand,
+    },
+}
+
+#[derive(Subcommand)]
+pub enum TemplateCommand {
+    /// Add template names and source files to the library
+    Add {
+        /// Name to add to library
+        name: String,
+        /// Source file to add to library
+        source_file: String,
+
+        #[arg(long, short)]
+        /// Append template to .gitignore when using (rather than truncating)
+        append: bool,
+    },
+
+    /// Remove templates from the library
+    Remove {
+        /// Name to remove from library
+        name: String,
+    },
+
+    /// Use templates
+    Use {
+        /// Name to write to gitignore
+        name: String,
+    },
+
+    /// List entries in library
+    List {
+        #[arg(long)]
+        /// Print entries on one line
+        oneline: bool
+    },
+    
+    /// Clear template library
+    Clear,
 }
 
@@ -45 +126 @@
         } => {
             let Some(path) = path else {
-                File::create("test_gitignore").unwrap_or_else(|e| {
-                    println!("Error creating file: {e}");
-                    exit(1);
-                });
+                File::create(".gitignore").handle_err("creating file");
 
                 std::process::exit(0);
             };
 
-            let mut append_handle = open_append("test_gitignore").unwrap_or_else(|e| {
-                println!("Error opening file for append: {e}");
-                exit(1);
-            });
-
-            append_handle.write_all(format!("{}\n", path.trim()).as_bytes()).unwrap_or_else(|e| {
-                println!("Error writing to file: {e}");
-                exit(1);
-            });
+            if fs::read_to_string(".gitignore")
+                .handle_err("reading file")
+                    .lines()
+                    .collect::<Vec<&str>>()
+                    .contains(&&path[..]) {
+                        println!("That path already exists in .gitignore!");
+                        exit(1);
+            }
+
+            let mut append_handle = open_append(".gitignore".as_ref()).handle_err("opening file for append");
+
+            append_handle.write_all(format!("{}\n", path.trim()).as_bytes()).handle_err("writing to file");
         },
         OperCommand::Remove {
@@ -67 +148 @@
         } => {
             let Some(path) = path else {
-                println!("This will permanently remove .gitignore!");
-
-                loop {
-                    println!("Do you really want to do this? y/N");
-                    let mut s = String::new();
-                    io::stdin()
-                        .read_line(&mut s)
-                        .unwrap_or_else(|e| {
-                            println!("Error reading from stdin: {e}");
-                            exit(1);
-                        });
-
-                    match &s.trim().to_lowercase()[..] {
-                        "" | "n" => break,
-                        "y" => {
-                            println!("Removing .gitignore...");
-
-                            fs::remove_file("test_gitignore").unwrap_or_else(|e| {
-                                eprintln!("Error while removing the file: {e}");
-                                exit(1);
-                            });
-
-                            exit(0);
+                if fs::exists(".gitignore").handle_err("searching for file") {
+                    loop {
+                        println!("This will permanently remove .gitignore!");
+                        println!("Do you really want to do this? y/N");
+                        let mut s = String::new();
+                        io::stdin()
+                            .read_line(&mut s)
+                            .handle_err("reading stdin");
+
+                        match &s.trim().to_lowercase()[..] {
+                            "" | "n" => break,
+                            "y" => {
+                                println!("Removing .gitignore...");
+
+                                fs::remove_file(".gitignore").handle_err("removing file");
+
+                                exit(0);
+                            }
+                            _ => continue,
                         }
-                        _ => continue,
                     }
+                    exit(0);
+                } else {
+                    println!("File is already removed.");
+                    exit(1);
                 }
-                exit(0);
             };
 
-            let contents = fs::read_to_string("test_gitignore").unwrap_or_else(|e| {
-                eprintln!("Error reading contents of file: {e}");
-                exit(1);
-            });
+            let contents = fs::read_to_string(".gitignore").handle_err("reading file");
 
             let mut lines: Vec<&str> =  contents.lines().collect();
@@ -113 +189 @@
             drop(extracted);
 
+            open_truncate(".gitignore".as_ref()).handle_err("opening file for truncate").write_all(b"").handle_err("writing to file");
+
             // Re-add lines to file, without [PATH].
             for line in lines {
-                File::create("test_gitignore").unwrap_or_else(|e| {
-                    eprintln!("{e}");
-                    exit(1);
-                })
-                .write_all(format!("{}\n", line).as_bytes())
-                .unwrap_or_else(|e| {
-                    eprintln!("{e}");
-                    exit(1);
-                });
+                open_append(".gitignore".as_ref()).handle_err("opening file for append")
+                    .write_all(
+                        format!("{line}\n").as_bytes()
+                    ).handle_err("writing to file");
             }
         },
@@ -130 +203 @@
             oneline
         } => {
-            let result = fs::read_to_string("test_gitignore");
+            let result = fs::read_to_string(".gitignore");
 
             if let Err(e) = result {
@@ -151 +224 @@
 
             println!("{}", result.trim());
+        },
+
+        OperCommand::Template {
+            operation: TemplateCommand::Add {
+                name,
+                source_file,
+                append,
+            }
+        } => {
+            template::add(template::Template::new(source_file.as_ref(), name, *append));
+        }
+
+        OperCommand::Template {
+            operation: TemplateCommand::Remove {
+                name,
+            }
+        } => {
+            template::remove(name);
+        },
+
+        OperCommand::Template {
+            operation: TemplateCommand::List {
+                oneline,
+            }
+        } => {
+            template::list(*oneline);
+        },
+
+        OperCommand::Template {
+            operation: TemplateCommand::Use {
+                name,
+            }
+        } => {
+            template::gitignore_write(name);
+        },
+
+        OperCommand::Template {
+            operation: TemplateCommand::Clear
+        } => {
+            template::clear();
         }
     };
 }
 
-fn open_append(path: &str) -> Result<File, Box<dyn Error>> {
+fn open_append(path: &Path) -> Result<File, Box<dyn Error>> {
     Ok(
         OpenOptions::new()
@@ -163 +276 @@
     )
 }
+fn open_truncate(path: &Path) -> Result<File, Box<dyn Error>> {
+    Ok(
+        OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(true)
+        .open(path)?
+    )
+}