gr-bin 0.1.5

Interact with remote repositories like you interact with git
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
69
70
71
72
73
74
75

use crate::cmd::{
    args::{Cli, Commands, OutputType, PrCommands},
    config::Configuration,
};
use colored::Colorize;
use eyre::{eyre, ContextCompat, Result};
use gr_bin::vcs::common::init_vcs;
use gr_bin::{git::git::LocalRepository, vcs::common::VersionControlSettings};
use tracing::{info, instrument};

#[instrument(skip_all, fields(command = ?args.command))]
pub fn merge(args: Cli, conf: Configuration) -> Result<()> {
    let Cli {
        command,
        branch,
        dir,
        auth,
        output,
        verbose: _,
    } = args;
    if let Commands::Pr(PrCommands::Merge { delete }) = command {
        let repository = LocalRepository::init(dir)?;
        let (hostname, repo, branch) = repository.get_parsed_remote(branch)?;

        // Find settings or use the auth command
        let settings = conf.find_settings(&hostname, &repo);
        let settings = if let Some(auth) = auth {
            VersionControlSettings {
                auth,
                ..settings.unwrap_or_default()
            }
        } else {
            settings.wrap_err(eyre!(
                "Authentication not found for {} in {}.",
                &hostname,
                &repo
            ))?
        };

        // Merge the PR
        let vcs = init_vcs(hostname, repo, settings);
        let pr = vcs.get_pr_by_branch(&branch)?;
        let pr = vcs.merge_pr(pr.id, delete)?;

        pr.print(false, output.into());

        // Checkout to the target branch
        let target_branch = pr.target;
        let message = format!(
            "Checking out to {} and pulling after merge.",
            target_branch.blue()
        );
        match output {
            OutputType::Json => info!("{}", message),
            _ => println!("{}", message),
        };
        repository.checkout_remote_branch(target_branch, output != OutputType::Json)?;

        // Delete local branch if delete was passed
        if delete {
            let source_branch = pr.source;
            repository.delete_branch(source_branch.clone())?;

            let message = format!("Deleted branch {}.", source_branch.blue());
            match output {
                OutputType::Json => info!("{}", message),
                _ => println!("{}", message),
            };
        }

        Ok(())
    } else {
        Err(eyre!("Invalid command!"))
    }
}