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

Move step running into enum for dynamic ordering (#1188)

Browse Source 
Co-authored-by: Stuart Reilly <sreilly@scottlogic.com>
This commit is contained in:
Stuart Reilly
2025-07-16 10:16:27 +01:00
committed by GitHub
parent 6719ff93d8
commit 75ac6808a1
22 changed files with 951 additions and 530 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
.github/workflows/ci.yml vendored
View File

@@ -35,15 +35,29 @@ jobs:
- name: Check if `Step` enum is sorted
run: |
ENUM_NAME="Step"
FILE="src/config.rs"
FILE="src/step.rs"
awk "/enum $ENUM_NAME/,/}/" "$FILE" | \
grep -E '^\s*[A-Za-z_][A-Za-z0-9_]*\s*,?$' | \
sed 's/[, ]//g' > original.txt
sort original.txt > sorted.txt
diff original.txt sorted.txt
step-match-sorted:
name: Step match sorted
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Check if `Step::run()`'s match is sorted
run: |
FILE="src/step.rs"
awk '/[[:alpha:]] =>/{print $1}' $FILE > original.txt
sort original.txt > sorted.txt
diff original.txt sorted.txt
main:
needs: [fmt, step-enum-sorted]
needs: [ fmt, step-enum-sorted, step-match-sorted ]
name: ${{ matrix.target_name }} (check, clippy)
runs-on: ${{ matrix.os }}
strategy:

20
CONTRIBUTING.md
View File

@@ -16,7 +16,7 @@ In `topgrade`'s term, package manager is called `step`.
To add a new `step` to `topgrade`:
1. Add a new variant to
[`enum Step`](https://github.com/topgrade-rs/topgrade/blob/cb7adc8ced8a77addf2cb051d18bba9f202ab866/src/config.rs#L100)
[`enum Step`](https://github.com/topgrade-rs/topgrade/blob/main/src/step.rs)
```rust
pub enum Step {
@@ -32,9 +32,9 @@ To add a new `step` to `topgrade`:
2. Implement the update function
You need to find the appropriate location where this update function goes, it should be
a file under [`src/steps`](https://github.com/topgrade-rs/topgrade/tree/master/src/steps),
a file under [`src/steps`](https://github.com/topgrade-rs/topgrade/tree/main/src/steps),
the file names are self-explanatory, for example, `step`s related to `zsh` are
placed in [`steps/zsh.rs`](https://github.com/topgrade-rs/topgrade/blob/master/src/steps/zsh.rs).
placed in [`steps/zsh.rs`](https://github.com/topgrade-rs/topgrade/blob/main/src/steps/zsh.rs).
Then you implement the update function, and put it in the file where it belongs.
@@ -68,10 +68,10 @@ To add a new `step` to `topgrade`:
Still, this is sufficient for most tools, but you may need some extra stuff
with complicated `step`.
3. Finally, invoke that update function in `main.rs`
3. Add a match arm to `Step::run()`
```rust
runner.execute(Step::Xxx, "xxx", || ItsModule::run_xxx(&ctx))?;
Xxx => runner.execute(*self, "xxx", || ItsModule::run_xxx(ctx))?
```
We use [conditional compilation](https://doc.rust-lang.org/reference/conditional-compilation.html)
@@ -86,19 +86,25 @@ To add a new `step` to `topgrade`:
}
```
4. Finally, add the step to `default_steps()` in `step.rs`
```rust
steps.push(Xxx)
```
Try to keep the conditional compilation the same as in the above step 3.
Congrats, you just added a new `step` :)
## Modification to the configuration entries
If your PR has the configuration options
(in [`src/config.rs`](https://github.com/topgrade-rs/topgrade/blob/master/src/config.rs))
(in [`src/config.rs`](https://github.com/topgrade-rs/topgrade/blob/main/src/config.rs))
modified:
1. Adding new options
2. Changing the existing options
Be sure to apply your changes to
[`config.example.toml`](https://github.com/topgrade-rs/topgrade/blob/master/config.example.toml),
[`config.example.toml`](https://github.com/topgrade-rs/topgrade/blob/main/config.example.toml),
and have some basic documentations guiding user how to use these options.
## Breaking changes

154
src/config.rs
View File

@@ -17,11 +17,12 @@ use regex::Regex;
use regex_split::RegexSplit;
use rust_i18n::t;
use serde::Deserialize;
use strum::{EnumIter, EnumString, IntoEnumIterator, VariantNames};
use strum::IntoEnumIterator;
use which_crate::which;
use super::utils::editor;
use crate::command::CommandExt;
use crate::step::Step;
use crate::sudo::SudoKind;
use crate::utils::string_prepend_str;
use tracing::{debug, error};
@@ -46,157 +47,6 @@ macro_rules! str_value {
pub type Commands = IndexMap<String, String>;
#[derive(ValueEnum, EnumString, VariantNames, Debug, Clone, PartialEq, Eq, Deserialize, EnumIter, Copy)]
#[clap(rename_all = "snake_case")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum Step {
AM,
AndroidStudio,
AppMan,
Aqua,
Asdf,
Atom,
Audit,
AutoCpufreq,
Bin,
Bob,
BrewCask,
BrewFormula,
Bun,
BunPackages,
Cargo,
Certbot,
Chezmoi,
Chocolatey,
Choosenim,
CinnamonSpices,
ClamAvDb,
Composer,
Conda,
ConfigUpdate,
Containers,
CustomCommands,
DebGet,
Deno,
Distrobox,
DkpPacman,
Dotnet,
Elan,
Emacs,
Firmware,
Flatpak,
Flutter,
Fossil,
Gcloud,
Gem,
Ghcup,
GitRepos,
GithubCliExtensions,
GnomeShellExtensions,
Go,
Guix,
Haxelib,
Helix,
Helm,
HomeManager,
// These names are miscapitalized on purpose, so the CLI name is
// `jetbrains_pycharm` instead of `jet_brains_py_charm`.
JetbrainsAqua,
JetbrainsClion,
JetbrainsDatagrip,
JetbrainsDataspell,
JetbrainsGateway,
JetbrainsGoland,
JetbrainsIdea,
JetbrainsMps,
JetbrainsPhpstorm,
JetbrainsPycharm,
JetbrainsRider,
JetbrainsRubymine,
JetbrainsRustrover,
JetbrainsToolbox,
JetbrainsWebstorm,
Jetpack,
Julia,
Juliaup,
Kakoune,
Krew,
Lensfun,
Lure,
Macports,
Mamba,
Mas,
Maza,
Micro,
MicrosoftStore,
Miktex,
Mise,
Myrepos,
Nix,
NixHelper,
Node,
Opam,
Pacdef,
Pacstall,
Pearl,
Pip3,
PipReview,
PipReviewLocal,
Pipupgrade,
Pipx,
Pipxu,
Pixi,
Pkg,
Pkgin,
PlatformioCore,
Pnpm,
Poetry,
Powershell,
Protonup,
Pyenv,
Raco,
Rcm,
Remotes,
Restarts,
Rtcl,
RubyGems,
Rustup,
Rye,
Scoop,
Sdkman,
SelfUpdate,
Sheldon,
Shell,
Snap,
Sparkle,
Spicetify,
Stack,
Stew,
System,
Tldr,
Tlmgr,
Tmux,
Toolbx,
Uv,
Vagrant,
Vcpkg,
Vim,
VoltaPackages,
Vscode,
Vscodium,
Waydroid,
Winget,
Wsl,
WslUpdate,
Xcodes,
Yadm,
Yarn,
Yazi,
Zigup,
Zvm,
}
#[derive(Deserialize, Default, Debug, Merge)]
#[serde(deny_unknown_fields)]
pub struct Include {

18
src/execution_context.rs
View File

@@ -1,5 +1,7 @@
#![allow(dead_code)]
use crate::executor::RunType;
#[cfg(target_os = "linux")]
use crate::steps::linux::Distribution;
use crate::sudo::Sudo;
use crate::utils::{get_require_sudo_string, require_option};
use crate::{config::Config, executor::Executor};
@@ -18,10 +20,17 @@ pub struct ExecutionContext<'a> {
tmux_session: Mutex<Option<String>>,
/// True if topgrade is running under ssh.
under_ssh: bool,
#[cfg(target_os = "linux")]
distribution: &'a Result<Distribution>,
}
impl<'a> ExecutionContext<'a> {
pub fn new(run_type: RunType, sudo: Option<Sudo>, config: &'a Config) -> Self {
pub fn new(
run_type: RunType,
sudo: Option<Sudo>,
config: &'a Config,
#[cfg(target_os = "linux")] distribution: &'a Result<Distribution>,
) -> Self {
let under_ssh = var("SSH_CLIENT").is_ok() || var("SSH_TTY").is_ok();
Self {
run_type,
@@ -29,6 +38,8 @@ impl<'a> ExecutionContext<'a> {
config,
tmux_session: Mutex::new(None),
under_ssh,
#[cfg(target_os = "linux")]
distribution,
}
}
@@ -60,4 +71,9 @@ impl<'a> ExecutionContext<'a> {
pub fn get_tmux_session(&self) -> Option<String> {
self.tmux_session.lock().unwrap().clone()
}
#[cfg(target_os = "linux")]
pub fn distribution(&self) -> &Result<Distribution> {
self.distribution
}
}

360
src/main.rs
View File

@@ -21,7 +21,7 @@ use once_cell::sync::Lazy;
use rust_i18n::{i18n, t};
use tracing::debug;
use self::config::{CommandLineArgs, Config, Step};
use self::config::{CommandLineArgs, Config};
use self::error::StepFailed;
#[cfg(all(windows, feature = "self-update"))]
use self::error::Upgraded;
@@ -29,8 +29,7 @@ use self::error::Upgraded;
use self::steps::{remote::*, *};
#[allow(clippy::wildcard_imports)]
use self::terminal::*;
use self::utils::{hostname, install_color_eyre, install_tracing, update_tracing};
use self::utils::{install_color_eyre, install_tracing, update_tracing};
mod breaking_changes;
mod command;
@@ -45,6 +44,7 @@ mod runner;
mod self_renamer;
#[cfg(feature = "self-update")]
mod self_update;
mod step;
mod steps;
mod sudo;
mod terminal;
@@ -122,7 +122,7 @@ fn run() -> Result<()> {
debug!("Version: {}", crate_version!());
debug!("OS: {}", env!("TARGET"));
debug!("{:?}", std::env::args());
debug!("{:?}", env::args());
debug!("Binary path: {:?}", std::env::current_exe());
debug!("self-update Feature Enabled: {:?}", cfg!(feature = "self-update"));
debug!("Configuration: {:?}", config);
@@ -135,15 +135,18 @@ fn run() -> Result<()> {
}
}
let powershell = powershell::Powershell::new();
let should_run_powershell = powershell.profile().is_some() && config.should_run(Step::Powershell);
let emacs = emacs::Emacs::new();
#[cfg(target_os = "linux")]
let distribution = linux::Distribution::detect();
let sudo = config.sudo_command().map_or_else(sudo::Sudo::detect, sudo::Sudo::new);
let run_type = executor::RunType::new(config.dry_run());
let ctx = execution_context::ExecutionContext::new(run_type, sudo, &config);
let ctx = execution_context::ExecutionContext::new(
run_type,
sudo,
&config,
#[cfg(target_os = "linux")]
&distribution,
);
let mut runner = runner::Runner::new(&ctx);
// If
@@ -170,7 +173,7 @@ fn run() -> Result<()> {
let should_self_update = env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !config.no_self_update();
if should_self_update {
runner.execute(Step::SelfUpdate, "Self Update", || self_update::self_update(&ctx))?;
runner.execute(step::Step::SelfUpdate, "Self Update", || self_update::self_update(&ctx))?;
}
}
@@ -193,344 +196,9 @@ fn run() -> Result<()> {
}
}
if let Some(topgrades) = config.remote_topgrades() {
for remote_topgrade in topgrades.iter().filter(|t| config.should_execute_remote(hostname(), t)) {
runner.execute(Step::Remotes, format!("Remote ({remote_topgrade})"), || {
ssh::ssh_step(&ctx, remote_topgrade)
})?;
for step in step::default_steps() {
step.run(&mut runner, &ctx)?
}
}
#[cfg(windows)]
{
runner.execute(Step::Wsl, "WSL", || windows::run_wsl_topgrade(&ctx))?;
runner.execute(Step::WslUpdate, "WSL", || windows::update_wsl(&ctx))?;
runner.execute(Step::Chocolatey, "Chocolatey", || windows::run_chocolatey(&ctx))?;
runner.execute(Step::Scoop, "Scoop", || windows::run_scoop(&ctx))?;
runner.execute(Step::Winget, "Winget", || windows::run_winget(&ctx))?;
runner.execute(Step::System, "Windows update", || windows::windows_update(&ctx))?;
runner.execute(Step::MicrosoftStore, "Microsoft Store", || {
windows::microsoft_store(&ctx)
})?;
}
#[cfg(target_os = "linux")]
{
// NOTE: Due to breaking `nu` updates, `packer.nu` needs to be updated before `nu` get updated
// by other package managers.
runner.execute(Step::Shell, "packer.nu", || linux::run_packer_nu(&ctx))?;
match &distribution {
Ok(distribution) => {
runner.execute(Step::System, "System update", || distribution.upgrade(&ctx))?;
}
Err(e) => {
println!("{}", t!("Error detecting current distribution: {error}", error = e));
}
}
runner.execute(Step::ConfigUpdate, "config-update", || linux::run_config_update(&ctx))?;
runner.execute(Step::AM, "am", || linux::run_am(&ctx))?;
runner.execute(Step::AppMan, "appman", || linux::run_appman(&ctx))?;
runner.execute(Step::DebGet, "deb-get", || linux::run_deb_get(&ctx))?;
runner.execute(Step::Toolbx, "toolbx", || toolbx::run_toolbx(&ctx))?;
runner.execute(Step::Snap, "snap", || linux::run_snap(&ctx))?;
runner.execute(Step::Pacstall, "pacstall", || linux::run_pacstall(&ctx))?;
runner.execute(Step::Pacdef, "pacdef", || linux::run_pacdef(&ctx))?;
runner.execute(Step::Protonup, "protonup", || linux::run_protonup_update(&ctx))?;
runner.execute(Step::Distrobox, "distrobox", || linux::run_distrobox_update(&ctx))?;
runner.execute(Step::DkpPacman, "dkp-pacman", || linux::run_dkp_pacman_update(&ctx))?;
runner.execute(Step::System, "pihole", || linux::run_pihole_update(&ctx))?;
runner.execute(Step::Firmware, "Firmware upgrades", || linux::run_fwupdmgr(&ctx))?;
runner.execute(Step::Restarts, "Restarts", || linux::run_needrestart(&ctx))?;
runner.execute(Step::Flatpak, "Flatpak", || linux::run_flatpak(&ctx))?;
runner.execute(Step::BrewFormula, "Brew", || {
unix::run_brew_formula(&ctx, unix::BrewVariant::Path)
})?;
runner.execute(Step::Lure, "LURE", || linux::run_lure_update(&ctx))?;
runner.execute(Step::Waydroid, "Waydroid", || linux::run_waydroid(&ctx))?;
runner.execute(Step::AutoCpufreq, "auto-cpufreq", || linux::run_auto_cpufreq(&ctx))?;
runner.execute(Step::CinnamonSpices, "Cinnamon spices", || {
linux::run_cinnamon_spices_updater(&ctx)
})?;
}
#[cfg(target_os = "macos")]
{
runner.execute(Step::BrewFormula, "Brew (ARM)", || {
unix::run_brew_formula(&ctx, unix::BrewVariant::MacArm)
})?;
runner.execute(Step::BrewFormula, "Brew (Intel)", || {
unix::run_brew_formula(&ctx, unix::BrewVariant::MacIntel)
})?;
runner.execute(Step::BrewFormula, "Brew", || {
unix::run_brew_formula(&ctx, unix::BrewVariant::Path)
})?;
runner.execute(Step::BrewCask, "Brew Cask (ARM)", || {
unix::run_brew_cask(&ctx, unix::BrewVariant::MacArm)
})?;
runner.execute(Step::BrewCask, "Brew Cask (Intel)", || {
unix::run_brew_cask(&ctx, unix::BrewVariant::MacIntel)
})?;
runner.execute(Step::BrewCask, "Brew Cask", || {
unix::run_brew_cask(&ctx, unix::BrewVariant::Path)
})?;
runner.execute(Step::Macports, "MacPorts", || macos::run_macports(&ctx))?;
runner.execute(Step::Xcodes, "Xcodes", || macos::update_xcodes(&ctx))?;
runner.execute(Step::Sparkle, "Sparkle", || macos::run_sparkle(&ctx))?;
runner.execute(Step::Mas, "App Store", || macos::run_mas(&ctx))?;
runner.execute(Step::System, "System upgrade", || macos::upgrade_macos(&ctx))?;
}
#[cfg(target_os = "dragonfly")]
{
runner.execute(Step::Pkg, "DragonFly BSD Packages", || {
dragonfly::upgrade_packages(&ctx)
})?;
runner.execute(Step::Audit, "DragonFly Audit", || dragonfly::audit_packages(&ctx))?;
}
#[cfg(target_os = "freebsd")]
{
runner.execute(Step::Pkg, "FreeBSD Packages", || freebsd::upgrade_packages(&ctx))?;
runner.execute(Step::System, "FreeBSD Upgrade", || freebsd::upgrade_freebsd(&ctx))?;
runner.execute(Step::Audit, "FreeBSD Audit", || freebsd::audit_packages(&ctx))?;
}
#[cfg(target_os = "openbsd")]
{
runner.execute(Step::Pkg, "OpenBSD Packages", || openbsd::upgrade_packages(&ctx))?;
runner.execute(Step::System, "OpenBSD Upgrade", || openbsd::upgrade_openbsd(&ctx))?;
}
#[cfg(target_os = "android")]
{
runner.execute(Step::Pkg, "Termux Packages", || android::upgrade_packages(&ctx))?;
}
#[cfg(unix)]
{
runner.execute(Step::Yadm, "yadm", || unix::run_yadm(&ctx))?;
runner.execute(Step::Nix, "nix", || unix::run_nix(&ctx))?;
runner.execute(Step::Nix, "nix upgrade-nix", || unix::run_nix_self_upgrade(&ctx))?;
runner.execute(Step::NixHelper, "nh", || unix::run_nix_helper(&ctx))?;
runner.execute(Step::Guix, "guix", || unix::run_guix(&ctx))?;
runner.execute(Step::HomeManager, "home-manager", || unix::run_home_manager(&ctx))?;
runner.execute(Step::Asdf, "asdf", || unix::run_asdf(&ctx))?;
runner.execute(Step::Mise, "mise", || unix::run_mise(&ctx))?;
runner.execute(Step::Pkgin, "pkgin", || unix::run_pkgin(&ctx))?;
runner.execute(Step::BunPackages, "bun-packages", || unix::run_bun_packages(&ctx))?;
runner.execute(Step::Shell, "zr", || zsh::run_zr(&ctx))?;
runner.execute(Step::Shell, "antibody", || zsh::run_antibody(&ctx))?;
runner.execute(Step::Shell, "antidote", || zsh::run_antidote(&ctx))?;
runner.execute(Step::Shell, "antigen", || zsh::run_antigen(&ctx))?;
runner.execute(Step::Shell, "zgenom", || zsh::run_zgenom(&ctx))?;
runner.execute(Step::Shell, "zplug", || zsh::run_zplug(&ctx))?;
runner.execute(Step::Shell, "zinit", || zsh::run_zinit(&ctx))?;
runner.execute(Step::Shell, "zi", || zsh::run_zi(&ctx))?;
runner.execute(Step::Shell, "zim", || zsh::run_zim(&ctx))?;
runner.execute(Step::Shell, "oh-my-zsh", || zsh::run_oh_my_zsh(&ctx))?;
runner.execute(Step::Shell, "oh-my-bash", || unix::run_oh_my_bash(&ctx))?;
runner.execute(Step::Shell, "fisher", || unix::run_fisher(&ctx))?;
runner.execute(Step::Shell, "bash-it", || unix::run_bashit(&ctx))?;
runner.execute(Step::Shell, "oh-my-fish", || unix::run_oh_my_fish(&ctx))?;
runner.execute(Step::Shell, "fish-plug", || unix::run_fish_plug(&ctx))?;
runner.execute(Step::Shell, "fundle", || unix::run_fundle(&ctx))?;
runner.execute(Step::Tmux, "tmux", || tmux::run_tpm(&ctx))?;
runner.execute(Step::Tldr, "TLDR", || unix::run_tldr(&ctx))?;
runner.execute(Step::Pearl, "pearl", || unix::run_pearl(&ctx))?;
#[cfg(not(any(target_os = "macos", target_os = "android")))]
runner.execute(Step::GnomeShellExtensions, "Gnome Shell Extensions", || {
unix::upgrade_gnome_extensions(&ctx)
})?;
runner.execute(Step::Pyenv, "pyenv", || unix::run_pyenv(&ctx))?;
runner.execute(Step::Sdkman, "SDKMAN!", || unix::run_sdkman(&ctx))?;
runner.execute(Step::Rcm, "rcm", || unix::run_rcm(&ctx))?;
runner.execute(Step::Maza, "maza", || unix::run_maza(&ctx))?;
}
#[cfg(not(any(
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
target_os = "dragonfly"
)))]
{
runner.execute(Step::Atom, "apm", || generic::run_apm(&ctx))?;
}
// The following update function should be executed on all OSes.
runner.execute(Step::Fossil, "fossil", || generic::run_fossil(&ctx))?;
runner.execute(Step::Elan, "elan", || generic::run_elan(&ctx))?;
runner.execute(Step::Rye, "rye", || generic::run_rye(&ctx))?;
runner.execute(Step::Rustup, "rustup", || generic::run_rustup(&ctx))?;
runner.execute(Step::Juliaup, "juliaup", || generic::run_juliaup(&ctx))?;
runner.execute(Step::Dotnet, ".NET", || generic::run_dotnet_upgrade(&ctx))?;
runner.execute(Step::Choosenim, "choosenim", || generic::run_choosenim(&ctx))?;
runner.execute(Step::Cargo, "cargo", || generic::run_cargo_update(&ctx))?;
runner.execute(Step::Flutter, "Flutter", || generic::run_flutter_upgrade(&ctx))?;
runner.execute(Step::Go, "go-global-update", || go::run_go_global_update(&ctx))?;
runner.execute(Step::Go, "gup", || go::run_go_gup(&ctx))?;
runner.execute(Step::Emacs, "Emacs", || emacs.upgrade(&ctx))?;
runner.execute(Step::Opam, "opam", || generic::run_opam_update(&ctx))?;
runner.execute(Step::Vcpkg, "vcpkg", || generic::run_vcpkg_update(&ctx))?;
runner.execute(Step::Pipx, "pipx", || generic::run_pipx_update(&ctx))?;
runner.execute(Step::Pipxu, "pipxu", || generic::run_pipxu_update(&ctx))?;
runner.execute(Step::Vscode, "Visual Studio Code extensions", || {
generic::run_vscode_extensions_update(&ctx)
})?;
runner.execute(Step::Vscodium, "VSCodium extensions", || {
generic::run_vscodium_extensions_update(&ctx)
})?;
runner.execute(Step::Conda, "conda", || generic::run_conda_update(&ctx))?;
runner.execute(Step::Mamba, "mamba", || generic::run_mamba_update(&ctx))?;
runner.execute(Step::Pixi, "pixi", || generic::run_pixi_update(&ctx))?;
runner.execute(Step::Miktex, "miktex", || generic::run_miktex_packages_update(&ctx))?;
runner.execute(Step::Pip3, "pip3", || generic::run_pip3_update(&ctx))?;
runner.execute(Step::PipReview, "pip-review", || generic::run_pip_review_update(&ctx))?;
runner.execute(Step::PipReviewLocal, "pip-review (local)", || {
generic::run_pip_review_local_update(&ctx)
})?;
runner.execute(Step::Pipupgrade, "pipupgrade", || generic::run_pipupgrade_update(&ctx))?;
runner.execute(Step::Ghcup, "ghcup", || generic::run_ghcup_update(&ctx))?;
runner.execute(Step::Stack, "stack", || generic::run_stack_update(&ctx))?;
runner.execute(Step::Tlmgr, "tlmgr", || generic::run_tlmgr_update(&ctx))?;
runner.execute(Step::Myrepos, "myrepos", || generic::run_myrepos_update(&ctx))?;
runner.execute(Step::Chezmoi, "chezmoi", || generic::run_chezmoi_update(&ctx))?;
runner.execute(Step::Jetpack, "jetpack", || generic::run_jetpack(&ctx))?;
runner.execute(Step::Vim, "vim", || vim::upgrade_vim(&ctx))?;
runner.execute(Step::Vim, "Neovim", || vim::upgrade_neovim(&ctx))?;
runner.execute(Step::Vim, "The Ultimate vimrc", || vim::upgrade_ultimate_vimrc(&ctx))?;
runner.execute(Step::Vim, "voom", || vim::run_voom(&ctx))?;
runner.execute(Step::Kakoune, "Kakoune", || kakoune::upgrade_kak_plug(&ctx))?;
runner.execute(Step::Helix, "helix", || generic::run_helix_grammars(&ctx))?;
runner.execute(Step::Node, "npm", || node::run_npm_upgrade(&ctx))?;
runner.execute(Step::Yarn, "yarn", || node::run_yarn_upgrade(&ctx))?;
runner.execute(Step::Pnpm, "pnpm", || node::run_pnpm_upgrade(&ctx))?;
runner.execute(Step::VoltaPackages, "volta packages", || {
node::run_volta_packages_upgrade(&ctx)
})?;
runner.execute(Step::Containers, "Containers", || containers::run_containers(&ctx))?;
runner.execute(Step::Deno, "deno", || node::deno_upgrade(&ctx))?;
runner.execute(Step::Composer, "composer", || generic::run_composer_update(&ctx))?;
runner.execute(Step::Krew, "krew", || generic::run_krew_upgrade(&ctx))?;
runner.execute(Step::Helm, "helm", || generic::run_helm_repo_update(&ctx))?;
runner.execute(Step::Gem, "gem", || generic::run_gem(&ctx))?;
runner.execute(Step::RubyGems, "rubygems", || generic::run_rubygems(&ctx))?;
runner.execute(Step::Julia, "julia", || generic::update_julia_packages(&ctx))?;
runner.execute(Step::Haxelib, "haxelib", || generic::run_haxelib_update(&ctx))?;
runner.execute(Step::Sheldon, "sheldon", || generic::run_sheldon(&ctx))?;
runner.execute(Step::Stew, "stew", || generic::run_stew(&ctx))?;
runner.execute(Step::Rtcl, "rtcl", || generic::run_rtcl(&ctx))?;
runner.execute(Step::Bin, "bin", || generic::bin_update(&ctx))?;
runner.execute(Step::Gcloud, "gcloud", || generic::run_gcloud_components_update(&ctx))?;
runner.execute(Step::Micro, "micro", || generic::run_micro(&ctx))?;
runner.execute(Step::Raco, "raco", || generic::run_raco_update(&ctx))?;
runner.execute(Step::Spicetify, "spicetify", || generic::spicetify_upgrade(&ctx))?;
runner.execute(Step::GithubCliExtensions, "GitHub CLI Extensions", || {
generic::run_ghcli_extensions_upgrade(&ctx)
})?;
runner.execute(Step::Bob, "Bob", || generic::run_bob(&ctx))?;
runner.execute(Step::Certbot, "Certbot", || generic::run_certbot(&ctx))?;
runner.execute(Step::GitRepos, "Git Repositories", || git::run_git_pull(&ctx))?;
runner.execute(Step::ClamAvDb, "ClamAV Databases", || generic::run_freshclam(&ctx))?;
runner.execute(Step::PlatformioCore, "PlatformIO Core", || {
generic::run_platform_io(&ctx)
})?;
runner.execute(Step::Lensfun, "Lensfun's database update", || {
generic::run_lensfun_update_data(&ctx)
})?;
runner.execute(Step::Poetry, "Poetry", || generic::run_poetry(&ctx))?;
runner.execute(Step::Uv, "uv", || generic::run_uv(&ctx))?;
runner.execute(Step::Zvm, "ZVM", || generic::run_zvm(&ctx))?;
runner.execute(Step::Aqua, "aqua", || generic::run_aqua(&ctx))?;
runner.execute(Step::Bun, "bun", || generic::run_bun(&ctx))?;
runner.execute(Step::Zigup, "zigup", || generic::run_zigup(&ctx))?;
runner.execute(Step::JetbrainsToolbox, "JetBrains Toolbox", || {
generic::run_jetbrains_toolbox(&ctx)
})?;
runner.execute(Step::AndroidStudio, "Android Studio plugins", || {
generic::run_android_studio(&ctx)
})?;
runner.execute(Step::JetbrainsAqua, "JetBrains Aqua plugins", || {
generic::run_jetbrains_aqua(&ctx)
})?;
runner.execute(Step::JetbrainsClion, "JetBrains CLion plugins", || {
generic::run_jetbrains_clion(&ctx)
})?;
runner.execute(Step::JetbrainsDatagrip, "JetBrains DataGrip plugins", || {
generic::run_jetbrains_datagrip(&ctx)
})?;
runner.execute(Step::JetbrainsDataspell, "JetBrains DataSpell plugins", || {
generic::run_jetbrains_dataspell(&ctx)
})?;
// JetBrains dotCover has no CLI
// JetBrains dotMemory has no CLI
// JetBrains dotPeek has no CLI
// JetBrains dotTrace has no CLI
// JetBrains Fleet has a different CLI without a `fleet update` command.
runner.execute(Step::JetbrainsGateway, "JetBrains Gateway plugins", || {
generic::run_jetbrains_gateway(&ctx)
})?;
runner.execute(Step::JetbrainsGoland, "JetBrains GoLand plugins", || {
generic::run_jetbrains_goland(&ctx)
})?;
runner.execute(Step::JetbrainsIdea, "JetBrains IntelliJ IDEA plugins", || {
generic::run_jetbrains_idea(&ctx)
})?;
runner.execute(Step::JetbrainsMps, "JetBrains MPS plugins", || {
generic::run_jetbrains_mps(&ctx)
})?;
runner.execute(Step::JetbrainsPhpstorm, "JetBrains PhpStorm plugins", || {
generic::run_jetbrains_phpstorm(&ctx)
})?;
runner.execute(Step::JetbrainsPycharm, "JetBrains PyCharm plugins", || {
generic::run_jetbrains_pycharm(&ctx)
})?;
// JetBrains ReSharper has no CLI (it's a VSCode extension)
// JetBrains ReSharper C++ has no CLI (it's a VSCode extension)
runner.execute(Step::JetbrainsRider, "JetBrains Rider plugins", || {
generic::run_jetbrains_rider(&ctx)
})?;
runner.execute(Step::JetbrainsRubymine, "JetBrains RubyMine plugins", || {
generic::run_jetbrains_rubymine(&ctx)
})?;
runner.execute(Step::JetbrainsRustrover, "JetBrains RustRover plugins", || {
generic::run_jetbrains_rustrover(&ctx)
})?;
// JetBrains Space Desktop does not have a CLI
runner.execute(Step::JetbrainsWebstorm, "JetBrains WebStorm plugins", || {
generic::run_jetbrains_webstorm(&ctx)
})?;
runner.execute(Step::Yazi, "Yazi packages", || generic::run_yazi(&ctx))?;
if should_run_powershell {
runner.execute(Step::Powershell, "Powershell Modules Update", || {
powershell.update_modules(&ctx)
})?;
}
if let Some(commands) = config.commands() {
for (name, command) in commands {
if config.should_run_custom_command(name) {
runner.execute(Step::CustomCommands, name, || {
generic::run_custom_command(name, command, &ctx)
})?;
}
}
}
if config.should_run(Step::Vagrant) {
if let Ok(boxes) = vagrant::collect_boxes(&ctx) {
for vagrant_box in boxes {
runner.execute(Step::Vagrant, format!("Vagrant ({})", vagrant_box.smart_name()), || {
vagrant::topgrade_vagrant_box(&ctx, &vagrant_box)
})?;
}
}
}
runner.execute(Step::Vagrant, "Vagrant boxes", || vagrant::upgrade_vagrant_boxes(&ctx))?;
if !runner.report().data().is_empty() {
print_separator(t!("Summary"));

3
src/runner.rs
View File

@@ -2,8 +2,9 @@ use crate::ctrlc;
use crate::error::{DryRun, SkipStep};
use crate::execution_context::ExecutionContext;
use crate::report::{Report, StepResult};
use crate::step::Step;
use crate::terminal::print_error;
use crate::{config::Step, terminal::should_retry};
use crate::terminal::should_retry;
use color_eyre::eyre::Result;
use std::borrow::Cow;
use std::fmt::Debug;

2
src/self_update.rs
View File

@@ -3,7 +3,7 @@ use std::env;
use std::os::unix::process::CommandExt as _;
use std::process::Command;
use crate::config::Step;
use crate::step::Step;
use color_eyre::eyre::{bail, Result};
use rust_i18n::t;
use self_update_crate::backends::github::Update;

859
src/step.rs Normal file
View File

@@ -0,0 +1,859 @@
use crate::execution_context::ExecutionContext;
use crate::runner::Runner;
use clap::ValueEnum;
use color_eyre::Result;
#[cfg(target_os = "linux")]
use rust_i18n::t;
use serde::Deserialize;
use strum::{EnumCount, EnumIter, EnumString, VariantNames};
#[cfg(feature = "self-update")]
use crate::self_update;
use crate::steps::remote::vagrant;
#[allow(clippy::wildcard_imports)]
use crate::steps::*;
use crate::utils::hostname;
#[derive(ValueEnum, EnumString, VariantNames, Debug, Clone, PartialEq, Eq, Deserialize, EnumIter, Copy, EnumCount)]
#[clap(rename_all = "snake_case")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum Step {
AM,
AndroidStudio,
AppMan,
Aqua,
Asdf,
Atom,
Audit,
AutoCpufreq,
Bin,
Bob,
BrewCask,
BrewFormula,
Bun,
BunPackages,
Cargo,
Certbot,
Chezmoi,
Chocolatey,
Choosenim,
CinnamonSpices,
ClamAvDb,
Composer,
Conda,
ConfigUpdate,
Containers,
CustomCommands,
DebGet,
Deno,
Distrobox,
DkpPacman,
Dotnet,
Elan,
Emacs,
Firmware,
Flatpak,
Flutter,
Fossil,
Gcloud,
Gem,
Ghcup,
GitRepos,
GithubCliExtensions,
GnomeShellExtensions,
Go,
Guix,
Haxelib,
Helix,
Helm,
HomeManager,
// These names are miscapitalized on purpose, so the CLI name is
// `jetbrains_pycharm` instead of `jet_brains_py_charm`.
JetbrainsAqua,
JetbrainsClion,
JetbrainsDatagrip,
JetbrainsDataspell,
JetbrainsGateway,
JetbrainsGoland,
JetbrainsIdea,
JetbrainsMps,
JetbrainsPhpstorm,
JetbrainsPycharm,
JetbrainsRider,
JetbrainsRubymine,
JetbrainsRustrover,
JetbrainsToolbox,
JetbrainsWebstorm,
Jetpack,
Julia,
Juliaup,
Kakoune,
Krew,
Lensfun,
Lure,
Macports,
Mamba,
Mas,
Maza,
Micro,
MicrosoftStore,
Miktex,
Mise,
Myrepos,
Nix,
NixHelper,
Node,
Opam,
Pacdef,
Pacstall,
Pearl,
Pip3,
PipReview,
PipReviewLocal,
Pipupgrade,
Pipx,
Pipxu,
Pixi,
Pkg,
Pkgin,
PlatformioCore,
Pnpm,
Poetry,
Powershell,
Protonup,
Pyenv,
Raco,
Rcm,
Remotes,
Restarts,
Rtcl,
RubyGems,
Rustup,
Rye,
Scoop,
Sdkman,
SelfUpdate,
Sheldon,
Shell,
Snap,
Sparkle,
Spicetify,
Stack,
Stew,
System,
Tldr,
Tlmgr,
Tmux,
Toolbx,
Uv,
Vagrant,
Vcpkg,
Vim,
VoltaPackages,
Vscode,
Vscodium,
Waydroid,
Winget,
Wsl,
WslUpdate,
Xcodes,
Yadm,
Yarn,
Yazi,
Zigup,
Zvm,
}
impl Step {
#[allow(clippy::too_many_lines)]
pub fn run(&self, runner: &mut Runner, ctx: &ExecutionContext) -> Result<()> {
use Step::*;
match *self {
AM =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "am", || linux::run_am(ctx))?
}
AndroidStudio => runner.execute(*self, "Android Studio Plugins", || generic::run_android_studio(ctx))?,
AppMan =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "appman", || linux::run_appman(ctx))?
}
Aqua => runner.execute(*self, "aqua", || generic::run_aqua(ctx))?,
Asdf =>
{
#[cfg(unix)]
runner.execute(*self, "asdf", || unix::run_asdf(ctx))?
}
Atom =>
{
#[cfg(not(any(
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
target_os = "dragonfly"
)))]
runner.execute(*self, "apm", || generic::run_apm(ctx))?
}
Audit => {
#[cfg(target_os = "dragonfly")]
runner.execute(*self, "DragonFly Audit", || dragonfly::audit_packages(ctx))?;
#[cfg(target_os = "freebsd")]
runner.execute(*self, "FreeBSD Audit", || freebsd::audit_packages(ctx))?
}
AutoCpufreq =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "auto-cpufreq", || linux::run_auto_cpufreq(ctx))?
}
Bin => runner.execute(*self, "bin", || generic::bin_update(ctx))?,
Bob => runner.execute(*self, "Bob", || generic::run_bob(ctx))?,
BrewCask => {
#[cfg(target_os = "macos")]
runner.execute(*self, "Brew Cask", || unix::run_brew_cask(ctx, unix::BrewVariant::Path))?;
#[cfg(target_os = "macos")]
runner.execute(*self, "Brew Cask (Intel)", || {
unix::run_brew_cask(ctx, unix::BrewVariant::MacIntel)
})?;
#[cfg(target_os = "macos")]
runner.execute(*self, "Brew Cask (ARM)", || {
unix::run_brew_cask(ctx, unix::BrewVariant::MacArm)
})?
}
BrewFormula => {
#[cfg(target_os = "linux")]
runner.execute(*self, "Brew", || unix::run_brew_formula(ctx, unix::BrewVariant::Path))?;
#[cfg(target_os = "macos")]
runner.execute(*self, "Brew (ARM)", || {
unix::run_brew_formula(ctx, unix::BrewVariant::MacArm)
})?;
#[cfg(target_os = "macos")]
runner.execute(*self, "Brew (Intel)", || {
unix::run_brew_formula(ctx, unix::BrewVariant::MacIntel)
})?
}
Bun => runner.execute(*self, "bun", || generic::run_bun(ctx))?,
BunPackages =>
{
#[cfg(unix)]
runner.execute(*self, "bun-packages", || unix::run_bun_packages(ctx))?
}
Cargo => runner.execute(*self, "cargo", || generic::run_cargo_update(ctx))?,
Certbot => runner.execute(*self, "Certbot", || generic::run_certbot(ctx))?,
Chezmoi => runner.execute(*self, "chezmoi", || generic::run_chezmoi_update(ctx))?,
Chocolatey =>
{
#[cfg(windows)]
runner.execute(*self, "Chocolatey", || windows::run_chocolatey(ctx))?
}
Choosenim => runner.execute(*self, "choosenim", || generic::run_choosenim(ctx))?,
CinnamonSpices =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "Cinnamon spices", || linux::run_cinnamon_spices_updater(ctx))?
}
ClamAvDb => runner.execute(*self, "ClamAV Databases", || generic::run_freshclam(ctx))?,
Composer => runner.execute(*self, "composer", || generic::run_composer_update(ctx))?,
Conda => runner.execute(*self, "conda", || generic::run_conda_update(ctx))?,
ConfigUpdate =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "config-update", || linux::run_config_update(ctx))?
}
Containers => runner.execute(*self, "Containers", || containers::run_containers(ctx))?,
CustomCommands => {
if let Some(commands) = ctx.config().pre_commands() {
for (name, command) in commands {
generic::run_custom_command(name, command, ctx)?;
}
}
}
DebGet =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "deb-get", || linux::run_deb_get(ctx))?
}
Deno => runner.execute(*self, "deno", || node::deno_upgrade(ctx))?,
Distrobox =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "distrobox", || linux::run_distrobox_update(ctx))?
}
DkpPacman =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "dkp-pacman", || linux::run_dkp_pacman_update(ctx))?
}
Dotnet => runner.execute(*self, ".NET", || generic::run_dotnet_upgrade(ctx))?,
Elan => runner.execute(*self, "elan", || generic::run_elan(ctx))?,
Emacs => runner.execute(*self, "Emacs", || emacs::Emacs::new().upgrade(ctx))?,
Firmware =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "Firmware", || linux::run_fwupdmgr(ctx))?
}
Flatpak =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "Flatpak", || linux::run_flatpak(ctx))?
}
Flutter => runner.execute(*self, "Flutter", || generic::run_flutter_upgrade(ctx))?,
Fossil => runner.execute(*self, "fossil", || generic::run_fossil(ctx))?,
Gcloud => runner.execute(*self, "gcloud", || generic::run_gcloud_components_update(ctx))?,
Gem => runner.execute(*self, "gem", || generic::run_gem(ctx))?,
Ghcup => runner.execute(*self, "ghcup", || generic::run_ghcup_update(ctx))?,
GitRepos => runner.execute(*self, "Git Repositories", || git::run_git_pull(ctx))?,
GithubCliExtensions => runner.execute(*self, "GitHub CLI Extenstions", || {
generic::run_ghcli_extensions_upgrade(ctx)
})?,
GnomeShellExtensions =>
{
#[cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))]
runner.execute(*self, "Gnome Shell Extensions", || unix::upgrade_gnome_extensions(ctx))?
}
Go => {
runner.execute(*self, "go-global-update", || go::run_go_global_update(ctx))?;
runner.execute(*self, "gup", || go::run_go_gup(ctx))?
}
Guix =>
{
#[cfg(unix)]
runner.execute(*self, "guix", || unix::run_guix(ctx))?
}
Haxelib => runner.execute(*self, "haxelib", || generic::run_haxelib_update(ctx))?,
Helix => runner.execute(*self, "helix", || generic::run_helix_grammars(ctx))?,
Helm => runner.execute(*self, "helm", || generic::run_helm_repo_update(ctx))?,
HomeManager =>
{
#[cfg(unix)]
runner.execute(*self, "home-manager", || unix::run_home_manager(ctx))?
}
JetbrainsAqua => runner.execute(*self, "JetBrains Aqua Plugins", || generic::run_jetbrains_aqua(ctx))?,
JetbrainsClion => runner.execute(*self, "JetBrains CL", || generic::run_jetbrains_clion(ctx))?,
JetbrainsDatagrip => {
runner.execute(*self, "JetBrains DataGrip", || generic::run_jetbrains_datagrip(ctx))?
}
JetbrainsDataspell => runner.execute(*self, "JetBrains DataSpell Plugins", || {
generic::run_jetbrains_dataspell(ctx)
})?,
JetbrainsGateway => runner.execute(*self, "JetBrains Gateway Plugins", || {
generic::run_jetbrains_gateway(ctx)
})?,
JetbrainsGoland => {
runner.execute(*self, "JetBrains GoLand Plugins", || generic::run_jetbrains_goland(ctx))?
}
JetbrainsIdea => runner.execute(*self, "JetBrains IntelliJ IDEA Plugins", || {
generic::run_jetbrains_idea(ctx)
})?,
JetbrainsMps => runner.execute(*self, "JetBrains MPS Plugins", || generic::run_jetbrains_mps(ctx))?,
JetbrainsPhpstorm => runner.execute(*self, "JetBrains PhpStorm Plugins", || {
generic::run_jetbrains_phpstorm(ctx)
})?,
JetbrainsPycharm => runner.execute(*self, "JetBrains PyCharm Plugins", || {
generic::run_jetbrains_pycharm(ctx)
})?,
JetbrainsRider => runner.execute(*self, "JetBrains Rider Plugins", || generic::run_jetbrains_rider(ctx))?,
JetbrainsRubymine => runner.execute(*self, "JetBrains RubyMine Plugins", || {
generic::run_jetbrains_rubymine(ctx)
})?,
JetbrainsRustrover => runner.execute(*self, "JetBrains RustRover Plugins", || {
generic::run_jetbrains_rustrover(ctx)
})?,
JetbrainsToolbox => runner.execute(*self, "JetBrains Toolbox", || generic::run_jetbrains_toolbox(ctx))?,
JetbrainsWebstorm => runner.execute(*self, "JetBrains WebStorm Plugins", || {
generic::run_jetbrains_webstorm(ctx)
})?,
Jetpack => runner.execute(*self, "jetpack", || generic::run_jetpack(ctx))?,
Julia => runner.execute(*self, "julia", || generic::update_julia_packages(ctx))?,
Juliaup => runner.execute(*self, "juliaup", || generic::run_juliaup(ctx))?,
Kakoune => runner.execute(*self, "Kakoune", || kakoune::upgrade_kak_plug(ctx))?,
Krew => runner.execute(*self, "krew", || generic::run_krew_upgrade(ctx))?,
Lensfun => runner.execute(*self, "Lensfun's database update", || {
generic::run_lensfun_update_data(ctx)
})?,
Lure =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "LURE", || linux::run_lure_update(ctx))?
}
Macports =>
{
#[cfg(target_os = "macos")]
runner.execute(*self, "MacPorts", || macos::run_macports(ctx))?
}
Mamba => runner.execute(*self, "mamba", || generic::run_mamba_update(ctx))?,
Mas =>
{
#[cfg(target_os = "macos")]
runner.execute(*self, "App Store", || macos::run_mas(ctx))?
}
Maza =>
{
#[cfg(unix)]
runner.execute(*self, "maza", || unix::run_maza(ctx))?
}
Micro => runner.execute(*self, "micro", || generic::run_micro(ctx))?,
MicrosoftStore =>
{
#[cfg(windows)]
runner.execute(*self, "Microsoft Store", || windows::microsoft_store(ctx))?
}
Miktex => runner.execute(*self, "miktex", || generic::run_miktex_packages_update(ctx))?,
Mise =>
{
#[cfg(unix)]
runner.execute(*self, "mise", || unix::run_mise(ctx))?
}
Myrepos => runner.execute(*self, "myrepos", || generic::run_myrepos_update(ctx))?,
Nix => {
#[cfg(unix)]
runner.execute(*self, "nix", || unix::run_nix(ctx))?;
#[cfg(unix)]
runner.execute(*self, "nix upgrade-nix", || unix::run_nix_self_upgrade(ctx))?
}
NixHelper =>
{
#[cfg(unix)]
runner.execute(*self, "nh", || unix::run_nix_helper(ctx))?
}
Node => runner.execute(*self, "npm", || node::run_npm_upgrade(ctx))?,
Opam => runner.execute(*self, "opam", || generic::run_opam_update(ctx))?,
Pacdef =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "pacdef", || linux::run_pacdef(ctx))?
}
Pacstall =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "pacstall", || linux::run_pacstall(ctx))?
}
Pearl =>
{
#[cfg(unix)]
runner.execute(*self, "pearl", || unix::run_pearl(ctx))?
}
Pip3 => runner.execute(*self, "pip3", || generic::run_pip3_update(ctx))?,
PipReview => runner.execute(*self, "pip-review", || generic::run_pip_review_update(ctx))?,
PipReviewLocal => runner.execute(*self, "pip-review (local)", || {
generic::run_pip_review_local_update(ctx)
})?,
Pipupgrade => runner.execute(*self, "pipupgrade", || generic::run_pipupgrade_update(ctx))?,
Pipx => runner.execute(*self, "pipx", || generic::run_pipx_update(ctx))?,
Pipxu => runner.execute(*self, "pipxu", || generic::run_pipxu_update(ctx))?,
Pixi => runner.execute(*self, "pixi", || generic::run_pixi_update(ctx))?,
Pkg => {
#[cfg(target_os = "dragonfly")]
runner.execute(*self, "Dragonfly BSD Packages", || dragonfly::upgrade_packages(ctx))?;
#[cfg(target_os = "freebsd")]
runner.execute(*self, "FreeBSD Packages", || freebsd::upgrade_packages(ctx))?;
#[cfg(target_os = "openbsd")]
runner.execute(*self, "OpenBSD Packages", || openbsd::upgrade_packages(ctx))?;
#[cfg(target_os = "android")]
runner.execute(*self, "Termux Packages", || android::upgrade_packages(ctx))?
}
Pkgin =>
{
#[cfg(unix)]
runner.execute(*self, "pkgin", || unix::run_pkgin(ctx))?
}
PlatformioCore => runner.execute(*self, "PlatformIO Core", || generic::run_platform_io(ctx))?,
Pnpm => runner.execute(*self, "pnpm", || node::run_pnpm_upgrade(ctx))?,
Poetry => runner.execute(*self, "Poetry", || generic::run_poetry(ctx))?,
Powershell => {
let powershell = powershell::Powershell::new();
if powershell.profile().is_some() {
runner.execute(Powershell, "Powershell Modules Update", || {
powershell.update_modules(ctx)
})?;
}
}
Protonup =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "protonup", || linux::run_protonup_update(ctx))?
}
Pyenv =>
{
#[cfg(unix)]
runner.execute(*self, "pyenv", || unix::run_pyenv(ctx))?
}
Raco => runner.execute(*self, "raco", || generic::run_raco_update(ctx))?,
Rcm =>
{
#[cfg(unix)]
runner.execute(*self, "rcm", || unix::run_rcm(ctx))?
}
Remotes => {
if let Some(topgrades) = ctx.config().remote_topgrades() {
for remote_topgrade in topgrades
.iter()
.filter(|t| ctx.config().should_execute_remote(hostname(), t))
{
runner.execute(Remotes, format!("Remote ({remote_topgrade})"), || {
crate::ssh::ssh_step(ctx, remote_topgrade)
})?;
}
}
}
Restarts =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "Restarts", || linux::run_needrestart(ctx))?
}
Rtcl => runner.execute(*self, "rtcl", || generic::run_rtcl(ctx))?,
RubyGems => runner.execute(*self, "rubygems", || generic::run_rubygems(ctx))?,
Rustup => runner.execute(*self, "rustup", || generic::run_rustup(ctx))?,
Rye => runner.execute(*self, "rye", || generic::run_rye(ctx))?,
Scoop =>
{
#[cfg(windows)]
runner.execute(*self, "Scoop", || windows::run_scoop(ctx))?
}
Sdkman =>
{
#[cfg(unix)]
runner.execute(*self, "SDKMAN!", || unix::run_sdkman(ctx))?
}
SelfUpdate => {
#[cfg(feature = "self-update")]
{
if std::env::var("TOPGRADE_NO_SELF_UPGRADE").is_err() && !ctx.config().no_self_update() {
runner.execute(*self, "Self Update", || self_update::self_update(ctx))?;
}
}
}
Sheldon => runner.execute(*self, "sheldon", || generic::run_sheldon(ctx))?,
Shell => {
#[cfg(unix)]
{
runner.execute(*self, "zr", || zsh::run_zr(ctx))?;
runner.execute(*self, "antibody", || zsh::run_antibody(ctx))?;
runner.execute(*self, "antidote", || zsh::run_antidote(ctx))?;
runner.execute(*self, "antigen", || zsh::run_antigen(ctx))?;
runner.execute(*self, "zgenom", || zsh::run_zgenom(ctx))?;
runner.execute(*self, "zplug", || zsh::run_zplug(ctx))?;
runner.execute(*self, "zinit", || zsh::run_zinit(ctx))?;
runner.execute(*self, "zi", || zsh::run_zi(ctx))?;
runner.execute(*self, "zim", || zsh::run_zim(ctx))?;
runner.execute(*self, "oh-my-zsh", || zsh::run_oh_my_zsh(ctx))?;
runner.execute(*self, "oh-my-bash", || unix::run_oh_my_bash(ctx))?;
runner.execute(*self, "fisher", || unix::run_fisher(ctx))?;
runner.execute(*self, "bash-it", || unix::run_bashit(ctx))?;
runner.execute(*self, "oh-my-fish", || unix::run_oh_my_fish(ctx))?;
runner.execute(*self, "fish-plug", || unix::run_fish_plug(ctx))?;
runner.execute(*self, "fundle", || unix::run_fundle(ctx))?
}
}
Snap =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "snap", || linux::run_snap(ctx))?
}
Sparkle =>
{
#[cfg(target_os = "macos")]
runner.execute(*self, "Sparkle", || macos::run_sparkle(ctx))?
}
Spicetify => runner.execute(*self, "spicetify", || generic::spicetify_upgrade(ctx))?,
Stack => runner.execute(*self, "stack", || generic::run_stack_update(ctx))?,
Stew => runner.execute(*self, "stew", || generic::run_stew(ctx))?,
System => {
#[cfg(target_os = "linux")]
{
// NOTE: Due to breaking `nu` updates, `packer.nu` needs to be updated before `nu` get updated
// by other package managers.
runner.execute(Shell, "packer.nu", || linux::run_packer_nu(ctx))?;
match ctx.distribution() {
Ok(distribution) => {
runner.execute(System, "System update", || distribution.upgrade(ctx))?;
}
Err(e) => {
println!("{}", t!("Error detecting current distribution: {error}", error = e));
}
}
runner.execute(*self, "pihole", || linux::run_pihole_update(ctx))?;
}
#[cfg(windows)]
runner.execute(*self, "Windows update", || windows::windows_update(ctx))?;
#[cfg(target_os = "macos")]
runner.execute(*self, "System update", || macos::upgrade_macos(ctx))?;
#[cfg(target_os = "freebsd")]
runner.execute(*self, "FreeBSD Upgrade", || freebsd::upgrade_freebsd(ctx))?;
#[cfg(target_os = "openbsd")]
runner.execute(*self, "OpenBSD Upgrade", || openbsd::upgrade_openbsd(ctx))?
}
Tldr =>
{
#[cfg(unix)]
runner.execute(*self, "TLDR", || unix::run_tldr(ctx))?
}
Tlmgr => runner.execute(*self, "tlmgr", || generic::run_tlmgr_update(ctx))?,
Tmux =>
{
#[cfg(unix)]
runner.execute(*self, "tmux", || tmux::run_tpm(ctx))?
}
Toolbx =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "toolbx", || toolbx::run_toolbx(ctx))?
}
Uv => runner.execute(*self, "uv", || generic::run_uv(ctx))?,
Vagrant => {
if ctx.config().should_run(Vagrant) {
if let Ok(boxes) = vagrant::collect_boxes(ctx) {
for vagrant_box in boxes {
runner.execute(Vagrant, format!("Vagrant ({})", vagrant_box.smart_name()), || {
vagrant::topgrade_vagrant_box(ctx, &vagrant_box)
})?;
}
}
}
runner.execute(Vagrant, "Vagrant boxes", || vagrant::upgrade_vagrant_boxes(ctx))?;
}
Vcpkg => runner.execute(*self, "vcpkg", || generic::run_vcpkg_update(ctx))?,
Vim => {
runner.execute(*self, "vim", || vim::upgrade_vim(ctx))?;
runner.execute(*self, "Neovim", || vim::upgrade_neovim(ctx))?;
runner.execute(*self, "The Ultimate vimrc", || vim::upgrade_ultimate_vimrc(ctx))?;
runner.execute(*self, "voom", || vim::run_voom(ctx))?
}
VoltaPackages => runner.execute(*self, "volta packages", || node::run_volta_packages_upgrade(ctx))?,
Vscode => runner.execute(*self, "Visual Studio Code extensions", || {
generic::run_vscode_extensions_update(ctx)
})?,
Vscodium => runner.execute(*self, "VSCodium extensions", || {
generic::run_vscodium_extensions_update(ctx)
})?,
Waydroid =>
{
#[cfg(target_os = "linux")]
runner.execute(*self, "Waydroid", || linux::run_waydroid(ctx))?
}
Winget =>
{
#[cfg(windows)]
runner.execute(*self, "Winget", || windows::run_winget(ctx))?
}
Wsl =>
{
#[cfg(windows)]
runner.execute(*self, "WSL", || windows::run_wsl_topgrade(ctx))?
}
WslUpdate =>
{
#[cfg(windows)]
runner.execute(*self, "WSL", || windows::update_wsl(ctx))?
}
Xcodes =>
{
#[cfg(target_os = "macos")]
runner.execute(*self, "Xcodes", || macos::update_xcodes(ctx))?
}
Yadm =>
{
#[cfg(unix)]
runner.execute(*self, "yadm", || unix::run_yadm(ctx))?
}
Yarn => runner.execute(*self, "yarn", || node::run_yarn_upgrade(ctx))?,
Yazi => runner.execute(*self, "Yazi packages", || generic::run_yazi(ctx))?,
Zigup => runner.execute(*self, "zigup", || generic::run_zigup(ctx))?,
Zvm => runner.execute(*self, "ZVM", || generic::run_zvm(ctx))?,
}
Ok(())
}
}
#[allow(clippy::too_many_lines)]
pub(crate) fn default_steps() -> Vec<Step> {
// For now, SelfRenamer and SelfUpdate isn't included as they're ran before the other non-steps (pre-commands, sudo, etc)
use Step::*;
// Could probably have a smaller starting capacity, but this at least ensures only 2 allocations:
// initial and shrink
let mut steps = Vec::with_capacity(Step::COUNT);
#[cfg(windows)]
steps.extend_from_slice(&[Wsl, WslUpdate, Chocolatey, Scoop, Winget]);
#[cfg(target_os = "macos")]
steps.extend_from_slice(&[BrewFormula, BrewCask, Macports, Xcodes, Sparkle, Mas]);
#[cfg(target_os = "dragonfly")]
steps.extend_from_slice(&[Pkg, Audit]);
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
steps.push(Pkg);
#[cfg(not(any(target_os = "dragonfly", target_os = "android")))]
steps.push(System);
#[cfg(windows)]
steps.push(MicrosoftStore);
#[cfg(target_os = "linux")]
steps.extend_from_slice(&[
ConfigUpdate,
AM,
AppMan,
DebGet,
Toolbx,
Snap,
Pacstall,
Pacdef,
Protonup,
Distrobox,
DkpPacman,
Firmware,
Restarts,
Flatpak,
BrewFormula,
Lure,
Waydroid,
AutoCpufreq,
CinnamonSpices,
]);
#[cfg(target_os = "freebsd")]
steps.push(Audit);
#[cfg(unix)]
steps.extend_from_slice(&[
Yadm,
Nix,
Guix,
HomeManager,
Asdf,
Mise,
Pkgin,
BunPackages,
Shell,
Tmux,
Tldr,
Pearl,
#[cfg(not(any(target_os = "macos", target_os = "android")))]
GnomeShellExtensions,
Pyenv,
Sdkman,
Rcm,
Maza,
]);
#[cfg(not(any(
target_os = "freebsd",
target_os = "openbsd",
target_os = "netbsd",
target_os = "dragonfly"
)))]
steps.push(Atom);
// The following update function should be executed on all OSes.
steps.extend_from_slice(&[
Fossil,
Elan,
Rye,
Rustup,
Juliaup,
Dotnet,
Choosenim,
Cargo,
Flutter,
Go,
Emacs,
Opam,
Vcpkg,
Pipx,
Pipxu,
Vscode,
Vscodium,
Conda,
Mamba,
Pixi,
Miktex,
Pip3,
PipReview,
PipReviewLocal,
Pipupgrade,
Ghcup,
Stack,
Tlmgr,
Myrepos,
Chezmoi,
Jetpack,
Vim,
Kakoune,
Helix,
Node,
Yarn,
Pnpm,
VoltaPackages,
Containers,
Deno,
Composer,
Krew,
Helm,
Gem,
RubyGems,
Julia,
Haxelib,
Sheldon,
Stew,
Rtcl,
Bin,
Gcloud,
Micro,
Raco,
Spicetify,
GithubCliExtensions,
Bob,
Certbot,
GitRepos,
ClamAvDb,
PlatformioCore,
Lensfun,
Poetry,
Uv,
Zvm,
Aqua,
Bun,
Zigup,
JetbrainsToolbox,
AndroidStudio,
JetbrainsAqua,
JetbrainsClion,
JetbrainsDatagrip,
JetbrainsDataspell,
// JetBrains dotCover has no CLI
// JetBrains dotMemory has no CLI
// JetBrains dotPeek has no CLI
// JetBrains dotTrace has no CLI
// JetBrains Fleet has a different CLI without a `fleet update` command.
JetbrainsGateway,
JetbrainsGoland,
JetbrainsIdea,
JetbrainsMps,
JetbrainsPhpstorm,
JetbrainsPycharm,
// JetBrains ReSharper has no CLI (it's a VSCode extension)
// JetBrains ReSharper C++ has no CLI (it's a VSCode extension)
JetbrainsRider,
JetbrainsRubymine,
JetbrainsRustrover,
// JetBrains Space Desktop does not have a CLI
JetbrainsWebstorm,
Yazi,
Powershell,
CustomCommands,
Vagrant,
]);
steps.shrink_to_fit();
steps
}

2
src/steps/emacs.rs
View File

@@ -8,9 +8,9 @@ use rust_i18n::t;
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::utils::{require, require_option, PathExt};
use crate::Step;
const EMACS_UPGRADE: &str = include_str!("emacs.el");
#[cfg(windows)]

3
src/steps/generic.rs
View File

@@ -18,6 +18,8 @@ use tracing::{debug, error, warn};
use crate::command::{CommandExt, Utf8Output};
use crate::execution_context::ExecutionContext;
use crate::executor::ExecutorOutput;
use crate::output_changed_message;
use crate::step::Step;
use crate::terminal::{print_separator, shell};
use crate::utils::{
check_is_python_2_or_shim, get_require_sudo_string, require, require_one, require_option, which, PathExt,
@@ -27,7 +29,6 @@ use crate::{
error::{SkipStep, StepFailed, TopgradeError},
terminal::print_warning,
};
use crate::{output_changed_message, Step};
#[cfg(target_os = "linux")]
pub fn is_wsl() -> Result<bool> {

2
src/steps/git.rs
View File

@@ -13,8 +13,8 @@ use tokio::runtime;
use tracing::{debug, error};
use crate::command::CommandExt;
use crate::config::Step;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::steps::emacs::Emacs;
use crate::terminal::print_separator;
use crate::utils::{require, PathExt};

4
src/steps/os/android.rs
View File

@@ -1,10 +1,10 @@
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::utils::require;
use crate::utils::which;
use crate::Step;
use color_eyre::eyre::Result;
use color_eyre::Result;
pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
//let pkg = require("pkg")?;

3
src/steps/os/archlinux.rs
View File

@@ -10,9 +10,10 @@ use walkdir::WalkDir;
use crate::command::CommandExt;
use crate::error::TopgradeError;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::utils::require_option;
use crate::utils::which;
use crate::{config, output_changed_message, Step};
use crate::{config, output_changed_message};
fn get_execution_path() -> OsString {
let mut path = OsString::from("/usr/bin:");

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

@@ -1,8 +1,8 @@
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require_option};
use crate::Step;
use color_eyre::eyre::Result;
use std::process::Command;

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

@@ -1,9 +1,9 @@
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require_option};
use crate::Step;
use color_eyre::eyre::Result;
use color_eyre::Result;
use rust_i18n::t;
use std::process::Command;

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

@@ -9,11 +9,12 @@ use tracing::{debug, warn};
use crate::command::CommandExt;
use crate::error::{SkipStep, TopgradeError};
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::steps::generic::is_wsl;
use crate::steps::os::archlinux;
use crate::terminal::{print_separator, prompt_yesno};
use crate::utils::{get_require_sudo_string, require, require_option, which, PathExt};
use crate::{Step, HOME_DIR};
use crate::HOME_DIR;
static OS_RELEASE_PATH: &str = "/etc/os-release";

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

@@ -1,8 +1,9 @@
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::terminal::{print_separator, prompt_yesno};
use crate::utils::require;
use crate::utils::{get_require_sudo_string, require_option};
use crate::{utils::require, Step};
use color_eyre::eyre::Result;
use rust_i18n::t;
use std::collections::HashSet;

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

@@ -1,5 +1,5 @@
use crate::command::CommandExt;
use crate::{output_changed_message, Step, HOME_DIR};
use crate::{output_changed_message, HOME_DIR};
use color_eyre::eyre::eyre;
use color_eyre::eyre::Context;
use color_eyre::eyre::Result;
@@ -28,6 +28,7 @@ use crate::execution_context::ExecutionContext;
use crate::executor::Executor;
#[cfg(any(target_os = "linux", target_os = "macos"))]
use crate::executor::RunType;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::utils::{get_require_sudo_string, require, require_option, PathExt};

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

@@ -7,10 +7,11 @@ use tracing::debug;
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::powershell;
use crate::step::Step;
use crate::terminal::{print_separator, print_warning};
use crate::utils::{require, which};
use crate::{error::SkipStep, steps::git::RepoStep};
use crate::{powershell, Step};
use rust_i18n::t;
pub fn run_chocolatey(ctx: &ExecutionContext) -> Result<()> {

2
src/steps/powershell.rs
View File

@@ -6,9 +6,9 @@ use rust_i18n::t;
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::terminal::{is_dumb, print_separator};
use crate::utils::{require_option, which};
use crate::Step;
pub struct Powershell {
path: Option<PathBuf>,

3
src/steps/remote/vagrant.rs
View File

@@ -10,8 +10,9 @@ use tracing::{debug, error};
use crate::command::CommandExt;
use crate::execution_context::ExecutionContext;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::{error::SkipStep, utils, Step};
use crate::{error::SkipStep, utils};
#[derive(Debug, Copy, Clone, EnumString)]
#[strum(serialize_all = "lowercase")]

2
src/steps/toolbx.rs
View File

@@ -1,7 +1,7 @@
use color_eyre::eyre::Result;
use crate::command::CommandExt;
use crate::config::Step;
use crate::step::Step;
use crate::terminal::print_separator;
use crate::{execution_context::ExecutionContext, utils::require};
use std::path::Path;