updt 0.2.2

Cross-platform update helper for npm, cargo, rustup, fnm, scoop, Homebrew, paru, flatpak, pacman, and pkg.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::env;
use std::io::{self, IsTerminal};
use tokio::fs;

use crate::state::{AppState, SystemProfile};

pub async fn parse_profile(state: &mut AppState) {
    let prefix = env::var("PREFIX").unwrap_or_default();
    state.enable.nvim = true;
    state.is_termux = prefix.contains("com.termux")
        || fs::metadata("/data/data/com.termux/files/usr/bin/pkg")
            .await
            .is_ok();
    state.is_arch_linux = fs::metadata("/etc/arch-release").await.is_ok();
    apply_profile_policy(state, detect_profile(state.is_termux, state.is_arch_linux));
}

struct ProfileRule {
    profile: SystemProfile,
    matches: fn(bool, bool) -> bool,
    apply: fn(&mut AppState),
}

const PROFILE_RULES: &[ProfileRule] = &[
    ProfileRule {
        profile: SystemProfile::Termux,
        matches: is_termux_profile,
        apply: apply_termux_policy,
    },
    ProfileRule {
        profile: SystemProfile::Windows,
        matches: is_windows_profile,
        apply: apply_windows_policy,
    },
    ProfileRule {
        profile: SystemProfile::Macos,
        matches: is_macos_profile,
        apply: apply_macos_policy,
    },
    ProfileRule {
        profile: SystemProfile::Arch,
        matches: is_arch_profile,
        apply: apply_arch_policy,
    },
];

fn detect_profile(is_termux: bool, is_arch_linux: bool) -> SystemProfile {
    PROFILE_RULES
        .iter()
        .find(|rule| (rule.matches)(is_termux, is_arch_linux))
        .map(|rule| rule.profile)
        .unwrap_or_default()
}

fn apply_profile_policy(state: &mut AppState, profile: SystemProfile) {
    state.system_profile = profile;
    if let Some(rule) = PROFILE_RULES.iter().find(|rule| rule.profile == profile) {
        (rule.apply)(state);
    }
}

fn is_termux_profile(is_termux: bool, _is_arch_linux: bool) -> bool {
    is_termux
}

fn is_windows_profile(is_termux: bool, _is_arch_linux: bool) -> bool {
    !is_termux && env::consts::OS == "windows"
}

fn is_macos_profile(is_termux: bool, _is_arch_linux: bool) -> bool {
    !is_termux && env::consts::OS == "macos"
}

fn is_arch_profile(is_termux: bool, is_arch_linux: bool) -> bool {
    !is_termux && is_arch_linux
}

fn apply_termux_policy(state: &mut AppState) {
    state.enable.pkg = true;
    state.enable.npm = true;
    state.enable.cargo = true;
    state.enable.fnm = true;
    state.enable.rustup = false;
}

fn apply_windows_policy(state: &mut AppState) {
    state.enable.npm = true;
    state.enable.cargo = true;
    state.enable.rustup = true;
    state.enable.fnm = true;
    state.enable.scoop = true;
}

fn apply_macos_policy(state: &mut AppState) {
    state.enable.brew = true;
    state.enable.npm = true;
    state.enable.cargo = true;
    state.enable.rustup = true;
    state.enable.fnm = true;
}

fn apply_arch_policy(state: &mut AppState) {
    state.enable.npm = true;
    state.enable.cargo = true;
    state.enable.rustup = true;
    state.enable.fnm = true;
    state.enable.paru = true;
    state.enable.pacman = true;
    state.enable.flatpak = true;
}

pub fn interactive_terminal() -> bool {
    io::stdout().is_terminal() && io::stdin().is_terminal()
}

pub fn desktop_linux_session() -> bool {
    env::consts::OS == "linux"
        && [
            "DISPLAY",
            "WAYLAND_DISPLAY",
            "XDG_CURRENT_DESKTOP",
            "DESKTOP_SESSION",
        ]
        .iter()
        .any(|key| env::var_os(key).is_some_and(|value| !value.is_empty()))
}