Struct scraper::selector::Selector

source ·

pub struct Selector { /* private fields */ }

Expand description

Wrapper around CSS selectors.

Represents a “selector group”, i.e. a comma-separated list of selectors.

Implementations§

source §

impl Selector

source

pub fn parse(selectors: &str) -> Result<Self, SelectorErrorKind<'_>>

Parses a CSS selector group.

Examples found in repository ?

examples/document.rs (line 15)

fn main() {
    let mut input = String::new();
    let mut stdout = io::stdout();
    let mut stdin = io::stdin();

    write!(stdout, "CSS selector: ").unwrap();
    stdout.flush().unwrap();
    stdin.read_line(&mut input).unwrap();
    let selector = Selector::parse(&input).unwrap();

    write!(stdout, "HTML document:\n").unwrap();
    stdout.flush().unwrap();
    input.clear();
    stdin.read_to_string(&mut input).unwrap();
    let document = Html::parse_document(&input);

    println!("{:#?}", document);

    for node in document.select(&selector) {
        println!("{:?}", node.value());
    }
}

More examples

Hide additional examples

examples/fragment.rs (line 15)

fn main() {
    let mut input = String::new();
    let mut stdout = io::stdout();
    let mut stdin = io::stdin();

    write!(stdout, "CSS selector: ").unwrap();
    stdout.flush().unwrap();
    stdin.read_line(&mut input).unwrap();
    let selector = Selector::parse(&input).unwrap();

    write!(stdout, "HTML fragment:\n").unwrap();
    stdout.flush().unwrap();
    input.clear();
    stdin.read_to_string(&mut input).unwrap();
    let fragment = Html::parse_fragment(&input);

    println!("{:#?}", fragment);

    for node in fragment.select(&selector) {
        println!("{:?}", node.value());
    }
}

src/selector.rs (line 148)

147
148
149

    fn try_from(s: &'i str) -> Result<Self, Self::Error> {
        Selector::parse(s)
    }

source

pub fn matches(&self, element: &ElementRef<'_>) -> bool

Returns true if the element matches this selector.

Examples found in repository ?

src/html/mod.rs (line 132)

    fn next(&mut self) -> Option<ElementRef<'a>> {
        for node in self.inner.by_ref() {
            if let Some(element) = ElementRef::wrap(node) {
                if element.parent().is_some() && self.selector.matches(&element) {
                    return Some(element);
                }
            }
        }
        None
    }
}

impl<'a, 'b> DoubleEndedIterator for Select<'a, 'b> {
    fn next_back(&mut self) -> Option<Self::Item> {
        for node in self.inner.by_ref().rev() {
            if let Some(element) = ElementRef::wrap(node) {
                if element.parent().is_some() && self.selector.matches(&element) {
                    return Some(element);
                }
            }
        }
        None
    }

source

pub fn matches_with_scope(
 &self,
 element: &ElementRef<'_>,
 scope: Option<ElementRef<'_>>
) -> bool

Returns true if the element matches this selector. The optional scope argument is used to specify which element has :scope pseudo-class. When it is None, :scope will match the root element.

Examples found in repository ?

src/selector.rs (line 38)

37
38
39

    pub fn matches(&self, element: &ElementRef) -> bool {
        self.matches_with_scope(element, None)
    }

More examples

Hide additional examples

src/element_ref/mod.rs (line 103)

    fn next(&mut self) -> Option<ElementRef<'a>> {
        for edge in &mut self.inner {
            if let Edge::Open(node) = edge {
                if let Some(element) = ElementRef::wrap(node) {
                    if self.selector.matches_with_scope(&element, Some(self.scope)) {
                        return Some(element);
                    }
                }
            }
        }
        None
    }