use crate::lint::pedantic::CLAIM_ORDER;
use crate::lint::{Group, Level, Lint};
use crate::scan::Hit;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Finding {
pub hit: Hit,
pub lint: Lint,
pub level: Level,
}
impl Finding {
pub(crate) fn is_failure(&self) -> bool {
self.level.is_failure()
}
}
pub(crate) fn one_claim(mut found: Vec<Finding>) -> Vec<Finding> {
found.sort_by_key(|f| (f.hit.position.byte, claim_rank(f.lint)));
found.dedup_by_key(|f| f.hit.position.byte);
found
}
fn claim_rank(lint: Lint) -> usize {
match lint.group {
Group::Hazard => 0,
Group::Charset => 1,
Group::Pedantic => {
let at = CLAIM_ORDER.iter().position(|l| *l == lint);
at.map_or(usize::MAX, |at| at.saturating_add(2))
}
}
}
pub(crate) fn exit_code(findings: &[Finding]) -> u8 {
u8::from(findings.iter().any(Finding::is_failure))
}
#[cfg(test)]
mod tests {
use super::{Finding, exit_code, one_claim};
use crate::lint::{Group, Level, Lint};
use crate::scan::{Hit, Position};
fn finding(level: Level) -> Finding {
let position = Position {
line: 1,
column: 1,
byte: 0,
};
let hit = Hit {
position,
character: 'x',
};
let lint = crate::lint::OUTSIDE_SET;
Finding { hit, lint, level }
}
#[test]
fn one_claim_keeps_the_strongest_finding_per_byte() {
let on = |name, group| Finding {
lint: Lint::new(name, group),
..finding(Level::Warn)
};
let mixed = on("mixed-script", Group::Pedantic);
let last = on("final-newline", Group::Pedantic);
let trailing = on("trailing-whitespace", Group::Pedantic);
let control = on("control-character", Group::Hazard);
let kept = one_claim(vec![mixed, last.clone()]);
assert_eq!(kept, vec![last.clone()]);
let kept = one_claim(vec![last, trailing.clone()]);
assert_eq!(kept, vec![trailing.clone()]);
assert_eq!(one_claim(vec![trailing, control.clone()]), vec![control]);
}
#[test]
fn a_clean_run_exits_zero() {
assert_eq!(exit_code(&[]), 0);
}
#[test]
fn allowed_and_warned_findings_do_not_fail_the_run() {
let quiet = [finding(Level::Allow), finding(Level::Warn)];
assert_eq!(exit_code(&quiet), 0);
}
#[test]
fn one_denied_finding_fails_the_run() {
let mixed = [finding(Level::Warn), finding(Level::Deny)];
assert_eq!(exit_code(&mixed), 1);
assert_eq!(exit_code(&[finding(Level::Deny)]), 1);
}
#[test]
fn one_forbidden_finding_fails_the_run() {
let mixed = [finding(Level::Allow), finding(Level::Forbid)];
assert_eq!(exit_code(&mixed), 1);
}
#[test]
fn a_finding_fails_exactly_when_its_level_does() {
for level in Level::ALL {
let one = finding(*level);
assert_eq!(one.is_failure(), level.is_failure(), "{level:?}");
}
}
}