acorn-cli 0.1.31

ACORN command line interface
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 acorn_lib::analyzer::readability::ReadabilityType;
use acorn_lib::analyzer::{summary, Check};
use acorn_lib::schema::ResearchActivity;
use acorn_lib::util::cli::{paths_from_options, CheckCategory, Options};
use acorn_lib::util::{print_values_as_table, Label};
use color_eyre::eyre::{Report, Result};
use dotenvy::dotenv;
use std::path::PathBuf;
use tracing::{debug, error, warn};

const READABILITY_METRIC: &str = "READABILITY_METRIC";

fn count(issues: Vec<Check>) -> usize {
    issues
        .into_iter()
        .filter(|Check { success, .. }| !success)
        .map(|issue| issue.issue_count())
        .sum()
}

#[allow(clippy::too_many_arguments)]
pub fn run(
    path: &Option<PathBuf>,
    branch: &Option<String>,
    commit: &Option<String>,
    ignore: &Option<String>,
    skip: &[CheckCategory],
    disable_website_checks: &bool,
    exit_on_first_error: &bool,
    merge_request: &bool,
    offline: &bool,
    readability_metric: &ReadabilityType,
) -> Result<(), Report> {
    if *offline {
        println!("=> {} ACORN is running in offline mode", Label::fmt_skip("OFFLINE"));
    }
    let options = Options::init()
        .maybe_branch(branch.clone())
        .maybe_commit(commit.clone())
        .maybe_ignore(ignore.clone())
        .exit_on_first_error(*exit_on_first_error)
        .merge_request(*merge_request)
        .build();
    let Options { exit_on_first_error, .. } = options;
    let paths = paths_from_options(path, &Some(options));
    let schema_issues = if skip.contains(&CheckCategory::Schema) {
        warn!("=> {} Schema validation", Label::skip());
        vec![]
    } else {
        let results = ResearchActivity::check(paths.clone(), *offline || *disable_website_checks);
        let issues = count(results.clone());
        if issues > 0 && exit_on_first_error {
            error!("=> {} Found {} schema validation errors", Label::fail(), issues);
            results.iter().for_each(|issue| issue.clone().print());
            std::process::exit(exitcode::DATAERR);
        }
        results
    };
    let prose_issues = if skip.contains(&CheckCategory::Prose) {
        warn!("=> {} Prose analysis", Label::skip());
        vec![]
    } else {
        let results = ResearchActivity::analyze_prose(paths.clone(), *offline);
        let issues = count(results.clone());
        if issues > 0 && exit_on_first_error {
            error!("=> {} Found {} prose issues", Label::fail(), issues);
            results.iter().for_each(|issue| issue.clone().print());
            std::process::exit(exitcode::DATAERR);
        }
        results
    };
    let readability_issues = if skip.contains(&CheckCategory::Readability) {
        warn!("=> {} Readability analysis", Label::skip());
        vec![]
    } else {
        let metric = match dotenv() {
            | Ok(_) => match dotenvy::var(READABILITY_METRIC) {

                | Ok(value) if !value.is_empty() => {
                    debug!(value, "=> {} Readability metric from .env", Label::using());
                    ReadabilityType::from_string(&value)
                }

                | _ => *readability_metric,
            },
            | _ => *readability_metric,

        };
        let results = ResearchActivity::calculate_readability(paths, metric);
        let issues = count(results.clone());
        if issues > 0 && exit_on_first_error {
            error!("=> {} Found {} readability issues", Label::fail(), issues);
            results.iter().for_each(|issue| issue.clone().print());
            std::process::exit(exitcode::DATAERR);
        }
        results
    };
    let conventions_issues = if skip.contains(&CheckCategory::Conventions) {
        warn!("=> {} Conventions verification", Label::skip());
        vec![]
    } else {
        vec![]
    };
    let all_issues = schema_issues
        .clone()
        .into_iter()
        .chain(prose_issues.clone())
        .chain(readability_issues.clone())
        .chain(conventions_issues.clone())
        .inspect(|issue| issue.clone().print())
        .filter(|Check { success, .. }| !success)
        .collect::<Vec<Check>>();
    if count(all_issues.clone()) > 0 {
        let headers = vec!["Issue Type", "Issue Count"];
        let rows = summary(all_issues);
        println!("\n");
        print_values_as_table(&Label::fmt_fail("Issues Overview"), headers, rows);
        std::process::exit(exitcode::DATAERR);
    }
    Ok(())
}