rustfmt

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ame"
-version = "2.3.1"
+version = "2.4.0"
 authors = [ "jnats <jnats@salyut.one>", "axtlos <axtlos@salyut.one>" ]
 edition = "2018"
 description = "a fast and efficient aur helper."

src/main.rs

@@ -1,6 +1,20 @@
-
 mod mods;
-use mods::{clearcache::clearcache, clone::clone, help::help, install::install, inssort::inssort, search::{a_search, r_search}, uninstall::uninstall, upgrade::upgrade, update::update, ver::ver, strs::inf, strs::err_unrec, strs::err_rec, xargs::*};
+use mods::{
+    clearcache::clearcache,
+    clone::clone,
+    help::help,
+    inssort::inssort,
+    install::install,
+    search::{a_search, r_search},
+    strs::err_rec,
+    strs::err_unrec,
+    strs::inf,
+    uninstall::uninstall,
+    update::update,
+    upgrade::upgrade,
+    ver::ver,
+    xargs::*,
+};
 use std::{env, process::exit, process::Command};
 
 fn main() {
@@ -70,11 +84,12 @@ fn main() {
         match pass.code() {
             Some(1) => {
                 err_rec(format!("No such operation \"{}\"", args.join(" ")));
-            inf(format!("Try running \"ame help\" for an overview of how to use ame"))
+                inf(format!(
+                    "Try running \"ame help\" for an overview of how to use ame"
+                ))
             }
             Some(_) => {}
-        None => {
+            None => err_unrec(format!("Something has gone terribly wrong.")),
-            err_unrec(format!("Something has gone terribly wrong."))
+        }
-        }}
     }
 }

src/mods.rs

@@ -1,12 +1,12 @@
 pub mod clearcache;
 pub mod clone;
 pub mod help;
+pub mod inssort;
 pub mod install;
 pub mod search;
+pub mod strs;
 pub mod uninstall;
-pub mod upgrade;
 pub mod update;
-pub mod strs;
+pub mod upgrade;
 pub mod ver;
-pub mod inssort;
 pub mod xargs;

src/mods/clearcache.rs

@@ -1,5 +1,5 @@
-use std::fs;
 use crate::mods::strs::err_rec;
+use std::fs;
 
 pub fn clearcache() {
     let path = format!("{}/.cache/ame/", std::env::var("HOME").unwrap());

src/mods/clone.rs

@@ -1,14 +1,21 @@
+use crate::{
+    err_unrec, inf, inssort, mods::strs::prompt, mods::strs::sec, mods::strs::succ,
+    mods::uninstall::uninstall,
+};
 use git2::Repository;
 use moins::Moins;
 use std::{env, fs, path::Path, process::Command};
-use crate::{err_unrec, inf, inssort, mods::strs::succ, mods::strs::sec, mods::strs::prompt, mods::uninstall::uninstall};
 
 fn uninstall_make_depend(results: Vec<raur::Package>, pkg: &str) {
     let aurpkgname = results[0].name.to_string();
     let make_depends = raur::info(&[&aurpkgname]).unwrap()[0].make_depends.clone();
 
     if make_depends.len() != 0 {
-            inf(format!("{} installed following make dependencies: {}", pkg, make_depends.join(", ")));
+        inf(format!(
+            "{} installed following make dependencies: {}",
+            pkg,
+            make_depends.join(", ")
+        ));
         let remove = prompt(format!("Would you like to remove them?"));
         if remove == true {
             uninstall(true, make_depends);
@@ -32,12 +39,9 @@ pub fn clone(noconfirm: bool, pkg: &str) {
     if !path.is_dir() {
         let cache_result = fs::create_dir(&path);
         match cache_result {
-        Ok(_) => {
+            Ok(_) => inf(format!("Created cache path (first run)")),
-            inf(format!("Created cache path (first run)"))
+            Err(_) => err_unrec(format!("Could not create cache path")),
         }
-        Err(_) => {
-            err_unrec(format!("Could not create cache path"))
-        }}
     }
 
     inf(format!("Cloning {} ...", pkg));
@@ -45,31 +49,28 @@ pub fn clone(noconfirm: bool, pkg: &str) {
     if Path::new(&pkgdir).is_dir() {
         let rm_result = fs::remove_dir_all(&pkgdir);
         match rm_result {
-        Ok(_) => {
+            Ok(_) => inf(format!(
-            inf(format!("Package path for {} already found. Removing to reinstall", pkg))
+                "Package path for {} already found. Removing to reinstall",
+                pkg
+            )),
+            Err(_) => err_unrec(format!(
+                "Package path for {} already found, but could not remove to reinstall",
+                pkg
+            )),
         }
-        Err(_) => {
-            err_unrec(format!("Package path for {} already found, but could not remove to reinstall", pkg))
-        }}
     }
 
     let dir_result = fs::create_dir(&pkgdir);
     match dir_result {
-    Ok(_) => {
+        Ok(_) => inf(format!("Cloned {} to package directory", pkg)),
-        inf(format!("Cloned {} to package directory", pkg))
+        Err(_) => err_unrec(format!("Couldn't create package directory for {}", pkg)),
     }
-    Err(_) => {
-        err_unrec(format!("Couldn't create package directory for {}", pkg))
-    }}
 
     let cd_result = env::set_current_dir(&pkgdir);
     match cd_result {
-    Ok(_) => {
+        Ok(_) => inf(format!("Entered package directory")),
-        inf(format!("Entered package directory"))
+        Err(_) => err_unrec(format!("Could not enter package directory")),
     }
-    Err(_) => {
-        err_unrec(format!("Could not enter package directory"))
-    }}
 
     sec(format!("Installing AUR package depends"));
 
@@ -84,9 +85,8 @@ pub fn clone(noconfirm: bool, pkg: &str) {
         Ok(_) => {
             inf(format!("Cloning {} into package directory", pkg));
         }
-    Err(_) => {
+        Err(_) => err_unrec(format!("Failed cloning {} into package directory", pkg)),
-        err_unrec(format!("Failed cloning {} into package directory", pkg))
+    }
-    }}
 
     if noconfirm == false {
         let pkgbuild = prompt(format!("View PKGBUILD?"));
@@ -109,7 +109,8 @@ pub fn clone(noconfirm: bool, pkg: &str) {
             }
             Err(_) => {
                 err_unrec(format!("Couldn't install {}", pkg));
-        }};
+            }
+        };
     } else {
         sec(format!("Installing {} ...", pkg));
         let install_result = Command::new("makepkg")
@@ -125,6 +126,7 @@ pub fn clone(noconfirm: bool, pkg: &str) {
             }
             None => {
                 err_unrec(format!("Couldn't install {}", pkg));
-        }};
+            }
+        };
     }
 }

src/mods/help.rs

@@ -1,9 +1,10 @@
-use crate::mods::strs::{inf, err_rec};
+use crate::mods::strs::{err_rec, inf};
 
 pub fn help() {
     println!("");
     inf(format!("Usage:"));
-    println!("
+    println!(
+        "
 ame -S(n)   / ins         <pkg> - install a package
 ame -R(n)   / -Rs(n) / rm <pkg> - remove  a package
 ame -Syu(n) / upg               - upgrade all packages to latest version
@@ -12,9 +13,9 @@ ame -Sa     / aursea      <pkg> - search for a package in the aur
 ame -Sr     / repsea      <pkg> - search for a package in the repos
 ame -v      / ver               - contributors and version info
 
-ame <any valid pacman flags>    - passes said flags to be processed by pacman");
+ame <any valid pacman flags>    - passes said flags to be processed by pacman"
+    );
     println!("");
     err_rec(format!("Appending 'n' where (n) is present passes '--noconfirm' to pacman. Use at your own risk. (alternatively, using '--noconfirm' as a flag works too.)"));
     println!("");
-
 }

src/mods/inssort.rs

@@ -1,5 +1,5 @@
-use crate::{clone, install, err_unrec, mods::strs::sec};
+use crate::{clone, err_unrec, install, mods::strs::sec};
-use std::process::{Stdio, Command};
+use std::process::{Command, Stdio};
 
 pub fn inssort(noconfirm: bool, pkgs: Vec<String>) {
     let mut repo = vec![];
@@ -12,18 +12,12 @@ pub fn inssort(noconfirm: bool, pkgs: Vec<String>) {
             .status()
             .expect("Something has gone wrong.");
         match out.code() {
-        Some(0) => {
+            Some(0) => repo.push(pkg),
-            repo.push(pkg)
+            Some(1) => aur.push(pkg),
+            Some(_) => err_unrec(format!("Something has gone terribly wrong")),
+            None => err_unrec(format!("Process terminated")),
         }
-        Some(1) => {
-            aur.push(pkg)
     }
-        Some(_) => {
-            err_unrec(format!("Something has gone terribly wrong"))
-        }
-        None => {
-            err_unrec(format!("Process terminated"))
-        }}}
 
     if repo.len() != 0 {
         sec(format!("Installing repo packages: {}", &repo.join(", ")));

src/mods/install.rs

@@ -1,31 +1,30 @@
-use runas::Command;
 use crate::mods::strs::{err_unrec, succ};
+use runas::Command;
 
 pub fn install(noconfirm: bool, pkg: &str) {
     let pkgs: Vec<&str> = pkg.split(" ").collect();
     if noconfirm == true {
-        let result = Command::new("pacman").arg("-Sy").arg("--noconfirm").args(&pkgs).status().expect("Couldn't call pacman");
+        let result = Command::new("pacman")
+            .arg("-Sy")
+            .arg("--noconfirm")
+            .args(&pkgs)
+            .status()
+            .expect("Couldn't call pacman");
         match result.code() {
-        Some(0) => {
+            Some(0) => succ(format!("Succesfully installed packages: {}", pkg)),
-            succ(format!("Succesfully installed packages: {}", pkg))
+            Some(_) => err_unrec(format!("Couldn't install packages: {}", pkg)),
-        }
+            None => err_unrec(format!("Couldn't install packages: {}", pkg)),
-        Some(_) => {
+        };
-            err_unrec(format!("Couldn't install packages: {}", pkg))
-        }
-        None => {
-            err_unrec(format!("Couldn't install packages: {}", pkg))
-        }};
     } else {
-        let result = Command::new("pacman").arg("-Sy").args(&pkgs).status().expect("Couldn't call pacman");
+        let result = Command::new("pacman")
+            .arg("-Sy")
+            .args(&pkgs)
+            .status()
+            .expect("Couldn't call pacman");
         match result.code() {
-        Some(0) => {
+            Some(0) => succ(format!("Succesfully installed packages: {}", pkg)),
-            succ(format!("Succesfully installed packages: {}", pkg))
+            Some(_) => err_unrec(format!("Couldn't install packages: {}", pkg)),
-        }
+            None => err_unrec(format!("Couldn't install packages: {}", pkg)),
-        Some(_) => {
+        };
-            err_unrec(format!("Couldn't install packages: {}", pkg))
-        }
-        None => {
-            err_unrec(format!("Couldn't install packages: {}", pkg))
-        }};
     }
 }

src/mods/search.rs

@@ -1,6 +1,6 @@
-use std::{ops::Deref, process::Command};
+use crate::mods::strs::{err_rec, err_unrec, succ};
 use ansi_term::Colour;
-use crate::mods::strs::{err_unrec, err_rec, succ};
+use std::{ops::Deref, process::Command};
 
 pub fn a_search(pkg: &str) {
     let results = raur::search(&pkg);
@@ -10,11 +10,13 @@ pub fn a_search(pkg: &str) {
             err_rec(format!("No matching AUR packages found"));
         }
         for res in r {
-            println!("{}{} {}\n    {}",
+            println!(
+                "{}{} {}\n    {}",
                 Colour::Cyan.bold().paint("aur/"),
                 Colour::White.bold().paint(&res.name),
                 Colour::Green.bold().paint(&res.version),
-            Colour::White.paint(res.description.as_ref().map_or("n/a", String::deref)));
+                Colour::White.paint(res.description.as_ref().map_or("n/a", String::deref))
+            );
         }
     }
 }
@@ -26,17 +28,9 @@ pub fn r_search(pkg: &str) {
         .status()
         .unwrap();
     match result.code() {
-    Some(0) => {
+        Some(0) => succ(format!("Repo search successful")),
-        succ(format!("Repo search successful"))
+        Some(1) => err_rec(format!("No matching repo packages found")),
-    }
+        Some(_) => err_unrec(format!("Someting went terribly wrong")),
-    Some(1) => {
+        None => err_unrec(format!("Couldn't search pacman repos")),
-        err_rec(format!("No matching repo packages found"))
+    };
-    }
-    Some(_) => {
-        err_unrec(format!("Someting went terribly wrong"))
-    }
-    None => {
-        err_unrec(format!("Couldn't search pacman repos"))
-    }};
-
 }

src/mods/strs.rs

@@ -1,49 +1,59 @@
 use ansi_term::Colour;
-use std::{process, env, io, io::Write};
+use std::{env, io, io::Write, process};
 use uwuizer::*;
 
-pub fn inf(a: std::string::String){
+pub fn inf(a: std::string::String) {
     if env::var("AME_UWU").unwrap_or("n/a".to_string()) == "YES" {
-        println!("{} {}",
+        println!(
+            "{} {}",
             Colour::Purple.paint("❖"),
-                 Colour::White.paint(uwuize!(&a)));
+            Colour::White.paint(uwuize!(&a))
+        );
     } else {
-        println!("{} {}",
+        println!("{} {}", Colour::Purple.paint("❖"), Colour::White.paint(a));
-                 Colour::Purple.paint("❖"),
-                 Colour::White.paint(a));
     }
 }
 
-pub fn sec(a: std::string::String){
+pub fn sec(a: std::string::String) {
     if env::var("AME_UWU").unwrap_or("n/a".to_string()) == "YES" {
-        println!("{} {}",
+        println!(
+            "{} {}",
             Colour::Purple.bold().paint("❖"),
-                 Colour::White.bold().paint(uwuize!(&a)));
+            Colour::White.bold().paint(uwuize!(&a))
+        );
     } else {
-        println!("{} {}",
+        println!(
+            "{} {}",
             Colour::Purple.bold().paint("❖"),
-                 Colour::White.bold().paint(a));
+            Colour::White.bold().paint(a)
+        );
     }
 }
 
 pub fn succ(a: std::string::String) {
     if env::var("AME_UWU").unwrap_or("n/a".to_string()) == "YES" {
-        println!("{} {}",
+        println!(
+            "{} {}",
             Colour::Green.bold().paint("✓"),
-                 Colour::Green.paint(uwuize!(&a)));
+            Colour::Green.paint(uwuize!(&a))
+        );
     } else {
-        println!("{} {}",
+        println!(
+            "{} {}",
             Colour::Green.bold().paint("✓"),
-                 Colour::Green.paint(&a));
+            Colour::Green.paint(&a)
+        );
     }
 }
 
 pub fn prompt(a: std::string::String) -> bool {
     if env::var("AME_UWU").unwrap_or("n/a".to_string()) == "YES" {
-        print!("{} {} {}",
+        print!(
+            "{} {} {}",
             Colour::Purple.bold().paint("❖"),
             Colour::White.bold().paint(uwuize!(&a)),
-                 Colour::White.bold().paint("(Y/n): "));
+            Colour::White.bold().paint("(Y/n): ")
+        );
         io::stdout().flush().ok().expect("Couldn't flush stdout");
         let mut yn: String = String::new();
         let _ = std::io::stdin().read_line(&mut yn);
@@ -53,10 +63,12 @@ pub fn prompt(a: std::string::String) -> bool {
             true
         }
     } else {
-        print!("{} {} {}",
+        print!(
+            "{} {} {}",
             Colour::Purple.bold().paint("❖"),
             Colour::White.bold().paint(&a),
-                 Colour::White.bold().paint("(Y/n): "));
+            Colour::White.bold().paint("(Y/n): ")
+        );
         io::stdout().flush().ok().expect("Couldn't flush stdout");
         let mut yn: String = String::new();
         let _ = std::io::stdin().read_line(&mut yn);
@@ -68,31 +80,38 @@ pub fn prompt(a: std::string::String) -> bool {
     }
 }
 
-
 pub fn err_unrec(a: std::string::String) {
     if env::var("AME_UWU").unwrap_or("n/a".to_string()) == "YES" {
-        println!("{} {} {}",
+        println!(
+            "{} {} {}",
             Colour::Red.bold().paint(uwuize!("✖ Unrecoverable error:")),
             Colour::Red.paint(uwuize!(&a)),
-                 Colour::Red.bold().paint(uwuize!("Terminating.")));
+            Colour::Red.bold().paint(uwuize!("Terminating."))
+        );
         process::exit(1);
     } else {
-        println!("{} {} {}",
+        println!(
+            "{} {} {}",
             Colour::Red.bold().paint("✖ Unrecoverable error:"),
             Colour::Red.paint(a),
-                 Colour::Red.bold().paint("Terminating."));
+            Colour::Red.bold().paint("Terminating.")
+        );
         process::exit(1);
     }
 }
 
 pub fn err_rec(a: std::string::String) {
     if env::var("AME_UWU").unwrap_or("n/a".to_string()) == "YES" {
-        println!("{} {}",
+        println!(
+            "{} {}",
             Colour::Yellow.bold().paint(uwuize!("⚠ WARNING:")),
-                 Colour::Yellow.paint(uwuize!(&a)));
+            Colour::Yellow.paint(uwuize!(&a))
+        );
     } else {
-        println!("{} {}",
+        println!(
+            "{} {}",
             Colour::Yellow.bold().paint("⚠ WARNING:"),
-                 Colour::Yellow.paint(a));
+            Colour::Yellow.paint(a)
+        );
     }
 }

src/mods/uninstall.rs

@@ -1,33 +1,41 @@
+use crate::mods::strs::{err_rec, err_unrec, sec, succ};
 use runas::Command;
-use crate::mods::strs::{err_unrec, sec, succ, err_rec};
 use std::{fs, path::Path};
 
 pub fn uninstall(noconfirm: bool, pkgs: Vec<String>) {
-        sec(format!("Attempting to uninstall packages: {}", &pkgs.join(" ")));
+    sec(format!(
+        "Attempting to uninstall packages: {}",
+        &pkgs.join(" ")
+    ));
     if noconfirm == true {
-            let result = Command::new("pacman").arg("-Rs").args(&pkgs).arg("--noconfirm").status().expect("Couldn't call pacman");
+        let result = Command::new("pacman")
+            .arg("-Rs")
+            .args(&pkgs)
+            .arg("--noconfirm")
+            .status()
+            .expect("Couldn't call pacman");
         match result.code() {
-            Some(0) => {
+            Some(0) => succ(format!(
-                succ(format!("Succesfully uninstalled packages: {}", &pkgs.join(" ")))
+                "Succesfully uninstalled packages: {}",
-            }
+                &pkgs.join(" ")
-            Some(_) => {
+            )),
-                err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" ")))
+            Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
-            }
+            None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
-            None =>{
+        };
-                err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" ")))
-            }};
     } else {
-            let result = Command::new("pacman").arg("-Rs").args(&pkgs).status().expect("Couldn't call pacman");
+        let result = Command::new("pacman")
+            .arg("-Rs")
+            .args(&pkgs)
+            .status()
+            .expect("Couldn't call pacman");
         match result.code() {
-            Some(0) => {
+            Some(0) => succ(format!(
-                succ(format!("Succesfully uninstalled packages: {}", &pkgs.join(" ")))
+                "Succesfully uninstalled packages: {}",
-            }
+                &pkgs.join(" ")
-            Some(_) => {
+            )),
-                err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" ")))
+            Some(_) => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
-            }
+            None => err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" "))),
-            None =>{
+        };
-                err_rec(format!("Couldn't uninstall packages: {}", &pkgs.join(" ")))
-            }};
     }
     for pkg in &pkgs {
         let pkgdir = format!("{}/.cache/ame/{}", std::env::var("HOME").unwrap(), pkg);
@@ -35,12 +43,9 @@ pub fn uninstall(noconfirm: bool, pkgs: Vec<String>) {
         if path.is_dir() {
             let rm_result = fs::remove_dir_all(&path);
             match rm_result {
-                Ok(_) => {
+                Ok(_) => succ(format!("Removed AUR cache directory for {}", pkg)),
-                    succ(format!("Removed AUR cache directory for {}", pkg))
+                Err(_) => err_unrec(format!("Failed to remove AUR cache directory for {}", pkg)),
-                }
+            };
-                Err(_) => {
-                    err_unrec(format!("Failed to remove AUR cache directory for {}", pkg))
-                }};
         }
     }
 }

src/mods/update.rs

@@ -1,5 +1,5 @@
-use runas::Command;
 use crate::mods::strs::{err_unrec, sec, succ};
+use runas::Command;
 
 pub fn update() {
     sec(format!("Syncing package repos"));
@@ -9,13 +9,8 @@ pub fn update() {
         .status()
         .expect("Couldn't call pacman");
     match result.code() {
-    Some(0) => {
+        Some(0) => succ(format!("Repos succesfully synced")),
-        succ(format!("Repos succesfully synced"))
+        Some(_) => err_unrec(format!("Couldn't sync package repos")),
-    }
+        None => err_unrec(format!("Couldn't sync package repos")),
-    Some(_) => {
-        err_unrec(format!("Couldn't sync package repos"))
     }
-    None => {
-        err_unrec(format!("Couldn't sync package repos"))
-    }}
 }

src/mods/upgrade.rs

@@ -1,8 +1,8 @@
+use crate::mods::strs::{err_unrec, inf, sec, succ};
 use runas::Command;
 use std::env;
-use crate::mods::strs::{err_unrec, inf, sec, succ};
 
-pub fn upgrade(noconfirm: bool){
+pub fn upgrade(noconfirm: bool) {
     let homepath = std::env::var("HOME").unwrap();
     let cachedir = format!("/{}/.cache/ame/", homepath);
     sec(format!("Performing system upgrade"));
@@ -13,72 +13,63 @@ pub fn upgrade(noconfirm: bool){
             .status()
             .expect("Couldn't call pacman");
         match result.code() {
-        Some(0) => {
+            Some(0) => succ(format!("All repo packages upgraded")),
-            succ(format!("All repo packages upgraded"))
+            Some(_) => err_unrec(format!("Couldn't upgrade packages")),
-        }
+            None => err_unrec(format!("Couldn't upgrade packages")),
-        Some(_) => {
+        };
-            err_unrec(format!("Couldn't upgrade packages"))
-        }
-        None => {
-            err_unrec(format!("Couldn't upgrade packages"))
-        }};
     } else {
         let result = Command::new("pacman")
             .arg("-Syu")
             .status()
             .expect("Couldn't call pacman");
         match result.code() {
-        Some(0) => {
+            Some(0) => succ(format!("All repo packages upgraded")),
-            succ(format!("All repo packages upgraded"))
+            Some(_) => err_unrec(format!("Couldn't upgrade packages")),
-        }
+            None => err_unrec(format!("Couldn't upgrade packages")),
-        Some(_) => {
+        };
-            err_unrec(format!("Couldn't upgrade packages"))
-        }
-        None => {
-            err_unrec(format!("Couldn't upgrade packages"))
-        }};
     }
 
     for file in std::fs::read_dir(&cachedir).unwrap() {
         let dir = &file.unwrap().path();
-        let output = std::process::Command::new("git").arg("pull").output().unwrap();
+        let output = std::process::Command::new("git")
+            .arg("pull")
+            .output()
+            .unwrap();
         let update_available = String::from_utf8(output.stdout).unwrap();
 
         let cd_result = env::set_current_dir(&dir);
         match cd_result {
-        Ok(_) => {
+            Ok(_) => inf(format!("Entered AUR package directory to pull changes")),
-            inf(format!("Entered AUR package directory to pull changes"))
+            Err(_) => err_unrec(format!(
+                "Could not enter AUR package directory to pull changes"
+            )),
         }
-        Err(_) => {
-            err_unrec(format!("Could not enter AUR package directory to pull changes"))
-        }}
 
         if update_available != "Already up to date." {
             let path_as_str = &dir.display().to_string();
             let pkg: Vec<&str> = path_as_str.split("/").collect();
 
-            inf(format!("{} is up to date", pkg[pkg.len()-1]));
+            inf(format!("{} is up to date", pkg[pkg.len() - 1]));
         } else {
             let cd2_result = env::set_current_dir(&dir);
             match cd2_result {
-            Ok(_) => {
+                Ok(_) => inf(format!(
-                inf(format!("Entering AUR package directory to install new version"))
+                    "Entering AUR package directory to install new version"
+                )),
+                Err(_) => err_unrec(format!(
+                    "Couldn't enter AUR package directory to install new version"
+                )),
             }
-            Err(_) => {
-                err_unrec(format!("Couldn't enter AUR package directory to install new version"))
-            }}
 
-            let makepkg_result = std::process::Command::new("makepkg").arg("-si").status().expect("Couldn't call makepkg");
+            let makepkg_result = std::process::Command::new("makepkg")
+                .arg("-si")
+                .status()
+                .expect("Couldn't call makepkg");
             match makepkg_result.code() {
-            Some(0) => {
+                Some(0) => succ(format!("New AUR package version installed")),
-                succ(format!("New AUR package version installed"))
+                Some(_) => err_unrec(format!("Couldn't install new AUR package version")),
-            }
+                None => err_unrec(format!("Couldn't install new AUR package version")),
-            Some(_) => {
+            };
-                err_unrec(format!("Couldn't install new AUR package version"))
-            }
-            None => {
-                err_unrec(format!("Couldn't install new AUR package version"))
-            }};
         }
     }
 }

src/mods/ver.rs

@@ -3,7 +3,7 @@ use ansi_term::Colour;
 
 pub fn ver() {
     println!("");
-    inf(format!("ame - v2.3.1"));
+    inf(format!("ame - v2.4.0"));
     println!("");
     inf(format!("Contributors:"));
     println!("- axtlos <axtlos@salyut.one>");
@@ -11,9 +11,16 @@ pub fn ver() {
     println!("- jasio <jasiobene@icloud.com>");
     println!("- generic <mdc028@bucknell.edu>");
     println!("");
-    inf(format!("This software is licensed under the BSD 3-Clause license."));
+    inf(format!(
+        "This software is licensed under the BSD 3-Clause license."
+    ));
     inf(format!("All source code is available at:"));
     println!("");
-    println!("{}", Colour::Purple.bold().paint("https://github.com/crystal-linux/ame"));
+    println!(
+        "{}",
+        Colour::Purple
+            .bold()
+            .paint("https://github.com/crystal-linux/ame")
+    );
     println!("");
 }

src/mods/xargs.rs

@@ -4,7 +4,7 @@ pub fn noconf(args: &Vec<String>) -> bool {
     } else {
         false
     }
-    }
+}
 
 pub fn argssort(args: &mut Vec<String>) -> &Vec<String> {
     if args.contains(&"--noconfirm".to_string()) {
@@ -14,4 +14,4 @@ pub fn argssort(args: &mut Vec<String>) -> &Vec<String> {
     } else {
         args
     }
-    }
+}