use super::Config;
use crate::charset::{CharSet, SetCatalog};
use crate::lint::{
CHAR_LINTS, DOUBLE_ENCODED, Finding, Hazards, LINE_LINTS, Level, Levels,
Lint, OUTSIDE_SET, TEXT_LINTS, Target, char_lints, double_encoded, inside,
line_hits, one_claim, text_hits, unicode_space,
};
use crate::rules::{self, Resolution, Rule};
use crate::scan::{Hit, Unreadable, decode, scan_str};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
pub(crate) enum Looked {
Findings(Vec<Finding>),
Unread(Unreadable),
}
pub(crate) struct Checker {
rules: Vec<Rule>,
catalog: SetCatalog,
hazards: Hazards,
strict: bool,
unions: RefCell<Unions>,
}
type Unions = HashMap<String, HashMap<Vec<String>, Rc<CharSet>>>;
pub(crate) struct Judge<'a> {
set: &'a CharSet,
hazards: &'a Hazards,
exempt: Vec<usize>,
selectors: Vec<usize>,
}
impl<'a> Judge<'a> {
const fn new(set: &'a CharSet, hazards: &'a Hazards) -> Self {
Self {
set,
hazards,
exempt: Vec::new(),
selectors: Vec::new(),
}
}
}
impl Judge<'_> {
fn over(&self, text: &str) -> Self {
Judge {
exempt: self.hazards.exempt(text),
selectors: self.selectors(text),
..*self
}
}
fn passes(&self, character: char, deep: bool) -> bool {
self.set.contains(character)
&& !self.hazard(character)
&& unicode_space(character).is_none()
&& !(deep && char_lints(character).iter().any(Option::is_some))
}
fn hazard(&self, character: char) -> bool {
self.hazards.contains(character)
&& !self.hazards.excuses(&self.set.name, character)
}
fn lints_for(&self, hit: Hit) -> impl Iterator<Item = Lint> {
let excused = self.hazards.excuses(&self.set.name, hit.character);
let hazard =
self.hazards.lint_at(hit, &self.exempt).filter(|_| !excused);
let outside =
(!self.set.contains(hit.character)).then_some(OUTSIDE_SET);
let pedantic = std::iter::once_with(move || char_lints(hit.character));
let chosen = self.selectors.binary_search(&hit.position.byte).is_ok();
let all = [hazard, outside]
.into_iter()
.flatten()
.chain(pedantic.flatten().flatten());
all.take(if chosen { 0 } else { usize::MAX })
}
}
impl Checker {
pub(crate) fn configured(config: &Config) -> Result<Self, String> {
let rules = config.rules()?;
let catalog = config.catalog()?;
Ok(Self {
rules,
hazards: Hazards::builtin().vouched_by(&catalog),
catalog,
strict: config.strict,
unions: RefCell::default(),
})
}
pub(crate) fn listing(config: &Config) -> Result<Self, String> {
let catalog = config.listing()?;
Ok(Self {
catalog,
..Self::configured(config)?
})
}
pub(crate) fn judge<'a>(&'a self, set: &'a CharSet) -> Judge<'a> {
Judge::new(set, &self.hazards)
}
#[cfg(test)]
pub(crate) fn law(&self, shown: &str) -> Result<(CharSet, Levels), String> {
let (set, levels) = self.shared_law(shown)?;
Ok((CharSet::clone(&*set), levels))
}
pub(crate) fn shared_law(
&self,
shown: &str,
) -> Result<(Rc<CharSet>, Levels), String> {
let found = rules::resolve(shown, &self.rules, &rules::matches);
let mut levels = levels_for(&found)?;
grant_hazards(&found, &mut levels)?;
levels.set_strict(self.strict);
Ok((self.granted(&found)?, levels))
}
pub(crate) fn findings(
&self,
shown: &str,
bytes: &[u8],
) -> Result<Option<Vec<Finding>>, String> {
let (set, levels) = self.shared_law(shown)?;
match inspect(bytes, &self.judge(&set), &levels) {
Looked::Findings(found) => Ok(Some(found)),
Looked::Unread(_) => Ok(None),
}
}
pub(crate) fn effective(
&self,
shown: &str,
) -> Result<(CharSet, Option<Rule>), String> {
let found = rules::resolve(shown, &self.rules, &rules::matches);
let set = CharSet::clone(&*self.granted(&found)?);
Ok((set, found.winner.cloned()))
}
pub(crate) fn declared(
&self,
family: &str,
) -> Result<Vec<CharSet>, String> {
self.catalog
.names()
.map(|name| self.catalog.resolve(name, family))
.collect::<Result<Vec<_>, _>>()
.map_err(|bad| bad.to_string())
}
fn granted(&self, found: &Resolution<'_>) -> Result<Rc<CharSet>, String> {
if let Some(set) = self.kept(found) {
return Ok(set);
}
let set = Rc::new(self.union(found)?);
let mut kept = self.unions.borrow_mut();
let by_sets = kept.entry(found.family.clone()).or_default();
by_sets.insert(found.sets.clone(), Rc::clone(&set));
Ok(set)
}
fn kept(&self, found: &Resolution<'_>) -> Option<Rc<CharSet>> {
let kept = self.unions.borrow();
let by_sets = kept.get(found.family.as_str())?;
by_sets.get(found.sets.as_slice()).map(Rc::clone)
}
fn union(&self, found: &Resolution<'_>) -> Result<CharSet, String> {
self.catalog
.resolve_union(&found.sets.join("+"), &found.sets, &found.family)
.map_err(|bad| bad.to_string())
}
}
fn levels_for(found: &Resolution) -> Result<Levels, String> {
let mut levels = Levels::new();
if let Some(level) = found.default_level {
levels.set_charset(level);
}
for choice in &found.levels {
let target = Target::named(&choice.target)
.ok_or_else(|| unknown(&choice.target))?;
levels.set(target, choice.level);
}
Ok(levels)
}
fn unknown(target: &str) -> String {
format!("unknown lint or group: {target}")
}
fn grant_hazards(
found: &Resolution,
levels: &mut Levels,
) -> Result<(), String> {
for class in &found.hazards {
let lint = Lint::grantable(class)
.ok_or_else(|| format!("unknown hazard class: {class}"))?;
levels.grant(lint);
}
Ok(())
}
pub(crate) fn inspect(
bytes: &[u8],
judge: &Judge<'_>,
levels: &Levels,
) -> Looked {
match decode(bytes) {
Err(reason) => Looked::Unread(reason),
Ok(text) => Looked::Findings(judged(text, judge, levels)),
}
}
pub(crate) fn judged(
text: &str,
judge: &Judge<'_>,
levels: &Levels,
) -> Vec<Finding> {
let judge = &judge.over(text);
let deep = asked(&CHAR_LINTS, levels);
let hits = scan_str(text, |c| judge.passes(c, deep));
let mut found = reportable(hits, judge, levels);
found.extend(context_findings(text, levels));
let found = damaged(text, found, levels);
one_claim(found)
}
fn damaged(text: &str, found: Vec<Finding>, levels: &Levels) -> Vec<Finding> {
let runs = double_encoded(text);
if runs.is_empty() {
return found;
}
let mut kept: Vec<Finding> = found
.into_iter()
.filter(|f| !inside(&runs, f.hit.position.byte))
.collect();
kept.extend(
runs.iter()
.map(|run| levels.finding(run.hit(), DOUBLE_ENCODED)),
);
kept
}
fn asked(lints: &[Lint], levels: &Levels) -> bool {
lints.iter().any(|l| levels.level_of(*l) != Level::Allow)
}
fn reportable(
hits: Vec<Hit>,
judge: &Judge<'_>,
levels: &Levels,
) -> Vec<Finding> {
hits.into_iter()
.filter_map(|hit| loudest(hit, judge, levels))
.collect()
}
fn loudest(hit: Hit, judge: &Judge<'_>, levels: &Levels) -> Option<Finding> {
judge
.lints_for(hit)
.map(|lint| levels.finding(hit, lint))
.find(|finding| finding.level != Level::Allow)
}
fn context_findings(text: &str, levels: &Levels) -> Vec<Finding> {
let mut found = Vec::new();
if asked(&LINE_LINTS, levels) {
found.extend(heard(line_hits(text), levels));
}
if asked(&TEXT_LINTS, levels) {
found.extend(heard(text_hits(text), levels));
}
found
}
fn heard(hits: Vec<(Lint, Hit)>, levels: &Levels) -> Vec<Finding> {
hits.into_iter()
.map(|(lint, hit)| levels.finding(hit, lint))
.filter(|finding| finding.level != Level::Allow)
.collect()
}
#[path = "rewrite.rs"]
mod rewrite;
#[cfg(test)]
#[path = "checker_test.rs"]
mod tests;