Support rust 1.51.0 (#789)

src/steps/os/dragonfly.rs

@@ -10,7 +10,7 @@ pub fn upgrade_packages(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()>
     print_separator("DrgaonFly BSD Packages");
     run_type
         .execute(sudo)
-        .args(["/usr/local/sbin/pkg", "upgrade"])
+        .args(&["/usr/local/sbin/pkg", "upgrade"])
         .check_run()
 }
 
@@ -18,7 +18,7 @@ pub fn audit_packages(sudo: &Option<PathBuf>) -> Result<()> {
     if let Some(sudo) = sudo {
         println!();
         Command::new(sudo)
-            .args(["/usr/local/sbin/pkg", "audit", "-Fr"])
+            .args(&["/usr/local/sbin/pkg", "audit", "-Fr"])
             .spawn()?
             .wait()?;
     }

src/steps/os/freebsd.rs

@@ -10,21 +10,21 @@ pub fn upgrade_freebsd(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()>
     print_separator("FreeBSD Update");
     run_type
         .execute(sudo)
-        .args(["/usr/sbin/freebsd-update", "fetch", "install"])
+        .args(&["/usr/sbin/freebsd-update", "fetch", "install"])
         .check_run()
 }
 
 pub fn upgrade_packages(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
     let sudo = require_option(sudo, String::from("No sudo detected"))?;
     print_separator("FreeBSD Packages");
-    run_type.execute(sudo).args(["/usr/sbin/pkg", "upgrade"]).check_run()
+    run_type.execute(sudo).args(&["/usr/sbin/pkg", "upgrade"]).check_run()
 }
 
 pub fn audit_packages(sudo: &Option<PathBuf>) -> Result<()> {
     if let Some(sudo) = sudo {
         println!();
         Command::new(sudo)
-            .args(["/usr/sbin/pkg", "audit", "-Fr"])
+            .args(&["/usr/sbin/pkg", "audit", "-Fr"])
             .spawn()?
             .wait()?;
     }

src/steps/os/linux.rs

@@ -46,12 +46,12 @@ impl Distribution {
 
         Ok(match id {
             Some("alpine") => Distribution::Alpine,
-            Some("centos" | "rhel" | "ol") => Distribution::CentOS,
+            Some("centos") | Some("rhel") | Some("ol") => Distribution::CentOS,
             Some("clear-linux-os") => Distribution::ClearLinux,
             Some("fedora") => Distribution::Fedora,
             Some("void") => Distribution::Void,
-            Some("debian" | "pureos") => Distribution::Debian,
-            Some("arch" | "anarchy" | "manjaro-arm" | "garuda" | "artix") => Distribution::Arch,
+            Some("debian") | Some("pureos") => Distribution::Debian,
+            Some("arch") | Some("anarchy") | Some("manjaro-arm") | Some("garuda") | Some("artix") => Distribution::Arch,
             Some("solus") => Distribution::Solus,
             Some("gentoo") => Distribution::Gentoo,
             Some("exherbo") => Distribution::Exherbo,
@@ -179,12 +179,12 @@ fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/zypper", "refresh"])
+            .args(&["/usr/bin/zypper", "refresh"])
             .check_run()?;
 
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/zypper", "dist-upgrade"])
+            .args(&["/usr/bin/zypper", "dist-upgrade"])
             .check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -197,12 +197,12 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/xbps-install", "-Su", "xbps"])
+            .args(&["/usr/bin/xbps-install", "-Su", "xbps"])
             .check_run()?;
 
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/xbps-install", "-u"])
+            .args(&["/usr/bin/xbps-install", "-u"])
             .check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -216,13 +216,13 @@ fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
 
     if let Some(sudo) = &ctx.sudo() {
         if let Some(layman) = which("layman") {
-            run_type.execute(&sudo).arg(layman).args(["-s", "ALL"]).check_run()?;
+            run_type.execute(&sudo).arg(layman).args(&["-s", "ALL"]).check_run()?;
         }
 
         println!("Syncing portage");
         run_type
             .execute(&sudo)
-            .args(["/usr/bin/emerge", "--sync"])
+            .args(&["/usr/bin/emerge", "--sync"])
             .args(
                 ctx.config()
                     .emerge_sync_flags()
@@ -288,7 +288,7 @@ fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/eopkg", "upgrade"])
+            .args(&["/usr/bin/eopkg", "upgrade"])
             .check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -310,7 +310,7 @@ fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = &ctx.sudo() {
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/swupd", "update"])
+            .args(&["/usr/bin/swupd", "update"])
             .check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -323,29 +323,29 @@ fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/cave", "sync"])
+            .args(&["/usr/bin/cave", "sync"])
             .check_run()?;
 
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
+            .args(&["/usr/bin/cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
             .check_run()?;
 
         if ctx.config().cleanup() {
             ctx.run_type()
                 .execute(&sudo)
-                .args(["/usr/bin/cave", "purge", "-x"])
+                .args(&["/usr/bin/cave", "purge", "-x"])
                 .check_run()?;
         }
 
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/cave", "fix-linkage", "-x", "--", "-Cs"])
+            .args(&["/usr/bin/cave", "fix-linkage", "-x", "--", "-Cs"])
             .check_run()?;
 
         ctx.run_type()
             .execute(&sudo)
-            .args(["/usr/bin/eclectic", "config", "interactive"])
+            .args(&["/usr/bin/eclectic", "config", "interactive"])
             .check_run()?;
     } else {
         print_warning("No sudo detected. Skipping system upgrade");
@@ -358,13 +358,13 @@ fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
     if let Some(sudo) = ctx.sudo() {
         ctx.run_type()
             .execute(&sudo)
-            .args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"])
+            .args(&["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"])
             .check_run()?;
 
         if ctx.config().cleanup() {
             ctx.run_type()
                 .execute(&sudo)
-                .args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
+                .args(&["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
                 .check_run()?;
         }
     } else {
@@ -450,7 +450,7 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
 
     run_type
         .execute(&flatpak)
-        .args(["update", "--user", "-y"])
+        .args(&["update", "--user", "-y"])
         .check_run()?;
 
     print_separator("Flatpak System Packages");
@@ -458,12 +458,12 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
         run_type
             .execute(sudo)
             .arg(flatpak)
-            .args(["update", "--system", "-y"])
+            .args(&["update", "--system", "-y"])
             .check_run()
     } else {
         run_type
             .execute(&flatpak)
-            .args(["update", "--system", "-y"])
+            .args(&["update", "--system", "-y"])
             .check_run()
     }
 }

src/steps/os/macos.rs

@@ -10,15 +10,15 @@ pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
     require("port")?;
     let sudo = ctx.sudo().as_ref().unwrap();
     print_separator("MacPorts");
-    ctx.run_type().execute(sudo).args(["port", "selfupdate"]).check_run()?;
+    ctx.run_type().execute(sudo).args(&["port", "selfupdate"]).check_run()?;
     ctx.run_type()
         .execute(sudo)
-        .args(["port", "-u", "upgrade", "outdated"])
+        .args(&["port", "-u", "upgrade", "outdated"])
         .check_run()?;
     if ctx.config().cleanup() {
         ctx.run_type()
             .execute(sudo)
-            .args(["port", "-N", "reclaim"])
+            .args(&["port", "-N", "reclaim"])
             .check_run()?;
     }
 
@@ -58,7 +58,7 @@ pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {
     }
 
     let mut command = ctx.run_type().execute("softwareupdate");
-    command.args(["--install", "--all"]);
+    command.args(&["--install", "--all"]);
 
     if should_ask {
         command.arg("--no-scan");

src/steps/os/unix.rs

@@ -75,7 +75,7 @@ pub fn run_fisher(base_dirs: &BaseDirs, run_type: RunType) -> Result<()> {
 
     print_separator("Fisher");
 
-    run_type.execute(&fish).args(["-c", "fisher update"]).check_run()
+    run_type.execute(&fish).args(&["-c", "fisher update"]).check_run()
 }
 
 pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
@@ -85,7 +85,7 @@ pub fn run_bashit(ctx: &ExecutionContext) -> Result<()> {
 
     ctx.run_type()
         .execute("bash")
-        .args(["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
+        .args(&["-lic", &format!("bash-it update {}", ctx.config().bashit_branch())])
         .check_run()
 }
 
@@ -98,7 +98,7 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("oh-my-fish");
 
-    ctx.run_type().execute(&fish).args(["-c", "omf update"]).check_run()
+    ctx.run_type().execute(&fish).args(&["-c", "omf update"]).check_run()
 }
 
 pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
@@ -128,7 +128,7 @@ pub fn run_fish_plug(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("fish-plug");
 
-    ctx.run_type().execute(&fish).args(["-c", "plug update"]).check_run()
+    ctx.run_type().execute(&fish).args(&["-c", "plug update"]).check_run()
 }
 
 pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
@@ -162,7 +162,7 @@ pub fn run_brew_formula(ctx: &ExecutionContext, variant: BrewVariant) -> Result<
     variant.execute(run_type).arg("update").check_run()?;
     variant
         .execute(run_type)
-        .args(["upgrade", "--ignore-pinned", "--formula"])
+        .args(&["upgrade", "--ignore-pinned", "--formula"])
         .check_run()?;
 
     if ctx.config().cleanup() {
@@ -180,19 +180,19 @@ pub fn run_brew_cask(ctx: &ExecutionContext, variant: BrewVariant) -> Result<()>
 
     let cask_upgrade_exists = variant
         .execute(RunType::Wet)
-        .args(["--repository", "buo/cask-upgrade"])
+        .args(&["--repository", "buo/cask-upgrade"])
         .check_output()
         .map(|p| Path::new(p.trim()).exists())?;
 
     let mut brew_args = vec![];
 
     if cask_upgrade_exists {
-        brew_args.extend(["cu", "-y"]);
+        brew_args.extend(&["cu", "-y"]);
         if ctx.config().brew_cask_greedy() {
             brew_args.push("-a");
         }
     } else {
-        brew_args.extend(["upgrade", "--cask"]);
+        brew_args.extend(&["upgrade", "--cask"]);
         if ctx.config().brew_cask_greedy() {
             brew_args.push("--greedy");
         }
@@ -229,7 +229,10 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
 
     if multi_user {
         if let Some(sudo) = ctx.sudo() {
-            run_type.execute(&sudo).args(["-i", "nix", "upgrade-nix"]).check_run()?;
+            run_type
+                .execute(&sudo)
+                .args(&["-i", "nix", "upgrade-nix"])
+                .check_run()?;
         } else {
             print_warning("Need sudo to upgrade Nix");
         }
@@ -259,7 +262,7 @@ pub fn run_asdf(run_type: RunType) -> Result<()> {
             return Err(TopgradeError::ProcessFailed(e).into());
         }
     }
-    run_type.execute(&asdf).args(["plugin", "update", "--all"]).check_run()
+    run_type.execute(&asdf).args(&["plugin", "update", "--all"]).check_run()
 }
 
 pub fn run_home_manager(run_type: RunType) -> Result<()> {
@@ -297,20 +300,32 @@ pub fn run_sdkman(base_dirs: &BaseDirs, cleanup: bool, run_type: RunType) -> Res
     print_separator("SDKMAN!");
 
     let cmd_selfupdate = format!("source {} && sdk selfupdate", &sdkman_init_path);
-    run_type.execute(&bash).args(["-c", &cmd_selfupdate]).check_run()?;
+    run_type
+        .execute(&bash)
+        .args(&["-c", cmd_selfupdate.as_str()])
+        .check_run()?;
 
     let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
-    run_type.execute(&bash).args(["-c", &cmd_update]).check_run()?;
+    run_type.execute(&bash).args(&["-c", cmd_update.as_str()]).check_run()?;
 
     let cmd_upgrade = format!("source {} && sdk upgrade", &sdkman_init_path);
-    run_type.execute(&bash).args(["-c", &cmd_upgrade]).check_run()?;
+    run_type
+        .execute(&bash)
+        .args(&["-c", cmd_upgrade.as_str()])
+        .check_run()?;
 
     if cleanup {
         let cmd_flush_archives = format!("source {} && sdk flush archives", &sdkman_init_path);
-        run_type.execute(&bash).args(["-c", &cmd_flush_archives]).check_run()?;
+        run_type
+            .execute(&bash)
+            .args(&["-c", cmd_flush_archives.as_str()])
+            .check_run()?;
 
         let cmd_flush_temp = format!("source {} && sdk flush temp", &sdkman_init_path);
-        run_type.execute(&bash).args(["-c", &cmd_flush_temp]).check_run()?;
+        run_type
+            .execute(&bash)
+            .args(&["-c", cmd_flush_temp.as_str()])
+            .check_run()?;
     }
 
     Ok(())

src/steps/os/windows.rs

@@ -40,7 +40,7 @@ pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("winget");
 
-    ctx.run_type().execute(&winget).args(["upgrade", "--all"]).check_run()
+    ctx.run_type().execute(&winget).args(&["upgrade", "--all"]).check_run()
 }
 
 pub fn run_scoop(cleanup: bool, run_type: RunType) -> Result<()> {
@@ -48,11 +48,11 @@ pub fn run_scoop(cleanup: bool, run_type: RunType) -> Result<()> {
 
     print_separator("Scoop");
 
-    run_type.execute(&scoop).args(["update"]).check_run()?;
-    run_type.execute(&scoop).args(["update", "*"]).check_run()?;
+    run_type.execute(&scoop).args(&["update"]).check_run()?;
+    run_type.execute(&scoop).args(&["update", "*"]).check_run()?;
 
     if cleanup {
-        run_type.execute(&scoop).args(["cleanup", "*"]).check_run()?;
+        run_type.execute(&scoop).args(&["cleanup", "*"]).check_run()?;
     }
 
     Ok(())
@@ -61,13 +61,13 @@ pub fn run_scoop(cleanup: bool, run_type: RunType) -> Result<()> {
 pub fn run_wsl_topgrade(ctx: &ExecutionContext) -> Result<()> {
     let wsl = require("wsl")?;
     let topgrade = Command::new(&wsl)
-        .args(["bash", "-lc", "which topgrade"])
+        .args(&["bash", "-lc", "which topgrade"])
         .check_output()
         .map_err(|_| SkipStep(String::from("Could not find Topgrade installed in WSL")))?;
 
     let mut command = ctx.run_type().execute(&wsl);
     command
-        .args(["bash", "-c"])
+        .args(&["bash", "-c"])
         .arg(format!("TOPGRADE_PREFIX=WSL exec {}", topgrade));
 
     if ctx.config().yes() {
@@ -94,7 +94,7 @@ pub fn windows_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn reboot() {
-    Command::new("shutdown").args(["/R", "/T", "0"]).spawn().ok();
+    Command::new("shutdown").args(&["/R", "/T", "0"]).spawn().ok();
 }
 
 pub fn insert_startup_scripts(ctx: &ExecutionContext, git_repos: &mut Repositories) -> Result<()> {