Code cleanup round 2

osupdater/src/main.rs

@@ -3,6 +3,8 @@ use std::path::{Path};
 use color_print::{cprintln};
 use clap::{command, Arg, ArgAction};
 
+const VERSION: &'static str = "0.1";
+
 fn trim_newline(s: &mut String) {
     if s.ends_with('\n') {
         s.pop();
@@ -25,7 +27,7 @@ fn update_apt() {
 
     let path = Path::new(&apt_bin);
     if path.exists(){
-        cprintln!("<bold><rev>Updating via: apt</rev></bold>");
+        cprintln!("<bold><rev>osupdater: Updating via apt</rev></bold>");
         let mut cmd =
             Command::new(&sudo_bin)
             .arg(&apt_bin).arg("update").arg("-y")
@@ -41,6 +43,24 @@ fn update_apt() {
     }
 }
 
+fn update_distrobox() {
+    let find_distrobox_upgrade = Command::new("which")
+        .arg("distrobox-upgrade").stdout(Stdio::piped()).output().unwrap();
+    let mut distrobox_upgrade_bin = String::from_utf8(find_distrobox_upgrade.stdout).unwrap();
+    trim_newline(&mut distrobox_upgrade_bin);
+
+    let path = Path::new(&distrobox_upgrade_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Updating distrobox containers</rev></bold>");
+        let mut cmd =
+            Command::new(&distrobox_upgrade_bin)
+            .arg("--all")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
 fn update_dnf() {
     let find_sudo = Command::new("which")
         .arg("sudo").stdout(Stdio::piped()).output().unwrap();
@@ -61,8 +81,8 @@ fn update_dnf() {
     let path_dnf5 = Path::new(&dnf5_bin);
 
     if path_dnf5.exists() {
-        cprintln!("<bold><rev>dnf found but skipped since dnf5 is present</rev></bold>");
+        cprintln!("<bold><rev>osupdater: dnf found but skipped since dnf5 is present</rev></bold>");
-        cprintln!("<bold><rev>Updating via: dnf5</rev></bold>");
+        cprintln!("<bold><rev>osupdater: Updating via dnf5</rev></bold>");
         let mut cmd =
             Command::new(&sudo_bin)
             .arg(&dnf5_bin).arg("--refresh").arg("--nobest").arg("-y").arg("update")
@@ -70,7 +90,7 @@ fn update_dnf() {
             .spawn().unwrap();
         let _output = cmd.wait();
     } else if path_dnf.exists(){
-        cprintln!("<bold><rev>Updating via: dnf</rev></bold>");
+        cprintln!("<bold><rev>osupdater: Updating via dnf</rev></bold>");
         let mut cmd =
             Command::new(&sudo_bin)
             .arg(&dnf_bin).arg("--refresh").arg("--skip-broken").arg("--nobest").arg("-y").arg("update")
@@ -81,6 +101,44 @@ fn update_dnf() {
 
 }
 
+fn update_flatpak() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_flatpak = Command::new("which")
+        .arg("flatpak").stdout(Stdio::piped()).output().unwrap();
+    let mut flatpak_bin = String::from_utf8(find_flatpak.stdout).unwrap();
+    trim_newline(&mut flatpak_bin);
+
+    let path = Path::new(&flatpak_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Updating user flatpak installs</rev></bold>");
+        let mut cmd =
+            Command::new(&flatpak_bin)
+            .arg("update").arg("--user").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+    let path = Path::new(&flatpak_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Updating system flatpak installs</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&flatpak_bin).arg("update").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
 fn update_pacman() {
     let find_sudo = Command::new("which")
         .arg("sudo").stdout(Stdio::piped()).output().unwrap();
@@ -94,7 +152,7 @@ fn update_pacman() {
 
     let path = Path::new(&pacman_bin);
     if path.exists(){
-        cprintln!("<bold><rev>Updating via: pacman</rev></bold>");
+        cprintln!("<bold><rev>osupdater: Updating via pacman</rev></bold>");
         let mut cmd =
             Command::new(&sudo_bin)
             .arg(&pacman_bin).arg("-Syu")
@@ -105,6 +163,110 @@ fn update_pacman() {
 
 }
 
+fn update_podman() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_podman = Command::new("which")
+        .arg("podman").stdout(Stdio::piped()).output().unwrap();
+    let mut podman_bin = String::from_utf8(find_podman.stdout).unwrap();
+    trim_newline(&mut podman_bin);
+
+    let path = Path::new(&podman_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Updating podman system containers</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&podman_bin).arg("auto-update")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+
+    if path.exists(){
+         cprintln!("<bold><rev>osupdater: Updating podman user containers</rev></bold>");
+         let mut cmd =
+             Command::new(&podman_bin)
+             .arg("auto-update")
+             .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+             .spawn().unwrap();
+         let _output = cmd.wait();
+     }
+
+     if path.exists(){
+         cprintln!("<bold><rev>osupdater: Pruning podman system containers</rev></bold>");
+         let mut cmd =
+             Command::new(&sudo_bin)
+             .arg(&podman_bin).arg("system").arg("prune").arg("-af")
+             .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+             .spawn().unwrap();
+         let _output = cmd.wait();
+     }
+
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Pruning podman user containers</rev></bold>");
+        let mut cmd =
+            Command::new(&podman_bin)
+            .arg("system").arg("prune").arg("-af")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_python() {
+    let find_pip_review = Command::new("which")
+        .arg("pip-review").stdout(Stdio::piped()).output().unwrap();
+    let mut pip_review_bin = String::from_utf8(find_pip_review.stdout).unwrap();
+    trim_newline(&mut pip_review_bin);
+
+    let path = Path::new(&pip_review_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Updating Python user installation via pip-review</rev></bold>");
+        let mut cmd =
+            Command::new(&pip_review_bin)
+            .arg("--auto").arg("--local").arg("--user")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
+fn update_snap() {
+    let find_sudo = Command::new("which")
+        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
+    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
+    trim_newline(&mut sudo_bin);
+
+    let find_snap = Command::new("which")
+        .arg("snap").stdout(Stdio::piped()).output().unwrap();
+    let mut snap_bin = String::from_utf8(find_snap.stdout).unwrap();
+    trim_newline(&mut snap_bin);
+
+    let path = Path::new(&snap_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Updating user snap installation</rev></bold>");
+        let mut cmd =
+            Command::new(&snap_bin)
+            .arg("refresh").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+    let path = Path::new(&snap_bin);
+    if path.exists(){
+        cprintln!("<bold><rev>osupdater: Updating system snap installation</rev></bold>");
+        let mut cmd =
+            Command::new(&sudo_bin)
+            .arg(&snap_bin).arg("refresh").arg("-y")
+            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
+            .spawn().unwrap();
+        let _output = cmd.wait();
+    }
+}
+
 fn update_urpmi() {
     let find_sudo = Command::new("which")
         .arg("sudo").stdout(Stdio::piped()).output().unwrap();
@@ -118,7 +280,7 @@ fn update_urpmi() {
 
     let path = Path::new(&urpmi_bin);
     if path.exists(){
-        cprintln!("<bold><rev>Updating via urpmi</rev></bold>");
+        cprintln!("<bold><rev>osupdater: Updating via urpmi</rev></bold>");
         let mut cmd =
             Command::new(&sudo_bin)
             .arg(&urpmi_bin).arg("--auto-update").arg("-y")
@@ -141,7 +303,7 @@ fn update_zypper() {
 
     let path = Path::new(&zypper_bin);
     if path.exists(){
-        cprintln!("<bold><rev>Updating via: zypper</rev></bold>");
+        cprintln!("<bold><rev>osupdater: Updating via zypper</rev></bold>");
         let mut cmd =
             Command::new(&sudo_bin)
             .arg(&zypper_bin).arg("up").arg("-y")
@@ -151,191 +313,39 @@ fn update_zypper() {
     }
 }
 
-fn update_flatpak() {
-    let find_sudo = Command::new("which")
-        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
-    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
-    trim_newline(&mut sudo_bin);
-
-    let find_sudo = Command::new("which")
-        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
-    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
-    trim_newline(&mut sudo_bin);
-
-    let find_flatpak = Command::new("which")
-        .arg("flatpak").stdout(Stdio::piped()).output().unwrap();
-    let mut flatpak_bin = String::from_utf8(find_flatpak.stdout).unwrap();
-    trim_newline(&mut flatpak_bin);
-
-    let path = Path::new(&flatpak_bin);
-    if path.exists(){
-        cprintln!("<bold><rev>Updating user flatpak installs</rev></bold>");
-        let mut cmd =
-            Command::new(&flatpak_bin)
-            .arg("update").arg("--user").arg("-y")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-    let path = Path::new(&flatpak_bin);
-    if path.exists(){
-        cprintln!("<bold><rev>Updating system flatpak installs</rev></bold>");
-        let mut cmd =
-            Command::new(&sudo_bin)
-            .arg(&flatpak_bin).arg("update").arg("-y")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-}
-
-fn update_snap() {
-    let find_sudo = Command::new("which")
-        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
-    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
-    trim_newline(&mut sudo_bin);
-
-    let find_snap = Command::new("which")
-        .arg("snap").stdout(Stdio::piped()).output().unwrap();
-    let mut snap_bin = String::from_utf8(find_snap.stdout).unwrap();
-    trim_newline(&mut snap_bin);
-
-    let path = Path::new(&snap_bin);
-    if path.exists(){
-        cprintln!("<bold><rev>Updating user snap installation</rev></bold>");
-        let mut cmd =
-            Command::new(&snap_bin)
-            .arg("refresh").arg("-y")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-    let path = Path::new(&snap_bin);
-    if path.exists(){
-        cprintln!("<bold><rev>Updating system snap installation</rev></bold>");
-        let mut cmd =
-            Command::new(&sudo_bin)
-            .arg(&snap_bin).arg("refresh").arg("-y")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-}
-
-fn update_python() {
-    let find_pip_review = Command::new("which")
-        .arg("pip-review").stdout(Stdio::piped()).output().unwrap();
-    let mut pip_review_bin = String::from_utf8(find_pip_review.stdout).unwrap();
-    trim_newline(&mut pip_review_bin);
-
-    let path = Path::new(&pip_review_bin);
-    if path.exists(){
-        cprintln!("<bold><rev>Updating Python user installation via pip-review</rev></bold>");
-        let mut cmd =
-            Command::new(&pip_review_bin)
-            .arg("--auto").arg("--local").arg("--user")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-}
-
-fn update_distrobox() {
-    let find_distrobox_upgrade = Command::new("which")
-        .arg("distrobox-upgrade").stdout(Stdio::piped()).output().unwrap();
-    let mut distrobox_upgrade_bin = String::from_utf8(find_distrobox_upgrade.stdout).unwrap();
-    trim_newline(&mut distrobox_upgrade_bin);
-
-    let path = Path::new(&distrobox_upgrade_bin);
-    if path.exists(){
-        cprintln!("<bold><rev>Updating Distrobox containers</rev></bold>");
-        let mut cmd =
-            Command::new(&distrobox_upgrade_bin)
-            .arg("--all")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-}
-
-fn update_podman() {
-    let find_sudo = Command::new("which")
-        .arg("sudo").stdout(Stdio::piped()).output().unwrap();
-    let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
-    trim_newline(&mut sudo_bin);
-
-    let find_podman = Command::new("which")
-        .arg("podman").stdout(Stdio::piped()).output().unwrap();
-    let mut podman_bin = String::from_utf8(find_podman.stdout).unwrap();
-    trim_newline(&mut podman_bin);
-
-    let path = Path::new(&podman_bin);
-    if path.exists(){
-        cprintln!("<bold><rev>Updating Podman system containers</rev></bold>");
-        let mut cmd =
-            Command::new(&sudo_bin)
-            .arg(&podman_bin).arg("auto-update")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-
-    if path.exists(){
-         cprintln!("<bold><rev>Updating Podman user containers</rev></bold>");
-         let mut cmd =
-             Command::new(&podman_bin)
-             .arg("auto-update")
-             .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-             .spawn().unwrap();
-         let _output = cmd.wait();
-     }
-
-     if path.exists(){
-         cprintln!("<bold><rev>Pruning Podman system containers</rev></bold>");
-         let mut cmd =
-             Command::new(&sudo_bin)
-             .arg(&podman_bin).arg("system").arg("prune").arg("-af")
-             .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-             .spawn().unwrap();
-         let _output = cmd.wait();
-     }
-
-    if path.exists(){
-        cprintln!("<bold><rev>Pruning Podman user containers</rev></bold>");
-        let mut cmd =
-            Command::new(&podman_bin)
-            .arg("system").arg("prune").arg("-af")
-            .stdout(Stdio::inherit()).stderr(Stdio::inherit())
-            .spawn().unwrap();
-        let _output = cmd.wait();
-    }
-}
-
 fn update_all() {
     // Tell user that we are going to start the update procedure
+    cprintln!("<bold><rev>osupdater: osupdater v{} written by Andrew Schott andrew@schotty.com </rev></bold>\n",&VERSION);
     cprintln!("<bold><rev>osupdater: This tool will locate and run any package/container managers on your system.</rev></bold>\n");
+    cprintln!("<bold><rev>osupdater: This tool will alphabetically iterate thru your:</rev></bold>\n");
+    cprintln!("<bold><rev>osupdater: * package managers</rev></bold>\n");
+    cprintln!("<bold><rev>osupdater: * application sandboxes</rev></bold>\n");
+    cprintln!("<bold><rev>osupdater: * containers</rev></bold>\n");
+    cprintln!("<bold><rev>---------------------------------------------------------------------------------------</rev></bold>\n");
 
     // Check package managers
-    cprintln!("<bold><rev>Looking for native package managers.</rev></bold>\n");
+    cprintln!("<bold><rev>osupdater: Looking for native package managers.</rev></bold>\n");
     update_apt();
     update_dnf();
     update_pacman();
     update_urpmi();
     update_zypper();
 
-    // Check container formats
+    // Check application sandboxes
-    cprintln!("<bold><rev>Checking application containers</rev></bold>");
+    cprintln!("<bold><rev>osupdater: Checking application containers</rev></bold>");
     update_flatpak();
-    update_snap();
     update_python();
+    update_snap();
+
+    // Check container formats
+    cprintln!("<bold><rev>osupdater: Checking containers</rev></bold>");
     update_distrobox();
     update_podman();
 }
 
-
 fn main() {
 
-    // Clear termianl, and move cursor to 1,1 inside the terminal
+    // Clear terminal, and move cursor to 1,1 inside the terminal
     // print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
 
     // Find sudo
@@ -344,9 +354,7 @@ fn main() {
     let mut sudo_bin = String::from_utf8(find_sudo.stdout).unwrap();
     trim_newline(&mut sudo_bin);
 
-    // update_all();
+    // Set CLI parameters
-
-
     let matches = command!()
     .arg(
         Arg::new("UPDATE_TOOL")
@@ -357,17 +365,18 @@ fn main() {
             .action(ArgAction::Append)
             ,
     )
-    .version("0.1")
+    .version(&VERSION)
     .about("Update your OS packages, sandboxes, and containers via your present tools.")
     .get_matches();
 
-
+    // Get the parameters into a vec for later parsing
     let args = matches
         .get_many::<String>("UPDATE_TOOL")
         .unwrap_or_default()
         .map(|v| v.as_str())
         .collect::<Vec<_>>();
 
+    // Parse the array for any updater tool
     if args.contains(&"all") {
         update_all()
     }