ccss 0.1.0

Const CSS parser
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

#![cfg(feature = "alloc")]

use std::borrow::Cow;

use ccss::parse::declaration::DeclarationParseListError;
use util::{error::MaybeError, TestSuite, TestSuites};

pub mod util;

type Expected<S> = MaybeError<util::declaration::Declaration<S>, S>;

const TEST: &str = include_str!("../css-parsing-tests/one_declaration.json");

#[test]
fn test_all() {
    let test_suites =
        serde_json::from_str::<TestSuites<Cow<str>, Expected<Cow<str>>>>(TEST).unwrap();
    for TestSuite { input, expected } in test_suites.0 {
        if input.contains("/*") {
            // TODO: comments are not supported yet
            continue;
        }

        // skip tests that ends with ";"
        if input.contains(";") {
            eprintln!("Tests with semicolon are skipped: {input:?}");
            continue;
        }

        let res = parse_one(&input);

        match expected.result {
            Ok(mut expected) => {
                // trim whitespace tokens
                while expected.value.last().is_some_and(|v| v.is_whitespace()) {
                    _ = expected.value.pop().unwrap();
                }

                {
                    let start_whitespace_count =
                        expected.value.iter().try_fold(0, |count, item| {
                            if item.is_whitespace() {
                                Ok(count + 1)
                            } else {
                                Err(count)
                            }
                        });

                    let start_whitespace_count =
                        start_whitespace_count.unwrap_or_else(std::convert::identity);

                    expected.value.drain(..start_whitespace_count)
                };

                let Ok(Some(d)) = res else {
                    panic!(
                        "expect declaration: {expected:?}\nUnexpected: {res:?}\ninput: {input:?}"
                    )
                };

                assert_eq!(
                    util::declaration::Declaration::from_parsed(d),
                    expected,
                    "\ninput: {input:?}"
                );
            }
            Err(err) => match &*err.reason {
                "empty" => {
                    assert!(
                        matches!(res, Ok(None)),
                        "Expect empty declaration\nUnexpected: {res:?}\ninput: {input:?}"
                    )
                }
                "invalid" => {
                    assert!(
                        res.is_err(),
                        "Expect error declaration\nUnexpected: {res:?}\ninput: {input:?}"
                    )
                }
                reason => {
                    panic!("unknown error reason: {reason}\ninput: {input:?}")
                }
            },
        }
    }
}

type Parsed<'a> = util::declaration::Parsed<'a, 10>;

const fn parse_one(input: &str) -> Result<Option<Parsed>, DeclarationParseListError> {
    let parse_list = Parsed::parse_list_from_str(input);
    let (v, parse_list) = match parse_list.try_into_next() {
        Ok(v) => v,
        Err(err) => return Err(err),
    };

    assert!(matches!(parse_list.try_into_next(), Ok((None, _))));

    Ok(v)
}