lazin 1.0.4

Primarily a dotfiles manager
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

use clap::{ArgAction, Parser, Subcommand};
use lazin_error::LazinResult;

use crate::{common, exit_error};

pub(super) mod check;
pub(super) mod init;
pub(super) mod link;
pub(super) mod list_workspaces;
pub(super) mod manage_encryption;
pub(super) mod version;

#[derive(Subcommand)]
enum Commands {
    Init(init::Init),
    Check(check::Check),
    Link(link::Link),
    Workspaces(list_workspaces::Workspaces),
    Encryption(manage_encryption::ManageEncryption),
}

#[derive(Parser)]
#[command(arg_required_else_help = true)]
pub struct Cli {
    #[arg(short = 'v', long = "version", action = ArgAction::SetTrue)]
    version: bool,
    #[command(subcommand)]
    commands: Option<Commands>,
    #[arg(short = 'q', long = "quiet", help = "Suppress all non error output")]
    quiet: bool,
}

impl Cli {
    pub fn main() {
        let cli = Self::parse();

        if cli.version {
            version::version();
            common::exit_success();
        }

        if cli.quiet {
            lazin_logger::quiet(true);
        }

        let result: LazinResult<()> = match cli.commands {
            Some(Commands::Init(cmd)) => cmd.init(),
            Some(Commands::Check(cmd)) => cmd.check(),
            Some(Commands::Link(cmd)) => cmd.link(),
            Some(Commands::Workspaces(cmd)) => cmd.list_workspaces(),
            Some(Commands::Encryption(cmd)) => cmd.manage(),
            None => Ok(()),
        };

        handle_error(result);
    }
}

fn handle_error<T>(result: LazinResult<T>) {
    if let Err(e) = result {
        lazin_logger::error!(e);
        exit_error!()
    }
}