lol_html 2.7.0

Streaming HTML rewriter/parser with CSS selector-based API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use super::attribute_matcher::AttributeMatcher;
use super::compiler::{CompiledAttributeExpr, CompiledLocalNameExpr};
use super::SelectorState;
use crate::html::LocalName;
use hashbrown::HashSet;
use std::hash::Hash;
use std::ops::Range;

pub(crate) type AddressRange = Range<usize>;

#[derive(Debug, PartialEq, Eq)]
pub(crate) struct ExecutionBranch<P>
where
    P: Hash + Eq,
{
    pub matched_payload: HashSet<P>,
    pub jumps: Option<AddressRange>,
    pub hereditary_jumps: Option<AddressRange>,
}

/// The result of trying to execute an instruction without having parsed all attributes
pub(crate) enum TryExecResult<'i, P>
where
    P: Hash + Eq,
{
    /// A successful match, contains the branch to move to
    Branch(&'i ExecutionBranch<P>),
    /// A partially successful match, but requires attributes to complete
    AttributesRequired,
    /// A failed match, doesn't require attributes to complete
    Fail,
}

pub(crate) struct Instruction<P>
where
    P: Hash + Eq,
{
    pub associated_branch: ExecutionBranch<P>,
    pub local_name_exprs: Box<[CompiledLocalNameExpr]>,
    pub attribute_exprs: Box<[CompiledAttributeExpr]>,
}

impl<P> Instruction<P>
where
    P: Hash + Eq,
{
    pub fn try_exec_without_attrs<'i>(
        &'i self,
        state: &SelectorState<'_>,
        local_name: &LocalName<'_>,
    ) -> TryExecResult<'i, P> {
        if self.local_name_exprs.iter().all(|e| e(state, local_name)) {
            if self.attribute_exprs.is_empty() {
                TryExecResult::Branch(&self.associated_branch)
            } else {
                TryExecResult::AttributesRequired
            }
        } else {
            TryExecResult::Fail
        }
    }

    pub fn complete_exec_with_attrs<'i>(
        &'i self,
        state: &SelectorState<'_>,
        attr_matcher: &AttributeMatcher<'_>,
    ) -> Option<&'i ExecutionBranch<P>> {
        if self.attribute_exprs.iter().all(|e| e(state, attr_matcher)) {
            Some(&self.associated_branch)
        } else {
            None
        }
    }

    pub fn exec<'i>(
        &'i self,
        state: &SelectorState<'_>,
        local_name: &LocalName<'_>,
        attr_matcher: &AttributeMatcher<'_>,
    ) -> Option<&'i ExecutionBranch<P>> {
        let is_match = self.local_name_exprs.iter().all(|e| e(state, local_name))
            && self.attribute_exprs.iter().all(|e| e(state, attr_matcher));

        if is_match {
            Some(&self.associated_branch)
        } else {
            None
        }
    }
}

pub(crate) struct Program<P>
where
    P: Hash + Eq,
{
    pub instructions: Box<[Instruction<P>]>,
    pub entry_points: AddressRange,
    /// Enables tracking child types for nth-of-type selectors.
    /// This is disabled if no nth-of-type selectors are used in the program.
    pub enable_nth_of_type: bool,
}