statue 0.3.1

Easier way to query selectors for static HTML pages.
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

use proc_macro::{token_stream::IntoIter as TokenTreeIter, TokenTree};

use crate::{
    args::{Args, HtmlPath, Opts},
    sel_queries::SelQueryBraceGroupParser,
};

use super::{
    comma_seped_parser::CommaSepedParser, error::args_impl::Error, opts_parser::OptsParser, Parse,
};

impl Parse for Args {
    type Error = Error;
    type OkTy = Self;
    type Wrapper<T, E> = Result<T, E>;

    fn parse(iter: &mut TokenTreeIter) -> Result<Self::OkTy, Self::Error> {
        let Some(html) = iter.next() else {
            return Err(Error::ArgsExpected);
        };
        if !(matches!(html, TokenTree::Ident(html) if html.to_string() == "html")) {
            return Err(Error::HtmlArgExpected);
        };

        let Some(colon) = iter.next() else {
            return Err(Error::ColonExpected);
        };
        if !(matches!(colon, TokenTree::Punct(colon) if colon.to_string() == ":")) {
            return Err(Error::ColonExpected);
        };

        let Some(html_path) = iter.next() else {
            return Err(Error::StrLitHtmlPathExpected);
        };

        let TokenTree::Literal(html_path) = html_path else {
            return Err(Error::StrLitHtmlPathExpected);
        };

        let path = html_path.to_string();
        let html_path = path.strip_prefix("\"").unwrap().strip_suffix("\"").unwrap();

        let Some(comma) = iter.next() else {
        return Err(Error::CommaExpected);
    };

        if !(matches!(comma, TokenTree::Punct(comma) if comma.to_string() == ",")) {
            return Err(Error::CommaExpected);
        };

        let Some(elements_arg_name) = iter.next() else {
        return Err(Error::ElementsArgExpected);
    };

        if !(matches!(elements_arg_name, TokenTree::Ident(selectors_arg_name) if selectors_arg_name.to_string() == "elements"))
        {
            return Err(Error::ElementsArgExpected);
        };

        let Some(colon) = iter.next() else {
        return Err(Error::ColonExpected);
    };

        if !(matches!(colon, TokenTree::Punct(colon) if colon.to_string() == ":")) {
            return Err(Error::ColonExpected);
        };

        let selectors = match SelQueryBraceGroupParser::parse(iter) {
            Ok(selectors) => selectors,
            Err(e) => return Err(e.into()),
        };
        let opts = CommaSepedParser::<OptsParser>::parse(iter)
            .unwrap_or(Ok(Opts::default()))
            // TODO: replace with returning an error variant
            .unwrap();
        Ok(Self {
            path: HtmlPath(html_path.to_owned()),
            sel_queries: selectors,
            opts,
        })
    }
}