fallow-cli 3.23.0

CLI for fallow, codebase intelligence for TypeScript and JavaScript
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
84
85
86
87
88
89
90
91
92
93
94
95

use fallow_types::envelope::TypeAwareMeta;
use fallow_types::semantic::SemanticCompleteness;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HumanStatus {
    Ok,
    Warning,
    Failure,
    Inactive,
}

impl HumanStatus {
    const fn prefix(self) -> &'static str {
        match self {
            Self::Ok => "[OK]",
            Self::Warning => "[W]",
            Self::Failure => "[X]",
            Self::Inactive => "[-]",
        }
    }
}

pub fn line(status: HumanStatus, message: impl std::fmt::Display) -> String {
    format!("{} {message}", status.prefix())
}

pub fn type_aware_meta_status(meta: &TypeAwareMeta) -> HumanStatus {
    // A pass that executed no query cannot be graded a success. `executed` is
    // the field the degraded path sets to mark exactly that, and the counted
    // dimensions below are all zero in that case, which would otherwise read
    // as a clean run.
    if !meta.executed {
        return HumanStatus::Inactive;
    }
    let identity_status = meta.identity.as_ref().map(|identity| identity.completeness);
    if identity_status == Some(SemanticCompleteness::Unavailable)
        || meta
            .queries
            .iter()
            .any(|query| query.status == SemanticCompleteness::Unavailable)
    {
        return HumanStatus::Inactive;
    }
    if identity_status == Some(SemanticCompleteness::Partial)
        || meta
            .queries
            .iter()
            .any(|query| query.status == SemanticCompleteness::Partial)
        || meta.abstained_count > 0
    {
        return HumanStatus::Warning;
    }
    HumanStatus::Ok
}

pub const fn semantic_status(status: SemanticCompleteness) -> HumanStatus {
    match status {
        SemanticCompleteness::Complete => HumanStatus::Ok,
        SemanticCompleteness::Partial => HumanStatus::Warning,
        SemanticCompleteness::Unavailable => HumanStatus::Inactive,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn status_prefixes_are_stable_and_scannable() {
        assert_eq!(line(HumanStatus::Ok, "ready"), "[OK] ready");
        assert_eq!(line(HumanStatus::Warning, "partial"), "[W] partial");
        assert_eq!(line(HumanStatus::Failure, "failed"), "[X] failed");
        assert_eq!(
            line(HumanStatus::Inactive, "unavailable"),
            "[-] unavailable"
        );
    }

    #[test]
    fn a_pass_that_never_executed_is_not_graded_ok() {
        let degraded = TypeAwareMeta {
            executed: false,
            warning_count: 1,
            warnings: vec!["type-aware refinement unavailable".to_owned()],
            ..TypeAwareMeta::default()
        };
        assert_eq!(type_aware_meta_status(&degraded), HumanStatus::Inactive);

        let executed = TypeAwareMeta {
            executed: true,
            ..TypeAwareMeta::default()
        };
        assert_eq!(type_aware_meta_status(&executed), HumanStatus::Ok);
    }
}