gmux 0.1.5

Manage multiple git repositories with ease.
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

use clap::Parser;
use gmux::{CheckoutManager, DiscoveryManager, GitCaller, Pool, Settings};
use log::{debug, error, info};
use std::io::prelude::*;

mod app;
use app::{Application, ApplicationCommands, GitCommand, PoolCommands};

fn report_error(err: Box<dyn std::error::Error>) {
    debug!("{:#?}", err.source());
    error!("{}", err);
}

fn main() {
    let app = Application::parse();
    let mut settings = Settings::load().map_err(report_error).unwrap();

    pretty_env_logger::init();

    match app.command {
        ApplicationCommands::Pool { pool_command } => match pool_command {
            None => match Pool::from_current(&settings) {
                Ok(pool) => {
                    match std::io::stdout().write_all(format!("{}\n", pool.label).as_bytes()) {
                        Ok(()) => (),
                        Err(err) => report_error(err.into()),
                    }
                }
                Err(err) => report_error(err),
            },
            Some(pool_sub_command) => match pool_sub_command {
                PoolCommands::List => match Pool::list(&settings) {
                    Ok(pools) => match std::io::stdout().write_all(
                        format!(
                            "{}\n",
                            pools
                                .into_iter()
                                .map(|pool| pool.label)
                                .collect::<Vec<String>>()
                                .join("\n")
                        )
                        .as_bytes(),
                    ) {
                        Ok(()) => (),
                        Err(err) => report_error(err.into()),
                    },
                    Err(err) => report_error(err),
                },
                PoolCommands::Show => match Pool::from_current(&settings) {
                    Ok(pool) => {
                        debug!("Showing current pool.");
                        info!("{:?}", &pool)
                    }
                    Err(err) => report_error(err),
                },
                PoolCommands::New { label, root } => match Pool::create(&mut settings, label, root)
                {
                    Ok(pool) => info!("New pool {} created.", pool),
                    Err(err) => report_error(err),
                },
                PoolCommands::Set { label } => {
                    match Pool::set_current(&mut settings, label.clone()) {
                        Ok(_) => info!("Default pool set to {}.", label),
                        Err(err) => report_error(err),
                    }
                }
                PoolCommands::Move { root } => match Pool::from_current(&settings) {
                    Ok(mut pool) => match pool.set_root(&settings, root) {
                        Ok(_) => info!("Moved pool {} to {}.", &pool.label, &pool.root.display()),
                        Err(err) => report_error(err),
                    },
                    Err(err) => report_error(err),
                },
                PoolCommands::Rename { label } => match Pool::from_current(&settings) {
                    Ok(mut pool) => match pool.set_label(&settings, label) {
                        Ok(_) => info!("Renamed current pool to {}.", &pool.label),
                        Err(err) => report_error(err),
                    },
                    Err(err) => report_error(err),
                },
                PoolCommands::Exclude { pattern } => match Pool::from_current(&settings) {
                    Ok(mut pool) => match pool.add_exclude(&settings, pattern.clone()) {
                        Ok(_) => info!("Added exclusion rule {} to {}", pattern, &pool.label),
                        Err(err) => report_error(err),
                    },
                    Err(err) => report_error(err),
                },
                PoolCommands::Checkout => match CheckoutManager::checkout(&mut settings) {
                    Ok(checkout) => info!(
                        "Checked out {} branches and {} repositories.",
                        checkout.branches.len(),
                        checkout.clone.len()
                    ),
                    Err(err) => report_error(err),
                },
                PoolCommands::Discover => match DiscoveryManager::discover_current(&settings) {
                    Ok(pool) => info!("Discovered pool {} files and repositories.", pool),
                    Err(err) => report_error(err),
                },
            },
        },
        ApplicationCommands::Command {
            exclude_filter,
            filter,
            command,
        } => match command {
            GitCommand::Command(args) => match GitCaller::new(&settings) {
                Ok(git) => {
                    git.call(args, filter, exclude_filter).unwrap();
                    ()
                }
                Err(err) => {
                    report_error(err);
                }
            },
        },
    }
}