rustfmt

src/main.rs

@@ -8,6 +8,8 @@ use mods::{
     install::install,
     purge::{purge, purge_from_file},
     search::{a_search, r_search},
+    stat_database::*,
+    statpkgs::*,
     strs::err_rec,
     strs::err_unrec,
     strs::inf,
@@ -16,13 +18,10 @@ use mods::{
     upgrade::upgrade,
     ver::ver,
     xargs::*,
-    statpkgs::*,
-    stat_database::*,
 };
 use std::{env, process::exit};
 
 fn main() {
-
     extern "C" {
         fn geteuid() -> u32;
     }

src/mods.rs

@@ -5,13 +5,13 @@ pub mod help;
 pub mod inssort;
 pub mod install;
 pub mod purge;
+pub mod rpc;
 pub mod search;
-pub mod statpkgs;
 pub mod stat_database;
+pub mod statpkgs;
 pub mod strs;
 pub mod uninstall;
 pub mod update;
 pub mod upgrade;
 pub mod ver;
 pub mod xargs;
-pub mod rpc;

src/mods/clone.rs

@@ -1,6 +1,6 @@
 use crate::{
-    err_unrec, inf, mods::database::add_pkg, mods::purge::purge, mods::strs::prompt,
-    mods::strs::sec, mods::strs::succ, mods::rpc::*
+    err_unrec, inf, mods::database::add_pkg, mods::purge::purge, mods::rpc::*, mods::strs::prompt,
+    mods::strs::sec, mods::strs::succ,
 };
 use moins::Moins;
 use std::{env, fs, path::Path, process::Command};

src/mods/install.rs

@@ -1,5 +1,5 @@
-use crate::mods::strs::{err_unrec, succ};
 use crate::mods::database::add_pkg;
+use crate::mods::strs::{err_unrec, succ};
 use runas::Command;
 
 pub fn install(noconfirm: bool, as_dep: bool, pkg: &str) {
@@ -18,7 +18,7 @@ pub fn install(noconfirm: bool, as_dep: bool, pkg: &str) {
                 Some(0) => {
                     succ(format!("Succesfully installed packages: {}", pkg));
                     add_pkg(true, &pkgs);
-                },
+                }
                 Some(_) => err_unrec(format!("Couldn't install packages: {}", pkg)),
                 None => err_unrec(format!("Couldn't install packages: {}", pkg)),
             };
@@ -33,7 +33,7 @@ pub fn install(noconfirm: bool, as_dep: bool, pkg: &str) {
                 Some(0) => {
                     succ(format!("Succesfully installed packages: {}", pkg));
                     add_pkg(true, &pkgs);
-                },
+                }
                 Some(_) => err_unrec(format!("Couldn't install packages: {}", pkg)),
                 None => err_unrec(format!("Couldn't install packages: {}", pkg)),
             };
@@ -51,7 +51,7 @@ pub fn install(noconfirm: bool, as_dep: bool, pkg: &str) {
             Some(0) => {
                 succ(format!("Succesfully installed packages: {}", pkg));
                 add_pkg(true, &pkgs);
-            },
+            }
             Some(_) => err_unrec(format!("Couldn't install packages: {}", pkg)),
             None => err_unrec(format!("Couldn't install packages: {}", pkg)),
         };

src/mods/rpc.rs

@@ -1,39 +1,41 @@
-#[derive(serde::Deserialize, Debug)]
-pub struct Package {
-    #[serde(rename = "Name")]
-    pub name: String,
-    #[serde(rename = "Version")]
-    pub version: String,
-    #[serde(rename = "Description")]
-    pub description: Option<String>,
-    #[serde(default)]
-    #[serde(rename = "Depends")]
-    pub depends: Vec<String>,
-    #[serde(default)]
-    #[serde(rename = "MakeDepends")]
-    pub make_depends: Vec<String>
-}
-
-#[derive(serde::Deserialize)]
-pub struct SearchResults {
-    pub resultcount: u32,
-    pub results: Vec<Package>
-}
-
-pub fn rpcinfo(pkg: &str) -> Package {
-    let res = reqwest::blocking::get(&format!(
-        "https://aur.archlinux.org/rpc/?v=5&type=info&arg={}",
-        pkg
-    )).unwrap();
-    
-    res.json().unwrap()
-}
-
-pub fn rpcsearch(pkg: &str) -> SearchResults {
-    let res = reqwest::blocking::get(&format!(
-        "https://aur.archlinux.org/rpc/?v=5&type=search&arg={}",
-        pkg
-    )).unwrap();
-
-    res.json().unwrap()
-}
+#[derive(serde::Deserialize, Debug)]
+pub struct Package {
+    #[serde(rename = "Name")]
+    pub name: String,
+    #[serde(rename = "Version")]
+    pub version: String,
+    #[serde(rename = "Description")]
+    pub description: Option<String>,
+    #[serde(default)]
+    #[serde(rename = "Depends")]
+    pub depends: Vec<String>,
+    #[serde(default)]
+    #[serde(rename = "MakeDepends")]
+    pub make_depends: Vec<String>,
+}
+
+#[derive(serde::Deserialize)]
+pub struct SearchResults {
+    pub resultcount: u32,
+    pub results: Vec<Package>,
+}
+
+pub fn rpcinfo(pkg: &str) -> Package {
+    let res = reqwest::blocking::get(&format!(
+        "https://aur.archlinux.org/rpc/?v=5&type=info&arg={}",
+        pkg
+    ))
+    .unwrap();
+
+    res.json().unwrap()
+}
+
+pub fn rpcsearch(pkg: &str) -> SearchResults {
+    let res = reqwest::blocking::get(&format!(
+        "https://aur.archlinux.org/rpc/?v=5&type=search&arg={}",
+        pkg
+    ))
+    .unwrap();
+
+    res.json().unwrap()
+}

src/mods/search.rs

@@ -1,5 +1,5 @@
-use crate::mods::strs::{err_rec, err_unrec, succ};
 use crate::mods::rpc::*;
+use crate::mods::strs::{err_rec, err_unrec, succ};
 use ansi_term::Colour;
 use std::process::Command;
 
@@ -16,7 +16,11 @@ pub fn a_search(pkg: &str) {
             Colour::Cyan.bold().paint("aur/"),
             Colour::White.bold().paint(&r.name),
             Colour::Green.bold().paint(&r.version),
-            Colour::White.paint(r.description.as_ref().unwrap_or(&"No description available".to_string()))
+            Colour::White.paint(
+                r.description
+                    .as_ref()
+                    .unwrap_or(&"No description available".to_string())
+            )
         );
     }
     if !results.is_empty() {

src/mods/stat_database.rs

@@ -5,20 +5,17 @@ pub fn stat_dump_dat() -> Vec<String> {
     let file = format!("{}/.local/share/ame/aur_pkgs.db", env::var("HOME").unwrap());
     let connection = sqlite::open(file).unwrap();
     let mut dat_pkgs = Vec::new();
-    let result = connection
-        .iterate("SELECT name FROM static_pkgs", |pairs| {
-            for &(_column, value) in pairs.iter() {
-                dat_pkgs.push(value.unwrap().to_string());
-            }
-            true
-        });
+    let result = connection.iterate("SELECT name FROM static_pkgs", |pairs| {
+        for &(_column, value) in pairs.iter() {
+            dat_pkgs.push(value.unwrap().to_string());
+        }
+        true
+    });
     match result {
         Ok(_) => {
             //inf("Dumped static packages".to_string());
         }
-        Err(_) => {
-            err_unrec("Couldn't dump packages from database".to_string())
-        }
+        Err(_) => err_unrec("Couldn't dump packages from database".to_string()),
     }
     dat_pkgs
 }
@@ -29,36 +26,38 @@ pub fn stat_get_value(pkg: &str, sear_value: &str) -> bool {
     let mut return_val = false;
     match sear_value {
         "name" => {
-            let result = connection.iterate(format!("SELECT name FROM static_pkgs WHERE name = \"{}\";",&pkg), |pairs| { 
-                for &(_column, _value) in pairs.iter() {
-                    return_val = true;
-                }
-                return_val
-            }
+            let result = connection.iterate(
+                format!("SELECT name FROM static_pkgs WHERE name = \"{}\";", &pkg),
+                |pairs| {
+                    for &(_column, _value) in pairs.iter() {
+                        return_val = true;
+                    }
+                    return_val
+                },
             );
             match result {
-                Ok(_) => {},
+                Ok(_) => {}
                 Err(_) => err_unrec("Couldn't get value from database".to_string()),
             }
             return return_val;
-        },
+        }
         "update" => {
-            let result = connection.iterate(format!("SELECT pin FROM static_pkgs WHERE name = \"{}\";",&pkg), |pairs| { 
-                for &(_column, _value) in pairs.iter() {
-                    return_val = true;
-                }
-                return_val
-            }
+            let result = connection.iterate(
+                format!("SELECT pin FROM static_pkgs WHERE name = \"{}\";", &pkg),
+                |pairs| {
+                    for &(_column, _value) in pairs.iter() {
+                        return_val = true;
+                    }
+                    return_val
+                },
             );
             match result {
-                Ok(_) => {},
+                Ok(_) => {}
                 Err(_) => err_unrec("Couldn't get value from database".to_string()),
             }
-            return return_val
-        },
-        _ => {
-            return_val = false
+            return return_val;
         }
+        _ => return_val = false,
     }
     return_val
 }
@@ -66,20 +65,20 @@ pub fn stat_get_value(pkg: &str, sear_value: &str) -> bool {
 pub fn stat_rem_pkg(static_pkgs: &[String]) {
     let file = format!("{}/.local/share/ame/aur_pkgs.db", env::var("HOME").unwrap());
     let connection = sqlite::open(file).unwrap();
-    print!("{:?}",static_pkgs);
+    print!("{:?}", static_pkgs);
     for i in static_pkgs {
-        let result = connection.execute(
-            format!("
+        let result = connection.execute(format!(
+            "
             DELETE FROM static_pkgs WHERE name = \"{}\";
-            ", i),
-        );
-        match result{
-            Ok(_) => {
-                inf(format!("Removed {} from database", i))
-            }
-            Err(_) => {
-                err_unrec(format!("Couldn't remove {} from database (static packages table)", i))
-            }
+            ",
+            i
+        ));
+        match result {
+            Ok(_) => inf(format!("Removed {} from database", i)),
+            Err(_) => err_unrec(format!(
+                "Couldn't remove {} from database (static packages table)",
+                i
+            )),
         }
     }
 }
@@ -88,17 +87,14 @@ pub fn stat_add_pkg(update: &str, pkg: &str) {
     let file = format!("{}/.local/share/ame/aur_pkgs.db", env::var("HOME").unwrap());
     let connection = sqlite::open(file).unwrap();
     let pin = if update == "true" { 1 } else { 0 };
-    let result = connection.execute(
-        format!("
+    let result = connection.execute(format!(
+        "
         INSERT INTO static_pkgs (name, pin) VALUES (\"{}\", {});
-        ", pkg, pin),
-    );
-    match result{
-        Ok(_) => {
-            inf(format!("Added {} to database", pkg))
-        }
-        Err(_) => {
-            err_unrec(format!("Couldn't add {} to database", pkg))
-        }
+        ",
+        pkg, pin
+    ));
+    match result {
+        Ok(_) => inf(format!("Added {} to database", pkg)),
+        Err(_) => err_unrec(format!("Couldn't add {} to database", pkg)),
     }
-}
+}

src/mods/statpkgs.rs

@@ -1,14 +1,8 @@
-use std::{fs, env};
 use crate::inf;
 use crate::{
-    err_rec,
-    stat_add_pkg,
-    stat_get_value,
-    stat_rem_pkg,
-    inssort,
-    stat_dump_dat,
-    uninstall,
+    err_rec, inssort, stat_add_pkg, stat_dump_dat, stat_get_value, stat_rem_pkg, uninstall,
 };
+use std::{env, fs};
 
 pub fn rebuild(noconfirm: bool) {
     let file = format!("{}/.config/ame/pkgs.toml", env::var("HOME").unwrap());
@@ -17,12 +11,13 @@ pub fn rebuild(noconfirm: bool) {
 
     let file = format!("{}/.local/share/ame/aur_pkgs.db", env::var("HOME").unwrap());
     let connection = sqlite::open(file).unwrap();
-    connection.execute(
-        "
+    connection
+        .execute(
+            "
         CREATE TABLE IF NOT EXISTS static_pkgs (name TEXT, pin INTEGER);
         ",
-    )
-    .unwrap();
+        )
+        .unwrap();
 
     let db_parsed = database.parse::<toml::Value>().expect("Invalid Database");
     let mut pkgs = Vec::new();
@@ -32,7 +27,7 @@ pub fn rebuild(noconfirm: bool) {
             // println!("{}", key);
             // println!("{}", format!("{}",value).replace("update = ", ""));
             tempvec.push(key.to_string());
-            tempvec.push(format!("{}",value).replace("update = ", ""));
+            tempvec.push(format!("{}", value).replace("update = ", ""));
             pkgs.push(tempvec);
         }
     }
@@ -81,4 +76,4 @@ pub fn rebuild(noconfirm: bool) {
     } else {
         err_rec("Configuration not changed!".to_string());
     }
-}
+}

src/mods/uninstall.rs

@@ -26,7 +26,7 @@ pub fn uninstall(noconfirm: bool, pkgs: Vec<String>) {
         "archlinux-keyring",
         "btrfs-progs",
         "timeshift",
-        "timeshift-autosnap"
+        "timeshift-autosnap",
     ];
 
     let mut overrides: Vec<String> = Vec::new();

src/mods/upgrade.rs

@@ -1,6 +1,6 @@
 use crate::{
-    err_rec, err_unrec, inf, inssort, mods::database::get_value, mods::strs::prompt,
-    mods::strs::sec, mods::strs::succ, uninstall, mods::rpc::*
+    err_rec, err_unrec, inf, inssort, mods::database::get_value, mods::rpc::*, mods::strs::prompt,
+    mods::strs::sec, mods::strs::succ, uninstall,
 };
 use runas::Command;
 use std::{env, fs, path::Path};
@@ -79,102 +79,18 @@ pub fn upgrade(noconfirm: bool) {
     if let Some(entry) = db_parsed.as_table() {
         for (key, _value) in &*entry {
             let results = rpcsearch(&key.to_string()).results;
-                let url = format!("https://aur.archlinux.org/{}.git", key);
-                let package = rpcinfo(&key.to_string());
-                let version = get_value(key, "version");
-                if results[0].version.contains(&version) {
-                    let keydir = format!("{}{}", &cachedir, &key);
-                    if Path::new(&keydir).is_dir() {
-                        let cd_result = env::set_current_dir(&keydir);
-                        match cd_result {
-                            Ok(_) => inf("Entered package directory".to_string()),
-                            Err(_) => err_unrec("Could not enter package directory".to_string()),
-                        }
-                        inssort(true, true, package.depends.clone());
-
-                        sec(format!("Installing {} ...", &key));
-                        let install_result = std::process::Command::new("makepkg")
-                            .arg("-si")
-                            .arg("--noconfirm")
-                            .arg("--needed")
-                            .status();
-                        match install_result {
-                            Ok(_) => {
-                                uninstall_make_depend(key);
-                            }
-                            Err(_) => {
-                                err_unrec(format!("Couldn't install {}", &key));
-                            }
-                        };
-
-                        sec(format!("Installing {} ...", &key));
-                        let install_result = std::process::Command::new("makepkg")
-                            .arg("-si")
-                            .arg("--needed")
-                            .status()
-                            .expect("Couldn't call makepkg");
-                        match install_result.code() {
-                            Some(0) => {
-                                uninstall_make_depend(key);
-                            }
-                            Some(_) => {
-                                err_unrec(format!("Couldn't install {}", &key));
-                            }
-                            None => {
-                                err_unrec(format!("Couldn't install {}", &key));
-                            }
-                        };
-                    } else {
-                        inf(format!("Cloning {} ...", &key));
-
-                        if Path::new(&keydir).is_dir() {
-                            let rm_result = fs::remove_dir_all(&keydir);
-                            match rm_result {
-                                    Ok(_) => inf(format!(
-                                        "Package path for {} already found. Removing to reinstall",
-                                        &key
-                                    )),
-                                    Err(_) => err_unrec(format!(
-                                        "Package path for {} already found, but could not remove to reinstall",
-                                        &key
-                                    )),
-                                }
-                        }
-
-                        let dir_result = fs::create_dir(&keydir);
-                        match dir_result {
-                            Ok(_) => inf(format!("Created package directory for {}", &key)),
-                            Err(_) => {
-                                err_unrec(format!("Couldn't create package directory for {}", &key))
-                            }
-                        }
-
-                        let cd_result = env::set_current_dir(&keydir);
-                        match cd_result {
-                            Ok(_) => inf("Entered package directory".to_string()),
-                            Err(_) => err_unrec("Could not enter package directory".to_string()),
-                        }
-
-                        inssort(true, true, package.depends.clone());
-
-                        let clone = std::process::Command::new("git")
-                            .arg("clone")
-                            .arg(&url)
-                            .arg(&keydir)
-                            .status()
-                            .expect("Couldn't clone repo");
-                        match clone.code() {
-                            Some(0) => {
-                                inf(format!("Cloning {} into package directory", &key));
-                            }
-                            Some(_) => {
-                                err_unrec(format!("Failed cloning {} into package directory", &key))
-                            }
-                            _ => {
-                                err_unrec(format!("Failed cloning {} into package directory", &key))
-                            }
-                        }
+            let url = format!("https://aur.archlinux.org/{}.git", key);
+            let package = rpcinfo(&key.to_string());
+            let version = get_value(key, "version");
+            if results[0].version.contains(&version) {
+                let keydir = format!("{}{}", &cachedir, &key);
+                if Path::new(&keydir).is_dir() {
+                    let cd_result = env::set_current_dir(&keydir);
+                    match cd_result {
+                        Ok(_) => inf("Entered package directory".to_string()),
+                        Err(_) => err_unrec("Could not enter package directory".to_string()),
                     }
+                    inssort(true, true, package.depends.clone());
 
                     sec(format!("Installing {} ...", &key));
                     let install_result = std::process::Command::new("makepkg")
@@ -190,6 +106,7 @@ pub fn upgrade(noconfirm: bool) {
                             err_unrec(format!("Couldn't install {}", &key));
                         }
                     };
+
                     sec(format!("Installing {} ...", &key));
                     let install_result = std::process::Command::new("makepkg")
                         .arg("-si")
@@ -208,9 +125,89 @@ pub fn upgrade(noconfirm: bool) {
                         }
                     };
                 } else {
-                    inf(format!("Package {} already up to date", &key));
+                    inf(format!("Cloning {} ...", &key));
+
+                    if Path::new(&keydir).is_dir() {
+                        let rm_result = fs::remove_dir_all(&keydir);
+                        match rm_result {
+                                    Ok(_) => inf(format!(
+                                        "Package path for {} already found. Removing to reinstall",
+                                        &key
+                                    )),
+                                    Err(_) => err_unrec(format!(
+                                        "Package path for {} already found, but could not remove to reinstall",
+                                        &key
+                                    )),
+                                }
+                    }
+
+                    let dir_result = fs::create_dir(&keydir);
+                    match dir_result {
+                        Ok(_) => inf(format!("Created package directory for {}", &key)),
+                        Err(_) => {
+                            err_unrec(format!("Couldn't create package directory for {}", &key))
+                        }
+                    }
+
+                    let cd_result = env::set_current_dir(&keydir);
+                    match cd_result {
+                        Ok(_) => inf("Entered package directory".to_string()),
+                        Err(_) => err_unrec("Could not enter package directory".to_string()),
+                    }
+
+                    inssort(true, true, package.depends.clone());
+
+                    let clone = std::process::Command::new("git")
+                        .arg("clone")
+                        .arg(&url)
+                        .arg(&keydir)
+                        .status()
+                        .expect("Couldn't clone repo");
+                    match clone.code() {
+                        Some(0) => {
+                            inf(format!("Cloning {} into package directory", &key));
+                        }
+                        Some(_) => {
+                            err_unrec(format!("Failed cloning {} into package directory", &key))
+                        }
+                        _ => err_unrec(format!("Failed cloning {} into package directory", &key)),
+                    }
                 }
-        
+
+                sec(format!("Installing {} ...", &key));
+                let install_result = std::process::Command::new("makepkg")
+                    .arg("-si")
+                    .arg("--noconfirm")
+                    .arg("--needed")
+                    .status();
+                match install_result {
+                    Ok(_) => {
+                        uninstall_make_depend(key);
+                    }
+                    Err(_) => {
+                        err_unrec(format!("Couldn't install {}", &key));
+                    }
+                };
+                sec(format!("Installing {} ...", &key));
+                let install_result = std::process::Command::new("makepkg")
+                    .arg("-si")
+                    .arg("--needed")
+                    .status()
+                    .expect("Couldn't call makepkg");
+                match install_result.code() {
+                    Some(0) => {
+                        uninstall_make_depend(key);
+                    }
+                    Some(_) => {
+                        err_unrec(format!("Couldn't install {}", &key));
+                    }
+                    None => {
+                        err_unrec(format!("Couldn't install {}", &key));
+                    }
+                };
+            } else {
+                inf(format!("Package {} already up to date", &key));
+            }
         }
     }
 }

src/mods/ver.rs

@@ -2,7 +2,6 @@ use crate::inf;
 use ansi_term::Colour;
 
 pub fn ver() {
-
     const VERSION: &str = env!("CARGO_PKG_VERSION");
 
     // print version and contributors