mntn 4.0.3

A Rust-based command-line tool for dotfiles management with profiles.
Documentation 
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

use crate::cli::UseArgs;
use crate::commands::core::{Command, CommandExecutor};
use crate::profiles::{
    ProfileConfig, clear_active_profile, get_active_profile_name, set_active_profile,
};
use color_eyre::Help;
use eyre::eyre;

const COMMON: &str = "common";
const NONE: &str = "none";

struct UseTask {
    profile_name: String,
}

impl UseTask {
    fn new(profile_name: String) -> Self {
        Self { profile_name }
    }

    fn is_clearing_profile(&self) -> bool {
        self.profile_name == COMMON || self.profile_name == NONE
    }
}

impl Command for UseTask {
    fn name(&self) -> &str {
        "Use"
    }

    fn execute(&mut self) -> eyre::Result<()> {
        let config = ProfileConfig::load_or_default();

        if self.is_clearing_profile() {
            clear_active_profile()?;
            println!("Switched to {} (no active profile)", COMMON);
            return Ok(());
        }

        if !config.profile_exists(&self.profile_name) {
            return Err(eyre!("Profile '{}' does not exist", self.profile_name))
                .suggestion(format!(
                    "Create it with: mntn profile create {}",
                    self.profile_name
                ))
                .suggestion("List available profiles with: mntn profile list");
        }

        let current = get_active_profile_name();
        if current.as_deref() == Some(&self.profile_name) {
            println!("Already using profile '{}'", self.profile_name);
            return Ok(());
        }

        set_active_profile(&self.profile_name)?;

        println!("Switched to profile '{}'", self.profile_name);
        println!();
        println!("Run 'mntn restore' to apply this profile's configurations");

        Ok(())
    }
}

pub(crate) fn run(args: UseArgs) -> eyre::Result<()> {
    let mut task = UseTask::new(args.profile);
    CommandExecutor::run(&mut task)
}