admin/topgrade
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: make all step functions take &ExectutionContext (#436)

Browse Source
This commit is contained in:
SteveLauC
2023-05-25 15:09:23 +08:00
committed by GitHub
parent c20a300eea
commit 76c39edc8b
14 changed files with 193 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
src/steps/generic.rs
View File

@@ -13,7 +13,7 @@ use tracing::{debug, error};
use crate::command::{CommandExt, Utf8Output};
use crate::execution_context::ExecutionContext;
use crate::executor::{ExecutorOutput, RunType};
use crate::executor::ExecutorOutput;
use crate::terminal::{print_separator, shell};
use crate::utils::{self, require, require_option, which, PathExt};
use crate::Step;
@@ -77,20 +77,20 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
Ok(())
}
pub fn run_flutter_upgrade(run_type: RunType) -> Result<()> {
pub fn run_flutter_upgrade(ctx: &ExecutionContext) -> Result<()> {
let flutter = utils::require("flutter")?;
print_separator("Flutter");
run_type.execute(flutter).arg("upgrade").status_checked()
ctx.run_type().execute(flutter).arg("upgrade").status_checked()
}
pub fn run_gem(run_type: RunType) -> Result<()> {
pub fn run_gem(ctx: &ExecutionContext) -> Result<()> {
let gem = utils::require("gem")?;
HOME_DIR.join(".gem").require()?;
print_separator("Gems");
let mut command = run_type.execute(gem);
let mut command = ctx.run_type().execute(gem);
command.arg("update");
if env::var_os("RBENV_SHELL").is_none() {
@@ -163,20 +163,21 @@ pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
.status_checked()
}
pub fn run_fossil(run_type: RunType) -> Result<()> {
pub fn run_fossil(ctx: &ExecutionContext) -> Result<()> {
let fossil = utils::require("fossil")?;
print_separator("Fossil");
run_type.execute(fossil).args(["all", "sync"]).status_checked()
ctx.run_type().execute(fossil).args(["all", "sync"]).status_checked()
}
pub fn run_micro(run_type: RunType) -> Result<()> {
pub fn run_micro(ctx: &ExecutionContext) -> Result<()> {
let micro = utils::require("micro")?;
print_separator("micro");
let stdout = run_type
let stdout = ctx
.run_type()
.execute(micro)
.args(["-plugin", "update"])
.output_checked_utf8()?
@@ -196,12 +197,12 @@ pub fn run_micro(run_type: RunType) -> Result<()> {
target_os = "netbsd",
target_os = "dragonfly"
)))]
pub fn run_apm(run_type: RunType) -> Result<()> {
pub fn run_apm(ctx: &ExecutionContext) -> Result<()> {
let apm = utils::require("apm")?;
print_separator("Atom Package Manager");
run_type
ctx.run_type()
.execute(apm)
.args(["upgrade", "--confirm=false"])
.status_checked()
@@ -214,16 +215,19 @@ pub fn run_rustup(ctx: &ExecutionContext) -> Result<()> {
ctx.run_type().execute(rustup).arg("update").status_checked()
}
pub fn run_juliaup(run_type: RunType) -> Result<()> {
pub fn run_juliaup(ctx: &ExecutionContext) -> Result<()> {
let juliaup = utils::require("juliaup")?;
print_separator("juliaup");
if juliaup.canonicalize()?.is_descendant_of(&HOME_DIR) {
run_type.execute(&juliaup).args(["self", "update"]).status_checked()?;
ctx.run_type()
.execute(&juliaup)
.args(["self", "update"])
.status_checked()?;
}
run_type.execute(&juliaup).arg("update").status_checked()
ctx.run_type().execute(&juliaup).arg("update").status_checked()
}
pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
@@ -236,15 +240,15 @@ pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
run_type.execute(&choosenim).args(["update", "stable"]).status_checked()
}
pub fn run_krew_upgrade(run_type: RunType) -> Result<()> {
pub fn run_krew_upgrade(ctx: &ExecutionContext) -> Result<()> {
let krew = utils::require("kubectl-krew")?;
print_separator("Krew");
run_type.execute(krew).args(["upgrade"]).status_checked()
ctx.run_type().execute(krew).args(["upgrade"]).status_checked()
}
pub fn run_gcloud_components_update(run_type: RunType) -> Result<()> {
pub fn run_gcloud_components_update(ctx: &ExecutionContext) -> Result<()> {
let gcloud = utils::require("gcloud")?;
if gcloud.starts_with("/snap") {
@@ -252,19 +256,22 @@ pub fn run_gcloud_components_update(run_type: RunType) -> Result<()> {
} else {
print_separator("gcloud");
run_type
ctx.run_type()
.execute(gcloud)
.args(["components", "update", "--quiet"])
.status_checked()
}
}
pub fn run_jetpack(run_type: RunType) -> Result<()> {
pub fn run_jetpack(ctx: &ExecutionContext) -> Result<()> {
let jetpack = utils::require("jetpack")?;
print_separator("Jetpack");
run_type.execute(jetpack).args(["global", "update"]).status_checked()
ctx.run_type()
.execute(jetpack)
.args(["global", "update"])
.status_checked()
}
pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
@@ -313,11 +320,11 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
command.args(["upgrade", "--no-dry-run"]).status_checked()
}
pub fn run_pipx_update(run_type: RunType) -> Result<()> {
pub fn run_pipx_update(ctx: &ExecutionContext) -> Result<()> {
let pipx = utils::require("pipx")?;
print_separator("pipx");
run_type.execute(pipx).arg("upgrade-all").status_checked()
ctx.run_type().execute(pipx).arg("upgrade-all").status_checked()
}
pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
@@ -362,7 +369,7 @@ pub fn run_mamba_update(ctx: &ExecutionContext) -> Result<()> {
command.status_checked()
}
pub fn run_pip3_update(run_type: RunType) -> Result<()> {
pub fn run_pip3_update(ctx: &ExecutionContext) -> Result<()> {
let python3 = utils::require("python3")?;
Command::new(&python3)
.args(["-m", "pip"])
@@ -390,7 +397,7 @@ pub fn run_pip3_update(run_type: RunType) -> Result<()> {
return Err(SkipStep("Does not run inside a virtual environment".to_string()).into());
}
run_type
ctx.run_type()
.execute(&python3)
.args(["-m", "pip", "install", "--upgrade", "--user", "pip"])
.status_checked()
@@ -448,7 +455,7 @@ pub fn run_pipupgrade_update(ctx: &ExecutionContext) -> Result<()> {
Ok(())
}
pub fn run_stack_update(run_type: RunType) -> Result<()> {
pub fn run_stack_update(ctx: &ExecutionContext) -> Result<()> {
if utils::require("ghcup").is_ok() {
// `ghcup` is present and probably(?) being used to install `stack`.
// Don't upgrade `stack`, let `ghcup` handle it. Per `ghcup install stack`:
@@ -459,14 +466,14 @@ pub fn run_stack_update(run_type: RunType) -> Result<()> {
let stack = utils::require("stack")?;
print_separator("stack");
run_type.execute(stack).arg("upgrade").status_checked()
ctx.run_type().execute(stack).arg("upgrade").status_checked()
}
pub fn run_ghcup_update(run_type: RunType) -> Result<()> {
pub fn run_ghcup_update(ctx: &ExecutionContext) -> Result<()> {
let ghcup = utils::require("ghcup")?;
print_separator("ghcup");
run_type.execute(ghcup).arg("upgrade").status_checked()
ctx.run_type().execute(ghcup).arg("upgrade").status_checked()
}
pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
@@ -512,28 +519,28 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
command.status_checked()
}
pub fn run_chezmoi_update(run_type: RunType) -> Result<()> {
pub fn run_chezmoi_update(ctx: &ExecutionContext) -> Result<()> {
let chezmoi = utils::require("chezmoi")?;
HOME_DIR.join(".local/share/chezmoi").require()?;
print_separator("chezmoi");
run_type.execute(chezmoi).arg("update").status_checked()
ctx.run_type().execute(chezmoi).arg("update").status_checked()
}
pub fn run_myrepos_update(run_type: RunType) -> Result<()> {
pub fn run_myrepos_update(ctx: &ExecutionContext) -> Result<()> {
let myrepos = utils::require("mr")?;
HOME_DIR.join(".mrconfig").require()?;
print_separator("myrepos");
run_type
ctx.run_type()
.execute(&myrepos)
.arg("--directory")
.arg(&*HOME_DIR)
.arg("checkout")
.status_checked()?;
run_type
ctx.run_type()
.execute(&myrepos)
.arg("--directory")
.arg(&*HOME_DIR)
@@ -672,12 +679,15 @@ pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
Ok(())
}
pub fn run_raco_update(run_type: RunType) -> Result<()> {
pub fn run_raco_update(ctx: &ExecutionContext) -> Result<()> {
let raco = utils::require("raco")?;
print_separator("Racket Package Manager");
run_type.execute(raco).args(["pkg", "update", "--all"]).status_checked()
ctx.run_type()
.execute(raco)
.args(["pkg", "update", "--all"])
.status_checked()
}
pub fn bin_update(ctx: &ExecutionContext) -> Result<()> {
@@ -720,14 +730,14 @@ pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
.status_checked()
}
pub fn run_helm_repo_update(run_type: RunType) -> Result<()> {
pub fn run_helm_repo_update(ctx: &ExecutionContext) -> Result<()> {
let helm = utils::require("helm")?;
print_separator("Helm");
let no_repo = "no repositories found";
let mut success = true;
let mut exec = run_type.execute(helm);
let mut exec = ctx.run_type().execute(helm);
if let Err(e) = exec.arg("repo").arg("update").status_checked() {
error!("Updating repositories failed: {}", e);
success = match exec.output_checked_utf8() {
@@ -746,9 +756,9 @@ pub fn run_helm_repo_update(run_type: RunType) -> Result<()> {
}
}
pub fn run_stew(run_type: RunType) -> Result<()> {
pub fn run_stew(ctx: &ExecutionContext) -> Result<()> {
let stew = require("stew")?;
print_separator("stew");
run_type.execute(stew).args(["upgrade", "--all"]).status_checked()
ctx.run_type().execute(stew).args(["upgrade", "--all"]).status_checked()
}

3
src/steps/git.rs
View File

@@ -14,7 +14,6 @@ use tracing::{debug, error};
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::executor::RunType;
use crate::terminal::print_separator;
use crate::utils::{which, PathExt};
use crate::{error::SkipStep, terminal::print_warning};
@@ -194,7 +193,7 @@ impl Git {
pub fn multi_pull(&self, repositories: &Repositories, ctx: &ExecutionContext) -> Result<()> {
let git = self.git.as_ref().unwrap();
if let RunType::Dry = ctx.run_type() {
if ctx.run_type().dry() {
repositories
.repositories
.iter()

10
src/steps/go.rs
View File

@@ -4,27 +4,27 @@ use std::process::Command;
use color_eyre::eyre::Result;
use crate::command::CommandExt;
use crate::executor::RunType;
use crate::execution_context::ExecutionContext;
use crate::terminal::print_separator;
use crate::utils;
use crate::utils::PathExt;
/// <https://github.com/Gelio/go-global-update>
pub fn run_go_global_update(run_type: RunType) -> Result<()> {
pub fn run_go_global_update(ctx: &ExecutionContext) -> Result<()> {
let go_global_update = require_go_bin("go-global-update")?;
print_separator("go-global-update");
run_type.execute(go_global_update).status_checked()
ctx.run_type().execute(go_global_update).status_checked()
}
/// <https://github.com/nao1215/gup>
pub fn run_go_gup(run_type: RunType) -> Result<()> {
pub fn run_go_gup(ctx: &ExecutionContext) -> Result<()> {
let gup = require_go_bin("gup")?;
print_separator("gup");
run_type.execute(gup).arg("update").status_checked()
ctx.run_type().execute(gup).arg("update").status_checked()
}
/// Get the path of a Go binary.

9
src/steps/os/dragonfly.rs
View File

@@ -1,16 +1,15 @@
use crate::command::CommandExt;
use crate::executor::RunType;
use crate::execution_context::ExecutionContext;
use crate::sudo::Sudo;
use crate::terminal::print_separator;
use crate::utils::require_option;
use color_eyre::eyre::Result;
use std::process::Command;
pub fn upgrade_packages(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("No sudo detected"))?;
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
print_separator("DragonFly BSD Packages");
run_type
.execute(sudo)
ctx.execute(sudo)
.args(["/usr/local/sbin/pkg", "upgrade"])
.status_checked()
}

13
src/steps/os/freebsd.rs
View File

@@ -1,6 +1,5 @@
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::executor::RunType;
use crate::sudo::Sudo;
use crate::terminal::print_separator;
use crate::utils::require_option;
@@ -8,20 +7,20 @@ use crate::Step;
use color_eyre::eyre::Result;
use std::process::Command;
pub fn upgrade_freebsd(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("No sudo detected"))?;
pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
print_separator("FreeBSD Update");
run_type
ctx.run_type()
.execute(sudo)
.args(["/usr/sbin/freebsd-update", "fetch", "install"])
.status_checked()
}
pub fn upgrade_packages(ctx: &ExecutionContext, sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("No sudo detected"))?;
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
print_separator("FreeBSD Packages");
let mut command = run_type.execute(sudo);
let mut command = ctx.run_type().execute(sudo);
command.args(["/usr/sbin/pkg", "upgrade"]);
if ctx.config().yes(Step::System) {

20
src/steps/os/linux.rs
View File

@@ -8,9 +8,7 @@ use tracing::{debug, warn};
use crate::command::CommandExt;
use crate::error::{SkipStep, TopgradeError};
use crate::execution_context::ExecutionContext;
use crate::executor::RunType;
use crate::steps::os::archlinux;
use crate::sudo::Sudo;
use crate::terminal::{print_separator, print_warning};
use crate::utils::{require, require_option, which, PathExt};
use crate::{Step, HOME_DIR};
@@ -677,8 +675,8 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
Ok(())
}
pub fn run_needrestart(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("sudo is not installed"))?;
pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
let needrestart = require("needrestart")?;
let distribution = Distribution::detect()?;
@@ -688,7 +686,7 @@ pub fn run_needrestart(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
print_separator("Check for needed restarts");
run_type.execute(sudo).arg(needrestart).status_checked()?;
ctx.run_type().execute(sudo).arg(needrestart).status_checked()?;
Ok(())
}
@@ -782,8 +780,8 @@ pub fn flatpak_update(ctx: &ExecutionContext) -> Result<()> {
Ok(())
}
pub fn run_snap(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("sudo is not installed"))?;
pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
let snap = require("snap")?;
if !PathBuf::from("/var/snapd.socket").exists() && !PathBuf::from("/run/snapd.socket").exists() {
@@ -791,17 +789,17 @@ pub fn run_snap(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
}
print_separator("snap");
run_type.execute(sudo).arg(snap).arg("refresh").status_checked()
ctx.run_type().execute(sudo).arg(snap).arg("refresh").status_checked()
}
pub fn run_pihole_update(sudo: Option<&Sudo>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("sudo is not installed"))?;
pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
let pihole = require("pihole")?;
Path::new("/opt/pihole/update.sh").require()?;
print_separator("pihole");
run_type.execute(sudo).arg(pihole).arg("-up").status_checked()
ctx.run_type().execute(sudo).arg(pihole).arg("-up").status_checked()
}
pub fn run_protonup_update(ctx: &ExecutionContext) -> Result<()> {

5
src/steps/os/macos.rs
View File

@@ -1,6 +1,5 @@
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::executor::RunType;
use crate::terminal::{print_separator, prompt_yesno};
use crate::{utils::require, Step};
use color_eyre::eyre::Result;
@@ -30,11 +29,11 @@ pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
Ok(())
}
pub fn run_mas(run_type: RunType) -> Result<()> {
pub fn run_mas(ctx: &ExecutionContext) -> Result<()> {
let mas = require("mas")?;
print_separator("macOS App Store");
run_type.execute(mas).arg("upgrade").status_checked()
ctx.run_type().execute(mas).arg("upgrade").status_checked()
}
pub fn upgrade_macos(ctx: &ExecutionContext) -> Result<()> {

14
src/steps/os/openbsd.rs
View File

@@ -1,22 +1,22 @@
use crate::executor::RunType;
use crate::execution_context::ExecutionContext;
use crate::terminal::print_separator;
use crate::utils::require_option;
use color_eyre::eyre::Result;
use std::path::PathBuf;
pub fn upgrade_openbsd(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("No sudo detected"))?;
pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
print_separator("OpenBSD Update");
run_type
ctx.run_type()
.execute(sudo)
.args(&["/usr/sbin/sysupgrade", "-n"])
.status_checked()
}
pub fn upgrade_packages(sudo: Option<&PathBuf>, run_type: RunType) -> Result<()> {
let sudo = require_option(sudo, String::from("No sudo detected"))?;
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
print_separator("OpenBSD Packages");
run_type
ctx.run_type()
.execute(sudo)
.args(&["/usr/sbin/pkg_add", "-u"])
.status_checked()

46
src/steps/os/unix.rs
View File

@@ -18,6 +18,7 @@ use crate::error::SkipStep;
use crate::execution_context::ExecutionContext;
#[cfg(any(target_os = "linux", target_os = "macos"))]
use crate::executor::Executor;
#[cfg(any(target_os = "linux", target_os = "macos"))]
use crate::executor::RunType;
use crate::terminal::print_separator;
#[cfg(not(any(target_os = "android", target_os = "macos")))]
@@ -89,7 +90,7 @@ impl BrewVariant {
}
}
pub fn run_fisher(run_type: RunType) -> Result<()> {
pub fn run_fisher(ctx: &ExecutionContext) -> Result<()> {
let fish = require("fish")?;
Command::new(&fish)
@@ -112,7 +113,8 @@ pub fn run_fisher(run_type: RunType) -> Result<()> {
print_separator("Fisher");
let version_str = run_type
let version_str = ctx
.run_type()
.execute(&fish)
.args(["-c", "fisher --version"])
.output_checked_utf8()?
@@ -121,10 +123,13 @@ pub fn run_fisher(run_type: RunType) -> Result<()> {
if version_str.starts_with("fisher version 3.") {
// v3 - see https://github.com/topgrade-rs/topgrade/pull/37#issuecomment-1283844506
run_type.execute(&fish).args(["-c", "fisher"]).status_checked()
ctx.run_type().execute(&fish).args(["-c", "fisher"]).status_checked()
} else {
// v4
run_type.execute(&fish).args(["-c", "fisher update"]).status_checked()
ctx.run_type()
.execute(&fish)
.args(["-c", "fisher update"])
.status_checked()
}
}
@@ -422,40 +427,43 @@ pub fn run_yadm(ctx: &ExecutionContext) -> Result<()> {
ctx.run_type().execute(yadm).arg("pull").status_checked()
}
pub fn run_asdf(run_type: RunType) -> Result<()> {
pub fn run_asdf(ctx: &ExecutionContext) -> Result<()> {
let asdf = require("asdf")?;
print_separator("asdf");
run_type.execute(&asdf).arg("update").status_checked_with_codes(&[42])?;
ctx.run_type()
.execute(&asdf)
.arg("update")
.status_checked_with_codes(&[42])?;
run_type
ctx.run_type()
.execute(&asdf)
.args(["plugin", "update", "--all"])
.status_checked()
}
pub fn run_home_manager(run_type: RunType) -> Result<()> {
pub fn run_home_manager(ctx: &ExecutionContext) -> Result<()> {
let home_manager = require("home-manager")?;
print_separator("home-manager");
run_type.execute(home_manager).arg("switch").status_checked()
ctx.run_type().execute(home_manager).arg("switch").status_checked()
}
pub fn run_tldr(run_type: RunType) -> Result<()> {
pub fn run_tldr(ctx: &ExecutionContext) -> Result<()> {
let tldr = require("tldr")?;
print_separator("TLDR");
run_type.execute(tldr).arg("--update").status_checked()
ctx.run_type().execute(tldr).arg("--update").status_checked()
}
pub fn run_pearl(run_type: RunType) -> Result<()> {
pub fn run_pearl(ctx: &ExecutionContext) -> Result<()> {
let pearl = require("pearl")?;
print_separator("pearl");
run_type.execute(pearl).arg("update").status_checked()
ctx.run_type().execute(pearl).arg("update").status_checked()
}
pub fn run_sdkman(cleanup: bool, run_type: RunType) -> Result<()> {
pub fn run_sdkman(cleanup: bool, ctx: &ExecutionContext) -> Result<()> {
let bash = require("bash")?;
let sdkman_init_path = env::var("SDKMAN_DIR")
@@ -483,33 +491,33 @@ pub fn run_sdkman(cleanup: bool, run_type: RunType) -> Result<()> {
if selfupdate_enabled == "true" {
let cmd_selfupdate = format!("source {} && sdk selfupdate", &sdkman_init_path);
run_type
ctx.run_type()
.execute(&bash)
.args(["-c", cmd_selfupdate.as_str()])
.status_checked()?;
}
let cmd_update = format!("source {} && sdk update", &sdkman_init_path);
run_type
ctx.run_type()
.execute(&bash)
.args(["-c", cmd_update.as_str()])
.status_checked()?;
let cmd_upgrade = format!("source {} && sdk upgrade", &sdkman_init_path);
run_type
ctx.run_type()
.execute(&bash)
.args(["-c", cmd_upgrade.as_str()])
.status_checked()?;
if cleanup {
let cmd_flush_archives = format!("source {} && sdk flush archives", &sdkman_init_path);
run_type
ctx.run_type()
.execute(&bash)
.args(["-c", cmd_flush_archives.as_str()])
.status_checked()?;
let cmd_flush_temp = format!("source {} && sdk flush temp", &sdkman_init_path);
run_type
ctx.run_type()
.execute(&bash)
.args(["-c", cmd_flush_temp.as_str()])
.status_checked()?;

9
src/steps/os/windows.rs
View File

@@ -8,7 +8,6 @@ use tracing::debug;
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::executor::RunType;
use crate::terminal::{print_separator, print_warning};
use crate::utils::require;
use crate::{error::SkipStep, steps::git::Repositories};
@@ -54,16 +53,16 @@ pub fn run_winget(ctx: &ExecutionContext) -> Result<()> {
.status_checked()
}
pub fn run_scoop(cleanup: bool, run_type: RunType) -> Result<()> {
pub fn run_scoop(cleanup: bool, ctx: &ExecutionContext) -> Result<()> {
let scoop = require("scoop")?;
print_separator("Scoop");
run_type.execute(&scoop).args(["update"]).status_checked()?;
run_type.execute(&scoop).args(["update", "*"]).status_checked()?;
ctx.run_type().execute(&scoop).args(["update"]).status_checked()?;
ctx.run_type().execute(&scoop).args(["update", "*"]).status_checked()?;
if cleanup {
run_type.execute(&scoop).args(["cleanup", "*"]).status_checked()?;
ctx.run_type().execute(&scoop).args(["cleanup", "*"]).status_checked()?;
}
Ok(())

5
src/steps/tmux.rs
View File

@@ -7,7 +7,6 @@ use color_eyre::eyre::Context;
use color_eyre::eyre::Result;
use crate::command::CommandExt;
use crate::executor::RunType;
use crate::terminal::print_separator;
use crate::HOME_DIR;
use crate::{
@@ -18,12 +17,12 @@ use crate::{
#[cfg(unix)]
use std::os::unix::process::CommandExt as _;
pub fn run_tpm(run_type: RunType) -> Result<()> {
pub fn run_tpm(ctx: &ExecutionContext) -> Result<()> {
let tpm = HOME_DIR.join(".tmux/plugins/tpm/bin/update_plugins").require()?;
print_separator("tmux plugins");
run_type.execute(tpm).arg("all").status_checked()
ctx.run_type().execute(tpm).arg("all").status_checked()
}
struct Tmux {

6
src/steps/vim.rs
View File

@@ -4,7 +4,7 @@ use crate::HOME_DIR;
use color_eyre::eyre::Result;
use etcetera::base_strategy::BaseStrategy;
use crate::executor::{Executor, ExecutorOutput, RunType};
use crate::executor::{Executor, ExecutorOutput};
use crate::terminal::print_separator;
use crate::{
execution_context::ExecutionContext,
@@ -141,10 +141,10 @@ pub fn upgrade_neovim(ctx: &ExecutionContext) -> Result<()> {
)
}
pub fn run_voom(run_type: RunType) -> Result<()> {
pub fn run_voom(ctx: &ExecutionContext) -> Result<()> {
let voom = require("voom")?;
print_separator("voom");
run_type.execute(voom).arg("update").status_checked()
ctx.run_type().execute(voom).arg("update").status_checked()
}

45
src/steps/zsh.rs
View File

@@ -8,13 +8,12 @@ use walkdir::WalkDir;
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::executor::RunType;
use crate::git::Repositories;
use crate::terminal::print_separator;
use crate::utils::{require, PathExt};
use crate::HOME_DIR;
pub fn run_zr(run_type: RunType) -> Result<()> {
pub fn run_zr(ctx: &ExecutionContext) -> Result<()> {
let zsh = require("zsh")?;
require("zr")?;
@@ -22,7 +21,10 @@ pub fn run_zr(run_type: RunType) -> Result<()> {
print_separator("zr");
let cmd = format!("source {} && zr --update", zshrc().display());
run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
ctx.run_type()
.execute(zsh)
.args(["-l", "-c", cmd.as_str()])
.status_checked()
}
fn zdotdir() -> PathBuf {
@@ -49,16 +51,16 @@ pub fn run_antidote(ctx: &ExecutionContext) -> Result<()> {
.status_checked()
}
pub fn run_antibody(run_type: RunType) -> Result<()> {
pub fn run_antibody(ctx: &ExecutionContext) -> Result<()> {
require("zsh")?;
let antibody = require("antibody")?;
print_separator("antibody");
run_type.execute(antibody).arg("update").status_checked()
ctx.run_type().execute(antibody).arg("update").status_checked()
}
pub fn run_antigen(run_type: RunType) -> Result<()> {
pub fn run_antigen(ctx: &ExecutionContext) -> Result<()> {
let zsh = require("zsh")?;
let zshrc = zshrc().require()?;
env::var("ADOTDIR")
@@ -69,10 +71,13 @@ pub fn run_antigen(run_type: RunType) -> Result<()> {
print_separator("antigen");
let cmd = format!("source {} && (antigen selfupdate ; antigen update)", zshrc.display());
run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
ctx.run_type()
.execute(zsh)
.args(["-l", "-c", cmd.as_str()])
.status_checked()
}
pub fn run_zgenom(run_type: RunType) -> Result<()> {
pub fn run_zgenom(ctx: &ExecutionContext) -> Result<()> {
let zsh = require("zsh")?;
let zshrc = zshrc().require()?;
env::var("ZGEN_SOURCE")
@@ -83,10 +88,13 @@ pub fn run_zgenom(run_type: RunType) -> Result<()> {
print_separator("zgenom");
let cmd = format!("source {} && zgenom selfupdate && zgenom update", zshrc.display());
run_type.execute(zsh).args(["-l", "-c", cmd.as_str()]).status_checked()
ctx.run_type()
.execute(zsh)
.args(["-l", "-c", cmd.as_str()])
.status_checked()
}
pub fn run_zplug(run_type: RunType) -> Result<()> {
pub fn run_zplug(ctx: &ExecutionContext) -> Result<()> {
let zsh = require("zsh")?;
zshrc().require()?;
@@ -97,13 +105,13 @@ pub fn run_zplug(run_type: RunType) -> Result<()> {
print_separator("zplug");
run_type
ctx.run_type()
.execute(zsh)
.args(["-i", "-c", "zplug update"])
.status_checked()
}
pub fn run_zinit(run_type: RunType) -> Result<()> {
pub fn run_zinit(ctx: &ExecutionContext) -> Result<()> {
let zsh = require("zsh")?;
let zshrc = zshrc().require()?;
@@ -115,10 +123,13 @@ pub fn run_zinit(run_type: RunType) -> Result<()> {
print_separator("zinit");
let cmd = format!("source {} && zinit self-update && zinit update --all", zshrc.display(),);
run_type.execute(zsh).args(["-i", "-c", cmd.as_str()]).status_checked()
ctx.run_type()
.execute(zsh)
.args(["-i", "-c", cmd.as_str()])
.status_checked()
}
pub fn run_zi(run_type: RunType) -> Result<()> {
pub fn run_zi(ctx: &ExecutionContext) -> Result<()> {
let zsh = require("zsh")?;
let zshrc = zshrc().require()?;
@@ -127,10 +138,10 @@ pub fn run_zi(run_type: RunType) -> Result<()> {
print_separator("zi");
let cmd = format!("source {} && zi self-update && zi update --all", zshrc.display(),);
run_type.execute(zsh).args(["-i", "-c", &cmd]).status_checked()
ctx.run_type().execute(zsh).args(["-i", "-c", &cmd]).status_checked()
}
pub fn run_zim(run_type: RunType) -> Result<()> {
pub fn run_zim(ctx: &ExecutionContext) -> Result<()> {
let zsh = require("zsh")?;
env::var("ZIM_HOME")
.or_else(|_| {
@@ -146,7 +157,7 @@ pub fn run_zim(run_type: RunType) -> Result<()> {
print_separator("zim");
run_type
ctx.run_type()
.execute(zsh)
.args(["-i", "-c", "zimfw upgrade && zimfw update"])
.status_checked()