ghtool 0.3.0

A command-line tool for interacting with Github API with some specialized features oriented around Checks
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

mod eslint;

use eslint::*;
use eyre::Result;
use futures::{stream::FuturesUnordered, StreamExt};
use tracing::info;

use crate::{
    git::Repository,
    github::{self, get_log_futures, CheckConclusionState, GithubClient},
    repo_config::{LintConfig, RepoConfig},
    term::{green, print_check_run_header},
};

pub async fn lint(
    client: &GithubClient,
    repo: &Repository,
    branch: &str,
    repo_config: &RepoConfig,
    show_files_only: bool,
) -> Result<()> {
    let lint_config = repo_config
        .lint
        .as_ref()
        .ok_or_else(|| eyre::eyre!("No lint config found in .ghtool.toml"))?;

    let pr = client
        .get_pr_for_branch_memoized(&repo.owner, &repo.name, branch)
        .await?;
    let check_runs = client.get_pr_status_checks(&pr.id).await?;
    let (lint_check_runs, any_in_progress) = filter_lint_check_runs(check_runs, lint_config);
    info!(?lint_check_runs, "got lint check runs");

    if lint_check_runs.is_empty() {
        eprintln!(
            "No lint check runs found matching the pattern /{}/",
            lint_config.job_pattern
        );
    } else {
        process_failing_checks(
            client,
            repo,
            lint_check_runs,
            any_in_progress,
            show_files_only,
        )
        .await?;
    }

    Ok(())
}

async fn process_failing_checks(
    client: &GithubClient,
    repo: &Repository,
    lint_check_runs: Vec<github::SimpleCheckRun>,
    any_in_progress: bool,
    show_files_only: bool,
) -> Result<()> {
    let failing_lint_check_runs: Vec<_> = lint_check_runs
        .into_iter()
        .filter(|cr| cr.conclusion == Some(CheckConclusionState::Failure))
        .collect();

    if failing_lint_check_runs.is_empty() {
        if any_in_progress {
            eprintln!("⏳  Some lint checks are in progress");
        } else {
            eprintln!("{}  All lint checks are green", green("✓"));
        }
        return Ok(());
    }

    let mut log_futures: FuturesUnordered<_> =
        get_log_futures(client, repo, &failing_lint_check_runs);

    let mut all_failing_lint_checks = Vec::new();
    while let Some(result) = log_futures.next().await {
        let bytes = result.map_err(|_| eyre::eyre!("Error when getting job logs"))?;
        let log = String::from_utf8_lossy(&bytes);
        let output = EslintLogParser::parse(&log);
        all_failing_lint_checks.push(output);
    }

    if all_failing_lint_checks.iter().all(|s| s.is_empty()) {
        eprintln!("No failing lint checks found in log output");
        return Ok(());
    }

    if show_files_only {
        print_failed_lint_files(&all_failing_lint_checks);
    } else {
        print_failed_lint_issues(&failing_lint_check_runs, &all_failing_lint_checks);
    }

    Ok(())
}

fn print_failed_lint_files(all_failing_lint_checks: &[Vec<EslintPath>]) {
    for failing_lint_check in all_failing_lint_checks {
        for eslint_path in failing_lint_check {
            println!("{}", eslint_path.path);
        }
    }
}

fn print_failed_lint_issues(
    failing_lint_check_runs: &[github::SimpleCheckRun],
    all_failing_lint_checks: &[Vec<EslintPath>],
) {
    for (check_run, failing_lint_check) in
        failing_lint_check_runs.iter().zip(all_failing_lint_checks)
    {
        print_check_run_header(check_run);

        let mut iter = failing_lint_check.iter().peekable();
        while let Some(eslint_path) = iter.next() {
            for issue in &eslint_path.lines {
                println!("{}", issue);
            }

            if iter.peek().is_some() {
                println!();
            }
        }
    }
}

fn filter_lint_check_runs(
    check_runs: Vec<github::SimpleCheckRun>,
    lint_config: &LintConfig,
) -> (Vec<github::SimpleCheckRun>, bool) {
    let mut lint_check_runs = Vec::new();
    let mut any_in_progress = false;

    for cr in check_runs {
        if lint_config.job_pattern.is_match(&cr.name) {
            if cr.conclusion.is_none() {
                any_in_progress = true;
            }
            lint_check_runs.push(cr);
        }
    }

    (lint_check_runs, any_in_progress)
}