use super::check::{
Row, Skip, batches, found_code, judged_against, skip, unreadable_code,
};
use super::remedy::Case;
use crate::fix::{self as engine, Map};
use crate::judge::{Checker, Config, File, files, judged};
use crate::lint::{Finding, Level, Lint, OUTSIDE_SET};
use crate::render::{self, Batch, Change, Format, Skipped};
use crate::scan::Unreadable;
use std::path::PathBuf;
pub(super) struct Report {
pub text: String,
pub code: u8,
pub note: String,
}
struct Changed {
path: String,
set: String,
rewrites: Vec<engine::Rewrite>,
verdicts: Vec<Verdict>,
}
impl Changed {
fn new(path: String, set: &str) -> Self {
Self {
path,
set: set.to_owned(),
rewrites: Vec::new(),
verdicts: Vec::new(),
}
}
}
#[derive(Default)]
struct Found {
changed: Vec<Changed>,
skips: Vec<Skip>,
unmapped: Vec<Row>,
pending: Vec<(PathBuf, String)>,
}
pub(super) fn run(
config: &Config,
paths: &[String],
format: Format,
write: bool,
) -> Result<Report, String> {
let pass = Pass::new(config, write)?;
let mut found = Found::default();
for file in files(&config.root, paths)? {
pass.visit(file?, &mut found)?;
}
written(&found.pending)?;
Ok(report_of(&found, format, pass.write))
}
fn written(pending: &[(PathBuf, String)]) -> Result<(), String> {
for (full, text) in pending {
std::fs::write(full, text)
.map_err(|e| format!("{}: {e}", full.display()))?;
}
Ok(())
}
struct Pass {
checker: Checker,
map: Map,
write: bool,
}
impl Pass {
fn new(config: &Config, write: bool) -> Result<Self, String> {
Ok(Self {
checker: Checker::configured(config)?,
map: config.map()?,
write,
})
}
fn visit(&self, file: File, found: &mut Found) -> Result<(), String> {
let File { full, shown, text } = file;
let Some(text) = text_of(text, &shown, found) else {
return Ok(());
};
let (set, levels) = self.checker.shared_law(&shown)?;
let judge = self.checker.judge(&set);
let case = Case::new(&judge, &levels, &text);
let mut changed = Changed::new(shown, &set.name);
let output = self.rewritten(&case, &mut changed, found)?;
if self.write && output != text {
found.pending.push((full, output));
}
found.absorb(changed);
Ok(())
}
fn rewritten(
&self,
case: &Case<'_>,
changed: &mut Changed,
found: &mut Found,
) -> Result<String, String> {
let fixed = self.fixed(case, &changed.path)?;
found.keep(
&changed.path,
&changed.set,
case.left_on_disk(&fixed, self.write),
);
changed.verdicts = verdicts(case, &fixed.report.rewrites);
let engine::Fixed { output, report, .. } = fixed;
changed.rewrites = report.rewrites;
Ok(output)
}
fn fixed(
&self,
case: &Case<'_>,
shown: &str,
) -> Result<engine::Fixed, String> {
let (judge, text) = (case.judge, case.text);
let mut fixed = judge
.fix(text, &self.map, case.levels)
.map_err(|e| format!("{shown}: {e}"))?;
fixed.report.unmapped = Vec::new();
Ok(fixed)
}
}
fn verdicts(case: &Case<'_>, rewrites: &[engine::Rewrite]) -> Vec<Verdict> {
let findings = judged(case.text, case.judge, case.levels);
let at = |byte: usize| {
findings
.binary_search_by_key(&byte, |f| f.hit.position.byte)
.ok()
.and_then(|i| findings.get(i))
.map_or((OUTSIDE_SET, Level::Allow), |f| (f.lint, f.level))
};
rewrites.iter().map(|r| at(r.hit.position.byte)).collect()
}
type Verdict = (Lint, Level);
impl Found {
fn keep(&mut self, path: &str, set: &str, findings: Vec<Finding>) {
if !findings.is_empty() {
let row = Row::new(path.to_owned(), set, findings, Vec::new());
self.unmapped.push(row);
}
}
fn absorb(&mut self, changed: Changed) {
if !changed.rewrites.is_empty() {
self.changed.push(changed);
}
}
}
fn text_of(
text: Result<String, Unreadable>,
shown: &str,
found: &mut Found,
) -> Option<String> {
match text {
Ok(text) => Some(text),
Err(reason) => {
found.skips.push(Skip {
path: shown.to_owned(),
reason,
});
None
}
}
}
fn report_of(found: &Found, format: Format, write: bool) -> Report {
let changes: Vec<Change<'_>> =
found.changed.iter().flat_map(changes).collect();
let skipped: Vec<Skipped<'_>> = found.skips.iter().map(skip).collect();
let kept: Vec<Batch<'_>> =
found.unmapped.iter().flat_map(batches).collect();
let left = kept.iter().map(|batch| batch.findings.len()).sum();
Report {
text: render::fix(format, &changes, &kept, &skipped),
code: code_of(found, write),
note: render::fix_note(format, changes.len(), left, write),
}
}
fn code_of(found: &Found, write: bool) -> u8 {
let drifted = !write && !found.changed.is_empty();
let failed = drifted
|| found_code(&found.unmapped) != 0
|| unreadable_code(&found.skips) != 0;
u8::from(failed)
}
fn changes(file: &Changed) -> impl Iterator<Item = Change<'_>> {
let verdict = |at: usize| file.verdicts.get(at).copied();
file.rewrites.iter().enumerate().map(move |(at, rewrite)| {
let (lint, level) = verdict(at).unwrap_or((OUTSIDE_SET, Level::Allow));
let set = judged_against(lint, &file.set);
let path = &file.path;
Change {
path,
rewrite,
set,
lint,
level,
}
})
}
#[cfg(test)]
#[path = "fix_test.rs"]
mod tests;