gr-bin 0.1.0-rc16

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
76
77
78
79
80
81
82
83

use crate::cmd::{
    args::{Cli, Commands, OutputType, PrCommands, StateFilter, UserFilter},
    config::Configuration,
};
use color_eyre::{
    eyre::{eyre, ContextCompat},
    Result,
};
use gr_bin::{
    formatters::formatter::Formatter,
    vcs::common::{
        init_vcs, PullRequestStateFilter, PullRequestUserFilter, VersionControlSettings,
    },
};
use gr_bin::{
    git::{git::LocalRepository, url::parse_url},
    vcs::common::ListPullRequestFilters,
};
use tracing::instrument;

#[instrument(skip_all, fields(command = ?args.command))]
pub async fn list(args: Cli, conf: Configuration) -> Result<()> {
    let Cli {
        command,
        dir,
        auth,
        output,
        ..
    } = args;
    if let Commands::Pr(PrCommands::List { author, state }) = command {
        let repository = LocalRepository::init(dir)?;
        // Find remote from branch upstream, or fallback to origin or any remote
        let remote_url = repository
            .get_remote_branch(None)
            .map(|(url, _)| url)
            .or_else(|_| repository.get_remote(None))?;
        let (hostname, repo) = parse_url(&remote_url)?;

        // 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
            ))?
        };

        let vcs = init_vcs(hostname, repo, settings);

        let prs = vcs
            .list_prs(ListPullRequestFilters {
                state: match state {
                    Some(StateFilter::Open) | None => PullRequestStateFilter::Open,
                    Some(StateFilter::Closed) => PullRequestStateFilter::Closed,
                    Some(StateFilter::Merged) => PullRequestStateFilter::Merged,
                    Some(StateFilter::Locked) => PullRequestStateFilter::Locked,
                    Some(StateFilter::All) => PullRequestStateFilter::All,
                },
                author: match author {
                    Some(UserFilter::Me) => PullRequestUserFilter::Me,
                    Some(UserFilter::All) | None => PullRequestUserFilter::All,
                },
            })
            .await?;

        for pr in prs {
            match output {
                OutputType::Json => print!("{}", pr.show_json()),
                _ => print!("{}", pr.show_short()),
            }
        }

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