use std::collections::HashMap;
use std::ops::Range;
use crate::parse::{self, Eol, Member, Scan};
use crate::{Config, Problem, Rule};
#[doc(hidden)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Fix {
pub rule: Rule,
pub offset: usize,
pub safe: bool,
}
#[doc(hidden)]
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Fixed {
pub text: String,
pub fixes: Vec<Fix>,
}
#[doc(hidden)]
pub fn fix(text: &str, config: &Config, unsafe_fixes: bool) -> Option<Fixed> {
try_fix(text, config, unsafe_fixes).ok()
}
#[doc(hidden)]
pub fn try_fix(
text: &str,
config: &Config,
unsafe_fixes: bool,
) -> Result<Fixed, Option<Vec<Problem>>> {
try_fix_at(text, config, unsafe_fixes, None)
}
#[doc(hidden)]
pub fn try_fix_at(
text: &str,
config: &Config,
unsafe_fixes: bool,
only: Option<&[usize]>,
) -> Result<Fixed, Option<Vec<Problem>>> {
let (problems, scan) = parse::scan(text, config);
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));
}
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);
edits.extend(group.edits);
fixes.push(Fix {
rule: group.rule,
offset: group.offset,
safe: group.safe,
});
}
if let (Some(problem), Some(target)) = (
problems.iter().find(|p| p.rule() == Rule::MixedLineEndings),
scan.target,
) && only.is_none_or(|only| only.contains(&problem.offset()))
{
fixes.push(Fix {
rule: Rule::MixedLineEndings,
offset: problem.offset(),
safe: true,
});
edits.extend(scan.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));
}
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..]);
fixes.sort_by_key(|f| f.offset);
Ok(Fixed { text: out, fixes })
}
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();
for problem in problems {
if let (Rule::DuplicateKey, Some(first)) = (problem.rule(), problem.related()) {
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();
for (first, later) in copies {
let dropped = std::iter::once(first).chain(later.iter().copied().take(later.len() - 1));
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();
let edits = vec![
Edit::delete(m.start..m.end),
Edit::delete(m.comma..m.comma + 1 + after),
];
groups.push(Group::new(Rule::DuplicateKey, start, false, edits));
}
}
groups
}