htmls 0.1.8

This is a library for parsing HTML and extracting HTML elements or text.
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

use super::{Parser, literal};
use crate::lexer::Token;
use crate::parser::ast::{IndexNode, Node};
use crate::parser::error::ParseError;

/// 解析索引选择
pub fn parse_index(it: &mut Parser, mut node: Node) -> Result<Node, ParseError> {
    if let Some((Token::Colon, _, _)) = &it.current_token {
        node = parse_index_selector(it, node)?;
    }

    Ok(node)
}

/// 解析索引选择器
pub fn parse_index_selector(it: &mut Parser, node: Node) -> Result<Node, ParseError> {
    if !it.check_token(&Token::Colon) {
        let (line, column) = it.get_current_position();
        let current = it.get_current_token_str();
        return Err(ParseError::unexpected_token(":", &current, line, column));
    }

    it.consume_token(&Token::Colon)?;

    it.check_depth()?;

    let index_node = match &it.current_token {
        Some((Token::Colon, _, _)) => {
            it.read_token();
            let end_index = if let Some((Token::Colon, _, _)) = &it.current_token {
                it.read_token();
                None
            } else {
                Some(literal::parse_literal(it)?)
            };

            let step_value = if let Some((Token::Colon, _, _)) = &it.current_token {
                it.read_token();
                Some(literal::parse_literal(it)?)
            } else {
                match literal::parse_literal(it) {
                    Ok(step) => Some(step),
                    Err(_) => None,
                }
            };

            IndexNode::Range(None, end_index, step_value)
        }
        _ => {
            let start_index = literal::parse_literal(it)?;
            match &it.current_token {
                Some((Token::Colon, _, _)) => {
                    it.read_token();
                    let end_index = if let Some((Token::Colon, _, _)) = &it.current_token {
                        it.read_token();
                        None
                    } else {
                        Some(literal::parse_literal(it)?)
                    };

                    let step_value = if let Some((Token::Colon, _, _)) = &it.current_token {
                        it.read_token();
                        Some(literal::parse_literal(it)?)
                    } else {
                        match literal::parse_literal(it) {
                            Ok(step) => Some(step),
                            Err(_) => None,
                        }
                    };

                    IndexNode::Range(Some(start_index), end_index, step_value)
                }
                Some((Token::Comma, _, _)) => {
                    it.read_token();

                    let mut indexs = vec![start_index];

                    while let Some((Token::Comma, _, _)) = &it.current_token {
                        it.read_token();
                        let index = literal::parse_literal(it)?;
                        indexs.push(index);
                    }

                    IndexNode::Multiple(indexs)
                }
                _ => IndexNode::Single(start_index),
            }
        }
    };

    it.decrease_depth();

    Ok(Node::IndexSelection(Box::new(node), Box::new(index_node)))
}