Struct scraper::element_ref::ElementRef

pub struct ElementRef<'a> { /* private fields */ }

Wrapper around a reference to an element node.

This wrapper implements the Element trait from the selectors crate, which allows it to be matched against CSS selectors.

Implementations

impl<'a> ElementRef<'a>

pub fn wrap(node: NodeRef<'a, Node>) -> Option<Self>

Wraps a NodeRef only if it references a Node::Element.

pub fn value(&self) -> &'a Element

Returns the Element referenced by self.

Examples found in repository

examples/document.rs (line 26)

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();

    writeln!(stdout, "HTML document:").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());
    }
}

examples/fragment.rs (line 26)

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();

    writeln!(stdout, "HTML fragment:").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());
    }
}

pub fn select<'b>(&self, selector: &'b Selector) -> Select<'a, 'b>

Returns an iterator over descendent elements matching a selector.

pub fn html(&self) -> String

Returns the HTML of this element.

pub fn inner_html(&self) -> String

Returns the inner HTML of this element.

pub fn attr(&self, attr: &str) -> Option<&'a str>

Returns the value of an attribute.

pub fn text(&self) -> Text<'a>

Returns an iterator over descendent text nodes.

pub fn child_elements(&self) -> impl Iterator<Item = ElementRef<'a>>

Iterate over all child nodes which are elements

Example

let fragment = Html::parse_fragment("foo<span>bar</span><a>baz</a>qux");

let children = fragment.root_element().child_elements().map(|element| element.value().name()).collect::<Vec<_>>();
assert_eq!(children, ["span", "a"]);

pub fn descendent_elements(&self) -> impl Iterator<Item = ElementRef<'a>>

Iterate over all descendent nodes which are elements

Example

let fragment = Html::parse_fragment("foo<span><b>bar</b></span><a><i>baz</i></a>qux");

let descendants = fragment.root_element().descendent_elements().map(|element| element.value().name()).collect::<Vec<_>>();
assert_eq!(descendants, ["html", "span", "b", "a", "i"]);

Methods from Deref<Target = NodeRef<'a, Node>>

pub fn id(&self) -> NodeId

Returns the ID of this node.

pub fn tree(&self) -> &'a Tree<T>

Returns the tree owning this node.

pub fn value(&self) -> &'a T

Returns the value of this node.

pub fn parent(&self) -> Option<NodeRef<'a, T>>

Returns the parent of this node.

pub fn prev_sibling(&self) -> Option<NodeRef<'a, T>>

Returns the previous sibling of this node.

pub fn next_sibling(&self) -> Option<NodeRef<'a, T>>

Returns the next sibling of this node.

pub fn first_child(&self) -> Option<NodeRef<'a, T>>

Returns the first child of this node.

pub fn last_child(&self) -> Option<NodeRef<'a, T>>

Returns the last child of this node.

pub fn has_siblings(&self) -> bool

Returns true if this node has siblings.

pub fn has_children(&self) -> bool

Returns true if this node has children.

pub fn ancestors(&self) -> Ancestors<'a, T>

Returns an iterator over ancestors.

pub fn prev_siblings(&self) -> PrevSiblings<'a, T>

Returns an iterator over previous siblings.

pub fn next_siblings(&self) -> NextSiblings<'a, T>

Returns an iterator over next siblings.

pub fn first_children(&self) -> FirstChildren<'a, T>

Returns an iterator over first children.

pub fn last_children(&self) -> LastChildren<'a, T>

Returns an iterator over last children.

pub fn children(&self) -> Children<'a, T>

Returns an iterator over children.

pub fn traverse(&self) -> Traverse<'a, T>

Returns an iterator which traverses the subtree starting at this node.

pub fn descendants(&self) -> Descendants<'a, T>

Returns an iterator over this node and its descendants.

Trait Implementations

impl<'a> Clone for ElementRef<'a>

fn clone(&self) -> ElementRef<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ElementRef<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Deref for ElementRef<'a>

type Target = NodeRef<'a, Node>

The resulting type after dereferencing.

fn deref(&self) -> &NodeRef<'a, Node>

Dereferences the value.

impl<'a> Element for ElementRef<'a>

Note: will never match against non-tree-structure pseudo-classes.

type Impl = Simple

fn opaque(&self) -> OpaqueElement

Converts self into an opaque representation.

fn parent_element(&self) -> Option<Self>

fn parent_node_is_shadow_root(&self) -> bool

Whether the parent node of this element is a shadow root.

fn containing_shadow_host(&self) -> Option<Self>

The host of the containing shadow root, if any.

fn is_pseudo_element(&self) -> bool

Whether we’re matching on a pseudo-element.

fn is_part(&self, _name: &CssLocalName) -> bool

fn is_same_type(&self, other: &Self) -> bool

Whether this element and the other element have the same local name and namespace.

fn imported_part(&self, _: &CssLocalName) -> Option<CssLocalName>

Returns the mapping from the exportparts attribute in the reverse direction, that is, in an outer-tree -> inner-tree direction.

fn prev_sibling_element(&self) -> Option<Self>

Skips non-element nodes

fn next_sibling_element(&self) -> Option<Self>

Skips non-element nodes

fn first_element_child(&self) -> Option<Self>

Skips non-element nodes

fn is_html_element_in_html_document(&self) -> bool

fn has_local_name(&self, name: &CssLocalName) -> bool

fn has_namespace(&self, namespace: &Namespace) -> bool

Empty string for no namespace

fn attr_matches( &self, ns: &NamespaceConstraint<&Namespace>, local_name: &CssLocalName, operation: &AttrSelectorOperation<&CssString> ) -> bool

fn match_non_ts_pseudo_class( &self, _pc: &NonTSPseudoClass, _context: &mut MatchingContext<'_, Self::Impl> ) -> bool

fn match_pseudo_element( &self, _pe: &PseudoElement, _context: &mut MatchingContext<'_, Self::Impl> ) -> bool

fn is_link(&self) -> bool

Whether this element is a link.

fn is_html_slot_element(&self) -> bool

Returns whether the element is an HTML element.

fn has_id(&self, id: &CssLocalName, case_sensitivity: CaseSensitivity) -> bool

fn has_class( &self, name: &CssLocalName, case_sensitivity: CaseSensitivity ) -> bool

fn is_empty(&self) -> bool

Returns whether this element matches :empty.

fn is_root(&self) -> bool

Returns whether this element matches :root, i.e. whether it is the root element of a document.

fn apply_selector_flags(&self, _flags: ElementSelectorFlags)

Sets selector flags on the elemnt itself or the parent, depending on the flags, which indicate what kind of work may need to be performed when DOM state changes.

fn pseudo_element_originating_element(&self) -> Option<Self>

The parent of a given pseudo-element, after matching a pseudo-element selector.

fn has_attr_in_no_namespace( &self, local_name: &<Self::Impl as SelectorImpl>::LocalName ) -> bool

fn assigned_slot(&self) -> Option<Self>

Returns the assigned element this element is assigned to.

fn ignores_nth_child_selectors(&self) -> bool

Returns whether this element should ignore matching nth child selector.

impl<'a> PartialEq for ElementRef<'a>

fn eq(&self, other: &ElementRef<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Selectable<'a> for ElementRef<'a>

type Select<'b> = Select<'a, 'b>

Iterator over element references matching a [CSS selectorSelector

fn select(self, selector: &Selector) -> Self::Select<'_>

Applies the given selector to the collection of elements represented by self

impl<'a> Serialize for ElementRef<'a>

fn serialize<S: Serializer>( &self, serializer: &mut S, traversal_scope: TraversalScope ) -> Result<(), Error>

Take the serializer and call its methods to serialize this type. The type will dictate which methods are called and with what parameters.

impl<'a> Copy for ElementRef<'a>

impl<'a> Eq for ElementRef<'a>

impl<'a> StructuralPartialEq for ElementRef<'a>