use std::collections::{HashMap, HashSet};
use std::ops::Range;
use crate::parse::{self, Eol, Member, Scan};
use crate::{Config, Problem, Rule};
#[doc(hidden)]
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Fix {
pub rule: Rule,
pub offset: usize,
pub safe: bool,
pub edits: Vec<(Range<usize>, &'static str)>,
}
impl Fix {
fn mixed(text: &str, offset: usize, scan: &Scan) -> Option<Self> {
let target = scan.target?;
Some(Fix {
rule: Rule::MixedLineEndings,
offset,
safe: true,
edits: scan
.endings
.iter()
.filter_map(|&(at, len)| {
(text[at..at + len] != *target.text()).then_some((at..at + len, target.text()))
})
.collect(),
})
}
}
#[doc(hidden)]
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Fixed {
pub text: String,
pub fixes: Vec<Fix>,
}
#[doc(hidden)]
pub fn try_fix(
text: &str,
config: &Config,
unsafe_fixes: bool,
only: Option<&[usize]>,
) -> Result<Fixed, Option<Vec<Problem>>> {
let (problems, scan) = parse::scan(text, config, unsafe_fixes);
let same = scan.commas.is_empty();
if problems.iter().any(|p| p.rule() == Rule::Syntax) {
return Err(same.then_some(problems));
}
let eol = scan.target.map_or_else(
|| match text.find('\n') {
Some(i) if text[..i].ends_with('\r') => "\r\n",
_ => "\n",
},
Eol::text,
);
let mut groups = Vec::new();
for problem in &problems {
match problem.rule() {
Rule::ByteOrderMark | Rule::MissingFinalNewline => {
let edit = if problem.rule() == Rule::ByteOrderMark {
Edit::delete(problem.offset()..problem.end())
} else {
Edit::newline(text, eol)
};
groups.push(Group::new(
problem.rule(),
problem.offset(),
true,
vec![edit],
));
}
_ => {}
}
}
for &comma in &scan.commas {
groups.push(Group::new(
Rule::Syntax,
comma,
true,
vec![Edit::delete(comma..comma + 1)],
));
}
if unsafe_fixes {
groups.extend(duplicate_groups(text, &problems, &scan));
}
let only = only.map(|only| only.iter().copied().collect::<HashSet<_>>());
if let Some(only) = &only {
groups.retain(|g| only.contains(&g.offset));
}
groups.sort_by_key(|g| (g.start, std::cmp::Reverse(g.end)));
let mut fixes = Vec::new();
let mut edits = Vec::new();
let mut done = 0;
for group in groups {
if group.start < done {
continue;
}
done = group.end.max(done);
fixes.push(Fix {
rule: group.rule,
offset: group.offset,
safe: group.safe,
edits: group
.edits
.iter()
.map(|e| (e.range.clone(), e.insert))
.collect(),
});
edits.extend(group.edits);
}
let mixed = problems
.iter()
.find(|p| p.rule() == Rule::MixedLineEndings)
.map(Problem::offset)
.filter(|at| only.as_ref().is_none_or(|only| only.contains(at)));
let standalone_mixed = mixed.and_then(|offset| Fix::mixed(text, offset, &scan));
let (mut target, mut endings, mut kept) = (scan.target, scan.endings, None);
if mixed.is_some() && fixes.iter().any(|f| f.rule == Rule::DuplicateKey) {
let text = apply(text, std::mem::take(&mut edits));
let (problems, scan) = parse::scan(&text, config, false);
target = scan
.target
.filter(|_| problems.iter().any(|p| p.rule() == Rule::MixedLineEndings));
endings = scan.endings;
kept = Some(text);
}
if let (Some(fix), Some(target)) = (standalone_mixed, target) {
fixes.push(fix);
edits.extend(endings.iter().map(|&(at, len)| Edit {
range: at..at + len,
insert: target.text(),
soft: true,
}));
}
if fixes.is_empty() {
return Err(same.then_some(problems));
}
fixes.sort_by_key(|f| f.offset);
Ok(Fixed {
text: apply(kept.as_deref().unwrap_or(text), edits),
fixes,
})
}
fn apply(text: &str, mut edits: Vec<Edit>) -> String {
edits.sort_by_key(|e| (e.range.start, e.range.end));
let mut reach = 0;
edits.retain(|e| {
let overlaps = e.range.start < reach;
if !overlaps {
reach = reach.max(e.range.end);
}
!(overlaps && e.soft)
});
let mut out = String::with_capacity(text.len());
let mut from = 0;
for edit in edits {
out.push_str(&text[from..edit.range.start]);
out.push_str(edit.insert);
from = edit.range.end;
}
out.push_str(&text[from..]);
out
}
struct Edit {
range: Range<usize>,
insert: &'static str,
soft: bool,
}
impl Edit {
fn delete(range: Range<usize>) -> Self {
Edit {
range,
insert: "",
soft: false,
}
}
fn newline(text: &str, insert: &'static str) -> Self {
let at = if insert == "\n" {
text.trim_end_matches('\r').len()
} else {
text.len()
};
Edit {
range: at..text.len(),
insert,
soft: false,
}
}
}
struct Group {
rule: Rule,
offset: usize,
safe: bool,
start: usize,
end: usize,
edits: Vec<Edit>,
}
impl Group {
fn new(rule: Rule, offset: usize, safe: bool, edits: Vec<Edit>) -> Self {
let start = edits.iter().map(|e| e.range.start).min().unwrap_or(offset);
let end = edits.iter().map(|e| e.range.end).max().unwrap_or(offset);
Group {
rule,
offset,
safe,
start,
end,
edits,
}
}
}
fn duplicate_groups(text: &str, problems: &[Problem], scan: &Scan) -> Vec<Group> {
let mut copies: HashMap<usize, Vec<usize>> = HashMap::new();
let mut hidden = scan.hidden.clone();
hidden.sort_unstable();
for problem in problems {
if let (Rule::DuplicateKey, Some(first)) = (problem.rule(), problem.related())
&& hidden.binary_search(&first.offset).is_err()
{
copies
.entry(first.offset)
.or_default()
.push(problem.offset());
}
}
let members: HashMap<usize, &Member> = scan.members.iter().map(|m| (m.start, m)).collect();
let mut groups = Vec::new();
let suppressed = |span: &Range<usize>| {
let lines = &scan.suppressed;
let i = lines.partition_point(|line| line.end < span.start);
lines.get(i).is_some_and(|line| line.start <= span.end)
};
for (first, later) in copies {
let dropped = std::iter::once(first).chain(later.iter().copied().take(later.len() - 1));
let mut edits = Vec::new();
for start in dropped {
let Some(m) = members.get(&start) else {
continue;
};
let after = text[m.comma + 1..]
.bytes()
.take_while(u8::is_ascii_whitespace)
.count();
edits.push((start, [m.start..m.end, m.comma..m.comma + 1 + after]));
}
if edits.iter().flat_map(|(_, spans)| spans).any(suppressed) {
continue;
}
for (start, [member, comma]) in edits {
let edits = vec![Edit::delete(member), Edit::delete(comma)];
groups.push(Group::new(Rule::DuplicateKey, start, false, edits));
}
}
groups
}