loq_core 0.1.0-alpha.4

Core library for loq - enforce file size constraints
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
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Human-readable output formatting.
//!
//! Formats findings and summaries for terminal output.

use crate::report::{Finding, FindingKind, SkipReason, Summary};

/// Formats a finding for display.
#[must_use]
pub fn format_finding(finding: &Finding) -> String {
    match &finding.kind {
        FindingKind::Violation {
            limit,
            actual,
            over_by,
            ..
        } => format_violation(&finding.path, *actual, *limit, *over_by),
        FindingKind::SkipWarning { reason } => format_skip_warning(&finding.path, reason),
    }
}

/// Formats a violation message.
#[must_use]
pub fn format_violation(path: &str, actual: usize, limit: usize, over_by: usize) -> String {
    format!("error[max-lines]: {path}: {actual} lines (limit: {limit}, +{over_by} over)")
}

/// Formats a skip warning message.
#[must_use]
pub fn format_skip_warning(path: &str, reason: &SkipReason) -> String {
    match reason {
        SkipReason::Binary => format!("warning[skip-binary]: {path}: binary file skipped"),
        SkipReason::Unreadable(error) => {
            format!("warning[skip-unreadable]: {path}: unreadable file skipped ({error})")
        }
        SkipReason::Missing => {
            format!("warning[skip-missing]: {path}: missing file skipped")
        }
    }
}

/// Formats the summary line with counts.
#[must_use]
pub fn format_summary(summary: &Summary) -> String {
    let error_label = if summary.errors == 1 {
        "error"
    } else {
        "errors"
    };
    format!(
        "{} files checked, {} skipped, {} passed, {} {} ({}ms)",
        summary.total,
        summary.skipped,
        summary.passed,
        summary.errors,
        error_label,
        summary.duration_ms
    )
}

/// Formats a success message when all checks pass.
#[must_use]
pub fn format_success(summary: &Summary) -> String {
    format!(
        "All checks passed! ({} files in {}ms)",
        summary.total, summary.duration_ms
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::ConfigOrigin;
    use crate::decide::MatchBy;
    use crate::report::Finding;

    #[test]
    fn format_error_line() {
        let finding = Finding {
            path: "src/lib.rs".into(),
            config_source: ConfigOrigin::BuiltIn,
            kind: FindingKind::Violation {
                limit: 10,
                actual: 12,
                over_by: 2,
                matched_by: MatchBy::Default,
            },
        };
        let line = format_finding(&finding);
        assert_eq!(
            line,
            "error[max-lines]: src/lib.rs: 12 lines (limit: 10, +2 over)"
        );
    }

    #[test]
    fn format_skip_binary() {
        let line = format_skip_warning("bin", &SkipReason::Binary);
        assert_eq!(line, "warning[skip-binary]: bin: binary file skipped");
    }

    #[test]
    fn format_skip_unreadable_and_missing() {
        let unreadable = format_skip_warning("bin", &SkipReason::Unreadable("denied".into()));
        assert_eq!(
            unreadable,
            "warning[skip-unreadable]: bin: unreadable file skipped (denied)"
        );
        let missing = format_skip_warning("bin", &SkipReason::Missing);
        assert_eq!(missing, "warning[skip-missing]: bin: missing file skipped");
    }

    #[test]
    fn format_summary_pluralization() {
        let summary = Summary {
            total: 2,
            skipped: 0,
            passed: 0,
            errors: 1,
            duration_ms: 5,
        };
        let line = format_summary(&summary);
        assert!(line.contains("1 error"));
    }

    #[test]
    fn format_summary_plural_errors() {
        let summary = Summary {
            total: 3,
            skipped: 0,
            passed: 1,
            errors: 2,
            duration_ms: 5,
        };
        let line = format_summary(&summary);
        assert!(line.contains("2 errors"));
    }

    #[test]
    fn format_finding_skip_warning() {
        let finding = Finding {
            path: "missing.txt".into(),
            config_source: ConfigOrigin::BuiltIn,
            kind: FindingKind::SkipWarning {
                reason: SkipReason::Missing,
            },
        };
        let line = format_finding(&finding);
        assert_eq!(
            line,
            "warning[skip-missing]: missing.txt: missing file skipped"
        );
    }

    #[test]
    fn format_success_message() {
        let summary = Summary {
            total: 10,
            skipped: 2,
            passed: 8,
            errors: 0,
            duration_ms: 42,
        };
        let line = format_success(&summary);
        assert_eq!(line, "All checks passed! (10 files in 42ms)");
    }
}