use crate::dom::DomNode;
use std::collections::HashMap;
use std::rc::Rc;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RegExpMatch {
pub groups: Vec<Option<String>>,
pub named_groups: HashMap<String, String>,
pub index: usize,
}
pub type RegexMatcher = Rc<dyn Fn(&str) -> Option<RegExpMatch>>;
pub type ImportCaptures = HashMap<String, RegExpMatch>;
pub type Predicate = Rc<dyn Fn(&DomNode, &mut ImportCaptures) -> bool>;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SelectorKind {
Element,
Text,
Comment,
}
#[derive(Clone)]
pub struct CompiledSelector {
pub(crate) kind: SelectorKind,
pub(crate) tags: Vec<String>,
predicates: Vec<Predicate>,
}
#[derive(Clone)]
pub enum AttrMatch {
Present,
Equals(String),
Matches(RegexMatcher, Option<String>),
}
#[derive(Clone)]
pub enum StyleMatch {
Equals(String),
Matches(RegexMatcher, Option<String>),
}
impl CompiledSelector {
pub(crate) fn predicate(&self) -> Predicate {
match self.kind {
SelectorKind::Text => Rc::new(|node: &DomNode, _: &mut ImportCaptures| node.is_text()),
SelectorKind::Comment => Rc::new(|node: &DomNode, _: &mut ImportCaptures| {
node.node_type() == crate::dom::DomNodeType::Comment
}),
SelectorKind::Element => combine_predicates(&self.predicates),
}
}
fn refine(&self, additional: Predicate) -> Self {
let mut predicates = self.predicates.clone();
predicates.push(additional);
build_selector(self.tags.clone(), predicates)
}
pub fn class_all(&self, classes: &[&str]) -> Self {
self.refine(build_class_all_predicate(classes))
}
pub fn class_any(&self, classes: &[&str]) -> Self {
self.refine(build_class_any_predicate(classes))
}
pub fn attr(&self, name: &str, value: AttrMatch) -> Self {
self.refine(build_attr_predicate(name, value))
}
pub fn style_any(&self, prop: &str, value: StyleMatch) -> Self {
let prop = prop.to_owned();
self.refine(match value {
StyleMatch::Equals(value) => Rc::new(move |node: &DomNode, _: &mut ImportCaptures| {
node.is_element() && node.style().get_property_value(&prop) == value
}),
StyleMatch::Matches(re, capture) => {
Rc::new(move |node: &DomNode, captures: &mut ImportCaptures| {
if !node.is_element() {
return false;
}
let v = node.style().get_property_value(&prop);
if v.is_empty() {
return false;
}
let Some(m) = re(&v) else {
return false;
};
if let Some(capture) = &capture {
captures.insert(capture.clone(), m);
}
true
})
}
})
}
}
fn combine_predicates(preds: &[Predicate]) -> Predicate {
match preds {
[] => Rc::new(|node: &DomNode, _: &mut ImportCaptures| node.is_element()),
[one] => one.clone(),
_ => {
let preds = preds.to_vec();
Rc::new(move |node: &DomNode, captures: &mut ImportCaptures| {
preds.iter().all(|p| p(node, captures))
})
}
}
}
pub(crate) fn build_selector(tags: Vec<String>, predicates: Vec<Predicate>) -> CompiledSelector {
CompiledSelector {
kind: SelectorKind::Element,
tags,
predicates,
}
}
fn normalize_class_list(classes: &[&str]) -> Vec<String> {
classes
.iter()
.filter(|c| !c.is_empty())
.map(|c| (*c).to_owned())
.collect()
}
pub(crate) fn build_class_all_predicate(classes: &[&str]) -> Predicate {
let ns = normalize_class_list(classes);
if ns.is_empty() {
return Rc::new(|_: &DomNode, _: &mut ImportCaptures| true);
}
Rc::new(move |node: &DomNode, _: &mut ImportCaptures| {
if !node.is_element() {
return false;
}
let cl = node.class_list();
ns.iter().all(|c| cl.contains(c))
})
}
pub(crate) fn build_class_any_predicate(classes: &[&str]) -> Predicate {
let ns = normalize_class_list(classes);
if ns.is_empty() {
return Rc::new(|_: &DomNode, _: &mut ImportCaptures| false);
}
Rc::new(move |node: &DomNode, _: &mut ImportCaptures| {
if !node.is_element() {
return false;
}
let cl = node.class_list();
ns.iter().any(|c| cl.contains(c))
})
}
pub(crate) fn build_attr_predicate(name: &str, value: AttrMatch) -> Predicate {
let name = name.to_owned();
match value {
AttrMatch::Present => Rc::new(move |node: &DomNode, _: &mut ImportCaptures| {
node.is_element() && node.has_attribute(&name)
}),
AttrMatch::Equals(value) => Rc::new(move |node: &DomNode, _: &mut ImportCaptures| {
node.is_element() && node.get_attribute(&name).as_deref() == Some(value.as_str())
}),
AttrMatch::Matches(re, capture) => {
Rc::new(move |node: &DomNode, captures: &mut ImportCaptures| {
if !node.is_element() {
return false;
}
let Some(v) = node.get_attribute(&name) else {
return false;
};
let Some(m) = re(&v) else {
return false;
};
if let Some(capture) = &capture {
captures.insert(capture.clone(), m);
}
true
})
}
}
}
pub fn any() -> CompiledSelector {
build_selector(Vec::new(), Vec::new())
}
pub fn comment() -> CompiledSelector {
CompiledSelector {
kind: SelectorKind::Comment,
tags: Vec::new(),
predicates: Vec::new(),
}
}
pub fn text() -> CompiledSelector {
CompiledSelector {
kind: SelectorKind::Text,
tags: Vec::new(),
predicates: Vec::new(),
}
}
pub fn tag(tags: &[&str]) -> CompiledSelector {
assert!(!tags.is_empty(), "sel.tag() requires at least one tag name");
let mut upper: Vec<String> = Vec::new();
for t in tags {
let t = t.to_uppercase();
if !upper.contains(&t) {
upper.push(t);
}
}
build_selector(upper, Vec::new())
}
pub fn css(source: &str) -> Result<CompiledSelector, crate::LexicalError> {
super::parse_css::parse_selector(source)
}
pub fn is_element_of_tag(node: &DomNode, tag: &str) -> bool {
node.is_element() && node.node_name() == tag.to_uppercase()
}