use crate::charset::{CharRange, CharSet};
use crate::lint::{DOUBLE_ENCODED, Group, Level};
#[cfg(test)]
use crate::render::Violation;
use crate::render::group::Fold;
use crate::render::line::{Line, Spelled};
use crate::render::name::{Codepoint, codepoint, level_name};
use crate::render::order;
use crate::render::total::{self, Total};
use crate::render::{Change, Explanation, FileStats, InForce, Skipped};
use crate::rules::{LevelChoice, Origin, Rule};
use crate::scan::Unreadable;
use crate::tokens::{Count, Method};
use std::borrow::Cow;
use std::fmt::Write;
const LINE_BYTES: usize = 40;
#[cfg(test)]
pub(super) fn check(
items: &[Violation<'_>],
skipped: &[Skipped<'_>],
) -> String {
check_bounded(order::lines(items).into_iter(), skipped, None)
}
pub(super) fn check_bounded<'a>(
lines: impl Iterator<Item = Line<'a>>,
skipped: &[Skipped<'_>],
max: Option<usize>,
) -> String {
let (total, room) = (lines.size_hint().0, max.unwrap_or(usize::MAX));
let mut out = String::new();
violations(&mut out, lines.take(room), "");
more(&mut out, total.saturating_sub(room));
unread_lines(&mut out, skipped);
out
}
pub(super) fn summary(
groups: &[Fold<'_>],
skipped: &[Skipped<'_>],
max: Option<usize>,
) -> String {
let room = max.unwrap_or(usize::MAX);
let mut out = String::new();
let mut path = Spelled::new(shown);
for group in groups.iter().take(room) {
next_line(&mut out);
violation(&mut out, path.of(group.first.path), group.first);
folded(&mut out, group);
}
more(&mut out, groups.len().saturating_sub(room));
unread_lines(&mut out, skipped);
out
}
fn folded(out: &mut String, group: &Fold<'_>) {
let _infallible = write!(out, " x{}", group.count);
let to = group.first.remedy.and_then(|r| r.to.as_deref());
if let Some(to) = to {
let _infallible = write!(out, " -> {to:?}");
}
}
fn more(out: &mut String, hidden: usize) {
if hidden > 0 {
next_line(out);
let _infallible = write!(out, "... {hidden} more");
}
}
fn violations<'a>(
out: &mut String,
lines: impl IntoIterator<Item = Line<'a>>,
prefix: &str,
) {
let lines = lines.into_iter();
out.reserve(lines.size_hint().0.saturating_mul(LINE_BYTES));
let mut path = Spelled::new(shown);
for item in lines {
next_line(out);
out.push_str(prefix);
violation(out, path.of(item.path), item);
}
}
const LEFT: &str = "left: ";
fn next_line(out: &mut String) {
if !out.is_empty() {
out.push('\n');
}
}
fn violation(out: &mut String, path: &str, item: Line<'_>) {
let hit = item.finding.hit;
let (at, code) = (hit.position, Codepoint(hit.character));
let _infallible = if item.finding.lint == DOUBLE_ENCODED {
let said = hit.character.to_string();
write!(
out,
"{path}:{}:{} {} {said:?} ({code})",
at.line, at.column, DOUBLE_ENCODED.name
)
} else {
let last = verdict(item);
write!(out, "{path}:{}:{} {code} {last}", at.line, at.column)
};
level_note(out, item.finding.level);
}
fn level_note(out: &mut String, level: Level) {
if level == Level::Warn {
let _infallible = write!(out, " ({})", level_name(level));
}
}
fn shown(path: &str) -> Cow<'_, str> {
if path.bytes().all(|b| matches!(b, b' '..=b'~')) {
return Cow::Borrowed(path);
}
let mut out = String::with_capacity(path.len());
for c in path.chars() {
match c {
' '..='~' => out.push(c),
_ => {
let _infallible = write!(out, "<{}>", Codepoint(c));
}
}
}
Cow::Owned(out)
}
fn verdict<'v>(item: Line<'v>) -> &'v str {
if item.finding.lint.group == Group::Pedantic {
item.finding.lint.name
} else {
item.set
}
}
fn unread_lines(out: &mut String, items: &[Skipped<'_>]) {
for item in order::skipped(items) {
next_line(out);
out.push_str(&unread(item));
}
}
fn unread(item: &Skipped<'_>) -> String {
match item.reason {
Unreadable::NotUtf8 { byte, line, column } => format!(
"{}: invalid UTF-8 at {line}:{column} (byte {byte})",
shown(item.path)
),
Unreadable::Binary => format!("{}: skipped, binary", shown(item.path)),
}
}
pub(super) fn fix<'a>(
items: &[Change<'_>],
unmapped: impl IntoIterator<Item = Line<'a>>,
skipped: &[Skipped<'_>],
) -> String {
let mut out = String::new();
let mut path = Spelled::new(shown);
for item in order::changes(items) {
next_line(&mut out);
change(&mut out, path.of(item.path), item);
}
violations(&mut out, unmapped, LEFT);
unread_lines(&mut out, skipped);
out
}
pub(super) fn fix_note(rewrote: usize, left: usize, wrote: bool) -> String {
if rewrote == 0 && left == 0 {
return String::new();
}
let verb = if wrote { "rewrote" } else { "would rewrite" };
if left == 0 {
return format!("{verb} {rewrote}, nothing left");
}
format!(
"{verb} {rewrote}, {left} left (no map entry): \
grant a set in .ctrm or edit by hand"
)
}
fn change(out: &mut String, path: &str, item: &Change<'_>) {
let hit = item.rewrite.hit;
let (at, code) = (hit.position, Codepoint(hit.character));
let to = &item.rewrite.to;
let _infallible =
write!(out, "{path}:{}:{} {code} -> {to:?}", at.line, at.column);
}
pub(super) fn stats(
files: &[FileStats<'_>],
skipped: &[Skipped<'_>],
) -> String {
let mut rows: Vec<String> =
order::stats(files).into_iter().map(row).collect();
let summed = total::of(files).filter(|sum| sum.files > 1);
rows.extend(summed.map(total_row));
let mut out = rows.join("\n");
unread_lines(&mut out, skipped);
out
}
fn row(item: &FileStats<'_>) -> String {
let tokens = counts(item.now, item.after);
let (outside, bytes) = (item.outside, item.bytes);
format!(
"{} outside={outside} bytes={bytes} tokens={tokens}",
shown(item.path)
)
}
fn total_row(sum: Total) -> String {
let tokens = counts(sum.now, sum.after);
let (files, outside, bytes) = (sum.files, sum.outside, sum.bytes);
format!(
"TOTAL files={files} outside={outside} bytes={bytes} tokens={tokens}"
)
}
fn counts(now: Count, after: Count) -> String {
let pair = format!("{}->{}", count(now), count(after));
if now.method == Method::Bpe || after.method == Method::Bpe {
return format!("{pair} (o200k)");
}
pair
}
fn count(value: Count) -> String {
match value.method {
Method::Estimate => format!("~{}", value.tokens),
Method::Bpe => value.tokens.to_string(),
}
}
pub(super) fn explain(item: &Explanation<'_>) -> String {
let mut lines = vec![
format!(
"path {}",
item.path.map_or_else(|| "(whole repo)".into(), shown)
),
format!("set {}", item.set.name),
];
match item.rule {
Some(rule) => lines.extend(rule_lines(rule)),
None => lines.push(String::from("rule none -- no rule grants a set")),
}
lines.extend(in_force(&item.in_force));
lines.join("\n")
}
fn in_force(item: &InForce<'_>) -> Vec<String> {
let named = item.family_origin.map_or_else(|| "default".into(), origin);
let mut lines = vec![format!("effective family {} {named}", item.family)];
if let Some(bare) = &item.level {
let (level, at) = (level_name(bare.value), origin(bare.origin));
lines.push(format!("effective level {level} {at}"));
}
for choice in &item.levels {
let (target, at) = (&choice.value.target, origin(choice.origin));
let level = level_name(choice.value.level);
lines.push(format!("effective level {target}={level} {at}"));
}
lines
}
fn rule_lines(rule: &Rule) -> Vec<String> {
vec![
format!("pattern {}", rule.pattern),
format!("sets {}", words(&rule.sets)),
format!("family {}", rule.family.as_deref().unwrap_or("none")),
format!("levels {}", levels(&rule.levels)),
format!("level {}", rule.default_level.map_or("none", level_name)),
format!("origin {}", origin(&rule.origin)),
]
}
fn levels(items: &[LevelChoice]) -> String {
let parts: Vec<String> = items
.iter()
.map(|item| format!("{}={}", item.target, level_name(item.level)))
.collect();
words(&parts)
}
fn origin(item: &Origin) -> String {
match item {
Origin::File { path, line } => {
format!("{}:{line}", shown(&path.to_string_lossy()))
}
Origin::Argument { index } => format!("argv[{index}]"),
Origin::Builtin { line } => format!("builtin:{line}"),
}
}
pub(super) fn sets(items: &[CharSet]) -> String {
let lines: Vec<String> = items.iter().map(set).collect();
lines.join("\n")
}
fn set(item: &CharSet) -> String {
let ranges: Vec<String> = item.ranges.iter().map(range).collect();
format!("{} {}", item.name, words(&ranges))
}
fn range(item: &CharRange) -> String {
if item.start == item.end {
return codepoint(item.start);
}
format!("{}-{}", codepoint(item.start), codepoint(item.end))
}
fn words(items: &[String]) -> String {
if items.is_empty() {
return String::from("none");
}
items.join(" ")
}
#[cfg(test)]
mod tests {
use super::{check, count, counts, explain, fix, sets, stats};
use crate::charset::{CharRange, CharSet};
use crate::fix::Rewrite;
use crate::lint::{Finding, Group, Level, Lint};
use crate::render::Violation;
use crate::render::{Change, Explanation, FileStats, InForce, Skipped};
use crate::rules::{LevelChoice, Origin, Rule, Sourced};
use crate::scan::{Hit, Position, Unreadable};
use crate::tokens::{Count, Method};
const CHARSET: Lint = Lint {
name: "charset",
group: Group::Charset,
};
fn hit() -> Hit {
let position = Position {
line: 2,
column: 5,
byte: 7,
};
Hit {
position,
character: '\u{2014}',
}
}
fn em_dash() -> Violation<'static> {
let finding = Finding {
hit: hit(),
lint: CHARSET,
level: Level::Deny,
};
Violation {
path: "src/a.rs",
finding,
set: "ascii",
}
}
fn skip(path: &str) -> Skipped<'_> {
Skipped {
path,
reason: Unreadable::Binary,
}
}
fn broken(path: &str, byte: usize) -> Skipped<'_> {
Skipped {
path,
reason: Unreadable::NotUtf8 {
byte,
line: 1,
column: byte.saturating_add(1),
},
}
}
fn estimate(tokens: u64) -> Count {
Count {
tokens,
method: Method::Estimate,
}
}
fn bpe(tokens: u64) -> Count {
Count {
tokens,
method: Method::Bpe,
}
}
fn builtin_rule() -> Rule {
Rule {
pattern: String::from("docs/**"),
sets: vec![String::from("ascii")],
hazards: vec![],
family: None,
levels: vec![],
default_level: None,
origin: Origin::Builtin { line: 3 },
}
}
fn explained() -> String {
explained_with(InForce {
family: "text",
family_origin: None,
level: None,
levels: vec![],
})
}
fn explained_with(in_force: InForce<'_>) -> String {
let set = CharSet {
name: String::from("ascii"),
ranges: vec![],
};
let rule = builtin_rule();
explain(&Explanation {
path: None,
set: &set,
rule: Some(&rule),
in_force,
})
}
#[test]
fn a_violation_is_path_line_column_codepoint_then_set() {
assert_eq!(check(&[em_dash()], &[]), "src/a.rs:2:5 U+2014 ascii");
}
#[test]
fn a_path_never_carries_a_control_or_bidi_character_out() {
let path = "e\u{1b}[2Jx\u{202e}y.md";
let safe = "e<U+001B>[2Jx<U+202E>y.md";
let mut item = em_dash();
item.path = path;
let said = check(&[item], &[skip(path)]);
let want = format!("{safe}:2:5 U+2014 ascii\n{safe}: skipped, binary");
assert_eq!(said, want);
assert_eq!(super::shown("za\u{17c}.md"), "za<U+017C>.md");
}
#[test]
fn a_pedantic_finding_names_its_lint_in_the_last_column() {
let mut item = em_dash();
item.finding.lint = Lint::new("trailing-whitespace", Group::Pedantic);
item.finding.hit.character = ' ';
let expected = "src/a.rs:2:5 U+0020 trailing-whitespace";
assert_eq!(check(&[item], &[]), expected);
}
#[test]
fn a_double_encoded_finding_names_the_character_it_decodes_to() {
let mut item = em_dash();
item.finding.lint = crate::lint::DOUBLE_ENCODED;
let expected = "src/a.rs:2:5 double-encoded \"\u{2014}\" (U+2014)";
assert_eq!(check(&[item.clone()], &[]), expected);
item.finding.hit.character = '\u{80}';
let expected = "src/a.rs:2:5 double-encoded \"\\u{80}\" (U+0080)";
assert_eq!(check(&[item], &[]), expected);
}
#[test]
fn a_warn_finding_names_its_level() {
let mut warn = em_dash();
warn.finding.level = Level::Warn;
let mut forbid = em_dash();
forbid.finding.hit.position.line = 3;
forbid.finding.level = Level::Forbid;
let expected = concat!(
"src/a.rs:2:5 U+2014 ascii (warn)\n",
"src/a.rs:3:5 U+2014 ascii"
);
assert_eq!(check(&[warn, forbid], &[]), expected);
}
#[test]
fn an_empty_report_is_the_empty_string() {
assert_eq!(check(&[], &[]), "");
}
#[test]
fn an_unread_file_is_named_rather_than_dropped() {
let items = [skip("b.bin"), broken("a.txt", 17)];
let expected =
"a.txt: invalid UTF-8 at 1:18 (byte 17)\nb.bin: skipped, binary";
assert_eq!(check(&[], &items), expected);
}
#[test]
fn an_estimate_wears_a_tilde() {
assert_eq!(count(estimate(40)), "~40");
}
#[test]
fn a_real_count_names_its_tokenizer_after_the_pair() {
assert_eq!(counts(bpe(40), bpe(38)), "40->38 (o200k)");
}
#[test]
fn a_stats_row_glues_every_figure_to_its_label() {
let row = FileStats {
path: "a.rs",
outside: 3,
bytes: 120,
now: estimate(40),
after: estimate(38),
};
let mut other = row;
other.path = "b.rs";
let expected = concat!(
"a.rs outside=3 bytes=120 tokens=~40->~38\n",
"b.rs outside=3 bytes=120 tokens=~40->~38\n",
"TOTAL files=2 outside=6 bytes=240 tokens=~80->~76"
);
assert_eq!(stats(&[other, row], &[]), expected);
}
#[test]
fn a_single_file_has_no_total_line() {
let row = FileStats {
path: "a.rs",
outside: 3,
bytes: 120,
now: bpe(40),
after: bpe(38),
};
let expected = "a.rs outside=3 bytes=120 tokens=40->38 (o200k)";
assert_eq!(stats(&[row], &[]), expected);
}
#[test]
fn a_fix_tally_says_what_was_rewritten_and_what_is_left() {
let left = "rewrote 5, 1 left (no map entry): \
grant a set in .ctrm or edit by hand";
assert_eq!(super::fix_note(5, 1, true), left);
assert_eq!(
super::fix_note(2, 0, false),
"would rewrite 2, nothing left"
);
assert_eq!(super::fix_note(0, 0, true), "");
}
#[test]
fn a_rewrite_shows_what_replaces_the_character() {
let rewrite = Rewrite {
hit: hit(),
to: String::from("--"),
};
let change = Change::plain("a.rs", &rewrite);
assert_eq!(fix(&[change], [], &[]), "a.rs:2:5 U+2014 -> \"--\"");
}
#[test]
fn an_unmapped_character_is_a_check_row() {
let rewrite = Rewrite {
hit: hit(),
to: String::from("--"),
};
let change = Change::plain("a.rs", &rewrite);
let said =
fix(&[change], crate::render::order::lines(&[em_dash()]), &[]);
assert_eq!(
said,
"a.rs:2:5 U+2014 -> \"--\"\nleft: src/a.rs:2:5 U+2014 ascii"
);
}
#[test]
fn a_set_prints_its_ranges_as_code_points() {
let range = CharRange {
start: '\u{0}',
end: '\u{7f}',
};
let ascii = CharSet {
name: String::from("ascii"),
ranges: vec![range],
};
assert_eq!(sets(&[ascii]), "ascii U+0000-U+007F");
}
#[test]
fn explain_labels_every_line_rather_than_writing_config_syntax() {
let expected = concat!(
"path (whole repo)\nset ascii\npattern docs/**\nsets ascii\n",
"family none\nlevels none\nlevel none\norigin builtin:3\n",
"effective family text default"
);
assert_eq!(explained(), expected);
}
#[test]
fn explain_names_what_is_in_force_and_where_each_came_from() {
let at = Origin::Argument { index: 5 };
let said = explained_with(InForce {
family: "emoji",
family_origin: Some(&at),
level: Some(Sourced {
value: Level::Allow,
origin: &at,
}),
levels: vec![pedantic_warn(&at)],
});
let tail = concat!(
"origin builtin:3\neffective family emoji argv[5]\neffective ",
"level allow argv[5]\neffective level pedantic=warn argv[5]"
);
assert!(said.ends_with(tail), "{said}");
}
fn pedantic_warn(origin: &Origin) -> Sourced<'_, LevelChoice> {
let value = LevelChoice {
target: String::from("pedantic"),
level: Level::Warn,
};
Sourced { value, origin }
}
}